File Information
File: 05-lr/acl_arc_1_sum/cleansed_text/xml_by_section/metho/02/j02-1003_metho.xml
Size: 30,086 bytes
Last Modified: 2025-10-06 14:07:49
<?xml version="1.0" standalone="yes"?> <Paper uid="J02-1003"> <Title>Generating Referring Expressions: Boolean Extensions of the Incremental Algorithm</Title> <Section position="3" start_page="38" end_page="38" type="metho"> <SectionTitle> ,:::, P </SectionTitle> <Paragraph position="0"> n such that their logical conjunction forms a &quot;distinguishing description&quot; (Dale 1989) of the target object r. In other words, writing [[Q]] for the extension of Q (i.e., the set of objects that have the property Q), the intersection [[P</Paragraph> </Section> <Section position="4" start_page="38" end_page="39" type="metho"> <SectionTitle> ]]\ \[[P </SectionTitle> <Paragraph position="0"> n ]] must equal the singleton set frg. It is a &quot;hillclimbing&quot; algorithm, which finds better and better approximations of the target setfrgby accumulating more and more properties--hence the term Incremental. There is no backtracking. Consequently, if some property P i in L is made redundant by later additions (i.e., when ([[P</Paragraph> <Paragraph position="2"> is retained as a member of L nevertheless.</Paragraph> <Paragraph position="3"> In the full algorithm (see below, D&R Att ), properties are analyzed as pairs consisting of an Attribute and a Value. Attributes are ordered in a listA.IfA</Paragraph> <Paragraph position="5"> is &quot;more preferred than&quot; A j ; as a consequence, A i will be considered before A j by the algorithm. Suppose r is the target object, and D (the &quot;domain&quot;) is the set of elements from which r is to be selected. The algorithm iterates through A; for each</Paragraph> <Section position="1" start_page="38" end_page="39" type="sub_section"> <SectionTitle> Attribute A </SectionTitle> <Paragraph position="0"> i , it checks whether specifying a Value for that Attribute would rule out at least one object that has not already been ruled out; if so, the Attribute is added to L, with a suitable Value (FindBestValue, below). C is the set of &quot;confusables&quot; at any given stage of the algorithm.</Paragraph> <Paragraph position="1"> Objects that are ruled out are removed from C. The process of expanding L and contracting C continues until C = frg; if and when this condition is met, L is a distinguishing set of properties. For easy generalizability, the algorithm will be cast in set-theoretic terms. We first present a version that focuses on properties, without separating these into Attributes and Values, and assume the properties themselves are ordered in a list P (cf. Reiter and Dale 2000). This version of the algorithm will be called D&R</Paragraph> <Paragraph position="3"> there is no risk of confusion. We assume that the domain contains one or more objects other than the target object, the so-called distractors: thus, r2Dbut frg6=D.</Paragraph> <Paragraph position="5"> If C =frg then Return L fSuccessg Return FailurefAll properties in P have been tested, and still C6=frgg Assuming (as do Dale and Reiter [1995]) that the tests in the body of the loop take some constant amount of time, the worst-case running time is on the order of n is the total number of properties. So, the algorithm has only linear complexity.</Paragraph> <Paragraph position="6"> A slightly closer approximation of Full Brevity can be achieved if Attributes and Values are separated (Dale and Reiter 1995), allowing the algorithm to choose the &quot;best&quot; Value for each Attribute. Given an Attribute, FindBestValue selects the Value that removes most distractors while still including the target r. If no Value includes r, the function returns nil. In case of a tie (i.e., no Value removes more distractors than Computational Linguistics Volume 28, Number 1 when dog rules out as many distractors as chihuahua, chihuahua cannot be chosen. A is the list of Attributes; L is the set of Attribute/Value combinations returned by the algorithm. A further notational convention will be useful: Values will be identified by two indices, the first of which identifies the Attribute. Thus, to denote Value j of</Paragraph> <Paragraph position="8"> . This version of the algorithm will be called D&R Att . The initializations of L and D are omitted for brevity.</Paragraph> <Paragraph position="10"> If C =frg then Return L</Paragraph> </Section> <Section position="2" start_page="39" end_page="39" type="sub_section"> <SectionTitle> Return Failure </SectionTitle> <Paragraph position="0"> We will switch back and forth between D&R and D&R Att , depending on what is at stake. Like D&R, D&R Att has linear complexity. This can be made precise in the following way.</Paragraph> <Paragraph position="1"> If the running time of a call of FindBestValue(r, A i ) is a constant times the number of Values of the Attribute A i , then the worst-case running time of equals the number of Attributes in the language and n v the average number of Values of all Attributes. 3. Completeness of the Incremental Algorithm Some new definitions will be useful. A GRE algorithm is successful with respect to a given situation (i.e., with respect to a KB and a target) if it produces a distinguishing description of r in that situation. We will call an algorithm complete if it is successful in every situation in which a distinguishing description exists. Success is not always possible: the properties in the KB may not be sufficient for individuating a given object. Such no-win situations will not be held against an algorithm. The Incremental Algorithm generates descriptions that contain set intersection as their only Boolean operation. We define a GRE algorithm to be intersectively complete if it has the following property: whenever an object can be characterized by intersecting a finite number of properties, the algorithm will find such an intersection. We would like to prove the Incremental Algorithm to be intersectively complete, but we will meet a few obstacles before we get there.</Paragraph> </Section> <Section position="3" start_page="39" end_page="39" type="sub_section"> <SectionTitle> 3.1 Completeness and Overlapping Values </SectionTitle> <Paragraph position="0"> One assumption without which the Incremental Algorithm cannot be proven to be intersectively complete concerns the semantic relation between different Values of a given Attribute: their extensions should not &quot;overlap&quot; in the following precise sense:</Paragraph> <Paragraph position="2"> are all nonempty.</Paragraph> </Section> </Section> <Section position="5" start_page="39" end_page="42" type="metho"> <SectionTitle> 3 Dale and Reiter arrived at linearity via the difficult concept of typical running time. They assumed that, </SectionTitle> <Paragraph position="0"> typically, n l (i.e., the number of properties in the description) is proportional to the number of Attributes examined by the algorithm (Ehud Reiter, personal communication). This allowed them to argue that the typical running time is O(n</Paragraph> <Paragraph position="2"> ), where n d is the number of distractors (Dale and Reiter 1995, Section 3.1). Our own worst-case assessment does not rely on assumptions of typicality.</Paragraph> <Section position="1" start_page="40" end_page="41" type="sub_section"> <SectionTitle> van Deemter Generating Referring Expressions (If V </SectionTitle> <Paragraph position="0"> i,j and V i,k do not overlap, then either [[V</Paragraph> <Paragraph position="2"> ]] have an empty intersection.) Values can overlap for different reasons. Some Attributes (e.g., COLOR) have &quot;vague&quot; Values (e.g., RED, ORANGE), which may be modeled as overlapping: some objects may count as both red and orange. Also, Values may derive from particular parts or aspects of an object; for example, if an object counts as METAL (PLASTIC) because it has some METAL (PLASTIC) parts, then it may be listed as both METAL and PLASTIC. Further examples arise if the KB models relations through unanalyzed properties. For example, a desk, or a particular type of desk, can stand in a given relation (e.g., &quot;being considered by&quot; or &quot;being bought by&quot;) to more than one other company. To see the problems arising from overlapping Values, consider a KB that models which customer bought which types of desks, and where C =fa, b, c, d, e, fg: BOUGHT-BY: PHILIPS (fa, b, eg), SONY (fa, c, d, fg) COLOR: BROWN (fa, bg), YELLOW (fc, dg) (Desks of types a, b, and e were bought by Philips, and so on. Note that desks of type a were bought by two different companies.) Suppose a is the target, while the Attribute BOUGHT-BY is more &quot;preferred&quot; than COLOR. The Value PHILIPS (being the BestValue of BOUGHT-BY, since it removes more distractors than the Value SONY)is chosen first, reducing the initial set C tofa, b, eg. Now, the algorithm is doomed to end in Failure, since the different Values of COLOR are unable to remove the unwanted b without also sacrificing a. None of this can be corrected, since the algorithm does not use backtracking. Note that a uniquely identifying description of a would have been possible if only SONY had been chosen instead of PHILIPS, leading to a description like the brown desk bought by Sony. The algorithm does not just fail: it fails in a situation where Success was perfectly achievable! How can this limitation be remedied? One might introduce a limited kind of backtracking, which &quot;remembers&quot; where the algorithm has encountered overlapping Values and, when it results in Failure, goes back to the last-encountered situation where it has made a choice between overlapping Values; if this does not lead to Success, the algorithm backtracks to the previous choice situation, and so on until no more choice situations are left (Failure) or a distinguishing description has been reached (Success). Unfortunately, this algorithm becomes intractable if Values overlap too often: in the worst case, we are back to having to check all combinations of properties.</Paragraph> <Paragraph position="3"> A simpler and computationally more efficient algorithm would include all overlapping Values that are true of the target while also removing some distractors. This could be done as follows: whenever a Value V i,j of an Attribute A i is selected for inclusion in L, search for other Values of the same Attribute that have the target r as an element; if such a Value V i,k is found, check whether it stands in the subset relation to</Paragraph> <Paragraph position="5"> as well; next, search for yet another Value V i,l of the same Attribute that has r as an element, and include V i,l if it does not stand in the subset relation to V i,j or V i,k ; and so on until no other Values of A i exist that have r as an element; then move on to the next Attribute. This algorithm has a worst-case running time of O(n In our example, this algorithm would produce a set consisting of the properties BOUGHT BY SONY and BOUGHT BY PHILIPS, which can be realized as the desk bought by Sony and by Philips; if we change the example by letting Philips buy c as well as a, the 4 This assumes that, once FindBestValue has found a Value V that removes distractors, one may need to inspect all the other Values of the same Attribute to find Values overlapping with V. Shortcuts are possible if Values are stored using a structure that reflects their semantic relationships. Computational Linguistics Volume 28, Number 1 algorithm will go on to select the property BROWN, resulting in a set of properties that may be realized as the brown desk bought by Sony and by Philips. Such descriptions appear to be quite natural. One might even argue, on Gricean grounds (Grice 1975), that identifying a simply as being bought by Philips can give rise to the false implicature that a was not bought by Sony. This suggests that the proposed algorithm might also be empirically more accurate than the one using limited backtracking provided, of course, properties are properly aggregated (e.g., Dalianis and Hovy 1996).</Paragraph> </Section> <Section position="2" start_page="41" end_page="41" type="sub_section"> <SectionTitle> 3.2 Assumptions Concerning Infinite Sets </SectionTitle> <Paragraph position="0"> To prove intersective completeness, certain assumptions concerning the cardinality of sets need to be made. To give an extreme example, suppose one wanted to refer to a real number that does not have a &quot;proper name&quot; (unlike, e.g., ); then the class of potentially useful properties is so vast that no GRE algorithm can take them all into consideration. As long as the number of properties (i.e., Attribute/Value combinations) is denumerably infinite (Kleene 1971), only termination becomes problematic: if a uniquely referring description [[P</Paragraph> <Paragraph position="2"> ]] exists, then the algorithm will find one in finite time, since each of the n properties in the description will be found in finite time; if no distinguishing description exists, however, the algorithm never terminates. In the less likely case where the set of properties is nondenumerably infinite (i.e., it does not stand in a 1-1 relation to any set of natural numbers), completeness becomes problematic as well, since it is impossible for the algorithm to consider all properties; hence, successful combinations may be overlooked (cf. Kleene 1971,pages 6-8).</Paragraph> <Paragraph position="3"> Infinity of the set of distractors results in a different problem. The key question is whether there exists an effective procedure for removing distractors (i.e., for cal-</Paragraph> <Paragraph position="5"> ]]). If no such procedure exists, the Incremental Algorithm can only be applied after a property has been found that cuts down the set of distractors to a manageable size. To be on the safe side when we prove completeness, we will assume that the set of properties is at most denumerably infinite, while the set of distractors is finite. These assumptions are harmless in connection with present NLG systems, all of which work with relatively small sets. It is unclear how human speakers cope with large sets of properties and/or distractors, but this question goes beyond our present concerns.</Paragraph> </Section> <Section position="3" start_page="41" end_page="42" type="sub_section"> <SectionTitle> 3.3 Proving Intersective Completeness </SectionTitle> <Paragraph position="0"> Based on these considerations, we prove intersective completeness under some assumptions concerning infinity and overlapping Values. We deal first with D&R, then with the more complex D&R must have been achieved. To see this, let Des i be the description that results after processing (i.e., inspecting and possibly including) Q i . Then a proof by induction over van Deemter Generating Referring Expressions i shows that [[Des</Paragraph> <Paragraph position="2"> ]], for all i m. (Consider the basic case, where i = 1, and assume that Q ) only if it removes the same distractors.</Paragraph> </Section> </Section> <Section position="6" start_page="42" end_page="47" type="metho"> <SectionTitle> 4. Generalizing the Incremental Algorithm </SectionTitle> <Paragraph position="0"> Both versions of the Incremental Algorithm have been proven to be intersectively complete. Now we widen the issue to include all other Boolean combinations, involving negation (i.e., complementation) and disjunction (i.e., union).</Paragraph> <Paragraph position="1"> This is natural, since properties expressed by Boolean combinations are implicit in the KB: if the KB lists the property POODLE and the property ALSATIAN, then it implicitly contains the property of being either a poodle or an Alsatian. This move will, however, only have its full impact when we also widen the issue to reference to sets of objects.</Paragraph> <Paragraph position="2"> In the new setting, it will be useful to generalize our earlier notion of intersective completeness (Section 3), calling a GRE algorithm Boolean complete iff it finds a Boolean description of a set whenever one can be given on the basis of the properties in the KB.</Paragraph> <Section position="1" start_page="43" end_page="44" type="sub_section"> <SectionTitle> 4.1 Describing Sets </SectionTitle> <Paragraph position="0"> Generating descriptions is even more important if the target is a set than if it is a single object: even if the objects in the set have proper names, the set as a whole may lack a name (and enumerating the objects may be cumbersome). Yet, reference to sets has long been disregarded in NLG. In this section, we sketch generalizations of D&R that produce descriptions of sets. To begin with, the algorithm D&R</Paragraph> <Paragraph position="2"> Return FailurefAll properties in P have been tested, yet C6= Sg Note that S takes the place of the target object r in the earlier algorithms; the process of expanding L and contracting C continues until C = S. Because this is basically the same algorithm as D&R, it has the same computational complexity of O(n characterizes a set by scrutinizing its elements. This does not work for properties like BEING OF THE SAME AGE, which crucially pertain to sets of objects (cf. Stone 2000). The algorithm can, however, be generalized to cover such cases if we initialize C not toDbut to the powerset ofD, after which the algorithm selects properties of sets, removing from P(D) all those sets for which the property is false. For example, selection of BEING OF THE SAME AGE removes all those sets whose elements are not of the same age as each other, selection of FORMING A FOOTBALL TEAM removes all sets that do not make up a football team, and so on. As a result, the algorithm generates descriptions of sets of collective entities (i.e., sets of sets). In this way, descriptions such as those teams all of whose members are of the same age can be generated. In this collective</Paragraph> <Paragraph position="4"> 6 We continue to disregard special provisions for head nouns (see footnote 1). Note, however, that a head noun must be selected that suits every element of the target set.</Paragraph> <Paragraph position="5"> Once again, these adaptations leave the algorithm structurally unchanged: sets replace objects throughout. Yet, they cause the complexity of the algorithm to become exponential, since testing whether C = S involves inspecting all elements of C, of which there can be up to 2</Paragraph> <Paragraph position="7"> is the cardinality of the domain D).</Paragraph> <Paragraph position="8"> This algorithm can also be applied to distributive properties if these are upgraded to the level of sets: Let a newfangled distributive property be true of a set iff the property (in ordinary parlance) is true of all its elements (Kamp and Reyle 1993, page 338). This requires that the target S is always cast as a set of sets, even if it is viewed distributively. For example, if a set of players--say, a, b, and c--are to be characterized as a collection (e.g., to say that they won as a team of three), then S = ffa, b, cgg; if they are to be characterized distributively (e.g., to say that each of them has the flu), then S = ffa, b, cg,fa, bg,fa, cg,fb, cg,fag,fbg,fcgg. In this way, the algorithm is able to combine collective and distributive properties, as in those football teams whose members are British.</Paragraph> <Paragraph position="9"> We will not explore collective versions of the Incremental Algorithm further here, focusing instead on the relatively simple case of D&R Plural , in which all properties are distributive. As in the case of D&R, it is easy to separate Attributes and Values when referring to sets, allowing a closer approximation of Full Brevity: the resulting treated as described in Section 3.1. In what follows, we will once again take propertyoriented versions of the Incremental Algorithm as our starting point, but implications for the separation between Attributes and Values will be mentioned where they are nontrivial.</Paragraph> </Section> <Section position="2" start_page="44" end_page="45" type="sub_section"> <SectionTitle> 4.2 Using Negations and Disjunctions </SectionTitle> <Paragraph position="0"> Now that we are able to generate references to sets, let us move away from purely intersective descriptions, on to full Boolean combinations of properties. Consider a KB whose domain is a set of animals (a, b, c, d, e) and whose only Attributes are TYPE and COLOR: TYPE: DOG (fa, b, c, d, eg), POODLE (fa, bg) COLOR: BLACK (fa, b, cg), WHITE (fd, eg) (All domain elements happen to be dogs.) In this situation, the Incremental Algorithm does not allow us to individuate any of the animals. Intuitively, however, the KB should enable one to refer to c, for example, since it is the only black dog that is not a poodle: fcg= BLACK\POODLE A similar gap exists where disjunctions might be used. For example, the Incremental Algorithm does not make the set of dogs that are either white or poodles referrable, whereas it is referrable in English--for example, the white dogs and the poodles. In the next two sections, we will investigate how negation and disjunction can be taken into account in GRE. But first we introduce a trick for determining whether Computational Linguistics Volume 28, Number 1 unique identification of an entity is possible, in a given situation. The idea is to calculate, for each element d in the domain, the Satellite set of d, that is, the intersection of the extensions of all the properties true of d. Taking all extensions from our dog example, we have</Paragraph> <Paragraph position="2"> Satellite sets show which sets can be uniquely identified and which ones cannot. In the case of the dogs, for example, no intersective description of fcg is possible because, in the Satellite sets, c is always accompanied by other objects (i.e., a and b); more generally, in this example, no object in the domain is uniquely identifiable, since no object occurs in a Satellite set that is a singleton.</Paragraph> <Paragraph position="3"> Satellite sets can also be applied to the construction of descriptions. The entityfa, bg, for example, is uniquely described by the intersection DOG\POODLE\BLACK, and this can be read off the list of Satellite sets. Two of the three properties in DOG\POODLE\ BLACK are redundant, however. Using Satellites sets for the construction of descriptions can be particularly useful when properly generalized to Boolean descriptions, but shortening the resulting descriptions in a computationally efficient way is difficult (van Deemter and Halld 'orsson 2001). The present paper will focus on another approach to Boolean descriptions, which takes the Incremental Algorithm as its point of departure (van Deemter 2001).</Paragraph> </Section> <Section position="3" start_page="45" end_page="45" type="sub_section"> <SectionTitle> 4.3 Generating Boolean Descriptions </SectionTitle> <Paragraph position="0"> In this section, we will show how full Boolean descriptions can be generated. This can be done in many different ways depending, among other things, on what form of descriptions are preferred, for example, disjunctions of conjunctions, or conjunctions of disjunctions. We will aim for the latter, while staying as close as possible to the Incremental Algorithm. The algorithm proceeds as follows. First we add negations to the list of atomic properties. Then D&R Plural runs a number of times: first, in Phase 1, the algorithm is performed using all positive and negative literals; if this algorithm ends before C = S, Phase 2 is entered in which further distractors are removed from C by making use of negations of intersections of two literals, and so on, until either</Paragraph> <Paragraph position="2"> . Thus, Phase 2 of the algorithm deals with disjunctions of length 2, Phase 3 deals with disjunctions of length 3, and so on. Optimizations may be applied to shorten the resulting descriptions. For instance, a description of the form (P[Q)\(P[R) can be simplified to (P[(Q\R)) using standard algorithms (e.g., McCluskey 1965). Such optimizations, however, are less urgent than in the case of the more verbose descriptions generated using Satellite sets (see above), and we will disregard optimizations here.</Paragraph> <Paragraph position="3"> A schematic presentation may be useful, in which P . If this is successful, then stop; otherwise, go to Phase 4.</Paragraph> <Paragraph position="4"> Etc.</Paragraph> <Paragraph position="5"> One can require without loss of generality that no property, considered at any phase, may have different occurrences of the same atom. (For example, it is useless to consider Therefore, since at phase n there is room for properties of length n, the maximal number of phases equals the total number of atomic properties.</Paragraph> <Paragraph position="6"> Consider our old example, where the preference order of atomic properties corresponds with the order in which they are listed, and where the same order extends to their negations, all of which are less preferred. Abbreviating B = BLACK, D = DOG, P = POODLE, and W = WHITE, we haveP =hB, D, P, W, B, D, P, Wi. Now, if S =fc, d, eg and S = fcg (as before) are to be characterized, nothing eventful happens. In both cases, a description is found during Phase 1: P in the first case, B\P in the second. The situation gets more interesting if S = fa, b, d, eg, which triggers Phase 2. For instance, if positive literals precede negative literals, the properties relevant for Phase 2 might be ordered as follows: hB[D, B[P, B[W, D[P, D[W, P[W, B[D, B[P, B[W, D[B, D[P, D[W, P[B, P[D, P[W, W[B, W[D, W[P, B[D, B[P, B[W, D[P, D[W, P[Wi During Phase 1, no property is selected, since the only property true of all elements in S =fa, b, d, egis D, which fails to remove any distractors. During Phase 2, one property after another is rejected. For example, the property B[D is rejected because it does not remove any distractors. The first property that is true of all elements of S while also removing distractors is P[W. This property removes all distractors at once, causing the algorithm to end with L = fPOODLE[WHITEg as the complete description. If we modify the example by letting [[BLACK]] =fa, cg(rather thanfa, b, cg) and S =fb, c, d, eg (rather than S =fa, b, d, eg), then the description L =fBLACK[POODLEg is found.</Paragraph> </Section> <Section position="4" start_page="45" end_page="47" type="sub_section"> <SectionTitle> D&R Boolean </SectionTitle> <Paragraph position="0"> is incremental not only within a phase, but also from one phase to the next, which causes shorter disjunctions to be favored over longer ones. Once a property has been selected, it will not be abandoned even if properties selected during later phases make it logically superfluous. As a result, one may generate descriptions like X \ (Y [ Z) (e.g., white (cats and dogs)) in a situation where Y[Z (e.g., cats and dogs) would have sufficed (because (Y [ Z) X). This is not unlike some of the redundancies generated by Dale and Reiter's algorithm and, as in their case, it is Computational Linguistics Volume 28, Number 1 unclear whether this is descriptively adequate. Adaptations can be made if needed. For instance, phases might run separately before running in combination: first (as usual) Phase 1, then 2, then (as usual) 1&2, then 3, then 1&3, then 2&3, then (as usual) 1&2&3, and so on.</Paragraph> <Paragraph position="1"> As a result of this adaptation, the description Y[Z would be generated because of Phase 2 alone.</Paragraph> <Paragraph position="2"> Double incrementality, however, does not save D&R Boolean from intractability. To estimate running time as a function of the number of properties (n a ) in the KB and those in the description (n l ), we can mirror an argument in Dale and Reiter (1995, Section 3.1.1) to show that the maximal number of properties to be considered equals . To avoid intractability, the algorithm can be pruned. No matter where this is done, the result is a polynomial algorithm. By cutting off after Phase 1, for example, only (negations of) atomic properties are combined, producing such descriptions as the black dog that is not a poodle, disregarding more complex descriptions; as a result, completeness is lost, but only for references to nonsingleton sets, because set union does not add descriptive power where the description of singletons is concerned. The number of properties to be considered by this simpler . Then the preference ordering between Attributes may be taken into account if the number of negative Values is the same in both unions; in case of a tie, the number of distractors removed by each of the two unions may decide; if all this fails to tip the balance, the relative specificity of Attributes may be used. The situation resembles that of D&R Att but, in the case of the new algorithm, D&R Boolean,Att , there is more scope for choice, because it compares combinations (i.e., unions) of properties: when the preference order of individual Attributes has been decided, it can happen that [[V Assume there are at most denumerably many properties, and finitely many distractors (one or more). Then if a set can be individuated distributively by any Boolean combination of properties, D&R Boolean will find such a combination.</Paragraph> <Paragraph position="3"> Proof Any Boolean expression can be written in conjunctive normal form (CNF), that is, as an intersection of unions of literals (e.g., Fitting 1996). Theorem 3 follows from the following lemma.</Paragraph> <Paragraph position="4"> Lemma Let ' be a CNF formula whose longest union has a length of n (i.e., it conjoins n literals). Then D&R , then, after i[?]1 phases, some possibly incomplete description has been found, such that [[ ]] [[ ]]. Also, [[']] [ ]]. Phase i inspects all unions of length i, including each of '</Paragraph> </Section> </Section> class="xml-element"></Paper>