| { |
| "paper_id": "E93-1009", |
| "header": { |
| "generated_with": "S2ORC 1.0.0", |
| "date_generated": "2023-01-19T10:54:50.342783Z" |
| }, |
| "title": "A Strategy for Dynamic Interpretation: a Fragment and an Implementation", |
| "authors": [ |
| { |
| "first": "Olivier", |
| "middle": [], |
| "last": "Bouchez", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "FUNDP", |
| "location": { |
| "addrLine": "61 Rue de Bruxelles, The Netherlands 3OTS, Trans 10", |
| "postBox": "P.O. Box 4079", |
| "postCode": "5000, 2CWI, 1009 AB, 3512 JK", |
| "settlement": "Narnur, Amsterdam, Utrecht", |
| "country": "Belgium, The Netherlands" |
| } |
| }, |
| "email": "" |
| }, |
| { |
| "first": "Jan", |
| "middle": [], |
| "last": "Van Eijck", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "FUNDP", |
| "location": { |
| "addrLine": "61 Rue de Bruxelles, The Netherlands 3OTS, Trans 10", |
| "postBox": "P.O. Box 4079", |
| "postCode": "5000, 2CWI, 1009 AB, 3512 JK", |
| "settlement": "Narnur, Amsterdam, Utrecht", |
| "country": "Belgium, The Netherlands" |
| } |
| }, |
| "email": "" |
| }, |
| { |
| "first": "Olivier", |
| "middle": [], |
| "last": "Istace", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "FUNDP", |
| "location": { |
| "addrLine": "61 Rue de Bruxelles, The Netherlands 3OTS, Trans 10", |
| "postBox": "P.O. Box 4079", |
| "postCode": "5000, 2CWI, 1009 AB, 3512 JK", |
| "settlement": "Narnur, Amsterdam, Utrecht", |
| "country": "Belgium, The Netherlands" |
| } |
| }, |
| "email": "" |
| } |
| ], |
| "year": "", |
| "venue": null, |
| "identifiers": {}, |
| "abstract": "The strategy for natural language interpretation presented in this paper implements the dynamics of context change by translating natural language texts into a meaning representation language consisting of (descriptions of) programs, in the spirit of dynamic predicate logic (DPL) [5]. The difference with DPL is that the usual DPL semantics is replaced by an error state semantics [2]. This allows for the treatment of unbound anaphors, as in DPL, but also of presuppositions and presupposition projection.", |
| "pdf_parse": { |
| "paper_id": "E93-1009", |
| "_pdf_hash": "", |
| "abstract": [ |
| { |
| "text": "The strategy for natural language interpretation presented in this paper implements the dynamics of context change by translating natural language texts into a meaning representation language consisting of (descriptions of) programs, in the spirit of dynamic predicate logic (DPL) [5]. The difference with DPL is that the usual DPL semantics is replaced by an error state semantics [2]. This allows for the treatment of unbound anaphors, as in DPL, but also of presuppositions and presupposition projection.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstract", |
| "sec_num": null |
| } |
| ], |
| "body_text": [ |
| { |
| "text": "The use of this dynamic interpretation strategy is demonstrated in an implementation of a small fragment of natural language which handles unbound pronoun antecedent links, where it is assumed that the intended links are indicated in the input string, and uniqueness presuppositions of definite descriptions. The implementation consists of a syntax module which outputs parse trees, a semantic module mapping parse trees to DPL representations, a representation processor which determines truth conditions, falsity conditions and presupposition failure conditions, and an evaluator of these conditions in a database model. The implementation uses the logic programming language GSdel [6] , an experimental successor of Prolog, with similar functionality and expressiveness, but with an improved declarative semantics.", |
| "cite_spans": [ |
| { |
| "start": 684, |
| "end": 687, |
| "text": "[6]", |
| "ref_id": "BIBREF17" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| }, |
| { |
| "text": "Recent developments in Natural Language semantics have witnessed a shift away from static representation languages towards representation languages with a dynamic flavour. Such representation languages can be viewed as definitions of very simple imperative programming languages. To see how the imperative style comes in, consider the treatment of indefinite descriptions (or: existential phrases). Existential quantifiers are viewed dynamically as random assignment statements followed by tests. The translation of the natural language phrase 'a man' becomes something like:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Idea of Dynamic Interpretation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "x := ?; man(x) The first part of this statement can be viewed as a random assignment to register x, the second part as a test on the value ofx. This sequence of instructions is performed against the background of a database, i.e., a model of first order logic. The sequence succeeds if the database contains (representations of) men, and it can succeed in as many ways as there are men available in the database.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Idea of Dynamic Interpretation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "The motivating examples for the shift from static to dynamic representation have to do with pronoun binding. The translation of phrases like 'a man' in terms of assignments of values to registers makes it possible to treat binding of pronouns across sentence boundaries (the next sentence can start with 'He' to pick up the reference to 'a man'). The nice thing about the treatment in terms of assignment is that the scope of the existential quantification is not closed off at the end of a sentence, as used to be the case for NL systems that employ static representation (in terms of the existential quantifiers of predicate logic, with their irritating closing brackets).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Idea of Dynamic Interpretation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "Recently, it has become clear that dynamic representation has some other interesting features:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Idea of Dynamic Interpretation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "\u2022 It becomes possible to give an account of presupposition failure phenomena in terms of the definition of an error state semantics for the dynamic representation language [3; 2] . Presupposition failure occurs for example if one tries to interpret \"John's wife is unhappy\" in a situation where John is not married. \u2022 A more natural treatment of tense becomes possible. A sequence of sentences in the past tense like \"A man walked in. He sat down. He ordered a drink\" etc, is represented using subsequent assignments of values (time intervals) to a dedicated time register t [10] . The dynamic representation language can be analysed with tools that were originally designed for analysing imperative programming languages, namely the tools for precondition reasoning from Itoare logic or dynamic logic [11] . Precondition reasoning for dynamic predicate logic with standard semantics was introduced in [4] . Precondition reasoning gives the truth conditions of DPL representations in the form of formulas of first order logic (FOL). When applied to the error state semantics of DPL, precondition reasoning can also be used to find the presupposition failure conditions of DPL representations as FOL formulas.", |
| "cite_spans": [ |
| { |
| "start": 172, |
| "end": 178, |
| "text": "[3; 2]", |
| "ref_id": null |
| }, |
| { |
| "start": 575, |
| "end": 579, |
| "text": "[10]", |
| "ref_id": "BIBREF21" |
| }, |
| { |
| "start": 802, |
| "end": 806, |
| "text": "[11]", |
| "ref_id": "BIBREF22" |
| }, |
| { |
| "start": 902, |
| "end": 905, |
| "text": "[4]", |
| "ref_id": "BIBREF15" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Idea of Dynamic Interpretation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "We provide an integrated treatment of syntax and semantics of a small fragment of natural language and test this by implementing it. The syntax of our toy grammar is a version of categorial grammar with feature unification. The semantics uses DPL representations, with an error state semantics which is reflected in the rules for precondition reasoning implemented in the precondition module. This module generates predicate logical formulas expressing the weakest preconditions of success, failure or error of the DPL representations.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Idea of Dynamic Interpretation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "In detail, our interpretation strategy consists of the following steps:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Idea of Dynamic Interpretation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "1. Parsing a sentence or text and building a representation tree of its structure.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Idea of Dynamic Interpretation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "2. Translating the parse tree into a DPL program. 3. Using precondition reasoning to compute preconditions as formulas of FOL. 4. Simplifying the preconditions using a simplifier for FOL formulas. 5. Evaluating the resulting formulas in a database model. The current implementation produces for an input text within the grammar fragment: a LaTeX form report containing the sentence, the parse tree, the DPL translation, the precondition of success, the precondition of failure and the precondition of error, all in simplified form, and the result of evaluation in the database. DPL meaning representations for natural language sentences can be viewed as procedures or programs with a relational semantics. The programs that represent the meanings are interpreted as relations between input states and output states. A state is a mapping from variables to values in a model (in our simple set-up all variables are of the same type). The representation for an example sentence such as \"John saw a man\" is a program which associates John with a variable z, a man with a variable y, and first checks whether the value of x equals John, next puts a value in y which satisfies the predicate of being a man, and finally checks whether the values of z and y are such that the first saw the second. Thus, the representation of \"John saw a man\" is a program which relates input states where z is mapped to John to output states where z is mapped to John and y is mapped to some man seen by John. If the evaluation takes place in a model where John saw several men, then there are several possible output states. If the evaluation takes place in a model where John saw no men at all, then there is no output. A program that yields no output for a given input fails for that input. A program yielding at least one output for a given input succeeds for that input. A program which yields at most one output for a given input is deterministic for that input. A program which yields more than one output for a given input is indeterministic for that input. The example \"John saw a man\" shows that indefinite descriptions may give rise to indeterministic programs. Deterministic programs that do not change their input are called test programs. If a test program succeeds, its output equals its input. The sentence \"John saw him\" would give rise to a test program. Assuming that the variable z, y are used for the subject and object of the sentence, respectively, the program will succeed for any input with x mapped to John and ~/ mapped to some male individual seen by John. In this case success means that the output state equals the input state. The program will fail for any other input.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Idea of Dynamic Interpretation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "All basic programs of DPL are tests; they do not change their input, and they succeed if the values of terms are in a specified relation and fail otherwise.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Idea of Dynamic Interpretation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "Indeterminism in DPL arises from assignment programs. The assignment program for an indefinite description a man will assign a new value to a variable x and succeed for any value of z which is a man. This is called indefinite assignment. The assignment program for a definite description ~he manager gives a value to a variable if and only if there is only one possible value in the model under consideration.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Idea of Dynamic Interpretation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "Complex programs can be formed by means of negation, implication and sequential composition. Negation and implication always form tests, but se-quential composition does not. Sequential compositions are tests if and only if the component programs are tests.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Idea of Dynamic Interpretation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "For ease of exposition we will assume there are no function symbols in the DPL representation language, so the terms of DPL are either constants or variables. Let C be the set of constants, V the set of variables, and assume c E C, v E V. We will use man, see as the relation symbols that translate \"man\", \"see\", and so on. Thus, 1is a DPL program.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Syntax", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "(1) (T/v2 : man(v2); see (v2, v4) ).", |
| "cite_spans": [ |
| { |
| "start": 25, |
| "end": 33, |
| "text": "(v2, v4)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Syntax", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "We will omit outermost brackets and brackets in sequential compositions like ((71\"1;7i'2);r3). This is harmless, for sequential composition is associative. Also, we will abbreviate r]v : v = t as v := t. This abbreviation is natural, as the sequential composition of random assignment to v and test for equality with t boils down to assigning the value of t to v.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Syntax", |
| "sec_num": "2.2" |
| }, |
| { |
| "text": "In the natural language fragment we treat, we use co-indexing to indicate intended anaphoric links. We follow Barwise [1] in using superscripts for antecedents and subscripts for anaphors.", |
| "cite_spans": [ |
| { |
| "start": 118, |
| "end": 121, |
| "text": "[1]", |
| "ref_id": "BIBREF12" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Indices for Antecedents and Anaphors", |
| "sec_num": "2.3" |
| }, |
| { |
| "text": "(2) A man walked in. He smiled.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Indices for Antecedents and Anaphors", |
| "sec_num": "2.3" |
| }, |
| { |
| "text": "If we intend the pronoun in (2) to refer to the subject of the first sentence, we indicate this intention as follows.", |
| "cite_spans": [ |
| { |
| "start": 28, |
| "end": 31, |
| "text": "(2)", |
| "ref_id": "BIBREF13" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Indices for Antecedents and Anaphors", |
| "sec_num": "2.3" |
| }, |
| { |
| "text": "(3) A man 1 walked in. He1 smiled.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Indices for Antecedents and Anaphors", |
| "sec_num": "2.3" |
| }, |
| { |
| "text": "The superscript on the indefinite noun phrase indicates that this NP acts as an antecedent for NPs with the same index as a subscript. The subscript on the pronoun indicates the antecedent to which the pronoun is linked. The use of subscripts and superscripts is necessary because noun phrases can act as anaphors and antecedents at the same time. 4A man I walked in. Another man~ walked ont. Hez was angry.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Indices for Antecedents and Anaphors", |
| "sec_num": "2.3" |
| }, |
| { |
| "text": "In example (4) the noun phrase another man is anaphorically constrained by an antecedent noun phrase a man (it must have a different referent), and at the same time acts as antecedent for the second occurrence of a man.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Indices for Antecedents and Anaphors", |
| "sec_num": "2.3" |
| }, |
| { |
| "text": "The superscripts and subscripts refer to the variables we employ in the translation of the noun phrases. Superscripts correspond to variables that get assigned a value in the translation, subscripts to variables that are simply used. Sentence 5will get translated as (6) (tense is ignored, here and hereafter, for ease of exposition). 5John 1 saw a man 2.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Indices for Antecedents and Anaphors", |
| "sec_num": "2.3" |
| }, |
| { |
| "text": "(6) vl := J; : man 2; see( l,,2).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Indices for Antecedents and Anaphors", |
| "sec_num": "2.3" |
| }, |
| { |
| "text": "Sentence 7gets translated as (8) . 7Mary 3 ignored himx. (8) va := M; ignore (va, vl) .", |
| "cite_spans": [ |
| { |
| "start": 29, |
| "end": 32, |
| "text": "(8)", |
| "ref_id": "BIBREF19" |
| }, |
| { |
| "start": 57, |
| "end": 60, |
| "text": "(8)", |
| "ref_id": "BIBREF19" |
| }, |
| { |
| "start": 77, |
| "end": 85, |
| "text": "(va, vl)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Indices for Antecedents and Anaphors", |
| "sec_num": "2.3" |
| }, |
| { |
| "text": "Sentence 9gets translated as (10) . 9Shea saw another man~. 10~/v4; v4 \u00a2 v2; man(v4); see (va, v4) . Turning now to definite descriptions, the natural translation of example 11is 12. 11John I saw the man 2.", |
| "cite_spans": [ |
| { |
| "start": 29, |
| "end": 33, |
| "text": "(10)", |
| "ref_id": "BIBREF21" |
| }, |
| { |
| "start": 90, |
| "end": 98, |
| "text": "(va, v4)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Indices for Antecedents and Anaphors", |
| "sec_num": "2.3" |
| }, |
| { |
| "text": "(12) vl := J; ~v2 : man(v2); see (vl, v2) . In the error state semantics for DPL that we have in mind for this, 12gives error in every model where there is no unique man. It is clear that in most cases this is too strong. Still, we do not think this is a serious problem for our general approach. It seems to be a linguistic fact that definite descriptions often are used in a context-dependent way, to designate a unique referent in a very specific context, which however is not made fully explicit.", |
| "cite_spans": [ |
| { |
| "start": 33, |
| "end": 41, |
| "text": "(vl, v2)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Indices for Antecedents and Anaphors", |
| "sec_num": "2.3" |
| }, |
| { |
| "text": "One context where (11) makes perfect sense is a situation where John and some other male individual are present, and where it is left implicit that John is excluded from the context where the reference is unique. In such cases we propose to read the definite description as uniquely satisfying the description plus the extra condition of being non-identical with some constraining antecedent, in this case the subject of the sentence. This strategy boils down to reading (11) as (13). 13John 1 saw the other man~.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Indices for Antecedents and Anaphors", |
| "sec_num": "2.3" |
| }, |
| { |
| "text": "Here the determiner the otheri is treated similarly to anotheri. This gives translation (14).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Indices for Antecedents and Anaphors", |
| "sec_num": "2.3" |
| }, |
| { |
| "text": "Vl := J; ,v2:(v2 \u00a2 vi; man(v2)); see(vi, cases another mechanism seems to be at In many work. 15A man walked in. John saw the man.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "(14)", |
| "sec_num": null |
| }, |
| { |
| "text": "Example (15) has a natural reading where the definite description is anaphorically linked to an antecedent. We propose to make such implicit anaphoric links explicit, as in (16).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "(14)", |
| "sec_num": null |
| }, |
| { |
| "text": "A man a walked in. John 2 saw the man~.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "(16)", |
| "sec_num": null |
| }, |
| { |
| "text": "If we provide the right translation instruction for such anaphoric uses of the, we arrive at translation (17).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "(16)", |
| "sec_num": null |
| }, |
| { |
| "text": "Ovl : man(vl); walk-in(v1); vg~ := J; /,'03 : (133 = 131; man(vs)); see (v2, v3) . This gives the man~ the meaning: the unique man that is equal to vl, with v3 available for later reference to this individual. It seems to us that this gives the correct result, in the present case and in lots of other cases.", |
| "cite_spans": [ |
| { |
| "start": 72, |
| "end": 80, |
| "text": "(v2, v3)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "(17)", |
| "sec_num": null |
| }, |
| { |
| "text": "In the case of (18) we still run into trouble, however. 18The man with the hat smiled.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "(17)", |
| "sec_num": null |
| }, |
| { |
| "text": "Here, the natural translation is (19).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "(17)", |
| "sec_num": null |
| }, |
| { |
| "text": "(19) +vx : (man(v1); ,vz : hat(v2) ; is-of(v2, vl); smile(v1).", |
| "cite_spans": [ |
| { |
| "start": 11, |
| "end": 34, |
| "text": "(man(v1); ,vz : hat(v2)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "(17)", |
| "sec_num": null |
| }, |
| { |
| "text": "This translation contains a definite assignment ev2 : hat(v2), so it seems to assume that there is a unique hat in the domain of discourse, which is perhaps a bit too strong. There are at least the following two ways out. One is by handwaving. Just remark that in descriptions like the man with the golden gun, the second definite article is not quite as definite as it looks, and the description is in fact idiomatic for the more strictly correct the man with a golden gun. The other escape is to add an epicycle to the analysis, in order to achieve that man 1 with1 the hat 2 translates into (20). We provisionally opt for the first solution.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "(17)", |
| "sec_num": null |
| }, |
| { |
| "text": "The standard DPL semantics maps input states to sets of possible output states. Let a model .A4 = (M, II, where M is the domain and I the interpretation function for a set of constants and relation symbols be Kiven. Then the set of states is the set of functions M v , and the standard semantics for DPL is given by a function [.]~ :", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Semantics", |
| "sec_num": "2.4" |
| }, |
| { |
| "text": "M V --+ ~p(MV).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Semantics", |
| "sec_num": "2.4" |
| }, |
| { |
| "text": "In order to capture the uniqueness presuppositions of definite descriptions, we replace the standard semantics by an error state semantics. In a Russellian account of definite descriptions, \"The king of France is bald\" when evaluated with respect to the state of affairs in 1905 or 1993 is false, for there is no unique referent for the description. But it is much more natural to follow Frege, Strawson and the majority of the linguistic community in assuming that statements involving \"the king of France\", when interpreted with respect to a state of affairs where there is no unique king of France, may be neither true nor false, because they suffer from presupposition failure.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Semantics", |
| "sec_num": "2.4" |
| }, |
| { |
| "text": "We propose to use an error state semantics to take in account the failure of uniqueness presuppositions of t assignments. The error state semantics of DPL if given by a function [.] .~ : (M e t.J <r) -+-:P(M V 12 e).", |
| "cite_spans": [ |
| { |
| "start": 178, |
| "end": 181, |
| "text": "[.]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Semantics", |
| "sec_num": "2.4" |
| }, |
| { |
| "text": "In the definition of this function, which follows, e refers to a special error state, A ranges over proper states, B ranges over states in general (including the error state), and A[x := d] is used for the proper state which is like A, except for the fact that z is mapped to d.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Semantics", |
| "sec_num": "2.4" |
| }, |
| { |
| "text": "1 otherwise. More information on this definition can be found in [2] . For present purposes it is sufficient to note that a DPL program can execute in three different ways, when acting on a given input state:", |
| "cite_spans": [ |
| { |
| "start": 65, |
| "end": 68, |
| "text": "[2]", |
| "ref_id": "BIBREF13" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Semantics", |
| "sec_num": "2.4" |
| }, |
| { |
| "text": "1. The program reports success by producing at least one proper output state. For example, the program man(vx) when acting on an input state where Vl refers to John will succeed and return the input state as its only output state.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Semantics", |
| "sec_num": "2.4" |
| }, |
| { |
| "text": "2. The program reports failure by not producing any output at all. For example, the program rlvl : woman(v1) will fail for any input state (except e) if there are no women in the model under consideration (its output state set will be empty).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Semantics", |
| "sec_num": "2.4" |
| }, |
| { |
| "text": "3. The program reports error by producing e as its only output. For example, the program ,.vl : manager(v1) will produce e for any input state if the model under consideration does not have a unique manager.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Semantics", |
| "sec_num": "2.4" |
| }, |
| { |
| "text": "Above, we have referred to DPL formulas as programs. We are now going to use tools for programming language analysis on DPL. We will use quantified dynamic logic over DPL to describe the preconditions for success, failure and error of DPL programs. We omit outermost parentheses as usual, and use T for a formula which is always true, I for a formula which is always false.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Preconditions of DPL programs", |
| "sec_num": "3" |
| }, |
| { |
| "text": "QDL", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Preconditions of DPL programs", |
| "sec_num": "3" |
| }, |
| { |
| "text": "The semantics of QDL is as for first order logic, with the following clauses for the program modalities added (assume A ~ e): The following axiom schemata can be used to compute these conditions as formulas of FOL.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Preconditions of DPL programs", |
| "sec_num": "3" |
| }, |
| { |
| "text": "\u2022", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Preconditions of DPL programs", |
| "sec_num": "3" |
| }, |
| { |
| "text": "2. [Rt, ...t,] ", |
| "cite_spans": [ |
| { |
| "start": 3, |
| "end": 14, |
| "text": "[Rt, ...t,]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "(Rt, ... t,,)~ ~ (ntt ...t, A ~).", |
| "sec_num": "1." |
| }, |
| { |
| "text": "The most interesting item of this list is the universal schema for t assignment (item 14) . To see what it means, note that [~r]m expresses that all output states of ~r are proper. The schema states that the following are equivalent:", |
| "cite_spans": [ |
| { |
| "start": 80, |
| "end": 89, |
| "text": "(item 14)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "[,,,: ~-]~, ~ (a!v(~-)T ^ V,,((~-)T --+ [~-]~)).", |
| "sec_num": "14." |
| }, |
| { |
| "text": "\u2022 For proper input state A, the program tv : lr does only have proper output states, and all of these satisfy ~a. It is not very difficult to see that these are indeed equivalent, so the axiom schema is sound, as are the other axiom schemata.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "[,,,: ~-]~, ~ (a!v(~-)T ^ V,,((~-)T --+ [~-]~)).", |
| "sec_num": "14." |
| }, |
| { |
| "text": "The axiom schemata can be used to calculate the truth, falsity and error conditions of DPL programs as formulas of FOL. If we represent a first order model as a database, then evaluation of DPL in a model reduces to evaluation of first order formulas in the database.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "[,,,: ~-]~, ~ (a!v(~-)T ^ V,,((~-)T --+ [~-]~)).", |
| "sec_num": "14." |
| }, |
| { |
| "text": "An example will make clear how the axioms may be used to compute preconditions of DPL programs as FOL formulas. Consider example (21) with translation (22). 21If a woman is married, her husband looks after her. To calculate the falsity conditions, we can use theorem (23), which is derivable from the axiom schemata:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "[,,,: ~-]~, ~ (a!v(~-)T ^ V,,((~-)T --+ [~-]~)).", |
| "sec_num": "14." |
| }, |
| { |
| "text": "Applying theorem (23), we get the following falsity conditions for (22):", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "[,,,: ~-]~, ~ (a!v(~-)T ^ V,,((~-)T --+ [~-]~)).", |
| "sec_num": "14." |
| }, |
| { |
| "text": "3x(Wx A Mx A 3!yHyx A Vy(Hyx ~ -~Lyx)).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "[,,,: ~-]~, ~ (a!v(~-)T ^ V,,((~-)T --+ [~-]~)).", |
| "sec_num": "14." |
| }, |
| { |
| "text": "Program 22aborts with error if it doesn't succeed and doesn't fail. Modulo some FOL reasoning the conditions for this are given by (24):", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "[,,,: ~-]~, ~ (a!v(~-)T ^ V,,((~-)T --+ [~-]~)).", |
| "sec_num": "14." |
| }, |
| { |
| "text": "(24) 3x(Wx A Mx A -,d!yYyx).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "[,,,: ~-]~, ~ (a!v(~-)T ^ V,,((~-)T --+ [~-]~)).", |
| "sec_num": "14." |
| }, |
| { |
| "text": "This means that in all models where married women do have unique husbands, program (22) will never abort with error. In other words, the calculus allows us to derive that the presupposition of the definite description has been cancelled by the implication.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "[,,,: ~-]~, ~ (a!v(~-)T ^ V,,((~-)T --+ [~-]~)).", |
| "sec_num": "14." |
| }, |
| { |
| "text": "The Implementation", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "4", |
| "sec_num": null |
| }, |
| { |
| "text": "The parser The grammar for our fragment uses categorial feature unification, and the parser is based on standard techniques for such grammars. The syntax consists of a lexicon, which associates categories with lexical items, a category descriptor which gives definitions of complex categories in terms of simpler categories and some reduction rules. \u2022 John~ sees a mani: NP(Sg,Third,*j,*)-VP(Sg,Third,Tensed) -(S/(E(Sg,Third,* j,*)kS))-(E(Sg,Third,Nom,*,*)\\S) mS.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "4", |
| "sec_num": null |
| }, |
| { |
| "text": "The translator The translator uses A-calculus to translate parse trees into DPL programs\u2022 We could have translated on the fly, building translations while parsing, but the present set-up seemed preferable for reasons of modularity of design. The translation algorithm makes use of a lexical function mapping pairs consisting of a lexical item with an associated category to A-expressions in the lexicon, along the lines of [9] .", |
| "cite_spans": [ |
| { |
| "start": 423, |
| "end": 426, |
| "text": "[9]", |
| "ref_id": "BIBREF20" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "4", |
| "sec_num": null |
| }, |
| { |
| "text": "Translating a sentence into DPL boils down to lambda reduction of the lambda expression which results from combining the lambda expressions associated with the leaves of the parse tree, according to the rules of functional application dictated by the categorial structure.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "4", |
| "sec_num": null |
| }, |
| { |
| "text": "Here are some examples of lambda expressions associated with lexical items with categories. Note that we assume the presence of indices in the lexicon, so we can handle anaphoric links by co-indexing.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "4", |
| "sec_num": null |
| }, |
| { |
| "text": "For a proper understanding of the translation instructions one should bear in mind the distinction between DPL variables that are used for DPL assignment and lambda calculus variables. We use lower case for the first and upper case for the latter.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "4", |
| "sec_num": null |
| }, |
| { |
| "text": "AVl.m..(VI). ~ v~. ( ~ v2.( ~ v~.( v~(v~) ; Vl ( ~ \u00bc ~of ( V~, v3)))).", |
| "cite_spans": [ |
| { |
| "start": 19, |
| "end": 41, |
| "text": "( ~ v2.( ~ v~.( v~(v~)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Translation for man, N(Sg):", |
| "sec_num": null |
| }, |
| { |
| "text": "All these translations are typed, but we have left most of the typing discipline implicit. For example, the translations of noun phrases all are of the type of (dynamic) generalized quantifiers, which take a property to give a DPL program. The translation of proper names is a dynamic variation of the Montague treatment for proper names [8] . In extensional Montague grammar, proper names translate into expressions denoting the set of properties which are true of the named individual. Here, proper names translate into expressions that for every property give the DPL program which first assigns the name of the individual to the index variable of the proper name, and then tests for the property. This is like in Montague grammar, but with a dynamic touch added. Anaphoric links to the name remain possible by means of the index variable as long as its value remains unchanged.", |
| "cite_spans": [ |
| { |
| "start": 338, |
| "end": 341, |
| "text": "[8]", |
| "ref_id": "BIBREF19" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Translation for man, N(Sg):", |
| "sec_num": null |
| }, |
| { |
| "text": "Other noun phrases with a dynamic flavour are indefinite and definite descriptions. Indefinite descriptions translate into expressions that for every property give the DPL program which does an indefinite assignment to an index variable and tests for the property. Definite descriptions are handled likewise, but with definite assignment instead of indefinite assignment. 25GSdel has facilities that permit elegant metaprogramming. In Prolog the program and the metaprogram are not independent: the predicates assert and retract modify the program itself in which these predicates occur. In GSdel, program and metaprogram are completely independent. It is possible for a program to load another program, to modify this other program by inserting or retracting predicates, functions or types, and to demonstrate a goal. In our implementation we use these facilities to represent a model as a logic database and a precondition as a complex goal.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Translation for man, N(Sg):", |
| "sec_num": null |
| }, |
| { |
| "text": "The Program Itself", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "6", |
| "sec_num": null |
| }, |
| { |
| "text": "The main module takes a sentence or text as input and produces a report containing the sentence, the parse tree, the DPL program it gets translated into, and the preconditions. This module uses the following submodules:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "6", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 the parser module which from a sentence, finds its category and builds its parse tree,", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "6", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 the translation module which from the parse tree, computes a representation of a DPL program, \u2022 the precondition module which from a DPL program, derives the preconditions (this module calls another module to simplify the resulting FOL formulas),", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "6", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 the evaluation module which performs a database evaluation.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "6", |
| "sec_num": null |
| }, |
| { |
| "text": "A lexicon module is called by the first two of these modules. It contains the words, with their categories and the associated A-expressions.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "6", |
| "sec_num": null |
| }, |
| { |
| "text": "This module receives a sentence represented by a list of words and parses it, translates it, produces a report, computes preconditions and evaluates these in a given model.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Main module", |
| "sec_num": "6.1" |
| }, |
| { |
| "text": "This module defines how to output programs, expressions, categories, trees, words, ... It uses the facilities of GSdel for manipulating text files.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Output", |
| "sec_num": "6.2" |
| }, |
| { |
| "text": "The lexicon is defined by a predicate Diet with three arguments: the word itself, a category and an appropriate lambda expression.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Lexicon", |
| "sec_num": "6.3" |
| }, |
| { |
| "text": "The parser employs backtracking and unification in the usual way. GSdel (as all logic programming languages) has these features built in, which makes it very easy to implement a parser for a simple fragment like ours. The parsing of a sentence consists of three steps:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Parser", |
| "sec_num": "6.4" |
| }, |
| { |
| "text": "* generate a list of categories corresponding to the sequence of words,", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Parser", |
| "sec_num": "6.4" |
| }, |
| { |
| "text": "\u2022 reduce the list of categories,", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Parser", |
| "sec_num": "6.4" |
| }, |
| { |
| "text": "\u2022 test if you have a sentence else retrace your steps and try again.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Parser", |
| "sec_num": "6.4" |
| }, |
| { |
| "text": "We use the type categor to represent categories. It is defined by the constant S and the functions E (nnmber, person, case, nindex, dindez) , NP (number, person, case, uindex, dindex) Empty represents the empty tree and the function A gives the information at the current node, the left subtree, and the right subtree. The information content of the nodes is of two kinds: internal nodes carry the result of combining the categories of the subtrees and leaf nodes carry a pair consisting of a word and its category. The parse trees are built during the reduction of the list of categories, starting with a list of trees corresponding to the words of the sentence. When we reduce two adjacent categories, we replace the two corresponding trees T1, 7\"2 by a single tree with T1 and Tz as immediate subtrees.", |
| "cite_spans": [ |
| { |
| "start": 101, |
| "end": 139, |
| "text": "(nnmber, person, case, nindex, dindez)", |
| "ref_id": null |
| }, |
| { |
| "start": 142, |
| "end": 183, |
| "text": "NP (number, person, case, uindex, dindex)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Parser", |
| "sec_num": "6.4" |
| }, |
| { |
| "text": "The translator uses two types: Program and Ezpression. The first represents a DPL-program, the second a complex A-expression. We have left the rest of the typing of the lambda expressions implicit. The definition of programs and lambda expressions is a bit cumbersome, for a A-expression may contain a program and vice versa. This complication is reflected in the rules for substitution and reduction. For example, it is necessary to define the substitution of an expression for a variable in a program, the free occurrence of a variable in a program, etc. The rules of reduction are a straightforward rendering of the rules of ~-reduction and 7-reduction in A calculus. We do not handle a reduction, as we see no need for variable renaming. The translation process employs the following predicates:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Translator", |
| "sec_num": "6.5" |
| }, |
| { |
| "text": "Trad This predicate translates a parse tree into a reduced A-expression. Depending on the information at the current node of the parse tree, a lexical lookup of the translation takes place, or the translation is found by reducing the application of the translations of the left and right subtrees.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Translator", |
| "sec_num": "6.5" |
| }, |
| { |
| "text": "Trans This predicate translates a list of parse trees for the sentences of a text into the corresponding 7", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Translator", |
| "sec_num": "6.5" |
| }, |
| { |
| "text": "The QDL translation discussed above only handles uniqueness presuppositions of definite descriptions. The method employed is general enough, however, to handle lots of other kinds of presupposition. Lexteal presuppositions, for example, are handled in the error state semantics by a slight revision of the semantic clause for atomic tests. Being a bachelor presupposes being male and adult, so the test for bachelorhood should give error if it is performed on an entity that does not satisfy the test for being a male adult. Formally, the revision boils down to this. Let At be the set of atomic formulae of DPL. Assume a lexicat presupposition function lp : At ~ DPL mapping each atomic test predicate of the representation language to its associated lexical presupposition, conceived as a program of the representation language. For example, here are the lexical presuppositions for bachelorhood.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": null |
| }, |
| { |
| "text": "lp(bachelor x) = (male x; adult x).", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": null |
| }, |
| { |
| "text": "The semantic clause for atomic relations is modified to take the function lp into account: This modified definition gives the success and failure of the relational test modulo the fact that the lexical presupposition of the relational test holds; if the presupposition does not hold then the test results in error. There is no need for any other changes in the rules, for the projection of lexical presupposition is taken care of by the general principles of error percolation that are already implicit in the semantic clauses. Thus, the DPL error semantics gives us that (28) presupposes that Jan is male and adult, but that (29) only presupposes that Jan is adult.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": null |
| }, |
| { |
| "text": "Jan is a bachelor. 29If Jan 1 is male, then hel is a bachelor.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "(28)", |
| "sec_num": null |
| }, |
| { |
| "text": "The change in the semantic clause for atomic relations is reflected in the calculus by replacing the schemata for Rtl ...tn by the following versions: In the implementation, lexical presupposition is handled by a predicate Lp and a modification of the reduction predicates for the relational test axiom schemata.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "(28)", |
| "sec_num": null |
| }, |
| { |
| "text": "Right now, we are extending the fragment to deal with other kinds of presupposition failure, in particular failure of presupposition of aspectual verbs such as start and stop.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "(28)", |
| "sec_num": null |
| } |
| ], |
| "back_matter": [ |
| { |
| "text": "As an example, we treat the translation of (25), which is obtained starting from the following parse tree:(S, (NP 1, John) , (yP, (TV, u~e~) , (NP?, (DET~,his) , (N, pc) ;w2.,v2 : pc(v2); is-of(v2, v0; v2(~2).uses his pc~ )~ V~ . ( )W2 . V, ( ), Vs . use ( V2 ,113 ) ) ) (~v2.~v2 : pc(v2); i~-of(~2, v0; v2(v2))~v2.(~v2.(~ : pc(~2); i~-of(v2, ~); V2(v2)) (aV3.use(V~, V,)) (AV~.tv2 : pc(v2) ; is-of(v~., vl) ; (AVa.use(V2, Vs) ~v2.,v2 : p~(v2); is-of(,2,,1); use(V2, ~2).John 1 uses his pc~ (~Vl.v~ := J; (vdvl)) ~V2.,v2 : ~c(v~); i~.of(v~, v~); use(V2, v~),.-+ v~ := J;(AVz .tv2: pc(v2); is-of(vg., Vl); use(V~, vg.)) (vl) ...4Vl := J; ~ : ~c(v~); is-of(~, ~1); use(~x, v~).In the same way, (26) gets translated into (27). 26John 1 is a man ~. (27) vl := J; ~/v2 : man(v2); Vl = v2.Note that 'is' is treated as in Montague grammar [8] . \u2022 Fequal(tl, t2) is an atomic test of equality of the terms tl and t2. (tl = t2) \u2022 Fand(phil, phi2) is the conjunction of two formulls. (~1 A ta2) \u2022 For(phil, phi2) is the disjunction of two formulls. (~1 V ta2) \u2022 Fimplie(phl,phi2)is the implication of two formulas. 1, phi) is the expression (q!vi~) \u2022 Fnot(phi) is the negation of the formula ta.", |
| "cite_spans": [ |
| { |
| "start": 110, |
| "end": 116, |
| "text": "(NP 1,", |
| "ref_id": null |
| }, |
| { |
| "start": 117, |
| "end": 122, |
| "text": "John)", |
| "ref_id": null |
| }, |
| { |
| "start": 125, |
| "end": 129, |
| "text": "(yP,", |
| "ref_id": null |
| }, |
| { |
| "start": 130, |
| "end": 140, |
| "text": "(TV, u~e~)", |
| "ref_id": null |
| }, |
| { |
| "start": 143, |
| "end": 159, |
| "text": "(NP?, (DET~,his)", |
| "ref_id": null |
| }, |
| { |
| "start": 162, |
| "end": 169, |
| "text": "(N, pc)", |
| "ref_id": null |
| }, |
| { |
| "start": 373, |
| "end": 390, |
| "text": "(AV~.tv2 : pc(v2)", |
| "ref_id": null |
| }, |
| { |
| "start": 393, |
| "end": 407, |
| "text": "is-of(v~., vl)", |
| "ref_id": null |
| }, |
| { |
| "start": 410, |
| "end": 422, |
| "text": "(AVa.use(V2,", |
| "ref_id": null |
| }, |
| { |
| "start": 423, |
| "end": 426, |
| "text": "Vs)", |
| "ref_id": null |
| }, |
| { |
| "start": 491, |
| "end": 512, |
| "text": "(~Vl.v~ := J; (vdvl))", |
| "ref_id": null |
| }, |
| { |
| "start": 619, |
| "end": 623, |
| "text": "(vl)", |
| "ref_id": null |
| }, |
| { |
| "start": 745, |
| "end": 749, |
| "text": "(27)", |
| "ref_id": null |
| }, |
| { |
| "start": 832, |
| "end": 835, |
| "text": "[8]", |
| "ref_id": "BIBREF19" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "John x uses his pc~.", |
| "sec_num": null |
| }, |
| { |
| "text": "\u2022 Fpreeexist(pi, phi)is the expression ((~r)ta) \u2022 Fprecuniv(pi, phi)is the expression ([~r]ia) \u2022 Fpar(pi, phi) is the expression (-~(Tr)taA-~[Tr]~). In the course of applying these predicates, formulas may get generated with obvious redundancies. We have defined a formula simplifier to remove some of these. This improves the readability of the output (the formulas are output in LaTeX format) and the performance of the database lookup on the basis of the conditions. There is the list of simplifications handled by the module Simple. ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Experiences with the GSdel Implementation Language", |
| "sec_num": "5" |
| }, |
| { |
| "text": "The intermediate language QDL allows us to translate DPL programs into formulas of FOL. These are then evaluated in a database model, i.e., a first order model which is implemented as a G6del database (a G6del program). There we have a so-cMled metamodule Evaluation and an object program Logic Database, and the meta-program manipulates the object program. We translate first order conditions into G6del goals, and then apply the goal to the object G6del program, using the possibilities of metaprogramming offered by G6del. In ordinary Prolog, these things could also be done, but they would look much less elegant.Here is an example of a Gfdel model (the lines preceded by % are comment lines): ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Evaluation", |
| "sec_num": "6.7" |
| } |
| ], |
| "bib_entries": { |
| "BIBREF0": { |
| "ref_id": "b0", |
| "title": "Bill)", |
| "authors": [ |
| { |
| "first": "(", |
| "middle": [], |
| "last": "Admire", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "John", |
| "suffix": "" |
| } |
| ], |
| "year": null, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Admire(John,Bill).", |
| "links": null |
| }, |
| "BIBREF4": { |
| "ref_id": "b4", |
| "title": "Manager(Bill)", |
| "authors": [], |
| "year": null, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Manager(Bill).", |
| "links": null |
| }, |
| "BIBREF9": { |
| "ref_id": "b9", |
| "title": "Adult(Bill)", |
| "authors": [], |
| "year": null, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Adult(Bill).", |
| "links": null |
| }, |
| "BIBREF11": { |
| "ref_id": "b11", |
| "title": "Myclone)", |
| "authors": [ |
| { |
| "first": "(", |
| "middle": [], |
| "last": "Use", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "John", |
| "suffix": "" |
| } |
| ], |
| "year": null, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Use(John,Myclone).", |
| "links": null |
| }, |
| "BIBREF12": { |
| "ref_id": "b12", |
| "title": "Noun phrases, generalized quantitiers and anaphora", |
| "authors": [ |
| { |
| "first": "J", |
| "middle": [], |
| "last": "Barwise", |
| "suffix": "" |
| } |
| ], |
| "year": 1987, |
| "venue": "Generalized Quantifiers: linguistic and logical approaches", |
| "volume": "", |
| "issue": "", |
| "pages": "1--30", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "J. Barwise. Noun phrases, generalized quanti- tiers and anaphora. In P. G~rdenfors, editor, Generalized Quantifiers: linguistic and logical approaches, pages 1-30. D. Reidel Publishing Company, Dordrecht, 1987.", |
| "links": null |
| }, |
| "BIBREF13": { |
| "ref_id": "b13", |
| "title": "The dynamics of description", |
| "authors": [ |
| { |
| "first": "J", |
| "middle": [], |
| "last": "Van Eijck", |
| "suffix": "" |
| } |
| ], |
| "year": 1993, |
| "venue": "Journal of Semantics", |
| "volume": "10", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "J. van Eijck. The dynamics of description. Jour- nal of Semantics, 10, 1993. to appear.", |
| "links": null |
| }, |
| "BIBREF14": { |
| "ref_id": "b14", |
| "title": "Presupposition failure --a comedy of errors. Manuscript, CWI", |
| "authors": [ |
| { |
| "first": "J", |
| "middle": [], |
| "last": "Van Eijck", |
| "suffix": "" |
| } |
| ], |
| "year": 1993, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "J. van Eijck. Presupposition failure --a comedy of errors. Manuscript, CWI, Amsterdam, 1993.", |
| "links": null |
| }, |
| "BIBREF15": { |
| "ref_id": "b15", |
| "title": "Dynamic interpretation and Hoare deduction", |
| "authors": [ |
| { |
| "first": "J", |
| "middle": [], |
| "last": "Van Eijck", |
| "suffix": "" |
| }, |
| { |
| "first": "F", |
| "middle": [ |
| "J" |
| ], |
| "last": "De Vries", |
| "suffix": "" |
| } |
| ], |
| "year": 1992, |
| "venue": "Journal of Logic, Language, and Information", |
| "volume": "1", |
| "issue": "", |
| "pages": "1--44", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "J. van Eijck and F.J. de Vries. Dynamic in- terpretation and Hoare deduction. Journal of Logic, Language, and Information, 1:1-44, 1992.", |
| "links": null |
| }, |
| "BIBREF16": { |
| "ref_id": "b16", |
| "title": "Dynamic predicate logic", |
| "authors": [ |
| { |
| "first": "J", |
| "middle": [], |
| "last": "Groenendijk", |
| "suffix": "" |
| }, |
| { |
| "first": "M", |
| "middle": [], |
| "last": "Stokhof", |
| "suffix": "" |
| } |
| ], |
| "year": 1991, |
| "venue": "Linguistics and Philosophy", |
| "volume": "14", |
| "issue": "", |
| "pages": "39--100", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "J. Groenendijk and M. Stokhof. Dynamic pred- icate logic. Linguistics and Philosophy, 14:39- 100, 1991.", |
| "links": null |
| }, |
| "BIBREF17": { |
| "ref_id": "b17", |
| "title": "The GSdel report", |
| "authors": [ |
| { |
| "first": "P", |
| "middle": [ |
| "M" |
| ], |
| "last": "Hill", |
| "suffix": "" |
| }, |
| { |
| "first": "J", |
| "middle": [ |
| "W" |
| ], |
| "last": "Lloyd", |
| "suffix": "" |
| } |
| ], |
| "year": 1991, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "P.M. Hill and J.W. Lloyd. The GSdel report. Technical report, Department of Computer Sci- ence, University of Bristol, Bristol, 1991 (re- vised 1992).", |
| "links": null |
| }, |
| "BIBREF18": { |
| "ref_id": "b18", |
| "title": "A logic programming language with lambda abstraction, function variables and simple unification", |
| "authors": [ |
| { |
| "first": "D", |
| "middle": [ |
| "A" |
| ], |
| "last": "Miller", |
| "suffix": "" |
| } |
| ], |
| "year": 1990, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "D.A. Miller. A logic programming language with lambda abstraction, function variables and sim- ple unification. In P. Schroeder-Heister, edi- tor, Eztensions of Logic Programming. Springer, 1990.", |
| "links": null |
| }, |
| "BIBREF19": { |
| "ref_id": "b19", |
| "title": "The proper treatment of quantification in ordinary english", |
| "authors": [ |
| { |
| "first": "R", |
| "middle": [], |
| "last": "Montague", |
| "suffix": "" |
| } |
| ], |
| "year": 1973, |
| "venue": "Approaches to Natural Language", |
| "volume": "", |
| "issue": "", |
| "pages": "221--242", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "R. Montague. The proper treatment of quantifi- cation in ordinary english. In J. Hintikka e.a., editor, Approaches to Natural Language, pages 221-242. Reidel, 1973.", |
| "links": null |
| }, |
| "BIBREF20": { |
| "ref_id": "b20", |
| "title": "Anaphora and the logic of change", |
| "authors": [ |
| { |
| "first": "R", |
| "middle": [], |
| "last": "Muskens", |
| "suffix": "" |
| } |
| ], |
| "year": 1990, |
| "venue": "Logics in AI / European Workshop JELIA '90", |
| "volume": "478", |
| "issue": "", |
| "pages": "412--427", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "R. Muskens. Anaphora and the logic of change. In J. van Eijck, editor, Logics in AI / Eu- ropean Workshop JELIA '90 / Amsterdam, The Netherlands, September 1990 / Proceed- ings, Lecture Notes in Artificial Intelligence 478, pages 412-427. Springer Verlag, 1991.", |
| "links": null |
| }, |
| "BIBREF21": { |
| "ref_id": "b21", |
| "title": "Tense and the logic of change", |
| "authors": [ |
| { |
| "first": "R", |
| "middle": [], |
| "last": "Muskens", |
| "suffix": "" |
| } |
| ], |
| "year": 1992, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "R. Muskens. Tense and the logic of change. Manuscript, University of Tilburg, 1992.", |
| "links": null |
| }, |
| "BIBREF22": { |
| "ref_id": "b22", |
| "title": "Semantical considerations on Floyd-Honre logic", |
| "authors": [ |
| { |
| "first": "V", |
| "middle": [], |
| "last": "Pratt", |
| "suffix": "" |
| } |
| ], |
| "year": 1976, |
| "venue": "Proceedings 17th IEEE Symposium on Foundations of Computer Science", |
| "volume": "", |
| "issue": "", |
| "pages": "109--121", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "V. Pratt. Semantical considerations on Floyd- Honre logic. Proceedings 17th IEEE Symposium on Foundations of Computer Science, pages 109-121, 1976.", |
| "links": null |
| } |
| }, |
| "ref_entries": { |
| "FIGREF0": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "DPL terms t ::= c I v. Assume a set of relation symbols R with arities. Then the programs of DPL are given by the following BNF definition. DPL programs ~r ::= t = t I Rt...t [ Qr;r) [(r" |
| }, |
| "FIGREF1": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "l); t~)2: (hat(I)2)\" ~ i8-0f(I;2,1)1) )." |
| }, |
| "FIGREF2": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": ". [xl.~l(e) = {c} 2. [Rta...tn].~(A)= {A} if (V~,a(tl), .... V.~,a(tn)) E I(R) 0 otherwise. 3. [t~ = t2].~(A) = {A} if Vdbl,A('l) ~-V.I~,A('2) there is a state B E [a'l]~(A) with[lr2]~(B) = {c} {A} if for all B e [~II~(A) it holds that[a'2]~(B) \u2022 {e) otherwise. 6. [('~x]~a(A) = {e} if [a']~(A) = {e} {A} if [Tr],~(A]~(A[z := d]) for the unique d with [x]~(A[z := d]) g {e} if d exists {e}" |
| }, |
| "FIGREF3": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "A4 ~A (~')~ iff there is some B with B E [Tr]]~a(A), B \u00a2 e and .44 ~B 9. \u2022 A4 ~A [lr]~ iff for all S e Iris(A) it holds that B # e and .44 ~ 9-Note that (~r) and [~r] are not duals. (~')T expresses the conditions for success of ~r, [~-].L the conditions for failure of z. It follows that ~(~r)T A --[~r].l_ expresses the conditions for error." |
| }, |
| "FIGREF4": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "to." |
| }, |
| "FIGREF5": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "n,,: ,r)~, ~. a~,(,,-)~,. 12. Nv: ~r]~# --Vv[vr]~." |
| }, |
| "FIGREF6": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "\u2022 For proper input state A there is precisely one d E M for which 7r has a proper output on input A[v :-d], and for all d' for which ~r has proper outputs on A[v := d'], all outputs of lr on A[v := d'] are proper and satisfy 9." |
| }, |
| "FIGREF7": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "Wx; Mx) =~ (~y: gyx; Lyx).Here is the derivation of the truth conditions.((rlz : Wa~; Mz) =~ (ty: Hyz; Lyx))T 4-~ [~x: Wx; Mx](~y : ttyx; Lyx)T ~-+ [rlx: Wx][Mz](*y : I'lyz)(Ly~)T ~-* Vx[Wx][Mx](Ly : Hyx}(Lyx)T Vx(Wx ~ (Mx -~ (:JIy(I-Iy~c)-t-A By(I-Iyx)(Lyx)T))) ,-, Vx(W2: .-* (Mx (3!yH~ ^ 3y(Hy~ ^ Lye))))." |
| }, |
| "FIGREF8": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "Basic categories are S without features, and E with features for number, person, case, uindez for up index (= antecedent index) and dindex for down index (= anaphor index). Complex categories are built with / and \\ and the constraints on feature unification in the usual way. The index features uindez and dindez also occur on noun phrases and determiners. Here are some examples of complex categories (, marks the feature values that do not matter). \u2022 N(number) = S/E(number,*,*,*). \u2022 NP(number,person,case,uindex,dindex) = S/(E(number,person,case,uindex,dindex) kS). \u2022 VP(number,person,*) = E(number,person,Nom,*,*)\\S. \u2022 TV(number,person,tense) = VP(*,*,tense)/NP(*,*,Acc,*,*). \u2022 DET(number,uindex,dindex) = NP(number,Third,*,uindex,dindex)/ N(number). \u2022 AUX(number,person) -VP(number,person,Tensed)/ VP (number ,person ,In f). \u2022 NEG = AUX(number,person)\\AUX(number,person). Basic categories get assigned in the lexicon. For ex-, Third, Tensed) \u2022 NP(Sg,Whird,*,*,*) = (VP(Sg,Third,Tensed)/ NP(Sg,Third,Acc,*,*,*)) -NP(Sg,Third,*,*,*) = VP(Sg,Third,Tensed)." |
| }, |
| "FIGREF9": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "Translation for John i,NP(Sg,Third,*,i,*): AVl.vi := J; Vi(v,). Translation for sees, TV(Sg,Third,Tensed): A VI.( A V2.(Vl A V3.see(V2, V3))). Translation for is, TV(Sg,Third,Tensed): A VI .( A V2.(Vl A Vs. V2 = v3)). Translation for a(n) i, Det(Sg,i,*): AV~.(AV2.(,lv, : VlO,,); V2(,,))). Translation for the i, Det(*,i,*): AVI.(AV~.(~,,,: V,(v,); V~(v,))). Translation for the~, Det(*,ij) (the anaphoric use of the): AVI.(AV2.~v, : (v, = vi; VlV,); v2(,,)). Translation for if, (S/S)/S: A VI ,( A V2. V, =~ v~ ). Translation for does, AUX(Sg,Third): AVI.V1. Translation for not, NEG: ~ v~ . ( ~ v~ . -, ( v~ v~ ) ) . Translation for another, DET(Sg,i,j): ~Vl.(~v~.(,~v~ : ,~ # v~; v](~); V~(vd)). Translation for the other, DET(*,i~): ~Vl.(~V~.(~,~ : (.~ # ~; V~(v~)); V~(~d)). Translation for he/, NP(Sg,Third,Nom,*,i): ~v~.v,(~,). Translation for hisS, DET(*,ij): ~v~.(~v~.,v~ : Vl(,d; iso/(,~, ~); V2(vd). Translation for with, (N(nr)\\N(nr))/NP(*,*,*,*,*):" |
| }, |
| "FIGREF10": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "{A} if ~lp(Rtl...t,)]~(A) q~ {e} and A4 ~A Rta ...tn, 0 if [lp(Rtl-.. t,)]~(A) 9~ {'} and .~4 ~A Rta ...t,~, {,} if ~lp(Rtl-..t,)]~(A) C_ {,}." |
| }, |
| "FIGREF11": { |
| "uris": null, |
| "num": null, |
| "type_str": "figure", |
| "text": "(Rtl...tn)~a ~-+ (Rtl... t,, A (p A (lp(Rt~ \u2022 \u2022 \u2022 tn))r). 2. [Rtl...tn]~ *-+ ( Rtl . . . t. --+ ~) ^ (lp(m~ .. \u2022 tn))r)." |
| } |
| } |
| } |
| } |
