<?xml version="1.0"?><!DOCTYPE article SYSTEM "/project/take/software/searchbench_offline_processing/paperxml_generator/aclextractor/src/python/../resource/dtd/paperxml.dtd"><article><header><firstpageheader><page local="1" global="71"/><title>Referring Expression Generation as a Search Problem</title><author surname="Bohnet" givenname="Bernd"><org  name="University of Stuttgart" country="Germany" city="Stuttgart"/></author><author surname="Dale" givenname="Robert"><org  name="Macquarie University" country="Australia" city="Sydney"/></author></firstpageheader><frontmatter><p><b>Referring Expression Generation as a Search Problem</b></p><p>Bernd Bohnet Bohnet@iis.uni-stuttgart.de</p><p>Institute for Intelligent Systems University of Stuttgart 70569 Stuttgart Germany</p><p>Robert Dale Robert.Dale@mq.edu.au</p><p>Centre for Language Technology Macquarie University Sydney NSW 2109 Australia</p></frontmatter><abstract>One of the most widely explored issues in natu­ral language generation is the generation of re­ferring expressions (gre): given an entity we want to refer to, how do we work out the content of a referring expression that uniquely identifies the intended referent? Over the last 15 years, a number of authors have proposed a wide range of algorithms for addressing different aspects of this problem, but the different approaches taken have made it very difficult to compare and con­trast the algorithms provided in any meaningful way. In this paper, we propose a characterisa­tion of the problem of referring expression gen­eration as a search problem; this allows us to recast existing algorithms in a way that makes their similarities and differences clear. </abstract></header><body><section number="1" title="Introduction"><p>A major component task in natural language generation (nlg) is the generation of referring expressions: given an entity that we want to refer to, how do we determine the content of a referring expression that uniquely identifies that intended referent? Since at least (Dale, 1989), the standard conception of this task in the lit­erature has been as follows:</p><p>1. We assume we have a knowledge base that characterises the entities in the domain in terms of a set of attributes and the values that the entities have for these attributes; so, for example, our knowledge base might represent the fact that entity <i>e\ </i>has the value <i>cup </i>for the attribute <i>type, </i>and the value <i>red </i>for the attribute <i>colour.</i></p><p>2. In a typical context where we want to re­fer to some ej, which we call the <i>intended referent, </i>there will be other entities from which the intended referent must be distin­guished; these are generally referred to as</p><p><i>distractors. </i>So, for example, we may want to distinguish a particular cup from all the other items present in the context of a din­ing table.</p><p>3. The goal of referring expression generation is therefore to find some collection of at­tributes and their values which distinguish the intended referent from all the potential distractors in the context.</p><p>Over the last 15 years, a wide variety of algo­rithms have been proposed to deal with specific aspects of this problem. For example, while ear­lier algorithms focussed on the use of attributes that correspond to simple one-place predicates, later work attempts to address the use of rela­tional predicates, and other work looks at the incorporation of boolean operators such as <i>not </i>and <i>and. </i>The consequence is that we now have a considerable body of research in this area, but it is difficult to establish just how these different algorithms relate to each other.</p><p>This paper represents a first step to­wards consolidating the results in this area, with the aim of developing a framework within which different algorithms can be compared and as­sessed. The structure of the paper is as fol­lows. In Section 2, we provide a brief overview of work on the generation of referring expres­sions to date. In Section 3, we borrow a stan­dard approach used in Artificial Intelligence (ai) to represent problems in an elegant and uni­form way (see, for example, (Simon and Newell, 1963); (Russell and Norvig, 2003)), sketching how gre algorithms can be expressed in terms of <i>problem-solving by search. </i>In Section 4, we explore how the most well-known algorithms can be expressed in this framework. In Sec­tion 5, we discuss how this approach enables a more fruitful comparison of existing algorithms, and we point to ways of taking this work fur­ther.</p><page local="2" global="72"/></section><section number="2" title="A Brief Review of Work To Date"><p>Although the task of referring expression gen­eration is discussed informally in earlier work on nlg (in particular, see (Winograd, 1972; McDonald, 1980; Appelt, 1981), the first for­mally explicit algorithm was introduced in Dale (1989). This algorithm, which we will refer to as the Full Brevity (fb) algorithm, is still frequently used as a basis for other gre al­gorithms. The fb algorithm searches for the best solution amongst all possible referring ex­pressions for an entity; the algorithm derives the smallest set of attributes for the referent in question, producing a referring expression that is both <i>adequate </i>and <i>efficient.</i></p><p>This initial algorithm limited its ap­plication to one-place predicates. Dale and Haddock (1991) introduced a constraint-based procedure that could generate referring expres­sions involving relations (henceforth ir), using a greedy heuristic to guide the search.</p><p>As a response to the computational complexity of greedy algorithms, (Reiter and Dale, 1992; Dale and Reiter, 1995) introduced the psycholinguistically motivated Incremental Algorithm (ia). The most used and adapted algorithm, this is based on the observation that people often produce referring expressions which are informationally redundant; the algo­rithm uses a preference ordering over the at­tributes to be used in a referring expression, ac­cumulating those attributes which rule out at least one potential distractor.</p><p>In recent years there have been a num­ber of important extensions to the ia. The Context-Sensitive extension (cs; (Krahmer and Theune, 2002)) is able to generate referring ex­pressions for the most salient entity in a con­text; the Boolean Expressions algorithm (be; (van Deemter, 2002)) is able to derive expres­sions containing boolean operators, as in <i>the cup that does not have a handle; </i>and the Sets algo­rithm (set; (van Deemter, 2002)) extends the basic approach to references to sets, as in <i>the red cups.</i></p><p>Some approaches combine algorithms which reuse only parts of other algorithms: the Branch and Bound (BaB; (Krahmer et al., 2003)) algorithm uses the Full Brevity algo­rithm, but is able to generate referring expres­sions with both attributes and relational de­scriptions using a graph-based technique.</p><p>We have identified here what we be­lieve to be the most cited strands of research in this area, but of course there are many other al­gorithms described in the literature: see, for ex­ample, (Horacek, 1997; Bateman, 1999; Stone, 2000). Space limitations prevent a complete summary of this other work here, but our in­tention is to extend the analysis presented in this paper to as many of these other algorithms as possible.</p><p>All these algorithms focus on the gen­eration of definite references; they are typically embedded in a higher-level algorithm that in­cludes cases for when the entity has not been previously mentioned (thus leading to an ini­tial indefinite reference) or when the referent is in focus (thus leading to a pronominal refer­ence); see, for example, (Dale, 1989; Krahmer and Theune, 2002; Dale, 2003).</p></section><section number="3" title="gre from the Perspective of Problem Solving"><p>With so many algorithms to choose from, it would be useful to have a uniform framework in which to discuss and compare algorithms; unfor­tunately, this is rather difficult given the variety of different approaches that have been taken to the problem.</p><p>Within the wider context of ai, Russell and Norvig (2003) present an elegant definition of a general algorithm for problem solving by search. The search graph consists of <i>nodes </i>with the components <i>state </i>and <i>path-cost; </i>the prob­lem is represented by an <i>initial-state, </i>an <i>expand-method </i>which identifies new states in the search space, a <i>queuing-method </i>which determines the order in which the states should be considered, and a <i>path-cost-function </i>which determines the cost of reaching a given state. In this frame­work, the search strategy is determined by the combination of <i>queuing-method </i>and <i>path-cost-function </i>used.</p><p>In the following, we use this framework to provide a characterisation of existing gre al­gorithms in terms of problem solving by search. We conceptualise the search space as consist­ing of states that have three components: a de­scription that is true of the intended referent, the set of distractor entities that the descrip­tion also applies to besides the intended refer­ent, and the set of properties of the intended referent that have not yet been considered to describe the referent.</p><page local="3" global="73"/><p>1. The <i>initial-state </i>is of the form <i>({},C,P</i>), where C is the set of distractors in the ini­tial context, and P is the set of all proper­ties true of the intended referent.</p><p>2. The goal state is of the form <i>({XxP1,XxP2,...},</i><i> </i><i>{},P'</i><i> </i>), where the first term contains a set of properties of the intended referent that, by virtue of the second term (the set of distractors) being an empty set, distinguish the intended referent; P' contains any properties of the intended referent not yet used in the description.</p><p>3. All other states in the search space are then intermediate states through which an algo­rithm will move as it adds new properties to the description.</p><p>4. The search strategy is carried out by the <i>expand-method </i>and the <i>queuing-method, </i>which together characterise the specific gre algorithm (for example, fb, gh or ia) that is used.</p><p>5. The <i>path-cost-function </i>allows us to route the search as required; this can be used to take account of salience weights, or to em­body some kind of heuristic search.</p><p>For any given algorithm, not all of the methods and functions need to be implemented; in par­ticular, some algorithms do not require a <i>path-cost-function.</i></p></section><section number="4" title="gre Algorithms in Terms of Problem Solving"><p>We adopt here an object oriented formalism,isince this allows the representation of depen­dencies between the algorithms by means of in­heritance and overwriting.</p><p>To enable more fruitful comparison of the different gre algorithms, we want to dis­tinguish those aspects of the algorithms which are true of all algorithms, and those which are unique to each particular algorithm. In Sec­tion 4.1, we first describe the elements that are shared by all the algorithms; we then go on to describe the distinct aspects of each algorithm in turn.</p><footnote label="1">We follow the code conventions as used in OO-languages, where the names of classes start with upper case characters, and the names of methods and variables start with lower case characters.</footnote><subsection number="4.1" title="Common Elements"><p>This approach allows us to separate out those aspects of the various algorithms which remain constant.</p><p>Following from the previous section, the definitions of the <i>node </i>and <i>state </i>classes are as shown in Definition 1. This figure also shows the definitions for <i>initial-state </i>and <i>goal, </i>which remain constant across the algorithms.</p><p><u>Definition 1: The Node and State Classes </u>class Node { s // State</p><p><i>path-cost </i>// Cost of the path <i>getState()</i></p><p>{return s} // returns the state of the node</p><doubt alpha="0.0" length="1" tooSmall="False" monospace="0.0">}</doubt><p>class State { L // Set of chosen properties and/or relations</p><p><i>C </i>// Set of distractors <i>P </i>// Set of available properties and/or relations <i>initialState() </i>{return new State(0,C,P)} // the goal is the empty set of distractors <i>goal(s) {</i></p><p>if s.C = 0 then return <i>true</i> else return <i>false</i></p><p>Given these components, the main method <i>makeRefExp </i>is then as represented in Definition 2. This takes two arguments, which serve as the parameters that distinguish one algorithm from another: an <i>expand </i>method to create the successors of a given state, and a <i>queue </i>method, which defines how to insert nodes into the node queue. Depending on the order in which the nodes are inserted, differ­ent search strategies can be realized: for exam­ple, when the nodes are inserted at the front of the queue, the search strategy is depth-first; when the nodes are inserted at the end of the queue, the search strategy is breadth-first; when the nodes of the queue are sorted by the esti­mated distance to the goal, then the search type is best-first; and so on.</p><p>In addition, we may require a number of general-purpose methods which can be used by a number of different algorithms. One such method is the method <i>rulesOut, </i>which takes a property or relations <i>p </i>and a set of distrac-tors, and returns the set of distractors which are ruled out by <i>p.</i></p><page local="4" global="74"/><doubt alpha="0.0" length="1" tooSmall="False" monospace="0.0">}</doubt><p>Definition 2: The Basic Algorithm Struc­ture_</p><p><i>makeRefExp() {</i> // create a initial queue with a single node <i>nodeQueue — </i>[new Node(initialState())] while <i>nodeQueue </i>= 0 do node — <i>removeFront(nodeQueue) </i>if <i>goal(node.getState()) </i>then</p><p>return <i>node </i>// success end</p><p><i>nodeQueue — queue(nodeQueue,expand(node)) </i>end</p><p>return <i>nil </i>// failure</p><p>With this machinery in place, we can now redefine the existing algorithms in terms of their core differences, which correspond essen­tially to different ways of expanding the search space.</p></subsection><subsection number="4.2" title="The Full Brevity Algorithm"><p>The distinctive property of the Full Brevity (fb) algorithm is that it computes all combinations of the available properties <i>P </i>with increasing length, so that it may find the shortest combi­nation that succeeds in identifying the intended referent.</p><p>This behaviour is captured by the <i>ex­pand </i>method shown in Definition 3. The method creates a set of successors by creating a node for each property <i>p</i><i>i </i>which has not so far been checked, provided that <i>pi </i>rules out at least one distractor.</p><p>The fb algorithm uses a breadth-first search implementation of the queue, as shown in Definition 4. Consequently, any solution for which <i>goal </i>returns <i>true </i>will have a minimal number of properties, since the breadth-first search considers smaller combinations of prop­erties first.</p><p>The fb algorithm uses the <i>expand </i>method, and <i>createNode </i>method which are shown in Definition 3 and it is invoked by a call of <i>makeRefExp </i>method which is shown in Definition 2.</p></subsection><subsection number="4.3" title="The Incremental Algorithm"><p>The distinctive property of the Incremental Al­gorithm is that it reduces the computational complexity of constructing a referring expres­sion by considering properties to use in se-</p><p>Definition 3: The Full Brevity Algorithm</p><doubt alpha="64.7" length="17" tooSmall="False" monospace="0.0">expand(node){N— 0</doubt><p><i>s </i><i>— </i><i>node.getState() </i>foreach <i>p </i><i>G </i><i>s.P </i>do</p><p><i>N </i><i>— </i><i>N </i><i>U { </i><i>createNode (node,p)} </i>end</p><doubt alpha="100.0" length="7" tooSmall="False" monospace="0.0">returnN</doubt><p><i>createNode(node, </i><i>p)</i><i> </i><i>{ </i><i>s </i><i>— </i><i>node.getState() out </i><i>— </i><i>rulesOut(p, s.C</i>) if <i>out </i>= <i>0 </i>then</p><doubt alpha="61.0" length="41" tooSmall="False" monospace="0.0">return newNode(s.C — out,s.LU{p},s.P—{p})</doubt><doubt alpha="64.9" length="37" tooSmall="False" monospace="0.0">else return newNode(s.C, s.L,s.P—{p})</doubt><p>Definition 4: Breadth-first Queueing</p><p><i>queue(actNodes, newNodes) </i><i>{ </i>// append the nodes at the end return <i>actNodes </i><i>U </i><i>newNodes</i></p><p>quence from a predefined ordering of the avail­able properties. The implementation of the <i>ex­pand </i>method shown in Definition 5 provides this behaviour.</p><p>If the set of properties of the current state <i>s.P </i>is not empty, then the first property <i>p </i>according to the given order <i>O </i>is chosen from the set of properties of the current state <i>s.P, </i>and a node is created with a new state by the method <i>createNode. </i>Note that the <i>createNode </i>method is the same as that used in the fb algo­rithm and shown in Definition 3.</p><p>Unlike the <i>expand </i>method used in the fb algorithm, however, the set of nodes re­turned here contains only one node. The main method applies the <i>goal </i>predicate to this node; if this returns true, then the node containing the state with the list of properties for the referring expression is returned.</p></subsection><subsection number="4.4" title="Extension of the IA to Sets"><p>All the algorithms considered so far have been concerned with constructing descriptions for in­dividual referents; van Deemter (2002) intro­duced an algorithm which extends the ia to sets. The extension is shown in terms of our frame­work in Definition 6.</p><page local="5" global="75"/><doubt alpha="0.0" length="1" tooSmall="False" monospace="0.0">}</doubt><doubt alpha="100.0" length="7" tooSmall="False" monospace="0.0">returnN</doubt><p>Definition 5: The Incremental Algorithm</p><p><i>O </i>// Predefined constant order of properties <i>expand(node) </i><i>{ </i><i>N </i><i>— 0</i> s — <i>node.getState()</i> p — choose the first p in O, where <i>p </i><i>G </i><i>s.</i><i>P N </i><i>— </i><i>N </i><i>U   </i>{ <i>createNode(node,p) </i><i>}</i></p><doubt alpha="66.7" length="12" tooSmall="False" monospace="0.0">ifs.P= 0then</doubt><doubt alpha="100.0" length="3" tooSmall="False" monospace="0.0">end</doubt><p>the largest number of distractors; in the sec­ond stage, each entity which is referenced by the chosen relation has to be described by re­peating the process recursively. This is done in a depth-first manner, but if the related entity is not uniquely distinguished then the next <i>pj</i><i> </i>that the intended referent participates in is cho­sen, and so on. This process continues until all entities are uniquely described (success) or no further relations can be chosen <i>(failure).</i></p><p>Definition 6: The Set Algorithm</p><p><i>R </i>// Set of referents <i>createNode</i>(node, <i>p)</i><i> </i>{ <i>out </i><i>— </i>rulesOut(p, <i>s.C</i>)</p><p>if (—3x <i>G </i><i>R&amp;x </i><i>G </i><i>out</i><i>)&amp;(3</i><i>x </i><i>G </i><i>C&amp;x </i><i>G </i><i>out) </i>then</p><doubt alpha="62.8" length="78" tooSmall="False" monospace="0.0">return newNode(s.C —out, s.LU{p},s.P—{p})else return newNode(s.C, s.L,s.P—{p})</doubt><doubt alpha="40.5" length="42" tooSmall="False" monospace="0.0">N=(L={Xa bowl(a)},C={b1,b3},P={on(x,y),..)</doubt><p>choose relation</p><p>between(x,w,v) describe entity</p><figure caption="Figure 1: Expansion tree for theIRalgorithm"></figure><p>Note that, precisely because this algo­rithm is an extension of the IA algorithm, we reuse the <i>expand </i>method from that algorithm. Consequently, the extension requires only the rewriting of the <i>createNode </i>method, whereby an attribute pj is only chosen when it does not rule out entities from the set of referents <i>R </i>and when it rules out at least one entity from the set of distractors <i>C</i>. If a property does not fulfil that condition, then a node with the current state is returned and the process is continued, as in the IA, with the next property.</p></subsection><subsection number="4.5" title="GRE Involving Relations"><p>The algorithm for GRE Involving Relations (ir) introduced by Dale and Haddock (1991) is constraint-based. The search strategy used to fulfil the constraints is a combination of a greedy search, which chooses the relation that leads to the smallest set of distractors, and depth-first search to describe the entities, that is, the in­tended referent as well as entities which are ref­erenced in the relations.</p><p>The strategy can be explained best by means of an AND/oR-tree, as shown in Figure 1. Here, the top node represents a state in which relational properties are to be considered as ad­ditions to the set of chosen properties. Each search step consists of two stages: in the first stage, we choose the relation <i>p</i><i>i </i>which rules out</p><p>The algorithm is represented in the problem solving paradigm as in Definition 7. Here, the <i>expand </i>method chooses a relation which rules out the largest number of distrac-tors; it then calls the method <i>createNode, </i>which recursively calls <i>makeRefExp </i>for each new ref­erent contained in the relation.</p></subsection><subsection number="4.6" title="Context-Sensitive GRE"><p>Krahmer and Theune (2002) also introduced a number of extensions to the IA: the use of salience weights in order to add a definite arti­cle to the description for the most salient entity; contrastive properties in order to add properties which impose a contrast between two entities; and a relational extension, similar in spirit but not in form to that in the IR algorithm described above.</p><p>Again, as for the <i>sets </i>algorithm, the commonality with the IA algorithm surfaces as the reuse of the latter algorithm's <i>expand </i>method; only the <i>createNode </i>method needs to be rewritten, as in Definition 8. To model this variant in our framework, we introduce the fol­lowing additional methods (cf.  (Krahmer and</p><doubt alpha="40.0" length="15" tooSmall="False" monospace="0.0">Theune, 2002)):</doubt><p><i>• contrastive </i>takes a referent <i>r </i>and a prop­erty <i>p</i>i; it checks whether the property un­der consideration is contrastive.</p><p><i>• mostSalient </i>takes a referent <i>r,</i><i> </i>a set of prop-</p><page local="6" global="76"/><doubt alpha="0.0" length="1" tooSmall="False" monospace="0.0">}</doubt><doubt alpha="100.0" length="3" tooSmall="False" monospace="0.0">end</doubt><p>Definition 7: Involving Relations</p><p><i>r </i>// Referent <i>expand(node) </i><i>{</i> <i>s </i><i>— </i><i>node.getState()</i> // Chosen relation is pc, where <i>p </i>rules out // the largest number of distractors foreach <i>p </i><i>G </i><i>s.</i><i>P </i>do</p><doubt alpha="83.3" length="6" tooSmall="False" monospace="0.0">pc—nil</doubt><p>if <i>pc </i>= <i>nil </i>or then <i>p</i><i>c — </i><i>p</i></p><doubt alpha="57.5" length="40" tooSmall="False" monospace="0.0">\rulesOut(p, s.C)\ &gt; \rulesOut(pc, s.C)\</doubt><doubt alpha="85.7" length="7" tooSmall="False" monospace="0.0">end end</doubt><p><i>nodec </i><i>— </i><i>createNode(node,pc </i>) if <i>(nodec </i>= nil) then return 0 else return <i>{nodec}</i></p><p><i>createNode(node, </i><i>p)</i><i> </i><i>{ </i><i>s </i><i>— </i><i>node.getState() C </i><i>—   </i><i>rulesOut(p, s.C</i>) <i>L </i><i>— </i><i>s.L </i><i>U </i><i>{p}</i><i> </i>// Extend Description</p><p>foreach <i>r' </i><i>G </i><i>{rp\rp </i><i>G </i>referents(p) &amp; <i>rp </i>= <i>r}</i><i> </i>do</p><p><i>node</i><b><i>ri </i></b><i>— </i><i>makeRefExp(r' </i>)</p><p>if <i>node</i><b><i>ri </i></b>= <i>nil </i>then return <i>nil </i>// failure</p><p><i>L </i><i>— </i><i>L </i><i>U </i><i>node.getState().L </i>end</p><doubt alpha="64.3" length="28" tooSmall="False" monospace="0.0">return newNode(C,L, s.P—{p})</doubt><p>erties, and a set of distractors; it checks whether every entity in the set of distrac-tors has a lower salience weight than <i>r.</i></p></subsection></section><section number="5" title="Conclusions and Future Work"><p>In the foregoing, we have shown how a num­ber of the most frequently discussed algorithms for the generation of referring expressions can be represented within a common framework. There are three significant advantages to this approach.</p><p>First, it allows us to determine what the algorithms have in common. This is partic­ularly interesting in that it allows us to begin to assemble a collection of core functionalities that are usable in a variety of different approaches to GRE. This is apparent not only in terms of the general framework (where, for example, the no­tions of states and their initialisation, and def­inition of what it is to be a goal state, and the overall algorithmic pattern) are shared, but in terms of 'helper' routines (such as <i>rulesOut </i>and <i>mostSalient) </i>which can be modularised out of the essence of different algorithms.</p><p>Definition 8: Context-Sensitive Algorithm</p><p><i>r </i>// Referent <i>createNode(node, </i><i>p)</i><i> </i><i>{</i> <i>out </i><i>— </i><i>rulesOut(p, s.</i><i>C)</i></p><doubt alpha="66.7" length="9" tooSmall="False" monospace="0.0">C—s.C—out</doubt><doubt alpha="60.0" length="5" tooSmall="False" monospace="0.0">L—s.L</doubt><p>if <i>(out </i>= <i>0 </i>or <i>contrastive(r, </i><i>p))</i><i> </i>then if <i>v </i>expresses a relation between <i>r </i>and <i>r' </i>then</p><doubt alpha="57.1" length="7" tooSmall="False" monospace="0.0">L—LU{p}</doubt><p><i>L </i><i>— </i><i>L </i><i>U </i><i>node</i><b><i>ri</i></b><i>.getState().L </i>end end</p><p>if <i>mostSalient(r, L, </i><i>C)</i><i> </i>then <i>L </i><i>— </i><i>L </i><i>U   { </i><i>defArt </i><i>}</i></p><p>// The most salient rules out all distractors:</p><doubt alpha="25.0" length="4" tooSmall="False" monospace="0.0">C— 0</doubt><doubt alpha="64.3" length="28" tooSmall="False" monospace="0.0">returnnew Node(C, L,s.P—{p})</doubt><p>Second, it makes it possible to see what the differences between the algorithms re­ally consist in. In their original forms, these differences are obscured, due to the absence of a common vocabulary for expressing the algo­rithms; by representing the algorithms within a common framework, it becomes easier to see where the algorithms differ, and where the dif­ferences are simply due to differences in nota­tion or presentation. By using the framework of problem solving as search, we have effectively decomposed the algorithms into a number of key elements: a search srategy, represented by the <i>queuing-method, </i>and an <i>expand-method, </i>which encompasses two aspects of each algorithm: the basic strategy adopted and the particular kinds of referring expressions covered. Furthermore, the <i>expand-method </i>decomposes into a general strategy for expansion (as found in, for exam­ple, the Full Brevity algorithm and the Incre­mental Algorithm), and a <i>createNode </i>method, which varies depending upon the kind of refer­ring expression targetted.</p><p>Third, it allows us to see more clearly the logical space within which the algorithms reside, and to see ways of combining aspects of different algorithms. At its simplest, this is clearest with respect to the kind of search strat­egy used in the algorithms. Present formula­tions conflate the choice of search strategy with the other aspects of the algorithm (such as how subsequent nodes in the search space are computed); our approach separates out these differ­ent facets of the algorithms, and makes it much easier to see that the choice of search strategy is an independent decision.<page local="7" global="77"/> Consequently, for example, we can easily experiment with a vari­ant of the ir algorithm that uses breadth-first search rather than depth-first search.</p><p>So far, we have used the framwework to express the most widely-known algorithms in the literature. Preliminary examination of the algorithms in (Krahmer et al., 2003), (van Deemter and Krahmer, forthcoming), and (Ho-racek, 2004) suggests that these will also be relatively straightforward to express within the framework described here. As we capture more algorithms in the framework, our intention is to tease out an inventory of basic constituent ele­ments which can then be reassembled and inte­grated in different ways, so that we can derive a better understanding of the nature of the prob­lem of referring expression generation.</p></section><references><p>D. E. Appelt. 1981. <i>Planning Natural Language Utterances to Satisfy Multiple Goals. </i>Ph.D. thesis, Stanford University. J. Bateman. 1999. Using Aggregation for Se­lecting Content when generating Re­ferring Expressions. In <i>Proceedings of the 37th Annual Meeting of the ACL. </i>University of Marylad. R. Dale and N. Haddock. 1991. Generating re­ferring expressions involving relations. In <i>Proceedings of the 5th EA CL, </i>pages 161-166, Berlin, Germany.</p><p>R. Dale and E. Reiter. 1995. Computational in­terpretations of the gricean maxims in the generation of referring expressions. <i>Cognitive Science, </i>19(2):233-263. R. Dale. 1989. Cooking up referring ex­pressions. In <i>Proceedings of the Twenty-Seventh Annual Meeting ofthe </i>ACL, pages 68-75, Vancouver, British Columbia.</p><p>R Dale. 2003. One-anaphora and the case for discourse-driven referring expression generation. In <i>Proceedings </i><i>ofthe</i><i> Aus­tralasian Language Technology Work­shop. </i>University of Melbourne. H. Horacek. 1997. An Algorithm for Generat­ing Referential Descriptions with Flex­ible Interfaces. In <i>Proceedings </i><i>of</i><i> the</i></p><p><i>35th Annual Meeting </i><i>ofthe</i><i> ACL. </i>Uni­versity of Madrid.</p><p>H. Horacek. 2004. On Referring toSets of Objects Naturally. In H. Bunt and R. Muskens, editors, <i>Third Interna­tional Natural Language Generation Conference, </i>pages 70 - 79. Springer­Verlag Heidelberg.</p><p>E. Krahmer and M. Theune. 2002. Efficient context-sensitive generation of refer­ring expressions. In <i>Information Shar­ing: Reference and Presupposition in NLG and Interpretation, </i>pages 223­264. CSLI.</p><p>E. Krahmer, S. van Erk, and A. Verleg. 2003.</p><p>Graph-based generation of referring expressions. <i>Computational Linguis­tics, </i>29(1):53-72.</p><doubt alpha="64.1" length="39" tooSmall="False" monospace="0.0">D. D. McDonald.   1980.Natural Language</doubt><p><i>Generation as a Process </i><i>of</i><i> Decision-making Under Constraints. </i>Ph.D. the­sis, Massachusetts Institute of Tech­nology.</p><doubt alpha="64.4" length="45" tooSmall="False" monospace="0.0">E. Reiter and R. Dale. 1992. A fast algorithm</doubt><p>for the generation of referring expres­sions. In <i>Proceedings </i><i>of</i><i> the 14th ACL,</i> pages 232-238.</p><p>S. Russell and P. Norvig. 2003. <i>Artificial Intelligence: A Modern Approach. </i>Prentice-Hall, Englewood Cliffs, NJ, 2nd edition.</p><p>H. A. Simon and A. Newell. 1963. GPS, a pro­gram that simulates human thought. <i>Computers and Thought, </i>pages 279­293.</p><p>M. Stone. 2000. On identifying sets. In <i>Pro­ceedings </i><i>ofthe</i><i> First International Nat­ural Language Generation Conference. </i>Mitzpe Ramon.</p><p>K. van Deemter and E. Krahmer. forthcom­ing. Graphs and booleans: On the generation of referring expressions. In H. Bunt and R. Muskens, editors, <i>Computing Meaning Vol. III. </i>Dor­drecht: Kluwer.</p><p>K. van Deemter. 2002. Generating referring ex­pressions: Boolean extensions of the incremental algorithm. <i>Computational Linguistics, </i>28(1):37-52.</p><p>T. Winograd. 1972. <i>Understanding Natural Language. </i>Academic Press.</p></references></body></article>