<?xml version="1.0" standalone="yes"?>
<Paper uid="P98-2169">
  <Title>Parametric Types for Typed Attribute-Value Logic</Title>
  <Section position="4" start_page="1028" end_page="1029" type="metho">
    <SectionTitle>
3 Induced Type Hierarchies
</SectionTitle>
    <Paragraph position="0"> The relationship expressed between two functions by EP, informally, is one between their image sets under their domains, 5 while each image where the arguments do not need to be expressed.</Paragraph>
    <Paragraph position="1"> 5One can restrict these domains with &amp;quot;parametric restrictions,&amp;quot; a parallel to appropriateness restrictions on set internally preserves the subsumption ordering of its domain. It is, thus, possible to think of a parametric type hierarchy as &amp;quot;inducing&amp;quot; a non-parametric type hierarchy, populated with the ground instances of its parametric types, that obeys both of these relationships.</Paragraph>
    <Paragraph position="2"> Definition 2: Given parametric type hierarchy, (P, Ep, a), the induced (type) hierarchy, (I(P), El), is defined such that: * I(P) is the smallest set, I, such that, for every parametric type, p(Xt,...,Xn) E P, and for every tuple, (tt...tn)EI n, p(tl,..., tn)eI.</Paragraph>
    <Paragraph position="3"> * p(tl,...,tn) EI q(ut,... ,urn) iff p EP q, and, for all l&lt;i&lt;n, either at(i ) = 0 or ti Et u~(i).</Paragraph>
    <Paragraph position="4"> It can easily be shown that (I(P), EI) is a partial order with a least element, namely .L, the least element of P. Note that I(P) also contains all of the simple types of P. In the case where 9rand92 are simple, gl EI g2 iff gl EP 92.</Paragraph>
    <Paragraph position="5"> Figure 4 shows a fragment of the type hierarchy induced by Figure 1. If list and nclist had</Paragraph>
    <Paragraph position="7"> not shared the same type variable ?,,nelistfl~ 0), then it would have induced the type hierarchy in Figure 5. In the hierarchy induced</Paragraph>
    <Paragraph position="9"> feature values. This abstract assumes that these domains are always the set of all types in the signature. This is the most expressive case of parametric types, and the worst case, computationally.</Paragraph>
    <Paragraph position="10">  by Figure 3, b(e,e) subsumes types d(e,Y,e), for any type Y, for example d(e,c(e,e),e), or d(e,b(_L,e),e), but not d(c(_L,e),e,e), since eElc(_l_, e). Also, for any types, W, X, and Z, c(W,e) subsumes d(X,e,Z).</Paragraph>
    <Paragraph position="11"> The present approach permits parametric types in the type signature, but only ground instances in a grammar relative to that signature. If one must refer to &amp;quot;some list&amp;quot; or &amp;quot;every list&amp;quot; within a grammar, for instance, one may use list(I), while still retaining groundedness. An alternative to this approach would be to attempt to cope with type variable parameters directly within descriptions. From a processing perspective, this is problematic when closing such descriptions under total well-typing, as observed in (Car92). The most general satisfier of the description, list(X)A(HEAD:HEAD &amp;quot;-&amp;quot; TAIL:HEAD), for example, is an infinite feature structure of the infinitely parametric type, nelist(nelist(.., because X must be bound to nelist(X).</Paragraph>
    <Paragraph position="12"> For which P does it make sense to talk about unification in I(P), that is, when is I(P) a meet semilattice? We can generalize the usual notion of coherence from programming languages, so that a subtype can add, and in certain cases drop, parameters with respect to a supertype: Definition 3: (P, EP, ap) is semi-coherent if, for allp, q E P such thatp Ep q, all1 _&lt; i _&lt; arity(p), 1 &lt;_ j &lt;_ arity(q):</Paragraph>
    <Paragraph position="14"> ,up._,t...aP~(i)...)), and * Ifpllpq$, then for all i and j for which there is a k &gt;_ 1 such that appUpq(i) = apqUpa(j) = k, the set, {rip Up q EP r and (@(i) = 0 or arq(j) = 0)} is empty or has a least element (with respect to EP).</Paragraph>
    <Paragraph position="15"> Theorem 1: If (P, Ep, ap) is semi-coherent, then (I(P),EI) is a meet semilattice. In particular, p(ti,...,tn) Ut q(ui,...,Um) = r(vi,...,vs), where p tap q = r, and, for all</Paragraph>
    <Paragraph position="17"> if there exist i and j such that @(i) = k and arq(j) = k if such an i, but no such j if such a j, but no such i if no such i or j.</Paragraph>
    <Paragraph position="18"> So p(ti,..., tn) UI q(ui,..., Um)~ if p Up q\]', or there exist i, j, and k &gt; 1 such that @(i) = arq(j) = k, but ti UI ujl&amp;quot;. 6 In the induced hierarchy of Figure 3, for example, b(e, 2) Ut 5(2, e) = b(e,e); b(e,e) U1 c(_L) = die , 2, e); and b(e, e) and b(c(_L), e) are not unifiable, as e and c(_l_) are not unifiable. The first two conditions of semi-coherence ensure that ap, taken as a relation between pairs of pairs of types and natural numbers, is an order induced by the order, EP, where it is not, taken as a function, zero. The third ensures that joins are preserved even when a parameter is dropped (ap = 0). Note that joins in an induced hierarchy do not always correspond to joins in a parametric hierarchy. In those places where ap ---- 0, types can unify without a corresponding unification in their parameters. Such is the case in Figure 5, where every instance of list(X) ultimately subsumes nelist(_k). One may also note that induced hierarchies can have not only deep infinity, where there exist infinitely long subsumption chains, but broad infinity, where certain types can have infinite supertype (but never subtype) branching factors, as in the case of nelist(I) or, in Figure 1, elist.</Paragraph>
  </Section>
  <Section position="5" start_page="1029" end_page="1030" type="metho">
    <SectionTitle>
