{ "paper_id": "P91-1015", "header": { "generated_with": "S2ORC 1.0.0", "date_generated": "2023-01-19T09:03:42.796064Z" }, "title": "Head Corner Parsing for Discontinuous Constituency", "authors": [ { "first": "Gertjan", "middle": [], "last": "Van Noord", "suffix": "", "affiliation": {}, "email": "vannoord@coli.uni-sb.de" } ], "year": "", "venue": null, "identifiers": {}, "abstract": "I describe a head-driven parser for a class of grammars that handle discontinuous constituency by a richer notion of string combination than ordinary concatenation. The parser is a generalization of the left-corner parser (Matsumoto et al., 1983) and can be used for grammars written in powerful formalisms such as non-concatenative versions of HPSG (Pollard, 1984; Reape, 1989).", "pdf_parse": { "paper_id": "P91-1015", "_pdf_hash": "", "abstract": [ { "text": "I describe a head-driven parser for a class of grammars that handle discontinuous constituency by a richer notion of string combination than ordinary concatenation. The parser is a generalization of the left-corner parser (Matsumoto et al., 1983) and can be used for grammars written in powerful formalisms such as non-concatenative versions of HPSG (Pollard, 1984; Reape, 1989).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Abstract", "sec_num": null } ], "body_text": [ { "text": "Although most formalisms in computational linguistics assume that phrases are built by string concatenation (eg. as in PATR II, GPSG, LFG and most versions of Categorial Grammar), this assumption is challenged in non-concatenative grammatical formalisms. In Pollard's dissertation several versions of 'qlead wrapping\" are defined (Pollard, 1984) . In the analysis of the Australian free word-order language Guugu Yimidhirr, Mark Johnson uses a 'combine' predicate in a DCG-like grammar that corresponds to the union of words (Johnson, 1985) . Mike Reape uses an operation called 'sequence union' to analyse Germanic semi-free word order constructions (l~ape, 1989; Reape, 1990a) . Other examples include Tree Adjoining Grammars (Joshi et al., 1975; Vijay-Shankar and Joshi, 1988) , and versions of Categorial Grammar (Dowry, 1990) and references cited there.", "cite_spans": [ { "start": 330, "end": 345, "text": "(Pollard, 1984)", "ref_id": "BIBREF7" }, { "start": 525, "end": 540, "text": "(Johnson, 1985)", "ref_id": "BIBREF2" }, { "start": 651, "end": 664, "text": "(l~ape, 1989;", "ref_id": null }, { "start": 665, "end": 678, "text": "Reape, 1990a)", "ref_id": null }, { "start": 728, "end": 748, "text": "(Joshi et al., 1975;", "ref_id": "BIBREF3" }, { "start": 749, "end": 779, "text": "Vijay-Shankar and Joshi, 1988)", "ref_id": "BIBREF16" }, { "start": 809, "end": 830, "text": "Grammar (Dowry, 1990)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "Motivation. There are several motivations for non-concatenative grammars. First, specialized string combination operations allow elegant linguistic accounts of phenomena that are otherwise notoriously hard. Examples are the analyses of Dutch cross serial dependencies by head wrapping or sequence union (Reape, 1990a) .", "cite_spans": [ { "start": 303, "end": 317, "text": "(Reape, 1990a)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "Furthermore, in non-concatenative grammars it is possible to relate (parts of) constituents that belong together semantically, but which are not adjacent. Hence such grammars facilitate a simple compositional semantics. In CF-based grammars such phenomena usually are treated by complex 'threading' mechanisms.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "Non-concatenative grammatical formalisms may also be attractive from a computational point of view. It is easier to define generation algorithms if the semantics is built in a systematically constrained way (van Noord, 1990b) . The semantic-head-driven generation strategy (van Noord, 1989; Calder ef al., 1989; Shieber et al., 1989; van Noord, 1990a; Shieber et al., 1990) faces problems in case semantic heads are 'displaced', and this displacement is analyzed using threading. However, in this paper I sketch a simple analysis of verb-second (an example of a displacement of semantic heads) by an operation similar to head wrapping which a headdriven generator processes without any problems (or extensions) at all. Clearly, there are also some computational problems, because most 'standard' parsing strategies assume context-free concatenation of strings. These problems are the subject of this paper.", "cite_spans": [ { "start": 207, "end": 225, "text": "(van Noord, 1990b)", "ref_id": null }, { "start": 273, "end": 290, "text": "(van Noord, 1989;", "ref_id": "BIBREF14" }, { "start": 291, "end": 311, "text": "Calder ef al., 1989;", "ref_id": null }, { "start": 312, "end": 333, "text": "Shieber et al., 1989;", "ref_id": "BIBREF12" }, { "start": 334, "end": 351, "text": "van Noord, 1990a;", "ref_id": null }, { "start": 352, "end": 373, "text": "Shieber et al., 1990)", "ref_id": "BIBREF13" } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "The task. I will restrict the attention to a class of constraint-based formalisms, in which operations on strings are defined that are more powerful than concatenation, but which operations are restricted to be nonerasing, and linear.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "The resulting class of systems can be characterized as Linear Context-Free Rewriting Systems (LCFRS), augmented with feature-structures (F-LCFRS). For a discussion of the properties of LCFRS without feature-structures, see (Vijay-Shanker et al., 1987) . Note though that these properties do not carry over to the current system, because of the augmention with feature structures.", "cite_spans": [ { "start": 223, "end": 251, "text": "(Vijay-Shanker et al., 1987)", "ref_id": "BIBREF17" } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "As in LCFRS, the operations on strings in F-LCFRS can be characterized as follows. First, derived structures will be mapped onto a set of occurances of words; i.e. each derived structure 'knows' which words it 'dominates'. For example, each derived feature structure may contain an attribute 'phon' whose value is a list of atoms representing the string it dominates. I will write w (F) for the set of occurances of words that the derived structure F dominates. Rules combine structures D1 ... Dn into a new structure M. Nonerasure requires that the union of w applied to each daughter is a subset of w(M):", "cite_spans": [ { "start": 383, "end": 386, "text": "(F)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "}I U w(Di) C_ w(M) i=l", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "Linearity requires that the difference of the cardinalities of these sets is a constant factor; i.e. a rule may only introduce a fixed number of words syncategorematically:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "Iw(M)l-I U w(Oi)) = c,c a constant i=1", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "CF-based formalisms clearly fulfill this requirement, as do Head Grammars, grammars using sequence union, and TAG's. I assume in the remainder of this paper that I.Jin=l w(Di) = w(M), for all rules other than lexical entries (i.e. all words are introduced on a terminal). Note though that a simple generalization of the algorithm presented below handles the general case (along the lines of Shieber et al. (1989; )by treating rules that introduce extra lexical material as nonchain-rules).", "cite_spans": [ { "start": 391, "end": 412, "text": "Shieber et al. (1989;", "ref_id": "BIBREF12" } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "Furthermore, I will assume that each rule has a designated daughter, called the head. Although I will not impose any restrictions on the head, it will turn out that the parsing strategy to be proposed will be very sensitive to the choice of heads, with the effect that F-LCFRS's in which the notion 'head' is defined in a systematic way (Pollard's Head Grammars, Reape's version of HPSG, Dowty's version of Categorial Grammar), may be much more efficiently parsed than other grammars. The notion seed of a parse tree is defined recursively in terms of the head. The seed of a tree will be the seed of its head. The seed of a terminal will be that terminal itself. Other approaches. In (Proudian and Pollard, 1985) a head-driven algorithm based on active chart parsing is described. The details of the algorithm are unclear from the paper which makes a comparison with our approach hard; it is not clear whether the parser indeed allows for example the head-wrapping operations of Pollard (1984) . Reape presented two algorithms (Reape, 1990b) which are generalizations of a shift-reduce parser, and the CKY algorithm, for the same class of grammars. I present a head-driven bottom-up algorithm for F-LCFR grammars. The algorithm resembles the head-driven parser by Martin Kay (Kay, 1989) , but is generalized in order to be used for this larger class of grammars. The disadvantages Kay noted for his parser do not carry over to this generalized version, as redundant search paths for CF-based grammars turn out to be genuine parts of the search space for F-LCFR grammars.", "cite_spans": [ { "start": 685, "end": 713, "text": "(Proudian and Pollard, 1985)", "ref_id": "BIBREF8" }, { "start": 980, "end": 994, "text": "Pollard (1984)", "ref_id": "BIBREF7" }, { "start": 1028, "end": 1042, "text": "(Reape, 1990b)", "ref_id": null }, { "start": 1276, "end": 1287, "text": "(Kay, 1989)", "ref_id": "BIBREF4" } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "The advantage of my algorithm is that it both employs bottom-up and top-down filtering in a straightforward way. The algorithm is closely related to head-driven generators (van Noord, 1989; Calder et al., 1989; Shieber et al., 1989; van Noord, 1990a; Shieber et ai., 1990) . The algorithm proceeds in a bottom-up, head-driven fashion. In modern linguistic theories very much information is defined in lexical entries, whereas rules are reduced to very general (and very uninformative) schemata. More information usually implies less search space, hence it is sensible to parse bottomup in order to obtain useful information as soon as possible. Furthermore, in many linguistic theories a special daughter called the head determines what kind of other daughters there may be. Therefore, it is also sensible to start with the head in order to know for what else you have to look for. As the parser proceeds from head to head it is furthermore possible to use powerful top-down predictions based on the usual head feature percolations. Finally note that proceding bottom-up solves some non-termination problems, because in lexicalized theories it is often the case that information in lexical entries limit the recursive application of rules (eg. the size of the subcat list of an entry determines the depth of the derivation tree of which this entry can be the seed).", "cite_spans": [ { "start": 172, "end": 189, "text": "(van Noord, 1989;", "ref_id": "BIBREF14" }, { "start": 190, "end": 210, "text": "Calder et al., 1989;", "ref_id": null }, { "start": 211, "end": 232, "text": "Shieber et al., 1989;", "ref_id": "BIBREF12" }, { "start": 233, "end": 250, "text": "van Noord, 1990a;", "ref_id": null }, { "start": 251, "end": 272, "text": "Shieber et ai., 1990)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "Before I present the parser in section 3, I will first present an example of a F-LCFR grammar, to obtain a flavor of the type of problems the parser handles reasonably well.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": "1" }, { "text": "In this section I present a simple F-LCFR grammar for a (tiny) fragment of Dutch. As a caveat I want to stress that the purpose of the current section is to provide an example of possible input for the parser to be defined in the next section, rather than to provide an account of phenomena that is completely satisfactory from a linguistic point of view.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A sample grammar", "sec_num": "2" }, { "text": "Grammar rules are written as (pure) Prolog clauses. 1 Heads select arguments using a subcat list. Argument structures are specified lexically and are percolated from head to head. Syntactic features are shared between heads (hence I make the simplifying assumption that headfunctor, which may have to be revised in order to treat modification). In this grammar I use revised versions of Pollard's head wrapping operations to analyse cross serial dependency and verb second constructions. For a linguistic background of these constructions and analyses, cf. Evers (1975) , Koster (1975) where Syn describes the part of speech, Subcat 1 It should be stressed though that other unification grammar formalisms can be extended quite easily to encode the same grammar. I implemented the algorithm for several grammars written in a version of PATR II without built-in string concate~aation.", "cite_spans": [ { "start": 557, "end": 569, "text": "Evers (1975)", "ref_id": "BIBREF1" }, { "start": 572, "end": 585, "text": "Koster (1975)", "ref_id": "BIBREF5" } ], "ref_spans": [], "eq_spans": [], "section": "A sample grammar", "sec_num": "2" }, { "text": "is a list of categories a category subcategorizes for, Phon describes the string that is dominated by this category, and Sere is the argument structure associated with this category. Rule indicates which rule (i.e. version of the combine predicate eb to be defined below) should be applied; it generalizes the 'Order' feature of UCG. The value of Phon is a term p(Left,Head,R\u00a3ght) where the fields in this term are difference lists of words. The first argument represents the string left of the head, the second argument represents the head and the third argument represents the string right of the head. Hence, the string associated with such a term is the concatenation of the three arguments from left to right. There is only one parameterized, binary branching, rule in the grammar:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A sample grammar", "sec_num": "2" }, { "text": "rule(x(Syn,[x(C,L,P2,S,R)[L],PI,Sem,_), x(Syn,L,P,Sem,_), [x(C,L,P2,S,R)]) :- cb(R, PI, P2, P).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A sample grammar", "sec_num": "2" }, { "text": "In this rule the first element of the subcategorization list of the head is selected as the (only) other daughter of the mother of the rule. The syntactic and semantic features of the mother and the head are shared. Furthermore, the strings associated with the two daughters of the rule are to be combined by the cb predicate. For simple (left or right) concatenation this predicate is defined as follows: p(L,H,RI-R2 ", "cite_spans": [], "ref_spans": [ { "start": 406, "end": 417, "text": "p(L,H,RI-R2", "ref_id": null } ], "eq_spans": [], "section": "A sample grammar", "sec_num": "2" }, { "text": "cb(left, p(L4-L.H,R), p(L1-L2,L2-L3,L3-L4), p(L1-L,H,R)). cb(right,", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "A sample grammar", "sec_num": "2" }, { "text": "Although this looks horrible for people not familiar with Prolog, the idea is really very simple.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "), p(R2-R3,R3-R4,R4-R), p(L,H,RI-R)).", "sec_num": null }, { "text": "In the first case the string associated with the argument is appended to the left of the string left of the head; in the second case this string is appended to the right of the string right of the head. In a friendlier notation the examples may look like:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "), p(R2-R3,R3-R4,R4-R), p(L,H,RI-R)).", "sec_num": null }, { "text": "p(A1.A2.A3-L,H, R) /\\ p(L,H,R) p(A1,A2,A3) p(L, H. R-A1.A2.A3) /\\ p(L,H,R) p(A1,A2,A3)", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "), p(R2-R3,R3-R4,R4-R), p(L,H,RI-R)).", "sec_num": null }, { "text": "Lexical entries for the intransitive verb 'slaapt' (sleeps) and the transitive verb 'kust' (kisses) are defined as follows:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "), p(R2-R3,R3-R4,R4-R), p(L,H,RI-R)).", "sec_num": null }, { "text": "rule( x(v,[x(n, [] ,_,A,left)], p(P-P,[slaaptlT]-T,R-R), sleep(A),_)). rule( x(v, [x(n, [] ,_,B,left), x(n, [] ,_,A,left)], p (P-P, [kust I T]-T, R-R), kiss(A,B),_)).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "), p(R2-R3,R3-R4,R4-R), p(L,H,RI-R)).", "sec_num": null }, { "text": "Proper nouns are defined as:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "), p(R2-R3,R3-R4,R4-R), p(L,H,RI-R)).", "sec_num": null }, { "text": "rule( x(n, [] ,p(P-P, [pier [T]-T,R-R),", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "), p(R2-R3,R3-R4,R4-R), p(L,H,RI-R)).", "sec_num": null }, { "text": "and a top category is defined as follows (complementizers that have selected all arguments, i.e. sentences):", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "pete,_)).", "sec_num": null }, { "text": "top(x(comp,[] ...... )).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "pete,_)).", "sec_num": null }, { "text": "Such a complementizer, eg. 'dat' (that) is defined as:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "pete,_)).", "sec_num": null }, { "text": "rule( x(comp, Ix(v, [] ,_,A,right)], p(P-P, [dat I T]-T, R-R), that (A), _) ).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "pete,_)).", "sec_num": null }, { "text": "The choice of datastructure for the value of Phon allows a simple definition of the verb raising (vr) version of the combine predicate that may be used for Dutch cross serial dependencies:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "pete,_)).", "sec_num": null }, { "text": "cb(vr, p(L1-L2,H,R3-R), p(L2-L,R1-R2,R2-R3), p(L1-L,H,R1-R)).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "pete,_)).", "sec_num": null }, { "text": "Here the head and right string of the argument are appended to the right, whereas the left string of the argument is appended to the left. Again, an illustration might help:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "pete,_)).", "sec_num": null }, { "text": "p(L-AI , II, A2.A3.R) /\\ p(L,", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "pete,_)).", "sec_num": null }, { "text": "A raising verb, eg. 'ziet' (sees) is defined as: ", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "li,X) p(A1,A2,A3)", "sec_num": null }, { "text": "rule(x(v", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "li,X) p(A1,A2,A3)", "sec_num": null }, { "text": "In this entry 'ziet' selects --apart from its npsubject --two objects, a np and a VP (with category inf). The inf still has an element in its subcat list; this element is controlled by the np (this is performed by the sharing of InfSubj). To derive the subordinate phrase 'dat jan piet marie ziet kussen' (that john sees pete kiss mary), the main verb 'ziet' first selects its rip-object 'piet' resulting in the string 'piet ziet'. Then it selects the infinitival 'marie kussen'. These two strings are combined into 'piet marie ziet kussen' (using the vr version of the cb predicate). The subject is selected resulting in the string 'jan pier marie ziet kussen'. This string is selected by the complementizer, resulting in 'dat jan piet marie ziet kussen'. The argument structure will be instantiated as that (sees (j elm, kiss (pete, mary))).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "see(A,B),_)).", "sec_num": null }, { "text": "In Dutch main clauses, there usually is no overt complementizer; instead the finite verb occupies the first position (in yes-no questions), or the second position (right after the topic; ordinary declarative sentences). In the following analysis an empty complementizer selects an ordinary (finite) v; the resulting string is formed by the following definition of \u00a2b:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "see(A,B),_)).", "sec_num": null }, { "text": "which may be illustrated with:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "cb(v2, p(A-A,B-B,C-C), p(R1-R2,H,R2-R), p(A-A,H,RI-R)).", "sec_num": null }, { "text": "p( [], A2, A1.A3) /\\ p([l, [], []) p", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "cb(v2, p(A-A,B-B,C-C), p(R1-R2,H,R2-R), p(A-A,H,RI-R)).", "sec_num": null }, { "text": "The finite complementizer is defined as: B-B,C-C,D-D) , that (A),_)).", "cite_spans": [], "ref_spans": [ { "start": 41, "end": 53, "text": "B-B,C-C,D-D)", "ref_id": null } ], "eq_spans": [], "section": "(A1,A2,A3)", "sec_num": null }, { "text": "xatle(xCcomp, [xCv, FI ,_,A,v2)], p(", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "(A1,A2,A3)", "sec_num": null }, { "text": "Note that this analysis captures the special relationship between complementizers and (fronted) finite verbs in Dutch. ", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "(A1,A2,A3)", "sec_num": null }, { "text": "This section describes the head-driven parsing algorithm for the type of grammars described above. The parser is a generalization of a leftcorner parser. Such a parser, which may be called a 'head-corner' parser, ~ proceeds in a bottom-up way. Because the parser proceeds from head to head it is easy to use powerful top-down predictions based on the usual head feature percolations, and subcategorization requirements that heads require from their arguments.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The head corner parser", "sec_num": "3" }, { "text": "In left-corner parsers (Matsumoto et aL, 1983 ) the first step of the algorithm is to select the left-2This name is due to Pete White.lock. most word of a phrase. The parser then proceeds by proving that this word indeed can be the leftcorner of the phrase. It does so by selecting a rule whose leftmost daughter unifies with the category of the word. It then parses other daughters of the rule recursively and then continues by connecting the mother category of that rule upwards, recursively. The left-corner algorithm can be generalized to the class of grammars under consideration if we start with the seed of a phrase, instead of its leftmost word. Furthermore the connect predicate then connects smaller categories upwards by unifying them with the head of a rule. The first step of the algorithm consists of the prediction step: which lexical entry is the seed of the phrase? The first thing to note is that the words introduced by this lexical entry should be part of the input string, because of the nonerasure requirement (we use the string as a 'guide ' (Dymetman ef al., 1990) as in a left-corner parser, but we change the way in which lexical entries 'consume the guide'). Furthermore in most linguistic theories it is assumed that certain features are shared between the mother and the head. I assume that the predicate head/2 defines these feature percolations; for the grammar of the foregoing section this predicate may be defined as:", "cite_spans": [ { "start": 23, "end": 45, "text": "(Matsumoto et aL, 1983", "ref_id": "BIBREF6" }, { "start": 1063, "end": 1088, "text": "' (Dymetman ef al., 1990)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "The head corner parser", "sec_num": "3" }, { "text": "head(x(Syn ..... Sent,_),", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The head corner parser", "sec_num": "3" }, { "text": "x(ST-..... Sn,_)).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The head corner parser", "sec_num": "3" }, { "text": "As we will proceed from head to head these features will also be shared between the seed and the top-goal; hence we can use this definition to restrict lexical lookup by top-down prediction. 3 The first step in the algorithm is defined as:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The head corner parser", "sec_num": "3" }, { "text": "parse(Cat,PO,P) \"-predict_lex(Cat,SmallCat,PO,P1), connect(SmallCat,Cat,P1,P).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The head corner parser", "sec_num": "3" }, { "text": "predict_lex(Cat,SmallCat,P0,P) :head(Cat,Sma11Cat), rule(SmallCat), string(SmallCat,Words), subset(Words,PO,P).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The head corner parser", "sec_num": "3" }, { "text": "Instead of taking the first word from the current input string, the parser may select a lexical en-3In the general case we need to compute the transitive closure of (restrictions of) pcesible mother-head relationships. The predicate 'head may also be used to compile rules into the format adopted here (i.e. using the definition the compiler will identify the head of a rule). try dominating a subset of the words occuring in the input string, provided this lexical entry can be the seed of the current goal. The predicate subset(L1,L2,L3) is true in case L1 is a subset of L2 with complement L3. 4", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The head corner parser", "sec_num": "3" }, { "text": "The second step of the algorithm, the connect part, is identical to the connect part of the leftcorner parser, but instead of selecting the leftmost daughter of a rule the head-corner parser selects the head of a rule: connect(X,X,P,P). The predicate 'start_parse' starts the parse process, and requires furthermore that the string associated with the category that has been found spans the input string in the right order. The definition of the predicate 'string' depends on the way strings are encoded in the grammar. The predicate relates linguistic objects and the string they dominate (as a list of words). I assume that each grammar provides a definition of this predicate. In the current grammar string/2 is defined as follows:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The head corner parser", "sec_num": "3" }, { "text": "4In Prolog this predicate may he defined as follows: The cut in select.chkls necessary in case the same word occurs twice in the input string; without it the parser would not be 'minima/'; this could be changed by indexins words w.r.t, their position, hut I will not assume this complication here, ", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The head corner parser", "sec_num": "3" }, { "text": "This predicate is complicated using the predicate copy_term/2 to prevent any side-effects to happen in the category. The parser thus needs two grammar specific predicates: head/2 and string/2.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "str(p(P-P1,P1-P2,P2-[]),P).", "sec_num": null }, { "text": "Example. To parse the sentence 'dat jan slaapt', the head corner parser will proceed as follows. The first call to 'parse' will look like:", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "str(p(P-P1,P1-P2,P2-[]),P).", "sec_num": null }, { "text": "parse (x(colap, [] ....", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "str(p(P-P1,P1-P2,P2-[]),P).", "sec_num": null }, { "text": "The prediction step selects the lexical entry 'dat'. The next goal is to show that this lexical entry is the seed of the top goal; furthermore the string that still has to be covered is now [jan,slaapt] .", "cite_spans": [ { "start": 190, "end": 202, "text": "[jan,slaapt]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": ".. ), [dat, j an, slaapt], [] )", "sec_num": null }, { "text": "Leaving details out the connect clause looks as :", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": ".. ), [dat, j an, slaapt], [] )", "sec_num": null }, { "text": "connect ( x(comp, Ix(v,.. ,right)],.. ), x(comp, 17,.. ), [jan, slaapt], [] )", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": ".. ), [dat, j an, slaapt], [] )", "sec_num": null }, { "text": "The category of dat has to be matched with the head of a rule. Notice that dat subcategorises for a v with rule feature right. Hence the right version of the cb predicate applies, and the next goal is to parse the v for which this complementizer subcategorizes, with input 'jan, slaapt'. Lexical lookup selects the word slaapt from this string. The word slaapt has to be shown to be the head of this v node, by the connect predicate. This time the left combination rule applies and the next goal consists in parsing a np (for which slaapt subcategorizes) with input string jan. This goal succeeds with an empty output string. Hence the argument of the rule has been found successfully and hence we need to connect the mother of the rule up to the v node. This succeeds trivially, and therefore we now have found the v for which dat subcategorizes. Hence the next goal is to connect the complementizer with an empty subcat list up to the topgoal; again this succeeds trivially. Hence we obtain the instantiated version of the parse call: Clearly the parser may enter an infinite loop (in case non branching rules are defined that may feed themselves or in case a grammar makes a heavy use of empty categories). However, in case the parser does terminate one can be sure that it has found all solutions. Furthermore the parser is minimal in the sense that it will return one solution for each possible derivation (of course if several derivations yield identical results the parser will return this result as often as there are derivations for it).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": ".. ), [dat, j an, slaapt], [] )", "sec_num": null }, { "text": "Efficiency. The parser turns out to be quite efficient in practice. There is one parameter that influences efficiency quite dramatically. If the notion 'syntactic head' implies that much syntactic information is shared between the head of a phrase and its mother, then the prediction step in the algorithm will be much better at 'predicting' the head of the phrase. If on the other hand the notion 'head' does not imply such feature percolations, then the parser must predict the head randomly from the input string as no top-down information is available.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": ".. ), [dat, j an, slaapt], [] )", "sec_num": null }, { "text": "Improvements. The efficiency of the parser can be improved by common Prolog and parsing techniques. Firstly, it is possible to compile the grammar rules, lexical entries and parser a bit further by (un)folding (eg. the string predicate can be applied to each lexical entry in a compilation stage). Secondly it is possible to integrate wellformed and non-well-formed subgoal tables in the parser, following the technique described by Matsumoto et al. (1983) . The usefulness of this technique strongly depends on the actual grammars that are being used. Finally, the current indexing of lexical entries is very bad indeed and can easily be improved drastically.", "cite_spans": [ { "start": 433, "end": 456, "text": "Matsumoto et al. (1983)", "ref_id": "BIBREF6" } ], "ref_spans": [], "eq_spans": [], "section": ".. ), [dat, j an, slaapt], [] )", "sec_num": null }, { "text": "In some grammars the string operations that are defined are not only monotonic with respect to the words they dominate, but also with respect to the order constraints that are defined between these words ('order-monotonic'). For example in Reape's sequence union operation the linear precedence constraints that are defined between elements of a daughter are by definition part of the linear precedence constraints of the mother. Note though that the analysis of verb second in the foregoing section uses a string operation that does not satisfy this restriction. For grammars that do satisfy this restriction it is possible to extend the top-down prediction possibilities by the incorporation of an extra clause in the 'connect' predicate which will check that the phrase that has been analysed up to that point can become a substring of the top string.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": ".. ), [dat, j an, slaapt], [] )", "sec_num": null } ], "back_matter": [ { "text": "This research was partly supported by SFB 314, Project N3 BiLD; and by the NBBI via the Eurotra project.I am grateful to Mike Reape for useful comments, and an anonymous reviewer of ACL, for pointing out the relevance of LCFRS. ", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Acknowledgements", "sec_num": null } ], "bib_entries": { "BIBREF0": { "ref_id": "b0", "title": "Proceedings of the 13th International Conference on Computational Linguistics (COLING)", "authors": [], "year": 1990, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "generation. In Proceedings of the 13th In- ternational Conference on Computational Lin- guistics (COLING), Helsinki, 1990.", "links": null }, "BIBREF1": { "ref_id": "b1", "title": "The Transformational Cycle in Dutch and German", "authors": [ { "first": "Arnold", "middle": [], "last": "Evers", "suffix": "" } ], "year": 1975, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Arnold Evers. The Transformational Cycle in Dutch and German. PhD thesis, Rijksuniver- siteit Utrecht, 1975.", "links": null }, "BIBREF2": { "ref_id": "b2", "title": "Parsing with discontinuous constituents", "authors": [ { "first": "Mark", "middle": [], "last": "Johnson", "suffix": "" } ], "year": 1985, "venue": "23th Annual Meeting of the Association for Computational Linguistics", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Mark Johnson. Parsing with discontinuous constituents. In 23th Annual Meeting of the Association for Computational Linguistics, Chicago, 1985.", "links": null }, "BIBREF3": { "ref_id": "b3", "title": "Tree adjunct grammars", "authors": [ { "first": "A", "middle": [ "K" ], "last": "Joshi", "suffix": "" }, { "first": "L", "middle": [ "S" ], "last": "Levy", "suffix": "" }, { "first": "M", "middle": [], "last": "Takahashi", "suffix": "" } ], "year": 1975, "venue": "Journal Computer Systems Science", "volume": "10", "issue": "1", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "A.K. Joshi, L.S. Levy, and M. Takahashi. Tree adjunct grammars. Journal Computer Systems Science, 10(1), 1975.", "links": null }, "BIBREF4": { "ref_id": "b4", "title": "ttead driven parsing", "authors": [ { "first": "Martin", "middle": [], "last": "Kay", "suffix": "" } ], "year": 1989, "venue": "Proceedings of Workshop on Parsing Technologies", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Martin Kay. ttead driven parsing. In Proceedings of Workshop on Parsing Technologies, Pitts- burgh, 1989.", "links": null }, "BIBREF5": { "ref_id": "b5", "title": "Dutch as an SOV language", "authors": [ { "first": "Jan", "middle": [], "last": "Koster", "suffix": "" } ], "year": 1975, "venue": "Linguistic Analysis", "volume": "1", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Jan Koster. Dutch as an SOV language. Linguis- tic Analysis, 1, 1975.", "links": null }, "BIBREF6": { "ref_id": "b6", "title": "BUP: a bottom up parser embedded in Prolog", "authors": [ { "first": "Y", "middle": [], "last": "Matsumoto", "suffix": "" }, { "first": "H", "middle": [], "last": "Tanaka", "suffix": "" }, { "first": "", "middle": [], "last": "It", "suffix": "" }, { "first": "", "middle": [], "last": "Itirakawa", "suffix": "" }, { "first": "", "middle": [], "last": "It", "suffix": "" }, { "first": "H", "middle": [], "last": "Miyoshi", "suffix": "" }, { "first": "", "middle": [], "last": "Yasukawa", "suffix": "" } ], "year": 1983, "venue": "New Generation Computing", "volume": "1", "issue": "2", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Y. Matsumoto, H. Tanaka, It. Itirakawa, It. Miyoshi, and H. Yasukawa. BUP: a bottom up parser embedded in Prolog. New Genera- tion Computing, 1(2), 1983.", "links": null }, "BIBREF7": { "ref_id": "b7", "title": "Generalized Context-Free Grammars, Head Grammars, and Natural Language", "authors": [ { "first": "Carl", "middle": [], "last": "Pollard", "suffix": "" } ], "year": 1984, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Carl Pollard. Generalized Context-Free Gram- mars, Head Grammars, and Natural Language. PhD thesis, Stanford, 1984.", "links": null }, "BIBREF8": { "ref_id": "b8", "title": "Parsing head-driven phrase structure grammar", "authors": [ { "first": "C", "middle": [], "last": "Proudian", "suffix": "" }, { "first": "C", "middle": [], "last": "Pollard", "suffix": "" } ], "year": 1985, "venue": "P3th Annual Meeting of the Association for Computational Linguistics", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "C. Proudian and C. Pollard. Parsing head-driven phrase structure grammar. In P3th Annual Meeting of the Association for Computational Linguistics, Chicago, 1985.", "links": null }, "BIBREF9": { "ref_id": "b9", "title": "A logical treatment .of semi-free word order and bounded discontinuous constituency", "authors": [ { "first": "Mike", "middle": [], "last": "Reape", "suffix": "" } ], "year": 1989, "venue": "Fourth Conference of the European Chapter of the Association for Computational Linguistics", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Mike Reape. A logical treatment .of semi-free word order and bounded discontinuous con- stituency. In Fourth Conference of the Euro- pean Chapter of the Association for Computa- tional Linguistics, UMIST Manchester, 1989.", "links": null }, "BIBREF10": { "ref_id": "b10", "title": "Getting things in order", "authors": [ { "first": "Mike", "middle": [], "last": "Reape", "suffix": "" } ], "year": 1990, "venue": "Proceedings of the Symposium on Discontinuous Constituency, ITK Tilburg", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Mike Reape. Getting things in order. In Proceed- ings of the Symposium on Discontinuous Con- stituency, ITK Tilburg, 1990.", "links": null }, "BIBREF11": { "ref_id": "b11", "title": "Parsing bounded discontinous constituents: Generalisations of the shift-reduce and CKY algorithms, 1990. Paper presented at the first CLIN meeting", "authors": [ { "first": "Mike", "middle": [], "last": "Reape", "suffix": "" } ], "year": null, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Mike Reape. Parsing bounded discontinous con- stituents: Generalisations of the shift-reduce and CKY algorithms, 1990. Paper presented at the first CLIN meeting, October 26, OTS Utrecht.", "links": null }, "BIBREF12": { "ref_id": "b12", "title": "A semantic-head-driven generation algorithm for unification based formalisms", "authors": [ { "first": "M", "middle": [], "last": "Stuart", "suffix": "" }, { "first": "", "middle": [], "last": "Shieber", "suffix": "" }, { "first": "Robert", "middle": [ "C" ], "last": "Gertjan Van Noord", "suffix": "" }, { "first": "Fernando", "middle": [ "C N" ], "last": "Moore", "suffix": "" }, { "first": "", "middle": [], "last": "Pereira", "suffix": "" } ], "year": 1989, "venue": "27th Annual Meeting of the Association for Computational Linguistics", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Stuart M. Shieber, Gertjan van Noord, Robert C. Moore, and Fernando C.N. Pereira. A semantic-head-driven generation algorithm for unification based formalisms. In 27th Annual Meeting of the Association for Computational Linguistics, Vancouver, 1989.", "links": null }, "BIBREF13": { "ref_id": "b13", "title": "Semantichead-driven generation", "authors": [ { "first": "M", "middle": [], "last": "Stuart", "suffix": "" }, { "first": "", "middle": [], "last": "Shieber", "suffix": "" }, { "first": "Robert", "middle": [ "C" ], "last": "Gertjan Van Noord", "suffix": "" }, { "first": "Fernando", "middle": [ "C N" ], "last": "Moore", "suffix": "" }, { "first": "", "middle": [], "last": "Pereira", "suffix": "" } ], "year": 1990, "venue": "Computational Linguistics", "volume": "16", "issue": "1", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Stuart M. Shieber, Gertjan van Noord, Robert C. Moore, and Fernando C.N. Pereira. Semantic- head-driven generation. Computational Lin- guistics, 16(1), 1990.", "links": null }, "BIBREF14": { "ref_id": "b14", "title": "BUG: A directed bottomup generator for unification based formalisms", "authors": [ { "first": "", "middle": [], "last": "Gertjan Van Noord", "suffix": "" } ], "year": 1989, "venue": "Current Research in Natural Language Generation", "volume": "4", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Gertjan van Noord. BUG: A directed bottom- up generator for unification based formalisms. Working Papers in Natural Language Process- ing, Katholieke Universiteit Leuven, Stichting Taaltechnologie Utrecht, 4, 1989. Gertjan van Noord. An overview of head- driven bottom-up generation. In Robert Dale, Chris Mellish, and Michael Zoek, editors, Cur- rent Research in Natural Language Generation. Academic Press, 1990.", "links": null }, "BIBREF15": { "ref_id": "b15", "title": "Reversible unifieation-based machine translation", "authors": [ { "first": "", "middle": [], "last": "Gertjan Van Noord", "suffix": "" } ], "year": 1990, "venue": "Proceedings of the 18th International Conference on Computational Linguistics (COLING)", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Gertjan van Noord. Reversible unifieation-based machine translation. In Proceedings of the 18th International Conference on Computa- tional Linguistics (COLING), Helsinki, 1990.", "links": null }, "BIBREF16": { "ref_id": "b16", "title": "Feature structure based tree adjoining grammar", "authors": [ { "first": "K", "middle": [], "last": "Vijay-Shankar", "suffix": "" }, { "first": "A", "middle": [], "last": "Joshi", "suffix": "" } ], "year": 1988, "venue": "Proceedings of the 12th International Conference on Computational Linguistics (COLING), Budapest", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "K. Vijay-Shankar and A. Joshi. Feature struc- ture based tree adjoining grammar. In Pro- ceedings of the 12th International Conference on Computational Linguistics (COLING), Bu- dapest, 1988.", "links": null }, "BIBREF17": { "ref_id": "b17", "title": "Characterizing structural descriptions produced by various grammatical formalisms", "authors": [ { "first": "K", "middle": [], "last": "Vijay-Shanker", "suffix": "" }, { "first": "David", "middle": [ "J" ], "last": "Weir", "suffix": "" }, { "first": "Aravind", "middle": [ "K" ], "last": "Joshi", "suffix": "" } ], "year": 1987, "venue": "25th Annual Meeting of the Association for Computational Linguistics", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "K. Vijay-Shanker, David J. Weir, and Aravind K. Joshi. Characterizing structural descriptions produced by various grammatical formalisms. In 25th Annual Meeting of the Association for Computational Linguistics, Stanford, 1987.", "links": null } }, "ref_entries": { "FIGREF0": { "type_str": "figure", "num": null, "text": "-P,[ziotIT]-T,R-R),", "uris": null }, "FIGREF5": { "type_str": "figure", "num": null, "text": ". The algorithm as it is defined is sound (assuming the Prolog interpreter is sound), and complete in the usual Prolog sense.", "uris": null }, "TABREF0": { "content": "
Rules are defined as
rule(Head,Mother,Other)
or ~s
rule(Mother)
(for lexical entries), where Head represents the
designated head daughter, Mother the mother
category and Other a list of the other daughters.
Each category is a term
x(Syn,Subcat,Phon,Sem,Rule)
", "text": "and many others.", "num": null, "type_str": "table", "html": null } } } }