| { |
| "paper_id": "1991", |
| "header": { |
| "generated_with": "S2ORC 1.0.0", |
| "date_generated": "2023-01-19T07:36:12.299885Z" |
| }, |
| "title": "The Valid Prefix Property and Left to Right Parsing of Tree-Adjoining Grammar*", |
| "authors": [ |
| { |
| "first": "Yves", |
| "middle": [], |
| "last": "Schabes", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "University of Pennsylvania", |
| "location": { |
| "postCode": "19104-6389", |
| "settlement": "Philadelphia", |
| "region": "PA" |
| } |
| }, |
| "email": "schabes@linc.cis.upenn.edu" |
| } |
| ], |
| "year": "", |
| "venue": null, |
| "identifiers": {}, |
| "abstract": "The valid prefix property (VPP) , the capability of a left to right parser to detect errors as soon as pos sible, often goes unnoticed in parsing CFGs. Ear ley's parser for CFGs (Earley, 1968; Earley, 1970) maintains the valid prefix property and obtains an O(n 3)-time worst case complexity, as good as parsers that do not maintain such as the CKY parser (Younger, 1967; Kasami, 1965). Contrary to CFGs, maintaining the valid prefix property for TAGs is costly. \u2022 This research was partially fu nded by ARO grant DAAL03-89-C0031PRI and DARPA grant N00014-90-J-1863. The difficulty of maintaining the valid prefix property for TAGS was first noticed in joint work with Vijay-Shanker in the context of deterministic parsing of tree-adjoining grammars (Schabes and Vijay-Shanker, 1990). I am in debted to Vijay-Shanker for nwnerous discussions on this topic. I am also indebted to Aravind Joshi for his sugges tions and for his support of this research. The discussions I had with Mitchell Marcus greatly improved the presenta tion of the algorithm introduced in this paper. I would also like to thank Bob Frank, Bernard Lang, Fernando Pereira, Philip Resnik and Stuart Shieber for providing valuable comments.", |
| "pdf_parse": { |
| "paper_id": "1991", |
| "_pdf_hash": "", |
| "abstract": [ |
| { |
| "text": "The valid prefix property (VPP) , the capability of a left to right parser to detect errors as soon as pos sible, often goes unnoticed in parsing CFGs. Ear ley's parser for CFGs (Earley, 1968; Earley, 1970) maintains the valid prefix property and obtains an O(n 3)-time worst case complexity, as good as parsers that do not maintain such as the CKY parser (Younger, 1967; Kasami, 1965). Contrary to CFGs, maintaining the valid prefix property for TAGs is costly. \u2022 This research was partially fu nded by ARO grant DAAL03-89-C0031PRI and DARPA grant N00014-90-J-1863. The difficulty of maintaining the valid prefix property for TAGS was first noticed in joint work with Vijay-Shanker in the context of deterministic parsing of tree-adjoining grammars (Schabes and Vijay-Shanker, 1990). I am in debted to Vijay-Shanker for nwnerous discussions on this topic. I am also indebted to Aravind Joshi for his sugges tions and for his support of this research. The discussions I had with Mitchell Marcus greatly improved the presenta tion of the algorithm introduced in this paper. I would also like to thank Bob Frank, Bernard Lang, Fernando Pereira, Philip Resnik and Stuart Shieber for providing valuable comments.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstract", |
| "sec_num": null |
| } |
| ], |
| "body_text": [ |
| { |
| "text": "In 1988, Schabes and Joshi proposed an Earley type parser for TA Gs. It maintains the valid pre fix property at the expense of its worst case com plexity (O(n 9 )-time) . To our knowledge, it is the only known polynomial time parser for TAGs that maintains the valid prefix property.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| }, |
| { |
| "text": "In this paper, we explain why the valid prefix property is expensive to maintain for TAGs and we introduce a predictive left to right parser for TAGs that does not maintain the valid prefix prop erty but that achieves an 0( n 6 )-time worst case behavior, O(n 4 )-time for unambiguous grammars and linear time for a large class of grammars.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| }, |
| { |
| "text": "The valid prefix property is a property of left of to right parsing algorithms which guarantees that errors in the input are detected \"as soon as possi ble\" . Parsers satisfying the valid prefix property guar antee that, as they read the input from left to right, the substrings read so far are valid prefi xes of the language defined by the grammar : if the parser has read the tokens a1 \u2022 \u2022 \u2022 ak from the in put a 1 \u2022 \u2022 \u2022 ak ak+l \u2022\u2022\u2022a n , then it is guaranteed that there is a string of tokens b 1 \u2022 \u2022 \u2022 b m (bi may not be part of the input) with which the string a1 \u2022 \u2022 \u2022 ak can be suffixed to form a string of the language; i.e.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Definition of the Valid Pre fix Property", |
| "sec_num": "1" |
| }, |
| { |
| "text": "The valid prefix property, the capability of a left to right parser to detect errors as soon as possi ble, is often unobserved in parsing CFGs . Earley's parser for CFGs (Earley, 1968) maintains the valid prefix property and obtains a worst case complex ity (O(n 3 )-time) , as good as parsers that do not maintain it, such as the CKY parser (Younger, 1967; Kasami, 1965) . This follows from the path set complexity, as we will see.", |
| "cite_spans": [ |
| { |
| "start": 170, |
| "end": 184, |
| "text": "(Earley, 1968)", |
| "ref_id": "BIBREF0" |
| }, |
| { |
| "start": 342, |
| "end": 357, |
| "text": "(Younger, 1967;", |
| "ref_id": null |
| }, |
| { |
| "start": 358, |
| "end": 371, |
| "text": "Kasami, 1965)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The _ Va lid Prefix Prop erty and Parsing of Tree Adjoining Grammar", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Maintaining the VPP requires a parser to recog nize the possible parse trees in a prefix order. The prefix traversal of the output tree consists of two components: a top-down component that expands a constituent to go to the next level down, and a bottom-up component that reduces a constituent to go to the next level up. When the VPP is main tained, these two components must be constrained together .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The _ Va lid Prefix Prop erty and Parsing of Tree Adjoining Grammar", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Context-free productions can be expanded in dependently of their context, in particular, inde pendently of the productions that subsume them. The path set (language defined as the set of paths from root to frontier of all derived trees) of CFGs is therefore a regular set. 2 It follows that no addi tional complexity is required to correctly constrain the top-down and bottom-up behavior required by the prefix traversal of the parse tree: the expan sion and the reduction of a constituent.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The _ Va lid Prefix Prop erty and Parsing of Tree Adjoining Grammar", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Contrary to CFGs, maintaining the valid prefix property for TA Gs is costly. 3 Two observations corroborate this statement and an explanation can be found in the path set complexity of TAG .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The _ Va lid Prefix Prop erty and Parsing of Tree Adjoining Grammar", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Our first observation was that the worst case complexity of parsers for TAG that maintain the VPP is higher than the parsers that do not main tain VPP. Vijay-Shanker and Joshi (1985) 4 pro posed a CKY-type parser for TAG that achieves 0( n 6 )-\" time worst case complexity. 5 As the orig inal CKY parser for CFGs, this parser does not maintain the VPP. The Earley-type parser de veloped for TAGs (Schabes and Joshi, 1988 ) is bottom-up and uses top-down prediction. It main-tains the VPP at a cost to its worst case com plexity (O(n 9 )-time in the worst case). However, the goal of our 1988 enterprise was to build a practical parser which behaves in practice better than its worst case complexity. Other parsers for TAGs have been proposed (Lang, 1988; Satta and Lavelli, 1990; Vijay-Shanker and Weir, 1990 ). 6 Al though they achieve 0( n 6 ) worst case time com plexity, none of these algorithms satisfies the VPP. To our knowledge, Schabes and Joshi's parser (1988) is the only known polynomial-time parser for TAG which satisfies the valid prefix property. It is still an open problem whether a better worst case complexity can be obtained for parsing TAGs while maintaining the valid prefix property.", |
| "cite_spans": [ |
| { |
| "start": 396, |
| "end": 420, |
| "text": "(Schabes and Joshi, 1988", |
| "ref_id": null |
| }, |
| { |
| "start": 742, |
| "end": 754, |
| "text": "(Lang, 1988;", |
| "ref_id": null |
| }, |
| { |
| "start": 755, |
| "end": 779, |
| "text": "Satta and Lavelli, 1990;", |
| "ref_id": null |
| }, |
| { |
| "start": 780, |
| "end": 808, |
| "text": "Vijay-Shanker and Weir, 1990", |
| "ref_id": null |
| }, |
| { |
| "start": 937, |
| "end": 970, |
| "text": "Schabes and Joshi's parser (1988)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The _ Va lid Prefix Prop erty and Parsing of Tree Adjoining Grammar", |
| "sec_num": "2" |
| }, |
| { |
| "text": "The second observation is in the context of de terministic left to right parsing of TAGs (Schabes and Vijay-Shanker, 1990) where it was for the first time explicitly noticed that VPP is problem atic to obtain. The authors were not able to de fine a bottom-up deterministic machine that sat isfies the valid prefix property and which recog nizes exactly tree-adjoining languages when used non-deterministically. Instead, they used a deter ministic machine that does not satisfy the VPP, the bottom-up embedded push-down automaton, which recognizes exactly tree-adjoining languages when used non-deterministically.", |
| "cite_spans": [ |
| { |
| "start": 89, |
| "end": 122, |
| "text": "(Schabes and Vijay-Shanker, 1990)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The _ Va lid Prefix Prop erty and Parsing of Tree Adjoining Grammar", |
| "sec_num": "2" |
| }, |
| { |
| "text": "The explanation for the difficulty of maintaining the VPP can be seen in in the complexity of the path set of TAGs. Tree-adj oining grammars gen erate some languages that are context-sensitive. The path set of a TAG is a context-free language . (_ Weir, 1988) and is therefore more powerful than the path set of a CFG. Therefore in TAGs, the expansion of a branch may depend on the parent super-tree, i.e. what is above this branch. Going bottom-up, these dependencies can be captured by a stack mechanism since trees are embedded by ad junction. However, if one would like to maintain the valid prefix property, which requires travers ing the output tree in a prefix fashion, the depen dencies are more complex than a context-free lan guage and the complexity of the parsing algorithm mcreases.", |
| "cite_spans": [ |
| { |
| "start": 245, |
| "end": 259, |
| "text": "(_ Weir, 1988)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The _ Va lid Prefix Prop erty and Parsing of Tree Adjoining Grammar", |
| "sec_num": "2" |
| }, |
| { |
| "text": "For example, consider the trees a, /3 and , in Figure J . When , is adjoined into /3 at the B node, and the result is adjoined into a at the A node, the resulting tree yields the string ux 'zx\"vy \"ty'w ( see Figure 1 ). If this TA G derived tree is recognized purely bottom-up from leaf to root ( and therefore with out maintaining the VPP), a stack based mech anism suffices for keeping track . of the trees to which to algorithm needs to come back. This is illustrated by the fact that the tree domains are embedded (see bottom left tree in Figure 1 ) when they . _ are read from leaf to root in the derived tree.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 47, |
| "end": 55, |
| "text": "Figure J", |
| "ref_id": null |
| }, |
| { |
| "start": 208, |
| "end": 216, |
| "text": "Figure 1", |
| "ref_id": "FIGREF1" |
| }, |
| { |
| "start": 543, |
| "end": 551, |
| "text": "Figure 1", |
| "ref_id": "FIGREF1" |
| } |
| ], |
| "eq_spans": [], |
| "section": "The _ Va lid Prefix Prop erty and Parsing of Tree Adjoining Grammar", |
| "sec_num": "2" |
| }, |
| { |
| "text": "\ufffd\" li ! i i i i i i z A. t \ufffd \\I z A. t \ufffd \ufffd Left to Right Recognition u x' z x\" v y\" t y' w 1 1' \"LYjrrr\ufffdr", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The _ Va lid Prefix Prop erty and Parsing of Tree Adjoining Grammar", |
| "sec_num": "2" |
| }, |
| { |
| "text": "However, if this derivation is recognized from left to right while maintaining the valid prefix property, the dependencies are more complex and can no longer be captured by a stack ( see bottom right tree in Figure 1 ).", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 208, |
| "end": 216, |
| "text": "Figure 1", |
| "ref_id": "FIGREF1" |
| } |
| ], |
| "eq_spans": [], |
| "section": "The _ Va lid Prefix Prop erty and Parsing of Tree Adjoining Grammar", |
| "sec_num": "2" |
| }, |
| { |
| "text": "The context-free complexity of the path set of TAGs makes the valid prefix property costly to maintain. We suspect that the same difficulty arises for context-sensitive formalism which use operations such as adjoining or wrapping (Joshi et al. , Forthcoming 1990) .", |
| "cite_spans": [ |
| { |
| "start": 230, |
| "end": 263, |
| "text": "(Joshi et al. , Forthcoming 1990)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The _ Va lid Prefix Prop erty and Parsing of Tree Adjoining Grammar", |
| "sec_num": "2" |
| }, |
| { |
| "text": "languages it recognizes still needs to be determined.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The _ Va lid Prefix Prop erty and Parsing of Tree Adjoining Grammar", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Parser fo r TA Gs", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "A Predictive Left to Right", |
| "sec_num": "3" |
| }, |
| { |
| "text": "In this section, we defi ne a new predictive left to right (Earley-style) parser for TAGs with adjoin ing constraints (Joshi, 1987) . It is a bottom-up parser that uses some but not all the top-down in formation given by prediction. As a consequence, the parser does not satisfy the valid prefi x prop erty: it always detects errors but not as soon as possible. However, it achieves an O(n 6 )-time worst case behavior, O(n 4 )-time for unambiguous grammars and linear time for a large class of gram mars (for example, the language a n b n ec n d n is rec ognized in linear time). This parser as well as in the one introduced by Schabes and Joshi 1988are practical parsers for TAGs since as is well known for CFGs, the average behavior of Earley style parsers is superior to their worst case com plexity. The algorithm has been modified to han dle extensions of TAGs such as substitution, fea ture structures for TA Gs and a version of multiple component TAG ( these extensions are explained in Schabes [1990] ).", |
| "cite_spans": [ |
| { |
| "start": 118, |
| "end": 131, |
| "text": "(Joshi, 1987)", |
| "ref_id": "BIBREF5" |
| }, |
| { |
| "start": 995, |
| "end": 1009, |
| "text": "Schabes [1990]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "A Predictive Left to Right", |
| "sec_num": "3" |
| }, |
| { |
| "text": "Any tree a will be considered to be a function from tree addresses to symbols of the grammar ( ter minal and non-terminal symbols) : if x is a valid address in a, then a( x) is the label of the node at address x in the tree a . A ddresses of nodes in a tree are encoded by Gorn-positions (Gorn, 1965) as defined by the following inductive defini tion: 0 is the address of the root node, k (k E N) is the address of the P h child of the root node, x \u2022 y ( x is an address, y E N) is the address of the y th child of the node at address x. Given a tree a and an address address in a, we define Adjunct(a, address) to be the set of aux iliary trees that can be adjoined at the node at address address in a. For TAGs with no con straints on adjunction, Adjunct( a, address) is the set of elementary auxiliary trees whose root node is labeled by a( address).", |
| "cite_spans": [ |
| { |
| "start": 273, |
| "end": 300, |
| "text": "Gorn-positions (Gorn, 1965)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Prel i m i nary Concepts", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "We define a dotted tree as a tree associated with a dot above or below and either to the left or to th e right of a given node. The four positions of the dot are annotated by la, lb, ra, rb (resp. left above, left below, right above, right below): ibA;b. We write < a, dot , pos > for a dotted tree in which the dot is at address dot and at position pos in the tree a.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Prel i m i nary Concepts", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "The tree traversal we define for parsing TAGs consists of moving a dot in an elementary tree in a manner consistent with the left to right scanning of the yield while still being able to recognize ad junctions on interior nodes of the tree. The tree traversal starts when the dot is above and to the left of the root node and ends when the dot is above and to the right of the root node. At any time, there is only one dot in the dotted tree. An example of tree traversal is shown in Figure 2 . ", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 484, |
| "end": 492, |
| "text": "Figure 2", |
| "ref_id": "FIGREF2" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Prel i m i nary Concepts", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "We consider to equivalent two successive ( ac cording to the tree traversal) dot positions that do not cross a node in the tree (see Figure 2 ). For ex ample the following equivalences hold for the tree a pictured in Figure 2 : < a, 0, lb >=< a, l, la > , < . a, 1 , ra >=< n, 2, la >, < a, 2, lb >=< a, 2 \u2022 l, la >,\u2022 \u2022 \u2022.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 133, |
| "end": 141, |
| "text": "Figure 2", |
| "ref_id": "FIGREF2" |
| }, |
| { |
| "start": 217, |
| "end": 225, |
| "text": "Figure 2", |
| "ref_id": "FIGREF2" |
| } |
| ], |
| "eq_spans": [], |
| "section": "This traversal will en \ufffd \ufffds to scan the frontier of an elementary tree om left to right while try ing to recognize pos ble adjunctions between the above and below p sitions of the dot.", |
| "sec_num": null |
| }, |
| { |
| "text": "We now define the data structures used by the parser. The input string is a 1 a, dot ,pos,i,j,k,l,sat?] where:", |
| "cite_spans": [ |
| { |
| "start": 78, |
| "end": 103, |
| "text": "a, dot ,pos,i,j,k,l,sat?]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Data Structures", |
| "sec_num": "3.2" |
| }, |
| { |
| "text": "s = [", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Data Structures", |
| "sec_num": "3.2" |
| }, |
| { |
| "text": "\u2022 a is an elementary tree, initial or auxiliary tree : a E JU A.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Data Structures", |
| "sec_num": "3.2" |
| }, |
| { |
| "text": "\u2022 dot is the address of the dot in the tree a.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Data Structures", |
| "sec_num": "3.2" |
| }, |
| { |
| "text": "\u2022 pos is the position of the dot: to the left and above, or to the left and below, or to the right and below, or to the right and above; pos E {la, lb, rb, ra } . \u2022 sat? is a boolean; sat? E {true, nil}. The components a, dot , pos of a state define a dotted tree. Similarly to a dotted rule for context free grammars defined by Earley ( 1 968), a dotted tree splits a tree into two contexts: a left context that has been traversed and a right context that needs to be recognized.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Data Structures", |
| "sec_num": "3.2" |
| }, |
| { |
| "text": "\u2022 i, j,", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Data Structures", |
| "sec_num": "3.2" |
| }, |
| { |
| "text": "The additional indices i, j, k, l record the por tions of the input string. The boolean sat? indicates whether an adjunc tion has been recognized on the node at address dot in the tree a.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Data Structures", |
| "sec_num": "3.2" |
| }, |
| { |
| "text": "In the following, we will refer to one of the two equivalent dot positions for the dotted tree. For example, if the dot at address dot and at position pos in the tree a is equivalent to the dot at address dot' at position pos' in a, then s = [a, dot, pos, i,j, k, l, sat?] and s' = [a, dot' ,pos', i, j, k, l, sat?] refer to the same state.", |
| "cite_spans": [ |
| { |
| "start": 242, |
| "end": 272, |
| "text": "[a, dot, pos, i,j, k, l, sat?]", |
| "ref_id": null |
| }, |
| { |
| "start": 282, |
| "end": 315, |
| "text": "[a, dot' ,pos', i, j, k, l, sat?]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Data Structures", |
| "sec_num": "3.2" |
| }, |
| { |
| "text": "We will use to our convenience s or s' to refer to this unique state.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Data Structures", |
| "sec_num": "3.2" |
| }, |
| { |
| "text": "There is a useful analogy between dotted TAG trees and dotted rules. It is by no mean a formal correspondence between TAG and a production system but it will give an intuitive understanding of the parser we define. It will also be used as a notation for referring to a dotted tree. One can interpret a TA G elementary tree as a set of productions on pairs of trees and addresses (i.e. nodes). For example, the tree in Figure 2 , let 's call it a, can be written as: a, 2 \u2022 1) (a, 2 \u2022 2 ) (a, 2 \u2022 3) (a , 3) -+ (a , 3 -1) (a , 3 \u2022 2 ) Of course, the label of the node at address i in a is associated with each pair (a, i) . 8 One can then relate a dotted tree to a dotted rule. For example, consider the dotted tree < a, 2, ra > in which the dot is at address 2 and at position \"right above\" in the tree a (tree in Figure 2) . Note that the dotted trees < a, 2, ra > and < a, 3 , la > are equivalent.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 418, |
| "end": 426, |
| "text": "Figure 2", |
| "ref_id": "FIGREF2" |
| }, |
| { |
| "start": 466, |
| "end": 535, |
| "text": "a, 2 \u2022 1) (a, 2 \u2022 2 ) (a, 2 \u2022 3) (a , 3) -+ (a , 3 -1) (a , 3 \u2022 2 )", |
| "ref_id": "FIGREF1" |
| }, |
| { |
| "start": 816, |
| "end": 825, |
| "text": "Figure 2)", |
| "ref_id": "FIGREF2" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Analogy between Dotted Trees and Dotted Rules", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "(a, 0) -+ (a, 1) (a, 2 ) (a, 3) (a, 2 )-+ (", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Analogy between Dotted Trees and Dotted Rules", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "8 TAGs could be defined in term of such productions. However adjunction must be defined within this production system. This is not our goal, since we want to draw an analogy and not to define a formal system. \ufffd", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Analogy between Dotted Trees and Dotted Rules", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "The dotted tree < a, 2, ra > is analogous to the dotted rule:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Analogy between Dotted Trees and Dotted Rules", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "(a, 0) -+ (a, 1) (a, 2) \u2022 (a, 3)", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Analogy between Dotted Trees and Dotted Rules", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "One can therefore put into correspondence a state defined on a dotted tree with a state defined on a dotted rule.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Analogy between Dotted Trees and Dotted Rules", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "A state s = [a, dot , pos , i,j, k , I, sat?] can also be written as the corresponding dotted rule associated with the in dices i,j, k, I and the flag sat?: [i,j, k , I, sat?] where TJo = (a, u) and T/p", |
| "cite_spans": [ |
| { |
| "start": 12, |
| "end": 45, |
| "text": "[a, dot , pos , i,j, k , I, sat?]", |
| "ref_id": null |
| }, |
| { |
| "start": 157, |
| "end": 175, |
| "text": "[i,j, k , I, sat?]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Analogy between Dotted Trees and Dotted Rules", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "T/o -+ 'f/1 \u2022 \u2022 \u2022 T/ y \u2022 T/ y +l \u2022 \u2022 \u2022 'f/z", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Analogy between Dotted Trees and Dotted Rules", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "= (a, u \u2022 p), p E [1, z]", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Analogy between Dotted Trees and Dotted Rules", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "Here u is the ad-dress of the parent node of the dotted node when the dot is above to the left or to the right, and where u = dot when the dot is below to the left or to the right.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Analogy between Dotted Trees and Dotted Rules", |
| "sec_num": "3.3" |
| }, |
| { |
| "text": "The algorithm collects states into a set C called a chart. The algorithm maintains an invariant that is satisfied for all states in the chart C. The cor rectness of the algorithm is a corollary of this in variant . The invariant is pictured in Figure 3 in terms of dotted trees. We informally describe it equivalently in terms of dotted rules. A state of the form: [i, j, k ,l, sat?] with TJo = (a, u) and T/ p = ( a, u . p) is in the chart if and only if the elementary tree a derives a tree such that :", |
| "cite_spans": [ |
| { |
| "start": 365, |
| "end": 383, |
| "text": "[i, j, k ,l, sat?]", |
| "ref_id": null |
| }, |
| { |
| "start": 413, |
| "end": 424, |
| "text": "( a, u . p)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 244, |
| "end": 252, |
| "text": "Figure 3", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Invariant of the Algorithm", |
| "sec_num": "3.4" |
| }, |
| { |
| "text": "'f/0 --+ 'f/1 \u2022\u2022\u2022TJ y \u2022 T/ y +1 \u2022\u2022 \u2022 TJz", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Invariant of the Algorithm", |
| "sec_num": "3.4" |
| }, |
| { |
| "text": "(", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Invariant of the Algorithm", |
| "sec_num": "3.4" |
| }, |
| { |
| "text": "1) 'f/1 \u2022 \u2022 \u2022 'f/ y \u21d2 \u20ac{!)' \u2022 a1 (2) (a, f) \u21d2 a i+l \u2022 \u2022 \u2022 ak", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Invariant of the Algorithm", |
| "sec_num": "3.4" |
| }, |
| { |
| "text": "where / is the address of the foot node of a. (2) only applies when the foot node of a (if there is one) is subsumed by one of the nodes 'f/ i ..", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Invariant of the Algorithm", |
| "sec_num": "3.4" |
| }, |
| { |
| "text": "When the pos = rb, the dot is at the end the dotted rule and if sat? = t the boundaries ai \u2022 \u2022 \u2022 a 1 include the string introduced by an adjunction on the dotted tree. 9 sat? = t indicates that an adjunction was rec ognized on the dotted node ( node at address dot in a). No more adjunction must be attempted on this node. 10 9 The algorithm will set sat? to t only when pos = rb. 10 The derivations in TAG disallow more than one auxil iary tree adjoined on the same node. ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": ". T/ y", |
| "sec_num": null |
| }, |
| { |
| "text": "The algorithm is a bottom-up parser that uses top-down information. It is a general recognizer for TAGs with adjunction constraints. Unlike the CKY-type algorithm for TAGs, it requires no con dition on the grammar: the elementary trees (ini tial or auxiliary) need not to be binary and they may have the empty string as frontier. The al gorithm given below is off-line: it needs to know the length n of the input string before starting any computation. However it can very easily be modified to an on-line algorithm by the use of an end-marker in the input string.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Recognizer", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "Initially, the chart C consists of all states of the form [a , 0, la, 0, -, -, 0, nil], with a an initial tree. These initial states correspond to d\ufffded initial trees with the dot above and to the left of the root node ( at address O).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Recognizer", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "Depending on the existing states in the chart C, new states are added to the chart by four proces sors until no more states can be added to the chart. The processors are: the Predictor, the Completor, the Adjunctor and the Scanner. If, in the final chart, there is a state corresponding to an initial tree completely recognized, i.e. witli the dot to the right and above the root node which spans the in put form position O to n (i.e. a state of the form [a, 0, ra, 0, -, -, n , \ufffd) , the input is recognized. The recognizer r6rT\ufffdGs follows:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Recognizer", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "Let G = (\"E, NT, I, A) be a TAG .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Recognizer", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "Let a1 \u2022 \u2022 \u2022 a n be the input string .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Recognizer", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "program recognizer", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Recognizer", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "begin C = {[a, 0, la, 0, -, -, 0, nil] I a E J }", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Recognizer", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "Apply one of the four processes on each state in the C unt il no more states can be added to the C: 1. Scanner 2. Predictor 3. Completor 4. Adjunctor If there is a state of the form [a, 0, ra, 0, -, -, n, nil] in C with a E J then return acceptance otherwise return rej ection . end .", |
| "cite_spans": [ |
| { |
| "start": 182, |
| "end": 209, |
| "text": "[a, 0, ra, 0, -, -, n, nil]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Recognizer", |
| "sec_num": "3.5" |
| }, |
| { |
| "text": "C={ [a, 0 , la, 0, -, -, 0, nil] la E J } puts all initial trees with the dot to the left and above the root node. The four processes are ex plained one by one in the four next sections.", |
| "cite_spans": [ |
| { |
| "start": 4, |
| "end": 32, |
| "text": "[a, 0 , la, 0, -, -, 0, nil]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The initialization step", |
| "sec_num": null |
| }, |
| { |
| "text": "The Scanner is a bottom-up processor that scans the input string. It applies when the dot is to the left and above a terminal symbol. It consists of two cases: one when the terminal is not the empty string, and the other when it is. Scanner (see Figure 4) : It applies to a state of the form \u2022s = [a, dot,la, i,j, k, l, nil] such that a(dot) E \ufffd u {l} .", |
| "cite_spans": [ |
| { |
| "start": 297, |
| "end": 324, |
| "text": "[a, dot,la, i,j, k, l, nil]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 246, |
| "end": 255, |
| "text": "Figure 4)", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "1 Scanner", |
| "sec_num": "3.5." |
| }, |
| { |
| "text": "\u2022 Case 1: a(dot) = a1+1", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "1 Scanner", |
| "sec_num": "3.5." |
| }, |
| { |
| "text": "The stat e s= [a, dot,ra, i,j, k, l+l ,nil] is added to C.", |
| "cite_spans": [ |
| { |
| "start": 14, |
| "end": 43, |
| "text": "[a, dot,ra, i,j, k, l+l ,nil]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "1 Scanner", |
| "sec_num": "3.5." |
| }, |
| { |
| "text": "\u2022 Case 2: a(dot) = f. (empty string)", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "1 Scanner", |
| "sec_num": "3.5." |
| }, |
| { |
| "text": "The stat e s [a, dot,ra, i, j, k, l, nil] is added to C. (Schabes and Joshi, 1988) .", |
| "cite_spans": [ |
| { |
| "start": 13, |
| "end": 41, |
| "text": "[a, dot,ra, i, j, k, l, nil]", |
| "ref_id": null |
| }, |
| { |
| "start": 57, |
| "end": 82, |
| "text": "(Schabes and Joshi, 1988)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "1 Scanner", |
| "sec_num": "3.5." |
| }, |
| { |
| "text": "Predictor (see Figure 5 ) :", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 15, |
| "end": 23, |
| "text": "Figure 5", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Predictor", |
| "sec_num": "3.5.2" |
| }, |
| { |
| "text": "\u2022 Step 1 appl ies to a state of the form s = [a, dot, la, i,j, k, l, = [a , dot , la, i,j, k,l, nil] such that a( dot) E NT and the node at address dot in a has no obligatory adj oining constraint .", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 41, |
| "end": 68, |
| "text": "s = [a, dot, la, i,j, k, l,", |
| "ref_id": null |
| }, |
| { |
| "start": 69, |
| "end": 100, |
| "text": "= [a , dot , la, i,j, k,l, nil]", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Predictor", |
| "sec_num": "3.5.2" |
| }, |
| { |
| "text": "If the conditiens are satisfied, the state [a, dot, lb(i,j) , z,/nil] is added to \ufffd c. = [a , dot , lb, i\ufffd 1, nil] such that such that a E A, and such that dot is the address of the foot node of a.", |
| "cite_spans": [ |
| { |
| "start": 43, |
| "end": 59, |
| "text": "[a, dot, lb(i,j)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 87, |
| "end": 114, |
| "text": "= [a , dot , lb, i\ufffd 1, nil]", |
| "ref_id": "FIGREF1" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Predictor", |
| "sec_num": "3.5.2" |
| }, |
| { |
| "text": "If the conditions are satisfied, for all elementary trees 6 E JU A and for all addresses dot' in 6 such that a E Adjunct( 6, dot'), the state [6 {p) lb, l, -,-,l, nil] is added to C.", |
| "cite_spans": [ |
| { |
| "start": 142, |
| "end": 167, |
| "text": "[6 {p) lb, l, -,-,l, nil]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "\u2022 Step 3 appl ies to a \ufffd \ufffde of the form s", |
| "sec_num": null |
| }, |
| { |
| "text": "(1)", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "\u2022 Step 3 appl ies to a \ufffd \ufffde of the form s", |
| "sec_num": null |
| }, |
| { |
| "text": "(3) ij,k,l,n il] [ I,-,-,l,nil] (2)", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 4, |
| "end": 16, |
| "text": "ij,k,l,n il]", |
| "ref_id": null |
| }, |
| { |
| "start": 19, |
| "end": 31, |
| "text": "I,-,-,l,nil]", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "\u2022 Step 3 appl ies to a \ufffd \ufffde of the form s", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 (1) A \ufffd [", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "\u2022 Step 3 appl ies to a \ufffd \ufffde of the form s", |
| "sec_num": null |
| }, |
| { |
| "text": "[ ij,k,l,nil] [I,-,-,I ,nil] -,-,1,nil] Predictor.", |
| "cite_spans": [ |
| { |
| "start": 30, |
| "end": 40, |
| "text": "-,-,1,nil]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 2, |
| "end": 23, |
| "text": "ij,k,l,nil] [I,-,-,I", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "\u2022 Step 3 appl ies to a \ufffd \ufffde of the form s", |
| "sec_num": null |
| }, |
| { |
| "text": "A ( 3) [l,", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "\u2022 Step 3 appl ies to a \ufffd \ufffde of the form s", |
| "sec_num": null |
| }, |
| { |
| "text": "The Co mpletor is a bottom-up processor that com bines two states to form another state that spans a bi gg er portion of the input. It consists of three possibly non-exclusive steps that apply when the dot is at position rb (right below).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Completor", |
| "sec_num": "3.5.3" |
| }, |
| { |
| "text": "Step 1 considers that the next token comes from the part to the right of the foot node of an auxiliary tree adjoined on the dotted node. Steps 2 and 3 try to further recognize the same tree and concatenate boundaries of two states.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Completor", |
| "sec_num": "3.5.3" |
| }, |
| { |
| "text": "Completor (see Figure 6 ) :", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 15, |
| "end": 23, |
| "text": "Figure 6", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Completor", |
| "sec_num": "3.5.3" |
| }, |
| { |
| "text": "\u2022", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Completor", |
| "sec_num": "3.5.3" |
| }, |
| { |
| "text": "Step 1 combines a state of the form s 1 [a, dot , rb, i,j,-k, 1, nil] such that a(dot) E NT , with a state s2 = [,B, dot',lb, i, -,-,i,nil] such that /3 E Adjunct(a, dot) and such that dot' is the address of the foot node of (3. It adds the state [,B, dot',rb, i, i, l, l, nil] to C.", |
| "cite_spans": [ |
| { |
| "start": 40, |
| "end": 69, |
| "text": "[a, dot , rb, i,j,-k, 1, nil]", |
| "ref_id": null |
| }, |
| { |
| "start": 112, |
| "end": 139, |
| "text": "[,B, dot',lb, i, -,-,i,nil]", |
| "ref_id": null |
| }, |
| { |
| "start": 247, |
| "end": 277, |
| "text": "[,B, dot',rb, i, i, l, l, nil]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Completor", |
| "sec_num": "3.5.3" |
| }, |
| { |
| "text": "\u2022 Step 2 combines a state of \u2022 the form s 1 = [a , dot , rb, i,j, k, 1, sat?] such that a( dot) E NT, and s. t. the node at address dot in a subsumes the foot node of a, with a state s2 [a, dot , la, h, -,-,i, nil] . It adds the state [a, dot , ra, h, j, k, 1, nil] to C.", |
| "cite_spans": [ |
| { |
| "start": 46, |
| "end": 77, |
| "text": "[a , dot , rb, i,j, k, 1, sat?]", |
| "ref_id": null |
| }, |
| { |
| "start": 186, |
| "end": 214, |
| "text": "[a, dot , la, h, -,-,i, nil]", |
| "ref_id": null |
| }, |
| { |
| "start": 235, |
| "end": 265, |
| "text": "[a, dot , ra, h, j, k, 1, nil]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Completor", |
| "sec_num": "3.5.3" |
| }, |
| { |
| "text": "\u2022", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Completor", |
| "sec_num": "3.5.3" |
| }, |
| { |
| "text": "Step 3 combines a state of the form s 1 = [a,dot, rb, i,j, k, l, sat?] [a , dot, la, h,j, k,i,nil] . It adds the state [a, dot , ra, h, j, k, 1, nil] to C.", |
| "cite_spans": [ |
| { |
| "start": 42, |
| "end": 70, |
| "text": "[a,dot, rb, i,j, k, l, sat?]", |
| "ref_id": null |
| }, |
| { |
| "start": 71, |
| "end": 98, |
| "text": "[a , dot, la, h,j, k,i,nil]", |
| "ref_id": null |
| }, |
| { |
| "start": 119, |
| "end": 149, |
| "text": "[a, dot , ra, h, j, k, 1, nil]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Completor", |
| "sec_num": "3.5.3" |
| }, |
| { |
| "text": "The Adjunctor is a bottom-up processor that com bines two states by adjunction to form a state that spans a bigger portion of the input. It consists of a single step. Adjunctor (see Figure 7) :", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 182, |
| "end": 191, |
| "text": "Figure 7)", |
| "ref_id": "FIGREF7" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Adjunctor", |
| "sec_num": "3.5.4" |
| }, |
| { |
| "text": "It combines combines a state of the form s 1 = [/3, 0, r , i, j, k, 1, nil] and a state s 2 = [a, dot , rb,j, m, n, k, nil] such that /3 E Adjunct(a, dot) . It adds the state [a, dot , rb, i, m, n, k, true] to C.", |
| "cite_spans": [ |
| { |
| "start": 47, |
| "end": 75, |
| "text": "[/3, 0, r , i, j, k, 1, nil]", |
| "ref_id": null |
| }, |
| { |
| "start": 94, |
| "end": 123, |
| "text": "[a, dot , rb,j, m, n, k, nil]", |
| "ref_id": null |
| }, |
| { |
| "start": 175, |
| "end": 206, |
| "text": "[a, dot , rb, i, m, n, k, true]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Adjunctor", |
| "sec_num": "3.5.4" |
| }, |
| { |
| "text": "We giv\ufffd an example that illustrates how the rec ognizer works. The grammar used for the exam ple ( see Figure 8 ) generates the language L = {a n b n ec n d n ln \ufffd 0} . The grammar consists of an initial tree a and an auxiliary tree /3. There is a null adjoining constraint on the root node and the foot node of /3.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 103, |
| "end": 111, |
| "text": "Figure 8", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "An Example", |
| "sec_num": "3.6" |
| }, |
| { |
| "text": "The input string given to the recognizer is: aabbeccdd. The corresponding chart is shown in Figure 9 . For purpose of explanation, we have preceded each state with a number that uniquely identifies the state and we followed the state with the operation(s) that caused it t9 be placed into the chart. We used the following abbreviations: init for the initialization step, pred(k) for the Pre dictor applied to the state numbered by k, sc(k) for the Scanner applied to the state numbered by k, compl(k+l) for the combination with the Comple tor of the states numbered by k and I and adj(k+l) for the combination with the Adjunctor of the states numbered by k and I. With this conven tion, one can trace step by step the building of the chart . For example, 31. [/3, dot : 2, rb, l, 4, 5, 8, t] adj(30+24) stands for the state [/3, dot : 2, rb, 1,4, 5, 8,t] uniquely identified by the number 31 which was placed into the chart by combining with the Ad junctor the states identified by the numbers 30 and 24.", |
| "cite_spans": [ |
| { |
| "start": 742, |
| "end": 754, |
| "text": "For example,", |
| "ref_id": null |
| }, |
| { |
| "start": 755, |
| "end": 763, |
| "text": "31. [/3,", |
| "ref_id": null |
| }, |
| { |
| "start": 764, |
| "end": 772, |
| "text": "dot : 2,", |
| "ref_id": null |
| }, |
| { |
| "start": 773, |
| "end": 776, |
| "text": "rb,", |
| "ref_id": null |
| }, |
| { |
| "start": 777, |
| "end": 779, |
| "text": "l,", |
| "ref_id": null |
| }, |
| { |
| "start": 780, |
| "end": 782, |
| "text": "4,", |
| "ref_id": null |
| }, |
| { |
| "start": 783, |
| "end": 785, |
| "text": "5,", |
| "ref_id": null |
| }, |
| { |
| "start": 786, |
| "end": 788, |
| "text": "8,", |
| "ref_id": null |
| }, |
| { |
| "start": 789, |
| "end": 791, |
| "text": "t]", |
| "ref_id": null |
| }, |
| { |
| "start": 824, |
| "end": 854, |
| "text": "[/3, dot : 2, rb, 1,4, 5, 8,t]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 92, |
| "end": 100, |
| "text": "Figure 9", |
| "ref_id": "FIGREF8" |
| } |
| ], |
| "eq_spans": [], |
| "section": "An Example", |
| "sec_num": "3.6" |
| }, |
| { |
| "text": "The input is recognized since [a , 0 , right, above, 0, -, -, 9 , nil] is in the chart C.", |
| "cite_spans": [ |
| { |
| "start": 30, |
| "end": 70, |
| "text": "[a , 0 , right, above, 0, -, -, 9 , nil]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "An Example", |
| "sec_num": "3.6" |
| }, |
| { |
| "text": "The algorithm described in Section 3.5 can be \u2022implemented to follow an arbitrary search space strategy by using a priority function that ranks the states to be processed. The ranking function can also be defined to obtain a left to right behav ior as in (Earley, 1968) . Such a function may also very well be of statistical nature as for example in (Magerman and Marcus, 1991) .", |
| "cite_spans": [ |
| { |
| "start": 255, |
| "end": 269, |
| "text": "(Earley, 1968)", |
| "ref_id": "BIBREF0" |
| }, |
| { |
| "start": 350, |
| "end": 377, |
| "text": "(Magerman and Marcus, 1991)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "7 Implementation", |
| "sec_num": "3." |
| }, |
| { |
| "text": "In order to bound the worst case complexity as stated in the next section, arrays must be used to implement efficiently the diffe rent processors. Due to the lack of space, we do not include the details of such implementation in this paper but they are found in (Schabes , 1991) .", |
| "cite_spans": [ |
| { |
| "start": 262, |
| "end": 278, |
| "text": "(Schabes , 1991)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "7 Implementation", |
| "sec_num": "3." |
| }, |
| { |
| "text": "The algorithm is a general parser for TAGs with constraints on adjunction that takes in worst case O(IGl 2 Nn 6 ) time and O(IGINn 4 ) space, n being the length of the input string, IGI the number of elementary trees in the grammar and N the maxi mum number of nodes in an elementary tree. The worst case complexity comes from the Adjunctor processor. An intuition of the validity of this re sult can be obtained by observing that that this processor (see Section 3.5.4) may be called at most IGl 2 N n 6 time since there are at most n 6 instances of the indices (i,j, k,l, m,n) and at most IGl 2 N pairs of dotted trees to combine (a, /3, dot). When it is used with unambiguous tree-adjoining gram mars, the algorithm takes at most O(IGl 2 Nn 4 ) time 11 and linear time on a large class of gram mars.", |
| "cite_spans": [ |
| { |
| "start": 563, |
| "end": 578, |
| "text": "(i,j, k,l, m,n)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness and Complexity", |
| "sec_num": "3.8" |
| }, |
| { |
| "text": "The proof of correctness consists in the proof of the invariant stated in Section 3.4.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness and Complexity", |
| "sec_num": "3.8" |
| }, |
| { |
| "text": "Due to the lack of space, the details of the proofs of correctness and complexity are not given in this paper, but they are found in Schabes (1991).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness and Complexity", |
| "sec_num": "3.8" |
| }, |
| { |
| "text": "The algorithm that we described in section :3.5 is a recognizer. However, if we include pointers from a state to the other states ( to a pair of states for the Completor and the Adjunctor or to a state for the Scanner and the Predictor) which caused it to be placed in the chart (in a similar manner to that shown in Figure 9 ) , the recognizer can be modi fied to record all parse trees of the input string. The representation is similar to a shared forest. The worst case time complexity for the parser is the same as for the recognizer (O(IGl 2 Nn 6 )-time) but the worst case space complexity increases to O(IGl 2 Nn 6 )-space.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 317, |
| "end": 325, |
| "text": "Figure 9", |
| "ref_id": "FIGREF8" |
| } |
| ], |
| "eq_spans": [], |
| "section": "The Parser", |
| "sec_num": "3.9" |
| }, |
| { |
| "text": "The algorithm has been modified to handle exten sions of TAGs such as substitution (Schabes et al., 1988) , unification based TAGs (Vijay-Shanker and Joshi, 1988; Vijay-Shanker, 199 1) and a version of multiple component TAG (see Schabes, 1990 , for details on how to modify the parser to. handle these extensions). It can also take advantage of lexicalized TAGs (Schabes and Joshi, 1989 [a, dot : 0 , la, 0 , -, -, 0, nil] init 3. [a, dot : 1 , la, 0, -, -, 0, nil] pred{l) 5. [, 8 , dot : 2, la, 0, -, -, 1 , nil] sc(4) _z__t,a.,_. daL :-2. l, la,-l, -,_ :-, 1,nil] pred{5) 9. [, 8 , dot : 2, la, 1, -, -, 2, nil] sc{8} 11. [,B, dot : 2,-,-, 3 .,-ni]\ufffd_\u00a3@ __ 2. [, 8, dot : 0, la, 0, -, -, 0, nil] ", |
| "cite_spans": [ |
| { |
| "start": 83, |
| "end": 105, |
| "text": "(Schabes et al., 1988)", |
| "ref_id": null |
| }, |
| { |
| "start": 230, |
| "end": 243, |
| "text": "Schabes, 1990", |
| "ref_id": null |
| }, |
| { |
| "start": 358, |
| "end": 387, |
| "text": "TAGs (Schabes and Joshi, 1989", |
| "ref_id": null |
| }, |
| { |
| "start": 388, |
| "end": 466, |
| "text": "[a, dot : 0 , la, 0 , -, -, 0, nil] init 3. [a, dot : 1 , la, 0, -, -, 0, nil]", |
| "ref_id": null |
| }, |
| { |
| "start": 478, |
| "end": 515, |
| "text": "[, 8 , dot : 2, la, 0, -, -, 1 , nil]", |
| "ref_id": null |
| }, |
| { |
| "start": 579, |
| "end": 636, |
| "text": "[, 8 , dot : 2, la, 1, -, -, 2, nil] sc{8} 11. [,B, dot :", |
| "ref_id": null |
| }, |
| { |
| "start": 637, |
| "end": 645, |
| "text": "2,-,-, 3", |
| "ref_id": null |
| }, |
| { |
| "start": 663, |
| "end": 698, |
| "text": "[, 8, dot : 0, la, 0, -, -, 0, nil]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Extensions", |
| "sec_num": "3.10" |
| }, |
| { |
| "text": ", la 2, -, -, 2, nil] pred{9) \ufffd ,4.a \u2022", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Extensions", |
| "sec_num": "3.10" |
| }, |
| { |
| "text": "pred{l) ,{ .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Extensions", |
| "sec_num": "3.10" |
| }, |
| { |
| "text": "[.8, dot '. 1 , la, 0 , -, -, 0, n\ufffdl] p_ red(g) _ ( \u00a7) [,B, dot . 0, la, 1, -, -, 1, nil] pred{5) -1:.._ [P, dot \ufffd) , [a, 1 , -, -, 1 , nil] [.8, dot : O, /a\u2022, -2, -,-.:_\ufffd\u2022 2, nil] pred (9} 12. [.8, dot : 1 , la, 2, --, 2 , nil] pred{10) \ufffd .\u00a3 r,B; a o r: -2.2, lb, 3, -, -, 3_ , nil ] 15. [,B,( \ufffd la, 3 ,: -, -, 3, n \ufffd l] pred(14) 17.", |
| "cite_spans": [ |
| { |
| "start": 55, |
| "end": 97, |
| "text": "[,B, dot . 0, la, 1, -, -, 1, nil] pred{5)", |
| "ref_id": null |
| }, |
| { |
| "start": 105, |
| "end": 115, |
| "text": "[P, dot \ufffd)", |
| "ref_id": null |
| }, |
| { |
| "start": 118, |
| "end": 140, |
| "text": "[a, 1 , -, -, 1 , nil]", |
| "ref_id": null |
| }, |
| { |
| "start": 141, |
| "end": 221, |
| "text": "[.8, dot : O, /a\u2022, -2, -,-.:_\ufffd\u2022 2, nil] pred (9} 12. [.8, dot : 1 , la, 2, --, 2", |
| "ref_id": null |
| }, |
| { |
| "start": 240, |
| "end": 284, |
| "text": ".\u00a3 r,B; a o r: -2.2, lb, 3, -, -, 3_ , nil ]", |
| "ref_id": null |
| }, |
| { |
| "start": 289, |
| "end": 330, |
| "text": "[,B,( \ufffd la, 3 ,: -, -, 3, n \ufffd l] pred(14)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Extensions", |
| "sec_num": "3.10" |
| }, |
| { |
| "text": "\ufffd' la, 3, -:-. -=.d ., _nzlJ. s _E{15)_", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "1I", |
| "sec_num": null |
| }, |
| { |
| "text": "19. [,B, do\ufffd\ufffd -1, \ufffd -. , -==-, -\ufffd , ni /] . P-\ufffd d{l 8 ) __ j 21. [a , dot : 0, rb, 4, -, -, 5, nil] sc{20 } .-, , . \u2022\u2022 \ufffd 16 . ra;ilot : 1 , \ufffd3, -, -, 3, nil] pred (14) \ufffd .[\ufffd, dot : 2.2 lb 4, -_, -4,m/] pm/{17) \ufffd [a, dot : 1 , la, 4, -, -, 4 , nil] pred{18}", |
| "cite_spans": [ |
| { |
| "start": 4, |
| "end": 41, |
| "text": "[,B, do\ufffd\ufffd -1, \ufffd -. , -==-, -\ufffd , ni /]", |
| "ref_id": null |
| }, |
| { |
| "start": 65, |
| "end": 123, |
| "text": "[a , dot : 0, rb, 4, -, -, 5, nil] sc{20 } .-, , . \u2022\u2022 \ufffd 16", |
| "ref_id": null |
| }, |
| { |
| "start": 163, |
| "end": 167, |
| "text": "(14)", |
| "ref_id": null |
| }, |
| { |
| "start": 210, |
| "end": 240, |
| "text": "\ufffd [a, dot : 1 , la, 4, -, -, 4", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "1I", |
| "sec_num": null |
| }, |
| { |
| "text": "WJ\u00b5\ufffd \ufffd9..L =...\ufffd. \ufffd.t r _ b .1.. i 1 i&i . , nil comp_{ _#l + 18 l 23. [,B, dot : 2.3, la, 3, 4, 5, 5, \ufffd ii) compl{_ !2 ' 1 J 24. [,B, dot : 2, rb, 3, 4 , 5 , 6 , nil] sc{23 } \u2022-25 . [.8, dot : 2.2, rb, 3, 3, 6 , 6, nil] compl{24+14) 26. [,B, dot : 2.3, la, 2, 3, 6 , 6, nil] compl{2 5+13) 27. [,B, dot :: 2, rb, 2; 3, 6 , 7 , nil] sc{26) 29. [,B, dot : 0, rb, 1 , 3 , 6, 8, nil] sc{28) 31. [,B, dot : 2, rb, 1 , 4, 5, 8, t] adj{30+24) 33. [,B, dot : 0, rb, 0, 4, 5 , 9 , nil] sc{32) 35.", |
| "cite_spans": [ |
| { |
| "start": 71, |
| "end": 160, |
| "text": "[,B, dot : 2.3, la, 3, 4, 5, 5, \ufffd ii) compl{_ !2 ' 1 J 24. [,B, dot : 2, rb, 3, 4 , 5 , 6", |
| "ref_id": null |
| }, |
| { |
| "start": 176, |
| "end": 180, |
| "text": "\u2022-25", |
| "ref_id": null |
| }, |
| { |
| "start": 183, |
| "end": 233, |
| "text": "[.8, dot : 2.2, rb, 3, 3, 6 , 6, nil] compl{24+14)", |
| "ref_id": null |
| }, |
| { |
| "start": 238, |
| "end": 275, |
| "text": "[,B, dot : 2.3, la, 2, 3, 6 , 6, nil]", |
| "ref_id": null |
| }, |
| { |
| "start": 294, |
| "end": 324, |
| "text": "[,B, dot :: 2, rb, 2; 3, 6 , 7", |
| "ref_id": null |
| }, |
| { |
| "start": 343, |
| "end": 379, |
| "text": "[,B, dot : 0, rb, 1 , 3 , 6, 8, nil]", |
| "ref_id": null |
| }, |
| { |
| "start": 391, |
| "end": 424, |
| "text": "[,B, dot : 2, rb, 1 , 4, 5, 8, t]", |
| "ref_id": null |
| }, |
| { |
| "start": 440, |
| "end": 469, |
| "text": "[,B, dot : 0, rb, 0, 4, 5 , 9", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "1I", |
| "sec_num": null |
| }, |
| { |
| "text": "[a , dot : 0, rb, 0, -, -, 9 , t] adj 34+21)", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "1I", |
| "sec_num": null |
| }, |
| { |
| "text": "28. [,B, dot : 3, la, 1 , 3, 6, 7, nil] compl{26+9) 30. [,B, dot : 0, ra, 1, 3, 6, 8 , nil] compl{28+6) 32. [,B, dot : 3,la, 0,4, 5 , 8,nil) compl{31 +5)", |
| "cite_spans": [ |
| { |
| "start": 4, |
| "end": 51, |
| "text": "[,B, dot : 3, la, 1 , 3, 6, 7, nil] compl{26+9)", |
| "ref_id": null |
| }, |
| { |
| "start": 56, |
| "end": 103, |
| "text": "[,B, dot : 0, ra, 1, 3, 6, 8 , nil] compl{28+6)", |
| "ref_id": null |
| }, |
| { |
| "start": 108, |
| "end": 140, |
| "text": "[,B, dot : 3,la, 0,4, 5 , 8,nil)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "1I", |
| "sec_num": null |
| }, |
| { |
| "text": "34. [,B, dot : 0 , ra, 0, 4, 5 , 9 , nil] compl{33+2) 36.", |
| "cite_spans": [ |
| { |
| "start": 4, |
| "end": 53, |
| "text": "[,B, dot : 0 , ra, 0, 4, 5 , 9 , nil] compl{33+2)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "1I", |
| "sec_num": null |
| }, |
| { |
| "text": "[a , dot : 0, ra, 0, -, -, 9 , nil] compl{35+1) ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "1I", |
| "sec_num": null |
| }, |
| { |
| "text": "We have shown that maintaining the valid prefix property for TAG parsing is costly because of the context-freeness of the path set of TA G derived trees.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": "4" |
| }, |
| { |
| "text": "In 1988, Schabes and Joshi introduced an Earley-style parser that satisfies the VPP how ever at a cost to its complexity ( 0( n 9 )-time in the worst case but linear on some gr:ammars). To our knowledge, it is the only known polynomial time parser for TAG which satisfies the valid prefix property.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": "4" |
| }, |
| { |
| "text": "We have introduced a predictive left to right parser for TAGs which does not maintain the valid prefix property but takes at most 0(n 6 )-time in the worst case, 0( n 4 )-time for unambiguous gram mars, and can behave linearly on some classes of grammars. The parser which we introduced is a practical parser since it often behaves better than its worst case complexity. It has been extended to handle extensions of TAGs such as unification based TAG and a restricted version of multiple component TAGs.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": "4" |
| }, |
| { |
| "text": "This predictive left to right parser can be adapted to other grammatical formalisms w\ufffdakly equivalent to tree-adjoining languages (Joshi et al. , Forthcoming 1990 ) such as linear index gram mar, head grammars and a version of combinatory categorial grammars.", |
| "cite_spans": [ |
| { |
| "start": 130, |
| "end": 162, |
| "text": "(Joshi et al. , Forthcoming 1990", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": "4" |
| }, |
| { |
| "text": "This result follows from Thatcher's work (1971), which defines frontier to root fini te state tree automata.3 We assume familiarity with tree-adjoining grammars.See, for instance, the introduction by Joshi(Joshi, 1987). 4 The parser is also reported in Vijay-Shanker (1987) . 5 However, this algorithm is not a practical parser for TAGs because, as is well known for CFGs, the average be havior of CKY-type parsers is the same as the worst case behavior.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| }, |
| { |
| "text": "We could have chosen to group the states into state sets as in (Earley, 1968) but we chose not to, allowing us to define an agenda driven parser.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| }, |
| { |
| "text": "This is a new upper-bound of the complexity of unam-bi gu ous TAG .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| } |
| ], |
| "back_matter": [], |
| "bib_entries": { |
| "BIBREF0": { |
| "ref_id": "b0", |
| "title": "An Effi cient Context-Free Parsing Algorithm", |
| "authors": [ |
| { |
| "first": "Jay", |
| "middle": [ |
| "C" |
| ], |
| "last": "Earley", |
| "suffix": "" |
| } |
| ], |
| "year": 1968, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Jay C. Earley. 1968. An Effi cient Context-Free Parsing Algorithm. Ph.D. thesis, Carnegie- Mellon University, Pittsburgh, PA . . .,", |
| "links": null |
| }, |
| "BIBREF1": { |
| "ref_id": "b1", |
| "title": "An efficient context-free parsing algorithm", |
| "authors": [ |
| { |
| "first": "Jay", |
| "middle": [ |
| "C" |
| ], |
| "last": "Earley", |
| "suffix": "" |
| } |
| ], |
| "year": 1970, |
| "venue": "Commun. ACM", |
| "volume": "13", |
| "issue": "2", |
| "pages": "94--102", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Jay C. Earley. 1970. An efficient context-free parsing algorithm. Commun. ACM, 13(2):94- 102.", |
| "links": null |
| }, |
| "BIBREF2": { |
| "ref_id": "b2", |
| "title": "Explicit definitions and linguis tic dominoes", |
| "authors": [ |
| { |
| "first": "", |
| "middle": [], |
| "last": "Saul Gorn", |
| "suffix": "" |
| } |
| ], |
| "year": 1965, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Saul Gorn. 1965. Explicit definitions and linguis tic dominoes. In John Hart and Satoru Takasu, editors, Systems and Computer Science. Univer sity of Toronto Press, Toronto, Canada.", |
| "links": null |
| }, |
| "BIBREF3": { |
| "ref_id": "b3", |
| "title": "An efficient parsing al gorithm for Tree Adjoining Grammars", |
| "authors": [ |
| { |
| "first": "Karen", |
| "middle": [], |
| "last": "Harbusch", |
| "suffix": "" |
| } |
| ], |
| "year": 1990, |
| "venue": "28 th Meeting of the Association fo r Computational Linguistics ( AGL '90 }", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Karen Harbusch . . 1990. An efficient parsing al gorithm for Tree Adjoining Grammars. In 28 th Meeting of the Association fo r Computational Linguistics ( AGL '90 }, Pittsburgh.", |
| "links": null |
| }, |
| "BIBREF4": { |
| "ref_id": "b4", |
| "title": "Vij ay-Shanker, and David We ir. Forthcoming, 1990. The convergence of mildly context-sensitive grammatical for malisms", |
| "authors": [ |
| { |
| "first": "K", |
| "middle": [], |
| "last": "Aravind", |
| "suffix": "" |
| }, |
| { |
| "first": "K", |
| "middle": [], |
| "last": "Joshi", |
| "suffix": "" |
| } |
| ], |
| "year": null, |
| "venue": "Fo undational Issues in Natual Language Processing", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Aravind K. Joshi, K. Vij ay-Shanker, and David We ir. Forthcoming, 1990. The convergence of mildly context-sensitive grammatical for malisms. In Peter Sells, Stuart Shieber, and Tom Wasow, editors, Fo undational Issues in Natual Language Processing. MIT Press, Cam bridge MA.", |
| "links": null |
| }, |
| "BIBREF5": { |
| "ref_id": "b5", |
| "title": "An Introduction to Tree Adjoining Grammars", |
| "authors": [ |
| { |
| "first": "K", |
| "middle": [], |
| "last": "Aravind", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Joshi", |
| "suffix": "" |
| } |
| ], |
| "year": 1987, |
| "venue": "Mathematics of Language. John Ben jamins", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Aravind K. Joshi. 1987. An Introduction to Tree Adjoining Grammars. In A. Manaster-Ramer, editor, Mathematics of Language. John Ben jamins, Amsterdam.", |
| "links": null |
| } |
| }, |
| "ref_entries": { |
| "FIGREF0": { |
| "uris": null, |
| "text": "an O(n 4 log(n)) worst time general TAG parser based on the CKY parser for CFGs. However, since the paper does not include a proof of correctness and com plexity, the relationship between the parser and the set of", |
| "type_str": "figure", |
| "num": null |
| }, |
| "FIGREF1": { |
| "uris": null, |
| "text": "Above, a sequence of adjunctions; be low left, bottom-up recognition of the derived tree; right, left to right recognition of the derived tree.", |
| "type_str": "figure", |
| "num": null |
| }, |
| "FIGREF2": { |
| "uris": null, |
| "text": "Left, left to right tree traversal; right, equivalent dot positions.", |
| "type_str": "figure", |
| "num": null |
| }, |
| "FIGREF3": { |
| "uris": null, |
| "text": "\u2022 \u2022\u2022an and the tree adjoining grammar is G = (E, NT, I, A): Ei s the finite set of terminal symbols, NT is the set of non-terminal symbols (E n NT = 0), I is the set of initial trees and A is the set of auxiliary trees.The algorithm uses one data structure: a state.7 A state s is defined as an 8-tuple,", |
| "type_str": "figure", |
| "num": null |
| }, |
| "FIGREF4": { |
| "uris": null, |
| "text": "k, l are indices of positions in the input string ranging over {O, \u2022 \u2022 \u2022, n} U {-}, n being the length of the input string and -indicating that the index is not bound.", |
| "type_str": "figure", |
| "num": null |
| }, |
| "FIGREF5": { |
| "uris": null, |
| "text": "Figure 3: Invariant .", |
| "type_str": "figure", |
| "num": null |
| }, |
| "FIGREF6": { |
| "uris": null, |
| "text": "Figure 4: Scanner.", |
| "type_str": "figure", |
| "num": null |
| }, |
| "FIGREF7": { |
| "uris": null, |
| "text": "Adjui:ictor.", |
| "type_str": "figure", |
| "num": null |
| }, |
| "FIGREF8": { |
| "uris": null, |
| "text": "States constituting the chart for the input: o a 1 a 2 b 3 b 4 e s c 6 c 1 d s d 9", |
| "type_str": "figure", |
| "num": null |
| }, |
| "TABREF1": { |
| "html": null, |
| "text": "", |
| "num": null, |
| "content": "<table><tr><td>a(dot) E NT .</td><td>nil] such that</td></tr><tr><td colspan=\"2\">If the conditions are satisfied , the states {[,B, 0, la, l, -, -, 1, nil]l,B E Adjunct(a, dot) } are added to C.</td></tr></table>", |
| "type_str": "table" |
| }, |
| "TABREF3": { |
| "html": null, |
| "text": ").", |
| "num": null, |
| "content": "<table><tr><td>I Input read</td><td>1.</td><td>States if:i the chart</td></tr><tr><td>a</td><td/><td/></tr><tr><td>a</td><td/><td/></tr><tr><td>aa aa aab aab aabb</td><td/><td/></tr></table>", |
| "type_str": "table" |
| } |
| } |
| } |
| } |
