it simpliies the notation, we write unary unction symbols without parenthesis, e.g., h((h(x);a)) would be written as h(hx; a). By s[t] we indicate tha

Transcription

1 Fast Algorithms or Uniorm Semi-Uniication Alberto Oliart Λ Laboratorio Nacional de Inormática Avanzada, A.C. Rébsamen 8, Xalapa, Veracruz, Mexico Wayne Snyder Boston University Computer Science Department 111 Cummington Street Boston, MA 2215 January 16, 23 Abstract Uniorm semi-uniication is a simple combination o matching and uniication deined as ollows: Given two terms s and t, do there exist substitutions and ρ such that sρ = t? We present two algorithms or this problem based on Huet's uniication closure method, one producing (possibly) non-principal solutions, and one producing principal solutions. For both we provide a precise analysis o correctness and asymptotic complexity. Under the uniorm cost RAM model (counting assignment, comparison, and arithmetic operations as primitive) our irst algorithm is asymptotically as ast as Huet's method, O(n(n)), where is the unctional inverse o Ackermann's unction. Under a model which counts assignments and comparisons o pointers, and arithmetic operations on bits, the cost is O(n 2 (n) 2 ). Producing principal solutions is more complex, however, and our second algorithm runs in O(n 2 (n) 2 ) and O(n 2 log 2 (n(n)) loglog(n(n)) (n) 2 ) under these two models. 1 Preliminaries This this section we will present the basic notions necessary or the remainder o the paper, and motivate our study o asymptotically ast algorithms or semiuniication. In general we ollow the standard notations established by [4], and provide here only a brie review o the most important ideas; readers requiring a more complete introduction to uniication are reerred to the comprehensive survey [2] We work with irst-order terms T (F; X ) (denoted by the symbols s, t, u, and v) over a ixed signature F (denoted by, g, and h) and set o variables X (represented by w, x, y, and z). When Λ Supported by CoNACyT. 1

2 it simpliies the notation, we write unary unction symbols without parenthesis, e.g., h((h(x);a)) would be written as h(hx; a). By s[t] we indicate that s contains a distinguished subterm t, and we extend this notation to sets o equations. A substitution (represented by and ρ) is a unction rom variables to terms almost everywhere equal to the identity. The application o a substitution to a term is represented in the orm s. The composition ρ is the unction which maps each x to (x)ρ. We denote the n-old composition o ρ by ρ n. I 1 and 2 are substitutions then we say that 1» 2 i there is a substitution such that 2 = 1. We say that a term s matches onto t i there exists a substitution ρ (a matcher) such that sρ = t. Matchers, when they exist, are unique. A uniication problem is a pair o terms denoted s =? t, and has a solution (or uniier) i s = t. Uniiers are, in general, not unique, and it is well known that a uniication problem has a uniier i it has a most general uniier, i.e., a uniier such that or any other uniier o s and t,». Semi-uniication is a combination o matching and uniication ormally deined as ollows. Deinition 1 A semi-uniication instance is a set o inequalities s 1»? t 1 ;:::s n»? t n g and is solvable i there exist substitutions ρ 1 ;:::;ρ n and such that s i ρ i = t i or each i. Since the ρ i can be uniquely generated once is given, we call the solution or semi-uniier o the instance. A semi-uniier is principal i or any other semi-uniier we have». A semi-uniication problem is uniorm when n = 1. Semi-uniication has applications in term rewriting, type checking or programming languages, proo theory, and computational linguistics (see [9] or a comprehensive list o reerences). Although it has a simple deinition, it has proved remarkably diicult to analyze precisely. In its general orm the problem has been shown to be undecidable [9], with an exceedingly diicult proo. The uniorm case is decidable, and various authors have given algorithms (see Section 8), however, a careul analysis o the asymptotic complexity o the problem has not been perormed. In this paper we present a two decision procedures based on the Huet uniication closure method. The irst can produce a (possibly non-principal) solution, or ail i no solution exists, in O(n(n)) under the uniorm cost RAM model (which counts only assignments, comparisons, and additions and subtractions o integers), where n is the number o symbols in the the problem instance. Thus, the complexity o deciding a uniorm semi-uniication instance and producing a solution is asymptotically equivalent to deciding an instance o standard uniication using Huet's uniication closure algorithm. However, as we explain below, arithmetic is a signiicant part o the algorithm, and it is also interesting to consider a model which counts assignment and comparison o pointers and arithmetic operations on bits. Under this model, the cost o the irst algorithm is O(n 2 (n) 2 ). However, the irst algorithm produces solutions which may not be principal; i principal solutions are desired, we must do additional work, and in particular must perorm GCD to keep weights on the links in reduced orm. This boosts the cost, and the resulting algorithm runs in O(n 2 (n) 2 ) under the uniorm-cost model and O(n 2 log 2 (n(n)) loglog(n(n)) (n) 2 ) under the bit-cost RAM model. Both algorithms run in quadratic space. 2

