<?xml version="1.0" standalone="yes"?>
<Paper uid="J99-1002">
  <Title>Default Representation in Constraint-based Frameworks</Title>
  <Section position="4" start_page="80" end_page="94" type="intro">
    <SectionTitle>
4. Linguistic Examples
</SectionTitle>
    <Paragraph position="0"> In this section, we go through some linguistic examples where defaults can be utilized.</Paragraph>
    <Paragraph position="1"> The aim of this section is to illustrate ways in which the use of defaults can simplify and enhance monotonic grammars, concentrating on syntax and (compositional and lexical) semantics. In particular, of course, our aim is to show the linguistic utility of the particular assumptions we have made in defining YADU. We do not have space here to systematically illustrate the ways in which defaults may be utilized in a grammar, though the papers listed in Section I give many more examples, which can, in general, also be modeled within the current framework (with the main exception being some uses that require asymmetric defaults, discussed in Section 6.5, below). We have tried to give examples that have not, to our knowledge, been extensively discussed in the previous default unification literature.</Paragraph>
    <Paragraph position="2"> We assume an HPSG-like framework, but we have tried to give an explanation in enough detail for readers who are relatively unfamiliar with HPSG to follow the examples. In HPSG, the basic linguistic structure is the sign. Signs may be lexical or phrasal, but always correspond to constraints that may be represented using typed feature structures. In what follows, we will instead use TDFSs, and take various liberties with the feature geometry for ease of exposition. However, although much simplified, the treatment in the grammar fragments here is substantially based on that assumed in the English Resource Grammar (ERG) under development at CSLI (Flickinger, Sag, and Copestake, in preparation). The ERG itself has been developed without making use of defaults up to this point, using the DISCO/PAGE system (Uszkoreit et al. 1994), but it also runs within the LKB system (Copestake 1992). YADU has been implemented within the latter system, replacing the earlier version of default unification described in Copestake (1993).</Paragraph>
    <Paragraph position="3"> Before giving detailed examples, however, we must make some further remarks on the assumptions we are making about persistent and nonpersistent defaults in these fragments. In the example of inflectional morphology that we gave in Section 2, we mentioned that the defaults could not persist beyond the lexicon, since the values for the suffixes must be treated as hard information by the parser/generator. More generally, we distinguish between defaults used in the description of some object in the grammar (that is, a lexical sign, a lexical rule or a grammar rule/schema), which we refer to as nonpersistent defaults, and defaults that are intended to contribute to the output of the grarmnar (in particular, the logical form), which we term persistent defaults. In fact, most of the examples we will discuss here make use of nonpersistent defaults, and where we intend defaults to be persistent we will distinguish this with a subscript p following the slash in the case of the abbreviatory notation, and with an annotation on the tail in the full description. 4 4 In principle at least, there can be a mixture of defaults of varying persistence in the tail of a TDFS, and  Computational Linguistics Volume 25, Number 1 In the examples below, as in Section 2, we assume that nonpersistent defaults may be part of type constraints. This is in line with the practice followed in the ERG, where some types are purely lexical, that is, they are only utilized in the description of lexical entries and are irrelevant to the parser/generator. However, some grammar writers deprecate such use of types, and capture the corresponding generalizations with macros or templates. For our current purposes, this controversy is of limited relevance, since the same TDFSs that we are describing as constraints on types could alternatively be used as the values of templates. The only requirement is that, in order to have a compatible notion of specificity, the templates must form a partial order (which will be naturally true if they are used as an inheritance hierarchy) so that template order can replace type order in the determination of specificity in YADU (as discussed in Section 6.2). Under these circumstances, nonpersistent defaults would most naturally be seen as part of the description language. For further discussion of the type/template distinction, in the context of a default inheritance system, see Lascarides et al. (1996).</Paragraph>
    <Section position="1" start_page="81" end_page="84" type="sub_section">
      <SectionTitle>
