Approximation: Theory and Algorithms

Transcription

1 Approximation: Theory and Algorithms The Tree Edit Distance (II) Nikolaus Augsten Free University of Bozen-Bolzano Faculty of Computer Science DIS Unit 7 April 17, 2009 Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

2 Outline 1 Tree Edit Distance (II) The Tree Edit Distance Algorithm 2 Conclusion Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

3 First Recursive Formula: Forest Distance Lemma (First Recursive Formula) Given two trees T 1 and T 2, i N(T 1 ) and d i desc(i), j N(T 2 ) and d j desc(j), then: fdist(t 1 [l(i)..d i 1], T 2 [l(j)..d j ]) + ω del fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j 1]) + ω ins fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j ]) = min fdist(t 1 [l(i)..l(d i ) 1], T 2 [l(j)..l(d j ) 1]) + fdist(t 1 [l(d i )..d i 1], T 2 [l(d j )..d j 1]) + ω ren Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

4 Proof Tree Edit Distance (II) Proof. Let M be the minimum-cost map between T 1 [l(i)..d i ] and T 2 [l(j)..d j ], i.e., the map we are looking for. Then for T 1 [d i ] and T 2 [d j ] there are tree possibilities: (1) T 1 [d i ] is not touched by a line in M: T 1 [d i ] is deleted and fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j ]) = fdist(t 1 [l(i)..d i 1], T 2 [l(j)..d j ]) + ω del (2) T 2 [d j ] is not touched by a line in M: T 2 [d j ] is inserted and fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j ]) = fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j 1]) + ω ins (3) Both, T 1 [d i ] and T 2 [d j ] are touched by a line in M: We show (by contradiction) that in this case (T 1 [d i ], T 2 [d j ]) M, i.e., T 1 [d i ] is renamed to T 2 [d j ]: Assume (T 1 [d i ], T 2 [d i ]) M and (T 1[d j ], T 2[d j ]) M. Case T 1 [d i ] is to the right of T 1 [d j ]: By sibling condition on M also T 2 [d i ] must be to the right of T 2[d j ]. Impossible in T 2 [l(j)..d j ]. Case T 1 [d i ] is proper ancestor of T 1 [d j ]: By ancestor condition on M also T 2 [d i ] must be ancestor of T 2[d j ]. Impossible in T 2 [l(j)..d j ]. As these three cases express all possible mappings yielding fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j ]), we take the minimum of these tree costs. Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

5 Example: First Recursive Formula (1/3) T 1 f 6 d 4 a 1 c 3 b 2 e 5 T 2 f 6 c 4 d 3 a 1 b 2 e 5 T 1 [l(i)..d i ] T 2 [l(j)..d j ] (i = 6, d i = 3) (j = 6, d j = 3) (1) fdist(t 1 [l(i)..d i 1], T 2 [l(j)..d j ]) + ω del a 1 c 3 b 2 d 3 a 1 b 2 T 1 [l(i)..d i 1] T 2 [l(j)..d j ] edit script: ins(d 3 ), del(c 3 ) cost: = 2 Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

6 Example: First Recursive Formula (2/3) T 1 f 6 d 4 a 1 c 3 b 2 e 5 T 2 f 6 c 4 d 3 a 1 b 2 e 5 T 1 [l(i)..d i ] T 2 [l(j)..d j ] (i = 6, d i = 3) (j = 6, d j = 3) (2) fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j 1]) + ω ins a 1 c 3 b 2 d 3 a 1 b 2 T 1 [l(i)..d i 1] T 2 [l(j)..d j ] edit script: del(c 3 ), ins(d 3 ) cost: = 2 Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

7 Example: First Recursive Formula (3/3) (3) fdist(t 1 [l(i)..l(d i ) 1], T 2 [l(j)..l(d j ) 1]) + fdist(t 1 [l(d i )..d i 1], T 2 [l(d j )..d j 1]) + ω ren a 1 c 3 b 2 d 3 a 1 b 2 T 1 [l(i)..l(d i ) 1] T 1 [l(d i )..d i 1] T 2 [l(j)..l(d j ) 1] T 2 [l(d j )..d j 1] T 1 [l(i)..l(d i ) 1] T 2 [l(j)..l(d j ) 1]: del(a 1 ) T 1 [l(d i )..d i 1] T 2 [l(d j )..d j 1]: ins(a 1 ) c 3 d 3 : ren(c 3, d 3 ) cost: = 3 Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

