<?xml version="1.0" standalone="yes"?>
<Paper uid="W05-1623">
  <Title>Reversibility and Re-usability of Resources in NLG and Natural Language Dialog Systems</Title>
  <Section position="4" start_page="0" end_page="0" type="metho">
    <SectionTitle>
2 A Formal Description of Reversibility
</SectionTitle>
    <Paragraph position="0"> In this section, we will provide a formal deflnition of reversibility which is based on previous work [Neumann and van Noord, 1994]. To this end, we will flrst give a short overview of the results obtained there in sect.</Paragraph>
    <Paragraph position="1"> 2.1. After that, we will present our extended deflnition in sect. 2.2.</Paragraph>
    <Section position="1" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
2.1 Previous deflnitions of Reversibility
</SectionTitle>
      <Paragraph position="0"> In [Neumann and van Noord, 1994], a deflnition of reversibility for programs is provided. The authors start with a deflnition for computing a relation r in both directions (def. 1).</Paragraph>
      <Paragraph position="1"> Deflnition 1. (Computing a relation in both directions according to Neumann and van Noord) A program P computes a relation r in both directions, ifi for a given input hdir; ei it recursively enumerates the set fx j (he; xi 2 r ^ dir = 0) _ (hx; ei 2 r ^ dir = 1)g. In this deflnition, the parameter dir denotes the direction in which the input is computed, and e represents the content of the input for which the appropriate output has to be obtained.</Paragraph>
      <Paragraph position="2"> Let us state a simple corollary to def. 1 which relates the notion of computing a relation in both directions to the notion of inverse relations.</Paragraph>
      <Paragraph position="3"> Corollary 1. A program P computes the relation r in both directions, if P computes r and the inverse relation of r, r!1.</Paragraph>
      <Paragraph position="4"> Proof. According to def. 1, P recursively enumerates the set fx j he; xi 2 rg for dir = 0 and the set fx j hx; ei 2 rg for dir = 1. Hence, it computes r for dir = 0 and (using the standard deflnition of inverse relations) r!1 for dir = 1.</Paragraph>
      <Paragraph position="5"> Based on def. 1, the following deflnitions for rreversibility of programs and relations are provided in [Neumann and van Noord, 1994] (def. 2).</Paragraph>
      <Paragraph position="6"> Deflnition 2. (Reversibility of programs and relations according to Neumann and van Noord)  1. A program P is r-reversible if it computes r in both directions.</Paragraph>
      <Paragraph position="7"> 2. A relation r is reversible ifi an r-reversible program exists.</Paragraph>
      <Paragraph position="8">  The notion of reversible programs in def. 1 and 2 is very general: In an extreme case, such a program can consist of two completely independent parts tied together only by an initial conditional statement. This statement decides, depending on the value of the direction parameter dir, whether the program part computing relation r (for dir = 0) or the one computing r!1 (for dir = 1) is used. In our opinion, such a program should not be called reversible any more. Hence, deflnitions 1 and 2 are too general.</Paragraph>
      <Paragraph position="9"> On the other hand, they are too speciflc; this is due  to three reasons: 1. Program and data are not distinguished.</Paragraph>
      <Paragraph position="10"> 2. Thus, difierent resources and resource types1 are also not addressed.</Paragraph>
      <Paragraph position="11"> 1such as linguistic and pragmatic resources 3. The availability time for a program or a resource2 is not considered.</Paragraph>
      <Paragraph position="12">  Hence, in the next section we will replace these definitions by a more general description of reversibility for generic program systems before we will describe reversibility in current NLDSs.</Paragraph>
    </Section>
    <Section position="2" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
