| { | |
| "paper_id": "E89-1012", | |
| "header": { | |
| "generated_with": "S2ORC 1.0.0", | |
| "date_generated": "2023-01-19T10:34:01.923371Z" | |
| }, | |
| "title": "Programming in Logic with Constraints for Natural Language Processing", | |
| "authors": [ | |
| { | |
| "first": "Patrick", | |
| "middle": [], | |
| "last": "Saint-Dizier", | |
| "suffix": "", | |
| "affiliation": { | |
| "laboratory": "", | |
| "institution": "LSI UniversiM Paul Sabatier", | |
| "location": { | |
| "addrLine": "118 route de Narbonne", | |
| "postCode": "31062 TOULOUSE", | |
| "settlement": "Cedex", | |
| "country": "France" | |
| } | |
| }, | |
| "email": "" | |
| } | |
| ], | |
| "year": "", | |
| "venue": null, | |
| "identifiers": {}, | |
| "abstract": "In this paper, we present a logic-based computational model for movement theory in Government and Binding Theory. For that purpose, we have designed a language called DISLOG. DISLOG stands for programming in logic with discontinuities and permits to express in a simple, concise and declarative way relations or constraints between non-contiguous elements in a structure. DISLOG is also weel adapted to model other types of linguistic phenomena like Quantifier Raising involving long-distance relations or constraints. 1.", | |
| "pdf_parse": { | |
| "paper_id": "E89-1012", | |
| "_pdf_hash": "", | |
| "abstract": [ | |
| { | |
| "text": "In this paper, we present a logic-based computational model for movement theory in Government and Binding Theory. For that purpose, we have designed a language called DISLOG. DISLOG stands for programming in logic with discontinuities and permits to express in a simple, concise and declarative way relations or constraints between non-contiguous elements in a structure. DISLOG is also weel adapted to model other types of linguistic phenomena like Quantifier Raising involving long-distance relations or constraints. 1.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Abstract", | |
| "sec_num": null | |
| } | |
| ], | |
| "body_text": [ | |
| { | |
| "text": "Many areas of natural language syntax and semantics are a fruitful source of inspiration for computer languages and systems designers. The complexity of natural language and the high level of abstraction of most linguistic and semantic theories have motivated the emergence of highly abstract and transparent programming languages. One of the most striking examples is undoubtedly Prolog, initially designed for natural language parsing, via Metamorphosis Grammars (Colmerauer 1978) .", | |
| "cite_spans": [ | |
| { | |
| "start": 465, | |
| "end": 482, | |
| "text": "(Colmerauer 1978)", | |
| "ref_id": "BIBREF1" | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "For a few years, the Logic Programming paradigm has been augmented with a number of technical and formal devices designed to extend its expressive power. New logic programming languages have emerged, several of them motivated by natural language processing problems. Among them let us mention: CIL (Mukai 1985) , designed to express in a direct way concepts of Situation Semantics, MOLOG (Farinas et al. 1985) , an extension to Prolog designed to specify in a very simple and declarative way the semantics of modal operators and ~,-Prolog (Nadathur and Miller 1988) , designed to deal with X-expressions and X-reduction.", | |
| "cite_spans": [ | |
| { | |
| "start": 298, | |
| "end": 310, | |
| "text": "(Mukai 1985)", | |
| "ref_id": "BIBREF2" | |
| }, | |
| { | |
| "start": 382, | |
| "end": 409, | |
| "text": "MOLOG (Farinas et al. 1985)", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 539, | |
| "end": 565, | |
| "text": "(Nadathur and Miller 1988)", | |
| "ref_id": "BIBREF3" | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Recently, the Logic Programming paradigm has been augmented with the concept of constrained logic programming (CLP) . The basic research done within this area amounts to specifying tools for a more refined control on the type of values or terms a variable in a program can stand for. Answers to goals can be intensional: they are sets of equations (constraints) rather than mere values. Furthermore, the idea at the operational level, incorrect assignments are filtered out as soon as they are encountered when building a proof, making thus proof procedures more efficient.", | |
| "cite_spans": [ | |
| { | |
| "start": 110, | |
| "end": 115, | |
| "text": "(CLP)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "In this document, we deal with a new, original, type of CLP mechanism: constraints on proof trees. This type of constraint has emerged from, in particular, the definition of a computational model for the quantifier raising operation and for movement theory in Government and Binding theory (noted hereafter as GB). We model those phenomena in terms of constraints between non-contiguous elements in a structure. For example, we want to express constraints between a moved constituent and its co-indexed trace. Constraints are expressed in terms of relations between subtrees in a syntactic tree or in terms of relations between parenthetized constituents in the now more commonly adopted annotated surface forms of sentences.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "We have designed Dislog, programming in logic with discontinuities, which permits to express relations between non-contiguous elements in a structure in a simple, declarative and concise way. Dislog is an extension to Prolog; its procedural and declarative semantics are given in (Saint-Dizier 1988b) , computer applications like compiler writing and planning are given in (Saint-Dizier 1988a) , its use in natural language parsing for free-phrase order languages is given in (Saint-Dizier 1987) . In the present document we will focus on modelling movement theory in GB (Chomsky 1982 (Chomsky , 1986 and Quantifier Raising (May 1986) , which have been in the past two years our main guidelines to specify Dislog. We do not have in mind to build a complete model of GB theory, but we feel that the transfer of some of its main principles and results to the field of natural language processing is worth investigating and is very promising for reasons we will develop hereafter. We are also convinced that GB principles should be paired with other approaches of AI to deal, for example, with the lexicon, lexical semantics, feature representation and control systems and, finally, logical form construction.", | |
| "cite_spans": [ | |
| { | |
| "start": 280, | |
| "end": 300, | |
| "text": "(Saint-Dizier 1988b)", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 373, | |
| "end": 393, | |
| "text": "(Saint-Dizier 1988a)", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 476, | |
| "end": 495, | |
| "text": "(Saint-Dizier 1987)", | |
| "ref_id": "BIBREF4" | |
| }, | |
| { | |
| "start": 571, | |
| "end": 584, | |
| "text": "(Chomsky 1982", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 585, | |
| "end": 600, | |
| "text": "(Chomsky , 1986", | |
| "ref_id": "BIBREF1" | |
| }, | |
| { | |
| "start": 624, | |
| "end": 634, | |
| "text": "(May 1986)", | |
| "ref_id": "BIBREF2" | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Introduction", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "In this section, we briefly summarize the main aspects of movement theory (Chomsky 1982 (Chomsky , 1986 and give several examples. GB theory is a complete revision of the baroque set of rules and transformations of the standard theory, achieving a much greater expressive power and explanatory adequacy. GB theory is composed of a very small base component (which follows X-bar syntax), a single movement rule and a small set of principles whose role is to control the power of the movement rule. GB exhibits a greater clarity, ease of understanding and linguistic coverage (in spite of some points which remain obscure). The recent formalization of GB theory has several attractive properties for the design of a computational model of natural language processing, among which:", | |
| "cite_spans": [ | |
| { | |
| "start": 74, | |
| "end": 87, | |
| "text": "(Chomsky 1982", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 88, | |
| "end": 103, | |
| "text": "(Chomsky , 1986", | |
| "ref_id": "BIBREF1" | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Movement Theory in GB", | |
| "sec_num": "2." | |
| }, | |
| { | |
| "text": "-concision and economy of means, -high degree of parametrization, -modularity (e.g. independence of filtering principles), -declarativity (e.g. no order in the application of rules), -absence of intermediate structures (e.g. no deep slructure).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Movement Theory in GB", | |
| "sec_num": "2." | |
| }, | |
| { | |
| "text": "GB theory postulates four levels: d-structure (sometimes not taken into account, like in our approach), s-structure (surface form of structural description), phonetic form (PF) and logical form (LF). The latter two levels are derived independently from s-structure. We will be mainly interested here in the s-structure level. Movement theory being also applicable, with different parameter values, to LF, we will also show how our approach is well-adapted to characterize LF level from s-structure level.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Movement Theory in GB", | |
| "sec_num": "2." | |
| }, | |
| { | |
| "text": "In GB, grammaticality of a sentence is based on the existence of a well-formed annotated surface form of that sentence. Thus, no real movements of constituents occur and additional computational and representational problems are avoided. Up to now very few and only partial works have been undertaken to model principles of GB theory. Among them, let us mention (Berwick and Weinberg 1986) , (Stabler 1987) and (Brown et al. 1987) . There is however an increasing interest for this approach.", | |
| "cite_spans": [ | |
| { | |
| "start": 362, | |
| "end": 389, | |
| "text": "(Berwick and Weinberg 1986)", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 392, | |
| "end": 406, | |
| "text": "(Stabler 1987)", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 411, | |
| "end": 430, | |
| "text": "(Brown et al. 1987)", | |
| "ref_id": "BIBREF0" | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Move-cx and constraints", | |
| "sec_num": "2.1" | |
| }, | |
| { | |
| "text": "GB theory postulates a single movement -88 -rule, more-a, controlled by principles and filters. This very general rule states:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Move-cx and constraints", | |
| "sec_num": "2.1" | |
| }, | |
| { | |
| "text": "Move any constituent a to any position.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Move-cx and constraints", | |
| "sec_num": "2.1" | |
| }, | |
| { | |
| "text": "The most immediate constraints are that tx is moved to the left to an empty position (a subject position which is not 0-marked) or is adjoined to a COMP or INFL node (new positions are created from nothing, but this not in contradiction with the projection principle). Constraints and filters control movement but they also force movement. For example, when a verb is used in the passive voice, it can no longer assign case to its object. The object NP must thus move to a place where it is assigned case. The (external) subject 0-role being also suppressed, the object NP naturally moves to the subject position, where it is assigned case, while keeping its previous 0-role.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Move-cx and constraints", | |
| "sec_num": "2.1" | |
| }, | |
| { | |
| "text": "Another immediate constraint is the 0-criterion: each argument has one and only one 0-role and each 0-role is assigned to one and only one argument. Such roles are lexically induced by means of the projection principle (and by lexical insertion), confering thus an increasing role to lexical subeategorization. Finally, government gives a precise definition of what a constituent can govern and thus how the projection principled is handled.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Move-cx and constraints", | |
| "sec_num": "2.1" | |
| }, | |
| { | |
| "text": "Move-ix is too abstract to be directly implementable. It needs to be at least partially instantiated, in a way which preserves its generality and its explanatory power. In addition, while the theory is attaining higher and higher levels of adequacy, the interest for analysing the specifics of particular constructions is decreasing. As a consequence, we have to make explicit elements left in the shade or just neglected. Finally, the feature system implicit in GB theory has also to be integrated.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Move-cx and constraints", | |
| "sec_num": "2.1" | |
| }, | |
| { | |
| "text": "All the examples given below are expressed within the framework of head-initial languages like French and English. Let us first consider the relative clause construction. In a relative clause, an N is pronominalized and moved to the left and adjoined to a COMP node. A trace of N is left behind and co-indexed with the pronominalized N:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "(1) [COMP N(+Pro)i ........ [N2 trace i ] ...... ] as in: [COMP thati John met IN2 trace i ] yesterday ]", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "Where i is the co-indexation link.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "The case of the passive construction is a little more complicated and needs to be explained. An object NP is moved to a subject position because the passivisation of the verb no longer allows the verb to assign case to its object NP and a 0-role to its subject NP (in an indirect manner):", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "at d-structure we have, for example:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "[ [NP ] [INFL gives [ N2 a book ] ] ]", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "and at s-structure we have:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "[ [NP a booki ] [INFL is given [N2 tracei ] ].", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "At d-structure, the subject NP is here not mentioned. In a passive construction, the subject is not moved to a PP position (by N2). 0-roles are redistributed when the verb is passivized (this illustrates once again the prominent role played by the lexical description and the projection principle) and a by-complement with the previous 0-role of the subject NP is created.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "Another example is the subject-to-subject raising operation, where:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "It seems that Jane is on time becomes:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "Jane seems to be on time.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "Jane moves to a position without 0-role (it is not 0-marked by seem ). When the clause is on time is in the infinitive form then the subject NP position is no longer case-marked, forcing Jane to move: Both what and who are adjoined to a COMP node. This latter type of movement is also restricted by a small number of general principles based on the type of landing site a raised quantifier may occupy and on the nature of the nodes a quantifier can cross over when raised. The first type of constraint will be directly expressed in rules by means of features; the latter will be dealt with in section 5 devoted to Bounding theory, where a model of the subjacency constraint is presented.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "[INFL Janei", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Examples of movements", | |
| "sec_num": "2.2" | |
| }, | |
| { | |
| "text": "Movements have to be expressed in a simple computational way. Let us consider the relative clause construction (wh-movement in general), all the other examples can be expressed in the same way.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Towards a computational expression of movements", | |
| "sec_num": "2.3" | |
| }, | |
| { | |
| "text": "Relative clause construction can be expressed in a declarative Way by stating, very informally, that:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Towards a computational expression of movements", | |
| "sec_num": "2.3" | |
| }, | |
| { | |
| "text": "within the domain of a COMP, an N(+Pro) is adjoined to that COMP and somewhere else in that domain an N2 is derived into a trace co-indexed with that N(+Pro). The notion of domain associated to a node like COMP refers to Bounding theory and will be detailed in section 5, the constraint on the co-existence in that domain of an N(+Pro) adjoined to a COMP and, somewhere else, of an N2 derived into a trace can directly be expressed by constraints on syntactic trees, and, thus, by constraints on proof trees in an operational framework. This is precisely the main motivation of DISLOG that we now briefly introduce.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Towards a computational expression of movements", | |
| "sec_num": "2.3" | |
| }, | |
| { | |
| "text": "in Logic with Discontinuities.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Introduction to DISLOG, Programming", | |
| "sec_num": "3." | |
| }, | |
| { | |
| "text": "Dislog is an extension to Prolog. It is a language composed of Prolog standard clauses and of Dislog clauses. The computational aspects are similar to that of Prolog. Foundations of DISLOG are given in (Saint-Dizier 1988b) . We now introduce and briefly illustrate the main concepts of Dislog.", | |
| "cite_spans": [ | |
| { | |
| "start": 202, | |
| "end": 222, | |
| "text": "(Saint-Dizier 1988b)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An Introduction to DISLOG, Programming", | |
| "sec_num": "3." | |
| }, | |
| { | |
| "text": "A Dislog clause is a t-mite, unordered set of Prolog clauses fi of the form:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Disiog clauses", | |
| "sec_num": "3.1." | |
| }, | |
| { | |
| "text": "{fl ,f2 ......... fn }.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Disiog clauses", | |
| "sec_num": "3.1." | |
| }, | |
| { | |
| "text": "The informal meaning of a Dislog clause is: ira clause fi in a Dislog clause is used in a given proof tree, then all the other ~ of that Dislog clause must be used to build that proof tree, with the same substitutions applied to identical variables. For example, the Dislog clause (with empty bodies here, for the sake of clarity):", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Disiog clauses", | |
| "sec_num": "3.1." | |
| }, | |
| { | |
| "text": "{ arc(a/a), arc(e~9 3. means that, in a graph, the use of arc (a,b) to construct a proof is conditional to the use of arc(e~. If one is looking for paths in a graph, this means that all path going through arc(a,b) will also have to go through arc(el).", | |
| "cite_spans": [ | |
| { | |
| "start": 62, | |
| "end": 67, | |
| "text": "(a,b)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Disiog clauses", | |
| "sec_num": "3.1." | |
| }, | |
| { | |
| "text": "A Dislog clause with a single element is equivalent to a Prolog clause (also called definite program clause).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Disiog clauses", | |
| "sec_num": "3.1." | |
| }, | |
| { | |
| "text": "A Dislog program is composed of a set of Dislog clauses. The definition of a predicate p in a Dislog program is the set of all Dislog clauses which contain at least one definite clause with head predicate symbol p. Here is an example of a possible definition for p:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Disiog clauses", | |
| "sec_num": "3.1." | |
| }, | |
| { | |
| "text": "{ p(1), h :-t(X) }. { (p(X) :-tfX), p(X-1) ), d(3) }. { p(5) }.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Disiog clauses", | |
| "sec_num": "3.1." | |
| }, | |
| { | |
| "text": "A full example is given in section 3.3.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Disiog clauses", | |
| "sec_num": "3.1." | |
| }, | |
| { | |
| "text": "We now propose some simple restrictions of the above general form for Dislog clauses. A first type of restriction is to impose restrictions on the order of use of Prolog clauses in a Dislog clause. We say that an instance of a clause ri precedes an instance of a clause rj in a proof tree if either ri appears in that proof tree to the left of rj or if ri dominates rj. Notice that this notion of precedence is independent of the strategy used to build the proof tree. In the following diagram, the clause: a :-al precedes the clause b :-bl. :", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Constraining Disiog clauses", | |
| "sec_num": "3.2" | |
| }, | |
| { | |
| "text": "or:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "/ \\ a b al bl", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "I al I ! I bl", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "/ \\ a b al bl", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "To model this notion of precedence, we add to Dislog clauses the traditional linear precedence restriction notation, with the meaning given above:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "/ \\ a b al bl", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "a < b means that the clause with head a precedes the clause with head b (clause numbers can also be used). When the clause order in a Dislog clause is complete, we use the more convenient notation:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "/ \\ a b al bl", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "fl /12 / ............ / fn.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "/ \\ a b al bl", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "which means that fl precedes 12 which precedes 13 etc... The relation I is viewed as an accessibility relation.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "/ \\ a b al bl", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Another improvement to Dislog clauses is the adjunction of modalities. We want to allow Prolog clauses in a Dislog clause to be used several times. This permits to deal, for example, with parasitic gaps and with pronominal references. We use the modality m applied on a rule to express that this clause can be used any number of times in a Dislog clause. For example, in: t :l.:e, mO ) :.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "/ \\ a b al bl", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "the clause f3 can be used any number of times, provided that fl anti t2 are used. Substitutions for identical variables remain the same as before.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "/ \\ a b al bl", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Another notational improvement is the use of the semi-colon ';' with a similar meaning as in Prolog to factor out rules having similar parts:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "/ \\ a b al bl", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "C.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "/ \\ a b al bl", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "can be factored out as:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "{a,b}. and {a,c}", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "{a,(b;c)}.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "{a,b}. and {a,c}", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "which means that a must be used with either b or", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "{a,b}. and {a,c}", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Here is a short and simple example where Dislog rams out to be very well-adapted.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Programming in Dislog", | |
| "sec_num": "3.3" | |
| }, | |
| { | |
| "text": "In a conventional programming language, there are several one-to-one or one-to-many relations between non-contiguous instructions. For instance, there is a relation between a procedure and its corresponding calls and another relation between a label declaration and its corresponding branching instructions. Dislog rule format is very well adapted to express those relations, permitting variables to be shared between several definite clause in a Dislog clause. These variables can percolate, for example, addresses of entry points.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Programming in Dislog", | |
| "sec_num": "3.3" | |
| }, | |
| { | |
| "text": "We now consider the compiler given in (Sterling and Shapiro 86) which transforms a program written in a simplified version of Pascal into a set of basic instructions (built in the argument)'. This small compiler can be augmented with two Dislog rules: {procedure declaration, procedure call(s) }. { label statement, branching instruction(s) to label}.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Programming in Dislog", | |
| "sec_num": "3.3" | |
| }, | |
| { | |
| "text": "In order for a procedure call to be allowed to appear before the declaration of the corresponding procedure we do not state any linear precedence restriction. Furthemore, procedure call and branching instruction description rules are in a many-to-one relation with respectively the procedure declaration and the label declaration. A procedure call may indeed appear several times in the body of a program (this is precisely the role of a procedure in fact). Thus, we have to use the modality m as follows: We have carried out an efficient and complete implementation for Dislog rules which are compiled into Prolog clauses.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Programming in Dislog", | |
| "sec_num": "3.3" | |
| }, | |
| { | |
| "text": "A way of thinking to move-or (as in Sells 85) is that it expresses the 'movement' part of a relation between two structures. We quote the term movement because, in our approach, we no longer deal with d-structure and no longer have, thus, movements but rather long-distance relations or constraints.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Expressing movement rules in Dislog", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": "We think that, in fact, move-vt is itself the relation (or prototype of relation) and that the constraints (case assignment, 0-marking, bounding theory, etc...) are just specific arguments or constraints on that relation: everything is possible (relation) and constraints filter out incorrect configurations. From this point of view, Dislog is a simple and direct computational model for move-or.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Expressing movement rules in Dislog", | |
| "sec_num": "4." | |
| }, | |
| { | |
| "text": "The relativisation rule given above is expressed in a straightforward way by a Dislog clause. That Dislog clause is composed of two Prolog(-like) clauses. The first clause deals with the adjunction of the N(+Pro) to the COMP and the second clause deals with the derivation of the N2 into a trace. A shared variable I permits to establish the co-indexation link. The Dislog clause is the following, in which we adopt the X-bar syntax terminology:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Expressing movement in Dislog", | |
| "sec_num": "4.1" | |
| }, | |
| { | |
| "text": "xp (comp,O,_,_, ) --> xp(n,O,pro(Case) ", | |
| "cite_spans": [ | |
| { | |
| "start": 3, | |
| "end": 38, | |
| "text": "(comp,O,_,_, ) --> xp(n,O,pro(Case)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Expressing movement in Dislog", | |
| "sec_num": "4.1" | |
| }, | |
| { | |
| "text": "An xp is a predicate which represents any category. The category is specified in the first argument, the bar level in the second, syntactic features in the third one (oversimplified here), the fourth argument is the co-indexation link and the last one, not dealt with here, contains the logical form associated with the rule. Notice that using identical variables (namely here I and Case) in two different clauses in a Dislog clauses permits to transfer feature values in a very simple and transparent way.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "J,_) , xp(comp,O,_,_, ). I xp(n2,CaseJ,_) --> trace(l).", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "The passive construction is expressed in a similar way. Notice that we are only interested in the s-structure description since we produce annotated surface forms (from which we then derive a semantic representation). The passive construction rule in Dislog is:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "J,_) , xp(comp,O,_,_, ). I xp(n2,CaseJ,_) --> trace(l).", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "xp (infl,1 .... ,_) --> xp(n,O,_J,_), xp(infl,1 .... ,_) I xp(n,2,_,l,_)--> trace(l) .", | |
| "cite_spans": [ | |
| { | |
| "start": 3, | |
| "end": 84, | |
| "text": "(infl,1 .... ,_) --> xp(n,O,_J,_), xp(infl,1 .... ,_) I xp(n,2,_,l,_)--> trace(l)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "J,_) , xp(comp,O,_,_, ). I xp(n2,CaseJ,_) --> trace(l).", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Case and 0-role are lexically induced. Following a specification format like in (Sells 85), we have, for example, for the verb to eat, the following lexical entry: , (subject:NP, agenO, (object:NP, patienO, assigns no case to object. which becomes with the passive inflection: eaten, V, (object: NP, patient), assigns no case. (the by-complement is also lexically induced by a lexical transformation of the same kind with: iobject:NP, agent, case: ablative)", | |
| "cite_spans": [ | |
| { | |
| "start": 164, | |
| "end": 233, | |
| "text": ", (subject:NP, agenO, (object:NP, patienO, assigns no case to object.", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "J,_) , xp(comp,O,_,_, ). I xp(n2,CaseJ,_) --> trace(l).", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "eat, V", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "J,_) , xp(comp,O,_,_, ). I xp(n2,CaseJ,_) --> trace(l).", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Let us now consider the subject-to-subject raising operation. At d-structure, the derivation of an N2 into the dummy pronoun it is replaced by the derivation of that N2 into an overt noun phrase. This is formulated as follows in Dislog:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "J,_) , xp(comp,O,_,_, ). I xp(n2,CaseJ,_) --> trace(l).", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "xp ( infl,2 , C as e .... ) --> xp(infl,1,_,_,_) t xp(n~,,Case,l,_)--> trace(l).", | |
| "cite_spans": [ | |
| { | |
| "start": 3, | |
| "end": 50, | |
| "text": "( infl,2 , C as e .... ) --> xp(infl,1,_,_,_) t", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "J,_) , xp(comp,O,_,_, ). I xp(n2,CaseJ,_) --> trace(l).", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "xp (n, 2, Case, 1, ) ,", | |
| "cite_spans": [ | |
| { | |
| "start": 3, | |
| "end": 6, | |
| "text": "(n,", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 7, | |
| "end": 9, | |
| "text": "2,", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 10, | |
| "end": 15, | |
| "text": "Case,", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 16, | |
| "end": 18, | |
| "text": "1,", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 19, | |
| "end": 20, | |
| "text": ")", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "J,_) , xp(comp,O,_,_, ). I xp(n2,CaseJ,_) --> trace(l).", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "The movement construction rules given above have many similarities. They can be informally put together to form a single, partially instaneiated movement rule, roughly as follows: ( (xp(infl,1, , , ) -->", | |
| "cite_spans": [], | |
| "ref_spans": [ | |
| { | |
| "start": 180, | |
| "end": 199, | |
| "text": "( (xp(infl,1, , , )", | |
| "ref_id": null | |
| } | |
| ], | |
| "eq_spans": [], | |
| "section": "J,_) , xp(comp,O,_,_, ). I xp(n2,CaseJ,_) --> trace(l).", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "xp (n,O,_,l,_), xp(infl,1 .... ,_) ) ; (xp(infl, 2, 2, Case, l, _) , xp(infl,1,_,_,_) ", | |
| "cite_spans": [ | |
| { | |
| "start": 3, | |
| "end": 36, | |
| "text": "(n,O,_,l,_), xp(infl,1 .... ,_) )", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 39, | |
| "end": 48, | |
| "text": "(xp(infl,", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 49, | |
| "end": 51, | |
| "text": "2,", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 52, | |
| "end": 54, | |
| "text": "2,", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 55, | |
| "end": 60, | |
| "text": "Case,", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 61, | |
| "end": 63, | |
| "text": "l,", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 64, | |
| "end": 66, | |
| "text": "_)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [ | |
| { | |
| "start": 69, | |
| "end": 85, | |
| "text": "xp(infl,1,_,_,_)", | |
| "ref_id": null | |
| } | |
| ], | |
| "eq_spans": [], | |
| "section": "J,_) , xp(comp,O,_,_, ). I xp(n2,CaseJ,_) --> trace(l).", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": ") ; etc .... /", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "J,_) , xp(comp,O,_,_, ). I xp(n2,CaseJ,_) --> trace(l).", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "xp(n2,(Case;pro(Case))\u00a3__) --> trace(l) ).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "J,_) , xp(comp,O,_,_, ). I xp(n2,CaseJ,_) --> trace(l).", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "Dislog has many other uses in natural language processing. At the semantic level, it can be used in a convenient way as a computational model to deal with quantifier raising, with negation and modality operator raising operations or to model some meaning postulates in Montague semantics. Dislog can also provide a simple model for temporal relations involving the notion of (partial) precedence of actions or events.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Other uses of Dislog for natural language processing", | |
| "sec_num": "4.2" | |
| }, | |
| { | |
| "text": "Semantic interpretation or formula optimisation often involves putting together or rewriting elements which are not necessarily contiguous in a formula. Dislog rules can then be used as rewriting rules.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Other uses of Dislog for natural language processing", | |
| "sec_num": "4.2" | |
| }, | |
| { | |
| "text": "In order to properly anchor the N2, we have to repeat in the Dislog rule a rule from the base component (rule with infl). Once again, this is lexically induced from the description of the verb to seem: when the N2 is raised, the proposition following the completive verb has no subject, it is tenseless, i.e. in the infinitive form. Finally, notice the case variable, designed to maintain the case chain.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Other uses of Dislog for natural language processing", | |
| "sec_num": "4.2" | |
| }, | |
| { | |
| "text": "The wh-construal construction at LF is dealt with in exactly the same manner, an N2(+pro) is adjoined to a COMP node:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Other uses of Dislog for natural language processing", | |
| "sec_num": "4.2" | |
| }, | |
| { | |
| "text": "xp(comp,2,_,_,_) --> xp(n,2,pro(Case),l,_), xp(comp,2,_ .... ) I", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Other uses of Dislog for natural language processing", | |
| "sec_num": "4.2" | |
| }, | |
| { | |
| "text": "xp(n2,Cased,_)--> trace(l).", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Other uses of Dislog for natural language processing", | |
| "sec_num": "4.2" | |
| }, | |
| { | |
| "text": "Case permits the distinction between different pronouns. Notice that this rule is exactly similar to the relative construction rule.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Other uses of Dislog for natural language processing", | |
| "sec_num": "4.2" | |
| }, | |
| { | |
| "text": "Dislog rules describing movements can be used in any order and are independent of the parsing strategy. They are simple, but their interactions can become quite complex. However, the high level of declarativity of Dislog permits us to control movements in a sound way.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Other uses of Dislog for natural language processing", | |
| "sec_num": "4.2" | |
| }, | |
| { | |
| "text": "Finally, at the level of syntax, we have shown in (Saint-Dizier 87) that Dislog can be efficiently used to deal with free phrase order or free word order languages, producing as a result a normalized syntactic tree. Dislog can also be used to skip parts of sentences which cannot be parsed.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Other uses of Dislog for natural language processing", | |
| "sec_num": "4.2" | |
| }, | |
| { | |
| "text": "A Dislog rule can be interpreted by a term attribute grammar. A term attribute grammar has arguments which are terms. It is a context-free grammar that has been augmented with conditions (on arguments) enabling non-context-free aspects of a language to be specified. A Dislog rule can be translated as follows into a term attribute grammar. Consider the rule:", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Formal grammatical aspects of Dislog rules", | |
| "sec_num": "4.3" | |
| }, | |
| { | |
| "text": "a-->b / c-->d. a possible (and simple) interpretation is: a(X,Y) --> b(X,X1), add (Xl,[c-->dl,Y) . b(X,Y) --> withdraw ([c-->d1,X,Y1), d(Y1,Y) . When a-->b is executed, the rule c-->d is stored in an argument (X and Y represent input and output arguments for storing these rules to be executed, like strings of words are stored in DCGs). c-->d can only be executed if it is present in the list. At the end of the parsing process, the list of rules to be executed must be empty (except for rules marked with modality m). Notice also that shared variables in a Dislog rule are unified and further percolated when rules are stored by the procedure add.", | |
| "cite_spans": [ | |
| { | |
| "start": 82, | |
| "end": 96, | |
| "text": "(Xl,[c-->dl,Y)", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 119, | |
| "end": 142, | |
| "text": "([c-->d1,X,Y1), d(Y1,Y)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Formal grammatical aspects of Dislog rules", | |
| "sec_num": "4.3" | |
| }, | |
| { | |
| "text": "however more general and more powerful because it deals with unordered sets of rules rather than with a single, rigid rewriting rule, it also permits to introduce modalities and no extrasymbols (to represents skips or to avoid loops) need to be introduced (see Saint-Dizier 88b). ", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Formal grammatical aspects of Dislog rules", | |
| "sec_num": "4.3" | |
| }, | |
| { | |
| "text": "{ (S --> [b], S), (S --> [d], S) }. S --> [a] / [b] / [el / [d].", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Formal grammatical aspects of Dislog rules", | |
| "sec_num": "4.3" | |
| }, | |
| { | |
| "text": "Bounding nodes and modalities can also be added to deal with more complex languages.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Formal grammatical aspects of Dislog rules", | |
| "sec_num": "4.3" | |
| }, | |
| { | |
| "text": "Dislog originates a new type of logic-based grammar that we call Contextual Discontinuous Grammars. The closest formalisms to Dislog are Extraposition Grammars (Pereira 1981) and Gapping Grammars (DaM and Abramson 1984) . As opposed to Gapping Grammars, Dislog permits to deal with trees rather than with graphs. Gapping Grammars are of type-0 and are much more difficult to write and to control the power of. Compared to Extraposition Grammars, Dislog no longer operates movements of strings and it is also more general since a Dislog clause can contain any number of Prolog clauses which can be used in any orderand at any place within a domain. Extraposition grammars also involve graphs (although much simpler than for Gapping Grammars) instead of trees, which are closer to the linguistic reality. The implementation of Dislog is about as efficient as the very insightful implementation provided by F. Pereira.", | |
| "cite_spans": [ | |
| { | |
| "start": 160, | |
| "end": 174, | |
| "text": "(Pereira 1981)", | |
| "ref_id": null | |
| }, | |
| { | |
| "start": 196, | |
| "end": 219, | |
| "text": "(DaM and Abramson 1984)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Related works", | |
| "sec_num": "4.4" | |
| }, | |
| { | |
| "text": "Bounding theory is a general phenomena common to several linguistic theories and expressed in very similar ways. Roughly speaking, Bounding theory states constraints on the way to move constituents, or, in non-transformational terms on the way to establish relations between non-contiguous elements in a sentence. The main type of constraint is expressed in terms of domains over the boundaries of which relations cannot be established. For example, if A is a bounding node (or a subtree which is a sequence of bounding nodes), then the domain of A is the domain it is the root of and no constituent X inside that domain can have relations with a constituent outside it (at least not directly):", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Bounding Theory in Dislog", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "A B", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Bounding Theory in Dislog", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "or, if A represents a sequence B ... C of bounding nodes: \\", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Bounding Theory in Dislog", | |
| "sec_num": "5." | |
| }, | |
| { | |
| "text": "In Dislog, if an instance of a Dislog clause is activated within the domain of a bounding node, then, the whole Dislog clause has to be used within that domain. For a given application, bounding nodes are specified as a small database of Prolog facts and are interpreted by the Dislog system. More recently (Dahl, forthcoming) , Static Discontinuity Grammars have been introduced, motivated by the need to model GB theory for sentence generation. They permit to overcome some drawbacks of Gapping Grammars by prohibiting movements of constituents in rules. They have also borrowed several aspects to Dislog (like bounding nodes and its procedural interpretation). Dislog is In the case of Quantifier Raising, we have several types of bounding nodes: the nodes of syntax, nodes corresponding to conjunctions, modals, some temporal expressions, etc... Those nodes are declared as bounding nodes and are then processed by Dislog in a way transparent to the grammar writer.", | |
| "cite_spans": [ | |
| { | |
| "start": 307, | |
| "end": 326, | |
| "text": "(Dahl, forthcoming)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "D empty~", | |
| "sec_num": null | |
| }, | |
| { | |
| "text": "We have carried out an specific implementation of Dislog for natural language parsing described in (St-Dizier, Toussaint, Delaunay and SebiUot 1989) . The very regular format of the grammar rules (X-bar syntax) permits us to define a specific implementation which, in spite of the high degree of parametrization of the linguistic system, is very efficient.", | |
| "cite_spans": [ | |
| { | |
| "start": 99, | |
| "end": 148, | |
| "text": "(St-Dizier, Toussaint, Delaunay and SebiUot 1989)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An implementation of Dislog for natural language processing", | |
| "sec_num": "6." | |
| }, | |
| { | |
| "text": "We use a bottom-up parsing strategy similar to that given in (Pereira and Shieber 1987) , with some adaptations due to the very regular rule format of X-bar syntax rules, and a one-step look-ahead mechanism which very efficiently anticipates the rejection of many unappropriate rules. The sentences we have worked on involve several complex constructions; they are parsed in 0.2 to 2 seconds CPU time in Quintus Prolog on a SUN 3.6 workstation.", | |
| "cite_spans": [ | |
| { | |
| "start": 61, | |
| "end": 87, | |
| "text": "(Pereira and Shieber 1987)", | |
| "ref_id": null | |
| } | |
| ], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "An implementation of Dislog for natural language processing", | |
| "sec_num": "6." | |
| }, | |
| { | |
| "text": "In this paper, we have presented a simple, declarative computational model for movement theory in Government and Binding. For that purpose, we have introduced Dislog, a logic programming language built on top of Prolog, designed to express in a simple, transparent and concise way relations or constraints between non-contiguous constituents in a structure. Although Dislog is still in an early stage of development, it seems a promising language for natural language processing and also to represent and to program several kinds of problems where the idea of non-contiguity is involved. The efficient implementation we have carried out permits to use Dislog on a large scale. We have designed a prototype parser which includes our model of movement rules, the GB base component, a quite extensive lexicon and semantic compositional rules to build logical formulas. We also use the same model for natural language generation.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Perspectives", | |
| "sec_num": "7." | |
| } | |
| ], | |
| "back_matter": [ | |
| { | |
| "text": "I would like to thank A. Borillo, M. Borillo, C. Brown, V. Dahl, C. Delannay, G. Lapalme, P. Sebillot and J. Virbel for their comments on ealier versions of this work. This project is supported by the INRIA and by the PRC Communication Homme-machine of the CNRS.", | |
| "cite_spans": [], | |
| "ref_spans": [], | |
| "eq_spans": [], | |
| "section": "Acknowledgements", | |
| "sec_num": null | |
| } | |
| ], | |
| "bib_entries": { | |
| "BIBREF0": { | |
| "ref_id": "b0", | |
| "title": "Towards a Theory of Natural Language Generation: the Connection between Syntax and Semantics, in: Natural Language Understanding and Logic Programming H", | |
| "authors": [ | |
| { | |
| "first": "R", | |
| "middle": [], | |
| "last": "Berwiek", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "A", | |
| "middle": [], | |
| "last": "Weinberg", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "C", | |
| "middle": [], | |
| "last": "Brown", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "T", | |
| "middle": [], | |
| "last": "Pattabhiraman", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "P", | |
| "middle": [], | |
| "last": "Massicotte", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": 1986, | |
| "venue": "", | |
| "volume": "", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "Berwiek, R. and Weinberg, A., The Grammatical Basis of Linguistic Performance, MIT Press, 1986. Brown, C., Pattabhiraman, T., Massicotte, P., Towards a Theory of Natural Language Generation: the Connection between Syntax and Semantics, in: Natural Language Understanding and Logic Programming H, V. Dahl and P. Saint-Dizier Edts, North Holland 1987.", | |
| "links": null | |
| }, | |
| "BIBREF1": { | |
| "ref_id": "b1", | |
| "title": "Lectures on Government and Binding", | |
| "authors": [ | |
| { | |
| "first": "N", | |
| "middle": [], | |
| "last": "Chomsky", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "N", | |
| "middle": [], | |
| "last": "Chomsky", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "A", | |
| "middle": [], | |
| "last": "Barriers ; Colmerauer", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": 1978, | |
| "venue": "Natural Language Understanding by Computer", | |
| "volume": "13", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "Chomsky, N., Lectures on Government and Binding, Foris Pub., Dordrecht, 1981. Chomsky, N., Barriers, Linguistic Inquiry monograph rib. 13, MIT Press 1986. Colmerauer, A., Metamorphosis Grammars, in: Natural Language Understanding by Computer, Lecture notes in Computer Science, L. Bole Edt., Springer-Verlag, 1978.", | |
| "links": null | |
| }, | |
| "BIBREF2": { | |
| "ref_id": "b2", | |
| "title": "Molog: Programming in Modal Logic, Fifth Generation Computing journal", | |
| "authors": [ | |
| { | |
| "first": "V", | |
| "middle": [], | |
| "last": "Dahl", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "H", | |
| "middle": [], | |
| "last": "Abramson", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "L", | |
| "middle": [], | |
| "last": "Farinas Del Cerro", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "A", | |
| "middle": [ | |
| "; R" | |
| ], | |
| "last": "Arthaud", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "K", | |
| "middle": [], | |
| "last": "Mukai", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": 1984, | |
| "venue": "Proc. of the 3rd Logic Programming Conference", | |
| "volume": "12", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "Dahl V., Abramson, H., On Gapping Grammars, Proc. of the 3rd Logic Programming Conference, Uppsala, 1984. Farinas del Cerro, L., Arthaud, A., Molog: Programming in Modal Logic, Fifth Generation Computing journal, 1985. May, R., Logical Form, Linguistic Inquiry monograph nb. 12, MIT Press, 1986. Mukai, K., Unification over Complex", | |
| "links": null | |
| }, | |
| "BIBREF3": { | |
| "ref_id": "b3", | |
| "title": "Logic for Natural Language Analysis", | |
| "authors": [ | |
| { | |
| "first": "G", | |
| "middle": [], | |
| "last": "Indeterminates ; Nadathur", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "D", | |
| "middle": [], | |
| "last": "Miller", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "F", | |
| "middle": [], | |
| "last": "Pereira", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": 1985, | |
| "venue": "SRI technical report", | |
| "volume": "275", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "Indeterminates, Fifth Generation Computer journal, 1985. Nadathur, G., Miller, D., An overview of 2.-Prolog, Technical report MS-CIS-88-40, University of Pennsylvania, 1988. Pereira, F., Logic for Natural Language Analysis, SRI technical report 275, Stanford, 1985.", | |
| "links": null | |
| }, | |
| "BIBREF4": { | |
| "ref_id": "b4", | |
| "title": "A Natural language processing system based on principles of government and binding theory, in Logic Programming and Logic grammars", | |
| "authors": [ | |
| { | |
| "first": "F", | |
| "middle": [], | |
| "last": "Pereira", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "S", | |
| "middle": [], | |
| "last": "Sheiber", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "P", | |
| "middle": [], | |
| "last": "Saint-Dizier", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "P", | |
| "middle": [], | |
| "last": "Dahl", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "North", | |
| "middle": [], | |
| "last": "Saint-Dizier Edts", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": ";", | |
| "middle": [], | |
| "last": "Holland", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "P", | |
| "middle": [], | |
| "last": "Saint-Dizier", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": ";", | |
| "middle": [ | |
| "P" | |
| ], | |
| "last": "Dislog", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "Y", | |
| "middle": [], | |
| "last": "Toussaint", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "C", | |
| "middle": [], | |
| "last": "Delaunay", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "P", | |
| "middle": [], | |
| "last": "Sebillot", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": 1987, | |
| "venue": "Prolog for Natural Language Analysis, CSLI lecture Notes", | |
| "volume": "5", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "Pereira, F., Sheiber, S., Prolog for Natural Language Analysis, CSLI lecture Notes, Chicago University Press, 1987. Saint-Dizier, P., Contextual Discontinuous Grammars, in: Natural Language Understanding and Logic Programming H, V. Dahl and P. Saint-Dizier Edts, North Holland, 1987. Saint-Dizier, P., Dislog, Programming in Logic with Discontinuities, Computational Intelligence, vol. 5-1, 1988. Saint-Dizier, P., Foundations of Dislog, programming in Logic with Discontinuities, in proc. of FGCS'88, Tokyo, 1988. Saint-Dizier,P., Toussaint,Y.,Delaunay,C., Sebillot,P., A Natural language processing system based on principles of government and binding theory, in Logic Programming and Logic grammars, P. Saint-Dizier and S. Szpakowicz Edts, Ellis Horwood, 1989.", | |
| "links": null | |
| }, | |
| "BIBREF5": { | |
| "ref_id": "b5", | |
| "title": "Stabler, E., Parsing with Explicit Representations of Syntactic Constraints", | |
| "authors": [ | |
| { | |
| "first": "P", | |
| "middle": [], | |
| "last": "Sells", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "L", | |
| "middle": [], | |
| "last": "Sterling", | |
| "suffix": "" | |
| }, | |
| { | |
| "first": "S", | |
| "middle": [], | |
| "last": "Shapiro", | |
| "suffix": "" | |
| } | |
| ], | |
| "year": 1985, | |
| "venue": "Lectures on Contemporary Syntactic Theories, CSLI lecture notes no 3", | |
| "volume": "", | |
| "issue": "", | |
| "pages": "", | |
| "other_ids": {}, | |
| "num": null, | |
| "urls": [], | |
| "raw_text": "Sells, P., Lectures on Contemporary Syntactic Theories, CSLI lecture notes no 3, Chicago University Press, 1985. Stabler, E., Parsing with Explicit Representations of Syntactic Constraints, in: Natural Language Understanding and Logic Programming II, V. Dalai and P. Saint-Dizier Edts, North Holland, 1987. Sterling, L., Shapiro, S., The Art of Prolog, M1T Press, 1986.", | |
| "links": null | |
| } | |
| }, | |
| "ref_entries": { | |
| "FIGREF0": { | |
| "text": "{procedure declaration, re(procedure call) }. { label statement, re(branching instruction to label)}. In a parse tree corresponding to the syntactic analysis of a Pascal program, we could have, for example the following tree: declaration and branching */ { (statement(label(N))--> identifier(N), [':'] ) , m(statement(goto(N)) --> identifier(N)) }.", | |
| "uris": null, | |
| "type_str": "figure", | |
| "num": null | |
| }, | |
| "FIGREF1": { | |
| "text": "Dislog rules can be used to express context-sensitive languages. For example, consider the language L= {anbmcndm, n, m positive integers), it is recognized by the following grammar:S--> A,B, C,D. A--> [a],A / C--> [c],C. B--> [b],B I D--> [d],D. A --> [a]. B --> [b]. C--> lc]. D --> [dl.If a, b, c and d are mixed, with the only condition that the number of a's is equal to the number of o's and the number of b's is equal to the number of d's, we have: { (S --> [a], S), (S --> [c], S) 1.", | |
| "uris": null, | |
| "type_str": "figure", | |
| "num": null | |
| } | |
| } | |
| } | |
| } |