8 Analogy to the String Case Why is the third formula not (in analogy to the string case): fdist(t 1 [l(i)..d i 1], T 2 [l(j)..d j 1]) + ω ren Consider the previous example: a 1 c 3 d 3 b 2 a 1 b 2 T 1 [l(i)..d i 1] T 2 [l(j)..d j 1] ren(c 3, d 3 ) does not transform T 1 [l(i)..d i ] to T 2 [l(j)..d j ] In fact the mapping M = {(a 1, a 1 ), (b 2, b 2 ), (c 3, d 3 )} is not valid: Connect all trees in the forest with a dummy node ( ): As d 3 is an ancestor of a 1, c 3 must be an ancestor of a 1, which is false. a 1 c 3 b 2 d 3 a 1 b 2 Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

9 Observation Tree Edit Distance (II) Observation about the First Recursive Formula: suggests bottom-up dynamic programming algorithm fdist(t 1 [l(d i )..d i 1], T 2 [l(d j )..d j 1]) [D] does not fit this scheme We derive the Second Recursive Formula: we distinguish two cases (both forests are trees/one forest is not a tree) in each case we replace term [D] by a new term that is easier to handle in a bottom up algorithm fdist(t 1 [l(i)..d i 1], T 2 [l(j)..d j ]) + ω del fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j 1]) + ω ins fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j ]) = min fdist(t 1 [l(i)..l(d i ) 1], T 2 [l(j)..l(d j ) 1]) + fdist(t 1 [l(d i )..d i 1], T 2 [l(d j )..d j 1]) + ω ren Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

10 Second Recursive Formula: Forest Distance Lemma (Second Recursive Formula) Given two trees T 1 and T 2, i N(T 1 ) and d i desc(i), j N(T 2 ) and d j desc(j), then: (1) If l(i) = l(d i ) and l(j) = l(d j ), i.e., both forests are trees: fdist(t 1 [l(i)..d i 1], T 2 [l(j)..d j ]) + ω del fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j ]) = min fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j 1]) + ω ins fdist(t 1 [l(i)..d i 1], T 2 [l(j)..d j 1]) + ω ren (2) If l(i) l(d i ) and/or l(j) l(d j ), i.e., one of the forests is not a tree: fdist(t 1 [l(i)..d i 1], T 2 [l(j)..d j ]) + ω del fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j 1]) + ω ins fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j ]) = min fdist(t 1 [l(i)..l(d i ) 1], T 2 [l(j)..l(d j ) 1]) + fdist(t 1 [l(d i )..d i ], T 2 [l(d j )..d j ]) Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

11 Proof of the Second Recursive Formula Proof. (1) follows from the previous recursive formula for l(i) = l(d i ) and l(j) = l(d j ) as the following holds: fdist(t 1 [l(i)..l(d i ) 1], T 2 [l(j)..l(d j ) 1]) = fdist(, ) = 0. (2) The following inequation holds: [A] fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j ]) fdist(t 1 [l(i)..l(d i ) 1], T 2 [l(j)..l(d j ) 1]) [B] + fdist(t 1 [l(d i )..d i ], T 2 [l(d j )..d j ]) [C] fdist(t 1 [l(i)..l(d i ) 1], T 2 [l(j)..l(d j ) 1]) [B] + fdist(t 1 [l(d i )..d i 1], T 2 [l(d j )..d j 1]) [D] + ω ren A B + C as the left-hand side is the minimal cost mapping, while the right-hand side is a particular case with a possibly sub-optimal mapping. C D + ω ren holds for the same reason. As we are looking for the minimum distance, we can substitute D + ω ren by C. Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

12 Illustration: Proof of the Second Recursive Formula (1/2) Case (1): l(i) = l(d i ) and l(j) = l(d j ): i j d i d j l(i) = l(d i ) l(j) = l(d j ) T 1 [l(i)..l(d i ) 1] T 1 [l(d i )..d i 1] T 2 [l(j)..l(d j ) 1] T 2 [l(d j )..d j 1] Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

13 Illustration: Proof of the Second Recursive Formula (2/2) Case (2): l(i) l(d i ) and/or l(j) l(d j ): i j d i d j l(i) l(d i ) T 1 [l(i)..l(d i ) 1] T 1 [l(d i )..d i 1] l(j) l(d j ) T 2 [l(j)..l(d j ) 1] T 2 [l(d j )..d j 1] Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

