| { | |
| "paper_id": "W79-0102", | |
| "header": { | |
| "generated_with": "S2ORC 1.0.0", | |
| "date_generated": "2023-01-19T06:44:15.840625Z" | |
| }, | |
| "title": "", | |
| "authors": [], | |
| "year": "", | |
| "venue": null, | |
| "identifiers": {}, | |
| "abstract": "", | |
| "pdf_parse": { | |
| "paper_id": "W79-0102", | |
| "_pdf_hash": "", | |
| "abstract": [], | |
| "body_text": [ | |
| { | |
| "text": "Fangorn is a system that reads descriptions of texts and generates samples of the texts described. It can be used for checking the empirical adequacy of text descriptions: if the output deviates (in some sense) from the corpus intended to be covered by the description, then the description is empirically inadequate.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "INTRODUCTION AND GENERAL IDEAS", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "Since many texts relate narratives about humans acting in purposeful, although conflicting, ways, Fangorn must contain facilities for describing problem-solving algorithms and it can be used for experiments in that area. However, the emphasis is not on efficiency but on simplicity, and it is strongly oriented towards producing readable texts as output. In these respects it deviates from systems such as TALE-SPIN (Meehan(77)). ", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "INTRODUCTION AND GENERAL IDEAS", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "A major principle behind Fangorn is that a network must be able to reproduce itself, if it is to bear a likeness to natural language. We know that a natural language is thus structured that children, when exposed to it, learn it in an amazingly uniform way. We know too that no simple copying operation is involved The difference between Fangorn and our hypothetical language is that the products of Fangorn are \"programs\" that may be executed without further ado, whereas our hypothetical program produces descriptions of programs that must be translated by very complicated processes before they can be executed. ", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "NODE-NODE., NODE. 2 3 4", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "We have two expansion atoms, EXPAND and GROW. gives it to a boy, then the boy has the toy. After assimilation, the rule reads: if someone has a blue car, and he gives it to John, then John has a blue car.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "EXPANSIONS", | |
| "sec_num": "3.2." | |
| }, | |
| { | |
| "text": "Both varieties, TRANSFORM and MOVE, consist of a structural description part (SD) and a structural change part (SC). A transformation is applicable to any network that its SD matches (actually, we allow two kinds of variables in the SD, the one being the X-variable of transformational grammar).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "TRANSFORMATIONS", | |
| "sec_num": "3.3." | |
| }, | |
| { | |
| "text": "Let a SD match network A, producing isomorphism L. Then A is assimilated into SC using L. And this modified SC is equal to the result of the transformation.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "TRANSFORM", | |
| "sec_num": "3.3.1" | |
| }, | |
| { | |
| "text": "Example: the passive transformation could be formulated: ", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "TRANSFORM", | |
| "sec_num": "3.3.1" | |
| }, | |
| { | |
| "text": "23 Proceedings of NODALIDA 1979", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "TRANSFORM", | |
| "sec_num": "3.3.1" | |
| }, | |
| { | |
| "text": "Proceedings of NODALIDA 1979", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "", | |
| "sec_num": null | |
| } | |
| ], | |
| "back_matter": [], | |
| "bib_entries": { | |
| "BIBREF0": { | |
| "ref_id": "b0", | |
| "title": "TALE-SPIN, an Interactive Program that Writes Stories\" (in: 5th Int", | |
| "authors": [ | |
| { | |
| "first": "", | |
| "middle": [], | |
| "last": "Peter B\u00f8gh Andersen", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": 1973, | |
| "venue": "Handlinger og symboler. Elementer af handlingens syntaks", | |
| "volume": "", | |
| "issue": "", | |
| "pages": "91--98", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "Peter B\u00f8gh Andersen: Handlinger og symboler. Elementer af handlingens syntaks (Akademisk Forlag, 1973) : Sproget p\u00e5 arbejde (GMT, 1977) : \"The syntax of texts and the syntax of actions\" (in: Pragmalinguistics, ed. J.L.Mey, Mouton,1979) \"TALE-SPIN, an Interactive Program that Writes Stories\" (in: 5th Int. Joint Conf. on Art. Int., 1977, p.91 -98)", | |
| "links": null | |
| }, | |
| "BIBREF1": { | |
| "ref_id": "b1", | |
| "title": "The nonlinear nature of plans", | |
| "authors": [], | |
| "year": 1975, | |
| "venue": "4th Int. Joint Conf. on Art. Int", | |
| "volume": "", | |
| "issue": "", | |
| "pages": "206--214", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "\"The nonlinear nature of plans\" (in: 4th Int. Joint Conf. on Art. Int., 1975, p.206 -214)", | |
| "links": null | |
| }, | |
| "BIBREF2": { | |
| "ref_id": "b2", | |
| "title": "Conceptual Graphs for a Database Interface", | |
| "authors": [], | |
| "year": 1976, | |
| "venue": "The structure for plans and behavior", | |
| "volume": "", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "The structure for plans and behavior (Elsevier Computer Science Library, Elsevir, 1977) \"Conceptual Graphs for a Database Interface\" (IBM Journal of Research and Development, July,1976)", | |
| "links": null | |
| } | |
| }, | |
| "ref_entries": { | |
| "FIGREF0": { | |
| "text": "is heavily influenced by SIMULA and to a lesser extent by LISP. It is being programmed in SIMULA, but I comtemplate reprogrammingit in a less expensive language when it is debugged. A Fangorn program is written in F-expressions (akin to LISP S-expressions). They are translated into a connected labelled network with a least upper bound. The network may contain cycles. It consists of NODES linked together with LINKS. Every NODE has certain attributes (variables) and in addition contains a block of actions that are executed when the node is activated. The attributes of a node are called its structure and the actions are called its process. Objects containing a structure an<^ a process are called aggregates. Every node in Fangorn is an aggregate, and every operation Fangorn can perform is a process, that is: it is associated with some node. Every node has at least two attributes: a variable of type text, name> and a pointer variable, sue. LINKS have no name; . Two nodes that are daughters of the same node are said to be sisters with respect to that no d e . Note that a node may have several mothers, and that two nodes may be sisters with respect to one node, but not with respect to another one.", | |
| "num": null, | |
| "uris": null, | |
| "type_str": "figure" | |
| }, | |
| "FIGREF1": { | |
| "text": "Fig.l may be drawn in a slightly simplified way as fig.2 or fig.3:", | |
| "num": null, | |
| "uris": null, | |
| "type_str": "figure" | |
| }, | |
| "FIGREF2": { | |
| "text": "copying the contents of the adult brain into the child's brain or the like). Instead, the child's language is built up, stage by stage, and at each stage it is capable of functioning as a language. A grammar does not only produce sentences: it also reproduces itself at the very same time as it produces sentences. 16 Proceedings of NODALIDA 1979 and largely by means of the very same mechanisms it uses to produce those sentences. For a \"programming\" language, this has the following consequence: the products it produces must be of the same kind as the program itself, and the operations by means of which it creates its output must be sufficient to create an output that is functionally equivalent to itself. Of course, any programming language could be fixed to meet these requirements: if it contained a procedure r u n (file) that would compile and execute the program, written on file, then a program could write another program on file, possibly a copy of itself; rvin (file) would then compile and execute the program written on file.", | |
| "num": null, | |
| "uris": null, | |
| "type_str": "figure" | |
| }, | |
| "FIGREF3": { | |
| "text": "parent would be a very skillful educator of the infant, because the infant is structured as any other object that the parent can create and manipulate -the parent may use the same techniques it would use in any other situation when educating the child. On the other hand, our hypothetical program would be a very poor educator: presumably, the child must be killed (the program must be terminated) and a new version written and compiled (bornI) if changes are to be made. We just dont do such things nowadays I If follows that a Fangorn program may change itself -it can educate itself. And this is obviously a desirable ability: because in many novels the protagonist changes during the narrative: for exampl\u00ab his problem-solving algorithms may change as a result of successes, failures, new insights, or what have you. These are the principial reasons why every bit of a Fangorn program is an energetic aggregate, ready to act when requested. It has certain drawbacks, however. It makes recursive programming exetremely expensive, because every time a \"procedure\" is called, a copy of the whole procedure must be created. Copying the local variables of the procedure does not suffice, since the procedure may change its body during execution. Fangorn is a forest in The Lord of the Rings by Tolkien, and since the program treats its network as a collection of trees, I thought that \"Fangorn\" fitted very well, the novel being one of my favourite books. But there is a little more to it than that: Fangorn is a very peculiar forest, consisting of trees, some of which are alive and move and act, and some of which are asleep and hard to wake. I have always been fascinated by Fangorn, because it contradicts the common idea of the world as consisting of two separate phenomena: things that are dead and passive, and beings that are alive and active. This conception simply does not fit language: a text, for example, is a thing: but it is also a process, influencing the reader in complicated ways, and leading him to conclusions that he may be most unwilling to draw. In many programming languages, the passive-active dichotomy emerges as the rigid data-statement division, which may be a useful distinction in some areas, but is extremely cumbersome when natural language is concerned. I have sometimes wondered whether this stubborn insistence on the passive-active dichotomy might not be due to an underlying powerful ideology that classifies everything as either being passive, subordinate and willing to undergo manipulation, or as being capable of and entitled to doing the manipulation, with nothing in between. But such a division does not accord with the facts, even if it accords with the wishful thinking of the present potentates. However that may be, in Fangorn I have tried to obliterate the distinction as far as possible, insisting that every action is performed by some entity that can itself be acted uponis activated, it executes its process and then activates one of its daughters defined by its structure. Most nodes conform to the following pattern: they have at most 3 possible outcomes, success, failure and dont know, which correspond to its 3 rightmost daughters in that order. For example, the node BELIEVED may have 3 results: true, false or dont kn o w . A person may believe a sentence, he may believe its negation or he may just dont know. If he believes it, the last-but-two sister is activated, if he disbelieves the last-but-one sister is activated, and if he dont know the last sister is activated. Some nodes may have only one outcome, succes. For example, the node SET has 3 daughters; it assigns the daughters of its second daughter to its first daughter, and then activates its third daughter, thereby corresponding to the assignment statement.A node may have operands; they are always the youngest daughters. SET has two operands, its first two daughters.", | |
| "num": null, | |
| "uris": null, | |
| "type_str": "figure" | |
| }, | |
| "FIGREF4": { | |
| "text": "GROW in that it searches a list in order to find matching nodes; but in this case B must be a daughter of a node X on the list, and B must match A and not conversely. If B is found, then A is assimilated into X, and X is inserted as the left", | |
| "num": null, | |
| "uris": null, | |
| "type_str": "figure" | |
| }, | |
| "FIGREF5": { | |
| "text": "Fig.12 (continued)", | |
| "num": null, | |
| "uris": null, | |
| "type_str": "figure" | |
| }, | |
| "FIGREF6": { | |
| "text": "structural description, and SENT^^ is the structural change. If fig.l3 is applied upon fig .14 we get fig .15 5 of an order defines the object to be moved, and its second daughter defines the destination. the SENT-node under GOAL into a sentence. Initially, the pointer C points to GOAL. DOWN moves it down to SENT, and GROW tries to expand the value of C, that is: SENT. If it succeeds the pointer is moved down to its first daughter, else we check whether C is the last sister. If not, then C is moved to the right and the new pointer value is expanded. If C is the last sister, then we check whether C points to GOAL (ISTOPGOAL). If not, C is set to its mother(UP) and we check whether C is now the last sister, If C points to the top goal we have finished, and the sentence is written on a file called OUTDATA. Then the pointer is moved to the ACTOR node (TOP) and the whole actor is written on a file named PAPER. Then the algorithm stops. The boxed portion of fig.18 shows a sentence generated by the program. OUTDATA and PAPER are \"channels\" connecting the FANGORN program to the file system. OUTDATA and PAPER belong to different types of channels: when a network is written on OUTDATA only its leaves (or terminal nodes) are printed, so OUTDATA is oriented towards accepting natural language texts. When a network is written on PAPER it is translated into the input language, so PAPER can be used for storing and retrieving parts of the FANGORN program.", | |
| "num": null, | |
| "uris": null, | |
| "type_str": "figure" | |
| }, | |
| "FIGREF7": { | |
| "text": "is very simple and does not generate stories or coherent texts, but facilities for these tasks are present in the program. In other programs, EPIC will have daughters representing the sequence of actions performed by the ACTORs. CAST may contain more than one actor, acting in a pseudo-parallel way. The algorithm in fig.18 may be replaced by algorithms for building and executing plans; in that case, RSET contains means-end rules, and CONT dominates", | |
| "num": null, | |
| "uris": null, | |
| "type_str": "figure" | |
| } | |
| } | |
| } | |
| } |