| { |
| "paper_id": "P02-1009", |
| "header": { |
| "generated_with": "S2ORC 1.0.0", |
| "date_generated": "2023-01-19T09:30:54.247385Z" |
| }, |
| "title": "Generalized Encoding of Description Spaces and its Application to Typed Feature Structures", |
| "authors": [ |
| { |
| "first": "Gerald", |
| "middle": [], |
| "last": "Penn", |
| "suffix": "", |
| "affiliation": { |
| "laboratory": "", |
| "institution": "University of Toronto 10 King's College Rd", |
| "location": { |
| "postCode": "M5S 3G4", |
| "settlement": "Toronto", |
| "country": "Canada" |
| } |
| }, |
| "email": "" |
| } |
| ], |
| "year": "", |
| "venue": null, |
| "identifiers": {}, |
| "abstract": "This paper presents a new formalization of a unification-or join-preserving encoding of partially ordered sets that more essentially captures what it means for an encoding to preserve joins, generalizing the standard definition in AI research. It then shows that every statically typable ontology in the logic of typed feature structures can be encoded in a data structure of fixed size without the need for resizing or additional union-find operations. This is important for any grammar implementation or development system based on typed feature structures, as it significantly reduces the overhead of memory management and reference-pointer-chasing during unification.", |
| "pdf_parse": { |
| "paper_id": "P02-1009", |
| "_pdf_hash": "", |
| "abstract": [ |
| { |
| "text": "This paper presents a new formalization of a unification-or join-preserving encoding of partially ordered sets that more essentially captures what it means for an encoding to preserve joins, generalizing the standard definition in AI research. It then shows that every statically typable ontology in the logic of typed feature structures can be encoded in a data structure of fixed size without the need for resizing or additional union-find operations. This is important for any grammar implementation or development system based on typed feature structures, as it significantly reduces the overhead of memory management and reference-pointer-chasing during unification.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstract", |
| "sec_num": null |
| } |
| ], |
| "body_text": [ |
| { |
| "text": "The logic of typed feature structures (Carpenter, 1992) has been widely used as a means of formalizing and developing natural language grammars that support computationally efficient parsing, generation and SLD resolution, notably grammars within the Head-driven Phrase Structure Grammar (HPSG) framework, as evidenced by the recent successful development of the LinGO reference grammar for English (LinGO, 1999) . These grammars are formulated over a finite vocabulary of features and partially ordered types, in respect of constraints called appropriateness conditions. Appropriateness specifies, for each type, all and only the features that take values in feature structures of that type, along with the types of values (value restrictions) those feature values must have. In Figure 1 , 1 for example, all head-typed TFSs must have bool-typed values for the features MOD and PRD, and no values for any other feature. Relative to data structures like arrays or logical terms, typed feature structures (TFSs) can be regarded as an expressive refinement in two different ways. First, they are typed, and the type system allows for subtyping chains of unbounded depth. Figure 1 has a chain of length \u00a1 from to noun. Pointers to arrays and logical terms can only monotonically \"refine\" their (syntactic) type from unbound (for logical terms, variables) to bound. Second, although all the TFSs of a given type have the same features because of appropriateness, a TFS may acquire more features when it promotes to a subtype. If a head-typed TFS promotes to noun in the type system above, for example, it acquires one extra casevalued feature, CASE. When a subtype has two or 1 In this paper, Carpenter's (1992) convention of using \u00a2 as the most general type, and depicting subtypes above their supertypes is used. more incomparable supertypes, a TFS can also multiply inherit features from other supertypes when it promotes.", |
| "cite_spans": [ |
| { |
| "start": 38, |
| "end": 55, |
| "text": "(Carpenter, 1992)", |
| "ref_id": "BIBREF2" |
| }, |
| { |
| "start": 399, |
| "end": 412, |
| "text": "(LinGO, 1999)", |
| "ref_id": "BIBREF5" |
| }, |
| { |
| "start": 1672, |
| "end": 1673, |
| "text": "1", |
| "ref_id": null |
| }, |
| { |
| "start": 1689, |
| "end": 1707, |
| "text": "Carpenter's (1992)", |
| "ref_id": "BIBREF2" |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 780, |
| "end": 788, |
| "text": "Figure 1", |
| "ref_id": null |
| }, |
| { |
| "start": 1169, |
| "end": 1175, |
| "text": "Figure", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Motivation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "The overwhelmingly most prevalent operation when working with TFS-based grammars is unification, which corresponds mathematically to finding a least upper bound or join. The most common instance of unification is the special case in which a TFS is unified with the most general TFS that satisfies a description stated in the grammar. This special case can be decomposed at compile-time into more atomic operations that (1) promote a type to a subtype, (2) bind a variable, or (3) traverse a feature path, according to the structure of the description.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Motivation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "TFSs actually possess most of the properties of fixed-arity terms when it comes to unification, due to appropriateness. Nevertheless, unbounded subtyping chains and acquiring new features conspire to force most internal representations of TFSs to perform extra work when promoting a type to a subtype to earn the expressive power they confer. Upon being repeatedly promoted to new subtypes, they must be repeatedly resized or repeatedly referenced with a pointer to newly allocated representations, both of which compromise locality of reference in memory and/or involve pointer-chasing. These costs are significant.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Motivation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "Because appropriateness involves value restrictions, simply padding a representation with some extra space for future features at the outset must guarantee a proper means of filling that extra space with the right value when it is used. Internal representations that lazily fill in structure must also be wary of the common practice in description languages of binding a variable to a feature value with a scope larger than a single TFS -for example, in sharing structure between a daughter category and a mother category in a phrase structure rule. In this case, the representation of a feature's value must also be interpretable independent of its context, because two separate TFSs may refer to that variable.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Motivation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "These problems are artifacts of not using a representation which possesses what in knowledge representation is known as a join-preserving encoding of a grammar's TFSs -in other words, a representation with an operation that naturally behaves like TFS-unification. The next section presents the standard definition of join-preserving encodings and provides a generalization that more essentially captures what it means for an encoding to preserve joins. Section 3 formalizes some of the defining characteristics of TFSs as they are used in computational linguistics. Section 4 shows that these characteristics quite fortuitously agree with what is required to guarantee the existence of a joinpreserving encoding of TFSs that needs no resizing or extra referencing during type promotion. Section 5 then shows that a generalized encoding exists in which variable-binding scope can be larger than a single TFS -a property no classical encoding has.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Motivation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "Earlier work on graph unification has focussed on labelled graphs with no appropriateness, so the central concern was simply to minimize structure copying. While this is clearly germane to TFSs, appropriateness creates a tradeoff among copying, the potential for more compact representations, and other memory management issues such as locality of reference that can only be optimized empirically and relative to a given grammar and corpus (a recent example of which can be found in Callmeier (2001) ). While the present work is a more theoretical consideration of how unification in one domain can simulate unification in another, the data structure described here is very much motivated by the encoding of TFSs as Prolog terms allocated on a contiguous WAM-style heap. In that context, the emphasis on fixed arity is really an attempt to avoid copying, and lazily filling in structure is an attempt to make encodings compact, but only to the extent that join preservation is not disturbed. While this compromise solution must eventually be tested on larger and more diverse grammars, it has been shown to reduce the total parsing time of a large corpus on the ALE HPSG benchmark grammar of English (Penn, 1993) by a factor of about 4 (Penn, 1999) .", |
| "cite_spans": [ |
| { |
| "start": 483, |
| "end": 499, |
| "text": "Callmeier (2001)", |
| "ref_id": "BIBREF1" |
| }, |
| { |
| "start": 1200, |
| "end": 1212, |
| "text": "(Penn, 1993)", |
| "ref_id": "BIBREF8" |
| }, |
| { |
| "start": 1236, |
| "end": 1248, |
| "text": "(Penn, 1999)", |
| "ref_id": "BIBREF9" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Motivation", |
| "sec_num": "1" |
| }, |
| { |
| "text": "We may begin with a familiar definition from discrete mathematics:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Join-Preserving Encodings", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Definition 1 Given two partial orders \u00a2 \u00a1 \u00a4 \u00a3 \u00a6 \u00a5 \u00a7 \u00a9 and \u00a2 \u00a3 \u00a6 \u00a5 \u00a9 , a function \u00a1 \" !", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Join-Preserving Encodings", |
| "sec_num": "2" |
| }, |
| { |
| "text": "is an orderembedding iff, for every", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Join-Preserving Encodings", |
| "sec_num": "2" |
| }, |
| { |
| "text": "# $ \u00a3 & % ( ' \u00a1 , # ) \u00a5 0 \u00a7 1 % iff 2 3 # 5 4 6 \u00a5 7 8 2 3 % 9 4 .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Join-Preserving Encodings", |
| "sec_num": "2" |
| }, |
| { |
| "text": "An order-embedding preserves the behavior of the order relation (for TFS type systems, subtyping; f Figure 2 : An example order-embedding that cannot translate least upper bounds.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 100, |
| "end": 108, |
| "text": "Figure 2", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Join-Preserving Encodings", |
| "sec_num": "2" |
| }, |
| { |
| "text": "for TFSs themselves, subsumption) in the encoding codomain. As shown in Figure 2 , however, order embeddings do not always preserve operations such as least upper bounds. The reason is that the image of may not be closed under those operations in the codomain. In fact, the codomain could provide joins where none were supposed to exist, or, as in Figure 2 , no joins where one was supposed to exist. Mellish (1991; was the first to formulate join-preserving encodings correctly, by explicitly requiring this preservation. Let us write", |
| "cite_spans": [ |
| { |
| "start": 401, |
| "end": 415, |
| "text": "Mellish (1991;", |
| "ref_id": "BIBREF6" |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 72, |
| "end": 80, |
| "text": "Figure 2", |
| "ref_id": null |
| }, |
| { |
| "start": 348, |
| "end": 356, |
| "text": "Figure 2", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Join-Preserving Encodings", |
| "sec_num": "2" |
| }, |
| { |
| "text": "\u00a2 \u00a1 \u00a7 \u00a4 \u00a3 for the join of and \u00a3 in partial order \u00a1 . Definition 2 A partial order \u00a2 \u00a1 \u00a4 \u00a3 \u00a6 \u00a5 7 \u00a9", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Join-Preserving Encodings", |
| "sec_num": "2" |
| }, |
| { |
| "text": "is bounded complete (BCPO) iff every set of elements with a common upper bound has a least upper bound.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Join-Preserving Encodings", |
| "sec_num": "2" |
| }, |
| { |
| "text": "Bounded completeness ensures that unification or joins are well-defined among consistent types. ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Join-Preserving Encodings", |
| "sec_num": "2" |
| }, |
| { |
| "text": "\u00a5 injectivity is an injection, \u00a5 zero preservation 2 \u00a6 \u00a7 \u00a1 \u00a7 \u00a3 4 \u00a9 2 iff 2 \u00a6 5 4 \u00a1 2 \u00a3 4 \u00a9 , and \u00a5 join homomorphism 2 \u00a6 \u00a1 \u00a7 \u00a3 4 1 2 \u00a6 4 \u00a1 2 \u00a3 4", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Definition 3 Given two BCPOs,", |
| "sec_num": null |
| }, |
| { |
| "text": ", where they exist.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Definition 3 Given two BCPOs,", |
| "sec_num": null |
| }, |
| { |
| "text": "Join-preserving encodings are automatically orderembeddings because", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Definition 3 Given two BCPOs,", |
| "sec_num": null |
| }, |
| { |
| "text": "\u00a4 \u00a1 \u00a3 \u00a2 \u00a3 iff 8 \u00a5 \u00a3", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Definition 3 Given two BCPOs,", |
| "sec_num": null |
| }, |
| { |
| "text": ". There is actually a more general definition:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Definition 3 Given two BCPOs,", |
| "sec_num": null |
| }, |
| { |
| "text": "Definition 4 Given two BCPOs, \u00a1 and , \u00a1 ! \" ! $ # 2 \u00a2 4 is a (generalized) join-preserving encoding of \u00a1 into iff: \u00a5 totality for all ' \u00a1 , 2 \u00a6 5 4 & % ( ' , \u00a5 disjointness 2 \u00a6 4 0 ) 2 \u00a3 4 & % ( ' iff 1 \u00a3 , 2", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Definition 3 Given two BCPOs,", |
| "sec_num": null |
| }, |
| { |
| "text": "We use the notation 2 4 3 6 5 7 9 8 A @ ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Definition 3 Given two BCPOs,", |
| "sec_num": null |
| }, |
| { |
| "text": "\u00a3 4 , T \u00a1 \u00a7 U \u00a3 V \u00a9 iff S T \u00a1 S \u00a3 V \u00a9", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Definition 3 Given two BCPOs,", |
| "sec_num": null |
| }, |
| { |
| "text": ", and", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Definition 3 Given two BCPOs,", |
| "sec_num": null |
| }, |
| { |
| "text": "\u00a5 join homomorphism for all S ' 2 \u00a6 5 4 and S \u00a3 ' 2 \u00a3 4 , S T \u00a1 S \u00a3 ' 2 \u00a6 \u00a4 \u00a1 \u00a7 1 \u00a3 4", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Definition 3 Given two BCPOs,", |
| "sec_num": null |
| }, |
| { |
| "text": ", where they exist. Although space does not permit here, this generalization has been used to prove that well-typing, an alternative interpretation of appropriateness, is equivalent in its expressive power to the interpretation used here (called total well-typing; Carpenter, 1992) ; that multi-dimensional inheritance (Erbach, 1994) adds no expressive power to any TFS type system; that TFS type systems can encode systemic networks in polynomial space using extensional types (Carpenter, 1992) ; and that certain uses of paramet-ric typing with TFSs also add no expressive power to the type system (Penn, 2000) .", |
| "cite_spans": [ |
| { |
| "start": 265, |
| "end": 281, |
| "text": "Carpenter, 1992)", |
| "ref_id": "BIBREF2" |
| }, |
| { |
| "start": 319, |
| "end": 333, |
| "text": "(Erbach, 1994)", |
| "ref_id": "BIBREF3" |
| }, |
| { |
| "start": 478, |
| "end": 495, |
| "text": "(Carpenter, 1992)", |
| "ref_id": "BIBREF2" |
| }, |
| { |
| "start": 600, |
| "end": 612, |
| "text": "(Penn, 2000)", |
| "ref_id": "BIBREF10" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Definition 3 Given two BCPOs,", |
| "sec_num": null |
| }, |
| { |
| "text": "There are only a few common-sense restrictions we need to place on our type systems: ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "TFS Type Systems", |
| "sec_num": "3" |
| }, |
| { |
| "text": "Definition 5 A TFS", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "TFS Type Systems", |
| "sec_num": "3" |
| }, |
| { |
| "text": "\u00a2 \u00a1 \u00a3 \u00a1 \u00a5 \u00a4! \u00a6 \u00a1 2 F \u00a3 \u00a6 ! \u00a6 \" $ # \u00a4! 5 2 F 4 & 4 & %", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "TFS Type Systems", |
| "sec_num": "3" |
| }, |
| { |
| "text": ", and for all", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "TFS Type Systems", |
| "sec_num": "3" |
| }, |
| { |
| "text": "' ' , if ( \u00a1 ) \u00a1 \u00a5 \u00a4! 0 \u00a1 2 F \u00a3 1 '4 & % , then ! \u00a6 \" $ # \u00a4! 2 F4 \u00a5 2 '", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "TFS Type Systems", |
| "sec_num": "3" |
| }, |
| { |
| "text": ", and", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "TFS Type Systems", |
| "sec_num": "3" |
| }, |
| { |
| "text": "\u00a5 (Upward Closure / Right Monotonicity) if \u00a2 \u00a1 \u00a3 \u00a1 \u00a5 \u00a4! \u00a6 \u00a1 2 F \u00a3 3 4 & % and 3 \u00a5 4 ' , then ( \u00a1 ) \u00a1 \u00a5 \u00a4! 0 \u00a1 2 F \u00a3 1 '4 & % and ( \u00a1 ) \u00a1 \u00a5 \u00a4! 0 \u00a1 2 F \u00a3 3 4 \u00a5 5 \u00a2 \u00a1 \u00a3 \u00a1 \u00a5 \u00a4! \u00a6 \u00a1 2 F \u00a3 1 '4 .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "TFS Type Systems", |
| "sec_num": "3" |
| }, |
| { |
| "text": "The function Approp maps a feature and type to the value restriction on that feature when it is appropriate to that type. If it is not appropriate, then Approp is undefined at that pair. Feature introduction ensures that every feature has a least type to which it is appropriate. This makes description compilation more efficient. Upward closure ensures that subtypes inherit their supertypes' features, and with consistent value restrictions. The combination of these two properties allows us to annotate a BCPO of types with features and value restrictions only where the feature is introduced or the value restriction is refined, as in Figure 1 . A very useful property for type systems to have is static typability. This means that if two TFSs that are well-formed according to appropriateness are unifiable, then their unification is automatically well-formed as well -no additional work is necessary.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 639, |
| "end": 647, |
| "text": "Figure 1", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "TFS Type Systems", |
| "sec_num": "3" |
| }, |
| { |
| "text": "Theorem 1 (Carpenter, 1992) An appropriateness specification is statically typable iff, for all types", |
| "cite_spans": [ |
| { |
| "start": 10, |
| "end": 27, |
| "text": "(Carpenter, 1992)", |
| "ref_id": "BIBREF2" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "TFS Type Systems", |
| "sec_num": "3" |
| }, |
| { |
| "text": "3 \u00a3 1 ' such that 3 \u00a1 6 ' 7 %", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "TFS Type Systems", |
| "sec_num": "3" |
| }, |
| { |
| "text": ", and Not all type systems are statically typable, but a type system can be transformed into an equivalent statically typable type system plus a set of universal constraints, the proof of which is omitted here. In linguistic applications, we normally have a set of universal constraints anyway for encoding principles of grammar, so it is easy and computationally inexpensive to conduct this transformation.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "TFS Type Systems", |
| "sec_num": "3" |
| }, |
| { |
| "text": "all F ' 8 \u00a7 \u00a9 : \u00a2 \u00a1 \u00a3 \u00a1 \u00a5 \u00a4! \u00a6 \u00a1 2 F \u00a3 3 \u00a1 9 ' & 4 @ A A A A B A A A A C ( \u00a1 \u00a3 \u00a1 D \u00a4! \u00a6 \u00a1 2 F \u00a3 3 4 \u00a1 if \u00a2 \u00a1 \u00a3 \u00a1 \u00a5 \u00a4! \u00a6 \u00a1 2 F \u00a3 3 4 & % and ( \u00a1 ) \u00a1 \u00a5 \u00a4! 0 \u00a1 2 F \u00a3 1 '4 ( \u00a1 ) \u00a1 \u00a5 \u00a4! 0 \u00a1 2 F \u00a3 1 ' & 4 & % ( \u00a1 \u00a3 \u00a1 D \u00a4! \u00a6 \u00a1 2 F \u00a3 3 4 if only ( \u00a1 \u00a3 \u00a1 D \u00a4! \u00a6 \u00a1 2 F \u00a3 3 4 & % ( \u00a1 \u00a3 \u00a1 D \u00a4! \u00a6 \u00a1 2 F \u00a3 1 '4 if only ( \u00a1 \u00a3 \u00a1 D \u00a4! \u00a6 \u00a1 2 F \u00a3 1 '4 & % unrestricted otherwise E E (head representation) E \" ! (MOD representation) \" ! (PRD representation) ! G F", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "TFS Type Systems", |
| "sec_num": "3" |
| }, |
| { |
| "text": "As mentioned in Section 1, what we want is an encoding of TFSs with a notion of unification that naturally corresponds to TFS-unification. As discussed in Section 3, static typability is something we can reasonably guarantee in our type systems, and is therefore something we expect to be reflected in our encodings -no extra work should be done apart from combining the types and recursing on feature values. If we can ensure this, then we have avoided the extra work that comes with resizing or unnecessary referencing and pointer-chasing. As mentioned above, what would be best from the standpoint of memory management is simply a fixed array of memory cells, padded with extra space to accommodate features that might later be added. We will call these frames. Figure 4 depicts a frame for the head-typed TFS in Figure 5 . In a frame, the representation of the type can either be (1) a bit vector encoding the type, 3 or (2) a reference pointer to another frame. If backtracking is supported in search, changes to the type representation must be trailed. For each appropriate feature, there is also a pointer to a frame for that feature's value. There are also additional pointers for future features (for head, CASE) that are grounded to some distinguished value indicating that they are unused -usually a circular reference to the referring array position. Cyclic TFSs, if they are supported, would be represented with cyclic (but not 1-cyclic) chains of pointers.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 765, |
| "end": 773, |
| "text": "Figure 4", |
| "ref_id": null |
| }, |
| { |
| "start": 816, |
| "end": 824, |
| "text": "Figure 5", |
| "ref_id": "FIGREF4" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Static Encodability", |
| "sec_num": "4" |
| }, |
| { |
| "text": "Frames can be implemented either directly as arrays, or as Prolog terms. In Prolog, the type representation could either be a term-encoding of the type, which is guaranteed to exist for any finite BCPO (Mellish, 1991; Mellish, 1992) , or in extended Prologs, another trailable representation such as a mutable term (Aggoun and Beldiceanu, 1990) or an attributed value (Holzbaur, 1992) . Padding the representation with extra space means using a Prolog term with extra arity. A distinguished value for unused arguments must then be a unique unbound variable. 4", |
| "cite_spans": [ |
| { |
| "start": 202, |
| "end": 217, |
| "text": "(Mellish, 1991;", |
| "ref_id": "BIBREF6" |
| }, |
| { |
| "start": 218, |
| "end": 232, |
| "text": "Mellish, 1992)", |
| "ref_id": "BIBREF7" |
| }, |
| { |
| "start": 315, |
| "end": 344, |
| "text": "(Aggoun and Beldiceanu, 1990)", |
| "ref_id": "BIBREF0" |
| }, |
| { |
| "start": 368, |
| "end": 384, |
| "text": "(Holzbaur, 1992)", |
| "ref_id": "BIBREF4" |
| } |
| ], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Static Encodability", |
| "sec_num": "4" |
| }, |
| { |
| "text": "At first blush, the prospect of adding as many extra slots to a frame as there could be extra features in a TFS sounds hopelessly unscalable to large grammars. While recent experience with LinGO (1999) suggests a trend towards modest increases in numbers of features compared to massive increases in numbers of types as grammars grow large, this is nevertheless an important issue to address. There are two discrete methods that can be used in combination to reduce the required number of extra slots:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Restricting the Size of Frames", |
| "sec_num": "4.1" |
| }, |
| { |
| "text": "Definition 6 Given a finite BCPO,", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Restricting the Size of Frames", |
| "sec_num": "4.1" |
| }, |
| { |
| "text": "\u00a2 \u00a1 \u00a4 \u00a3 \u00a6 \u00a5 0 \u00a9 , the set of modules of \u00a2 \u00a1 \u00a4 \u00a3 \u00a6 \u00a5 7 \u00a9", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Restricting the Size of Frames", |
| "sec_num": "4.1" |
| }, |
| { |
| "text": "is the finest partition of", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Restricting the Size of Frames", |
| "sec_num": "4.1" |
| }, |
| { |
| "text": "\u00a1 \u00a1 \u00a3 \u00a2 \u00a1 \u00a4 , \u00a5 \u00a7 \u00a6 \u00a3 \u00a9 \u00a9 \u00a9 \u00a5 , such that (1) each \u00a5", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Restricting the Size of Frames", |
| "sec_num": "4.1" |
| }, |
| { |
| "text": "is upward-closed (with respect to subtyping), and (2) if two types have a least upper bound, then they belong to the same module.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Restricting the Size of Frames", |
| "sec_num": "4.1" |
| }, |
| { |
| "text": "Trivially, if a feature is introduced at a type in one module, then it is not appropriate to any type in any other module. As a result, a frame for a TFS only needs to allow for the features appropriate to the 4 Prolog terms require one additional unbound variable per TFS (sub)term in order to preserve the intensionality of the logic -unlike Prolog terms, structurally identical TFS substructures are not identical unless explicitly structure-shared. There are type systems, of course, for which modularization and graph-coloring will not help. Figure 6, for example, has one module, three features, and a three-clique for a feature graph. There are statistical refinements that one could additionally make, such as determining the empirical probability that a particular feature will be acquired and electing to pay the cost of resizing or referencing for improbable features in exchange for smaller frames.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 547, |
| "end": 553, |
| "text": "Figure", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Restricting the Size of Frames", |
| "sec_num": "4.1" |
| }, |
| { |
| "text": "With the exception of extra slots for unused feature values, frames are clearly isomorphic in their structure to the TFSs they represent. The implementation of unification that we prefer to avoid resizing and referencing is to (1) find the least upper bound of the types of the frames being unified, (2) update one frame's type to the least upper bound, and point the other's type representation to it, and (3) recurse on respective pairs of feature values. The frame does not need to be resized, only the types need to be referenced, and in the special case of promoting the type of a single TFS to a subtype, the type only needs to be trailed. If cyclic TFSs are not supported, then acyclicity must also be enforced with an occurscheck.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": "The correctness of frames as a join-preserving encoding of TFSs thus depends on being able to make sense of the values in these unused positions. The problem is that features may be introduced at joinreducible types, as in Figure 7 . There is only one module, so the frames for a and b must have a slot available for the feature F. When an a-typed TFS unifies with a b-typed TFS, the result will be of type c, so leaving the slot marked unused after recursion would be incorrect -we would need to look in a table to see what value to assign it. An alternative would be to place that value in the frames for a and b from the beginning. But since the value itself must be of type a in the case of Figure 7 , this strategy would not yield a finite representation. The answer to this conundrum is to use a distinguished circular reference in a slot iff the slot is either unused or the value it contains is (1) the most general satisfier of the value restriction of the feature it represents and (2) not structure-shared with any other feature in the TFS. 5 During unification, if one TFS is a circular reference, and the other is not, the circular reference is referenced to the other. If both values are circular references, then one is referenced to the other, which remains circular. The feature structure in Figure 8 , for example, has the frame representation shown in Figure 9 . The PRD value is a TFS of type bool, and this value is not shared with any other structure in the TFS. If the values of MOD and PRD are both bool-typed, then if 5 The sole exception is a TFS of type \u00a2 , which by definition belongs to no module and has no features. Its representation is a distinguished circular reference, unless two or more feature values share a single \u00a2 -typed TFS value, in which case one is a circular reference and the rest point to it. The circular one can be chosen canonically to ensure that the encoding is still classical. (Figure 11) , and if they are not shared (Figure 12 ), both of them use a different circular reference ( Figure 13 ).", |
| "cite_spans": [ |
| { |
| "start": 1543, |
| "end": 1544, |
| "text": "5", |
| "ref_id": null |
| } |
| ], |
| "ref_spans": [ |
| { |
| "start": 223, |
| "end": 231, |
| "text": "Figure 7", |
| "ref_id": null |
| }, |
| { |
| "start": 695, |
| "end": 703, |
| "text": "Figure 7", |
| "ref_id": null |
| }, |
| { |
| "start": 1309, |
| "end": 1317, |
| "text": "Figure 8", |
| "ref_id": "FIGREF6" |
| }, |
| { |
| "start": 1371, |
| "end": 1379, |
| "text": "Figure 9", |
| "ref_id": null |
| }, |
| { |
| "start": 1933, |
| "end": 1944, |
| "text": "(Figure 11)", |
| "ref_id": null |
| }, |
| { |
| "start": 1974, |
| "end": 1984, |
| "text": "(Figure 12", |
| "ref_id": null |
| }, |
| { |
| "start": 2038, |
| "end": 2047, |
| "text": "Figure 13", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": "E E (head representation) E \" ! (MOD representation) ! G F ! G F", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": "With this convention for circular references, frames are a classical join-preserving encoding of the TFSs of any statically typable type system. Although space does not permit a complete proof here, the intuition is that (1) most general satisfiers of value restrictions necessarily subsume every other value that a totally well-typed TFS could take at that feature, and (2) when features are introduced, their initial values are not structure-shared with any other substructure. Static typability ensures that value restrictions unify to yield value restrictions, except in the final case of Theorem 1. The following lemma deals with this case:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": "Lemma 1 If Approp is statically typable, 3 \u00a1 2 ' 7 %", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": ", and for some F ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": "' \u00a7 \u00a9 \u00a3 , \u00a2 \u00a1 \u00a3 \u00a1 \u00a5 \u00a4! \u00a6 \u00a1 2 F \u00a3 3 4 \u00a9 and \u00a2 \u00a1 \u00a3 \u00a1 \u00a5 \u00a4! \u00a6 \u00a1 2 F \u00a3 1 ' & 4 \u00a9 , then either ( \u00a1 ) \u00a1 \u00a5 \u00a4! 0 \u00a1 2 F \u00a3 3 \u00a1 ' & 4 \u00a9 or E E (head representation) E \" ! (MOD/PRD representation) - ! G F", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": "\u00a2 \u00a1 \u00a3 \u00a1 \u00a5 \u00a4! \u00a6 \u00a1 2 F \u00a3 3 \u00a1 6 '4 G \u00a2 \u00a1 \u00a3 \u00a1 \u00a5 \u00a4! \u00a6 \u00a1 2 F \u00a3 \u00a6 ! \u00a6 \" $ # \u00a4! 2 F 4 & 4 . Proof: Suppose ( \u00a1 ) \u00a1 \u00a5 \u00a4! 0 \u00a1 2 F \u00a3 3 \u00a1 '4 & % . Then ! \u00a6 \" $ # \u00a4! 2 F 4 \u00a5 3 \u00a1 6 ' . ( \u00a1 ) \u00a1 \u00a5 \u00a4! 0 \u00a1 2 F \u00a3 3 4 \u00a9 and \u00a2 \u00a1 \u00a3 \u00a1 \u00a5 \u00a4! \u00a6 \u00a1 2 F \u00a3 1 ' & 4 \u00a9 , so ! \u00a6 \" $ # \u00a4! 2 F 4 1 % \u00a5 3 and ! \u00a6 \" $ # \u00a4! 2 F 4 U % \u00a5 '", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": ". So there are three cases to consider:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": "Intro2 F 4 \u00a1 \u00a1 \u00a2", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": ": then the result trivially holds. ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": "3 \u00a1 ! \u00a6 \" $ # \u00a4! 2 F 4 & % and 3 U \u00a1 ! \u00a6 \" $ # \u00a4! 2 F 4 \u00a5 3 \u00a1 2 '", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": ". By upward closure,", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": "\u00a2 \u00a1 \u00a3 \u00a1 \u00a5 \u00a4! \u00a6 \u00a1 2 F \u00a3 \u00a6 ! \u00a6 \" $ # \u00a4! 5 2 F4 \u00a1 3 4 & %", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": "and by static typability,", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": "\u00a2 \u00a1 \u00a3 \u00a1 \u00a5 \u00a4! \u00a6 \u00a1 2 F \u00a3 \u00a6 ! \u00a6 \" $ # \u00a4! 5 2 F4 \" \u00a1 3 4 \u00a2 \u00a1 \u00a3 \u00a1 \u00a5 \u00a4! \u00a6 \u00a1 2 F \u00a3 \u00a6 ! \u00a6 \" $ # \u00a4! 2 F 4 & 4 . Furthermore, 2 ! \u00a6 \" $ # \u00a4! 2 F 4 \u00a1 3 4 \u00a1 ' U 3 \u00a1 '", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": "; thus by static typability the lemma holds.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Correctness of Frames", |
| "sec_num": "4.2" |
| }, |
| { |
| "text": "This lemma is very significant in its own rightit says that we know more than Carpenter's Theorem 1. An introduced feature's value restriction can always be predicted in a statically typable type system. The lemma implicitly relies on feature intro-", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "\u00a3", |
| "sec_num": null |
| }, |
| { |
| "text": "3 \u00a1 6 ' ! \u00a6 \" \u00a5 # \u00a4! 5 2 F4", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "\u00a3", |
| "sec_num": null |
| }, |
| { |
| "text": "3 ' Figure 14 : The second case in the proof of Lemma 1.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 4, |
| "end": 13, |
| "text": "Figure 14", |
| "ref_id": null |
| } |
| ], |
| "eq_spans": [], |
| "section": "\u00a3", |
| "sec_num": null |
| }, |
| { |
| "text": "F:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "\u00a1 6 '", |
| "sec_num": "3" |
| }, |
| { |
| "text": "I 3 F: G ' F:", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "\u00a1 6 '", |
| "sec_num": "3" |
| }, |
| { |
| "text": "H D I G H Figure 15 : A statically typable \"type system\" that multiply introduces F at join-reducible elements with different value restrictions.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 10, |
| "end": 19, |
| "text": "Figure 15", |
| "ref_id": "FIGREF4" |
| } |
| ], |
| "eq_spans": [], |
| "section": "\u00a1 6 '", |
| "sec_num": "3" |
| }, |
| { |
| "text": "duction, but in fact, the result holds if we allow for multiple introducing types, provided that all of them agree on what the value restriction for the feature should be. Would-be type systems that multiply introduce a feature at join-reducible elements (thus requiring some kind of distinguished-value encoding), disagree on the value restriction, and still remain statically typable are rather difficult to come by, but they do exist, and for them, a frame encoding will not work. Figure 15 shows one such example. In this signature, the unification:", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 484, |
| "end": 493, |
| "text": "Figure 15", |
| "ref_id": "FIGREF4" |
| } |
| ], |
| "eq_spans": [], |
| "section": "\u00a1 6 '", |
| "sec_num": "3" |
| }, |
| { |
| "text": "\u00a4 s F d\u00a5 \u00a1 \u00a4 t F b\u00a5 \u00a9", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "\u00a1 6 '", |
| "sec_num": "3" |
| }, |
| { |
| "text": "does not exist, but the unification of their frame encodings must succeed because the ' -typed TFS's F value must be encoded as a circular reference. To the best of the author's knowledge, there is no fixedsize encoding for Figure 15 .", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 224, |
| "end": 233, |
| "text": "Figure 15", |
| "ref_id": "FIGREF4" |
| } |
| ], |
| "eq_spans": [], |
| "section": "\u00a1 6 '", |
| "sec_num": "3" |
| }, |
| { |
| "text": "In practice, this classical encoding is not good for much. Description languages typically need to bind variables to various substructures of a TFS, , and then pass those variables outside the substructures of where they can be used to instantiate the value of another feature structure's feature, or as arguments to some function call or procedural goal. If a value in a single frame is a circular reference, we can properly understand what that reference encodes with the above convention by looking at its context, i.e., the type. Outside the scope of that frame, we have no way of knowing which feature's value restriction it is supposed to encode. A generalized term encoding provides an elegant solution to this problem. When a variable is bound to a substructure that is a circular reference, it can be filled in with a frame for the most general satisfier that it represents and then passed out of context. Having more than one representative for the original TFS is consistent, because the set of representatives is closed under this filling operation.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Generalized Term Encoding", |
| "sec_num": "5" |
| }, |
| { |
| "text": "A schematic overview of the generalized encoding is in Figure 16 . Every set of frames that encode a particular TFS has a least element, in which circular references are always opted for as introduced feature values. This is the same element as the classical encoding. It also has a greatest element, in which every unused slot still has a circular reference, but all unshared most general satisfiers are filled in with frames. Whenever we bind a variable to a substructure of a TFS, filling pushes the TFS's encoding up within the same set to some other encoding. As a result, at any given point in time during a computation, we do not exactly know which encoding we are using to represent a given TFS. Furthermore, when two TFSs are unified successfully, we do not know exactly what the result will be, but we do know that it falls inside the correct set of representatives because there is at least one frame with circular references for the values of every newly introduced feature.", |
| "cite_spans": [], |
| "ref_spans": [ |
| { |
| "start": 55, |
| "end": 64, |
| "text": "Figure 16", |
| "ref_id": "FIGREF10" |
| } |
| ], |
| "eq_spans": [], |
| "section": "Generalized Term Encoding", |
| "sec_num": "5" |
| }, |
| { |
| "text": "Simple frames with extra slots and a convention for filling in feature values provide a join-preserving encoding of any statically typable type system, with no resizing and no referencing beyond that of type representations. A frame thus remains stationary in memory once it is allocated. A generalized encoding, moreover, is robust to side-effects such as extra-logical variable-sharing. Frames have many potential implementations, including Prolog terms, WAM-style heap frames, or fixed-sized records.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Conclusion", |
| "sec_num": "6" |
| }, |
| { |
| "text": "Instead of a bit vector, we could also use an index into a table if least upper bounds are computed by table look-up.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "", |
| "sec_num": null |
| } |
| ], |
| "back_matter": [], |
| "bib_entries": { |
| "BIBREF0": { |
| "ref_id": "b0", |
| "title": "Time stamp techniques for the trailed data in constraint logic programming systems", |
| "authors": [ |
| { |
| "first": "A", |
| "middle": [], |
| "last": "Aggoun", |
| "suffix": "" |
| }, |
| { |
| "first": "N", |
| "middle": [], |
| "last": "Beldiceanu", |
| "suffix": "" |
| } |
| ], |
| "year": 1990, |
| "venue": "Programmation en Logique, Actes du 8eme Seminaire", |
| "volume": "", |
| "issue": "", |
| "pages": "487--509", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "A. Aggoun and N. Beldiceanu. 1990. Time stamp techniques for the trailed data in constraint logic programming systems. In S. Bourgault and M. Dincbas, editors, Programmation en Logique, Actes du 8eme Seminaire, pages 487-509.", |
| "links": null |
| }, |
| "BIBREF1": { |
| "ref_id": "b1", |
| "title": "Efficient parsing with large-scale unification grammars. Master's thesis", |
| "authors": [ |
| { |
| "first": "U", |
| "middle": [], |
| "last": "Callmeier", |
| "suffix": "" |
| } |
| ], |
| "year": 2001, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "U. Callmeier. 2001. Efficient parsing with large-scale unifica- tion grammars. Master's thesis, Universitaet des Saarlandes.", |
| "links": null |
| }, |
| "BIBREF2": { |
| "ref_id": "b2", |
| "title": "The Logic of Typed Feature Structures", |
| "authors": [ |
| { |
| "first": "B", |
| "middle": [], |
| "last": "Carpenter", |
| "suffix": "" |
| } |
| ], |
| "year": 1992, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "B. Carpenter. 1992. The Logic of Typed Feature Structures. Cambridge.", |
| "links": null |
| }, |
| "BIBREF3": { |
| "ref_id": "b3", |
| "title": "Multi-dimensional inheritance", |
| "authors": [ |
| { |
| "first": "G", |
| "middle": [], |
| "last": "Erbach", |
| "suffix": "" |
| } |
| ], |
| "year": 1994, |
| "venue": "Proceedings of KONVENS 94", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "G. Erbach. 1994. Multi-dimensional inheritance. In Proceed- ings of KONVENS 94. Springer.", |
| "links": null |
| }, |
| "BIBREF4": { |
| "ref_id": "b4", |
| "title": "Metastructures vs. attributed variables in the context of extensible unification", |
| "authors": [ |
| { |
| "first": "C", |
| "middle": [], |
| "last": "Holzbaur", |
| "suffix": "" |
| } |
| ], |
| "year": 1992, |
| "venue": "Programming Language Implementation and Logic Programming", |
| "volume": "", |
| "issue": "", |
| "pages": "260--268", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "C. Holzbaur. 1992. Metastructures vs. attributed variables in the context of extensible unification. In M. Bruynooghe and M. Wirsing, editors, Programming Language Implementa- tion and Logic Programming, pages 260-268. Springer Ver- lag.", |
| "links": null |
| }, |
| "BIBREF5": { |
| "ref_id": "b5", |
| "title": "The LinGO grammar and lexicon", |
| "authors": [ |
| { |
| "first": "", |
| "middle": [], |
| "last": "Lingo", |
| "suffix": "" |
| } |
| ], |
| "year": 1999, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "LinGO. 1999. The LinGO grammar and lexicon. Available on-line at http://lingo.stanford.edu.", |
| "links": null |
| }, |
| "BIBREF6": { |
| "ref_id": "b6", |
| "title": "Graph-encodable description spaces", |
| "authors": [ |
| { |
| "first": "C", |
| "middle": [], |
| "last": "Mellish", |
| "suffix": "" |
| } |
| ], |
| "year": 1991, |
| "venue": "DYANA Deliverable R3.2B", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "C. Mellish. 1991. Graph-encodable description spaces. Tech- nical report, University of Edinburgh Department of Artifi- cial Intelligence. DYANA Deliverable R3.2B.", |
| "links": null |
| }, |
| "BIBREF7": { |
| "ref_id": "b7", |
| "title": "Term-encodable description spaces", |
| "authors": [ |
| { |
| "first": "C", |
| "middle": [], |
| "last": "Mellish", |
| "suffix": "" |
| } |
| ], |
| "year": 1992, |
| "venue": "Logic Programming: New Frontiers", |
| "volume": "", |
| "issue": "", |
| "pages": "189--207", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "C. Mellish. 1992. Term-encodable description spaces. In D.R. Brough, editor, Logic Programming: New Frontiers, pages 189-207. Kluwer.", |
| "links": null |
| }, |
| "BIBREF8": { |
| "ref_id": "b8", |
| "title": "The ALE HPSG benchmark grammar", |
| "authors": [ |
| { |
| "first": "G", |
| "middle": [], |
| "last": "Penn", |
| "suffix": "" |
| } |
| ], |
| "year": 1993, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "G. Penn. 1993. The ALE HPSG benchmark gram- mar. Available on-line at http://www.cs.toronto.edu/ \u00a7", |
| "links": null |
| }, |
| "BIBREF9": { |
| "ref_id": "b9", |
| "title": "An optimized Prolog encoding of typed feature structures", |
| "authors": [ |
| { |
| "first": "G", |
| "middle": [], |
| "last": "Penn", |
| "suffix": "" |
| } |
| ], |
| "year": 1999, |
| "venue": "Proceedings of the 16th International Conference on Logic Programming (ICLP-99)", |
| "volume": "", |
| "issue": "", |
| "pages": "124--138", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "G. Penn. 1999. An optimized Prolog encoding of typed feature structures. In Proceedings of the 16th International Confer- ence on Logic Programming (ICLP-99), pages 124-138.", |
| "links": null |
| }, |
| "BIBREF10": { |
| "ref_id": "b10", |
| "title": "The Algebraic Structure of Attributed Type Signatures", |
| "authors": [ |
| { |
| "first": "G", |
| "middle": [], |
| "last": "Penn", |
| "suffix": "" |
| } |
| ], |
| "year": 2000, |
| "venue": "", |
| "volume": "", |
| "issue": "", |
| "pages": "", |
| "other_ids": {}, |
| "num": null, |
| "urls": [], |
| "raw_text": "G. Penn. 2000. The Algebraic Structure of Attributed Type Signatures. Ph.D. thesis, Carnegie Mellon University.", |
| "links": null |
| } |
| }, |
| "ref_entries": { |
| "FIGREF0": { |
| "text": "Figure 1: A sample type system with appropriateness conditions.", |
| "num": null, |
| "type_str": "figure", |
| "uris": null |
| }, |
| "FIGREF2": { |
| "text": "Figure 3: A non-classical join-preserving encoding between BCPOs for which no classical joinpreserving encoding exists.", |
| "num": null, |
| "type_str": "figure", |
| "uris": null |
| }, |
| "FIGREF3": { |
| "text": "classical join-preserving encoding. It is not necessary, however, to require that only one element of represent an element of \u00a1 , provided that it does not matter which representative we choose at any given time. Figure 3 shows a generalized join-preserving encoding between two partial orders for which no classical encoding exists. There is no classical encoding of R into because no three elements can be found in that pairwise unify to a common join. A generalized encoding exists because we can choose three potential representatives for D Notice that the set of representatives for D must be closed under unification.", |
| "num": null, |
| "type_str": "figure", |
| "uris": null |
| }, |
| "FIGREF4": { |
| "text": "A TFS of type head from the type system inFigure 1.", |
| "num": null, |
| "type_str": "figure", |
| "uris": null |
| }, |
| "FIGREF5": { |
| "text": "The least number of feature slots required for a frame of any type in \u00a5", |
| "num": null, |
| "type_str": "figure", |
| "uris": null |
| }, |
| "FIGREF6": { |
| "text": "A TFS of type head in which one feature value is a most general satisfier of its feature's value restriction.", |
| "num": null, |
| "type_str": "figure", |
| "uris": null |
| }, |
| "FIGREF7": { |
| "text": "The frame forFigure 8. they are shared (Figure 10), they do not use circu-: A TFS of type head in which both feature values are most general satisfiers of the value restrictions, but they are shared. lar references", |
| "num": null, |
| "type_str": "figure", |
| "uris": null |
| }, |
| "FIGREF8": { |
| "text": "The frame forFigure 10. : A TFS of type head in which both feature values are most general satisfiers of the value restrictions, and they are not shared. The frame forFigure 12.", |
| "num": null, |
| "type_str": "figure", |
| "uris": null |
| }, |
| "FIGREF10": { |
| "text": ": A pictorial overview of the generalized encoding.", |
| "num": null, |
| "type_str": "figure", |
| "uris": null |
| } |
| } |
| } |
| } |