4.1 Modals
</SectionTitle>
      <Paragraph position="0"> One very straightforward example of the utility of defaults in descriptions of syntactic behavior is the treatment of ought in English. It behaves as a modal verb in most respects: it inverts, it can be negated without do, it takes the contracted negation oughtn't, and it does not have distinct inflected forms (though we will ignore morphological issues here). However, unlike most modals, it requires the to-infinitive, as shown in (6a-d), rather than the base form of the verb. The modal is to behaves similarly, as shown in (6e), although it inflects. 5  (6) a. I ought to finish this paper.</Paragraph>
      <Paragraph position="1"> b. * I ought finish this paper.</Paragraph>
      <Paragraph position="2"> c. You oughtn't to disagree with the boss.</Paragraph>
      <Paragraph position="3"> d. Ought we to use this example? e. You are not to argue.</Paragraph>
      <Paragraph position="4">  Here we sketch a treatment of modals that allows ought to be an exception to the general class, just with respect to the value of the attribute on its complement specification, which specifies whether ought expects a base or infinitival complement. We also briefly introduce the syntactic feature geometry we will also assume for all the examples that follow.</Paragraph>
      <Paragraph position="5"> Figure 7 shows a constraint specification for a type modal, which we assume is the lexical type of all modal verbs including ought. This constraint is responsible for the characteristic behavior of modals mentioned above. Because we are ignoring morphology, the figure only shows the SYNSEM (syntax/semantics) part of the lexical the DefFill operation must be defined so that it is sensitive to this distinction and only incorporates defaults of the appropriate persistence. To do this, we can define a partial order on persistence markers and add a persistence marker as an extra component to the definition of a tail. DefFill is then defined relative to a particular persistence, and incorporates all tails marked as having that persistence or any persistence that is prior in the partial order. Since none of the examples that follow make use of mixed persistence tails, we ignore this complication here. 5 For some speakers the infinitive without to is possible or even preferred with ought in nonassertive contexts. For others, ought does not share the other properties of modals we have listed here. We will ignore these dialect variations here, and simply assume the grammaticality pattern shown in (6).  Structure of an HPSG-style phrase for could sleep.</Paragraph>
      <Paragraph position="6"> sign, and we will ignore the semantics of modals for this example. Subcategorization properties of signs are specified via valence (VAL) features, which describe a list of specifications with which the SYNSEM values of other signs may be unified. For verbs, the relevant valence features are SUBJ (subject) and COMPS (complements), though we have systematically omitted SUBJ in this example for simplicity. The constraint given on modal for the value of the COMPS list means that it may only contain a single element. That element must have a verbal HEAD, a single member subject list, and an empty complements list: i.e., it must be a verb phrase. Thus the constraint means that modals are restricted to taking a single verb phrase complement, which we assume here is obligatory. The value of the VFORM of the complement is specified by default to be bse, which is true of verbs and verb phrases where the head is a base form, but not of infinifivals (which have VFORM inf).</Paragraph>
      <Paragraph position="7"> Figure 8 illustrates the complement selection mechanism in operation. It shows a simple instance of a head complement phrase consisting of a modal (could) and its verb phrase complement (sleep). As we mentioned above, phrases are represented as TDFSs. Generalizations about phrases, or schemata, are represented as constraints on types and correspond to grammar rules in other frameworks. Here head-comp-phrase is a type, corresponding to head-complement phrases, as we will discuss in more detail in Section 4.2. Headed phrases have features HD-DTR, indicating the head of the phrase, which in this case corresponds to the structure for the modal verb could, and NON-HD-DTRS, which corresponds to a list of the other daughters. Here NON-HD-DTRS is a singleton, corresponding to the verb phrase sleep. The head-complement schema constrains the list of SYNSEMs of the NON-HD-DTRS signs to be equal to the COMPS list of the head daughter.</Paragraph>
      <Paragraph position="8"> The constraint for modal in Figure 7 also specifies that the HEAD AUX value of modal signs is true indefeasibly. This controls the behavior with respect to various lexical rules. For instance, negation is implemented via a lexical rule which, among  Examples of lexical description for modal verbs* other things, adds a structure compatible with not to the beginning of the complement list of the verb. This lexical rule only applies to verbs such as auxiliaries and modals which, unlike other verbs, have a value for SYNSEM HEAD AUX compatible with true. The AUX feature also controls the application of the inversion lexical rule. The lexical specification for could, which we take as an example of a normal modal, is also shown in Figure 9. The only idiosyncratic information given here is the morphology (though of course in the full entry there is also a specification of the semantics). Thus the TFS for could inherits all the information from the constraint on the type modal. Note, however, that the default for the VFORM of the complement must be nonpersistent, and thus the actual TFS for the lexical sign is calculated via DefFill, with the result that is shown in Figure 9. The structure for could sleep, which is derived from the sign shown in Figure 9, is shown in Figure 8 (for details on constructing this, see Section 4.2). In contrast, the lexical specification for ought overrides the default value inherited from modal with the nondefault value inf for the VFORM of its complement. So ought cannot combine with sleep in the manner shown in Figure 8, as required.</Paragraph>
      <Paragraph position="9"> This is a very simple example but it illustrates that the use of defaults allows the grammar to capture the generalization that most modals take a base form complement. It is possible to devise a monotonic encoding that would produce the same lexical FSs but the various behaviors characteristic of modals would have to be split into different constraints, so that ought could inherit some but not all of them. This would not capture the intuition that ought is the exceptional case. Furthermore a monotonic encoding requires extra types. With the example as shown here, it appears that the monotonic encoding would require two additional types compared to the default encoding, one for ought and is to (and also used to, for speakers for whom this is a modal) and the other for all other modals. However, in the full English Resource Grammar, seven types are duplicated to allow for ought. The real gain in conciseness from allowing defaults is therefore more significant than our simplified example suggests.</Paragraph>
    </Section>
    <Section position="2" start_page="84" end_page="87" type="sub_section">
      <SectionTitle>