4 Appropriateness
</SectionTitle>
    <Paragraph position="0"> So far, we have formally considered only type hierarchies, and no appropriateness. Appropriateness constitutes an integral part of a parametric type signature's expressive power, because the scope of its type variables extends to include it.</Paragraph>
    <Paragraph position="1"> Definition 4: A parametric (type) signature is a parametric hierarchy, (P, EP, ap&gt;, along with finite set of features, Featp, and a partial (parametric) appropriateness function, Appropp : Featp x P --~ Q, where Q = UneNat Qn, and each Qn is the smallest set satisfying the equation, Qn = {1,...,n} u {P(qi,...,qk)lP E Parity k, qi E Qn}, such that:  ity n, for every f E Featp, if Appropp(f ,p) is defined, then Appropp(f,p) e Qn.</Paragraph>
    <Paragraph position="2"> Appropp maps a feature and the parametric type for which it is appropriate to its value restriction on that parametric type. The first two conditions are the usual conditions on (Car92)'s appropriateness. The third says that the natural numbers in its image refer, by position, to the parametric variables of the appropriate parametric type -- we can use one of these parameters wherever we would normally use a type. Notice that ground instances of parametric types are permitted as value restrictions, as are instances of parametric types whose parameters are bound to these parametric variables, as are the parametric variables themselves. The first is used in HPSG for features such as SUBCAT, whose value must be list(synsem); whereas the second and third are used in the appropriateness specification for nelist(X) in Figure 1. The use of parameters in appropriateness restrictions is what conveys the impression that ground instances of lists or other parametric types are more related to their parameter types than just in name.</Paragraph>
    <Paragraph position="3"> It is also what prevents us from treating instances of parametric types in descriptions as instantiations of macro descriptions. These putative &amp;quot;macros&amp;quot; would be, in many cases, equivalent only to infinite descriptions without such macros, and thus would extend the power of the description language beyond the limits of HPSG's own logic and model theory. Lists in HPSG would be one such case, moreover, as they place typing requirements on every element of lists of unbounded length. Ground instances of parametric types are also routinely used in appropriate value restrictions, whose extension to arbitrary descriptions would substantially extend the power of appropriateness as well. This alternative is considered further in the full version of this paper.</Paragraph>
    <Paragraph position="4"> A parametric signature induces a type hierarchy as defined above, along with the appropriateness conditions on its ground instances, determined by the substitution of actual parameters for natural numbers. Thus:</Paragraph>
  </Section>
  <Section position="6" start_page="1030" end_page="1031" type="metho">
    <SectionTitle>
5 Signature Subsumption
</SectionTitle>
    <Paragraph position="0"> Now that parametric type signatures have been formalized, one can ask whether parametric types really add something to the expressive power of typed attribute-value logic. There are at least two ways in which to formalize that question: Definition 5: Two type signatures, P and Q, are equivalent (P ~s Q) if there exists an orderisomorphism (w.r.t. subsumption) between the abstract totally well-typed feature structures of P and those of Q.</Paragraph>
    <Paragraph position="1"> Abstract totally well-typed feature structures are the &amp;quot;information states&amp;quot; generated by signatures. Formally, as (Car92) shows, they can either be thought of as equivalence classes of feature structures modulo alphabetic variants, or as pairs of a type assignment function on feature paths and a path equivalence relation.</Paragraph>
    <Paragraph position="2"> In either case, they are effectively feature structures without their &amp;quot;nodes,&amp;quot; which only bear information insofar as they have a type and serve as the focus of potential instances of structure sharing among feature path, where the traversal of two different paths from the same node leads to the same feature structure.</Paragraph>
    <Paragraph position="3"> If, for every parametric signature P, there is a finite non-parametric N such that P ~s N, then parametric signatures add no expressive power at all -- their feature structures are just those of some non-parametric signatures painted a different color. This is still an open question. There is, however, a weaker but still relevant reading: Definition 6: Type signature, P, subsumes signature Q (P Es Q) if there exists an injection, f, from the abstract totally well-typed fea- null ture structures of P to those of Q, such that:</Paragraph>
    <Paragraph position="5"> If for every parametric P, there is a finite non-parametric N such that P ___s N, then it is possible to embed problems (specifically, unifications) that we wish to solve from P into N, solve them, and then map the answers back to P. In this reading, linguist users who want to think about their grammars with P must accept no non-parametric imitations because N may not have exactly the same structure of information states; but an implementor of a feature-based NLP system, for example, could secretly perform all of the work for those grammars in N, and no one would ever notice.</Paragraph>
    <Paragraph position="6"> Under this reading, many parametrically typed encodings add no extra expressive power: Definition 7: Parametric type hierarchy, (P, EP, ap) is persistent if ap never attains zero. Theorem 3: For any persistent parametric signature, P, there is a finite non-parametric signature, N, such that P Es N.</Paragraph>
    <Paragraph position="7"> If elist in Figure 1 retained list(X)'s parameter, then HPSG's type hierarchy (without sets) would be persistent. This is not an unreasonable change to make. The encoding, however, requires the use of junk slots, attributes with no empirical significance whose values serve as workspace to store intermediate results.</Paragraph>
    <Paragraph position="8"> There are at least some non-persistent P, including the portion of HPSG's type hierarchy explicitly introduced in (PS94) (without sets), that subsume a finite non-parametric N; but the encodings are far worse. It can be proven, for example, that for any such P, some of its acyclic feature structures must be encoded by cyclic feature structures in N; and the encoding cannot be injective on the equivalence classes induced by the types of P, i.e. some type in N must encode the feature structures of more than one type from P. While parametric types may not be necessary for the grammar presented in (PS94) in the strict sense, their use in that grammar does roughly correspond to cases for which the alternative would be quite unappealing. Of course, parametric types are not the only extension that would ameliorate these encodings. The addition of relational expressions, functional uncertainty, or more powerful appropriateness restrictions can completely change the picture.</Paragraph>
  </Section>
  <Section position="7" start_page="1031" end_page="1032" type="metho">
    <SectionTitle>
6 Finiteness
</SectionTitle>
    <Paragraph position="0"> It would be ideal if, for the purposes of feature-based NLP, one could simply forget the encodings, unfold any parametric type signature into its induced signature at compile-time and then proceed as usual. This is not possible for systems that pre-compute all of their type operations, as the induced signature of any parametric signature with at least one non-simple type contains infinitely many types. 7 On the other hand, at least some pre-compilation of type information has proven to be an empirical necessity for efficient processing. 8 Given that one will only see finitely many ground instances of parametric types in any fixed theory, however, it is sufficient to perform some pre-compilation specific to those instances, which will involve some amount of unfolding. What is needed is a way of determining, given a signature and a grammar, what part of the induced hierarchy could be needed at run-time, so that type operations can be compiled only on that part.</Paragraph>
    <Paragraph position="1"> One way to identify this part is to identify some set of ground instances (a generator set) that are necessary for computation, and close that set under Ui(p): Theorem 4: If G C I(P), is finite, then the sub-algebra of I(P) generated by G, I(G), is finite.</Paragraph>
    <Paragraph position="2"> \[I(G)\[ is exponential in \[G\[ in the worst case; but if the maximum parametric depth of G can be bounded (thus bounding \[GD, then it is polynomial in \[P\[, although still exponential in the maximum arity of P: Definition 8: Given a parametric hierarchy, P, the parametric depth of a type, t -p(tl,...,tn) e I(P), ~(t), is 0 if n = 0, and 1 + maxl&lt;i&lt;n ~(ti) if n &gt; O.</Paragraph>
    <Paragraph position="3"> So, for example, 6(list(list(list(.l_))))= 3.</Paragraph>
    <Paragraph position="4"> In practice, the maximum parametric depth should be quite low, 9 as should the maximum 7With parametric restrictions (fn. 5), this is not necessarily the case.</Paragraph>
    <Paragraph position="5"> SEven in LFG, a sensible implementation will use de facto feature co-occurrence constraints to achieve much of the same effect.</Paragraph>
    <Paragraph position="6"> 9With lists, so far as I am aware, the potential demand has only reached 6 -- 2 (MSI98) in the HPSG  arity. A standard closure algorithm can be used, although it should account for the commutativity and associativity of unification. One could also perform the closure lazily during processing to avoid a potentially exponential delay at compile-time. All of the work, however, can be performed at compile-time. One can easily construct a generator set: simply collect all ground instances of types attested in the grammar, or collect them and add all of the simple types, or add the simple types along with some extra set of types distinguished by the user at compiletime. The partial unfoldings like Figure 2 are essentially manual computations of I(G).</Paragraph>
    <Paragraph position="7"> Some alternatives to this approach are discussed in the full version of this paper. The benefit of this one is that, by definition, I(G) is always closed under Ili(p). In fact, I(G) is the least set of types that is adequate for unification-based processing with the given grammar. Clearly, this method of sub-signature extraction can be used even in the absence of parametric types, and is a useful, general tool for large-scale grammar design and grammar reuse. null</Paragraph>
  </Section>
class="xml-element"></Paper>