3 2 A Naive Decision Procedure by Transormations The basic idea o the algorithms we present in this paper (due to [8]) is to transorm a semiuniication problem s»? t into a kind o uniication problem on '(s)=? t, where ' is a placeholder or the matching substitution ρ. The uniication algorithm used is dierent rom standard uniication because in the presence o the placeholder ' one must be careul about applying substitutions (i.e., the Variable Elimination rule) and because the ailure condition related to the occurs check is more delicate. In this section we explore the logical properties o the problem by irst considering how the rulebased approach to standard uniication (see [2]) must be modiied to account or these dierrences. 1 The algorithm begins with an instance s»? t and either ails (i no solution exists) or terminates with a set o pairs o terms rom which a solution (possibly non-principal) may be extracted. By considering how the primitive operations o this rule-based approach may be eiciently perormed, we develop the eicient methods presented later. Beore presenting the rules, we must ormalize the notion o a placeholder or a matching substitution. Deinition 2 Let ' be a unary unctional symbol not in F. The set o '-terms is T ' = T (F [ 'g; X ). For any term t, ' t = t and ' i+1 t = '(' i t). Let ρ be a substitution over terms in T and let t be a '-term. Then tρg = 8 >< >: x i t = x (s 1 ρg;:::;s n ρg) i t = (s 1 ;:::;s n ) ρ i (t ρg) i t = ' i t Thus, we may think o t 2 T ' as a term that has a (single) unknown substitution applied to some o its subterms, and t ρg is the term in T that results when an actual substitution ρ is instantiated or ' and applied to those subterms. In act, we are generally only interested in the eect o substitutions on variables, and so we will distribute ' down into subterms using rewrite rules o the orm '((s 1 ;:::;s n ))! ('(s 1 );:::;'(s n )) or every 2 F. The normal orm o a term t under these rules will be denoted by b t. In other words, we may push the ocurrences o ' down until they either disappear (at constants) or can be pushed no arther (at variables). Clearly, tρg = b t ρg: For example, i t = '((x; '((y; z)))) and ρ = x 7! a; y 7! hyg, then t ρg = (a; (hhy; z)) 1 The rules presented in this section are essentially the same as those in [8], however, they are worth presenting again, in the interests o being relatively sel contained. 3

4 and bt = ('x; (' 2 y; ' 2 z)): To ensure termination, we will also need a well-ounded ordering on '-terms. Deinition 3 Let > be a ixed total ordering on Var(s; t). Then or any '-terms ' n s and ' m t, ' n s > ' m t i 1. s; t 2 X and s > t, or 2. s; t 2 X and t = s and n > m, or 3. t 2 X and s 62 X. This ordering is not total, but will suice or termination o the rule set, which we now deine. Deinition 4 The set o rules S Let E be a set o equations on '-terms, let s; t, and u be '-terms, and χ be a total ordering on Var(s; t; u). Push: E [ '((s 1 ;:::;s n ))? = tg ) E [ ('(s 1 );:::;'(s n ))? = tg E [ s? = '((t 1 ;:::;t n ))g ) E [ s? = ('(s 1 );:::;'(s n ))g Decompose: E [ (s 1 ;:::;s n )? = (t 1 ;:::;t n )g ) E [ s 1? = t 1 ;:::s n? = t n g Transitivity: E [ s? = t; t? = ug ) E [ s? = u; s? = t; t? = ug Orient: E [ s? = tg ) E [ t? = sg i t χ s Substitute: E [ s[' n x]? = t; ' n x? = ug ) E [ s[u=' n x]? = t; ' n x? = ug Fail: E [ (:::)? = g(:::)g )? i 6= g E [ ρ n x? = (:::;ρ m x;:::)g )? i n» m 4

5 By [ we mean multiset union and by s[u=' n x] we mean that u is substituted or an occurrence o the term ' n x in s. We now deine what it means or a set o equations on '-terms to have a solution. Deinition 5 A set o equations on '-terms E = s 1 =? t 1 ;:::;s n =? t n g has a solution i there exist substitutions and ρ such that s 1 ρg = t 1 ρg; :::; s n ρg = t n ρg. We say that is a solution to E. The set o all solutions o E is denoted by Sol(E). A set o equations on '-terms which is not a ailure set, but which no rule applies, is called a solution set. The ollowing result can be easily shown (see [8]). Theorem 1 Let E = '(s)=? tg. I s and t are semi-uniiable, then any application o the above rules to E will result in a solution set; otherwise any application o the rules will result in?. We illustrate how this naive decision procedure works with two examples. Example 1: (x; (y; z))»? ((z; x);x) We deine the ordering among variables as z > y > x. The algorithm starts with the equation which becomes, ater pushing on the let side, Ater decomposition we get the equations '((x; (y; z)))? = ((z; x);x); ('(x);('(y);'(z)))? = ((z; x);x): '(x)? = (z; x); x? = ('(y);'(z)): Substituting in irst equation using the second and then pushing on the let, we obtain: (' 2 (y);' 2 (z))? = (z; ('(y);'(z))); x? = ('(y);'(z)): Finally, ater applying Push, Decompose, and Orient, we get x? = ('(y);' 3 (y)); ' 4 (y)? = ('(y);' 3 (y)); z? = ' 2 (y): No more rules apply and hence the two terms are semi-uniiable. Example 2: g((x; y);(y; z))»? g(z; x) Ater pushing on the let we have the equation g(('(x);'(y));('(y);'(z)))? = g(z; x): 5

6 Ater applying Decompose and Orient, we obtain: z? = ('(x);'(y)); x? = ('(y);'(z)): Using the irst equation to substitute into the second, and pushing on the right side, we have: z? = ('(x);'(y)); x? = ('(y);(' 2 (x);' 2 (y))) and by virtue o the second equation this reduces to?. Hence the terms are not semi-uniiable. 3 A Fast Decision Procedure The method presented in section 2 is obviously not very eicient: duplication o variable occurrrences leads to duplication o terms, substitution is time-consuming, and the best order in which to apply the rules is not clear. As in the case o standard uniication, we may develop a more eicient algorithm by representing terms as directed acyclic graphs (DAGs) with unique occurrences o variable nodes, and using Union-Find data structures; both are necessary to achieve almost-linear time and both can be translated into the case o semi-uniication very naturally. 2 For example, the instance = g((x; y);(y; z))»? g(z; x)g used in Example 2 would have a DAG representation as ollows: g g x y z We assume that the reader is amiliar with this standard data structure or terms, and reer those needing more background to the survey [2]. 2 Using DAGs without Union-Find results in a quadratic upper bound or standard uniication [3]; the use o Union-Find to achieve almost linear time is due to [7]. In Section 8 we will explain in some detail why the Huet algorithm is the most natural approach or ast semi-uniication. For the application o DAGs and Union-Find to Robinson's original algorithm see [14]. 6

7 3.1 The Semi-Uniication Algorithm Based on Uniication Closure The algorithm presented in this section 3 builds equivalence classes o subterms in DAGs by adding pointers ( class links") between the nodes on the graph; thus, as in the Huet method, equivalence classes o terms to be uniied are represented by a tree o pointers, with one term (the representative") at the root. However, in our case, the algorithm also has to account or the matching substitution (represented by '). The class links account or the application o the matching substitution with two weights, the source weight and the target weight, which count the number o applications o ' on each side o the directed link in a similar way to the algorithm o chapter 2. A n class link o the orm r m - s says that the term r is a member o the class whose representative is s, and that ρ n (r) = ρ m (s), in other words, a link represents an equation between '-terms. In addition, the data structure or the links has a Boolean lag (or mark") that is only used or the proo o correctness o the algorithm. The links are added to the graph (and perhaps later marked), more or less as equations are added and removed in the naive algorithm presented above. We now present our algorithm in detail. Our graph nodes have the ollowing properties : 1. class : indicates the class representative or that node. This contains two weights, a source cost and a target cost. At the beginning it is initialized to point to itsel, with both weights equal to. 2. size : Indicates the size o the class when the node is a class representative. 3. children : List o the subterms o the term in the original DAG. 4. sel loop : Indicates the presence o a sel-loop. It is initialized to alse or all nodes in the original DAG. 5. in stack : Indicates whether the node is in the stack used or inding cycles. Initialized to alse. 6. processed : Indicates whether the node has already been processed in the inding o cycles. 7. cycle cost : Indicates the cost o the traversed path when searching or cycles. 8. unc : The unctional symbol in a node. It is null i the node represents a variable. Each link has associated with it a Boolean lag called mark, which is set to alse when it is irst created, and may be set to true sometime during the algorithm. We say that a link is marked i the mark lag is true. In addition, we maintain a global list LSF which contain the nodes that are involved in sel-loops (i.e., have links that start and end at the same node); this is critical in the decision procedure, as we see below. The algorithm may now be given. Our driver unction SU irst calls unction Semiuniy; i Semiuniy returns true it then calls unction Cycle. This unction returns true i both Semiuniy and Cycle return true. 3 This paper is based on the irst-author's Ph.D. thesis [13] and the reader is reerred to that document or a more extensive development o the two algorithms presented in this paper. 7

8 boolean SU (term s, term t) // s» t? return Semiuniy(s; 1; t; ) AND Cycle(s; t) g Function Semiuniy returns true i there are no symbol clashes. As a side eect it adds links to the DAG that represents the two terms. Ater this, the resulting graph is not necessarily a DAG. The links added by the algorithm to the DAG represent membership in a given class o nodes. To do this it uses the well-known almost-linear Union-Find algorithm. The Union unction is embedded in the Semiuniy unction, and Find is deined below. boolean Semiuniy(term s, int n, term t, int m) (n 1 ;m 1 ;s n ) = Find(s); // Find link s 1 m- 1 s to representative (1) (n 2 ;m 2 ;t n ) = Find(t); // Find link t 2 m- 2 t to representative (2) // Check or symbol clash i (unc(s )!= unc(t ) and both are non-null) return alse; // Determine new path between s and t (w 1 ;w 2 ) = Getpath((m 2 ;n 2 ); (m; n); (n 1 ;m 1 )); // Check or sel-loop. i (s == t ) // Union not necessary, but have sel-loop i (w 1 6= w 2 ) sel loop(s ) = true; return true; (3) g else // Classes distinct, take union // Assume, wlog, that size(s ) size(t ), so s is new // representative. The link to be added here is t - w 2 w 1 s. // The case or size(s ) < size(t ) is analogous. class(t ) = (w 2 ;w 1 ;s ); size(s ) = size(s ) + size(t ); i (unc(s ) == null) and (unc(t )!= null) unc(s ) = unc(t ); // unc(t ) is new unction node else i (unc(s )!= null) and (unc(t )!= null) // Calculate link between unction nodes and push down (p 1, q 1, s ) = Find(unc(s )); // s and t are unchanged (4) (p 2, q 2, t ) = Find(unc(t )); (5) (k 1, k 2 ) = GetPath(((p 1 ;q 1 ); (w 1 ;w 2 ); (q 2 ;p 2 ))); return Sulist(subterms(unc(s )), k 1, subterms(unc(t )), k 2 ); (6) g 8

9 g g Function Sulist traverses the list o subterms o a DAG node and returns true i Semiuniy returns true or each subterm. Function Getpath returns the weights or a new link to be added to the graph. It receives the weights or three links, which represent the links to be collapsed. The new link goes rom the node that is at the source o the irst link to the node that is the target o the last link. Given the pairs o integers (m 2 ;n 2 ); (m; n); (n 1 ;m 1 ), the pair o weights returned by Getpath is (w 1 ;w 2 ), where w 1 = maxm 2 ;m 2 n 2 + m; m 2 n 2 + m n + n 1 g w 2 = w 1 ((((m 2 n 2 ) + m) n + n 1 ) m 1 ) This corresponds to deriving an equality ρ w 1 (s ) = ρ w 2 (t ) rom the equalities ρ m 1 (s ) = ρ n 1 (s), ρ n (s) = ρ m (t), and ρ m 2 (t ) = ρ n 2 (t). Such an inerence is sound according to an appropriate set o rules or equational inerence which preserve solvability but not principality o solutions extracted. This is because the set includes a rule or cancellation o ρ; e.g., sρ 2 = tρ is solvable i s ρ = t is, however the solution to the second is larger (in act it is ρ). For a decision procedure this is not an issue, although in order to extract principal solutions, we will need to modiy the graph to recover the original links (see below), which accounts or its higher complexity. Function Find(s) is rom the ast Union-Find algorithm, but it also calculates the weights o the new compressed links constructed in a manner similar to GetPath. It returns the class representative o the class o term s together with the weights that correspond to the compressed path rom s to the class representative. The unction also compresses the path to the representative o any other node that is in the original path rom s. Function Cycle checks or bad cycles in the terminal graph which indicate the non-existence o solutions. To ind cycles this unction uses the well-known linear algorithm, while perorming a calculation similar to that used in GetPath to derive equational consequences o the equivalence n links ollowed. I a cycle x m - x is ound, where m» n, then this indicates that the system implies a bad equation ρ m (x) = ρ n ((:::x:::)), which is suicient or the non-existence o solutions (c. [8]). Secondly, i a cycle o any kind involving a node with a sel-loop is ound, then this is also suicient or non-existence, since this implies the existence o an equational consequence ρ p (s) = ρ q (s), which can be used to pump the exponents in the cyclical equation to produce a bad equation. I neither o these conditions holds, it can be shown that the graph has a solution, and so Cycle returns true. 4 Examples We now demonstrate the decision procedure on the two examples presented previously, plus one more that shows how instances may ail to semi-uniy i a sel-loop is produced during the algorithm. 9

10 4.1 Example 1 Revisited This shows how a problem may have an instance o an occurs check equation and still be semiuniiable. The DAG representing the problem (x; (y; z))»? ((z; x);x) is as ollows: y z x In these diagrams, we will indicate a call to Semiuniy on two nodes as an equivalence link, denoted by an undirected dotted line, which indicates that the two nodes are about to be put in the same equivalence class, distinguishing it rom an actual link between a node and the representative or its class (as beore, a dashed arrow). Ater the irst call to Semiuniy we have an equivalence link between the two top nodes; one o the two nodes is chosen as representative (arbitrarily, since they are both unction nodes) and this link turns into a pointer to a class representative: 1 y z x Now the link between the top nodes is pushed down by the recursive calls to Semiuniy and a link is placed on the let subterms x and (z; x) and pointed to the latter term as representative. A 1

11 link is then placed on the right subterms; no weights have yet changed in any o these arcs. Here is a view o the graph beore the representative is chosen: y z x Since x has a pointer to a class representative, then the equivalence link to x must be repointed to this representative, by adding a new arrow, with new weights calculated along the path rom (y; z) to (z; x): y z x At this point, the new link between (y; z) and (z; x) must be pushed down into the subterms. The link is pushed down to z and y, and since neither has a representative, one is arbitrarily chosen, and then the subterms y and x are linked; here is the diagram beore the representative is chosen or this last link: 11

12 1 2 1 y z x 2 2 Now the equivalence link between z and x must be repointed so that it joins the representatives o these two terms, and this means building a representative pointer between y and (z; x); since the class o the latter is larger (with 3 terms) than the class o the ormer (with 2 terms), the latter is chosen as the new representative. A representative pointer is built, with new weights calculated along the path y, z, x, (z; x): y z x 2 No other arcs are added to the DAG ater this, and the algorithm would proceed to check or cycles. 1 In act, the DAG has a cycle, rom the link x - (z; x). Because the cost on x is greater than the cost on (z; x) this is not a bad cycle, and thereore the instance has a solution. The decision procedure would return true. 4.2 Example 2 Revisited The DAG or the two terms was given at the beginning o Section 3. The ' is applied to the g node that represents the head o the let term in, so the irst link to be added is between 12

13 those two nodes. This represents the irst set o equations in the process, which contains only one equation, namely '(g((x; y);(y; z))) =? g(z; x). This means that both nodes belong to the same equivalence class, and we arbitrarily choose the right hand side node as the representative o the class. The graph at this point appears as ollows: g 1 g x y z In the naive algorithm, we would push down the ' using Push and then Decompose the equation; in the graph algorithm the same eect may be obtained by pushing down the link (with its weights) onto the subterms. Ater this step, we have this graph: g 1 g 1 1 x y z As already noted in Example 2, this particular instance has no solution, and the problem is a occurrence o the second ailure condition (a kind o occurs check). This is relected in the graph as a so-called bad cycle among the links. There are actually two such bad cycles in this graph: 13

14 one o them starts at x, and the other one in z. The loop rom x is given by ollowing the link 1 x - 1, then ollowing the subterm link rom to z, then the link z -, and inally back to x through the corresponding subterm link. However, not all occurs checks indicate non-semi-uniiability (i.e., when n > m in the second ailure condition in our naive algorithm), and not all cycles in the graph are bad. The weights in the links play a role in the cycles, and in this particular case, i we traverse every weighted link, subtracting the target weight (second value) rom the source weight (irst value), when we return to x we have an accumulated negative value, which means that this is a bad cycle, which means that the instance has no solution. Instead o inding a bad occurs check using a kind o equational rewriting, we do it here using graph traversal and arithmetic on the weights. 4.3 Example 3: A Cycle with a Sel-Loop In the previous example we saw an instance that has no solution because o a bad cycle, we now present an example with no solution because o a sel-loop. This is in a sense equivalent to a bad cycle, because the sel-loop (considered equationally) can be used to rewrite any cycle into a bad cycle by pumping the exponent o one side o the equation. Our instance here is (x; (x; z))»? ((x; y);x), corresponding to the ollowing DAG: 1 x z y Ater pushing down the links into the subterms and repointing, we obtain: 14

15 1 2 x 1 z y Pushing down the link between (x; z) and (x; y) into the let subterms gives us a sel-loop on x, which is repointed and thereby moved up to (x; y). Pushing down onto the right subterms gives us the completed DAG: x 1 z 2 y 1 There is a good loop x - (x; y), however the sel-loop participates in this good loop, so that the decision procedure would return alse, as the instance is not semi-uniiable. 5 Correctness o the Decision Procedure To prove the correctness o the decision procedure we interpret the class links on the graph as equations over '-terms. This means that at the end o the procedure we are let with a set o equations, and we show that this inal set o equations has a solution i and only i the instance o semi-uniication given as input to the algorithm has a solution. We use the term semi-uniication graph" (or, in what ollows, simply graph") or any graph obtained at any point during the 15

16 procedure described above with an arbitrary instance as input. We irst show that the algorithm terminates. Lemma 1 I = s»? tg is an instance o semi-uniication, then the call SU(s; t) terminates. Proo: The call to unction SU produces calls to unctions Semiuniy and Cycle, however, the latter is the well known algorithm to ind cycles in a graph and obviously terminates. The only non-trivial case is the recursive unction Semiuniy. We irst note that unctions Find and Getpath, which are called on the body o Semiuniy obviously terminate. Thus the only issue are the recursive calls to Semiuniy itsel. Let us associate with each call to this unction the number o equivalence classes in the graph beore the call. Note that equivalence classes are only joined, never split. The irst call to the unction is associated with the number o nodes in the graph, and beore each recursive call through Sulist in line (6), the (ormerly distinct) classes o the terms s and t are joined, reducing the measure. Hence the unction terminates. 2 n Each class link o the orm t m - s, where s and t are subterms o the graph, represents an equation on '-terms o the orm ' n t =? ' m s. At each step o the process, a class link is added to the graph, or a class link is substituted with another. Each o these new graphs represents a new set o equations on '-terms, so the process can be interpreted as building the inal set o equations through intermediate sets o equations, starting rom a set with only one equation. Deinition 6 For any graph G, the set o equations represented by G is E(G) = ' n s =? ' m n t j there is an unmarked arc s m - t in Gg[ ' n s =? ' m s j a sel-loop was added to s with weights m; ng Given an instance o semi-uniication = t»? ug, the set o equations associated with the graph ater the irst call to Semiuniy is 't =? ug, which obviously has a solution i and only i has one. The graph changes with every call to Semiuniy, Find and Cycle. To show that the resulting changes on the corresponding sets o equations preserves solvability (to be deined below), we now deine a set o transormations on the sets o equations, show that these transormations preserve solvability, and that changes made to the graph by the above-mentioned unctions are equivalent to inite sequences o the transormations on the sets o equations. These transormations are based on the transormations described in section 2. For technical reasons we need to mark some parts o a term in an equation with the symbol!, which does not aect the term in any way. For example, i s is a term, then the marked version is denoted by s!. Deinition 7 Let E be a set o equations on '-terms, and let s; t, and u be '-terms. We deine the ollowing sequence o transormations. l E [ s =? tg ) E [ t =? sg. l E [ s =? tg ) 1 E [ b t =? bsg. 16

17 l E [ ' n (s 1 ;:::;s n )=? ' m (t 1 ;:::;t n )g ) 2 E [ ' n (s 1 ;:::;s! i ;:::;s n)=? ' m (t 1 ;:::;t! i ;:::;t n);' n s i =? ' m t i g or 1» i» n, with s i ;t i unmarked. l E [ 's =? 'tg ) 3 E [ s =? tg. l E [ s =? tg ) 4 E [ 's =? 'tg. l E [ s =? t; t =? ug ) 5 E [ s =? u; t =? ug. l E [ s =? t; t =? ug ) 6 E [ s =? t; s =? ug. l E [ (s! 1 ;:::;s! n)=? (t! 1 ;:::;t! n)g ) 7 E. l E [ s[' n x]=? t; ' n x =? ug ) 8 E [ s[u=' n x]=? t; ' n x =? ug. Furthermore, let ) = ) [ ) 2 [ :::[ ) 8 and let ) n i denote n applications o rule ) i. We say that ) i, i 2 1;:::;8g, preserves solvability i and only i E ) i E implies Sol(E) Sol(E ) and Sol(E) = ; implies Sol(E ) = ;. The sense in which these transormations (corresponding to the actions o our algorithm) preserve solvability is make precise in the next result. Lemma 2 (a) I E ) i E ; i 2 ; 1; 2; 4; 6; 7; 8g then Sol(E) = Sol(E ). (b) For any substitutions and ρ, and '-term ' i (t); (' i t)ρg = (tρg)ρ i = tρ i ρg: (c) I 2 Sol(E [ ' n+i t =? ' m+i sg, then = ρ i 2 Sol(E [ ' n t =? ' m sg). (d) Let E = E [ ' n t =? ' m sg. Then E 1 = E [ ' n+i s =? ' m+i tg has a solution i and only i E has a solution. (e) I E ) 3 E then Sol(E ) Sol(E). () ) 4 preserves solvability. Proo: The only non-trivial part o this lemma is (c). Clearly we have (' n t) ρg = t ρ n ρg = tρ n+i ρg = (' n+i t)ρg = (' m+i s)ρg = sρ m+i ρg = s ρ m ρg = (' m s) ρg: Let ' k u =? ' j v 2 E. Since (' k u)ρg = (' j v)ρg, then (' k u) ρg = u ρ k ρg = uρ k+i ρg = vρ j+i ρg = v ρ k ρg = (' j v) ρg: 17

18 We now need to show that these transormations to the graph by unction Semiuniy can be explained in terms o the transormations deined above. The changes occur at points (1) - (6), o which (1), (2), (4) and (5) are all equivalent, since they are calls to unction Find. 2 Lemma 3 Assume that graph G has a the ollowing unmarked links: n t 1 m- 1 n s 2 m- 2 u; where u is the representative. Then, the call Find(t) generates the graph G 1, such that G 1 is equal to G everywhere except on the part shown, which is changed to: n s 2 m- 2 u m 3 n 3 t where n 3 = maxn 1 ;n 1 m 1 + n 2 g and m 3 = n 3 (n 1 m 1 + n 2 )+m 2, and E(G 1 ) has a solution i and only i E(G) has a solution. Proo: Upon inspection o the code or unction Find we observe that only one more call to Find is issued, speciically Find(s), which returns the triplet (u; n 2 ;m 2 ). Ater this, unction GetPath is called with parameter the list [(n 1 ;m 1 ); (n 2 ;m 2 )]. This call returns the values n 3 = maxn 1 ;n 1 m 1 + n 2 g and m 3 = n 3 (n 1 m 1 + n 2 ) + m 2. Finally, the class link or node t is replaced by one that points to node u, which is the representative, adding the corresponding values as the weights. And this is the only change to the graph, so the graph G 1 is generated and it is equal to G except at the part shown. To show that E(G) has a solution i and only i E(G 1 ) has one, we irst note that there is a set o equations E 1 such that E(G) = E 1 [ ' n 1 t =? ' m 1 s; ' n 2 s =? ' m 2 ug and E(G 1 ) = E 1 [ ' n 3 t =? ' m 3 u; ' n 2 s =? ' m 2 ug. We need to consider two cases: (1) m 1 < n 2, and (2) m 1 n 2. For the irst case, we note that n 3 = maxn 1 ;n 1 m 1 + n 2 g = n 1 m 1 + n 2, and m 3 = n 3 (n 1 m 1 + n 2 ) + m 2 = m 2. Thereore we have that E(G) ) (n 2 m 1 ) 4 E 1 [ ' n 3 t? = ' n 2 s; ' n 2 s? = ' m 2 ug ) 5 E 1 [ ' n 3 t? = ' m 3 u; ' n 2 s? = ' m 2 ug; and we have that E 1 [ ' n 3 t? = ' m 3 u; ' n 2 s? = ' m 2 ug = E(G 1 ): Thereore E(G) has a solution i and only i E(G 1 ) has a solution. For the second case we have that n 3 = n 1 and m 3 = n 1 (n 1 m 1 + n 2 )+m 2 = m 1 n 2 + m 2. We thereore have that and we also have that E(G) ) (m 1 n 2 ) 4 E 1 [ ' n 1 t? = ' m 1 s; ' m 1 s? = ' m 3 ug; E 1 [ ' n 1 t? = ' m 1 s; ' m 1 s? = ' m 3 ug ) 5 E 1 [ ' n 3 t? = ' m 3 u; ' m 1 s? = ' m 3 ug ) (m 1 n 2 ) 3 E(G 1 ): Thereore, since the transormations used preserve solvability, E(G) has a solution i and only i E(G 1 ) has a solution. 2 18

19 Lemma 4 A call to Find on a node on a graph G produces a graph G 1 such that E(G) has a solution i and only i E(G 1 ) has a solution. Proo: The proo o this lemma is by induction on the number o calls generated by the irst call to Find using Lemma 3 2 Lemma 5 Let = t»? ug be an instance o semi-uniication. Then the call Semiuniy(t; 1;u;) returns a graph G S such that has a solution i and only i E(G S ) has a solution. Proo: We prove the ollowing by induction on the total number o calls to the unction Semiuniy: Let G be a semi-uniication graph, and let t; u be nodes in the graph. Let E = E(G) [ ' n s =? ' m tg. Then the graph G S that results rom the call Semiuniy(s; n; t; m) is such that E has a solution i and only i E(G S ) has a solution. Semiuniy calls itsel recursively through a call to Sulist. Assume that E has a solution. Base case: The unction executes irst lines (1) and (2). Let G 2 be the grpah ater the execution o (2). By lemma 4 we have that E has a solution i and only i E(G 2 ) has one. We call s and t the respective representatives returned by the call to Find. Since only one call is generated, either line (3) or line (4) is executed, but not (5), (6) and (7). I it executes (3) then a sel loop with weights w 1 and w 2 is added to s = t. The resulting graph is G S, and E(G S ) contains the equation ' w 1 s =? ' w 2 s. We observe also that the equations ' n 1 s =? ' m 1 s and ' n 2 t =? ' m 2 t are in E 2 = E(G 2 ) [ ' n s =? ' m tg. We now show that it is possible to go rom E 2 to E(G S ) using ). We irst observe that w 1 = maxm 2 ;m 2 n 2 + m; m 2 n 2 + m n + n 1 g and w 2 = w 1 (m 2 n 2 + m n + n 1 ) + m 1 : We can easily check that w 1 = maxw 1 ;w 1 w 2 + n 1 g and w 2 = w 1 (w 1 w 2 + n 1 ) + m 1, where w 1 = maxm 2 ;m 2 n 2 + mg and w 2 = w 1 (m 2 n 2 + m) + n. Using a similar argument to the one used in the proo o lemma 3, it is easy to check that E S can be obtained rom E 2 using a combination o ) 3 ; ) 4, etc. I line (4) is executed, then the argument is basically the same as the previous case, the only dierence being that the equation added is not a sel loop. Induction Hypothesis. Assume that the lemma is true or ewer than n calls. To show that the lemma is true or n calls, we notice that the call Semiuniy(s; n; t; m) does not execute line (3), and it must execute lines (1), (2), (4), (5), (6) and (7). Let G 6 be the graph ater the execution o line (6). It is easy to show, using a very similar argument to the one used or the base case, that E(G 6 ) has a solution i and only i E has one. We just need to show that G S, the graph ater the execution o line (7), which comes ater a call to unction Sulist, is such that E(G S ) has a solution i and only i E has a solution. Observe that unction Sulist simply takes two nodes o the graph and calls Semiuniy on all descendants o both nodes rom let to right. Let s 1 ;:::;s k and t 1 ;:::;t k be the descendants 19

20 (subterms) o s and t respectively, i.e., s = (s 1 ;:::;s k ), and t = (t 1 ;:::;t k ) or some unctional symbol. We deine, or i 2 1;:::;kg the sets o equations E i = E(G (i 1) ) [ ' n s i? = ' m t i ;(s! 1 ;:::;s! i ;:::;s k)? = (t! 1 ;:::;t! i ;:::;t k)g; where G (i) is the graph that results ater the call Semiuniy(s i ;n;t i ;m), and G () = G 6. By the induction hypothesis, and since each o the calls to Semiuniy will generate less than n recursive calls, we have that E i has a solution i and only i E(G (i) ) has a solution. Using rule ) 7 we get the result we require. 2 Proposition 1 A set o equations E containing an equation o the orm ' n (x) = t, where b t is in the orm b t [' m x]; n» m, has no solution. Deinition 8 An equation o the orm ' n x = t, where b t has the orm b t [' m x]; n» m, is called unsolvable. Lemma 6 Let = t»? ug be an instance o semi-uniication, and let G and G S correspond to the graphs associated with and the graph resulting rom the call to Semiuniy on. Then, i the call to Cycle on G S returns alse, then there is no solution or G S. Proo: I Cycle returns alse on G S, then there is a bad cycle o the orm ' n 1 x 1 = ' m 1 s 1 ;:::;' nk x k = ' mk s k where s i [x i+1 ] or i 2 1;::::k 1g, and s k [x 1 ], or a cycle with a sel loop, which is analogous to a bad cycle. We now show, by induction on k, the number o equations in the cycle, that an unsolvable equation can be deduced rom the equations in the cycle. For one equation, ' n 1 x 1 = ' m 1 s 1 with s 1 [x 1 ], we observe that during the execution o Cycle the value c = cycle c ost(x 1 ) is greater than c + n 1 m 1, which means that n 1» m 1 and thereore the equation shown is unsolvable. We assume the result true or all integers smaller than k, and prove it now or k. The irst step is to reduce the equations ' n 1 x 1 = ' m 1 s 1 and ' n 2 x 2 = ' m 2 s 2. There are two cases that we have to consider. I m 1 n 2, using ) 1 we can get the equation ' n 1 = ' md 1 s 1 = s 1. We observe that s 1[' n 2 x 2 ], and thereore we can apply rule ) 8, to obtain the equation ' n 1 x 1 = s 1 ['m 1 n 2 +m 2 s 2 =' m 1 x 2]. We now have k 1 equations, and thereore we can conclude, by induction hypothesis, that an unsolvable equation can be derived. I m 1 < n 2 we irst apply ) 3 as many times as necessary to obtain the equation ' n 1+n 2 m 1 x 1 = ' n 2 s 1, and then we proceed as above. 2 Lemma 7 Let = t»? ug be an instance o semi-uniication, and let G and G S correspond to the graphs associated to and the graph resulting rom the call to Semiuniy on. Then, i the call to Cycle on G S returns true, then there is a solution or G S. 2

21 Proo: We show this by constructing a solution or the set o equations E(G S ). We irst note that i the equations are oriented in such a way that the class representative is on the right hand side, then we have one equation or each o the variables appearing in. The irst step in constructing the solution is to apply rule ) 8 to the set o equations until it can be applied no more. This is possible since there are no bad cycles in the graph. We also observe that the new set o equations obtained, we call it E 1, is such that Sol(E 1 ) = Sol(E(G S )). Once the above procedure is done, we know that no term appearing on the let-hand side o an equation appears on the let hand side o an equation. We now describe the procedure to build the solution. (This procedure is basically the same described by Kapur et. al. in [8]). We start with = ρ = ;. 1. Eliminate all occurrences o terms o the orm ' n (x) rom the right sides o equations in E 1 as ollows: While there is a term o the orm ' n ('(x)) on the right side o an equation in E 1, make ρ = ρ [ x 7! x g, where x is a resh variable, and replace '(x) with x in E Now build as ollows, or every equation o the orm x = t, where x is a variable make x = t. 3. Finish building ρ. For every remaining equation o the orm ' n x = t, we let ρ = ρ [ x 7! x 1 ;x 1 7! x 2 ;:::;x n 2 7! x n 1 ;x n 1 7! tg. It is trivial to check that and ρ are a solution to E 1. 2 The correctness o the decision procedure now ollows directly rom lemmas 4, 5, 6 and 7. Theorem 2 Let = t»? ug be a semi-uniication instance. Then the call to SU on returns true i and only i has a solution. 5.1 Complexity Analysis The decision procedure is based on the well known O(n(n)) uniication algorithm o Huet, where (n) is the inverse o Ackerman's unction [1], and n is the number o symbols in the semi-uniication instance. The central part is played by unction Semiuniy and it is easy to check that i the call is made with both numeric parameters equal to, then the algorithm would behave as Huet's algorithm or uniication. To analyze the complexity o the algorithm we count pointer assignments, comparisons o pointers or symbols, and primitive operations on bits. We consider the ollowing points: l Semiuniy is called at most n times, where n is the number o symbols in the original equation to be solved; l A sequence o O(n) calls to Union (implicit in our algorithm) and Find can be perormed with O(n(n)) assignments, comparisons, or additions o two numbers, where is the unctional inverse o Ackermann's unction [1]; 21

22 l All other operations add at most a constant number o assignments, comparisons, or additions/subtractions o two numbers to each call to Semiuniy; l The arithmetic operations o the algorithm may be analyzed as ollows: i we start with two numbers o constant size (number o bits), and create a list o O(m) new numbers by addition and subtraction o previous members o the list, we can create numbers o size at most O(m); thus at each step we need to do at most O(m) bit operations, which gives a total cost o O(m 2 ) (in our algorithm, m = n(n)). This gives us our complexity result. Theorem 3 Under the uniorm-cost RAM model (counting assignments, comparisons, additions and subtractions), a call to Semiuniy(s,j,t,k), where the combined size o s and t is n symbols, costs O(n(n)). For a RAM model counting assignments and bit operations, the cost is O(n 2 (n) 2 ) assignments, comparisons, or bit operations. Note that a Union-Find problem can be reduced to a Semi-Uniication problem in a trivial way, which shows that we cannot improve the O(n(n)) bound unless we can do the same or Union- Find, which is unlikely. What is interesting about this result is that the purely symbolic operations cost no more than or standard uniication (O(n(n)); the dominate cost is or the arithmetic on weights. In Section 8 we compare this result with previous algorithms, which do not closely analyze the cost o the arithmetic. 6 Solution Extraction 6.1 An Example o Solution Extraction The decision procedure described in Section 3 does not give enough inormation to construct the principal semi-uniier or a given instance. Consider the instance o the example in Section 4.1. In 1 this case, the links added by the algorithm to the original DAG are x - 5 (z; x); y - (z; x) 2 and z - y. Considering these links as equations we can deduce that xρ = (z; x), but this says nothing about x. In ollowing the execution o the decision procedure or this example we notice that there are three calls to the Semiuniy unction involving variable x. These calls represent links between x and the other terms involved. I an ordering is given to the variables, say z > y > x, and links are always assumed to be rom greater to smaller, then the links associated with x during execution 1 are x - 1 (z; x); x - 2 (y; z) and z - x. We can see these links as rewrite rules, and do a reduction. In this case, we can reduce the two links coming out o x, and keep the one with cost on x. This operation would produce a rewrite rule between the two terms, which can be ignored. I all these possible links coming out o variables are considered, what we get is a system o rewrite rules that can be used to extract the solution o an instance o uniorm semi-uniication. 22

23 We are interested in obtaining the semi-uniier, since the matching substitution is determined by the semi-uniier. The links obtained are: 2 z - 5 y - 1 x - 2 x z - (z; x) 1 (z; x) x - y (y; z) Ater simpliying the links rom z: 2 z - 5 y - 1 x - y 4 (z; x) y - 1 (z; x) x - x (y; z) Ater simpliying y: 2 z - 4 y - 1 x - y x 1 (z; x) x - 1 (y; z) x - (z; x) Finally, ater simpliying the links (rules) that correspond to x we have one link (rule) or each variable. The links that have a as the weight on the side o the variable indicate the. 2 z - 4 y y - 1 x x - (y; z) Which says that x = ρ((y; z)); y = y; z = yρρ. 6.2 The Solution-Extraction Procedure The algorithm or extracting a principal solution is an extension o the decision procedure. A ew more data structures are needed to extract the solution. Weights on the sel loops are added, since they also are links between nodes in the graph, and the weights on them are needed to obtain the solution. Sel loops on non-variable nodes have to be pushed to the descendant variable nodes. Also, a list o all links encountered during the decision procedure is kept to build. We also assume a total ordering > among the variables. The ollowing properties are added to the graph nodes: 23

24 1. slw : A pair o weights or a sel loop. I t is a term, slw:w1(t) denotes the irst element o the pair and slw:w2(t) the second. 2. extract : A list o links encountered during the decision procedure. The extraction algorithm starts by pushing the sel loops to the variables. It then pushes links between unctional symbol nodes that have not been pushed beore, which are those in the extract property o the nodes. Each pushed link is then removed rom extract. At the end, each o the links in the extract property o a variable is viewed as a rewrite rule. These rewrite rules are reduced until there is only one rewrite rule per variable. These rewrite rules deine the semi-uniier. Function SU calls unction Extract when the call to Semiuniy returns true. The Semiuniy unction in the decision procedure has to be modiied so that it initializes the properties slw and extract or each node. The change is basically to add to extract the link represented by the call. This is done right ater the check or a symbol clash. Also, the link between the class representatives is added to the extract property o one o them, making sure that the links are not in the extract property already. The other unctions used in the decision procedure o section 3 are the same. To save space, we do not show the modiied procedure since it is basically the same as or the decision part. The unction Extract receives as a parameter a graph that corresponds to the Semi-Uniication instance. It basically processes each variable in the graph until there is only one link associated with each variable, including sel loop. This is possible given that unction Semiuniy has determined that there is a solution, and this means that there are no bad loops in the resulting graph. At this point the graph is solved, and the links rom the variables indicate which is the semi-uniier. Function Pushlinks takes all links between two unctional nodes stored in the extract property o one o the nodes and pushes the links to the variables, so that simpliication can take place. Function Pushloops takes the sel loops in the graph and pushes them to the variables. I more than one sel loop is ound in a node they are simpliied in the same way as in unction Semiuniy and only one is pushed. The unction Simpliy var takes the list o extraction links o a variable and simpliies it until only one extraction link is let. These links are then used in the extraction o (the semi-uniier) and ρ (the matching substitution). The unction takes a pair o links and simpliies the one with the larger weight with the one with the smaller weight. This links are treated as rewrite rules. The code or the unction may now be given. Simpliy var(term t) // First simpliy the links on Extract, and then deal with a sel loop. // First choose the good link, and then simpliy the others. // We assume that the links in the extract property are sorted in ascending order using the // ordering o integer pairs induced by the normal integer order relation. i (extract is not empty) then Let l 1 be the smallest link in extract, with n 1 and m 2 as its costs or each link l 2 in extract 24

25 let n 2 and m 2 be the costs associated to l 2 // n 1» n 2 n // The links are t 1 m- 1 n t 1 and t 2 m- 2 t 2. // Where t 1 and t 2 are terms, and t is a variable. Remove l 2 rom extract Simpliy rule(l 2 ;l 1 ;t) end or i (t has a sel loop) then // sel-loop, simpliy n Let l be t m - t 1, the only link in extract while (slw:w1(t)» n) // slw:w1(t) slw:w2(t) n := (n slw:w1(t)) + slw:w2(t) end while n Let l 1 be a new link t 1 m- 1 t 1, where m 1 := (slw:w1(t) n) + m n 1 = slw:w2(t) i (n > n 1 ) then Simpliy rule(l; l 1 ;t) else Simpliy rule(l 1 ;l;t) Add l 1 to extract(t) and remove l. end i end i end i end Simpliy var The unction Simpliy rule simpliies the rewriting rule represented by t 1 using the one represented by t 2. Simpliy rule(link l 1 ; link l 2 ; term t) n // The two links are: t 1 m- 1 n t 1 and t 2 m- 2 t 2. Simpliication makes a link or t 1 and t 2 // I the two nodes are distinct unctional nodes, then the link must // be pushed to the variables. Otherwise a sel-loop must be processed. i (t 1 6= t 2 ) m := (n 1 n 2 ) + m 2 ; n := m 1 ; n Add link l = t m 1 - t 2 to extract(t 1 ). i ( unc(t 1 ) 6= null and unc(t 2 ) 6= null) // Both are unctional nodes. // The link has to be pushed to the variables and processed, // i there is no other link between the nodes. Otherwise ignore. i (there is no link between t 1 and t 2 ) PushLink(l); // Push the links to the variables or processing. end i end i else i (t 1 = t 2 ) then // This is a sel loop, process 25

26 i (n 6= m) then // I the costs are the same then this sel loop must be ignored. // Otherwise it has to be added i there is no sel loop, // or simpliied i there is another sel loop on the variable. i (exists sel loop on t 1 ) // I there is a sel loop then simpliy the sel loops. slw:w1(t 1 ) := gcd(abs(n m); abs(slw:w1(t 1 ) slw:w2(t 1 ))) i (m < slw:w2(t 1 )) slw:w1(t 1 ) := slw:w1(t 1 ) + m slw:w2(t 1 ) = m else slw:w1(t 1 ) := slw:w1(t 1 ) + slw:w2(t 1 ) end i else // There is no previous sel loop. Add a sel loop on t 1 slw:w1(t 1 ) := maxn; mg slw:w2(t 1 ) := minn; mg end i end i i (t 1 is a unctional symbol) Pushsubterm(t 1 ;slw(t 1 )) end i // I the term is a unctional symbol, push sel loop end i end Simpliy rule 6.3 Correctness o Principal Solution Extraction The proo o correctness o the principal solution extraction procedure is very simlar to the one or the decision procedure o section 3. We have to change the deinition o the set o equations represented by the graph. Deinition 9 For any graph G obtained rom a semi-uniication instance through a call to unction SU the set o equations represented by G is: E(G) = ' n s =? ' m n t j there is an unmarked arc s m - t in extract(s) [ extract(t)g[ ' n s =? ' m s j a sel-loop was added to s with weights m; ng 26

27 The main dierence between the two procedures is that the principal solution extraction keeps all the links encountered during the algorithm, and thereore the set o solutions is preserved. The set o equations that a graph represents is now given by the unmarked links stored in the extract property o the nodes. We start by showing that the algorithm terminates. It is obvious that the new unction Semiuniy ends since it is basically the same as in section 3. Lemma 8 A call to unction Simpliy var terminates. Proo: The unction simply takes all links on the extract property o a node and removes them one by one, until only one is let. The only unction calls inside Simpliy var are to Simpliy rule, which obviously terminates i there are no sel loops involved. I there is a sel loop involved, the only problem would be to have a cycle preventing termination. This is not possible since the decision procedure would have detected a cycle with a sel loop. 2 The equation transormations deined in section 5 are now dierent, since we don't have to deal with the elimination o certain equations rom the original set. The transormations are now basically the same as those in section 2. The transormations are: Deinition 1 Let E be a set o equations on '-terms, and let s; t, and u be '-terms. l E [ s =? tg ) E [ t =? sg. l E [ s =? tg ) 1 E [ ^t =? ^sg. l E [ ' n (s 1 ;:::;s n )=? ' m (t 1 ;:::;t n )g ) 2 E [ (s 1 ;:::;s! i ;:::;s n)=? (t 1 ;:::;t! i ;:::;t n);s i =? t i g or some i 2 1;:::;ng with s i and t i unmarked. l E [ s =? t; t =? ug ) 3 E [ s =? u; s =? t t =? ug. l E [ (s! 1 ;:::;s! n)=? (t! 1 ;:::;t! n)g ) 4 E. l E [ s[' n x]=? t; ' n x =? ug ) 5 E [ s[u=' n x]=? t; ' n x =? ug. Let ) = ) [ ) 1 [ :::[ ) 5. The ollowing may be proved easily by inspection o the rules. Proposition 2 I E ) E then Sol(E) = Sol(E ). We now need to show that the sets o equations corresponding to the dierent graphs produced by the procedure described above can also be obtained through some sequence o transormations, starting rom the set o equations that corresponds to the irst graph. 27