File Information
File: 05-lr/acl_arc_1_sum/cleansed_text/xml_by_section/metho/94/p94-1023_metho.xml
Size: 27,507 bytes
Last Modified: 2025-10-06 14:13:54
<?xml version="1.0" standalone="yes"?> <Paper uid="P94-1023"> <Title>ON DETERMINING THE CONSISTENCY OF PARTIAL DESCRIPTIONS OF TREES</Title> <Section position="4" start_page="0" end_page="163" type="metho"> <SectionTitle> D-THEORYANDTREETHEORY DESCRIPTION LANGUAGE </SectionTitle> <Paragraph position="0"> We will make use of the following description language ,,~. Define the set of basic relation names, R, as: b --&quot;below&quot; (i.e., dominated-by) d -- &quot;dominates&quot; e -- &quot;equals&quot; f --&quot;follows&quot; (i.e., preceded-by) p -- &quot;precedes&quot; We define an algebra on relation names as follows.</Paragraph> <Paragraph position="1"> ($1 V $2)(x,y) =def the collection of relation names in either $1 or S2.</Paragraph> <Paragraph position="2"> (S1 A $2)(x,y) =def the collection of relation names in both $1 and $2.</Paragraph> <Paragraph position="3"> S'(xoI) --def the collection of relation names not in S.</Paragraph> <Paragraph position="4"> We then define the full set of compound relation name expressions R* as the closure of the basic relation names under A, V and '. A formula of is then an element of R* applied to a pair of node names. We will often refer to the compound relation name expression in a formula S(x,31 ) as a constraint on the pair x, 31. Semantically, we treat S(x,31 ) as satisfiable if we can assign the denotata of the pair x, 31 to at least one of the relations denoted by members of S. On this semantics, if S(x,31 ) is satisfiable and S ~< T, then T(x,31 ) is satisfiable as well. Clearly the empty constraint (x,31) is never satisfiable. (Atoms of the form e(x,31 ) are satisfiable if and only if x and 31 denote identical members of the domain of discourse. Atoms of the form b(x,31) and f(x,31) are to be considered equivalent to d(31,x ) and p(31,x), respectively.) A description is a finite set of formulas. If a description contains only formulas with a basic relation name, we will call it classical, since this is the type of description considered in Marcus et al. (1983).</Paragraph> </Section> <Section position="5" start_page="163" end_page="163" type="metho"> <SectionTitle> AXIOMS </SectionTitle> <Paragraph position="0"> Note that such structures are not guaranteed to be trees. Therefore we make use of the following fragment of an axiomatization of tree structures, which we will assume in the background of all that follows, and formalize in the next section.</Paragraph> <Paragraph position="1"> Strictness. Dominance and precedence are strict partial orders, i.e., transitive and irreflexive relations.</Paragraph> <Paragraph position="2"> Equality. We assume that equality is reflexive, and that we can freely substitute equals for equals.</Paragraph> <Paragraph position="3"> Exhaustiveness. Every pair of nodes in a tree stand in at least one of the five possible relations. I.e. R(x,31 ) for all x and 31.</Paragraph> <Paragraph position="4"> Inheritance. All nodes inherit the precedence properties of their ancestors. So if p(x,31 ) and d(31,z), then p(x,z) as well.</Paragraph> <Paragraph position="5"> A number of familiar properties of trees follow from the above system. Inheritance assures both the non-tangling of tree branches and the impossibility of upward branching ('V-shaped') configurations. Inheritance, Transitivity, Substitution of equals and Exhaustiveness jointly derive the property of Exclusiueness, which states that every pair of nodes is related in at most one way. (Note that it is Exclusiveness which assures the soundess of our use of A.) A less familiar property, which we will make some use of, is roughly parallel to Inheritance; Upwards Inheritance states that if x dominates 31 and 31 precedes (follows) z, then x dominates or precedes (follows) z.</Paragraph> <Paragraph position="6"> Note that this system is not meant to be an axiomatic definition of trees; it lacks a Rootedness condition, and it allows infinite and densely ordered structures. It is specifically adapted to the satisfiabilit31 problem, rather than the oalidit31 problem. It is relatively straightforward to show that, from any finite atomic dE-description satisfying these conditions, we can construct a finite tree or a precedence ordered finite forest of finite trees (which can be extended to a finite tree by the addition of a root node). So this system is complete as far as satisfiability is concerned. Briefly, if a set of formulas satisfies all of the above constraints, then we can (1) construct a new description over the quotient node-space modulo e; (2) list the dominance chains; (3) add a root if necessary; (4) noting that the dominance maximal elements under the root must be totally precedence ordered (they must be ordered and they cannot be dominance ordered or they would not be maximal), we number them accordingly; (5) apply the same procedure to the dominance ideals generated by each of the root's daughters. From the resulting numbering we can construct a &quot;tree domain&quot; straightforwardly. The Inheritance property assures us that dominance chains are non-tangled, so that the ideal generatred by any node will be disjoint from the ideal generated by any node precedence-ordered with respect to the first. Therefore no node will receive two numbers, and, by Exhaustiveness, every node will receive a number.</Paragraph> </Section> <Section position="6" start_page="163" end_page="164" type="metho"> <SectionTitle> DEDUCTION WITH DESCRIPTIONS </SectionTitle> <Paragraph position="0"> There is a strong formal parallel among the axioms of Transitivity, Substitution of Equals, and Inheritance: each allows us to reason from a pair of atomic formulas to a single atomic formula. Thus they allow us to reason from classical descriptions to (slightly larger) classical descriptions. Let us refer to these axioms as 9enerators. The reason for adopting dE as a description language, rather than the simpler language of Marcus et al. (1983), is that we can now treat the No Upward Branching property (&quot;if x and z both dominate 31 then x dominates z or z dominates x or they are equal,&quot;) and the Upwards Inheritance property as generators.</Paragraph> <Paragraph position="1"> They allow us to reason from pairs of atomic formulas (e.g., d(x,31 ) and P(31,z)) to compound formulas (e.g., dp(x,z)). This means that we can express the consequences of any pair of atomic</Paragraph> <Paragraph position="3"> formulas as a formula of d~, though possibly a compound formula. They are exhibited in Figure 1. Cells corresponding to axioms in the theory are boxed.</Paragraph> <Paragraph position="4"> For doing formal deductions we will employ a sequent calculus adapted to our description language ~. We assume that sequents are pairs of finite sets of formulas, and we can make the further restriction that formulas on the right of the sequent arrow (&quot;succedents&quot;) contain at most a single member. The axioms of the calculus we employ are exhibited in Figure 2, and the connective rules in Figure 3.</Paragraph> <Paragraph position="5"> A sequent \[F --, A\] is interpreted as an implication from conjunctions to disjunctions: if everything in F is true, then something in A must be true. It follows that \[--*A\] is invariably true, and \[F--,\] is invariably false. A sequent calculus proof is a tree (written right side up, with its root on the bottom) labeled with sequents. The theorem to be proved labels its root, the leaves are labeled with axioms, and all the local subtrees must be accepted by some inference rule. A proof that a description F0 is inconsistent is a proof of the sequent \[F0--*\]. Note that r--, (x,~) F--, is a valid inference, essentially since (x,y) and the empty succedent both express the empty disjunction.</Paragraph> <Paragraph position="7"/> </Section> <Section position="7" start_page="164" end_page="165" type="metho"> <SectionTitle> TWO ALGORITHMS </SectionTitle> <Paragraph position="0"> Suppose we are given an input description F0 to check for satisfiability. If it is unsatisfiable, then it contradicts one of the axioms of the tree theory: Exhaustiveness, Reflexivity of Equals, lrreflexivity of Dominance and Precedence, and the Generators. A complete consistency checker must be able to exhaust the consequences of these axioms for F0, monitoring for the false formula (x,~/).</Paragraph> <Paragraph position="1"> Both algorithms take as input a description and an integer indicating the number of node-names constrained by the description. In the Prolog implementations that follow, the description is expected to be a list of constraints in normal order, that is, with the first argument lexicographically less than or equal to the second. Thus, assuming we are using integers as node names, the normal order form of d(2,1) will be b(1,2). Furthermore, the description is assumed to be sorted by its node-pairs. This will allow us to use efficient ordered-set manipulations.</Paragraph> <Paragraph position="2"> For any given set of nodes of size N, we can construct a description which is a filter for violations of Reflexivity, lrreflexivity and Exhaustiveness. We construct F N to contain for every pair of nodes x,, xj, i,j <~ N, e(x,,xj) if i =j, and e'(x,xi) (i.e., bdfp(x,xi)) if i#j. We can</Paragraph> <Paragraph position="4"> determine that a description F0 violates either Reflexivity, lrreflexivity or Exhaustiveness simply by taking its pointwise meet F0 I&quot;1 FN .2 If a description is in violation of the Exhaustiveness condition, then it contains some formula S(x,21) with some part of S not given in R*. In that case, taking its meet with anything ~< R(x,21) will prune away the offending part. Similarly, if a constraint on a reflexive pair of nodes S(x,x) fails to have eE S, then taking its meet with e(x,x) will yield (x,x). Finally, taking the meet of S(x,y), x # 2t, with e'(x,21) will yield (x,21) if S = e; in arty case it will have the useful effect of pruning e out of S. Therefore both algorithms begin by constructing F N and then taking its meet with the input description. This has the extra side effect that any pair of nodes x and 21 not explicitly constrained in the input will now be explicitly constrained.</Paragraph> </Section> <Section position="8" start_page="165" end_page="167" type="metho"> <SectionTitle> EXTEND : TOP-DOWN BACKTRACKING SEARCH FOR CONSISTENT MAXIMAL EXTENSIONS </SectionTitle> <Paragraph position="0"> Given that we have begun by taking F0 I-I F N, we have only the generators left to check F0 against.</Paragraph> <Paragraph position="1"> We can think of the generator table as defining a function from pairs of atomic formulas to consequences. To use it we must first have atomic formulas.</Paragraph> <Paragraph position="2"> Def'n: A description r' is a maximal extension of a description F if, for every formula S(x,y) in 2 We can assume that any pair of nodes x, y not explicitly constrained in the input is implicitly constrained by R(x,y). Of course, (RAe')= e', so this assumption just amounts to setting unmentioned pairs of (distinct) nodes to e'(x,y).</Paragraph> <Paragraph position="3"> FRFN, r' contains s(x,y) for some sES.</Paragraph> <Paragraph position="4"> An obvious solution is to enumerate the maximal extensions of F0 F'I F N and feed them to the generators. If any such extension passes the generators, then it is satisfiable, and therefore it is a witness to the satisfiability of F0. If the extension is unsatisfiable, then it must violate at least one of the generators. Because a maximal extension is a total assignment of node-pairs to relations, a single application of a well-chosen generator will suffice to derive a contradiction.</Paragraph> <Paragraph position="5"> And so a single pass through the complete set of applicable generators should be sufficient to decide if a given maximal extension is consistent.</Paragraph> <Paragraph position="6"> Thus, if the input description F0 is inconsistent, then there is a proof of F0--, in which every branch of the proof ends in a subproof like that in Figure 4. There we have the simple description {d(1,2),e(1,3),p(2,3)}, which gives us dp(1,3), by a generator (Upwards Inheritance, in this case), and e(1,3), by a structural axiom. Combining these by an invocation of RA we get the false formula (1,3).</Paragraph> <Paragraph position="7"> The roots of these sub-proofs can be combined using LV until we eventually build up the input description on the left, proving F0-', as in Figure 5.</Paragraph> <Paragraph position="8"> The following fragment of a Prolog implementation of max_extension/3 can be seen as implementing a backwards chaining search for such a &quot;RA-LV&quot; proof. The input to both extend and to close (see below, next section) is assumed to be an ~-description together with an integer giving the number of node-names subject to the description. The node-count is used to construct the appropriate F N for this description. Note that, aside from implementing pointwise /-1, merge descs/3 checks for the derivation of an empty constraint, and fails if that happens. The real work is then done by extend/3, which is a recursion on an Agenda. The agenda is initialized to the input description. As individual constraints are narrowed, they are added to the agenda so as to implement constraint propagation.</Paragraph> <Paragraph position="10"> Meet_rule/4, in the second clause of extend~3, differs from merge_descs/3 only in (a) sorting its first argument and (b) deriving both the merged description (D1) and a list of those consequences which actually had some effect on DO. Both merge_descs/3 and meet_rule/'\[ are based on routines for ordered set union from O'Keefe (1990). The main difference is that ordering is defined on the node-pairs of the constraint, rather than on the term expressing the constraint as a whole; equality is defined so that two constraints are equal if they constrain the same node pair, and if two formulas are 'equal' in this sense, then the output contains the meet of their respective relation names expressions. The truly new consequences derived by meet_rule/4 are then added to the remaining agenda (Cs) with another call to merge_descs/3. (If NewCons were merely appended to Cs, we could have two constraints on the same pair of nodes in the agenda at once, either of which may be less tightly constrained than the result of merging the two instances.) Extend/3 thus both consumes items off the agenda (CO) and adds new items (NewCons).</Paragraph> <Paragraph position="11"> However, each new consequence, if it is truly novel, represents the narrowing of a constraint; since each pair starts with a maximum of four options, clearly we will eventually run out of options to remove; NewCons will be empty, the remaining agenda will eventually be consumed, and the program will halt.</Paragraph> <Paragraph position="12"> The core of extend/3 is consequences/3, which determines for any given constraint what consequences it has when paired with each of the constraints in the description. Consequences/3 has two clauses; the first handles compound formulas, while the second handles atomic formulas. The second clause of consequences/3 invokes the Splitting Rule, which implements LV.</Paragraph> <Paragraph position="13"> Note that, instead of exhausting the consequences of the Splitting Rule and then applying the Generator Rule, we apply the Generator Rule whenever we can. This is because it can act to prune away options from its consequents, thus minimizing the combinatorial explosion lurking behind the Splitting Rule. Furthermore, if an application of the Generator Rule does lead to the discovery of an inconsistency, then the program backtracks to its last application of the Splitting Rule, in effect pruning away from its search tree all further consequences of its inconsistent choice.</Paragraph> <Paragraph position="15"> The heart of consequences/3 is the Generator Rule, implemented as generator_rule/3. It scans the current description for formulas which form a connected pair with its second argument. Note that in all our examples, we have carefully presented inputs to the generators as Sx(x,3), Sz(y,z). Such a combination can be looked up directly in the generator table. However, note that St(x,y), S2(z,y) is no less a connected pair.</Paragraph> <Paragraph position="16"> In order to match it to the generator table, though, we need to invert the second member, giving Sz'l(y,z). This is done by connected order/4, which succeeds, returning the connected form of the formulas, if they have a connected form, and fails otherwise. If it succeeds, then there is art entry in the generator table which gives the consequence of that connected pair. This consequence (XZ) is then placed in normal order (C3), and added to the output list of consequences.</Paragraph> <Paragraph position="17"> If C2 is an unconnected atom, or a compound formula, it is skipped. Note that skipping compound formulas does not affect the completeness of the algorithm. Every agenda item leads a dual life: as an agenda item, and as a member of the current description. The ignored compound formula will eventually be subjected to the Splitting Rule, the result being placed on the agenda. It will then eventually be paired with C2's entry in the description by the Generator Rule. The only difference will be in which formula is the left antecedent and which the right; but that doesn't matter, since they'll be converted to connected form in any case, and their result will be converted to normal order. 3</Paragraph> <Paragraph position="19"> Every rule applied in this procedure is based on a rule in the associated sequent calculus. The Splitting Rule is just LV; the Meet Rule is RA; and the Generator Rule is just the application of an axiom. So there can be little doubt that the algorithm is a sound implementation of a search for a LV-RA proof of F0 --,. That it is complete follows from the fact that consistent maximal extensions are Hintikka sets. In particular, every generator F,A,B--* C has the same truth conditions as the set of formulas F U {',AV'~BVC}. So a maximal extension is a Hintikka set if it contains either -,A or &quot;~B or C for every generator. The exhaustiveness of our search assures this: every pair of constraints is checked at least once to see if it matches a</Paragraph> </Section> <Section position="9" start_page="167" end_page="167" type="metho"> <SectionTitle> 3 In fact, every connected pair has two connected </SectionTitle> <Paragraph position="0"> forms: Sl(x,y), S2(y,z) and T~(z,y), Tl(y,z).</Paragraph> <Paragraph position="1"> Unsurprisingly, in this case the output of the generator table for T2 and T: will be the inverse of what it is for S~ and $2. In either case, the output will be placed in normal order before being entered into the description, so we have the required commutativity, generator. If it does not then the extension must contain either &quot;,A or -~B. If it does, then the extension contains A and B, and so it must also contain C, or be found inconsistent by the Meet Rule/RA.</Paragraph> <Paragraph position="2"> However, completeness is purchased at the cost of the complexities of exhaustive search. Note that the Splitting Rule is the only source of non-determinism in the program. All of the routines whose definitions were left out are deterministic. The ordered set manipulations are linear in the size of the combined input lists; the sort called by the Meet Rule is just a variant of merge-sort, and so of N logN complexity; the many inversions which may have to be done are linear in the length of the constraint list, which is bounded from above by 4, so they can be treated as constant time operations. It is only the Splitting Rule that causes us trouble. The second algorithm attempts to address this problem.</Paragraph> </Section> <Section position="10" start_page="167" end_page="169" type="metho"> <SectionTitle> CLOSE : POLYNOMIAL SEARCH FOR A Lv-RA PROOF </SectionTitle> <Paragraph position="0"> The basic design problem to be solved is that the generator table accepts only atomic formulas as inputs, while the description whose consistency is at issue may contain any number of compound formulas. Extend solved this problem by 'bringing the description to the generators,' Close solves this problem by 'bringing the generators to the description.' Figure 6 represents a proof that {dp(1,2),bf(1,B),dp(2,3)} is inconsistent. Here the leaves are almost entirely drawn from the generator axioms. Only the rightmost leaf invokes a structural axiom. The initial stages of the proof involve combining generators by means of RV and LV until the two antecedent atoms match a pair of compound atoms found in the input description (in this case dp(1,2) and dp(2,3)). Then this 'compound generator' is fed into the RA rule together with the corresponding structural axiom, generating our inconsistency.</Paragraph> <Paragraph position="1"> Close, like extend, implements a backwards chaining search for a proof of the relevant sort. The code for the two algorithms has been made almost identical, for the purposes of this paper. The sole essential difference is that now consequences/3 has only one clause, which invokes the New Generator Rule. The input to new_generator_rule/3 is the same as the input to generator_rule/3: the current description, a constraint looking to be the left antecedent of a generator, and the output consequences. Like the old rule, the new rule searches the current description for a connected formula (now not pair it constructs a compound generator by taking the cross product of the atomic relations in the compound formulas (in a double loop implemented in distribute/4 and distrib_l/4), feeding the atomic pairs so constructed to the generator table (in distrib 1/4), and joining each successive generator output. The result is a compound generator whose consequent represents the join of all the atomic generators that went into its construction.</Paragraph> <Paragraph position="2"> newgeneratorrule( U, _C, fl )new generator_rule( \[C21Rest\], C1, \[C31Cons\] ) :connected_order( C1, C2, $1 :(X,Y), S2:(Y,Z) ), distribute( $1 :(X,Y), S2:(Y,Z), \[\]:(X,Z), S3:(X,Z) ), normal_order(S3:(X,Z), C3 ), new_generator_rule( Rest, C1, Cons ).</Paragraph> <Paragraph position="3"> new_generator_rule( \[C21Rest\], C1, Cons ) :\+ connected order( C1, C2 .... ), new_generator_rule( Rest, C1, Cons ).</Paragraph> <Paragraph position="4"> distribute( ~:_, _C2, Cons, Cons ).</Paragraph> <Paragraph position="5"> distribute( \[RIlS1\]:XY, S2:YZ, S3a:XZ, S3:XZ ) :distrib_J (S2:YZ, \[RlJ:XY, S3a:XZ, S3b:XZ ), distribute( $1 :XY, S2:YZ, S3b:XZ, S3:XZ ).</Paragraph> <Paragraph position="6"> distdb_l( \[\].'.._, _C1, Cons, Cons ).</Paragraph> <Paragraph position="7"> dislrib_l( \[R21S2\]:YZ, $1 :XY, S3a:XZ, S3:XZ ) :gen( $1 :XY. \[R2\]:YZ, S3b:XZ ), ord_union( S3a, S3b, $3c ), distrib 1 ( S2:YZ, $1 :XY, S3c:XZ, S3:XZ ).</Paragraph> <Paragraph position="8"> On completion of the double loop, control works its way back to consequences/3 and thence to the Meet Rule, as usual.</Paragraph> <Paragraph position="9"> Unlike extend, close is deterministic. Each agenda item is compared to each item in the current description, and that is that.</Paragraph> <Paragraph position="10"> Furthermore, the complexity of the New Generator Rule is not much greater than before: the double loop we have added can only be executed a maximum of 4 x 4 -- 16 times, so we have increased the complexity of the algorithm, considered apart from the Splitting Rule, by at most a constant factor. The question is: at what cost? Before we turn to the analysis of close, however, note that its output is different from that of extend. Extend returns a maximal extension, selected non-deterministically. Close returns the input description, but with values that could not be part of any solution removed. Essentially, close returns the pointwise join of all of F0's consistent maximal extensions.</Paragraph> <Paragraph position="11"> This action, of joining all the atomic consequences of a pair of constraints, does not preserve all of the information present in the atomic consequences. Consider the following description.</Paragraph> <Paragraph position="13"> F0 is its own closure, and is consistent. However, if we examine its maximal extensions, we note that one of them r3 : {d(1,2), p(1,3), d(2,3)} is inconsistent. There is nothing in F0 to tell us that one combination of the values it presents is impossible. Note that this may not be essential to proving inconsistency: for F0 to be inconsistent, it would have to be the case that all values in some constraint were ruled out in all maximal extensions.</Paragraph> </Section> <Section position="11" start_page="169" end_page="169" type="metho"> <SectionTitle> ANALYSIS OF CLOSE </SectionTitle> <Paragraph position="0"> We first argue that close is indeed finding a LV-RA proof of F0 --,. Note that in our toy example of Figure 6 only a single 'compound generator' was required to derive the empty solution. In general it may take several compound generators to build a proof of F0--*. Each one functions to remove some of the possibilities from a constraint, until eventually no possibilities are left. Thus we have a LV-RA proof of F0-, if and only if we have a proof of FQ --, (x,y), for some x and y. Let us call such a (not necessarily unique) pair a critical pair in the proof of F0---,, and its associated constraint in F0 a critical constraint.</Paragraph> <Paragraph position="1"> It is not at all obvious how to choose a critical constraint beforehand, so close must search for it. Every time it calls the New Generator Rule and then calls the Meet Rule to merge in its consequence, it constructs a fragment of a LV-RA proof. We could then take the constraint which it finally succeeds in emptying out as the critical constraint, collect the proof fragments having that constraint as their succedent, and plug them together in the order they were generated to supply us with a LV-RA proof of F0 --*.</Paragraph> <Paragraph position="2"> So close will find a LV-RA proof of F0-,, if one exists. It is not clear, however, that such a proof always exists when F0 is unsatisfiable.</Paragraph> <Paragraph position="3"> Close is essentially a variant of the path-consistency algorithms frequently discussed in the Constraint Satisfaction literature (IVlackworth, 1977; Allen, 1983). It is known that path-consistency is not in general a strong enough condition to ensure completeness. There are, however, special cases where path-consistency techniques are complete (Montanari, 1974). So far, close appears to be complete, (two years of work have failed to turn up a counterexample) but it is unlikely to yield an easy completeness proof. The algorithm presented here is strongly reminiscent of the algorithm in Allen (1983), which is demonstrably incomplete for the temporal reasoning problems to which he applied it. Therefore, if close is complete for D-theory, it can only be due to a property of the generator axioms, that is, to properties of trees, as contrasted with properties of temporal intervals. Standard approaches of any generality will almost certainly generalize to the temporal reasoning case.</Paragraph> </Section> class="xml-element"></Paper>