<?xml version="1.0" standalone="yes"?>
<Paper uid="W98-1423">
  <Title>APPROACHES TO SURFACE REALIZATION WITH HPSG</Title>
  <Section position="4" start_page="219" end_page="220" type="metho">
    <SectionTitle>
2 Head-.Driven Generation (I)
</SectionTitle>
    <Paragraph position="0"> Head-driven generation algorithms (van Noord, 1990) are based on systematic sharing of logical form between the mother and one of the daughters, the semantic head daughter, in grammar rules. Given a suitable grammar with such Systematic sharing, these algorithms are very efficient, especially when implemented with a chart (Haruno et ah, 1996; Wilcock and Matsumoto, 1996) *. The question is, are HPSG grammars suitable in this sense? This question is addressed by Wilcock and Matsum0to (1998), who point Out that semantic head-driven generation with HPSG should be easy to implement because semantic heads are very clearly defined in HPSG (in head-adjunct phrases, the adjunct daughter is the semantic head; in other headed phrases, the syntactic head daughter is the semantic head) and in both cases, the HPSG Semantics Principle requires the semantic content of the semantic head to be identical to the semantic content of the mother. Therefore, taking this semantic content to be the logical fornL HPSG appears to be extremely suitable for semantic head-driven generation. The Semantics Principle means that, apart from coordinate structures, all grammar rules must include the sharing of logical form required for head-driven generation.</Paragraph>
    <Section position="1" start_page="219" end_page="219" type="sub_section">
      <SectionTitle>
2.1 BUGI and HPSG
</SectionTitle>
      <Paragraph position="0"> The simplest version of a head-driven generation algorithm Was specified by van Noord (1990) as the BUG1</Paragraph>
      <Paragraph position="2"> connect(Small, Node).</Paragraph>
      <Paragraph position="3"> connect(Node, Node).</Paragraph>
      <Paragraph position="4"> connect(Small, Big) &amp;quot;predict_rule(Small,Middle,Others,Big), null gen_ds(Others), connect(Middle, Big).</Paragraph>
      <Paragraph position="5"> gen_ds ( \[\] ).</Paragraph>
      <Paragraph position="6"> gen_ds(\[Node\]Nodes\]) :bugl(Node), null gen_ds(Nodes).</Paragraph>
    </Section>
    <Section position="2" start_page="219" end_page="220" type="sub_section">
      <SectionTitle>
2.2 Problems with Quantifiers and Context
</SectionTitle>
      <Paragraph position="0"> This very simple approach to head-driven generation with HPSG works successfully, if all the information required for generation is supplied as part of the initial logical form, and if this logical form call be identified with semantic content in the HPSG granunar, In particular, the initial logical form must be unifiable with the CONTENT feature of some appropriate lexical item which can serve ms the pivot for the generation algorithm. However, this over-simplifies the way semantic information is represented in HPSG.</Paragraph>
      <Paragraph position="1"> Wilcock and Matsumoto (1998) point out two severe difficulties for head-driven generation with HPSG.</Paragraph>
      <Paragraph position="2"> The first problem is how to handle quantifier scoping. Unscoped quantifiers are stored in the QSTORE feature, which is not part of CONTENT. At *some point in a syntactic derivation, a quantifier is retrieved from the *store and moved to the QUANTS feature, which is inside CONTENT. In the grammar rule which licenses this part of the derivation , the CONTENTof the mother includes the quantifier, but the CONTENT of the semantic head daugllter does not, so the daughter is not the semantic head as required by the generation algorithm.</Paragraph>
      <Paragraph position="3"> The second problem is how to handle contextual background conditions, such as tile assumption that the personreferred to by she is female. In HPSG, these conditions are specified in BACKGR, Which is part. of CONTEXT and is not part of CONTENT at all..If the conditions are included in the initial logical form, it.</Paragraph>
      <Paragraph position="4"> will not. be unifiable with the CONTENT feature of the semantic head, whose CONTENq does not include</Paragraph>
      <Paragraph position="6"> CONTEXT features. As Wilcock and Matsumoto (1998) point out, even a simple sentence such as She saw Kim cannot be generated with this approach to head-driven generation with HPSG.</Paragraph>
    </Section>
  </Section>
  <Section position="5" start_page="220" end_page="221" type="metho">
    <SectionTitle>
