| { | |
| "paper_id": "W91-0102", | |
| "header": { | |
| "generated_with": "S2ORC 1.0.0", | |
| "date_generated": "2023-01-19T04:42:37.392574Z" | |
| }, | |
| "title": "Reversibility in a Constraint and Type based Logic Grammar: Application to Secondary Predication", | |
| "authors": [ | |
| { | |
| "first": "Palmira", | |
| "middle": [], | |
| "last": "Marrafa", | |
| "suffix": "", | |
| "affiliation": { | |
| "laboratory": "", | |
| "institution": "FLL -Universidade de Lisboa / ILTEC Ava Engo Arantes e Oliveira", | |
| "location": { | |
| "addrLine": "40 (Lte 41), 8 E. P-1900" | |
| } | |
| }, | |
| "email": "[email protected]" | |
| } | |
| ], | |
| "year": "", | |
| "venue": null, | |
| "identifiers": {}, | |
| "abstract": "In this document, we present a formalism for natural language processing which associates type construction principles to constraint logic programming. We show that it provides more uniform, expressive and efficient tools for parsing and generating language. Next, we present two abstract machines which enable us to design, in a symmetric way, a parser and a generator from that formalism. This abstract machinery is then exemplified by a detailed study of secondary predication within the framework of a principledbased description of language: Government and Binding theory.", | |
| "pdf_parse": { | |
| "paper_id": "W91-0102", | |
| "_pdf_hash": "", | |
| "abstract": [ | |
| { | |
| "text": "In this document, we present a formalism for natural language processing which associates type construction principles to constraint logic programming. We show that it provides more uniform, expressive and efficient tools for parsing and generating language. Next, we present two abstract machines which enable us to design, in a symmetric way, a parser and a generator from that formalism. This abstract machinery is then exemplified by a detailed study of secondary predication within the framework of a principledbased description of language: Government and Binding theory.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Abstract", | |
| "sec_num": null | |
| } | |
| ], | |
| "body_text": [ | |
| { | |
| "text": "Lexical as well as grammatical and discursive knowledge required to understand or to produce natural language utterances is usually a description which is independent of the sentence production or comprehension 'algorithms'. It comes naturally into mind to have a common, shared knowledge base of what language is, independently of its potential uses. Besides well-known advantages of uniformity and transparency, this point of view is very convenient for the computer scientist who does not have to integrate into his parsers or generators the unavoidable updafings required by grammar development. The linguistic knowledge is thus specified in a declarative way in different modules (lexical, grammatical, discursive .... ) and different strategies are applied which refer to these data (directly for interpreters or via the production of a compiled code for compilers). This approach can however be realiTed more or less easily depending on the formalisms used to describe language phenomena.", | |
| "cite_spans": [ | |
| { | |
| "start": 685, | |
| "end": 725, | |
| "text": "(lexical, grammatical, discursive .... )", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "In this document we introduce new advanced tools of the Logic Programming framework and show that they contribute to meeting the requirements imposed by the manipulation and the control of large amounts of data required by both the parsing and the generation procedure. We first consider logical types which are a declarative and easy-to-use tool and formalism which permit a grammar writer to encode knowledge in a very flexible and principled-based way.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "In addition to types, we introduce new active constraints of the Constraint Logic Programming (CLP) framework which allow us to treat and to check for consistency of constraints throughout the whole generation procedure and not to only evaluate them when they are given in the programme or grammar. These active constraints are fully declarative and can be used by any type of parsing/generation process. CLP introduces a greater expressive power together with a higher efficiency since the resolution of constraints is postponed till they can be properly evaluated and since constraints have to be always true and consistent with each other. Finally, a feature of active constraints is that they are usually independent of the way they are processed, they are thus strategy independent and can equivalently be used for parsing and for generation.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "To make reversibility concrete in our system, we develop in this document two different abstract machines based on type construction and constraint satisfaction which give the foundations of a parser and a generator using the same source of declarative linguistic knowledge. The differences between these machines exemplifies the 'technical' differences one may have between parsing and generation processes.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Three major types of operations are at the basis of the typed-based language we have designed for language processing, namely:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A type based description language", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "-the expression of type construction to generate phrase structures, -the expression of dependencies (either local or long-distance) between types, -the expression of well-formedness constraints on types.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A type based description language", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "Types here refers to the usual data structures in computer science. We now informally present the syntax of our type-based language. It is directly derived from the syntax of Login (Ait-Ka~i and Nasr 86). The syntactic representation of a structured term is called a V-term. It consists of:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A type based description language", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "(1) a root symbol, which is a type constructor and denotes a class of entities,", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A type based description language", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "(2) attribute ~labels, which are record field symbols. Each attribute denotes a function in extenso, from the root to the attribute value. The attribute value can itself be a reference to a type.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A type based description language", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "(3) coreference constraints among paths of labels, which indicate that the corresponding attributes denote the same function. They are indicated by variabies. Here is an example:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A type based description language", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "person( id => name(first => string, last => X: string),", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A type based description language", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "born => date(day => integer, month => monthname, year => integer),", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A type based description language", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "father => person( id => name(last => X ))).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A type based description language", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "The root symbol is person; id, born and father are three Sub-V-terms which have either constants or type s as values. X indicates a coreference. All different type structures are tagged by different symbols. Notice also that in the latter field only relevant information about person is mentioned. Infinite structures can also be specified by coreference links. Variables are in capital letters, constants in small letters.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A type based description language", | |
| "sec_num": "1." | |
| }, | |
| { | |
| "text": "We have extended the type description framework with active constraints and have given them a Constraint Logic Programming (Colmeraner 90, Jaffar and Lassez 87) interpretation, permitting us to have a more principled-based description of language. The general form of a type is :", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Dealing with constraints", | |
| "sec_num": "2." | |
| }, | |
| { | |
| "text": "Type :-Constraints. We view constraints as part of the type:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Dealing with constraints", | |
| "sec_num": "2." | |
| }, | |
| { | |
| "text": "(Type :-Constraints)", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Dealing with constraints", | |
| "sec_num": "2." | |
| }, | |
| { | |
| "text": "is itself a type, subsumed by Type.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Dealing with constraints", | |
| "sec_num": "2." | |
| }, | |
| { | |
| "text": "The simplest constraint is the precedence constraint:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Dealing with constraints", | |
| "sec_num": "2." | |
| }, | |
| { | |
| "text": "preeede(X,Y), where X and Y are of type string. This constraint imposes that the string X precedes of the string Y. When processing a sentence, precedence constraints on constituents are stated in the grammar rules and possibly at the lexical level. At each stage i of the processing, there is a partial order Pl(i) on the words and structures already processed. At the end of the process, precedence constraints give all the possible word orderings which meet the constraints of the grammar. In the case of parsing, constraints imposed by the order of words in the input string must be coherent with the precedence results of the parse.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Dealing with constraints", | |
| "sec_num": "2." | |
| }, | |
| { | |
| "text": "The next constraaint imposes the presence of an attribute in a type:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Dealing with constraints", | |
| "sec_num": "2." | |
| }, | |
| { | |
| "text": "has(Attribute, Type)", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Dealing with constraints", | |
| "sec_num": "2." | |
| }, | |
| { | |
| "text": "where Attribute is either an attribute label or a full pair attribute-value and Type is a reference to a given type. This constraint imposes that at some stage there is an attribute in Type which is subsumed by or equal to Attribute. Informally, (1) when incoherence with Attribute is detected or (2) when Type is fully constructed, the non-satisfaction of has(Attribute,Type) will provoque backtracking. This constraint permits us to encode thematic role assignment and focus management, and also to encode the inclusion of a set of values into another.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Dealing with constraints", | |
| "sec_num": "2." | |
| }, | |
| { | |
| "text": "The last class of constraint is mainly related to the expression of long-distance relations between sentence constituents. Within the framework of types, the notion of long-distance is somewhat obsolete since there is no ordering relation on subtypes in a type (attributes may be written in any order). Thus, the notion of long-distance dependency will be here formulated as a sub-type co-occurence constraint. This constraint emerged from Dislog (Saint-Dizier 87, 89). Very briefly, the co-occurence of two or more subtypes in a larger type is expressed by the constraint: ponding(A,B) where A is a type specification and B is a list of type specifications. Informally, this constraint means that A originates the pending of the sub-types in B, in other terms that A can be used if, somewhere else in the main type (corresponding for example to a full sentence), all the sub-types in B are used with identical substitutions applied to identical variables.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Dealing with constraints", | |
| "sec_num": "2." | |
| }, | |
| { | |
| "text": "We will mainly present here simple, motivational examples. A more abstract syntactic description will be given in section 6 which will more fully motivate our approach. The examples given in this text show that our description language can accomodate principled-based descriptions of language like Government and Binding theory as well as lexicaUy and head driven descriptions like in the HPSG framework.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Processing Language with types and constraints", | |
| "sec_num": "3." | |
| }, | |
| { | |
| "text": "In the following simple examples, we only have two main type constructors:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Processing Language with types and constraints", | |
| "sec_num": "3." | |
| }, | |
| { | |
| "text": "-x0 corresponding to lexical entries, -xp corresponding to phrase structures.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Processing Language with types and constraints", | |
| "sec_num": "3." | |
| }, | |
| { | |
| "text": "Here is the description of the lexical entry corresponding to the verb to give:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Processing Language with types and constraints", | |
| "sec_num": "3." | |
| }, | |
| { | |
| "text": "xO( cat => v, string => [give] ) :- pending(xO(cat => v), [xp( cat => n, string => $1, role => patient ),", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Processing Language with types and constraints", | |
| "sec_num": "3." | |
| }, | |
| { | |
| "text": "xp( cat => p, string => $2, role => recipient) ] ), precede([give],S1), precede(S1, $2).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Processing Language with types and constraints", | |
| "sec_num": "3." | |
| }, | |
| { | |
| "text": "This entry says that give is a verb which subcategorizes for an np with role patient and a pp with role recipient; np and pp are left pending. The string S 1 generated from the np has to precede the string $2 generated from the pp. These constraints will be treated at the level of the type describing the structure of a vp. The whole description xO construction and related constraints is the type of the verb to give, Let us now consider the construction of a vp with an np and a pp complements. To the construction of a vp type corresponds the generation of a (set of) string(s) corresponding to a via, this is stored in S. We then have the following construction:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Processing Language with types and constraints", | |
| "sec_num": "3." | |
| }, | |
| { | |
| "text": "xp( cat => v, string => S, constl => xO(cat => v ), const2 => X : xp(cat => n), const3 => Y : xp( cat => p) ) :-", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Processing Language with types and constraints", | |
| "sec_num": "3." | |
| }, | |
| { | |
| "text": "has(role, X), has(case, X), has(role, Y), has(case, Y).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Processing Language with types and constraints", | |
| "sec_num": "3." | |
| }, | |
| { | |
| "text": "The constraints has(role,X) and has(role,Y) impose that the constituents const2 and const3 have a role assigned at some level of the type construction process. The same situation holds for case. This is a simple expression, for example, of the case filter in GB theory. Notice that most pending situations are satisfied locally, which limits complexity.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Processing Language with types and constraints", | |
| "sec_num": "3." | |
| }, | |
| { | |
| "text": "Parsing a sentence is constructing a well-formed type describing the sentence structure. We present in this section an abstract machine which describes how types are constructed. This machine is based on the procedural semantics of Prolog but it resembles a push-down tree automaton whose stack is updated each dine a subtype is modified.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An abstract machine for type construction in a parsing process", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": "There are two kinds of type constructors: those corresponding to non-terminal structures (such as xp and x 1 in our examples) and those corresponding to terminal structures (e.g. x0). We now present a step in the construction of a type. It can be decomposed into 3 levels:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An abstract machine for type construction in a parsing process", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": "(1) current state o i :", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An abstract machine for type construction in a parsing process", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": "cO( a 1 => t 1, a 2 => t 2 ..... a n => tn),", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An abstract machine for type construction in a parsing process", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": "(2) selection in the current programme P of a type construction specification: cl(b 1 => t' 1 ..... b m =>t' m) such that t 1 subsumes it or unifies with it modulo the mgn 0 i.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An abstract machine for type construction in a parsing process", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": "(3) New state \u00b0i+l : tl is replaced by :", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An abstract machine for type construction in a parsing process", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": "el( b 1 => t' 1 ..... b m => t' m )", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An abstract machine for type construction in a parsing process", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": ", with, as a result, the following type:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An abstract machine for type construction in a parsing process", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": "co(a 1 => cl(b 1 => t' 1 ..... b m => t' m ), a 2 => t 2 ..... a n => t n) 0 i", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An abstract machine for type construction in a parsing process", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": "The process goes on and processes t' 1\" The type construction strategy is here similar to Prolog's strategy and computation rule : depth-first and from left to right. The main difference at this level with SLD-resolution is that only types corresponding to non-terminal structures are expanded. Informally, when a type tj corresponds to a terminal structure, an attempt is made to find a terminal type description t'j in the programme which is subsumed by or unifies with t.j and, if so, a replacement, occurs, t'j is said to be in a final state. If t j does not exist, backtracking occurs. The next type description immediately to the right of t'j is then treated in the same manner. The type construction process successfully ends when all subtypes corresponding to terminal symbols are in a final state and it fails ff a terminal type description tp cannot reach a final state. The initial state: is :", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An abstract machine for type construction in a parsing process", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": "xp( cat => sentence i string => [ string,to,parse] ).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An abstract machine for type construction in a parsing process", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": "The above abstract machine can be extended in a simple way to deal with constraints. Constraint resolution mechanisms are similar to usual constraint logic programming systems like Prolog IH. The three above le~,els become:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Extension of the abstract machine to constraints", | |
| "sec_num": "4.2." | |
| }, | |
| { | |
| "text": "(1) current state \u00b0i represented by the couple: < c0(a l=>t 1, a 2=>t 2 ..... a n=>tn),S > where S is the set of current constraints,", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Extension of the abstract machine to constraints", | |
| "sec_num": "4.2." | |
| }, | |
| { | |
| "text": "(2) selection in the current programme P of a type construction specification:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Extension of the abstract machine to constraints", | |
| "sec_num": "4.2." | |
| }, | |
| { | |
| "text": "cl(b 1 => t'l, ...; b m => t' m ) :-R.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Extension of the abstract machine to constraints", | |
| "sec_num": "4.2." | |
| }, | |
| { | |
| "text": "where R is the set of constraints associated to cl, and t 1 subsumes Or unifies with t' 1 modulo the mgu 0 i.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Extension of the abstract machine to constraints", | |
| "sec_num": "4.2." | |
| }, | |
| { | |
| "text": "(3) New state o i+ 1 characterized by the following couple:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Extension of the abstract machine to constraints", | |
| "sec_num": "4.2." | |
| }, | |
| { | |
| "text": "< c0(a 1 =>cl(b 1 => t' 1 ..... b m => t' m), a 2 => t 2, .... a n => t n) 0 i , S u R u subsume(tl,Cl( b 1 => t' 1 ..... bm =>i t'm ) ) >", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Extension of the abstract machine to constraints", | |
| "sec_num": "4.2." | |
| }, | |
| { | |
| "text": "with the condition that the new set of constraints must be satisfiable with respect to the constraint resolution axioms defined for each type of constraint and, if not,:a backtracking occurs. At this level constraints simplifications may also occur.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Extension of the abstract machine to constraints", | |
| "sec_num": "4.2." | |
| }, | |
| { | |
| "text": "The output of the parsing process may be simply a syntactic tree, but it may also be a logical formula, similar to the one used and presented in section 5. We however think that both processes, parsing and generating, need not necessarily respectively produce and start from the same abstract internal representation.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Extension of the abstract machine to constraints", | |
| "sec_num": "4.2." | |
| }, | |
| { | |
| "text": "From the above declarative descriptions of language construction, an abstract machine for language generation can also be defined. At the level of type construction, generation proceeds by monotone increasing restrictions: a phrase structure z is described by a type constructor linking a set of subtypes. This operation introduces a restriction on the possible left and right contexts that each of the subtypes could potentially have if they were independent from each other. The degree of generality of the selected type constructor linking those subtypes can be subject to various interpretations. Finally, generation is guided by the semantic representation from which a sentence is uttered. As shall be seen, the semantic representation will determine the computation rule and the subgoal selection procedure. It is thus much more deterministic than its parsing process counterpart.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "Let us now briefly consider the abstract machine for language generation. The general technique, that we have already exemplified in (Saint-Dizier 89), consists in:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "-(1) writing a formal grammar of the semantic representation from which the generation process starts, -(2) identifying the phrasal units and the lexical units (and intermediate units if necessary) which can be associated to the symbols of that formal grammar, -(3) associating generation points to these symbols (terminal and non-terminal) which will generate natural language ffi-agrnents based on a consultation of the grammatical and the lexicai system (these generation points could be added automatically).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "For example, if the formal grammar of the semantic representation of quantified noun phrases is:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "Quant_np--> det([Quant, Var], Np,", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "Rest of sentence). Np --> and( Noun, Modifiers ).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "We then have, for example, and informally, the following generation points, where the call p(formula, string, corresponding syntactic category) The relation between a predicate (or an argument) and a word is established by a call to a lexical entry as follows: p(Predieate, Type) :-Type, has(Type, sem_rept => Predicate ).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "Informally, Typel and Type2 are constructed from the treatment of the quantifier and the noun phrase, they are then combined, in the first rule above, by means of the first call to generation_point, resulting in Type3. This generation point includes the treament of the string of words being generated (including the precedence constraints on the words generated from lexical insertion) and the treatment of more abstract features such as category, inflection or semantic characteristics. Finally, the second call to generation_point integrates Type3 with Type4, the latter being the type associated to the remainder of the sentence. The result is Type.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "Generation points support by themselves the generation strategy. A model of these generation points is given below by means of an abstract machine. As can be noticed, calls to generation points occur after the parse of the corresponding semantic structure. This means that calls to generation points will be stacked (by Prolog) and will be then unstacked in the reverse order they have been stacked: the strategy is then bottom-up.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "Generation points determine, by means of a call to the grammatical system, the resulting syntactic category and the way the partial strings of words ill Type1, Type2 and Type4 are assembled. The way types are constructed by generation points is modelled by the following abstract machine. At this level, we generalize the generation points to take into account any number of subtypes, and not only two as shown in the examples.We claim that this method is general and can be used from most current semantic representations (such as, for example, DRT or Conceptual Graphs).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "The abstract machine for language generation can be described by its initial state and a step in the construction procedure. It has the general form of a finite state tree automaton. The initial state is o 0, it is the empty type. Let us now consider a step a i .", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "1. Two cases arise: it is either (a) a set of subtypes from which a more general type can be constructed:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "o i = (a) (C 1, C 2 ..... C n)", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "is an unordered sequence of subtypes ; or (b) it is a single type : o i = D1 2. Type constructor selection:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "(a) let DC be such that: DC has exactly k attributes constj, k <_ n, and DC is of the form:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "DC := xp( .... const I => C' 1 ..... const k => C' k )", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "and: for all j E [ l,k], subsume(C'i, Ci ) (notice that the Cj are not n~cess~rily the jtn element of the list given in 1 above, notice also that the type constructor DC contains the subtypes constq together with other information like category and morphology.) or (b) D' (single type)", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "3. o i+l = (a)(DC,Ck+ 1 ..... C n) for all i, j E [1,k] or (b) (D1, D').", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "The type constructor DC contains the subtypes constq together with other information like category and rhorphology. It should be noticed that the constructor DC is selected according to a subsumption criterion, which is more general and powerful than standard unification. It better corresponds to the process of incremental generation of phrases. The process ends when a type with category sentence is reached. This is a terminal state in the automaton, more precisely it is the root of the tree automaton, since our generation system proceeds in a bottom-up fashion.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "Let us now consider the step 2 above devoted to the selection of a type constructor. This selection is mainly guided by the generation points given in the formal grammar of the semantic representation. They indeed select between cases (a) or (b) and in case (a) they directly characterize which of the C i will be included in the type construction at the current stage. Finally, since active constraints associated to type descriptions can be executed at any time, the constraint resolution mechanisms which maintain constraint coherence are independent of the generation strategy. In other terms, these mechanisms are independent of the way and the order constraints are added to the set of active constraints.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "The abstract machine which handles types and constraints is the following. It is represented by a tuple: <type, set of active constraints>.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "We then have:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "1. ai= ", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Abst:ract Machine for Language Generation", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "At the end of the generation process, the set of possible admissible surface sentences can be directly derived from the preddence constraints which may not be a total order (some words may have different positions).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "(b) < (DI, D'), S u R >", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "We now present a more elaborate and comprehensive example which will further motivate our approach. Secondary predication is described at both lexical and syntac'fic levels, the intertwining of several constraints makes it simpler to describe in a fully declarative way. The description is thus independent of its use~ parsing or generation. This gives a good application example of the specification and use of our formalism and system for a real phenomenon of mueh importance to natural language system designers.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Application to Secondary Predication", | |
| "sec_num": "6." | |
| }, | |
| { | |
| "text": "Secondary Predication is a term used in the literature to denote a very productive structural relationship in many languages: the relationship between a subject and a predicate, the subject being assigned a thematic role by that predicate and by an obligatory thematic roie assigner in the sentence, namely the verb. For instance, in 1(1) Mary drinks the water cold the water, the direct object of drinks, is assigned a thematic role by this verb and another one by the adjective cold. Then, water is, at the same time, an object for drinks and a subject for cold. In other terms, water integrates -as an object -a primary predication which corresponds to the whole sentence, and -as a subject -a secondary predication which corresponds to the sequence the water cold.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "A linguistic approach", | |
| "sec_num": "6.1" | |
| }, | |
| { | |
| "text": "Secondary predication is not an uniform or an homogeneous phenomenon, neither from the point of view of a specific language, nor from a crosslinguistic one. We will describe here some of the most relevant structural properties and lexical constraints of this type of construction in French. Let us begin by considering the French sentence corresponding to (1):", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(2) Marie bolt l'eau froide.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(2) is an ambiguous sentence as can be illustrated by the paraphrases below (the English translations of the examples are, all of them, literal translations):", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(2) (a)( Marie boit l'eau qui est froide (\"Mary drinks the water which is cold\") (b) Quand Marie boit l'eau, l'eau est froide. (\"When Mary drinks the water, the water is cold\")", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "Considering the interpretation in (2)(a), the adjective is part of the direct object of the verb, which is not the case for the interpretation in (2)(b). Then, l'eaufroide can have the structure In (3)(a)froide is a modifier of eau, while in (3)(b) it behaves as a predicate, assigning a secondary thematic roleto the NP. The predication relationship is expressed by coindexation.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "Let us now consider the sentence (4): (4) Marie boit i'eau mindrale (\"Mary drinks the water mineral'9", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "In spite of its superficial structural resemblance with the example above, (4) is not ambiguous, the interpretation corresponding to the paraphrase (b) being not available:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(4)(a) Marie boit l'eau qui est min~rale (\"Mary drinks the water that is mineral\") but :", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(4)(b) *Quand Marie boit l'eau, l'eau est min~rale (\"When Mary drinks the water, the water is mineral \") This means that the possibility of having or not having an object-oriented secondary predication depends on the semantic nature of the adjective. Moreover, there also exist semantic co-occurrence reslrictions between the adjectival predicate and the verb:", | |
| "cite_spans": [ | |
| { | |
| "start": 102, | |
| "end": 104, | |
| "text": "\")", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(5) *Marie boit l'eau congel~e (\"Mary drinks the water frozen'9 (5) is excluded because something frozen cannot be drunk. Notice that the presence of an adjective in sentences like (2) is optional, in opposition to what happens in sentences like (6) (for the same interpretation of the verb):", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(6) Marie considdre l'eau froide (\"Mary considers the water cold\") (6)(a) *Marie considdre l'eau \"Mary considers the water\")", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "What we can infer from the fact that (6)(a) is ruled out is that: (i) conside'rer (to consider) does not subcategorize for an NP, then fro/de can not be a modifier of l'eau; (ii) if fro/de is not a modifier of l'eau it must be a predicate, but, in this case, we dont have the structure presented in (3)(b). In fact, l}au froide behaves like a clausal phrase. It can even be replaced by a completive sentence (the semantic interpretation remaining the same) as exemplified in (6)(b):", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(6)(b) Marie considdre que l'eau est froide (\"Mary considers that the water is cold\")", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "We have then empirical evidence to analyse l'eaufroide in (6) as a clause, a \"small clause\" using an usual label in the literature (since the categorial status of the small clause is irrelevant for our purposes, we will only use the symbol \"SC\" to refer to this constituent, assuming the small clauses analysis proposed by Stowell (1981) and Stowell (1983) ). As a consequence, l'eau froide is a predication having the structure in (7):", | |
| "cite_spans": [ | |
| { | |
| "start": 323, | |
| "end": 337, | |
| "text": "Stowell (1981)", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 342, | |
| "end": 356, | |
| "text": "Stowell (1983)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(7) [SC[NP i l'eau] [AP i froide]] In this case it is the whole predication, and not only its subject, which is theta-marked by the verb. Stricto sensus, we have not a secondary predication, nevertheless, the conlrastive analysis remains important since the two kinds of structures are superficially very similar.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "As largely assumed in the GB framework (Chomsky (1981) and (1986)), predication is configurationnaly constrained: subject and predicate must be reciprocally m-commanded, that is, all maximal projections (phrase levels) dominating one of them must dominate the other one. Given this condition and the facts we have examined, (8) and (9) are appropriate representations (we use here X-bar notation only when relevan0, respectively, for 2and (6):", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(8) [S [NP Marie] IV\" [V'[V boit] [NP i l'eau] ] [AP i froide]]] (9) [S [NP Marie] [V\"[V'[V consid&e] [SC [NP i l'eau] [AP i froide]]]]]", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "Although attached to different nodes inside V\" (while in (8) the subject of the secondary predication occupies the direct object position and its predicate is in a weak adjunction position (in the sense of Demonte (1988) ), in (9) subject and predicate are together in direct object position), the predications we have considered so far involve only adjacent elements. Let us now examine sentence (10):", | |
| "cite_spans": [ | |
| { | |
| "start": 206, | |
| "end": 220, | |
| "text": "Demonte (1988)", | |
| "ref_id": "BIBREF1" | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(10) La lessive rend le linge blanc (The washing makes the clothes white\") Similary to what happens in (6), the sentence is ruled out if the adjecfif is not present:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(lO)(a) *La lessive rend le linge (\"The washing makes the linge\") With respect to these facts it seems to be natural that sentence (10) is structurally identical to (9). Nevertheless, (10)(b), which is equivalent to (10), does not support this hypothesis:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(lO)(b) La lessive blanchit le linge (\"The washing whitens the clothes\") As we can observe, blanchit, a verbal predicate, can replace the verb -rend -and the adjectival predicate blanc (for the same semantic interpretation). Then, rend blanc behaves like a single predicate. At the same time, blanc is a secondary predicate for linge. Following a proposal by Marrafa (1983) and (1985) for similar cases in Portuguese, we consider rend blanc as a discontinuous complex predicate and we express the relationship between the two elements that constitue it by co-superscription. Therefore, (10) has the structure (10)(c),where k indicates the discontinuity in the predicate rend-blanc :", | |
| "cite_spans": [ | |
| { | |
| "start": 359, | |
| "end": 377, | |
| "text": "Marrafa (1983) and", | |
| "ref_id": "BIBREF1" | |
| }, | |
| { | |
| "start": 378, | |
| "end": 384, | |
| "text": "(1985)", | |
| "ref_id": "BIBREF1" | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "(10)(c) [S[NP La lessive] [V\"[V'[V k rend] [NP i le linge] [Apki blanc]]]]", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Object-oriented Predicates", | |
| "sec_num": "6.1.1" | |
| }, | |
| { | |
| "text": "Discontinuity can also be an obligatory property of a certain kind of secondary predication, namely in the case of subject-oriented predicates. (11) is an example:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Subject-oriented predicates", | |
| "sec_num": "6.1.2" | |
| }, | |
| { | |
| "text": "(11) Jean dansait triste (\"John dansed sad\") Since Jean is a proper noun, it can not be modified. Then triste is necessarily a predicate for John. Although the subject of triste is the main subject and not an NP in object position as in the above sentences, there are semantic co-occurrence constraints between the verb and the adjectival predicate, as illustrated below:", | |
| "cite_spans": [ | |
| { | |
| "start": 25, | |
| "end": 44, | |
| "text": "(\"John dansed sad\")", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Subject-oriented predicates", | |
| "sec_num": "6.1.2" | |
| }, | |
| { | |
| "text": "(11)(a) *Jean dansait repenti (\"John dansed repented\") Taking into account these constraints and not violating the m-command condition refered to above, we represent the adjectival predicate as an strong adjunction (again in die terms of Demonte (1988) ) to V\", the syntactic representation of (11) being, then, Notice that continuous and discontinuous secondary predication s can co-occurre in the same sentence:", | |
| "cite_spans": [ | |
| { | |
| "start": 238, | |
| "end": 252, | |
| "text": "Demonte (1988)", | |
| "ref_id": "BIBREF1" | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Subject-oriented predicates", | |
| "sec_num": "6.1.2" | |
| }, | |
| { | |
| "text": "(12)Jean i boit l'eauj froidej triste i (\"John drinks the 'water cold sad\")", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Subject-oriented predicates", | |
| "sec_num": "6.1.2" | |
| }, | |
| { | |
| "text": "It is also interesting to point out that, in certain cases, sentences are iambiguous with respect to continuous and discontinuous secondary predication:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Subject-oriented predicates", | |
| "sec_num": "6.1.2" | |
| }, | |
| { | |
| "text": "(13)Jean i laisse son amiej triste i j (\"John left his girlfriend sad\")", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Subject-oriented predicates", | |
| "sec_num": "6.1.2" | |
| }, | |
| { | |
| "text": "To summarize, secondary predication can be associated to different types of structure and to continuous or discontinuous elements. Moreover, there are numerous and different semantic cooccurrence restrictions ~ of different types affecting the lexical items invoNed.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Subject-oriented predicates", | |
| "sec_num": "6.1.2" | |
| }, | |
| { | |
| "text": "We now show how the above examples are expressed both at syntactic and lexical levels. The full syntactic structures are given under (8), (9), (10c) and (1 lb). The structure in (8) says that the AP is a sister of the V' (noted in the grammar as V with bar level 1) and that the AP is co-indexed with the object NP, the co-indeXation relation is left pending since it is preceded by the V' description. We have the following construction: Since the AP is not obligatory (it is a weak adjunct), there is nothing said about it in the lexicon.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "xp( cat => v, string => SV, constl => xl( cat => v", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "Construction 9introduces a small clause (noted here as sc). Since it is not necessarily contiguous to the V', but only dominated by the V', we need a pending constraint. The type construction is the following:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "xl( cat => v, string => SV, constl => xO( cat => v, string => $1 ), const2 => xp( cat => sc, string => $2 ) ) :- pending(x1 (cat => v),[xl( cat => sc, string => SV, constl => xp( cat => n, index => I, string => $3), const2 =>", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "xp( cat => a, string => S4,index => I ) ) ] ), precede(S1,S2), precede(S3,S4).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "The lexical entry of the verb (here considerer)", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "has a pending constraint for the small clause: the verb subcategorizes for a small clause.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "Construction (10c) introduces a double indexation but no long-distance dependency for the compound predicate 'rend-blanc'. We represent it as follows:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "xl( cat => v, string => SV, constl => xO( cat => v, compound_..pred => K, string => $1),", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "const2 => xp( cat => n, index => I, string => $2 ), const3 => xp( cat => a, index => I, string => $3, compound pred => K ) ) :precede(S1 ,$2), precede(S2,S3).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "Finally, the construction given in (llb) introduces a long-distance relation between an NP in subject position and an AP which is in object position. To handle this phenomenon, we have to go up to the sentence level, that we will represent here for simplicity as s (instead of, for example, COMP). The type construction is the following:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "xp( cat => s, string => SV, constl => xp( cat => n, string => $1, index => I ), const2 => xp(cat=>v, string => $2 )) :- pending(xp(cat => s),[xp( cat => v, string => T, constl => xp( eat => v,string => S3), const2 => xp( cat => a, string => $4, index => I ) ) ] ),", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "precede(S1 ,$2), precede(S3,S4).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "At the lexical level, the adjoined AP is not mentioned, since it is not syntactically necessary (but it might be necessary from a semantic point of view, as also for case (8) above).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Implementation in terms of types and constraints", | |
| "sec_num": "6.2" | |
| }, | |
| { | |
| "text": "Our approach can be contrasted mainly with the usual systems based on unification grammar (UG) formalisms (Shieber, 86), (Emele and Zajac 90). The first major difference is that the unification and rewriting mechanisms usually associated with UG are replaced by a more constraining operation, type construction, which always proceeds by sucessive restrictions (or monotone increasing specialisation) each time a type is further expanded. From that point of view, our approach also substantially differs from (Ait Ka~i and Nasr, 86) who propose a powerful and semantically clear mechanism for typed unification associated to type inheritance.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Specific features of our approach", | |
| "sec_num": "7." | |
| }, | |
| { | |
| "text": "Next, we have a single operation: type construction; we do not have on the one hand grammar rules and on the other hand, associated to each rule, a set of equations to deal with feature values and constraints. The constraints we have associated with our types are not of the same nature and cannot be compared to the equations of UGs. They are moreover a part of the type.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Specific features of our approach", | |
| "sec_num": "7." | |
| }, | |
| { | |
| "text": "Constraints added to types are interpreted within the CLP framework, this permits us to have a more expressive and powerful constraint system, which is also more efficient and simpler to write. Constraint satisfaction is not indeed guaranteed at the level they are given, but throughout the whole type construction process.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Specific features of our approach", | |
| "sec_num": "7." | |
| }, | |
| { | |
| "text": "Our approach is compatible with the current principled-based approaches to describing languages. This is exemplified in section 4 by the constraints on role and case assignments. In a more general way, the description language we have presented here is particularly appropriate for highly abstract descriptions of language, which corresponds to several current trends in computational linguistics. Our description language is, in the same time, well-adapted to deal with lexical-based approaches to language processing (those approaches like lexicon grammars where the lexicon plays a central role) and to describe representations developed within lexical semantics.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Specific features of our approach", | |
| "sec_num": "7." | |
| }, | |
| { | |
| "text": "Finally, a constraint like pending generalises the notion of long-distance dependency to several other kinds of dependencies. This generalization is in particular a consequence of the fact that type structures do not have any ordering on subtypes and they cannot, thus, directly express the difference between remote and close constituents.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Specific features of our approach", | |
| "sec_num": "7." | |
| }, | |
| { | |
| "text": "Besides these general properties, our approach has several interesting properties which are more specific to reversibility. First, the common data shared by the two processes is all the linguistic data which is specified in a declarative way: lexical and grammatical. The semantic composition rules are the same. In the case of generation, they are translated into a parser of the formal grammar of this semantic representation. It should be pointed out that the parser given in section 5 can be generated automatically.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Specific features of our approach", | |
| "sec_num": "7." | |
| }, | |
| { | |
| "text": "Both processes also have a lot of elements in common at the procedural level: the type construction mechanisms are identical, the major difference at this level being the selection rule, which is, in the ease of generation, guided by the semantic form from which the process starts. The other difference is that parsing proceeds a priori topdown in the case we have exemplified (it could also proceed bottom-up). Generation proceeds bottom-up, for reasons explained in section 5. From this difference it results that the starting type in the case of parsing is a general type corresponding to sentence whereas there are no starting type in the case of generation, the starting points being the types corresponding to the predicates appearing in the logical formula, which are deduced from an operation close to lexical insertion. If the parsing process were bottom-up, then the starting types would be the same and the subsumpfion operation would also be used instead of the standard unification.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Specific features of our approach", | |
| "sec_num": "7." | |
| }, | |
| { | |
| "text": "Finally, and most importantly, the constraint system that we have presented is fully independent of the strategies used and of the direction of the process: generation of parsing. This is a consequence of the fact that constraints are evaluted only when there is sufficient available information to evaluate them and also that their coherence with the other constraints is checked throughout the whole proof construction procedure. The variables which are used by active constraints are thus global variables.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Specific features of our approach", | |
| "sec_num": "7." | |
| }, | |
| { | |
| "text": "In this document, we have first defined a formalism based on t~jpes and active constraints of the Logic Programming framework and have shown that it is well-appropriate to describe language constructions. We have in particular illustrated it by focussing on secondary predication, an important phenomenon in langt~age processing. Finally, we have shown that our formalism is particularly appropriate to be used by a parser and by a generator, in a symmetric way, and we have defined for that prupose two abstract machines. This work is now fully implemented in Sicstus Prolog (which allows the writing of constraint resolution mechanism) on a Sun workstation. Since constraints are so far metainterpreted, we cannot make real comparisons with existing NLP systems. A significant result is however the much smaller number of backtraking operations that we havelobserved.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Conclusion", | |
| "sec_num": null | |
| } | |
| ], | |
| "back_matter": [ | |
| { | |
| "text": "We thank N. Hathout for his insightful comments on this work, which was supported by the PRC Communication ' Homme-Machine and the French ministry of rese~trch.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Acknowledgements", | |
| "sec_num": null | |
| } | |
| ], | |
| "bib_entries": { | |
| "BIBREF0": { | |
| "ref_id": "b0", | |
| "title": "LOGIN: A Logic Programming Language with Built-in Inheritance", | |
| "authors": [ | |
| { | |
| "first": "H", | |
| "middle": [], | |
| "last": "Ait-Ka~i", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "R", | |
| "middle": [], | |
| "last": "Nasr", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "A", | |
| "middle": [], | |
| "last": "Colmerauer", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": 1981, | |
| "venue": "Lectures on Government and Binding, Foris", | |
| "volume": "3", | |
| "issue": "", | |
| "pages": "33--40", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "Ait-Ka~i, H., Nasr, R., LOGIN: A Logic Programming Language with Built-in Inheritance, journal of Logic Programming, vol. 3, pp 185-215, 1986. Chomsky, N., Lectures on Government and Binding, Foris, 1981. Chomsky, N., Barriers, Linguistic Inquiry monograph no 13, MIT Press, 1986. Colmerauer, A., An Introduction to Prolog III, CACM 33-7, 1990.", | |
| "links": null | |
| }, | |
| "BIBREF1": { | |
| "ref_id": "b1", | |
| "title": "Saint-Dizier, P., A generation Strategy based on GB Principles, proc", | |
| "authors": [ | |
| { | |
| "first": "V", | |
| "middle": [], | |
| "last": "Demonte", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "M", | |
| "middle": [], | |
| "last": "Emele", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "R", | |
| "middle": [], | |
| "last": "Zajac", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "J", | |
| "middle": [], | |
| "last": "Jaffar", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "J", | |
| "middle": [ | |
| "L" | |
| ], | |
| "last": "Lassez", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "P", | |
| "middle": [], | |
| "last": "Marrafa", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "P", | |
| "middle": [ | |
| "; V" | |
| ], | |
| "last": "Marrafa", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "P", | |
| "middle": [], | |
| "last": "Dahl", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "North", | |
| "middle": [], | |
| "last": "Salnt-Dizier Edts", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "", | |
| "middle": [], | |
| "last": "Holland", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "S", | |
| "middle": [], | |
| "last": "Sheiber", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": 1983, | |
| "venue": "Remarks on Secondary Predicates: C-Command, Extraction and Reanalysis", | |
| "volume": "6", | |
| "issue": "", | |
| "pages": "285--312", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "Demonte, V., Remarks on Secondary Predicates: C-Command, Extraction and Reanalysis, The Linguistic Review 6, pp 1-39, 1988. Emele, M., Zajac, R., Typed Unification Grammars, in proc. COLING'90, Heisinki, 1990. Jaffar, J., Lassez, J.L., Constraint Logic Programming, Proc. 14th ACM Symposium on Principles of Programming Languages, 1987. Marrafa, P., Teoria das Pequenas Ora~oes vs Teofia da Predicafao: Controlo, Cfittfio Tematico e Principio de Projec~ao, ms, FLL-University of Lisbon, 1983. Marrafa, P., A Constru~ao Transitiva- Predicafiva em Portuguts, FLL-University of Lisbon, 1985. Saint-Dizier, P., Contextual Discontinuous Grammars, 2nd NLULP, Vancouver 1987 and in: Natural Language Understanding and Logic Programming II, V. Dahl and P. Salnt-Dizier Edts, North Holland, 1988. Saint-Dizier, P., A generation Strategy based on GB Principles, proc. 2nd European workshop on language generation, Edinburgh, 1989. Saint-Dizier, P., Constrained Logic Programming for Natural Language Processing, proc. ACL-89, Manchester, 1989. Sheiber, S., An Introduction to Unification- Based Approaches to Grammar, CSLI lecture notes no 4, Chicago University Press, 1986. Stowell, T., Origins of Phrase Structure, PhD. dissertation, MIT, 1981. Stowell, T., Subject across Categories, The Linguistic Review 2, pp 285-312, 1983.", | |
| "links": null | |
| } | |
| }, | |
| "ref_entries": { | |
| "FIGREF0": { | |
| "text": "is used to process the semantic representation:p(det([Quant,Var],Np,Rest of sent), Type ) :p(Quant, Type1), p(Np, Type2), generation_point(Type1, Type2, Type3),p(Rest_of_sentence, Type4), generation_point(Type3, Type4, Type). p(and(Np, Mod),Type) :p(Np, Type1), p(Mod,Type2), generation_point(Type1, Type2, Type).", | |
| "type_str": "figure", | |
| "uris": null, | |
| "num": null | |
| }, | |
| "FIGREF1": { | |
| "text": "<DC, R> where R is the set of constraints associated to DC and such that: i) same restrictions as above on DC and ii) R is consistent with S (b) < D' , R > (single type) with R consistent with S.", | |
| "type_str": "figure", | |
| "uris": null, | |
| "num": null | |
| }, | |
| "FIGREF2": { | |
| "text": "C'j => Cj ))!for all j E [l,k] ) >", | |
| "type_str": "figure", | |
| "uris": null, | |
| "num": null | |
| }, | |
| "FIGREF3": { | |
| "text": "(3)(a) [NP[NP reau] lAP froide]] or the structure: (3)(b) [NP i reau][AP i froide].", | |
| "type_str": "figure", | |
| "uris": null, | |
| "num": null | |
| }, | |
| "FIGREF4": { | |
| "text": "(b): (11)@) [S[NP i Jean] IV\" IV\" IV' IV dansait]]] [AP i triste]]]", | |
| "type_str": "figure", | |
| "uris": null, | |
| "num": null | |
| }, | |
| "FIGREF5": { | |
| "text": ", string => $3), b const2 => xp( cat: => a, string => $4, index => I ) :pending(xp(cat => v),[xl( cat => v,", | |
| "type_str": "figure", | |
| "uris": null, | |
| "num": null | |
| } | |
| } | |
| } | |
| } |