4.2 Defaults in Constructions
</SectionTitle>
      <Paragraph position="0"> Default inheritance can also be utilized in the description of rules, schemata, or constructions within the grammar itself. Recent work within HPSG has demonstrated the utility of describing a hierarchy of phrasal types in a manner analogous to the more familiar lexical hierarchy. As we mentioned in the previous example, in HPSG, phrasal types play a similar role to rules in other frameworks, systematically relating the mother of a phrase to its daughters. Sag (1997), in an account of relative clause constructions, defines a general type phrase, from which various subtypes of phrase inherit (Figure 10). Sag uses defaults in his description of the phrasal hierarchy, but we go through the example in detail here, in order to demonstrate more formally how default unification operates in this case.</Paragraph>
      <Paragraph position="1"> We will not go into the full details of the hierarchy here, since our main concern is to demonstrate the way in which defaults are used. We will just consider the constraints on headed-phrase (shown in Figure 11) and the way these are inherited by some of its subtypes. 6 The Head Feature Principle (HFP), which states that the HEAD value of the mother is identical to that of the head daughter, is unchanged from earlier work on HPSG (e.g., Pollard and Sag 1994, 34) and is not default. In contrast the Valence Principle (VALP) and the Empty Complement Constraint (ECC) are both stated in terms of defaults. VALP is a reformulation of the Valence Principle in Pollard and Sag (1994, 348). Here SUBJ (subject), SPEC (specifier) and COMPS (complements) are all valence features, and the effect of the constraint is to specify that these should be identical on the head daughter of a phrase and the mother, unless a more specific phrase type overrides this. The exceptions to the generalization that valence information is identical on the head daughter and mother are the phrase types where the individual valence features are satisfied. For example, in a head-complement phrase, the complements of the head of the phrase are instantiated and the COMPS list of the mother will be empty (as shown above in the example in Figure 8). ECC is a simpler 6 The constraints are presented slightly differently from Sag (1997), since he sometimes omits features on paths when specifying constraints, but for the sake of clarity we show full paths here. We have also added the feature VAL, as in the ERG and the example above.</Paragraph>
      <Paragraph position="2">  Expressing the HFP, VALP, and ECC constraints as a single TDFS (SS here is an abbreviation for SYNSEM).</Paragraph>
      <Paragraph position="3"> constraint which states that, by default, headed-phrases have head daughters with an empty complement list. It is important to note that although Sag states HFP, VALP, and ECC as three separate constraints, this is equivalent to treating their conjunction as a single constraint on the type headed-phrase, as shown in Figure 12 (for clarity we use the full indefeasible/tail notation for a TDFS). Note that one advantage of order independence in our definition of defaults is that the result of specifying constraints individually is guaranteed to be equivalent to stating them as a single TDFS, leading to greater perspicuity in the definition of a grammar.</Paragraph>
      <Paragraph position="4"> In Figure 13, we show the constraint specifications on the types head-nexusphrase, head-complement-phrase, and head-specifier-phrase, as given by Sag (with modifications as above). The constraint on head-nexus-phrase refers to how the semantic content is shared between mother and head daughter (a default version of this constraint that actually removes the need for the type head-nexus-phrase will be discussed in Section 6.1). For head-complement-phrase and head-specifier-phrase, the attribute NON-HD-DTRS corresponds to a list of the daughters of the phrase excluding the head. As in Figure 8, elements of the appropriate valence feature are instantiated by the SYNSEMs of the nonhead daughters.</Paragraph>
      <Paragraph position="5"> There is a complication here: the constraint on head-complements-phrase given by Sag is intended to be read as specifying that an arbitrary number of complements (possibly zero) correspond to the value of the COMPS feature. In fact, this cannot be directly implemented as written in the framework we assume here. The required effect can be achieved with a recursive type, or, on the assumption that the complements list can contain no more than four elements, multiple subtypes can be specified, each with a fixed number of complements. For simplicity, we have assumed the latter encoding style here, which we illustrate with two schemata in Figure 13, for the zero complement (head-zero-comp-phrase) and the one complement cases (head-one-comp-phrase).</Paragraph>
      <Paragraph position="6">  phrases and head-specifier-phrase, after inheritance from the supertypes and making the default properties nondefault. 7 Note that in the head-one-complement-phrase schema, the ECC is overridden, as is the part of VALP that concerns the coindexation between the complements of the head-daughter and the mother, while in headspecifier-phrase, the coindexation of the specifier has been overridden.</Paragraph>
      <Paragraph position="7"> One interesting point is that the specification language discussed in Section 3.5 allows for a very succinct encoding of constraints which, like the valence principle, state that a set of features are identical by default. Figure 15 shows this alternative encoding for VALP: the default TFS states one coindexation, between the VAL features for mother and head daughter. Because the definition of BasicTDFS states that a path equivalence will be present in the tail for each case where a node can be reached by two distinct paths, the TDFS contains tail elements indicating a path equivalence not only for VAL, but also for all paths that extend VAL, i.e., SUBJ, COMPS, and SPR (for clarity, we have shown the type list explicitly, rather than using the angle-bracket notation: list has no appropriate features). Thus the TDFS has one extra tail element compared to the version we gave in Figure 12, but this extra element will be overridden in all of the schemata (except head-zero-comp-phrase, if we use the encoding assumed in Figure 13). 8 Thus the use of defaults allows a more concise specification of the phrase hierarchy, enabling generalizations to be captured that would be obscured with a purely monotonic treatment. Although these constraints could be captured in a system without defaults, either they would have to be stipulated redundantly, in multiple points in the hierarchy, or extra types would have to be introduced so that multiple inheritance could be used to distribute properties appropriately. This latter option would consid7 Sag (1997) suggests that the constraints are converted from default to nondefault for all maximally specific phrasal types, which means that these must have a special status. A more straightforward approach is to assume that the terminal schemata are analogous to lexical entries, rather than being types in their own right.</Paragraph>
      <Paragraph position="8"> 8 This encoding style also has potential in the representation of lexical rules, where these are represented as single TDFS with an input and an output feature, since the default TFS in the specification can state that the input is equal to the output. This allows a much more succinct description than is possible in an unextended monotonic language, where feature values must be explicitly duplicated.</Paragraph>
      <Paragraph position="9">  erably complicate the hierarchy for the set of default constraints that Sag considers. In neither case could the valence principle be stated as a single generalization. The only way in which this would be possible in a monotonic system would be if the constraint language were enriched. This example shows the utility of allowing overriding of default path equivalence statements. This would not be possible with some previous versions of default unification, including Russell, Carroll, and Warwick-Armstrong (1991), Russell et al. (1993), and the second version of the LKB default unification given in Copestake (1993). It is also not allowed in Young and Rounds (1993), which is the only order-independent version of default unification of which we are aware apart from PDU and YADU.</Paragraph>
    </Section>
    <Section position="3" start_page="87" end_page="89" type="sub_section">
      <SectionTitle>
