Base_JSON/prefixP/json/P90/P90-1035.json

{
    "paper_id": "P90-1035",
    "header": {
        "generated_with": "S2ORC 1.0.0",
        "date_generated": "2023-01-19T09:38:55.734081Z"
    },
    "title": "DETERMINISTIC LEFT TO RIGHT PARSING OF TREE ADJOINING LANGUAGES*",
    "authors": [
        {
            "first": "Yves",
            "middle": [],
            "last": "Schabes",
            "suffix": "",
            "affiliation": {
                "laboratory": "",
                "institution": "University of Pennsylvania Philadelphia",
                "location": {
                    "postCode": "19104-6389",
                    "region": "PA",
                    "country": "USA"
                }
            },
            "email": "schabes@linc.cis.upenn.edu"
        },
        {
            "first": "K",
            "middle": [],
            "last": "Vijay-Shanker",
            "suffix": "",
            "affiliation": {},
            "email": ""
        }
    ],
    "year": "",
    "venue": null,
    "identifiers": {},
    "abstract": "We define a set of deterministic bottom-up left to right parsers which analyze a subset of Tree Adjoining Languages. The LR parsing strategy for Context Free Grammars is extended to Tree Adjoining Grammars (TAGs). We use a machine, called Bottom-up Embedtied Push Down Automaton (BEPDA), that recognizes in a bottom-up fashion the set of Tree Adjoining Languages (and exactly this se0. Each parser consists of a finite state control that drives the moves of a Bottom-up Embedded Pushdown Automaton. The parsers handle deterministically some context-sensitive Tree Adjoining Languages. In this paper, we informally describe the BEPDA then given a parsing table, we explain the LR parsing algorithm. We then show how to construct an LR(0) parsing table (no lookahead). An example of a context-sensitive language recognized deterministically is given. Then, we explain informally the construction of SLR(1) parsing tables for BEPDA. We conclude with a discussion of our parsing method and current work.",
    "pdf_parse": {
        "paper_id": "P90-1035",
        "_pdf_hash": "",
        "abstract": [
            {
                "text": "We define a set of deterministic bottom-up left to right parsers which analyze a subset of Tree Adjoining Languages. The LR parsing strategy for Context Free Grammars is extended to Tree Adjoining Grammars (TAGs). We use a machine, called Bottom-up Embedtied Push Down Automaton (BEPDA), that recognizes in a bottom-up fashion the set of Tree Adjoining Languages (and exactly this se0. Each parser consists of a finite state control that drives the moves of a Bottom-up Embedded Pushdown Automaton. The parsers handle deterministically some context-sensitive Tree Adjoining Languages. In this paper, we informally describe the BEPDA then given a parsing table, we explain the LR parsing algorithm. We then show how to construct an LR(0) parsing table (no lookahead). An example of a context-sensitive language recognized deterministically is given. Then, we explain informally the construction of SLR(1) parsing tables for BEPDA. We conclude with a discussion of our parsing method and current work.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Abstract",
                "sec_num": null
            }
        ],
        "body_text": [
            {
                "text": "LR(k) parsers for Context Free Grammars (Knuth, 1965) consist of a finite state control (constructed given a CFG) that drives deterministically with k lookahead symbols a push down stack, while scanning the input from left to right. It has been shown that they recognize exactly the set of languages recognized by deterministic push down automata. LR(k) parsers for CFGs have been proven useful for compilers as well as recently for natural language processing. For natural language processing, although LR(k) parsers are not powerful enough, conflicts between multiple choices are solved by pseudoparallelism (Lang, 1974 , Tomita, 1987 . This gives rise to a class of powerful yet efficient parsers for natural languages. It is in this context that we study deterministic (LR(k)-style) parsing of TAGs.",
                "cite_spans": [
                    {
                        "start": 40,
                        "end": 53,
                        "text": "(Knuth, 1965)",
                        "ref_id": "BIBREF11"
                    },
                    {
                        "start": 610,
                        "end": 621,
                        "text": "(Lang, 1974",
                        "ref_id": "BIBREF0"
                    },
                    {
                        "start": 622,
                        "end": 636,
                        "text": ", Tomita, 1987",
                        "ref_id": "BIBREF4"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "The set of Tree Adjoining Languages is a strict superset of the set of Context Free Languages (CFLs). For example, the cross serial dependency constmction in Dutch can be generated by a TAG. 1 Waiters (1970) , R~v6sz (1971) , Turnbull and Lee (1979) investigated deterministic parsing of the class of context-sensitive languages. However they used Turing machines which recognize languages much more powerful than Tree Adjoining Languages. So far no deterministic bottom-up parser has been proposed for any member of the class of the so-called \"mildly context sensitive\" formalisms (Joshi, 1985) in which Tree Adjoining Grammars fall. 2 Since the set of Tree Adjoining Languages (TALs) is a strict superset of the set of Context Free Languages, in order to define LR-type parsers for TAGs, we need to use a more powerful configuration then a finite state automaton driving a push down stack. We investigate the design of deterministic left to right bottom up parsers for TAGs in which a finite state control drives the moves of a Bottom-up Embedded Push Down Stack. The class of corresponding non-deterministic automata recognizes exactly the set of TALs.",
                "cite_spans": [
                    {
                        "start": 193,
                        "end": 207,
                        "text": "Waiters (1970)",
                        "ref_id": "BIBREF8"
                    },
                    {
                        "start": 210,
                        "end": 223,
                        "text": "R~v6sz (1971)",
                        "ref_id": null
                    },
                    {
                        "start": 226,
                        "end": 249,
                        "text": "Turnbull and Lee (1979)",
                        "ref_id": "BIBREF6"
                    },
                    {
                        "start": 582,
                        "end": 595,
                        "text": "(Joshi, 1985)",
                        "ref_id": "BIBREF9"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "We focus our attention on showing how a bottomup embedded pushdown automaton is deterministically driven given a parsing table. To illustrate the building of a parsing table, we consider the simplest case, i.e. building of LR(0) items and the corresponding LR(0) 1The parsers that we develop in this paper can parse these constructions deterministically (see Figure 5 ).",
                "cite_spans": [
                    {
                        "start": 257,
                        "end": 262,
                        "text": "LR(0)",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 359,
                        "end": 367,
                        "text": "Figure 5",
                        "ref_id": "FIGREF7"
                    }
                ],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "2Tree Adjoining Grammars, Modified Head Grammars, Linear Indexed Grammars and Categorial Grammars (all of which generate the same subclass of context-sensitive languages) fall in the class of the so-called \"mildly context sensitive\" formalisms. The Embedded Push Down Automaton recognizes exactly this set of languages (Vijay-Shanker 1987) . parsing table for a given TAG. An example for a TAG generating a context-sensitive language is given in Figure 5 . Finally, we consider the construction of SLR(1) parsing tables.",
                "cite_spans": [
                    {
                        "start": 319,
                        "end": 339,
                        "text": "(Vijay-Shanker 1987)",
                        "ref_id": "BIBREF7"
                    },
                    {
                        "start": 446,
                        "end": 454,
                        "text": "Figure 5",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "We assume that the reader is familiar with TAGs. We refer the reader to Joshi (1987) for an introduction to TAGs. We will assume that the trees can be combined by adjunction only.",
                "cite_spans": [
                    {
                        "start": 72,
                        "end": 84,
                        "text": "Joshi (1987)",
                        "ref_id": "BIBREF10"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Introduction",
                "sec_num": "1"
            },
            {
                "text": "Before we discuss the Bottom-up Embedded Pushdown Automaton (BEPDA) which we use in our parser, we will introduce the Embedded Pushdown Automaton (EPDA). An EPDA is similar to a pushdown automaton (PDA) except that the storage of an EPDA is a sequence of pushdown stores. A move of an EPDA (see Figure 1 ) allows for the introduction of bounded pushdowns above and below the current top pushdown. Informally, this move can be thought of as corresponding to the adjoining operation move in TAGs with the pushdowns introduced above and below the current pushdown reflecting the tree structure to the left and right of the foot node of an auxiliary being adjoined. The spine (path from root to foot node) is left on the previous stack.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 295,
                        "end": 303,
                        "text": "Figure 1",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Automata Models of Tags",
                "sec_num": "2"
            },
            {
                "text": "The generalization of a PDA to an EPDA whose storage is a sequence of pushdowns captures the generalization of the nature of the derived trees of a CFG to the nature of derived trees of a TAG. From Thatcher (1971) , we can observe that the path set of a CFG (i.e. the set of all paths from root to leaves in trees derived by a CFG) is a regular set. On the other hand, the path set of a TAG is a CFL. This follows from the nature of the adjoining operation of TAGs, which suggests stacking along the path from root to a leaf. For example, as we traverse down a path in a tree 3' (in Figure 1) , if adjunction, say by/~, occurs then the spine of/~ has to be traversed before we can resume the path in 7. For any TAG G, an EPDA can be designed such that its moves correspond to a top-down parse of a string generated by G (EPDA characterizes exactly the set of Tree Adjoining Languages, Vijay-Shanker, 1987 ). If we wish to design a bottom-up parser, say by adopting a shift reduce parsing strategy, we have to consider the nature of a reduce move of such a parser (i.e. using EPDA storage). This reduce move, for example applied after completely considering an auxiliary tree, must be allowed to 'remove' some bounded pushdowns above and below some (not necessarily bounded) pushdown. Thus (see Figure 2 ), the reduce move is like the dual of the wrapping move performed by an EPDA.",
                "cite_spans": [
                    {
                        "start": 198,
                        "end": 213,
                        "text": "Thatcher (1971)",
                        "ref_id": "BIBREF3"
                    },
                    {
                        "start": 885,
                        "end": 904,
                        "text": "Vijay-Shanker, 1987",
                        "ref_id": "BIBREF7"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 583,
                        "end": 592,
                        "text": "Figure 1)",
                        "ref_id": null
                    },
                    {
                        "start": 1294,
                        "end": 1302,
                        "text": "Figure 2",
                        "ref_id": "FIGREF1"
                    }
                ],
                "eq_spans": [],
                "section": "Automata Models of Tags",
                "sec_num": "2"
            },
            {
                "text": "Therefore, we introduce Bottom-up Embedded Pushdown Automaton (BEPDA), whose moves are dual of an EPDA. The two moves of a BEPDA are the unwrap move depicted in Figure 2 -which is an inverse of the wrap move of an EPDA -and the introduction of new pnshdowns on top of the previous pushdown (push move). In an EPDA, when the top pnshdown is emptied, the next pushdown automatically becomes the new top pushdown. The inverse of this step is to allow for the introduction of new pushdowns above the previous top pushdown. These are the two moves allowed in a BEPDA, the various steps in our parsers are sequences of one or more such moves.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 161,
                        "end": 169,
                        "text": "Figure 2",
                        "ref_id": "FIGREF1"
                    }
                ],
                "eq_spans": [],
                "section": "Automata Models of Tags",
                "sec_num": "2"
            },
            {
                "text": "Due to space constraints, we do not show the equivalence between BEPDA and EPDA apart from noting that the moves of the two machines are dual of each other.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Automata Models of Tags",
                "sec_num": "2"
            },
            {
                "text": "An LR parser consists of an input, an output, a sequence of stacks, a driver program, and a parsing table that has three parts (ACTION, GOTOright and GOTO.foot). The parsing program is the same for all LR parsers, only the parsing tables change from one grammar to another. The parsing program reads characters from the input one character at a time. The program uses the sequence of stacks to store states.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "LR Parsing Algorithm",
                "sec_num": "4"
            },
            {
                "text": "The parsing \u2022 Resume Right of 6 at address dot (rs6@dot)), where 6 is an elementary tree and dot is the address of a node in 6;",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "LR Parsing Algorithm",
                "sec_num": "4"
            },
            {
                "text": "\u2022 Reduce Root of the auxiliary tree/5 in which the last adjunction on the spine was performed at address star (rd/3@star);",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "LR Parsing Algorithm",
                "sec_num": "4"
            },
            {
                "text": "\u2022 Accept (acc);",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "LR Parsing Algorithm",
                "sec_num": "4"
            },
            {
                "text": "\u2022 Error, no action applies, the parsers rejects the input string (errors are associated with empty table entries). The function GOTOright and GOTOfoo, take a state i and an auxiliary tree # and produce a state j.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "LR Parsing Algorithm",
                "sec_num": "4"
            },
            {
                "text": "An example of a parsing table for a grammar generating L = {anbnecndnln > 0} is given in Figure 5 .",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 89,
                        "end": 97,
                        "text": "Figure 5",
                        "ref_id": "FIGREF7"
                    }
                ],
                "eq_spans": [],
                "section": "LR Parsing Algorithm",
                "sec_num": "4"
            },
            {
                "text": "We denote an instantaneous description of the BEPDA by a pair whose first component is the sequence of pushdowns and whose second component is the unexpanded input:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "LR Parsing Algorithm",
                "sec_num": "4"
            },
            {
                "text": "(lltm'' \"till\" \"-Ilsl\" \"sw, a~a~+l...",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "LR Parsing Algorithm",
                "sec_num": "4"
            },
            {
                "text": "In the above sequence of pushdowns, the stacks are Suppose the parser reaches the configuration:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "a,$)",
                "sec_num": null
            },
            {
                "text": "(lit,,,\" \"till\" \"IIi~\"\"\" ill, arar+l.., an$)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "a,$)",
                "sec_num": null
            },
            {
                "text": "The next move of the parser is determined by reading at, the current input token and the state i on top of the sequence of stacks, and then consulting the parsing table  entry for ACTION address dot (rs6@doO. The parser is coming to the right and below of the node at address dot in 6, say ri, on which an auxiliary tree has been adjoined. The information identifying the auxiliary tree is in the sequence of stacks and must be recovered. There are two eases: Case 1:71 does not subsume a foot node. Let k be the number of terminal symbols subsumed by r/. Before applying this move, the current configuration looks like:",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 155,
                        "end": 186,
                        "text": "parsing table  entry for ACTION",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "a,$)",
                "sec_num": null
            },
            {
                "text": "(ll\"\" Ilikll \"\" IIi111i, a,.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "a,$)",
                "sec_num": null
            },
            {
                "text": "The k top first stacks are merged into one stack and the stack IIm is pushed on top of it, where m = GOTOfoo, [ik, #] for some auxiliary tree # that can be adjoined in 6 at 71, and the parser enters the configuration:",
                "cite_spans": [
                    {
                        "start": 110,
                        "end": 117,
                        "text": "[ik, #]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": ". \"an$)",
                "sec_num": null
            },
            {
                "text": "(11\"\"\" Ilikllit-t \"'\" ix illm, at\"\" a,$)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": ". \"an$)",
                "sec_num": null
            },
            {
                "text": "Case 2:~7 subsumes the foot node of 6. Let k (resp. k') be the number of terminal symbols to the right (resp. to the left) of the foot node subsumed by r/. Before applying this move, the configuration looks like:",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": ". \"an$)",
                "sec_num": null
            },
            {
                "text": "(ll\" \"\" Ilnv+tll\"\"\" Ilnxllsl\" \"\" szllik\" \"\" Iii111i, a,--. a.$) The k' stacks below the k + 2 *h stack from the top as well as the k + 1 top stacks are rewritten onto the k + 2 th stack and the stack lira is pushed on top of it, where m = GOTO/oot[nk,+ x,/3] for some auxiliary tree ~ that can be adjoined in 6 at ,7, and the parser enters the configuration: (11\"\" Ilnv+lllsl \"\" .sink .... nlik.., ixil]m, a~... an$) (iii) ACTION[/, at] = reduce root of an auxiliary tree/3 in which the last adjunction on the spine was performed at address star (rdfl@star). The parser has finished the recognition of the auxiliary tree/L It must remove all information about/3 and continue the recognition of the tree in which/3 was adjoined.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": ". \"an$)",
                "sec_num": null
            },
            {
                "text": "The parser executes an unwrap move. Let k (resp. k') be the number of terminal symbols to the left (resp. to the righO of the foot node of B. Let ff be the node at address star in/3 (ff = nil if star is not set). Let p be the number of terminal symbols to the left of the foot node subsumed by ~ (p = 0 if = nil). p + k' + 1 symbols from the top of the sequence of stacks popped. Then k -p single element stacks below the new top stack are unwrapped. Let j be the new top element of the top stack. Let ra = GOTOriaht~, t~]. j is popped and the single element stack lira is pushed on top of the top stack.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": ". \"an$)",
                "sec_num": null
            },
            {
                "text": "By keeping track of the auxiliary trees being reduced, it is possible to output a parse instead of acceptance or an error.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": ". \"an$)",
                "sec_num": null
            },
            {
                "text": "The parser recognizes the derived tree inside out: it extracts recursively the innermost auxiliary tree that has no adjunction performed in it.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": ". \"an$)",
                "sec_num": null
            },
            {
                "text": "This section explain how to construct an LR(0) parsing table given a TAG. The construction is an extension of the one used for CFGs. Similarly to Schabes and Joshi (1988) , we extend the notion of dotted rules to trees. We define the closure operations that correspond to adjunction. Then we explain how transitions between states are defined. We give in Figure 5 an example of a finite state automaton used to build the parsing table for a TAG (see Figure 5 ) generating a context-sensitive language.",
                "cite_spans": [
                    {
                        "start": 146,
                        "end": 170,
                        "text": "Schabes and Joshi (1988)",
                        "ref_id": "BIBREF2"
                    }
                ],
                "ref_spans": [
                    {
                        "start": 355,
                        "end": 363,
                        "text": "Figure 5",
                        "ref_id": "FIGREF7"
                    },
                    {
                        "start": 450,
                        "end": 458,
                        "text": "Figure 5",
                        "ref_id": "FIGREF7"
                    }
                ],
                "eq_spans": [],
                "section": "LR(0) Parsing Tables",
                "sec_num": "5"
            },
            {
                "text": "We first explain preliminary concepts (originally defined to construct an Earley-type parser for TAGs) that will be used by the algorithm. Dotted rules are extended to trees. Then we recall a tree traversal that the algorithm will mimic in order to scan the input from left to right.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "LR(0) Parsing Tables",
                "sec_num": "5"
            },
            {
                "text": "A dotted symbol is defined as a symbol associated with a dot above or below and either to the left or to 279 the right of it. The four positions of the dot are annotated by ia, ib, ra, rb (resp. left above, left below, right above, right below): taa,~ In practice, only two dot",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "LR(0) Parsing Tables",
                "sec_num": "5"
            },
            {
                "text": "positions can be used (to the left and to the fight of a node). However, for sake of simplicity, we will use four different dot positions. A dotted tree is defined as a tree with exactly one dotted symbol. Furthermore, some nodes in the dotted tree can be marked with a star. A star on a node expresses the fact that an adjunction has been performed on the corresponding node. A dotted tree is referred as [c~, dot, pos, stars] , where o~ is a tree, dot is the address of the dot, pos is the position of the dot (la, lb, ra or rb) and stars is a list of nodes in a annotated by a star. Given a dotted tree with the dot above and to the left of the root, we define a tree traversal of a dotted tree (as shown in the Figure 3 ) that will enable us to scan the frontier of an elementary tree from left to right while trying to recognize possible adjunctions between the above and below positions of the dot of interior nodes.",
                "cite_spans": [
                    {
                        "start": 406,
                        "end": 427,
                        "text": "[c~, dot, pos, stars]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 715,
                        "end": 723,
                        "text": "Figure 3",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Ib.L.rb \u2022",
                "sec_num": null
            },
            {
                "text": ". ",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "STAa :",
                "sec_num": null
            },
            {
                "text": "A state in the finite state automaton is defined to be a set of dotted trees closed under the following operations: Adjunction Prediction, Left Completion, Move Dot Down, Move Dot Up and Skip Node (See Figtire 4) . 4",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 202,
                        "end": 212,
                        "text": "Figtire 4)",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Figure 3: Left to Right Tree Traversal",
                "sec_num": null
            },
            {
                "text": "Adjunction Prediction predicts all possible auxiliary trees that can be adjoining at a given node. Left Completion occurs when an auxiliary tree is recognized up to its foot node. All trees in which that tree can be adjoined are pulled back with the node on which adjunction has been performed added to the list of stars. Move Dot Down moves the dot down the links. Move Dot Up moves the dot up the links. Skip Node moves the dot up on the right hand side of a node on which no adjunction has been performed.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Figure 3: Left to Right Tree Traversal",
                "sec_num": null
            },
            {
                "text": "All the states in the finite state automaton (FSA) must be closed under the closure operations. The FSA is 4These operations correspond to proeesson in the Eadey-type parser for TAGs. In states set 0, we put all initial trees with a dot to the left and above the root. The state is then closed. Then recursively we build new states with the following transitions (we refer to Figure 5 for an example of such a construction).",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 376,
                        "end": 384,
                        "text": "Figure 5",
                        "ref_id": "FIGREF7"
                    }
                ],
                "eq_spans": [],
                "section": "Figure 3: Left to Right Tree Traversal",
                "sec_num": null
            },
            {
                "text": "\u2022 A transition on a (where a is a terminal symbol)",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "from Si to Sj occurs if and only if in Si there is a dotted tree [6, dot, la, stars] in which the dot is to the left and above a terminal symbol a; Sj consists of the closure of the set of dotted trees of the form [6, dot, ra, stars] .",
                "cite_spans": [
                    {
                        "start": 65,
                        "end": 84,
                        "text": "[6, dot, la, stars]",
                        "ref_id": null
                    },
                    {
                        "start": 214,
                        "end": 233,
                        "text": "[6, dot, ra, stars]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "\u2022 A transition on/3~ight from Si to Sj occurs iff in Si there is a dotted tree [8, dot, rb, stars] such that the dot is to the right and below a node on which /3 can he adjoined; Sj consists of the closure of the set of dotted trees of the form [8, dot, ra, stars'] .",
                "cite_spans": [
                    {
                        "start": 79,
                        "end": 98,
                        "text": "[8, dot, rb, stars]",
                        "ref_id": null
                    },
                    {
                        "start": 245,
                        "end": 265,
                        "text": "[8, dot, ra, stars']",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "If the dotted node of [8, dot, rb, stars] [/3, dot, lb, stars] transition from Si to Sj occurs iff in S~ there is a dotted tree [/3, dot, lb, stars] such that the dot is to the left and below the foot node of the auxiliary tree/3; Sj consists of the closure of the set of dotted trees of the form [/3, dot, rb, stars] .",
                "cite_spans": [
                    {
                        "start": 22,
                        "end": 41,
                        "text": "[8, dot, rb, stars]",
                        "ref_id": null
                    },
                    {
                        "start": 42,
                        "end": 62,
                        "text": "[/3, dot, lb, stars]",
                        "ref_id": null
                    },
                    {
                        "start": 128,
                        "end": 148,
                        "text": "[/3, dot, lb, stars]",
                        "ref_id": null
                    },
                    {
                        "start": 297,
                        "end": 317,
                        "text": "[/3, dot, rb, stars]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "The parsing table is constructed from the FSA built as above. In the following, we write trans(i, z) for set of states in the FSA reached from state i on the transition labeled by z.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "The actions for ACTION(i, a) are: \u2022 Shift j (sc(j)). It applies fff j E trans(i, a).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "5Nodes on the path from root node to foot node. 280",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "\u2022 Resume Right of /6, dot, rb, stars] (rsS@dot).",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "It applies iff in state i there is a dotted tree [8, dot, rb, stars] , where dot E stars.",
                "cite_spans": [
                    {
                        "start": 49,
                        "end": 68,
                        "text": "[8, dot, rb, stars]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "\u2022 Reduce Root of/3 (rd/3@star). It applies iff in state i there is a dotted tree [/3, O, ra, {star}] , where /3 is an auxiliary tree. 6",
                "cite_spans": [
                    {
                        "start": 81,
                        "end": 100,
                        "text": "[/3, O, ra, {star}]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "\u2022 Accept occurs iff a is the end marker (a = $) and",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "there is a dotted tree [~, O, ra, {star}] , where a is an initial tree and the dot is to the right and above the root node.",
                "cite_spans": [
                    {
                        "start": 23,
                        "end": 41,
                        "text": "[~, O, ra, {star}]",
                        "ref_id": null
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "\u2022 Error, if none of the above applies. The GOTO table encodes the transitions in the FSA on non-terminal symbols.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "It is indexed by a state and by /3right or /31oot, for all auxiliary trees /3: j G GOTO(i, label) iff there is a transition from i to j on the given label (label E {/3riaht,/3/oot I/3 is an auxiliary tree}.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "If more than one action is possible in an entry of the action table, the grammar is not LR(0): there is a conflict of action, the grammar cannot be parsed deterministitally without lookahead. An example of a finite state automaton used for the construction of the LR(0) table for a TAG (trees cq,/31 in Figure 5 ) generating 7 L = {anbneendnln >_ O}, its corresponding parsing table is given and an example of sequences of moves are given in Figure 5 .",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 303,
                        "end": 311,
                        "text": "Figure 5",
                        "ref_id": "FIGREF7"
                    },
                    {
                        "start": 442,
                        "end": 450,
                        "text": "Figure 5",
                        "ref_id": "FIGREF7"
                    }
                ],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "60 is the address of the root node. tin the given TAG (trees ~1 and/31), if we omit a and c, we obtain a TAG that is similar to the one for the Dutch cross-serial construction. This grammar can still bc handled by an LR(0) parser. In the trees c~ and /3, na stand for null adjuncfion constraint (i.e. no anxifiary tree can be adjoined on a node with null adjunction constraint). [[3[[9[[4[[10, ccdd$) (110112112[[3[[9114[[101111, cdd$) (110112112113114 9 10 11116, cdd$) (110112112113114 9 10 11116117, dd$) (110H2H2H3H4 9 10 11 [[6117[[8, d$) (110[[2ll4 9 101112, d Tables   The tables that Figure 6 : Example of SLR(1) Parsing Table   By associating dotted trees with lookaheads, one can also compute LR(k) items in the finite state automaton in order to build LR(k) parsing tables.",
                "cite_spans": [
                    {
                        "start": 379,
                        "end": 435,
                        "text": "[[3[[9[[4[[10, ccdd$) (110112112[[3[[9114[[101111, cdd$)",
                        "ref_id": null
                    },
                    {
                        "start": 529,
                        "end": 566,
                        "text": "[[6117[[8, d$) (110[[2ll4 9 101112, d",
                        "ref_id": null
                    }
                ],
                "ref_spans": [
                    {
                        "start": 567,
                        "end": 591,
                        "text": "Tables   The tables that",
                        "ref_id": null
                    },
                    {
                        "start": 592,
                        "end": 600,
                        "text": "Figure 6",
                        "ref_id": null
                    },
                    {
                        "start": 629,
                        "end": 639,
                        "text": "Table   By",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Move Dot Up Move Dot Down",
                "sec_num": null
            },
            {
                "text": "The deterministic parsers we have developed do not satisfy an important property satisfied by LR parsers for CFG. This property is often described as the viable prefix property which states that as long as the portion of the input considered so far leads to some stack configuration (i.e. does not lead to error), it is always possible to find a suffix to obtain a string in the language.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Current Research",
                "sec_num": "7"
            },
            {
                "text": "Our parsers do not satisfy this property because the left completion move is not a 'reduce\" move. This move aDue to the lack of space, we do not define FIRST and FOLLOW. How\u00a2ver, we explain the basic principles used for the computafi~m of FIRST and FOLI\u00a3)W. 282 applies when we have reached a bottom-left end (to the left of the foot node) of an auxiliary tree, say/3. If we had considered this move to be a reduce move, then by popping appropriate amount of elements off the storage would allow us to figure out which tree (into which/3 was adjoined), say a, to proceed with. Rather than using this information (that is available in the storage of the BEPDA), by putting left completion in the closure operations, we apply a move that is akin to the predict move of Earley parser. That is we continue by considering every possible nodes/3 could have been adjoined at, which could include nodes in trees that were not used so far. However, we do not accept incorrect strings, we only lose the prefix property (for an example see Figure 7) . As a consequence, errors are always detected but not as soon as possible. The reason why we did not consider the left completion move to be a reduce move is related to the restrictions on moves of BEPDA which is weakly equivalent to TAGs (perhaps also due to the fact that left to right parsing may not be most natural for parsing TAGs which produce trees with context-free path sets). In CFGs, where there is only horizontal stacking, a single reduction step is used to account for the application of rule in left to right parsing. On the other hand, with TAGs, if a tree is used successfully, it appears that a prediction move and more than one reduction move are necessary for auxiliary tree. In left to right parsing, a prediction is made to start an auxiliary tree/3 at top left end; a reduction is appropriate to recover the node/3 was adjoined at the left completion stage; a reduction is needed again at resume right state to resume the right end of t; finally a reduction is needed at the right completion stage. In our algorithm, reductions are used at right resume stage and reduce right state. Even if a reduction step is applied at left completion stage, an encoding of the fact that left part of/3 (as well as the left part of trees adjoined on the spine of/~) has been completed has to be restored in the storage (note in a reduction move of any shift reduce parser for CFGs, any information about the rule used is discarded once reduction step applied). So far we have not been able to apply a reduction step at the left completion stage, reinsert the left part of fl and yet maintain the correct sequence in the storage so that the right part of/3 can be recovered at the resume right stage. We are considering alternative strategies for shift reduce parsing with BEPDA as well as considering whether there are other automata models equivalent to TAGs better suited for deterministic left to right parsing of tree-adjoining languages.",
                "cite_spans": [],
                "ref_spans": [
                    {
                        "start": 1029,
                        "end": 1038,
                        "text": "Figure 7)",
                        "ref_id": null
                    }
                ],
                "eq_spans": [],
                "section": "Current Research",
                "sec_num": "7"
            },
            {
                "text": "We have introduced a bottom-up machine (Bottom-up Embedded Push Down Automaton) that enabled us to define LR-like parsers for TAGs. The machine recognizes in a bottom-up fashion exactly the set of Tree Adjoining Languages.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": null
            },
            {
                "text": "We described the LR parsing algorithm and a method for computing LR(0) parsing tables. We also mentioned the possibility of building SLR(k) parsing tables by defining the notions of FIRST and FOLLOW sets for TAGs.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": null
            },
            {
                "text": "As shown for the example, no lookaheads are neeessary to parse deterministically the language L = {anbnec\"d\"ln >_ O}. If instead of using e, we had the empty string e in the initial tree, LR(0)-like parser will not be enough. On the other hand SLR(1)-like parser will suffice.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": null
            },
            {
                "text": "We have noted that our parsers do not satisfy the valid prefix property. As a consequence, errors are always detected but not as soon as possible.",
                "cite_spans": [],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": null
            },
            {
                "text": "Similar to the work of Lang (1974) and Tomita (1987) extending LR parsers for arbitrary CFGs, the LR parsers for TAGs can be extended to solve by pseudo-parallelism the conflicts of moves.",
                "cite_spans": [
                    {
                        "start": 23,
                        "end": 34,
                        "text": "Lang (1974)",
                        "ref_id": "BIBREF0"
                    },
                    {
                        "start": 39,
                        "end": 52,
                        "text": "Tomita (1987)",
                        "ref_id": "BIBREF4"
                    }
                ],
                "ref_spans": [],
                "eq_spans": [],
                "section": "Conclusion",
                "sec_num": null
            }
        ],
        "back_matter": [],
        "bib_entries": {
            "BIBREF0": {
                "ref_id": "b0",
                "title": "Deterministic Techniques for Eff\u00c9cient Non-Deterministic Parsers",
                "authors": [
                    {
                        "first": "Bernard",
                        "middle": [],
                        "last": "Lang",
                        "suffix": ""
                    }
                ],
                "year": 1974,
                "venue": "Automata, Languages and Programming, 2rid Colloquium",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Lang, Bernard, 1974. Deterministic Techniques for Eff\u00c9- cient Non-Deterministic Parsers. In Loeckx, Jacques (editor), Automata, Languages and Programming, 2rid Colloquium, University of Saarbri~cken. Lecture Notes in Computer Science, Springer Verlag.",
                "links": null
            },
            "BIBREF1": {
                "ref_id": "b1",
                "title": "Unilateral context sensitive grammars and left to fight parsing",
                "authors": [
                    {
                        "first": "G",
                        "middle": [],
                        "last": "R6v6sz",
                        "suffix": ""
                    }
                ],
                "year": 1971,
                "venue": "J. Comput. System Sci",
                "volume": "5",
                "issue": "",
                "pages": "337--352",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "R6v6sz, G., 1971. Unilateral context sensitive gram- mars and left to fight parsing. J. Comput. System Sci. 5:337-352.",
                "links": null
            },
            "BIBREF2": {
                "ref_id": "b2",
                "title": "An Earley-Type Parsing Algorithm for Tree Adjoining Grammars",
                "authors": [
                    {
                        "first": "Yves",
                        "middle": [],
                        "last": "Schabes",
                        "suffix": ""
                    },
                    {
                        "first": "Aravind",
                        "middle": [
                            "K"
                        ],
                        "last": "Joshi",
                        "suffix": ""
                    }
                ],
                "year": 1988,
                "venue": "26 th Meeting of the Association for Computational Linguistics (A CL' 88 )",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Schabes, Yves and Joshi, Aravind K., June 1988. An Earley-Type Parsing Algorithm for Tree Adjoining Grammars. In 26 th Meeting of the Association for Computational Linguistics (A CL' 88 ). Buffalo.",
                "links": null
            },
            "BIBREF3": {
                "ref_id": "b3",
                "title": "Characterizing Derivations Trees of Context Free Grammars through a Generalization of Finite Automata Theory",
                "authors": [
                    {
                        "first": "J",
                        "middle": [
                            "W"
                        ],
                        "last": "Thatcher",
                        "suffix": ""
                    }
                ],
                "year": 1971,
                "venue": "J. Comput. Syst. Sci",
                "volume": "5",
                "issue": "",
                "pages": "365--396",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Thatcher, J. W., 1971. Characterizing Derivations Trees of Context Free Grammars through a Generalization of Finite Automata Theory. J. Comput. Syst. Sci. 5:365-396.",
                "links": null
            },
            "BIBREF4": {
                "ref_id": "b4",
                "title": "An Efficient Augmented",
                "authors": [
                    {
                        "first": "Masaru",
                        "middle": [],
                        "last": "Tomita",
                        "suffix": ""
                    }
                ],
                "year": 1987,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Tomita, Masaru, 1987. An Efficient Augmented-",
                "links": null
            },
            "BIBREF5": {
                "ref_id": "b5",
                "title": "Context-Free Parsing Algorithm",
                "authors": [],
                "year": null,
                "venue": "Computational Linguistics",
                "volume": "13",
                "issue": "",
                "pages": "31--46",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Context-Free Parsing Algorithm. Computational Lin- guistics 13:31--46.",
                "links": null
            },
            "BIBREF6": {
                "ref_id": "b6",
                "title": "Generalized Deterministic Left to Right Parsing",
                "authors": [
                    {
                        "first": "C",
                        "middle": [
                            "J M"
                        ],
                        "last": "Turnbull",
                        "suffix": ""
                    },
                    {
                        "first": "E",
                        "middle": [
                            "S"
                        ],
                        "last": "Lee",
                        "suffix": ""
                    }
                ],
                "year": 1979,
                "venue": "Acta lnformatica",
                "volume": "12",
                "issue": "",
                "pages": "187--207",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Turnbull, C. J. M. and Lee, E. S., 1979. Generalized Deterministic Left to Right Parsing. Acta lnformatica 12:187-207.",
                "links": null
            },
            "BIBREF7": {
                "ref_id": "b7",
                "title": "A Study of Tree Adjoining Grammars. Phi) thesis",
                "authors": [
                    {
                        "first": "K",
                        "middle": [],
                        "last": "Vijay-Shanker",
                        "suffix": ""
                    }
                ],
                "year": 1987,
                "venue": "",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Vijay-Shanker, K., 1987. A Study of Tree Adjoining Grammars. Phi) thesis, Department of Computer and Information Science, University of Pennsylvania.",
                "links": null
            },
            "BIBREF8": {
                "ref_id": "b8",
                "title": "Deterministic Context-Sensitive Languages",
                "authors": [
                    {
                        "first": "D",
                        "middle": [
                            "A"
                        ],
                        "last": "Waiters",
                        "suffix": ""
                    }
                ],
                "year": 1970,
                "venue": "Inf. Control",
                "volume": "17",
                "issue": "",
                "pages": "14--40",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Waiters, D.A., 1970. Deterministic Context-Sensitive Languages. Inf. Control 17:14--40.",
                "links": null
            },
            "BIBREF9": {
                "ref_id": "b9",
                "title": "How Much Context-Sensitivity is Necessary for Characterizing Structural Descriptions---Tree Adjoining Grammars",
                "authors": [
                    {
                        "first": "Aravind",
                        "middle": [],
                        "last": "Joshi",
                        "suffix": ""
                    },
                    {
                        "first": "",
                        "middle": [],
                        "last": "Ic",
                        "suffix": ""
                    }
                ],
                "year": 1983,
                "venue": "Natural Language Processing--Theoretical, Computational and Psychological Perspectives",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Joshi, Aravind IC, 1985. How Much Context- Sensitivity is Necessary for Characterizing Struc- tural Descriptions---Tree Adjoining Grammars. In Dowry, D., Karttunen, L., and Zwicky, A. (editors), Natural Language Processing--Theoretical, Compu- tational and Psychological Perspectives. Cambridge University Press, New York. Originally presented in a Workshop on Natural Language Parsing at Ohio State University, Columbus, Ohio, May 1983.",
                "links": null
            },
            "BIBREF10": {
                "ref_id": "b10",
                "title": "An Inmxluction to Tree Adjoining Grammars",
                "authors": [
                    {
                        "first": "Aravind",
                        "middle": [
                            "K"
                        ],
                        "last": "Joshi",
                        "suffix": ""
                    }
                ],
                "year": 1987,
                "venue": "Mathematics of Language. John Benjamins",
                "volume": "",
                "issue": "",
                "pages": "",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Joshi, Aravind K., 1987. An Inmxluction to Tree Ad- joining Grammars. In Manaster-Ramer, A. (editor), Mathematics of Language. John Benjamins, Amster- dam.",
                "links": null
            },
            "BIBREF11": {
                "ref_id": "b11",
                "title": "On the translation of languages from left to right",
                "authors": [
                    {
                        "first": "D",
                        "middle": [
                            "E"
                        ],
                        "last": "Knuth",
                        "suffix": ""
                    }
                ],
                "year": 1965,
                "venue": "Inf. Control",
                "volume": "8",
                "issue": "",
                "pages": "607--639",
                "other_ids": {},
                "num": null,
                "urls": [],
                "raw_text": "Knuth, D. E., 1965. On the translation of languages from left to right. Inf. Control 8:607-639.",
                "links": null
            }
        },
        "ref_entries": {
            "FIGREF0": {
                "type_str": "figure",
                "uris": null,
                "num": null,
                "text": "Figure 1: Embedded Pushdown Automaton"
            },
            "FIGREF1": {
                "type_str": "figure",
                "uris": null,
                "num": null,
                "text": "Bottom-up Embedded Pushdown Automaton at. The entry in the action table can have one of the following five values:\u2022 Shift j (s j), where j is a state;"
            },
            "FIGREF2": {
                "type_str": "figure",
                "uris": null,
                "num": null,
                "text": "piled up from left to right. II stands for the bottom of a stack, s~ is the top element of the top stack, Sx is the bottom element of the top stack, tl is the top element of the bottom stack and tm is the bottom element of the bottom stack.The initial configuration of the parser is set to: (110, al-..an$) where 0 is the start state and ax \u2022 .. a,$ is the input string to be read with an end marker ($). 278"
            },
            "FIGREF3": {
                "type_str": "figure",
                "uris": null,
                "num": null,
                "text": "[i, a,]. The parser keeps applying the move associated with ACTION[i, at] until acceptance or error occurs. The following moves are possible: (i) (ii) ACTION[/, at] = shift state j (,j). The parser executes a push move, entering the configuration: (lltm''' tx II\"\" IIi~o \u2022 \u2022 \u2022 ilillJ, at+l\"'\" an$) ACTION[/, at] = resume right of 6 at"
            },
            "FIGREF4": {
                "type_str": "figure",
                "uris": null,
                "num": null,
                "text": "Figure 4: Closure Operations"
            },
            "FIGREF6": {
                "type_str": "figure",
                "uris": null,
                "num": null,
                "text": "Example of LR(O) Parsing TableExample of sequences of moves sj _----Shift j; rs6~dot --Resume Right of 6 at dot; rd~star ----Reduce Root of/~ with star at address star; $ --end of input."
            },
            "FIGREF7": {
                "type_str": "figure",
                "uris": null,
                "num": null,
                "text": "Example of the construction of an LR(0) parser for a TAG recognizing L = {a'~bnec\"d\" }6 SLR(1) Parsing"
            },
            "FIGREF8": {
                "type_str": "figure",
                "uris": null,
                "num": null,
                "text": "Figure 7: Example of error detecting"
            },
            "TABREF0": {
                "num": null,
                "content": "<table><tr><td>read only input tape</td><td/><td/><td/><td/></tr><tr><td/><td/><td colspan=\"2\">Bounded number [1</td><td>A~</td></tr><tr><td/><td/><td>of stacks of bounded size</td><td>II</td><td>All</td></tr><tr><td/><td/><td colspan=\"2\">1 Bounded number [~ of stack elements</td><td>al</td></tr><tr><td/><td/><td colspan=\"2\">Unbounded number (1 of stack elements ~.J</td><td/></tr><tr><td/><td>u</td><td>Bounded number of stacks of bounded size</td><td>II ~,1</td><td>BI 7\" Bn</td><td>EPDA</td></tr><tr><td>BEPDA</td><td>stack of aac~</td><td/><td/><td/><td>lnove</td><td>[]</td></tr><tr><td/><td/><td colspan=\"4\">UNWRAP move</td><td>PUSH move</td></tr></table>",
                "type_str": "table",
                "html": null,
                "text": "table consists of three parts, a parsing action function ACTION and two goto functions GOTOright and GOTOloot. The program driving the LR parser first determines the state i currently on top of the top stack and the current input token at. Then it consults the ACTION table entry for state i and token 3The need to use bottom-up version of an EPDA in LR style parsing of TAGs was suggested to us by Bernard Lang and David Weir. Also their susgestions played all insU~llaK~[ v01e in the definition of BBPDA, for example restriction on the moves allowed."
            },
            "TABREF2": {
                "num": null,
                "content": "<table/>",
                "type_str": "table",
                "html": null,
                "text": "is not on the spine 5 of 8, star' consists of all the nodes in star that strictly dominate the dotted node. When the dotted node is on the spine, stars' consists of all the nodes in star that strictly dominate the dotted node, ff there are some, otherwise stars' = {dot}."
            },
            "TABREF5": {
                "num": null,
                "content": "<table><tr><td/><td/><td>The accu-</td></tr><tr><td colspan=\"3\">racy of the parsing table can be improved by comput-</td></tr><tr><td colspan=\"3\">ing lookaheads. FIRST and FOLLOW can be extended</td></tr><tr><td colspan=\"3\">to dotted trees, s FIRST of a dotted tree corresponds to</td></tr><tr><td colspan=\"3\">the set of left most symbols appearing below the subtree</td></tr><tr><td colspan=\"3\">dominated by the dotted node. FOLLOW of a dotted tree</td></tr><tr><td colspan=\"3\">defines the set of tokens that can appear in a derivation</td></tr><tr><td colspan=\"3\">immediately following the dotted node. Once FIRST</td></tr><tr><td colspan=\"3\">and FOLLOW computed, the LR(0) parsing table can</td></tr><tr><td colspan=\"3\">be improved to an SLR(1) table: Resume Right and Re-</td></tr><tr><td colspan=\"3\">duce Root are applicable only on the input tokens in the</td></tr><tr><td colspan=\"2\">follow set of the dotted tree.</td><td/></tr><tr><td colspan=\"3\">For example, the SLR(1) table for the TAG built with</td></tr><tr><td colspan=\"2\">trees oq and ~1 is given in Figure 6.</td><td/></tr><tr><td>I</td><td>PARSING AC'TION</td><td>II GOTO[</td></tr><tr><td>I</td><td/><td>I1 foot II right I</td></tr><tr><td colspan=\"3\">I I'lbl 'c I a lel S I1~11 ~1</td></tr><tr><td/><td/><td>6</td></tr></table>",
                "type_str": "table",
                "html": null,
                "text": "we have constructed are LR(0) tables. The Resume Right and Reduce Root moves are performed regardless of the next input token."
            }
        }
    }
}