| { |
| "paper_id": "W91-0113", |
| "header": { |
| "generated_with": "S2ORC 1.0.0", |
| "date_generated": "2023-01-19T04:42:54.971334Z" |
| }, |
| "title": "COMPILING TRACE & UNIFICATION GRAMMAR FOR PARSING AND GENERATION", |
| "authors": [ |
| { |
| "first": "Hans", |
| "middle": [], |
| "last": "Ulrich Block", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "ZFE IS INF", |
| "location": { |
| "addrLine": "23 Otto Hahn-Ring 6", |
| "postCode": "D-8000", |
| "settlement": "Miinchen 83", |
| "country": "Germany" |
| } |
| }, |
| "email": "block@ztivax.uucp" |
| } |
| ], |
| "year": "", |
| "venue": null, |
| "identifiers": {}, |
| "abstract": "This paper presents Trace & Unification Grammar (TUG), a declarative and reversible grammar formalism that brings together Unification Grammar (uG) and ideas of Government & Binding Theory (GB) in an undogmatic way. A grammar compiler is presented that transforms a grammar written in the TUG formalism into two different forms, one being useful for parsing, the other being useful for generation.", |
| "pdf_parse": { |
| "paper_id": "W91-0113", |
| "_pdf_hash": "", |
| "abstract": [ |
| { |
| "text": "This paper presents Trace & Unification Grammar (TUG), a declarative and reversible grammar formalism that brings together Unification Grammar (uG) and ideas of Government & Binding Theory (GB) in an undogmatic way. A grammar compiler is presented that transforms a grammar written in the TUG formalism into two different forms, one being useful for parsing, the other being useful for generation.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstract", |
| "sec_num": null |
| } |
| ], |
| "body_text": [ |
| { |
| "text": "During the last years there has been a growing interest in NL systems that can be used for both parsing and generation. The invention of unification grammar that allows for a declarative description of language made it possible to use the same grammar for both tasks. The main goal of a grammar then is to describe a relation between normalized (semantic) representations and language strings. A grammar that can be used in both directions is called \"reversible\".", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "INTRODUCTION", |
| "sec_num": "1" |
| }, |
| { |
| "text": "We can distinguish three levels of reversibility. On the first level, not only the same grammar is used for parsing and generation, but also the interpreter for parsing and generation is reversible. This approach is taken in Shieber (1988) . Besides elegance the approach has the advantage that the reversibility is guaranteed. Further advantages are mentioned in Neumann (1991) . As a disadvantage, it is yet unclear whether and how these systems can be made efficient.", |
| "cite_spans": [ |
| { |
| "start": 225, |
| "end": 239, |
| "text": "Shieber (1988)", |
| "ref_id": "BIBREF10" |
| }, |
| { |
| "start": 364, |
| "end": 378, |
| "text": "Neumann (1991)", |
| "ref_id": "BIBREF6" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "INTRODUCTION", |
| "sec_num": "1" |
| }, |
| { |
| "text": "On the second level we find systems where the same reversible grammar is processed by two different interpreters, one for parsing, one for generation. The advantage of these systems is that the grammar can be changed and tested easily, which helps to shorten the development cycle. The disadvantage again is that grammar interpreters are usually too slow to be used in realistic systems.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "INTRODUCTION", |
| "sec_num": "1" |
| }, |
| { |
| "text": "On the third level we finally find systems, where the linguistic description is given in a reversible declarative grammar. This grammar is then compiled into two different forms, one being usefull only for parsing, the other only for generation. Whereas here we have to face the disadvantage that compiling can take some time and therefore prolongs the development cycle, the advantage lies in the efficient processing that can be achieved with compiled grammars. Strzalkowski (1990) and Strzalkowski/Peng (1990) describe a compiler that transforms a grammar originally written for parsing into an efficient generator.", |
| "cite_spans": [ |
| { |
| "start": 464, |
| "end": 483, |
| "text": "Strzalkowski (1990)", |
| "ref_id": null |
| }, |
| { |
| "start": 488, |
| "end": 512, |
| "text": "Strzalkowski/Peng (1990)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "INTRODUCTION", |
| "sec_num": "1" |
| }, |
| { |
| "text": "In the follwing section I will present a system of the third type and show by means of which compiling methods a grammar written in a perspicious formalism, TRACE AND UNIFICATION GRAMMAR (TUG) can be transformed to fast parsers and generators. The proposed compilers and their modular architecture have the further advantage that most of their parts can be used also for other formalisms than the one described, e.g. DCGS.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "INTRODUCTION", |
| "sec_num": "1" |
| }, |
| { |
| "text": "The whole system is part of a polyfunctional linguistic processor for German called LINGUISTIC KERNEL PROCESSOR (LKP). The LKP contains a grammar of German with broad coverage. The grammar describes the relation between a subset of German and a subset of QLF, the intermediate semantic form that is used in the Care Language Engine of SRI Cambridge (Alshawi 1990 ). The LKP has been implemented in PROLOG. Parsing and Generation of a sentence up to 15 words normally takes between 1 and 10 seconds, with a strong tendency to the lower bound.", |
| "cite_spans": [ |
| { |
| "start": 349, |
| "end": 362, |
| "text": "(Alshawi 1990", |
| "ref_id": "BIBREF1" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "INTRODUCTION", |
| "sec_num": "1" |
| }, |
| { |
| "text": "The design of Trace and Unification Grammar has been guided by the following goals: i \u2022 Perspicuity. We are convinced that the generality, coverage , reliability and development speed of a grammar are a direct function of its perspicuity, just as programming in Pascal is less errorprone than programming in assembler. In the optimal case, the grammar writer shoul d be freed of reflections on how to code things best for processing but should only be guided by linguistic criteria. These goals led for .example to the introduction of unrestricted disjunction into the TUG formalism.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "FORMALISM", |
| "sec_num": "2" |
| }, |
| { |
| "text": "\u2022 Compatibility to GB Theory. It was a major objective bf the LKP to base the grammar on well undo;stood and motivated grounds.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "FORMALISM", |
| "sec_num": "2" |
| }, |
| { |
| "text": "As most of the newer linguistic descriptions on German ate in the framework of GB theory, TUG was designed to be somehow compatible with this theory though it was not our goal to \"hardwire\" every Gs principle.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "FORMALISM", |
| "sec_num": "2" |
| }, |
| { |
| "text": "\u2022 Efficiency. :As the LKP is supposed to be the basis of products for interactive usage of natural langu~age, efficiency is a very important goal. Making efficiency a design goal of the formalism led e.g. to the introduction of feature types 'and the separation of the movement rules int~ head movement and argument movement.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "FORMALISM", |
| "sec_num": "2" |
| }, |
| { |
| "text": "The basis of TUG is formed by a context free grammar that is augmented by PATR n-style feature equations. Besides this basis, the main features of TUG are feature typing, mixing of attribute-value-pair and (PROLOG-) term unification, flexible macros, unrestricted disjunction and special rule types !for argument and head movement.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "FORMALISM", |
| "sec_num": "2" |
| }, |
| { |
| "text": "As a very simple example we will look at the TUG version of the example grammar in Shieber (1984 ).", |
| "cite_spans": [ |
| { |
| "start": 83, |
| "end": 96, |
| "text": "Shieber (1984", |
| "ref_id": "BIBREF9" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "BASIC FEATURES", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "The two main differences to PATR II in the basic framwork are that first, TUG is leas flexible in that it has a \"hard\" contextfree backbone, whereas in PATR II categories of the context free part are placeholders for feature structures, their names boeing taken as the value of the cat feature in the structure. Second, TUG has a strict typing. For a feature path to be well defined, each of its attributes has to be declared in the type definition.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "BASIC FEATURES", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "Besides defined attribute-value-pairs, TUO allows for the mixing of attribute-value-pair unification with arbitrary structures like PROLOG terms using a back-quote notation. This can be regarded as the unificational variant of the BUILDQ operation known from ATNS. As an example consider the following lexicon entry of each that constructs a predicate logic notation out of dot :base, TUG allows for arbitrary disjunction of feature equations. Disjunctions and Conjunction may be mixed freely. Besides well known cases as in the entry for knight above, we found many cases where disjunctions of path equations are useful, e.g. for the description of the extraposed relative clauses*.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "BASIC FEATURES", |
| "sec_num": "2.1" |
| }, |
| { |
| "text": "Further to these more standard uG-features, TUG provides special rule formats for the description of discontinuous dependencies, so called \"movement rules\". Two main types of movement are distinguished: argument movement and head movement. The format and processing of argument movement rules is greatly inspired by Chen e.a. (1988) and Chen (1990) , the processing of head movement is based on GPSG like slash features.", |
| "cite_spans": [ |
| { |
| "start": 326, |
| "end": 332, |
| "text": "(1988)", |
| "ref_id": null |
| }, |
| { |
| "start": 337, |
| "end": 348, |
| "text": "Chen (1990)", |
| "ref_id": "BIBREF5" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "MOVEMENT RULES", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "A head movement rule defines a relation between two positions in a parse tree, one is the landing site, the other the trace position. Head movement is constrained by the condition that the trace is the head of a specified sister (the root node) of 1Block/Sclunid (1991) describes our processing technique for disjunctions. the landing site 2. Trace and Antecedent are identical with the exception that the landing site contains overt material, the trace does'nt. Suppose, that v is the head of vk, vk the head of vp and vp the head of s, then only the first of the following structures is a correct head movement, the second is excluded because np is not head of vp, the third because antecedent and trace are unequal. To include recursive rules in the head path, heads are defined by the following head definitions. In a structure [M D, ...", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Head Movement", |
| "sec_num": null |
| }, |
| { |
| "text": "D,] D~ is the head of14 if either Di is_head_of 14 is defined or D~ has the same category as 14 and either Di is_head_of X or X is_head_of Dt is defined for any category X.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Head Movement", |
| "sec_num": null |
| }, |
| { |
| "text": "Head movement rules are very well suited for a concise description of the positions of the finite verb in German (sentence initial, second and final) as in", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Head Movement", |
| "sec_num": null |
| }, |
| { |
| "text": "Hast the man the woman the book given tt", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Hat~ der Mann der Frau das Buch gegeben t~ ?", |
| "sec_num": null |
| }, |
| { |
| "text": "The man hast the woman the book given ti ... daft der Mann der Frau das Buch gegeben hat ... that the man the woman the book given has All that is needed are the head definitions and the rule that introduces the landing site 3.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Der Mann hat~ der Frau das Buch gegeben", |
| "sec_num": null |
| }, |
| { |
| "text": "~Here, \"head of\" is a transitive relation s.t. if x is head of y and y is head of z then x is head of z.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Der Mann hat~ der Frau das Buch gegeben", |
| "sec_num": null |
| }, |
| { |
| "text": "SEven though verb movement is not supposed to be a topic for English grammar, one might think of describing English Subj-Aux inversion in terms of head movement. This rule states that np: ante 4 is the antecedent of an np-trace that is dominated by sl. This rule describes a leftward movement. Following Chen's proposal, TUG also provides for rightward movement rules, though these are not needed in the German grammar. A rightward movement rule might look like this. The first argument in the trace-term indicates whether the landing site is for a variable (vat) or for an anaphoric (ana) trace. Other than head movement, where trace and antecedent are by definition identical, the feature sharing of argument traces with their 'antecedents has to be defined in the grammar by feature equations (ante:fx = trace: fx .... ). ~,Furthermore, it is not necessary that the antecedent and the trace have the same syntactic category. A rule for pronoun fronting in German might e.g. look like this:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Der Mann hat~ der Frau das Buch gegeben", |
| "sec_num": null |
| }, |
| { |
| "text": "spr ---> pron<trace(ana0np), s [ ...", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Peter hao been reading a book Has~ Peter ti been reading a book", |
| "sec_num": null |
| }, |
| { |
| "text": "4The notation Cat :Index is used to distinguish two or more occurrences of the same category in the same rule in the equation part. :ante and :trace are arbitrary names used as index to refer to the two different nps.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Peter hao been reading a book Has~ Peter ti been reading a book", |
| "sec_num": null |
| }, |
| { |
| "text": "The current version of the formalisms requires that the grammar contains a declaration on which categories are possible traces. In such a declaration it is possible to assign features to a trace, for example marking it as empty: erace(np) I np:e~pty = yes.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Peter hao been reading a book Has~ Peter ti been reading a book", |
| "sec_num": null |
| }, |
| { |
| "text": "Bounding nodes have to be declared as such in the grammar by statements of the form bounding_node(np).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Peter hao been reading a book Has~ Peter ti been reading a book", |
| "sec_num": null |
| }, |
| { |
| "text": "[ s:tense = yes.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "bounding_node(s)", |
| "sec_num": null |
| }, |
| { |
| "text": "As in the second case, bounding nodes may be defined in terms of category symbols and features 5. Typical long distance movement phenomena are described within this formalism as in GB by trace hopping. Below is a grammar fragment to describe the sentence Which books~ do you think ti John knows ti Mary did'nt understand ti:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "bounding_node(s)", |
| "sec_num": null |
| }, |
| { |
| "text": "bounding_node(s). bounding_node(rip). sl ---> np<trace(vax,np), s I s ---> np, vp [ ... s ---> aux, np, vp [ ... np ---> propernoun [ ... np ---> det, n [ vp ---> v, sl [ ... vp ---> v, np [ ...", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "bounding_node(s)", |
| "sec_num": null |
| }, |
| { |
| "text": "The main difference of argument movement to other approaches for the description of discontinuities like extraposition grammars (Pereira 1981) is that argument movement is not restricted to nested rule application. This makes the approach especially atractive for a scrambling analysis of the relative free word order in the German Mittel/eld as in Ihml hatj das Buchk keiner ti tk gegeben tj.", |
| "cite_spans": [ |
| { |
| "start": 128, |
| "end": 142, |
| "text": "(Pereira 1981)", |
| "ref_id": "BIBREF8" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "trace(rip).", |
| "sec_num": null |
| }, |
| { |
| "text": "TUG can be processed by a parser and a generator. Before parsing and generation, the grammar is compiled to a more efficient form.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "PROCESSING TRACE & UNIFICATION GRAMMAR", |
| "sec_num": "3" |
| }, |
| { |
| "text": "5Currently, only conjunction of equations is allowed in the definition of bounding nodes.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "PROCESSING TRACE & UNIFICATION GRAMMAR", |
| "sec_num": "3" |
| }, |
| { |
| "text": "The first compilation step is common to generation and parsing. The attribute-value-pair structure is transformed to (PROLOG) term structure by a TUG-tO-.DCG converter. This transformation makes use of the type definitions. As an example consider the transformation of the grammar", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "PROCESSING TRACE & UNIFICATION GRAMMAR", |
| "sec_num": "3" |
| }, |
| { |
| "text": "a => f(al:tl). b => f(al:tl).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "PROCESSING TRACE & UNIFICATION GRAMMAR", |
| "sec_num": "3" |
| }, |
| { |
| "text": "tl => f(a2:t2,a3:t3).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "PROCESSING TRACE & UNIFICATION GRAMMAR", |
| "sec_num": "3" |
| }, |
| { |
| "text": "=> {1,2}. It is transformed to the following grammar in a DCG like format e. The compilation steps following the TUG-to-DCG converter are different for parsing and generation.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "~2", |
| "sec_num": null |
| }, |
| { |
| "text": "In the LKP, a TUG is processed by a Tomita parser (Tomita 1986) . For usage in that parser the result of the TUG-tO-DCG converter is compiled in several steps: First, head movement rules are eliminated and the grammar is expanded by introducing slash rules for the head path by the head movement expander. Suppose the Tuo-to-DCG converter has produced the following fragment: eNote that the goal {A \" 1 ; 1;1(A.2) ,m B} is interpreted as a constraint and not as a PROLOG goal as in DCGs. See Block/Schmld (1991) for the evaluation of the constraints. v(_) is_head_of vk(_). vk(_) is_head_of vp(_). vp(_) is_head_of s(_). Then, the head movement expander introduces slash rules ~ along the head-path, thereby introducing the empty nonterminals push(X) and pop(X). push(X) and pop(X) are \"marker rules\" (Aho/Sethi/Ullman 1986) that invoke the parser to push and pop their argument onto and off a left-to-right stack. This treatment of head movement leads to a twofold prediction in the Tomita parser. First, the new slash categories will lead to LR parsing tables that predict that the verb will be missing if rule sl ---> ... has applied. Second, the feature structure of the verb is transported to the right on the left-to-right stack. Therefore, as soon as a v_v is expected, the whole information of the verb, e.g. its subcategorization frame, is available. This strategy leads to a considerable increase in parsing efficiency.", |
| "cite_spans": [ |
| { |
| "start": 50, |
| "end": 63, |
| "text": "(Tomita 1986)", |
| "ref_id": "BIBREF14" |
| }, |
| { |
| "start": 492, |
| "end": 511, |
| "text": "Block/Schmld (1991)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 396, |
| "end": 413, |
| "text": "{A \" 1 ; 1;1(A.2)", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "THE PARSER GENERATOR", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "\u2022", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "THE PARSER GENERATOR", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "In the next compilation phase, argument movement rules are transformed to the internal format. ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "THE PARSER GENERATOR", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "Gs,Gt)}. s(Gi,Go,S) --->!np(Gi,Gt,NP), vp(Gt,Go, VP), {bound(Gi)}. vp(Gi,Go,VP) --~> v(Gi,Go,V). vp(Gi,Go,VP) --~> v(Gi,Gt,V), np(Gt,Go,NP). np([trace(_,np(SP))[G],G,NP) ---> []. i", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "THE PARSER GENERATOR", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "The predicates cut_trace/3 and bound/1 are defined as in Chen e.a. (1988) .", |
| "cite_spans": [ |
| { |
| "start": 67, |
| "end": 73, |
| "text": "(1988)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "THE PARSER GENERATOR", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "The next step, the empty production eliminater, eliminates all empty productions except those for push and pop. This transforms the output of the argument movement expander to the following grammar. s1(Gi,Go,S1) --i> np(Gi,Gt,NP), s(Gs,Go,S), {cut_trace(trace(var,np(Trace)), Gs,Gt)}. sl ([trace(_,np(NP) ", |
| "cite_spans": [ |
| { |
| "start": 288, |
| "end": 304, |
| "text": "([trace(_,np(NP)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "THE PARSER GENERATOR", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": ")[Gt],Go,S1) ---> s(Gs,Go,S). {cut_trace(trace(var,np(Trace)), Gs,Gt)}. s(Gi,Go,S) --->inp(Gi,Gt,NP), vp(Gt,Go,VP), {bound(Gi)}. s([trace(_,np(NP))[Gt]0Go,S) ---> vp(Gt,Go,VP), {bound(Gi)}. vp(Gi,Go,VP) ---> v(Gi,Go,V). vp(Gi,Go,VP) --~> v(Gi,Gt,V), np(Gt,Go,NP). vp(Gi,Go,VP) --~> v(Gi,[trace(_,np(SP))[Go],V).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "THE PARSER GENERATOR", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "Elimination of empty productions allows for a simpler implementation of the Tomita parser, which again leads to an increased efficiency. The next step, the DcG-to-LRK converter splits the grammar rules into a context free and a DCG part. A context free rule is represented as rule (No,LIIS,RHS) (S, s, [np, vp] ). rule (4, s, [vp] ). rule (S,vp, [v] ). rule (6,vp, [v,np] ).", |
| "cite_spans": [ |
| { |
| "start": 295, |
| "end": 310, |
| "text": "(S, s, [np, vp]", |
| "ref_id": null |
| }, |
| { |
| "start": 319, |
| "end": 330, |
| "text": "(4, s, [vp]", |
| "ref_id": null |
| }, |
| { |
| "start": 339, |
| "end": 349, |
| "text": "(S,vp, [v]", |
| "ref_id": null |
| }, |
| { |
| "start": 358, |
| "end": 371, |
| "text": "(6,vp, [v,np]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 281, |
| "end": 294, |
| "text": "(No,LIIS,RHS)", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "THE PARSER GENERATOR", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "dcg_rule(1,sl(Gi,Go,S1), ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "THE PARSER GENERATOR", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "EQUATION", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [ |
| { |
| "start": 0, |
| "end": 8, |
| "text": "EQUATION", |
| "ref_id": "EQREF", |
| "raw_str": "[v(Gi,Gv,V)], ( Gv = Go ; Gv = [trace(_,np(NP))[Go] )). dcg_rule(6,vp(Gi,Go,VP), [v(Gi,Gt,V),np(Gt,Go,NP)],", |
| "eq_num": "true)." |
| } |
| ], |
| "section": "THE PARSER GENERATOR", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "Note that during this step, different rules that share the same context free backbone are transformed to a single context free rule. The difference in their feature structure is expressed in a disjunction in the Constraint (e.g. rule 5). As very often traces occur in optional positions (e.g. objects, as in vp ---> v. vp ---> v, np), the elimination of empty productions (traces) considerably reduces the amount of edges the parser has to build.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "THE PARSER GENERATOR", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "After these compilation steps the context free rules are transformed to YACC format and YACC is used to compute the LR parsing table. Finally, YACC'S y. output file is transformed to PROLOG.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "THE PARSER GENERATOR", |
| "sec_num": "3.1" |
| }, |
| { |
| "text": "For generation with TUG an improved version of the semantic-head-driven generator (SHDG) (see Shieber e.a. 1990) is used. Before beeing useful for generation, the grammar is transformed in the following steps:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 expansion of head movement rules * transformation to the semantic head driven generator format", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 expansion of movement rules", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 elimination of nonchainrules with uninstantiated semantics", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 goal reordering and transformation to executable prolog code First, the head movement expander transforms the head movement rules. As in the parser generator, slashed categories are generated along the head path, but no push and pop categories are introduces. Instead, the head movement rule and the trace are treated similar to argument movement. The resulting relevant new rules from the example above are:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "newly introduced slash rules sl(S1) ---> [v(V)<trace(var,v_v(V)), s_v(S)S. s_v(S) ---> [ .... vp_v(VP),...]. vp_v(VP) ---> [...,vk_v(VK) .... ]. vk_v(VZ) ---> [...,v_v(V),...]. trace(_,v_v(V)).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "In the next step rule symbols are transformed to the node(Cat,S,S0) format needed by the semantic-head-driven generator. Thereby disjunctions on the semantic argument as in the following example a(Sem) ---> b(BSem), c(CSem), (BSem = Sem; CSem = Sam}.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "are unfolded (multiplied out) to different rules. The output of this step for the above rule is: node(a(Sem),S,SO) ---> nods(b(Sem),S,Sl), node(c(CSem),S1~SO). node(a(Sem),S,SO) ---> node(b(SSem),S,Sl), node(c(Sem),Sl,SO).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "Obviously, unfolding of semantic disjunctions is necessary for a correct choice of the semantic head.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "The next compilation cycle expands the movement rules. Similar to the parser generator two arguments for gap threaddin8 are introduced. The filling of the arguments and the transformation of the movement rules is different from the parser generator. It is a rather complicated operation which is sensitive to the semantics control flow. we can distinguish two cases:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "1) The rule is a nonchain rule in the sense of Shieber e.a. (1990) or it is a chain rule and the antecedent of the trace is the semantic head. In this case the antecedent has to be generated prior to the trace. A typical example is a predicate logic analysis as in: 2) If any element other than the antecedent is the semantic head, then this head has to be generated prior to the antecedent. As the head might contain the trace, it also has to be generated prior to its antecedent. Consider the rule:", |
| "cite_spans": [ |
| { |
| "start": 47, |
| "end": 66, |
| "text": "Shieber e.a. (1990)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "node(sl(Sem),S,SO) ---> node(np(NPSem)<trace(var,np(NPSem)), S,SI), node(s(Sem),Sl,S0).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "In this rule s is generated prior to np. Within s, the trace of np w'ill be generated. Following the suggestion in Shieber e.a. (1990) , rules like this axe compiled in such a way that an antecedent is generated in the~ trace position without linking it to the input st,ing. This antecedent is then added to the set of gaps together with its starting and ending position (coded as a difference list). When generation domes to the landing site, the antecedent is cut out of the trace set. Thereby its starting and ending position is unified with the landing site's star( and end positions. The translation of the above I rule is: node(sl(Gi,Go,Sem),S,SO) ---> node(s(Gs,Go,Sem),Sl,SO), {cut_~race(trace(vax,np(NPSem),S,S1), Gs,Gi)}.", |
| "cite_spans": [ |
| { |
| "start": 128, |
| "end": 134, |
| "text": "(1990)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "node (np([trace(var,np(NPSem) In the next steP, a certain class of nonchain rules is eliminated from the grammar. One of the basic inefficiencies of the semantic-head-driven generator in Shiebcr e.a. (1990) has its origin in nonchaln rules who~se left-hand-side-semantics is a variable. This kin d of nonchain rule often results from empty productions or lexicon entries of semantically empty words. the rule introducing is is a nonchain rule whose semantics is a variable and thus cannot be indexed properly. Rules like this one are eliminated by a partial evaluation technique. For each grammar rule that contains the left-hand-side of the rule on its right-hand-side/~ a copy of the rule is produced where the variables ~ are unified with the left-handside of the nonchain rule and the corresponding right-hand-side element is replaced with the righthand-side of the nonchain rule. E.g. insertion of the rule for is into the vk-rule above leads to vk(SC)/Sem ---> [is], vk([Subj I SC])/Sem. which is a normal chain rule.", |
| "cite_spans": [ |
| { |
| "start": 5, |
| "end": 29, |
| "text": "(np([trace(var,np(NPSem)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "A final compilation transforms the rules to executable PROLOG code and sorts the right hand side to achieve a proper semantics information flow. Suppose that, in the following nonchaln rule the first argument of a category is its semantics argument.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "node(a(f(Sem)),S,SO) ---> node(b(BSem)oS,Sl), node(c(CSem,BSem),SI,S2), node(d(Sem,CSem),S2,SO).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "The righthand side has to be ordered in such a way that all semantics arguments have a chance to be instantiated when the corresponding category is expanded, as in the following rule: This ordering is achieved by a bubble-sort like mechanism. Elements of the right-hand-side are sorted into the new right-hand-side from right to left. To insert a new element e, ew into an (already sorted) list el ... ei, e,,, is inserted into e, ...ei-1 if the semantics argument of e, ew is not equal to some argument of ei, otherwise it is sorted after ei.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "In the final PROLOG code nonchaln rules are indexed by the functor of their lefthand side's semantics as in the following example. Chain rules (like e.g. the one that resuits by replacing node(a(fCSem)),S,S0) by node(a(Sem),S,S0) in the rule above) are indexed by their syntactic category: d(node(d(Sem),S2,SO),Exp) :link(a(Sem),Exp), generate(CSem,node(c(CSem,BSem), sl,s2)), generate(BSem,node(b(BSem),S,S1)), a(node(a(Sem),S,SO),Exp).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "The auxiliary predicates needed for the generator then can be reduced to bottom-up termination rules C(X,X) for all syntactic category symbols C and the predicate for generate/2: generate(Sem,Exp) :-func~or(Sem,F,A), functor(Goal,F,2), arg(1,Goal,Sem), arg(2,Goal,Exp), call(Goal).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "3.2THE GENERATOR GENERATOR", |
| "sec_num": null |
| }, |
| { |
| "text": "We have distinguished three levels of reversibility: runtime reversibility, interpretation reversibility and compilation reversibility. We then have presented Trace & Unification Grammar, a grammar formalism that tries to bridge the gap between uo and GB theory in an undogmatic way and have presented a parser generator and a generator generator that lead to effient runtime code of the grammar both for parsing and for generation. No special effort has been invested to optimize the compilers themselves, so the compilation takes about 1.5 secs. per rule or lexicon entry. Due to space limitations many details of the compilation phase could not be discussed.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "CONCLUSION", |
| "sec_num": "4" |
| }, |
| { |
| "text": "The presented grammar formalism has been used to describe a relevant subset of German language and a smaller subset of Chinese. The grammars describe a mapping between German and Chinese and QLF expressions.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "CONCLUSION", |
| "sec_num": "4" |
| } |
| ], |
| "back_matter": [ |
| { |
| "text": "I would like to thank Ms. Ping Peng and my collegues Manfred Gehrke, Rudi Hunze, Steffi Schachtl and Ludwig Schmid for many discussions on the TUG-formalism.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "ACKNOWLEDGEMENTS", |
| "sec_num": null |
| } |
| ], |
| "bib_entries": { |
| "BIBREF0": { |
| "ref_id": "b0", |
| "title": "Compilers. Principles, Techniques and Tools", |
| "authors": [ |
| { |
| "first": "A", |
| "middle": [ |
| "V" |
| ], |
| "last": "Aho", |
| "suffix": "" |
| }, |
| { |
| "first": "R", |
| "middle": [], |
| "last": "Sethi", |
| "suffix": "" |
| }, |
| { |
| "first": "J", |
| "middle": [ |
| "D" |
| ], |
| "last": "Ullman", |
| "suffix": "" |
| } |
| ], |
| "year": 1986, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Aho, A.V., R. Sethi and J.D. Ullman (1986) Compilers. Principles, Techniques and Tools. Addison-Wesley Publishing Company.", |
| "links": null |
| }, |
| "BIBREF1": { |
| "ref_id": "b1", |
| "title": "Resolving Quasi Logical Forms", |
| "authors": [ |
| { |
| "first": "H", |
| "middle": [], |
| "last": "Alshawi", |
| "suffix": "" |
| } |
| ], |
| "year": 1990, |
| "venue": "Computational Linguistics", |
| "volume": "16", |
| "issue": "", |
| "pages": "133--144", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Alshawi, H. (1990) \"Resolving Quasi Logical Forms\", Computational Linguistics, Vol. 16, pp. 133-144.", |
| "links": null |
| }, |
| "BIBREF2": { |
| "ref_id": "b2", |
| "title": "Two optimizations for Semantic-Head-Driven Generators", |
| "authors": [ |
| { |
| "first": "H", |
| "middle": [ |
| "U" |
| ], |
| "last": "Block", |
| "suffix": "" |
| } |
| ], |
| "year": null, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Block, H. U. (forthcoming) \"Two optimizations for Semantic-Head-Driven Generators\".", |
| "links": null |
| }, |
| "BIBREF3": { |
| "ref_id": "b3", |
| "title": "Using Disjunctive Constraints in a Bottom-Up Parser", |
| "authors": [ |
| { |
| "first": "H", |
| "middle": [ |
| "U" |
| ], |
| "last": "Block", |
| "suffix": "" |
| }, |
| { |
| "first": "L", |
| "middle": [ |
| "A" |
| ], |
| "last": "Schmid", |
| "suffix": "" |
| } |
| ], |
| "year": null, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Block, H. U. and L. A. Schmid (forthcoming) \"Us- ing Disjunctive Constraints in a Bottom-Up Parser\".", |
| "links": null |
| }, |
| "BIBREF4": { |
| "ref_id": "b4", |
| "title": "A new design of Prolog-based bottom-up Parsing System with Government-Binding Theory", |
| "authors": [ |
| { |
| "first": "H.-H", |
| "middle": [], |
| "last": "Chen", |
| "suffix": "" |
| }, |
| { |
| "first": "C.-P", |
| "middle": [], |
| "last": "I-P. Lin", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Wu", |
| "suffix": "" |
| } |
| ], |
| "year": 1988, |
| "venue": "Proc. l~th International Conference on Computational Linguistics (COLING-88)", |
| "volume": "", |
| "issue": "", |
| "pages": "112--116", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Chen, H.-H., I-P. Lin and C.-P. Wu (1988) \"A new design of Prolog-based bottom-up Pars- ing System with Government-Binding The- ory\", Proc. l~th International Conference on Computational Linguistics (COLING-88), pp. 112-116.", |
| "links": null |
| }, |
| "BIBREF5": { |
| "ref_id": "b5", |
| "title": "A Logic-Based Government-Binding Parser for Mandarin Chinese", |
| "authors": [ |
| { |
| "first": "H.-H", |
| "middle": [], |
| "last": "Chen", |
| "suffix": "" |
| } |
| ], |
| "year": 1990, |
| "venue": "Proc. 13th International Conference on Computational Linguistics (COLING-90)", |
| "volume": "", |
| "issue": "", |
| "pages": "1--6", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Chen, H.-H. (1990) \"A Logic-Based Government- Binding Parser for Mandarin Chinese\", Proc. 13th International Conference on Computa- tional Linguistics (COLING-90), pp. 1-6.", |
| "links": null |
| }, |
| "BIBREF6": { |
| "ref_id": "b6", |
| "title": "A Bidirectional Model for Natural Language Processing", |
| "authors": [ |
| { |
| "first": "G", |
| "middle": [], |
| "last": "Neumann", |
| "suffix": "" |
| } |
| ], |
| "year": 1991, |
| "venue": "Proc. 5th", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Neumann, G. (1991) \"A Bidirectional Model for Natural Language Processing\" Proc. 5th", |
| "links": null |
| }, |
| "BIBREF7": { |
| "ref_id": "b7", |
| "title": "Conf. of the European Chapter of the ACL (EACL-91", |
| "authors": [], |
| "year": null, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "245--250", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Conf. of the European Chapter of the ACL (EACL-91) pp. 245-250.", |
| "links": null |
| }, |
| "BIBREF8": { |
| "ref_id": "b8", |
| "title": "Extraposition Grammar", |
| "authors": [ |
| { |
| "first": "F", |
| "middle": [], |
| "last": "Pereira", |
| "suffix": "" |
| } |
| ], |
| "year": 1981, |
| "venue": "Computational Linguistics", |
| "volume": "7", |
| "issue": "", |
| "pages": "243--256", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Pereira, F. (1981) \"Extraposition Grammar\" Computational Linguistics Vol. 7, pp. 243- 256.", |
| "links": null |
| }, |
| "BIBREF9": { |
| "ref_id": "b9", |
| "title": "The design of a Computer Language for Linguistic Information", |
| "authors": [ |
| { |
| "first": "S", |
| "middle": [ |
| "M" |
| ], |
| "last": "Shieber", |
| "suffix": "" |
| } |
| ], |
| "year": 1984, |
| "venue": "Proc. lOth International Conference on Computational Linguistics (COLING-84)", |
| "volume": "", |
| "issue": "", |
| "pages": "362--366", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Shieber, S.M. (1984) \"The design of a Computer Language for Linguistic Information\" Proc. lOth International Conference on Computa- tional Linguistics (COLING-84), pp. 362-366.", |
| "links": null |
| }, |
| "BIBREF10": { |
| "ref_id": "b10", |
| "title": "A Uniform Architecture for Parsing and Generation", |
| "authors": [ |
| { |
| "first": "S", |
| "middle": [ |
| "M" |
| ], |
| "last": "Shieber", |
| "suffix": "" |
| } |
| ], |
| "year": 1988, |
| "venue": "Proc. l~th International Conference on Computational Linguistics (COLING-88)", |
| "volume": "", |
| "issue": "", |
| "pages": "614--619", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Shieber, S.M. (1988) \"A Uniform Architecture for Parsing and Generation\", Proc. l~th Interna- tional Conference on Computational Linguis- tics (COLING-88), pp. 614-619.", |
| "links": null |
| }, |
| "BIBREF11": { |
| "ref_id": "b11", |
| "title": "Semantic-Head-Driven Generation", |
| "authors": [ |
| { |
| "first": "S", |
| "middle": [ |
| "M" |
| ], |
| "last": "Shieber", |
| "suffix": "" |
| }, |
| { |
| "first": "G", |
| "middle": [], |
| "last": "Van Noord", |
| "suffix": "" |
| }, |
| { |
| "first": "F", |
| "middle": [ |
| "C N" |
| ], |
| "last": "Pereira", |
| "suffix": "" |
| }, |
| { |
| "first": "R", |
| "middle": [ |
| "C" |
| ], |
| "last": "Moore", |
| "suffix": "" |
| } |
| ], |
| "year": 1990, |
| "venue": "Computational Linguistics", |
| "volume": "16", |
| "issue": "", |
| "pages": "30--43", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Shieber, S.M., G. van Noord, F.C.N. Pereira and R.C. Moore (1990). \"Semantic-Head- Driven Generation\". Computational Linguis- tics, Vol. 16, pp. 30-43.", |
| "links": null |
| }, |
| "BIBREF12": { |
| "ref_id": "b12", |
| "title": "Automated Inversion of Logic Grammars for Generation", |
| "authors": [ |
| { |
| "first": "T", |
| "middle": [], |
| "last": "Strzalkowsi", |
| "suffix": "" |
| }, |
| { |
| "first": "Ping", |
| "middle": [], |
| "last": "Peng", |
| "suffix": "" |
| } |
| ], |
| "year": 1990, |
| "venue": "Proc. Conf. of the 28th Annual Meeting of the ACL, (ACL-90", |
| "volume": "", |
| "issue": "", |
| "pages": "212--219", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Strzalkowsi, T. and Ping Peng (1990). \"Auto- mated Inversion of Logic Grammars for Gen- eration\" Proc. Conf. of the 28th Annual Meeting of the ACL, (ACL-90) pp. 212-219.", |
| "links": null |
| }, |
| "BIBREF13": { |
| "ref_id": "b13", |
| "title": "How to Invert a Natural Language Parser into an Efficient Generator: An Algorithm for Logic Grammars", |
| "authors": [ |
| { |
| "first": "T", |
| "middle": [], |
| "last": "Strzalkowsiki", |
| "suffix": "" |
| } |
| ], |
| "year": 1990, |
| "venue": "Proc. 13th International Conference on Computational Linguistics (COLING-90)", |
| "volume": "", |
| "issue": "", |
| "pages": "347--352", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Strzalkowsiki, T. (1990). \"How to Invert a Nat- ural Language Parser into an Efficient Gen- erator: An Algorithm for Logic Grammars\" Proc. 13th International Conference on Com- putational Linguistics (COLING-90), pp. 347- 352.", |
| "links": null |
| }, |
| "BIBREF14": { |
| "ref_id": "b14", |
| "title": "E~icient Parsing for Natural Language: A fast Algorithm for Practical Systems", |
| "authors": [ |
| { |
| "first": "M", |
| "middle": [], |
| "last": "Tomita", |
| "suffix": "" |
| } |
| ], |
| "year": 1986, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Tomita, M. (1986). E~icient Parsing for Natural Language: A fast Algorithm for Practical Sys- tems. Boston: Kluwer Academic Publishers.", |
| "links": null |
| } |
| }, |
| "ref_entries": { |
| "FIGREF0": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "movement rules describe a relation between a landing site and a trace. The trace is always c-commanded by the landing site, its antecedent. Two different traces are distinguished, anaphoric traces and variable traces. Anaphoric traces must find their antecedent within the same bounding node, variable trace binding is constrained by subjacency, e.a.the binding of the trace to its antecedent must not cross two bounding nodes.' Anaphoric traces are found for example in English passive constructions Is [np The book' of this author]/ was read ti] whereas variable graces are usually found in whconstructions and~ topicalization. Similar to the proposal in Chen e.a.(1988), argument movement is coded in TUG by a rule that describes the landing site, as for example in s2 ---> np:ante<trace(var,np:tracs), sll ante:fx = trace:fx," |
| }, |
| "FIGREF1": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "s2 ---> sl, traCe(var,np:trace)>np:an~e [ ante:fx = trace:fx," |
| }, |
| "FIGREF3": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "a(tl(A,2)) ---> [b(B), {A = 1 ; ~1(A,2) = B}]." |
| }, |
| "FIGREF4": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "expansion of head movement rules \u2022 transformation of argument movement rules \u2022 elimination of empty productions \u2022 conversion to LR(K) format \u2022 computation of LR. tables" |
| }, |
| "FIGREF5": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "s1(Sl) ---> Iv(v) + sCs)]. s(s) ---> [...,vp(vP),...]. vp(VP) ---> [...,vk(VX) .... ]. vk(VK) ---> [...,v(V),...]." |
| }, |
| "FIGREF6": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": ") ---> [ .... vp(VP),...]. vp(VP) ---> [...,vk(VX),...]. vk(VZ) ---> [...,v(V),...].newly introduced slash rulessl(S1) ---> [v(V), push(v(V)), s_v(S)]. s_v(S) ---> [...,vp_v(VP),...]. vp_v(VP) ---> [ .... vk_v(VX) .... ]. vk_v(VX) ---> [ .... v_v(V),...]. v_vCV)---> [popCvCV))]. empty productions for push and pop push(X) ---> []. pop(X) ---> []." |
| }, |
| "FIGREF7": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "For the control of gaps a gap-threadding mechanism is introduced. Following Chen e.a. (1988), the gap features are designed as multisets, thus allowing crossing binding relations as mentioned in section 2. 7 A slashed category Xl\u00a5 is represented using the under.score character Z_\u00a5.ITo see the effect of this compilation step, take the following fragment as output of the head movement expander.boundlng_node(s(_)). sl(Si) ---> np(NP)<trace(var,np(Trace)), sCs). s(S) ---> np(NP), vp(VP). vp(VP) ---> v(V). vp(VP) ---> v(V), np(NP). trace(np(_)). The argument movement expander transforms this to the followifig grammar. sl(Gi,Go0Sl) --~> np(Gi,Gt,NP), s(Gs,Go,S) I, {cut_trace(trace(var,np(Trace))," |
| }, |
| "FIGREF8": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "[np(Gi,Ot,NP),s(~s,Go,S)], cut_trace(trace(var,np(Trace)), ~s,~t)). dcg_rule(2,sl([trace(_,np(NP))]Gt], s(Gi,Go,S), [np(Gi,Gt,NP),vp(Gt,Go,VP)], bound(Gi)). dcg_rule(4,s([~race(_,np(NP))iGt], Go,S), [vp(Gt,Go,VP)], bo~uad(Gi)). dcg_rule(S,vp(Gi,Go,VP)," |
| }, |
| "FIGREF9": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "Given a rule a(A) ---> b(B)<trace(var,b(BT)), c(C)}" |
| }, |
| "FIGREF10": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "SemIn),Sl,SO).As the antecedent carries the semantic information, it is expanded at the landing site, while the trace is just empty:" |
| }, |
| "FIGREF11": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": ",S,SO)[Go], Go,NPSem),SX,SX) ---> node(np(G,G~NPSem),S,SO)." |
| }, |
| "FIGREF12": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "For instance, in a grammar and lexicon fragment like vk(SC)/Sem ---> aux(VKSem,SC,VKSC)/Sem, vk(VKSC)/VKSem, aux (VKSem, SC, SC)/past (VKSem) ---> [has]. aux (Sere, SC, [Subj [ SC] )/Sere ---> [is]." |
| }, |
| "FIGREF14": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": ",node(b(BSem),S,S1)), a(node(a(f(Sem)),S,SO),gxp)." |
| }, |
| "TABREF2": { |
| "html": null, |
| "text": "...]...].,.]...]To formulate head movement in TUG the following format is used. First, a head definition defines which category is the head of which other.Second, the landing site is defined by a rule like", |
| "num": null, |
| "type_str": "table", |
| "content": "<table><tr><td>[vk \"\"</td><td colspan=\"2\">v ...]...],..]</td></tr><tr><td colspan=\"2\">Is, np~ [s ...</td><td>[vp ...</td></tr><tr><td colspan=\"3\">[vk \"\" trace(vh v is_head_of vk.</td></tr><tr><td colspan=\"2\">vk is_head_of vp.</td></tr><tr><td colspan=\"2\">vp is_head_of s.</td></tr></table>" |
| } |
| } |
| } |
| } |