3 Head-Driven Generation (II)
</SectionTitle>
    <Paragraph position="0"> In order to use a semantic head-driven generation algorithm with HPSG, while including unscoped quantifiers and contextual backgrounds, the role of semantic heads in the grammar needs to be consolidated, as proposed by Wilcock (1997). The problem is that semantic information in standard HPSG (Pollard and Sag, 1994) is fragmented into quantificational content, nuclear content, and context. Only nuclear content is consistently shared between the mother and the semantic head daughter, but nuclear content contains no more tha:n referential indices attached to semantic roles. Quantificational content may or may not be shared, depending on whether quantifiers are retrieved. Contextual background is gathered from all daughters, with no special role for the semantic head.</Paragraph>
    <Paragraph position="1"> The problem is in the mechanism for collecting together the quantifiers and background conditions of a phrase. In standard HPSG,-a phrase's set of unscoped quantifiers (QSTORE) must be the union Of the QSTOREs of the phrase's daughters (minus any quantifiers which are retrieved), and a phrase's set of contextual background conditions (BACKGR) must be the union of the BACKGRs of the phrase's daughters.</Paragraph>
    <Paragraph position="2"> This is known as phrasal amalgamation.</Paragraph>
    <Paragraph position="3"> In contrast to this, head-driven generation requires all semantic information- nuclear, quantificational and contextual - to be shared between the mother and the semantic head, with semantic heads thereby playing a key role in the grammar. This requires the lexicalization of quantifier scoping, and the lexicalization of context, as described by Wilcock (1997). Basically, this means that a word's QSTORE nmst be the union of the QSTOREs of the word's arguments, and a word's BACKGR must be the union of the BACKGRs of the word's arguments. These requirements take the form of lexical constraints in HPSG theory, and this mechanism is known as lc:rical amalgamation.</Paragraph>
    <Section position="1" start_page="220" end_page="221" type="sub_section">
      <SectionTitle>