4.3 Agreement and Semantic Plurality
</SectionTitle>
      <Paragraph position="0"> We turn now to an example involving a more complex use of YADU, in which it is necessary to allow default values to survive when default path equivalence statements are overridden. The example concerns the relationship of number agreement to semantic notions of plurality and massness in English nouns. It is partially based on a treatment given in Copestake (1992), but the use of YADU enables a more satisfactory encoding of the central intuition, which is that agreement usually, but not always, follows the semantics.</Paragraph>
      <Paragraph position="1"> To explain the account, we must first briefly introduce the style of semantic en- null coding used in the ERG. This is known as Minimal Recursion Semantics (MRS) and is described in detail in Copestake et al. (1995), though for the sake of simplicity we will ignore most of the details in these examples, including all discussion of quantification. The semantics (i.e., the value for the CONTENT feature) for the lexical sign for dog is shown in (7a). This has an interpretation roughly equivalent to that of (7b).</Paragraph>
      <Paragraph position="2"> (7) a. \[INDEX: i\[AGRNUi:sg\]_dog_rel LISZT: ( INST : \[\] b. Ax\[dog(x)\] The feature INDEX in (7a) indicates the equivalent of the lambda variable in (7b). Features on the index indicate agreement, in the usual way in HPSG: here the noun will agree with a verb that takes singular agreement (we only consider number agreement here). The LISZT contains a list of relations, which is a singleton here as for most lexical signs (composition of the semantics proceeds by appending LISZTs). The type of the relation, _dog_tel, indicates the predicate name. The initial underscore in the type name is a notational convention to indicate a lexical predicate, so that we can for instance distinguish the type noun_rel, which is a general type for noun relations in the type hierarchy, and _noun_rel, which is the relation corresponding to the noun noun. The argument to the predicate is indicated by INST, which is coindexed with the value of INDEX.</Paragraph>
      <Paragraph position="3"> This structure has to be augmented to represent semantic plurality and individuation (i.e., the mass/count distinction) since the AGR NUM feature will not always make the appropriate distinctions. Although in normal count nouns (such as dog in its most usual interpretation) number agreement and semantics are in step, this is not true for all nouns. Some nouns, such as scissors or trousers, that denote bipartite objects have obligatory plural agreement. Other count nouns, such as gallows and barracks, show variable agreement, even when referring to a single object (Quirk et al. 1985). Mass  Computational Linguistics Volume 25, Number 1 terms usually take singular agreement, but there are exceptions, such as clothes, which although it behaves semantically as a mass term, nonetheless takes plural agreement. Here we will assume that semantic plurality/individuation is indicated by a predicate modifier, as illustrated in (8).</Paragraph>
      <Paragraph position="4"> (8) single entity &amp;x\[Struth(x)\] plural entity )~x\[Ptruth(x)\] unindividuated entity ,~x\[Mtruth(x)\] One truth is self-evident.</Paragraph>
      <Paragraph position="5"> Some truths are self-evident.</Paragraph>
      <Paragraph position="6"> There is much truth in that.</Paragraph>
      <Paragraph position="7"> For simplicity, we have assumed that all occurrences of noun predicates are modified either by M, P, or S (corresponding to mass, singular, and plural) though it does not matter if one of these subcases is taken to correspond to the unmodified predicate, or if the structure assumed is more complex, since all that matters for current purposes is that there is some three-way distinction in the formal semantics. Similarly, we need not go into the details of the corresponding models (though see Krifka \[1987\] for example). One way of capturing the distinction in MRS is to add another feature to the relation to record the predicate modifier, which we will call PLMOD. The values of this slot are irrelevant from the perspective of the formal semantics, as long as we can make a three-way distinction. However, in order to facilitate the provision of the default relationship between semantic values and agreement, we will use the values sg, pl, and mass, where the first two types also correspond to possible values of the AGR NUM slot. The hierarchy for these atomic types is shown at the top of Figure 16. We can now capture the generalizations about semantics and agreement as shown in Figure 16. The type noun-sign is a subtype of sign, and mass-sign is a subtype of noun-sign (along with types for count nouns, pair nouns, and so on, which are not shown here). Encoding the generalizations at the sign level allows inflectional information to be included, though we do not show this here. But another reason for not using the rel hierarchy is that we want types such as _truth_rel to be neutral between mass and count. The default generalization about nouns is that the value of the PLMOD and the AGR NUM paths are coindexed. This default will remain intact for ordinary count nouns. For mass nouns, as shown in Figure 16, there is a default value for the AGR NUM feature of sg and a nondefault value of mass for the PLMOD feature. The lexical entries for clothing and clothes both inherit from mass-noun, but the latter has AGR NUM of pl. We make the usual assumption that DefFill operates on these lexical entries, to give the results shown in Figure 17. For this example, we have made use of default reentrancy, and the fact that a default value can survive on a node for which a default path equivalence was overridden, which was not the case in PDU. 9</Paragraph>
    </Section>
    <Section position="4" start_page="89" end_page="94" type="sub_section">
      <SectionTitle>
4.4 Persistent Defaults and the Interface between the Lexicon and Pragmatics
</SectionTitle>
      <Paragraph position="0"> The utility of persistent defaults in the interface between the lexicon and pragmatics was discussed in some detail in Lascarides et al. (1996), and from a more linguistic perspective in Lascarides and Copestake (in press). However, since this sort of use was an important part of the motivation for developing PDU and YADU, we will give one 9 Note that it is not actually the case for this example that a default value is overriding a default path equivalence, although this is allowed in YADU, as we have discussed. The value of AGR NUM is indefeasibly agrnum, which is incompatible with the indefeasible value mass for the PLMOD of mass-nouns. However, in PDU this conflict would have resulted in the value +- on the relevant node in the default structure, and the default value sg on AGR NUM would thus in effect have been ignored.</Paragraph>
      <Paragraph position="1">  Expanded and DefFilled lexical signs.</Paragraph>
      <Paragraph position="2"> example here, which was not discussed in the former paper and was only considered briefly and informally in the latter.</Paragraph>
      <Paragraph position="3"> Verbs such as drink, eat, and bake have both intransitive and strict transitive uses. Both uses have very similar meanings, since for these verbs, intransitive uses imply a patient (in contrast to kick, for instance), but as pointed out by Fillmore (1986) and  Computational Linguistics Volume 25, Number 1 others, the intransitive uses have more specific default interpretations. In the absence of information to the contrary, (9a) means (9b), (10a) means (10b), and (11a) means (11b):  (9) a. John drinks all the time.</Paragraph>
      <Paragraph position="4"> b. John drinks alcohol all the time.</Paragraph>
      <Paragraph position="5"> (10) a. We've already eaten.</Paragraph>
      <Paragraph position="6"> b. We've already eaten a meal.</Paragraph>
      <Paragraph position="7"> (11) a. I spent yesterday afternoon baking.</Paragraph>
      <Paragraph position="8">  b. I spent yesterday afternoon baking cookies, cakes, or bread.</Paragraph>
      <Paragraph position="9"> (as opposed to ham, apples, or potatoes, for example) These defaults can be overridden by arbitrary background information, for example: (12) As long as we're baking anyway, we may as well do the ham now too. (due to Silverstein, cited in Fillmore \[1986\]) A purely pragmatic explanation for the default for bake seems implausible, since there is no evident real-world explanation. For instance it would be difficult to claim that people usually bake flour-based products as opposed to natural ones. A historical justification could be suggested, since the Oxford English Dictionary (second edition) says of bake: primarily used of preparing bread, then of potatoes, apples, the flesh of animals.</Paragraph>
      <Paragraph position="10"> However, synchronically, the default interpretation seems to have become lexicalized: even if the speaker often cooks potatoes by baking but very rarely prepares bread or cakes, (11a) still implies (11b). This implies that the default is associated conventionally with the word bake, rather than arising as a consequence of its meaning. The assumption we make about the boundary between the lexicon and pragmatics is that the lexicon is responsible for encoding the relationship between word forms and meanings, and that pragmatics only has access to meanings. Under these assumptions, the default must be encoded lexically, but in such a way that it can be overridden in the right discourse context. This motivates the use of a persistent default: that is, one which is not converted to hard information, in contrast to the descriptive defaults discussed in the previous examples (for further details and justification of these general assumptions, see Lascarides and Copestake \[in press\]).</Paragraph>
      <Paragraph position="11"> One way of describing an entry for bake that covers both transitive and intransitive uses is sketched in Figure 18. We first go over the indefeasible part of the structure, which will be the same for other verbs that take an optional noun phrase complement. The VAL COMPS value is a singleton, which is constrained to have HEAD noun and an empty complements list, i.e., to be a noun phrase. However, unlike in our earlier examples, we have also shown the feature OPT on the complement. A complement is treated as optional if its value of OPT is (compatible with) true (the details of the schemata that achieve this are not relevant here). As before, we use the MRS style of encoding semantics in TFSs. The INDEX value of the complement is coindexed with  Simplified representation for intransitive and transitive bake.</Paragraph>
      <Paragraph position="12"> the object slot in the main relation for the semantics of the verb. The MRS structure for the verb relation corresponds to bake(x,y) where x is coindexed with the index on the subject, and y with the object. The (r) in the CONT LISZT value of the verb is shorthand for a complex feature structure that has the effect of appending the noun phrase semantics to that of the verb.</Paragraph>
      <Paragraph position="13"> The default part of the structure concerns the semantics for the noun phrase complement, which conventionally would not be instantiated. Here, however, the LISZT is stated, by default, to be the singleton relation flour-based_tel. 1deg Note the subscript p, indicating that the default is persistent: that is, it is not subject to the lexical De, Fill. The effect of this is that the object of bake is given a default semantics indicating that it is a flour-based substance. We assume that flour-based_rel is a type that is incompatible with all lexical relational types, and thus any explicit object will override this specification. However, in an intransitive use the default semantics will be retained, giving a representation that can be represented in a linear notation as: bake(e, x, y) A/flour-based(y). The manner in which this can be overridden by pragmatics in examples such as (12) is outside the scope of this paper, but is discussed in Lascarides and Copestake (in press).</Paragraph>
      <Paragraph position="14"> With a suitably rich constraint language, one could devise a monotonic encoding that would allow for an underspecified entry for bake, which could be specialized either to have an obligatory complement or to be strictly intransitive with the additional flour-based_rel. However, such a treatment would not allow for overriding by pragmatics in contexts such as (12). Furthermore, it should be clear that this sort of use of defaults is only possible if defaults can be distinguished from indefeasible parts of the structure, and if they persist beyond the lexicon, and that an approach such as PDU or YADU is therefore required for such examples.</Paragraph>
      <Paragraph position="15"> 10 In a full treatment the default semantics would also contain a quantifier. In fact the implicit object must have narrow scope existential quantification. Combining YADU with a semantic representation capable of representing quantifier scope in an underspecified fashion means that this can be made to follow from a general default assignment of scope. However the details are outside the scope of this paper.  Computational Linguistics Volume 25, Number 1 5. Theoretical and Practical Complexity Issues Whe&lt;n&gt; discussing the complexity properties of YADU, we have to distinguish between the N operation, which involves the combination of two TDFSs, and DefFS, the calculation of the default structure from a TDFS. One reason for drawing this distinction is that, in a practical system, it may be necessary to carry out the former operation much more frequently than the latter. As we mentioned in Section 3, it is only necessary to construct the default feature structure at some interface: for example, at the interface between the lexicon and the parser/generator (as in the examples in Sections 4.1, 4.2, and 4.3) or between the grammar and the pragmatic component (as in the examples in Section 4.4). In fact, only one DeJFS operation is necessary per lexical entry (or other gran~nar object), regardless of the depth or complexity of the inheritance hierarchy. Similarly, one DeJFS is required per parse for the use of persistant defaults. This is fortunate, since the combination operation has considerably better complexity properties than the calculation of the default structure.</Paragraph>
      <Paragraph position="16"> simply involves unification of typed feature structures, set union of tails, and removal of tail elements that are incompatible with the indefeasible structure. Checking path-value tail elements for unifiability with the indefeasible structure involves checking one pair of types to see if they are compatible. Checking path-equivalence elements is roughly equivalent to unifying the relevant parts of the indefeasible structure: in the worst case this could amount to unifying two TFSs of (n - 1)/2 nodes each per tail-element, where n is the number of nodes in the indefeasible structure. But, although we defined H as requiring the elimination of tail elements that are incompatible with the default, we could equivalently have left this to the DefFS operation, and simply accumulated tail elements via set union. This is an insignificant overhead on normal unification, since the tail elements have very simple structures.</Paragraph>
      <Paragraph position="17"> In contrast, the worst-case properties of the calculation of the default TFS are unpleasant. Recall that this operation involves partitioning the tail and then carrying out a step similar to asymmetric default unification as described by Carpenter (1993) for each partition. The only known algorithms for computing asymmetric default unification are factorial in the number of atomic FSs in the worst case (Carpenter 1993). Thus, for a partition with t tail elements, the worst-case performance is proportional to t! in the number of individual unification operations, where each unifcation could involve up to (n - 1)/2 nodes, as above.</Paragraph>
      <Paragraph position="18"> In practice, YADU is much better behaved on realistic examples than this would suggest. The first point to make is that, as far as operations on TFSs themselves are concerned, the DefFS operation can be implemented as a series of normal unification steps. One consequence of this is that the use of YADU does not incur any significant overhead with respect to ordinary unification when there are no tail elements. The only additional requirement for YADU is that there be a slot at the top level of an object's representation to store its tail. We mention this because it contrasts with some other extensions to TFS formalisms: implementations of disjunction, for example, generally require that the TFS data structures and unification algorithms be considerably more complex, with a consequent overhead in performance even for nondisjunctive structures. Another mitigating factor is that it is easy for a grammar writer to tell in advance whether a particular use of defaults is likely to be computationally expensive. The worst-case complexity behavior only occurs in situations where there are interactions between path equivalence statements that are not resolved by specificity. While it is possible to invent pathological examples that have very deleterious performance characteristics, it is not clear that comparable cases will often arise in real grammars, especially if defaults are being used in a rather conservative fashion to extend a mono-</Paragraph>
    </Section>
    <Section position="5" start_page="94" end_page="94" type="sub_section">
      <SectionTitle>
Lascarides and Copestake Default Representation
</SectionTitle>
      <Paragraph position="0"> tonic core grammar. Consider the example in Section 4.1, for instance. There is only a single path value element in the tails of any of the structures described, and this will straightforwardly either conflict or be compatible with an indefeasible atomic value.</Paragraph>
      <Paragraph position="1"> Indeed in examples like this, the reduction in the numbers of types involved compared to the purely monotonic encoding could potentially lead to an efficiency gain.</Paragraph>
      <Paragraph position="2"> As we mentioned above, since PDU is polynomial, it has much better worst-case behavior than YADU. However, making a realistic comparison is not straightforward.</Paragraph>
      <Paragraph position="3"> The combination operation in PDU is more complex than in YADU, since it is necessary to calculate default TFSs at every stage as well as tails. The constant overhead compared to ordinary unification is higher and the implementation of PDU is trickier than YADU. Furthermore, there is a trade-off between complexity behavior and intuitiveness. The reason that PDU has better complexity behavior is that it always accumulates default reentrancies. If there is a clash with default values, the default reentrancies win--if there is a clash with indefeasible values, the coindexed nodes in the default structure are set to 3_, indicating inconsistency, and the DefFill operation must subsequently take care of constructing a valid TFS by removing the default path equivalences. However, this can lead to cases where potentially valid default path equivalences are removed.</Paragraph>
      <Paragraph position="4"> Thus, in PDU the sort of example that leads to the factorial worst-case complexity in YADU is treated specially, in that maximal information is not incorporated from the default structure. Roughly speaking, for these corner cases, there is a trade-off between the complexity behavior in YADU, and the complex behavior of PDU. 11 But our main practical reason for preferring YADU over PDU is that PDU can behave in unintuitive ways in examples where YADU would have nonproblematic complexity behavior. It is also worth noting that YADU will not be slow if the tail partitions are kept small, which is something the grammar writer can control.</Paragraph>
    </Section>
  </Section>
class="xml-element"></Paper>