2.2 Extended deflnition of reversibility
</SectionTitle>
      <Paragraph position="0"> In this section, we will present our deflnition of reversibility. We start with deflnitions of a generic program sys- null tem and of system and program relations (def. 3).</Paragraph>
      <Paragraph position="1"> Deflnition 3. (Program system, system relations, and program relations) 1. A program system S consists of a triplet (COMPS; PROGS; RESS) of (a) a set of preprocessing programs COMPS = fC1; : : : ; Ckg which are executed before system start, (b) a set of runtime programs PROGS = fP1; : : : ; Plg, (c) and a set of resources RESS = fR1; : : : ; Rmg. 2. The set of relations RELS = fr1; : : : ; rng computed by the programs of PROGS is called the set of system relations of S.</Paragraph>
      <Paragraph position="2"> 3. The set of relations RELP = fr1; : : : ; rpg computed by a single program Pi 2 PROGS is called the set  of program relations of P.</Paragraph>
      <Paragraph position="3"> By resources we denote every data structure needed by a runtime program for its execution3. More precisely, the resource RPi;rk provides a necessary (but not su-cient) condition for the runtime program Pi to compute one of its program relations rk. All of these resources must be available at system start, but they may be generated by preprocessing programs.</Paragraph>
      <Paragraph position="4"> Before we can state our deflnition of reversibility, we have to give a formal description of inverse programs and resources (def. 4).</Paragraph>
      <Paragraph position="5"> Deflnition 4. (Inverse program and inverse resource) Let S be a program system, R 2 RESS a system resource, and P 2 PROGS a program with a program relation r 2 RELP . Let R be a resource needed by P for  computing r.</Paragraph>
      <Paragraph position="6"> 1. Then every program P!1 computing the inverse relation r!1 is called an inverse program to P with respect to r.</Paragraph>
      <Paragraph position="7"> 2. The transformation of a resource R needed by P!1  to compute r!1 is called inverse resource R!1 to R with respect to r.</Paragraph>
      <Paragraph position="8"> A simple corollary relates self-inverse programs to r-reversible programs.</Paragraph>
      <Paragraph position="9"> 2i.e. whether it is available only at runtime or already at compile time 3contrary to the terminology used e.g. in operating systems programming Corollary 2. If P * P!1 holds, i.e. if P is self-inverse with respect to r, then P is r-reversible.</Paragraph>
      <Paragraph position="10"> Proof. If P computes r, P!1 computes r!1, and P * P!1 holds, then P computes r!1 as well. Then, according to def. 1, P computes r in both directions, and with def. 2 P is r-reversible.</Paragraph>
      <Paragraph position="11"> Algorithmic reversibility For any program system of def. 3, we deflne algorithmic reversibility in the following way (def. 5). Deflnition 5. (Algorithmic reversibility) Let S be a program system, P 2 PROGS a program in S, and r 2 RELP a program relation of P.</Paragraph>
      <Paragraph position="12"> Then S is algorithmic-reversible in P and r if P is r-reversible.</Paragraph>
      <Paragraph position="13"> Hence, P (and no other program Q 2 PROGS with Q 6= P)4 has to compute r and r!1 as well.</Paragraph>
      <Paragraph position="14"> Data reversibility Data reversibility, the counterpart of algorithmic reversibility, can be deflned as follows (def. 6). Deflnition 6. (Data reversibility) Let S be a program system, R 2 RESS a system resource of S, and r 2 RELS a system relation of S. Then S is data-reversible to R and r if two programs P1; P2 2 PROGS exist which both need R to be executed and for both of which r 2 RELP1 and r!1 2 RELP2 holds.</Paragraph>
      <Paragraph position="15"> Thus, P1 must compute r using R, and P2 must compute the inverse relation r!1 (also by using R). If</Paragraph>
      <Paragraph position="17"> and r.</Paragraph>
      <Paragraph position="18"> Static and dynamic reversibility A difierent dimension of reversibility dealing with the availability time of a program or a resource can be described as follows (def. 7).</Paragraph>
      <Paragraph position="19"> Deflnition 7. (Static and dynamic reversibility) Let S be a program system, R 2 RESS a system re- null source and r 2 RELS a system relation of S. 1. S is static-reversible with respect to R and r if (a) a program P 2 PROGS with r 2 RELP exists which needs R for its execution, (b) also r!1 2 RELS, P!1 2 PROGS, and R!1 2 RESS holds, and additionally (c) at least one preprocessing program C 2 COMPS is needed for the construction of R!1 from R or of P!1 from P.</Paragraph>
      <Paragraph position="20"> 2. If no such program C is needed, S is called  dynamic-reversible with respect to R and r. 4By Q 6= P we denote syntactic in-equivalence here. This is easily decidable, whereas semantic equivalence of programs is certainly not.</Paragraph>
      <Paragraph position="21"> If, under the preconditions of def. 7, the inverse program P!1 is constructed, S is also algorithmic-reversible with respect to P and r. However, if the inverse resource R!1 is constructed, S is data-reversible with respect to R and r. Obviously, both algorithmic and data reversibility can occur simultaneously.</Paragraph>
    </Section>
  </Section>
  <Section position="5" start_page="0" end_page="0" type="metho">
    <SectionTitle>