3.1 Lexical mnalgamation in ProFIT
</SectionTitle>
      <Paragraph position="0"> A ProFIT implementation of lexical amalgamation is shown in Figure 3, from (Wilcock and Maisumoto, 1998). In lhe lexical entry for the verb saw, QSTORE sets and BACKGR sets are Prolog difference lists.</Paragraph>
      <Paragraph position="1"> The subject's BACI(GR set B0-B1 and the object's BACI(GR set B1-BN are amalgamated in the verb's BA('KGR set t30-BN. The subject and object. QSTORE sets. Q0-Qt and Q1-QN, are similarly amalgamated in the verb's QSTORE QO-QN.</Paragraph>
      <Paragraph position="2"> lex( phon!\[sa~\[X\]-X a @verb &amp;</Paragraph>
      <Paragraph position="4"> The basic Semantics Principle, for semantic content only. was implemented by tile template 'SetuP' shown in Figure 1. In order to ensure the required sharing of unscoped quantifiers and background .conditions between a phrase and its semant.ic hcad, the Semamics Principle is extended, as proposed by Wilcock (1997), to three principles: Semantic Itead Inheritance Principle (StIIP). Quantifier Inheritance Principle (QUIP).</Paragraph>
      <Paragraph position="5">  and Contextual Head Inheritance Principle (CHIP). These are implemented by templates as shown in Figure 3, and the three principles are included in the grammar by the modified template for hd:.aexus_ph, which replaces the earlier template in Figure 1. With these revisions, it is possible to include unscoped quantifiers and background conditions in the starting logical form, and perform head-driven generation successfully using the BUG1 generator.</Paragraph>
    </Section>
  </Section>
  <Section position="6" start_page="221" end_page="223" type="metho">
    <SectionTitle>
4 Bag Generation
</SectionTitle>
    <Paragraph position="0"> We now switch to non,head-driven approaches. Phillips (1993) proposed a bottom-up chart generation algorithm for use With indexed logical forms and categorial grammar in machine translation. An important property of the algorithm is that the Order of terms in the logical form is not significant. The name bag generation is adopted from related work on shake-and-bake machine translation.</Paragraph>
    <Paragraph position="1"> We now show how Phillips' algorithm can-be used with HPSG grammar; with a bag of MRS relations instead of a bag of indexed logical terms. Though he presents the algorithm as a generator for categorial grammar, PhilliPs suggests that it can be adapted for use with phrasestructure grammar (PSG), provided an indexed logical form is used -and the indices are included in the syntactic categories. HPSG uses indices for agreement, and therefore includes the indices inside syntactic categories. By implementing HPSG as a PSG extended with typed feature structures (Sect.ion 1.2), and by implementing MRS as a similarly ext.ended :indexed QLF (SeCtion 4.2), we can adapt* Phillips I algorithm for use with HPSG. .:</Paragraph>
    <Section position="1" start_page="221" end_page="221" type="sub_section">
      <SectionTitle>
4.1 A Simple Bag Generator
</SectionTitle>
      <Paragraph position="0"> The adapted algorithm is shown in Figure 4. \Ve use simple chart processing from the bottom-up chart.</Paragraph>
      <Paragraph position="1"> parser of Gazdar and Mellish (1989). The main work is done by start_gen, which looks up the next term in the list of semantic tern)s, adds appropriate edges to the chart, and calls itself recursively on the remaining terms. Generation finishes when all edges have been built, and is successful if an inactive edge &amp;quot;'spans&amp;quot; the Whole input semantics, i.e. if an inactive edge's semantics are a laermufalion of the input, semantics.</Paragraph>
      <Paragraph position="2"> permutation/2:is a library predicate.</Paragraph>
      <Paragraph position="4"> The algorithm assumes that Categories include surface strings and semantics as wellas syntactic information (HpSG has Category sign,.with string in PHON and semantics in CONTENT). For a part.icular grammar, the predicates string and semantics extract the string and semantics from the Category, giving a clean interface between the algorithm and the grammar. For a particular lexicon, lookup_term returns the Category of a lexical entry which includes the given semantic predicate, giving an interface between the algorithm and the lexicon.</Paragraph>
    </Section>
    <Section position="2" start_page="221" end_page="221" type="sub_section">
      <SectionTitle>
4.2 MRS and QLF
</SectionTitle>
      <Paragraph position="0"> MRS (Copestake et. al., 1997) is a new semantic representation for use with HPSG. Like the indexed QLF of\[ ) ~illips.(.19.9:~,). Ml(..q was moliv;m:.d I,.v the nee(Is of machine translation, where &amp;quot;flat&amp;quot; representations</Paragraph>
      <Paragraph position="2"> are preferred over strongly head-driven representations, as the head in one language may not correspond to the head in another language. Like the QLF, MRS depends on the use of indices to represent dependencies between the terms in the fiat list. HPSG previously used indices only for entities of type nominal_object, to assign them to semantic roles as participants in states of affairs and to carry agreement features. In MRS, indices are also used for events, as in the QLF.</Paragraph>
      <Paragraph position="3"> A major difference between MRS and the QLF is that MRS uses typed feature structures instead of ordinary logical terms. Each element in the list is an HPSG typed feature structure of type relation. This facilitates the integration of MRS into HPSG. While the QLF logical terms could be represented in Prolog, we need ProFIT to extend the terms with typed feature structures for MRS. We thus implement MRS as an extension of QLF in the same way that we implement HPSG as an extension of PSG.</Paragraph>
      <Paragraph position="4"> Another major difference, which makes MRS a significant improvement over the QLF, is that MRS supports the representation of quantifier scope (either fully resolved or underspecified). This is done by including handles which label each term in the list. Scope can be represented by means of the handles, while maintaining the flat list representation, without the nesting required when operators are used to represent scope. As a musical joke about semantic composition, the handle feature is named HANDEL and the list feature is named LISZT.</Paragraph>
    </Section>
    <Section position="3" start_page="221" end_page="223" type="sub_section">
      <SectionTitle>
4.3 Non-Head-Driven Semantics
</SectionTitle>
      <Paragraph position="0"> In the semantics of Pollard and Sag (1994), which was derived from Situation Semantics, semantic ,composition is performed by recursive unification of semantic feature structures, to produce a single complex semantic feature structure in the semantic head. This semantic structure is structure-shared between a phrase and its semantic head daughter, by the Semantics Principle. This form of semantic representation is therefore suitable for semantic head-driven generation.</Paragraph>
      <Paragraph position="1"> By contrast, in the fiat MRS representation, semantic composition is performed by concatenation of the LISZTs of a phrase's daughters to give the LISZT of the mother. The LISZT of the semantic head daughter will not be the same as the LISZT of the mother. MRS is therefore suitable for bag generation, but not for head-driven generation 1. The Semantics Principle must be scrapped or redefined. We show a simple revision of 'SetuP' in Figure 5, in which INDEX and HANDEL (but not LISZT) are shared between mother and semantic head, in contrast to 'SetuP' in Figure 1 which shares the whole * CONTENT structure.</Paragraph>
      <Paragraph position="3"> We use Prolog difference lists to implement the LISZT feature for efficient concatenation, as we did with PHON. In the case of LISZT, the predicate semantics hides this representation from the algorithm. LISZT concatenation is added to the PSG rules for HPSG schemata, as shown in Figure 5.</Paragraph>
      <Paragraph position="4"> A full MRS representation includes a top-level handle and a top-level index, which are specified separately from the flat list'of terms. A top-level index is also mentioned by Phillips (1993). We have ignored these in the bag generation algorithm, to simplify adaptation to incremental generation in Section 5. However, the top-level index specifies what the semantics is about. For example, a simple QLF representation: \[man(m), t~alk(e,ra)'l could mean either &amp;quot;A man walked&amp;quot; or &amp;quot;A man who walked&amp;quot;. These are only distinguished by the top-level index (e or m respectively). In this respect, the top-level index specifies the topic, part of information structure, which we will come back to in Section 5.3.</Paragraph>
      <Paragraph position="5"> 1Head-driven generation with MRS would require the lexical amalgamation of LISZT.</Paragraph>
      <Paragraph position="6">  !</Paragraph>
    </Section>
  </Section>
  <Section position="7" start_page="223" end_page="225" type="metho">
    <SectionTitle>
5 Incremental Generation
</SectionTitle>
    <Paragraph position="0"> A variant of Phillips' algorithm was used in PLUS (a Pragmatics-based Language Understanding System) for surface generation of dialogue responses from an indexed QLF using a categorial grammar. Jokinen (1996) gives an overview of the PLUS system, and describes the planning of dialogue responses to be passed to the surface generator as indexed QLF representations. Lager and Black (1994), discussing&amp;quot;the PLUS surface generator, suggest that the algorithm and the QLF are suitable for incremental generation.</Paragraph>
    <Paragraph position="1"> We now show how the bag generation algorithm can be modified for incremental generation with HPSG andMRS, and discuss differences between categorial grammar and HPSG which incremental generation emphasises. From an incomplete bag and a partial utterance, the generator attempts to continue the utterance as further semantic terms are added. We include a simple form of repair when the generator cannot find a way to continue the utterance. We ignore the issue of real-time processing here, and deal only with order of inputs and outputs. Though the order of terms in the bag is not itself significant, the order in which terms are added influences the utterance very strongly.</Paragraph>
    <Paragraph position="2"> * 5.1 An Incremental Algorithm :: The basic incremental algorithm is shown in Figure 6. incremental_gen is initialized with an empty bag of semantic terms and an empty list of strings uttered so far. The procedure inputs a new semantic term, looks it up in the lexicon, and adds a new edge for each word found, thereby triggering construction of further edges. When all edges have been built, the procedure calls utter and then recursively calls itself with the augmented bag of terms and the augmented list of strings uttered.</Paragraph>
    <Paragraph position="3"> incremental_generation :- incremental_gen(SemO ,PhonO) :abolish(edge ,2), input_t erm(Term),  A set of utterance rules is shown in Figure 7, numbered from 1 to 4. Each rule is attempted, in the order given, until an utterance is produced, or the default rule 4 is reached, which simply utters nothing and allows incremental.gen to input another semantic term.</Paragraph>
    <Paragraph position="4"> Utterance Rule 1 succeeds if it finds an inactive edge (a coinplete syntactic constituent) which spans the bag of semantic terms, and whose PHON list is a continuation of the list uttered so far. If so, tile new part of PHON is outPut by utter_continue. (An edge &amp;quot;spans&amp;quot; a bag of terms if its own semantics is a permutation of the terms in the bag): Utterance Rule 2 performs a simple form of repair, when there is a complete syntactic constituent which spans the semantics, but its PHON does not continue the utterance which has been started. In this case, utter_.repair finds the minimum backtracking change needed to effect the repair, and utters the new part only, preceded by &amp;quot;Er,...&amp;quot;.</Paragraph>
    <Paragraph position="5"> If there is no complete syntactic constituent which spans the bag of terms, we could wait (Rule 4), or, if we want the generator to be more &amp;quot;talkative&amp;quot;, we can use active edges from the chart. Utterance Rule 3 continues the utterance with any active edge whose semantics matches the new semantic term. The best set of rules needs to be found by further work.</Paragraph>
    <Paragraph position="6"> 5.2- Categorial Grammar and HPSG Previous work on incremental generation has usually assumed that Utterances must correspond to syntactic constituents. For example, discussing the possible adaptation of Phillips' algorithm to incremental generation, Lager and Black (1994) point out that some versions of Categorial Grammar (CG) would make the generator more talkative, by giving rise to &amp;quot;a more generous notion of constituency&amp;quot;. However, in order to use HPSG for incremental generation, we must challenge the underlying assumption.</Paragraph>
    <Paragraph position="7"> The basic approach to combining a head (verb) with its arguments (subject and complements) is significant here. Whereas in CG a head -may be combined with its arguments one by one, giving a series of unsaturated 224.</Paragraph>
    <Paragraph position="8">  intermediate constituents until a saturated one is completed, in HPSG a head (a verb) is usually combined first with all Of its complements in one constituent (a VP), and then this is combined with the subject. In incremental generation of English, after the subject has been generated, further semantic input may enable the verb to be generated next. In this case, CG may allow the subject and verb to be combined into a valid syntactic constituent, but HPSG will not recognise this as a constituent. If an incremental generator only Utters valid constituents, an HPSG-based generator must wait, after uttering the subject, until all the complements of the verb have been identified, before uttering the verb as part of the complete verb phrase. This is a significant problem in using HPSG for incremental generation.</Paragraph>
    <Paragraph position="9"> However, in deciding what units should be uttered it is information structure which should be decisive, not syntactic constituency. From this point of view, which we will discuss in the next sectionl the problem with HPSG's notion of constituency can be reduced toa computational matter. As the verb is put into the chart as an active edge before its complements are identified, it can also be uttered, if desired, without waiting for the VP edge to be completed. This may be computationally slightly awkward, but it is feasible.</Paragraph>
    <Section position="1" start_page="223" end_page="225" type="sub_section">
      <SectionTitle>
5.3 Information Structure
</SectionTitle>
      <Paragraph position="0"> The incremental system described so far does not take information structure into account, but is driven purely by the order in which semantic terms are supplied. In a &amp;quot;shallow&amp;quot; system (for example, a simultaneous interpretation system) it may be necessary to rely on the order to implicitly realize information structure, but if the system includes &amp;quot;deep&amp;quot; processing, with logical inferencing, then it is not satisfactory to rely on the order in which an inference component happens to produce its results. Such a system needs ezplici~ management of information structure.</Paragraph>
      <Paragraph position="1"> Engdahl and Vallduvi (1996) argue that information structure is a distinct dimension, and locate INFO-STRUCT in the HPSG CONTEXT feature rather than CONTENT. However, the representation they propose is purely syntactic: Link (topic) and Focus are equated with syntactic constituents (NPs and VPs) which realize the topic concept and the focus information. In a footnote, they accept that it would be more appropriate for the value of INFO-STRUCT to be structure shared with the value of CONTENT.</Paragraph>
      <Paragraph position="2"> Steedman (199.1) argues that there is a correspondence between information structure, intonation and syntactic constituency, and it is a strength ofCG that it allows suitable syntactic constituents: Engdahl and Vallduvi (1996) argue that there is no correspondence between information structure and syntactic constituency, and that it is a strength of HPSG's multidimensional representation that we are not forced to assume such a correspondence.</Paragraph>
      <Paragraph position="3"> Perhaps both approaches over-emphasise the role of Syntaxl in an area where semantics and pragmatics should be more central. In the PLUS system, a pragmatics-based Dialogue Manager (Jokinen, 1996) explicitly manages information structure, using a semantics-based representation. Central Concept (topic) and Newlnfo (focus) are represented using QLFs with explicit indices for discourse referents. This facilitates  distinguishing old and new information, but the QLF lacks explicit representation of scope. This suggests that it would be interesting to include focus scope (&amp;quot;narrow focus&amp;quot; and &amp;quot;wide focus&amp;quot;) in an MR.S-based representation with HPSG, in a similar way to quantifier scope.</Paragraph>
      <Paragraph position="4"> Response planning in the PLUS Dialogue Manager always stares from NewInfo, adding other content (such as Central Concept linking) only when necessary. This gives rise to natural, elliptical surface generation. It also makes possible a proper approach to time constraints. This approach to generation from NewInfo has been developed further by Jokinen et al. (1998).</Paragraph>
    </Section>
  </Section>
  <Section position="8" start_page="225" end_page="225" type="metho">
    <SectionTitle>
6 Other Approaches
</SectionTitle>
    <Paragraph position="0"> In conclusion we take a brief look at some other approaches. One approach to generation is to take a grammar which was developed for parsing, and invert it for generation. Since most existing HPSG grammars were developed for parsing, this approach has a point. It has been applied to HPSG by Wintner et al. (1997).</Paragraph>
    <Paragraph position="1"> Their work is also representative of the recent development of new implementations for ttPSG based on abstract machines, which are expected to supercede the current Prolog-based implementations such as the ProFIT system used here.</Paragraph>
    <Paragraph position="2"> As noted in the introduction, another approach is to convert HPSG into TAG (Kasper et al., 1995) for generation. Similar work on compiling HPSG for efficient parsing (Torisawa and Tsujii, 1996) should be equally applicable to generation.</Paragraph>
    <Paragraph position="3"> Finally, we come back to Systemic Functional Grammar (SFG) which we contrasted with HPSG in the introduction. Since SFG and HPSG share a similar underlying logic of typed feature structures, it should be possible to use tools such-as ProFIT and AMALIA (Wintner et al., 1997) for SFG, by implementing the system network as a type hierarchy.</Paragraph>
    <Paragraph position="4"> A more surprising approach would be tO attempt to use a systemic generation algorithm with an HPSG grammar. A systemic generation algorithm traverses the system network, making choices within the systems as it goes, and collecting realization rules which will decide the final output: To apply this to HPSG would mean implementing the HPSG type hierarchy as a system network, and traversing it with a systemic generation algorithm, making choices within the subtypes as it goes, and collecting type constraints which will decide the final output.</Paragraph>
  </Section>
class="xml-element"></Paper>