14 Implications by the Second Recursive Formula Note: fdist(t 1 [l(d i )..d i ], T 2 [l(d j )..d j ] is the tree edit distance between the subtrees rooted in T[d i ] and T[d j ]. We use the following notation: treedist(d i, d j ) = fdist(t 1 [l(d i )..d i ], T 2 [l(d j )..d j ]) Dynamic Programming: As the same sub-problem must be solved many times, we use a dynamic programming approach. Bottom-Up: As for the computation of the tree distance treedist(i, j) we need almost all values treedist(d i, d j ) (d i desc(t 1 [i]), d j desc(t 1 [j])), we use a bottom-up approach. Key Roots: If d i is on the path from l(i) to T 1 [i] and d j is on the path from l(j) to T 2 [j], then treedist(d i, d j ) is computed as a byproduct of treedist(i, j). We call the nodes that are not computed as a byproducts the key roots. Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

15 Key Roots Tree Edit Distance (II) Definition (Key Root) The set of key roots of a tree T is defined as kr(t) = {k N(T) k N(T) : k > k and l(k) = l(k )} Alternative definition: A key root is a node of T that either has a left sibling or is the root of T. Example: kr(t) = {3, 5, 6} f 6 d 4 e 5 a 1 c 3 b 2 Only subtrees rooted in a key root need a separate computation. The number of key roots is equal to the number of leaves in the tree. Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

16 The Edit Distance Algorithm I/II The Tree Edit Distance Algorithm tree-edit-dist(t 1, T 2 ) td[1.. T 1, 1.. T 2 ] : empty array for tree distances; l 1 = lmld(root(t 1 )); kr 1 = kr(l 1, leaves(t 1 ) ); l 2 = lmld(root(t 2 )); kr 2 = kr(l 2, leaves(t 2 ) ); for x = 1 to kr 1 do for y = 1 to kr 2 do forest-dist(kr 1 [x], kr 2 [y], l 1, l 2, td); l 1 is an array of size T 1, l 1 [i] is the leftmost leaf descendant of node i; l 2 is the analog for T 2 (detailed algorithm lmld(.) follows) kr 1 is an array that contains all the key roots of T 1 sorted in ascending order; kr 2 is the analog for T 2 (detailed algorithm kr(.,.) follows) Algorithm and lemmas by [ZS89] (see also [AG97]) Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

17 The Edit Distance Algorithm II/II The Tree Edit Distance Algorithm forest-dist(i, j, l 1, l 2, td) fd[l 1 [i] 1..i, l 2 [j] 1..j] : empty array; fd[l 1 [i] 1, l 2 [j] 1] = 0; for d i = l 1 [i] to i do fd[d i, l 2 [j] 1] = fd[d i 1, l 2 [j] 1] + ω del ; for d j = l 2 [j] to j do fd[l 1 [i] 1, d j ] = fd[l 1 [i] 1, d j 1] + ω ins ; for d i = l 1 [i] to i do for d j = l 2 [j] to j do if l 1 [d i ] = l 1 [i] and l 2 [d j ] = l 2 [j] then fd[d i, d j ] = min(fd[d i 1, d j ] + ω del, fd[d i, d j 1] + ω ins, fd[d i 1, d j 1] + ω ren ); td[d i, d j ] = f [d i, d j ]; else fd[d i, d j ] = min(fd[d i 1, d j ] + ω del, fd[d i, d j 1] + ω ins, fd[l 1 [d i ] 1, l 2 [d j ] 1] + td[d i, d j ]); Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

18 The Tree Edit Distance Algorithm The Temporary Forest Distance Matrix fd[d i, d j ] contains the forest distance between T 1 [l(i)..d i ], where d i desc(t 1 [i]) and T 2 [l(j)..d j ], where d j desc(t 2 [j]). d j d i = T 1 [l(i)..l(i) 1] T 1 [l(i)..l(i)] T 1 [l(i)..i] T 2 [l(j)..l(j) 1] = T 2 [l(j)..l(j)] T 2 [l(j)..j] fdist(t 1 [l(i)..d i ], T 2 [l(j)..d j ]) fd is temporary and exists only in forest-dist() Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

19 The Tree Distance Matrix The Tree Edit Distance Algorithm td[i][j] stores the tree edit distance between the tree rooted in T 1 [i] (i.e., T 1 [l(i)..i]) and the tree rooted in T 2 [j] (i.e., T 2 [l(j)..j]). each call of forest-dist() fills new values into td td[ T 1, T 2 ] stores the tree edit distance between T 1 and T 2 Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

20 Summary Conclusion Tree Edit Distance recursive formula for the edit distance dynamic programming algorithm Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

21 What s Next? Conclusion Tree Edit Distance (III): correctness and complexity of the algorithm edit distance variants Lower Bounds for the Edit Distance Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23

22 Alberto Apostolico and Zvi Galill, editors. Pattern Matching Algorithms, chapter Tree Pattern Matching, pages Oxford University Press, Kaizhong Zhang and Dennis Shasha. Simple fast algorithms for the editing distance between trees and related problems. SIAM Journal on Computing, 18(6): , Nikolaus Augsten (DIS) Approximation: Theory and Algorithms Unit 7 April 17, / 23