3 Reversibility in Dialog Systems
</SectionTitle>
    <Paragraph position="0"> Consider the special relation sp!s between phonetic and semantic structures. This is the relation computed by the analysis part of a natural language dialog system (NLDS). By applying our deflnitions of reversibility presented in sect. 2.2 on sp!s, we face an important question of natural language processing: To what extent is a given NLDS reversible? But before we consider this question in more detail, we have to deflne our notion of an NLDS flrst. Based on def. 3, we formally describe an NLDS as follows (def. 8).</Paragraph>
    <Paragraph position="1"> Deflnition 8. (NLDS) Let rp!s be the relation between phonological and semantic structures and r!1p!s the inverse relation of rp!s.5 An NLDS is a program system S with rp!s 2 RELS and r!1p!s * rs!p 2 RELS.</Paragraph>
    <Paragraph position="2"> Hence, an NLDS must contain both the relations rp!s and rs!p as system relations. This is quite obvious, since natural language dialog requires both natural language understanding (NLU) and natural language generation (NLG).</Paragraph>
  </Section>
  <Section position="6" start_page="0" end_page="0" type="metho">
    <SectionTitle>
4 Classiflcation of Reversibility Types
</SectionTitle>
    <Paragraph position="0"> As we have seen in the previous sections, generic program systems and NLDSs in particular can be reversible in two independent dimensions: On the one hand, they can be static or6 dynamic, and on the other hand, algorithms and/or data can be reversible. Given that a system may also be not reversible at all in both dimensions just mentioned, we obtain a classiflcation of nine possible reversibility types.</Paragraph>
    <Paragraph position="1"> [Neumann, 1994], however, describes just four types of reversibility in dialog systems and takes only the grammar as a linguistic resource into account: Type A has static reversibility (in terms of data and algorithms), while type B has dynamic data reversibility. Type C has statistically reversible data and dynamically reversible algorithms, while type D has dynamic data and algorithmic reversibility.</Paragraph>
    <Paragraph position="2"> By further exploring the notions of algorithmic and data reversibility introduced above, both of which can be realized in three difierent variants (none, static, and dynamic), we are able to extend the classiflcation in [Neumann, 1994] by two more types: Type E is statically re- null extended classiflcation of reversible dialog systems is depicted in flg. 1.</Paragraph>
    <Paragraph position="3"> There are three more possible types in our classiflcation, all of them without data reversibility: Type G has statically and type H dynamically reversible algorithms, whereas type I does not have any reversibility at all. While types G and H are just not desirable for real-world NLDSs, type I is even unacceptable. Hence we decided to exclude types G, H, and I from flg. 1 and depict them separately in flg. 2. However, the legend displayed there applies to flg. 1 as well.</Paragraph>
    <Paragraph position="4"> It has to be pointed out here that any classiflcation of reversible dialog systems must not be restricted to the grammar, but has to be extended to the other resources used in an NLDS as well. Apart from the grammar, we distinguish flve additional system resources: Lexicon and morphology component are linguistic resources (together with the grammar), whereas discourse memory, domain model, and user model are pragmatic system resources. Hence, the reversibility of an NLDS can be classifled depending on (at least) six difierent resource categories. Together with the six reversibility types introduced above, these six resources form a 6-tuple which enables us to describe the reversibility of an NLDS formally and completely.</Paragraph>
    <Paragraph position="5"> Let us take the Conald dialog system [Ludwig, 2003] as an example. The system lexicon is precompiled into an NLG lexicon at development time, hence we have static reversibility of type E here. On the other hand, the morphology component is used by both the parser and the generator at runtime in a uniform way (cf. [Klarner and Ludwig, 2004]), resulting in dynamic reversibility for this component. Discourse memory and domain model are used in the dialog manager for pragmatic integration and by the NLG component. The data structures are identical, but the algorithms are difierent. Thus, we have type B reversibility for these two resources. The user model, however, is not used for parsing, only for generation, hence the system is not reversible with respect to the user model.</Paragraph>
    <Paragraph position="6"> In table 1 the reversibility types of the difierent resources are put together. They form a tuple (E, D, A, B, B, none) completely describing reversibility in Conald.</Paragraph>
    <Paragraph position="7">  The Amalia system [Gabrilovich et al., 1998] is a typical example for Prolog-based reversible NLG systems.</Paragraph>
    <Paragraph position="8"> The system grammar is flrst inverted and then compiled into two difierent versions, one for parsing and one for generation. Thus, we have type C reversibility here. The  same applies to the lexicon. As there are no pragmatic resources and no morphology component, we can skip their analysis here. Hence, Amalia can be characterized by the reversibility tuple (C, n/a, C, n/a, n/a, n/a); cf.  Our third and flnal example is Trips [Ferguson and Allen, 1998]. In this system, the Discourse Context and the Reference component are shared between the Interpretation Manager (which is used for parsing) and the Generation Manager (cf. [Allen et al., 2001]). This results in type B for the discourse memory. The same holds for the ontology of Trips (cf. [Stent, 2001], p.</Paragraph>
    <Paragraph position="9"> 139): Its domain model is of type B as well. As there is no speciflc user model contained in the system, there is also no degree of reversibility to be found there. For various reasons, the Generation Manager uses its own grammar and morphology component (cf. [Stent, 2001], p. 180 &amp; 182). The NLG lexicon of Trips is obtained semi-automatically from various system resources and ofi-line extraction (cf. [Stent, 2001], p. 180). Hence, we have type A reversibility here. We therefore conclude that Trips can be described by the reversibility tuple (A, none, C, B, B, n/a); cf. table 3.</Paragraph>
  </Section>
  <Section position="7" start_page="0" end_page="0" type="metho">
    <SectionTitle>
5 Re-usability as Static Reversibility of
Resources
</SectionTitle>
    <Paragraph position="0"> Given our deflnitions of reversibility in sect. 2, we can view re-using resources in an NLDS as static or dynamic reversibility of the system for these resources. Compared to the deflnition in [Neumann and van Noord, 1994] referred in sect. 2.1, this is a more general deflnition which can be applied to a lot of existing NLDSs.</Paragraph>
    <Paragraph position="1"> Let us again use the Conald system as an example, this time only taking the data structures into account, in order to search for possible re-use of resources. Two core linguistic resources of its parsing branch are re-used in its NLG component Hyperbug [Klarner and Ludwig, 2004]: The system lexicon and the morphology component are both used by the parser and the generator, with static reversibility for the system lexicon and dynamic reversibility for the morphology component. As mentioned in sect. 4, re-use is also done for the pragmatic resources, namely discourse memory and domain model.</Paragraph>
    <Paragraph position="2"> Generally speaking, the more linguistic and pragmatic resources are re-used in an NLDS, the higher its degree of reversibility becomes, and the more e-cient the system will be to develop and maintain.</Paragraph>
  </Section>
class="xml-element"></Paper>