| { |
| "paper_id": "E93-1008", |
| "header": { |
| "generated_with": "S2ORC 1.0.0", |
| "date_generated": "2023-01-19T10:54:30.221608Z" |
| }, |
| "title": "Disjunctions and Inheritance in the Context Feature Structure System", |
| "authors": [ |
| { |
| "first": "Martin", |
| "middle": [], |
| "last": "Bsttcher", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "GMD-IPSI", |
| "location": { |
| "addrLine": "Dolivostra~e 15", |
| "postCode": "D 6100", |
| "settlement": "Darmstadt Germany boettche~darmstadt.gmd.de" |
| } |
| }, |
| "email": "" |
| } |
| ], |
| "year": "", |
| "venue": null, |
| "identifiers": {}, |
| "abstract": "Substantial efforts have been made in order to cope with disjunctions in constraint based grammar formalisms (e.g. [Kasper, 1987; Maxwell and Kaplan, 1991; DSrre and Eisele, 1990].). This paper describes the roles of disjunctions and inheritance in the use of feature structures and their formal semantics. With the notion of contexts we abstract from the graph structure of feature structures and properly define the search space of alternatives. The graph unification algorithm precomputes nogood combinations, and a specialized search procedure which we propose here uses them as a controlling factor in order to delay decisions as long as there is no logical necessity for deciding.", |
| "pdf_parse": { |
| "paper_id": "E93-1008", |
| "_pdf_hash": "", |
| "abstract": [ |
| { |
| "text": "Substantial efforts have been made in order to cope with disjunctions in constraint based grammar formalisms (e.g. [Kasper, 1987; Maxwell and Kaplan, 1991; DSrre and Eisele, 1990].). This paper describes the roles of disjunctions and inheritance in the use of feature structures and their formal semantics. With the notion of contexts we abstract from the graph structure of feature structures and properly define the search space of alternatives. The graph unification algorithm precomputes nogood combinations, and a specialized search procedure which we propose here uses them as a controlling factor in order to delay decisions as long as there is no logical necessity for deciding.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstract", |
| "sec_num": null |
| } |
| ], |
| "body_text": [ |
| { |
| "text": "The Context Feature Structure System (CFS) [BSttcher and KSnyves-Tdth, 1992 ] is a unification based system which evaluates feature structures with distributed disjunctions and dynamically definable types for structure inheritance. CFS is currently used to develop and to test a dependency grammar for German in the text analysis project KONTEXT. In this paper disjunctions and inheritance will be investigated with regard to both, their application dimension and their efficient computational treatment.", |
| "cite_spans": [ |
| { |
| "start": 43, |
| "end": 75, |
| "text": "[BSttcher and KSnyves-Tdth, 1992", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "The unification algorithm of CFS and the concept of virtual agreements for structure sharing has been introduced in [BSttcher and KSnyves-TSth, 1992] . The algorithm handles structure inheritance by structure sharing and constraint sharing which avoids copying of path structures and constraints completely. Disjunctions are evaluated concurrently without backtracking and without combinatoric multiplication of the path structure. For that purpose the path structure is separated from the structure of disjunctions by the introduction of contexts.", |
| "cite_spans": [ |
| { |
| "start": 130, |
| "end": 149, |
| "text": "KSnyves-TSth, 1992]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "Contexts are one of the key concepts for maintaining disjunctions in feature terms. They describe readings of disjunctive feature structures. We define them slightly different from the definitions in [DSrre and Eisele, 1990] and [Backofen et ai., 1991] , with a technical granularity which is more appropriate for their efficient treatment. The CFS unification algorithm computes a set of nogood contexts for all conflicts which occur during unification of structures. An algorithm for contexts which computes from a set of nogoods whether a structure is valid, will be described in this paper. It is a specialized search procedure which avoids the investigation of the full search space of contexts by clustering disjunctions.", |
| "cite_spans": [ |
| { |
| "start": 200, |
| "end": 224, |
| "text": "[DSrre and Eisele, 1990]", |
| "ref_id": null |
| }, |
| { |
| "start": 229, |
| "end": 252, |
| "text": "[Backofen et ai., 1991]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "We start with some examples how disjunctions and inheritance are used in the CFS environment. Then contexts are formally defined on the basis of the semantics of CFS feature structures. Finally the algorithm computing validity of contexts is outlined.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Introduction", |
| "sec_num": "1" |
| }, |
| { |
| "text": "Disjunctions are used to express ambiguity and capability. A first example is provided by the lexicon entry for German die (the, that, ...) in Figure 1 . It may be nominative or accusative, and if it is singular the gender has to be feminine.", |
| "cite_spans": [ |
| { |
| "start": 123, |
| "end": 139, |
| "text": "(the, that, ...)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 143, |
| "end": 151, |
| "text": "Figure 1", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "The Use of Disjunctions and Inheritance Disjunctions", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Those parts of the term which are not inside a disjunction are required in any case. Such parts shall be shared by all \"readings\" of the term. The internal die := L_definit-or-relativ@ <> graph : die Figure 2 shows a type describing possible realizations of a transitive object. The outermost disjunction distinguishes whether the dominating predicate is in active or in passive voice. For active predicates either a noun (syn : categ : class : nomn)or a subsentence (syn : categ : class : ssent) is allowed\u2022 This way disjunctions describe and restrict the possibility of combinations of constituents\u2022", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 200, |
| "end": 208, |
| "text": "Figure 2", |
| "ref_id": "FIGREF0" |
| } |
| ], |
| "eq_spans": [], |
| "section": "The Use of Disjunctions and Inheritance Disjunctions", |
| "sec_num": "2" |
| }, |
| { |
| "text": "The KONTEXT grammar is a lexicalized grammar. This means that the possibility of combinations of constituents is described with the entries in the lexicon rather than in a separated, general grammar. A chart parser is used in order to decide which constituents to combine and maintain the combinations\u2022 This means that some of the disjunctions concerning concrete combinations are handled not by the unification formalism, but by the chart\u2022 Therefore structure sharing for inheritance which is extensively used by the parser is even more important. trans is inherited (marked by $<>) to the structure for the lexeme spielen (to play) at the destination of the path syn : slots :. A virtual copy of the type structure is inserted\u2022 The type trans will be inherited to all the verbs which allow (or require) a transitive object. It is obvious that it makes sense not only to inherit the structure to all the verbs on the level of grammar description but also to share the structure in the internal representation, without copying it.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "External Treatment of Disjunctions", |
| "sec_num": null |
| }, |
| { |
| "text": "L_spielen := lexem : spielen .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "External Treatment of Disjunctions", |
| "sec_num": null |
| }, |
| { |
| "text": "[ fie_verb : schwach syn :", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "External Treatment of Disjunctions", |
| "sec_num": null |
| }, |
| { |
| "text": "ca~eg : [ pfk : habeil slots : trans@<> v-verbt~<> Inheritance is also extensively used by the parser. It works bottom-up and has to try different combinations of constituents. For single words it just looks up the structures in the lexicon. Then it combines a slot of a functor with a filler. An example is given in Figure 4 which shows a trace of the chart for the sentence Kinder spielen eine Rolle im Theater. (Children play a part in the theatre.) In the 6'th block, in the line starting with ... 4 the parser combines type _16 (for the lexicon entry of im) with the type _17 (for Theater) and defines this combination dynamically as type _18. _16 is the functor, _17 the filler, and caspn the name of the slot. The combination is done by unification of feature structures by the CFS system.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 317, |
| "end": 325, |
| "text": "Figure 4", |
| "ref_id": "FIGREF3" |
| } |
| ], |
| "eq_spans": [], |
| "section": "External Treatment of Disjunctions", |
| "sec_num": null |
| }, |
| { |
| "text": "The point here is that the parser tries to combine the result _18 of this step more than once with different other structures, but unification is a destructive operation! So, instead of directly unifying the structures of say _7 and _18 (_11 and _18, .\u2022.), _7 and _18 are inherited into the new structure of _20. This way virtual copies of the structures are produced, and these are unified\u2022 It is essential for efficiency that a virtual copy does not mean that the structure of the type has to be copied. The lazy copying approach ( [Kogure, 1990] , and [Emele, 1991] for lazy copying in TFS with historical backtracking) copies only overlapping parts of the structure. CFS avoids even this by structure-and constraint-sharing.", |
| "cite_spans": [ |
| { |
| "start": 534, |
| "end": 548, |
| "text": "[Kogure, 1990]", |
| "ref_id": "BIBREF4" |
| }, |
| { |
| "start": 555, |
| "end": 568, |
| "text": "[Emele, 1991]", |
| "ref_id": "BIBREF2" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "External Treatment of Disjunctions", |
| "sec_num": null |
| }, |
| { |
| "text": "For common sentences in German, which tend to be rather long, a lot of types will be generated\u2022 They supply only a small part of structure themselves (just the path from the functor to the filler and a simple slot-filler combination structure). The bulk of the structure is shared among the lexicon and all the different combinations produced by the parser.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "External Treatment of Disjunctions", |
| "sec_num": null |
| }, |
| { |
| "text": "Recursive inheritance would be a means to combine phrases in order to analyze (and generate) without a parser (as in TFS). On the other hand a parser is a controlled device which e.g. knows about important paths in feature structures describing constituents, and which can do steps in a certain sequence, while unification in principle is sequenceinvariant. We think that recursion is not in principle impossible in spite of CFS' concurrent treatment of disjunctions, but we draw the borderline between the parser and the unification formalism such that the cases for recursion and iteration are handled by the parser. This seems to be more efficient.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Avoiding Recursive Inheritance", |
| "sec_num": null |
| }, |
| { |
| "text": "The similarity of the relation between disjunctive structure and disjunct and the relation between type and instance is, that in a set theoretic semantics (see below) the denotation of the former is a superset of the denotation of the latter. The difference is that a disjunctive structure is invalid, i.e. has the empty set as denotation, if each disjunct is invalid. A type, however, stays valid even when all its currently known instances are invalid. This distinction mirrors the uses of the two: inheritance for abstraction, disjunctions for complete enumeration of alternatives. When an external system, like the chart of the parser, keeps track of the relation between types and instances disjunctions might be replaced by inheritance.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "The Connection between Disjunctions and Types", |
| "sec_num": null |
| }, |
| { |
| "text": "This chapter introduces the syntax and semantics of CFS feature terms, defines contexts, and investigates the relation between type and instance concerning the validity of contexts. We want to define contexts such that they describe a certain reading of a (disjunctive) term, i.e. chooses a disjunct for some or all of the disjunctions. We will define validity of a context such that the intended reading has a non-empty denotation.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Contexts and Inheritance", |
| "sec_num": null |
| }, |
| { |
| "text": "The CFS unification algorithm as described in [BSttcher, KSnyves-TSth 92] computes a set of in-vMid contexts for all unification conflicts, which are Mways conflicts between constraints expressed in the feature term (or in types). The purpose of the definition of contexts is to cover all possible conflicts, and to define an appropriate search space for the search procedure described in the last part of this paper. Therefore our definition of contexts differ from those in [DSrre and Eisele, 1990] or [Backofen et al., 1991] . The concrete syntax of CFS is richer than this definition. Variables are allowed to express path equations, and types can be unified destructively. Cyclic path equations (e.g. <> = <gl. \u2022 \u2022gm >) are supported, but recursive type definition and negation are not supported, yet.", |
| "cite_spans": [ |
| { |
| "start": 487, |
| "end": 500, |
| "text": "Eisele, 1990]", |
| "ref_id": null |
| }, |
| { |
| "start": 504, |
| "end": 527, |
| "text": "[Backofen et al., 1991]", |
| "ref_id": "BIBREF0" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Contexts and Inheritance", |
| "sec_num": null |
| }, |
| { |
| "text": "In order to define contexts we define the set of disjunctions of a term, the disjuncts of a disjunction, and deciders as (complete) functions from disjunctions to disjuncts. Mi is a mapping substituting all disjunction names d by i(d), where i is unique for each instantiation. ([tl, ..,tn] ", |
| "cite_spans": [ |
| { |
| "start": 278, |
| "end": 290, |
| "text": "([tl, ..,tn]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Syntax and Semantics of Feature Terms", |
| "sec_num": null |
| }, |
| { |
| "text": "dis : T ~ 2 D, sub : D ~ 2 N, dis(a) := {} dis(<p> --<q>) :-{} dis(f : t) :-dis(t) dis(x~<>i) := dis(Mi(t))lz := t dis", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Syntax and Semantics of Feature Terms", |
| "sec_num": null |
| }, |
| { |
| "text": ") := U.i dis(tj)", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Syntax and Semantics of Feature Terms", |
| "sec_num": null |
| }, |
| { |
| "text": "dis ({tl,..,tn}a) : Figure 6 defines the interpretation [tiC of deciders i c w.r.t, terms t as subsets of some universe U (similar to [Smolka, 1988] , without sorts, but with named disjunctions and instantiations).", |
| "cite_spans": [ |
| { |
| "start": 4, |
| "end": 17, |
| "text": "({tl,..,tn}a)", |
| "ref_id": null |
| }, |
| { |
| "start": 134, |
| "end": 148, |
| "text": "[Smolka, 1988]", |
| "ref_id": "BIBREF5" |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 20, |
| "end": 28, |
| "text": "Figure 6", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Syntax and Semantics of Feature Terms", |
| "sec_num": null |
| }, |
| { |
| "text": "= {d} U Uj dis(tj), sub(d) := {1, ..., n} deciders(t) := {choice: dis(t) -o Nlchoice(d) E sub(d)}", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Syntax and Semantics of Feature Terms", |
| "sec_num": null |
| }, |
| { |
| "text": "g\u00b1, yZ(a = \u00b1, = \u00b1, Similar to deciders we define specializers as partial functions from disjunctions to disjuncts. We also define a partial order _t on specializers of a term:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "a I E U, yz :", |
| "sec_num": null |
| }, |
| { |
| "text": "c1 ~ c~ iff Vdedis(t) (c~ is defined on dA c2(d) = j) ==~ cz(d) = j", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "a I E U, yz :", |
| "sec_num": null |
| }, |
| { |
| "text": "The interpretation function can be extended to specializers now: If c is a specializer of t, then", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "a I E U, yz :", |
| "sec_num": null |
| }, |
| { |
| "text": "A specializer is valid iff it's denotation is not empty.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "\u00a2~6deeiders(t)Ae'-g~\u00a2", |
| "sec_num": null |
| }, |
| { |
| "text": "For the most general specializer, the function cawhich is undefined on each disjunction, we get the interpretation of the term:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "\u00a2~6deeiders(t)Ae'-g~\u00a2", |
| "sec_num": null |
| }, |
| { |
| "text": "It] := [fLy", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "\u00a2~6deeiders(t)Ae'-g~\u00a2", |
| "sec_num": null |
| }, |
| { |
| "text": "Contexts will be objects of computation and representation. They are used in order to record validity for distributed disjunctions. We give our definition first, and a short discussion afterwards.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Contexts", |
| "sec_num": null |
| }, |
| { |
| "text": "For the purpose of explanation we restrict the syntax concerning the composition of disjunctions. We say that a disjunctive subterm {..-}d oft is outwards in t if there is no subterm {.., tj, ..}a, of t with {...}n subterm of tj. We require for each disjunctive subterm {...}a oft and each subterm {..,tj, ..}d' oft: if {...}d is outwards in t i then each subterm {...}a of t is outwards in tj. This relation between d ~ and d we define as subdis (d~,j, d) . Figure 7 shows the definition of contexts.", |
| "cite_spans": [ |
| { |
| "start": 447, |
| "end": 456, |
| "text": "(d~,j, d)", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 459, |
| "end": 467, |
| "text": "Figure 7", |
| "ref_id": "FIGREF6" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Contexts", |
| "sec_num": null |
| }, |
| { |
| "text": "(e is defined on d ^ snbdis ( d', j, d The set of contexts and a bottom element \u00b1 form a lattice (__t, Ct\u00b1). The infimum operator of this lattice we write as At. We drop the index ~ from operators whenever it is clear which term is meant.", |
| "cite_spans": [ |
| { |
| "start": 28, |
| "end": 38, |
| "text": "( d', j, d", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "A specializer c of t is a context of t, iff Vd, d / E dis(t) :", |
| "sec_num": null |
| }, |
| { |
| "text": "Discussion: E.g. for the term", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": ") ) =~(e is defined on d ~ ^ e(d ~) = j)", |
| "sec_num": null |
| }, |
| { |
| "text": "f : t\" t lIt d2 dl", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": ") ) =~(e is defined on d ~ ^ e(d ~) = j)", |
| "sec_num": null |
| }, |
| { |
| "text": "(dl --~ 2, d2 ~ 1) is a specializer but not a context. We exclude such specializers which have more general specializers (dl --~ 2) with the same denotation. For the same term (d2 ~ 1) is not a context. This makes sense due to the fact that there is no constraint expressed in the term required in (d2 ~ 1), but e.g. a at the destination of f is required in (dl --* 1, d2 ~ 1). We will utilize this information about the dependency of disjunctions as it is expressed in our definition of contexts. In order to show what contexts are used for we define the relation is required in (requi) of subterms and contexts of t by the recursive scheme:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": ") ) =~(e is defined on d ~ ^ e(d ~) = j)", |
| "sec_num": null |
| }, |
| { |
| "text": "t requi cT f : t ~ requie =~ t' requic z~<>i requi e A z := t' :\u00a2, Mi(t/) requi c [..,t I, ..] ", |
| "cite_spans": [ |
| { |
| "start": 82, |
| "end": 94, |
| "text": "[..,t I, ..]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": ") ) =~(e is defined on d ~ ^ e(d ~) = j)", |
| "sec_num": null |
| }, |
| { |
| "text": "The contexts in which some subterms of t are required, we call input contexts of t. Each value constraint at the destination of a certain path and each path equation is required in a certain input context. Example: In e a is required in (dl --+ 1) at the destination of f, and e is required in (d2 --+ 2) at the destination of f, and the conflict is in the infimum context (dl --* 1) n (d~ --, 2) = (dl ---, 1, d2 ---, 2). This way each conflict is always in one context, and any context might be a context of a conflict. So the contexts are defined with the necessary differentiation and without superfluous elements.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "c(a/)]", |
| "sec_num": null |
| }, |
| { |
| "text": "We call the contexts of conflicts nogoods. It is not a trivial problem to compute the validity of a term or a context from the set of nogoods in the general case. This will be the topic of the last part (4). Therefore each nogood of t also implies that the corresponding context of the instance term z\u00a9<>i has the empty denotation. It is not necessary to detect the conflicts again. The nogoods can be inherited. (In fact they have to because CFS will never compute a conflict twice.) If the instance is a larger term, the instance usually will be more specific than the type, and there might be conflicts between constraints in the type and constraints in the instance. In this case there are valid contexts of the type with invalid corresponding contexts of the instance. Furthermore the inheritance can occur in the scope of disjunctions of the instance.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "c(a/)]", |
| "sec_num": null |
| }, |
| { |
| "text": "We summarize this by the definition of contezt mapping mi in Figure 8 . ", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 61, |
| "end": 69, |
| "text": "Figure 8", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "c(a/)]", |
| "sec_num": null |
| }, |
| { |
| "text": "z := t, c E contexts(t) t I --..x@<>i.., zQ<>i is required in d E contezts(t') mi : contezts( t ) ~ eontezts( t'), ( i(d)---* c(d) ) mi(c) := d' --.* c'(d')", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "c(a/)]", |
| "sec_num": null |
| }, |
| { |
| "text": "Given a set of nogood contexts, the disjunctions and the subdis-relation of a term, the question is whether the term is valid, i.e. whether it has a non-empty denotation. A nogood context n means that [t]n = {}. The answer to this question in this section will be an algorithm, which in CFS is run after all conflicts are computed, because an incremental version of the algorithm seems to be more expensive. We start with an example in order to show that simple approaches are not effective.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Computing Validity", |
| "sec_num": "4" |
| }, |
| { |
| "text": "{fi it }, { [i it }. { [i (dl --, 1, --, 1), (dl 2, 2), (d2 --+ 1, d3 --* 1), (d2 --* 2, d3 --* 2), (d3 --* 1, dl ---* 1), (d3 \"-~ 2, dl --~ 2)", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Computing Validity", |
| "sec_num": "4" |
| }, |
| { |
| "text": "Figure 9: Term and Nogood Contexts", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Computing Validity", |
| "sec_num": "4" |
| }, |
| { |
| "text": "For the term in Figure 9 the unification algorithm of CFS computes the shown nogoods. The term is invalid because each decider's denotation is empty. A strategy which looks for similar nogoods and tries to replace them by a more general one will fail. This example shows that it is necessary at least in some cases to look at (a covering of) more specific contexts.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 16, |
| "end": 24, |
| "text": "Figure 9", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Computing Validity", |
| "sec_num": "4" |
| }, |
| { |
| "text": "But before we start to describe an algorithm for this purpose we want to explain why the algorithm we describe does a little bit more. It computes all most general invalid contexts from the set of given nogoods. This border of invalid contexts, the computed nogoods, allows us afterwards to test at a low rate whether a context is invalid or not. It is just the test Bn G Computed-Nogoods : c ~_t n. This test is frequently required during inspection of a result and during output. Moreover nogoods are inherited, and if these nogoods are the most general invalid contexts, computations for instances will be reduced.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Computing Validity", |
| "sec_num": "4" |
| }, |
| { |
| "text": "The search procedure for the most general invalid contexts starts from the most general context cv. It descends through the context lattice and modifies the set of nogoods. We give a rough description first and a refinement afterwards:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Computing Validity", |
| "sec_num": "4" |
| }, |
| { |
| "text": "Recursive procedure n-1 1. if 3n E Nogoods : c -4 n then return 'bad'. 5. continue with step 2 selecting a different disjunction.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Computing Validity", |
| "sec_num": "4" |
| }, |
| { |
| "text": "If we replace the fifth step by 5. return 'good'", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Computing Validity", |
| "sec_num": "4" |
| }, |
| { |
| "text": "n-1 will be a test procedure for validity. n-1 is not be very efficient since it visits contexts more than once and since it descends down to most specific contexts even in cases without nogoods. In order to describe the enhancements we write: Cl is relevant for c2, iff cl I-1 c2 ~ .1..", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Computing Validity", |
| "sec_num": "4" |
| }, |
| { |
| "text": "The algorithm implemented for CFS is based on the following ideas: (a) select nogoods relevant for c, return 'good' if there are none (b) specialize c only by disjunctions for which at least some of the relevant nogoods is defined. (c) order the disjunctions, select in this order in the step 2.-4. cycle. (d) prevent multiple visits of contexts by different specialization sequences: if the selected disjunction is lower than some disjunction c is defined on, do not select any disjunction in the recursive calls (do step 1 only). The procedure will be favorably parametrized not only by the context c, but also by the selection of relevant nogoods, which is reduced in each recursive call (because only 'relevant' disjunctions are selected due to enhencement (b)). This makes the procedure stop at depth linear to the number of disjunctions a nogood is defined on. Together with the ordering (c,d) every context which is more general than any nogood is visited once (step 1 visits due to enhencement (d) not counted), because they are candidates for most general nogood contexts. For very few nogoods it might be better to use a different procedure searching 'bottom-up' from the nogoods (as [de Kleer, 1986, second part] proposed for ATMS).", |
| "cite_spans": [ |
| { |
| "start": 1194, |
| "end": 1223, |
| "text": "[de Kleer, 1986, second part]", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Computing Validity", |
| "sec_num": "4" |
| }, |
| { |
| "text": "(a) reduces spreading by recognizing contexts without more specific invalid contexts. (b) might be further restricted in some cases: select only such d with Vj G sub(d) : 3n E relevant-nogoods : n(d) = j.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Computing Validity", |
| "sec_num": "4" |
| }, |
| { |
| "text": "(b) in fact clusters disjunctions into mutually independent sets of disjunctions. This also ignores disjunctions for which there are currently no nogoods thereby reducing the search space exponentially.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Computing Validity", |
| "sec_num": "4" |
| }, |
| { |
| "text": "The algorithm implemented in CFS is also capable of a second task: It computes whether disjunctions are no longer relevant. This is the case if either the context in which the disjunctive term is required is invalid, or the contexts of all but one disjunct is invalid.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Eliminating Irrelevant Disjunctions", |
| "sec_num": null |
| }, |
| { |
| "text": "Why is this an interesting property? There are two reasons: This knowledge reduces the search space of the algorithm computing the border of most general nogoods. And during inheritance neither the disjunction nor the nogoods for such disjunctions need to be inherited. It is most often during inheritance that a disjunction of a type becomes irrelevant in the instance. (Nobody would write down a disjunction which becomes irrelevant in the instance itself.)", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Eliminating Irrelevant Disjunctions", |
| "sec_num": null |
| }, |
| { |
| "text": "Structure-and constraint sharing in CFS makes it necessary to keep this information because contexts of shared constraints in the type are still defined on this disjunction, i.e. the disjunction stays relevant in the type. Let the only valid disjunct of d be k. The information that either the constraint can be ignored (c(d) ~ k) or the disjunction can be ignored (c(d) = k) is stored with the instantiation. The context mapping for the instantiation filters out either the whole context or the disjunction.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Eliminating Irrelevant Disjunctions", |
| "sec_num": null |
| }, |
| { |
| "text": "The algorithm is extended in the following way:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Eliminating Irrelevant Disjunctions", |
| "sec_num": null |
| }, |
| { |
| "text": "4a. if e is an input context of t and d is a disjunction specializing e and the subcontexts are also input contexts, and if all but one specialization delivers 'bad' the disjunction is irrelevant for t. All subdisjunctions of subterms other than the one which is not 'bad' are irrelevant, too.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Eliminating Irrelevant Disjunctions", |
| "sec_num": null |
| }, |
| { |
| "text": "One consequence of the elimination of irrelevant disjunctions during inheritance is, that an efficient implementation of contexts by bitvectors (as proposed in e.g. [ de Kleer, 1986] ) with a simple shift operation for context mappings will waste a lot of space. Either sparse coding of these bit vectors or a difficult compactifying context mapping is required. The sparse coding are just vectors of pairs of disjunction names and choices. Maybe someone finds a good solution to this problem. Nevertheless the context mapping is not consuming much of the resources, and the elimination of irrelevant disjunctions is worth it.", |
| "cite_spans": [ |
| { |
| "start": 167, |
| "end": 182, |
| "text": "de Kleer, 1986]", |
| "ref_id": "BIBREF1" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Consequences", |
| "sec_num": null |
| }, |
| { |
| "text": "For the tasks outlined in the first part, the efficient treatment of disjunctions and inheritance, we introduced contexts. Contexts have been defined on the basis of a set theoretic semantics for CFS feature structures, such that they describe the space of possible unification conflicts adequately. The unification formalism of CFS computes a set of nogood contexts, from which the algorithm outlined in the third part computes the border of most general nogood contexts, which is also important for inspection and output. Clearly we cannot find a polynomial algorithm for an exponential problem (number of possible nogoods), but by elaborated techniques we can reduce the effort exponentially in order to get usable systems in the practical case.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": "5" |
| } |
| ], |
| "back_matter": [], |
| "bib_entries": { |
| "BIBREF0": { |
| "ref_id": "b0", |
| "title": "Non-destructive unification of disjunctive feature structures by constraint sharing", |
| "authors": [ |
| { |
| "first": "[", |
| "middle": [], |
| "last": "References", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Backofen", |
| "suffix": "" |
| } |
| ], |
| "year": 1991, |
| "venue": "Coping with Linguistic Ambiguity in Typed Feature Formalisms, Workshop Notes", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "References [Backofen et al., 1991] R. Backofen, L. Euler, and G. Ghrz. Distributed disjunctions for life. In H. Boley and M. M. Richter, editors, Processing Declarative Knowledge. Springer, Berlin, 1991. [Bhttcher and Khnyves-T6th, 1992] M. Bhttcher and M. Khnyves-Thth. Non-destructive unifica- tion of disjunctive feature structures by constraint sharing. In H. Trost and R. Backofen, editors, Coping with Linguistic Ambiguity in Typed Fea- ture Formalisms, Workshop Notes, Vienna, 1992. ECAI '92.", |
| "links": null |
| }, |
| "BIBREF1": { |
| "ref_id": "b1", |
| "title": "DSrre and Eisele, 1990] J. DSrre and A. Eisele. Feature logic with disjunctive unification", |
| "authors": [ |
| { |
| "first": ";", |
| "middle": [ |
| "J" |
| ], |
| "last": "Kleer", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "De Kleer", |
| "suffix": "" |
| } |
| ], |
| "year": 1986, |
| "venue": "Proceedings of COLING '90", |
| "volume": "28", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Kleer, 1986] J. de Kleer. ATMS. Artificial In- telligence, 28(2), 1986. [DSrre and Eisele, 1990] J. DSrre and A. Eisele. Fea- ture logic with disjunctive unification. In Proceed- ings of COLING '90, Helsinki, 1990.", |
| "links": null |
| }, |
| "BIBREF2": { |
| "ref_id": "b2", |
| "title": "Unification with lazy non-redundant copying", |
| "authors": [ |
| { |
| "first": "; ] M", |
| "middle": [ |
| "C" |
| ], |
| "last": "Emele", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Emele", |
| "suffix": "" |
| } |
| ], |
| "year": 1991, |
| "venue": "Proceedings of the gg'th ACL", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Emele, 1991] M. C. Emele. Unification with lazy non-redundant copying. In Proceedings of the gg'th ACL, Berkeley, 1991.", |
| "links": null |
| }, |
| "BIBREF3": { |
| "ref_id": "b3", |
| "title": "A unification method for disjunctive feature descriptions", |
| "authors": [ |
| { |
| "first": ";", |
| "middle": [ |
| "R" |
| ], |
| "last": "Kasper", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Kasper", |
| "suffix": "" |
| } |
| ], |
| "year": 1987, |
| "venue": "Proceedings of the 25'th ACL", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Kasper, 1987] R. Kasper. A unification method for disjunctive feature descriptions. In Proceedings of the 25'th ACL, Stanford, 1987.", |
| "links": null |
| }, |
| "BIBREF4": { |
| "ref_id": "b4", |
| "title": "Strategic lazy incremental copy graph unification", |
| "authors": [ |
| { |
| "first": "; ] K. Kogure ; J", |
| "middle": [ |
| "T" |
| ], |
| "last": "Kogure", |
| "suffix": "" |
| }, |
| { |
| "first": "R", |
| "middle": [ |
| "M" |
| ], |
| "last": "Maxwell", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Kaplan", |
| "suffix": "" |
| } |
| ], |
| "year": 1990, |
| "venue": "Proceedings of COL-ING '90", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Kogure, 1990] K. Kogure. Strategic lazy incremen- tal copy graph unification. In Proceedings of COL- ING '90, Helsinki, 1990. [Maxwell andKaplan, 1991] J. T. Maxwell and R. M. Kaplan. A method for disjunctive constraint satisfaction. In M. Tomita, editor, Current Issues in Parsing Technology. Kluver Academic Publish- ers, 1991.", |
| "links": null |
| }, |
| "BIBREF5": { |
| "ref_id": "b5", |
| "title": "A feature logic with subsorts", |
| "authors": [ |
| { |
| "first": ";", |
| "middle": [ |
| "G" |
| ], |
| "last": "Smolka", |
| "suffix": "" |
| }, |
| { |
| "first": "", |
| "middle": [], |
| "last": "Smolka", |
| "suffix": "" |
| } |
| ], |
| "year": 1988, |
| "venue": "Lilog Report", |
| "volume": "33", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "Smolka, 1988] G. Smolka. A feature logic with subsorts. Lilog Report 33, IBM Deutschland, Stuttgart, 1988.", |
| "links": null |
| } |
| }, |
| "ref_entries": { |
| "FIGREF0": { |
| "text": "The Type transAs a second example", |
| "type_str": "figure", |
| "uris": null, |
| "num": null |
| }, |
| "FIGREF1": { |
| "text": "Inheritance is used for two purposes: abstraction in the lexicon and non-destructive combination of chart entries\u2022 Figure 3 together with the type trans of Figure 2 shows an example of abstraction: The feature structure of", |
| "type_str": "figure", |
| "uris": null, |
| "num": null |
| }, |
| "FIGREF2": { |
| "text": "Lexicon Entry for spielen", |
| "type_str": "figure", |
| "uris": null, |
| "num": null |
| }, |
| "FIGREF3": { |
| "text": "Chart for Kinder spielen ...", |
| "type_str": "figure", |
| "uris": null, |
| "num": null |
| }, |
| "FIGREF4": { |
| "text": "Let A = {a,...} be a set of atoms, F = {f, fi, gi,...} a set of feature names, D --{d,...} a set of disjunction names, X = {x, y, z,...} a set of type names, I = {i,...} a set of instantiation names. The set of terms T -{t, tl,...} is defined by the recursive scheme inFigure 5. A sequence of type definitions is X := ~1 y := t2 Z := t3 .... The Set of Feature Terms T", |
| "type_str": "figure", |
| "uris": null, |
| "num": null |
| }, |
| "FIGREF5": { |
| "text": "fn > = <gl-..qm>]e:----{S e Ulf (..ft (s", |
| "type_str": "figure", |
| "uris": null, |
| "num": null |
| }, |
| "FIGREF6": { |
| "text": "Definition of Contexts", |
| "type_str": "figure", |
| "uris": null, |
| "num": null |
| }, |
| "FIGREF7": { |
| "text": "If z := t is a type, and x is inherited to some term x\u00a9<>i then for each context c of z there is a corresponding context d of z\u00a9<>i with the same denotation.[z\u00a9<>i]c, = [Mi(t)]c, = [tic c' : dis(M~(t) ~ N, c'(i(d)) = c(d)", |
| "type_str": "figure", |
| "uris": null, |
| "num": null |
| }, |
| "FIGREF8": { |
| "text": "Figure 8: Context Mappings", |
| "type_str": "figure", |
| "uris": null, |
| "num": null |
| }, |
| "FIGREF9": { |
| "text": "2. select a disjunction d with c undefined on d and such that the specializer (d -* j, d ~ --~ c(d~)) is a context, if no such disjunction exists, return 'good'. 3. for each j E sub(d) recursively call n-1 with (d --+ j, d ~ -.+ c( d~) ). 4. if each call returns 'bad', then replace all n E Nogoods : n ~_ c by c and return 'bad'.", |
| "type_str": "figure", |
| "uris": null, |
| "num": null |
| } |
| } |
| } |
| } |
