Equational Reasoning in THEOREMA

Transcription

1 Research Institute for Symbolic Computation Johannes Kepler University of Linz, Austria Workshop on Formal Gröbner Bases Theory. March 8, Linz, Austria

2 Outline 1 2

3 Equational Prover of THEOREMA Equational Prover Method and Implementation A prover for unit equalities in the first order or applicative higher order form. Based on unfailing completion. Fully automatic (no user interaction during run time). Allows sequence variables in the input. Has access to MATHEMATICA functions. Nice input and output.

4 Simple Examples Equational Prover Method and Implementation Example (Boolean Algebra. First Order Form.) Given Boolean algebra axioms: x x + 0 = x x x + ( x) = 1 x,y x,y x + y = y + x x y = y x x,y,z x + (y z) = (x + y) (x + z) x,y,z x (y + z) = (x y) + (x z) x x 1 = x x x ( x) = 0 Prove idempotence of multiplication: x x x = x

5 Simple Examples Equational Prover Method and Implementation Example (Combinatory Logic. Higher Order Form.) Given the definitions of M and Q combinators: x,y,z x M(x) = x(x) Q(x)(y)(z) = y(x(z)) Prove existence of a fixpoint: x y y = x(y)

6 Method Equational Prover Method and Implementation Completion without failure (Bachmair, Dershowitz, Plaisted). Unfailing variant of Knuth-Bendix completion. Critical pair/completion method, related to Gröbner bases.

7 Equational Prover Method and Implementation Unfailing Completion. The Procedure Function ProveByCompletion(E, G, >) 1: (A, P):=(, E) 2: while trivial(g) P = do 3: e :=Select(P); P := P\{e} 4: if orphan(e) then 5: e :=Normalize > A (e) 6: if redundant(e) then 7: (A, P 1 ):=Interred > (A, e) 8: A := A {Orient > (e)} 9: P 2 :=CP > (e, A) 10: P := P Normalize > A (P 1 P 2 ) 11: 12: end G :=Normalize > A (G) 13: end 14: end 15: return trivial(g)

8 Organization of Passive Facts Equational Prover Method and Implementation The set P can grow very big. Challenges: 1 How to select the minimal equality fast. 2 How to store P compactly. 3 How to delete redundant equalities from P fast. Solution idea: 1 Organize P as pairing heaps. 2 Store in heaps only the information necessary to select and delete equalities. 3 Keep terms separately as stringterms and refer to them when needed.

9 Organization of Passive Facts Equational Prover Method and Implementation The set P can grow very big. Challenges: 1 How to select the minimal equality fast. 2 How to store P compactly. 3 How to delete redundant equalities from P fast. Solution idea: 1 Organize P as pairing heaps. 2 Store in heaps only the information necessary to select and delete equalities. 3 Keep terms separately as stringterms and refer to them when needed.

10 Organization of Passive Facts Equational Prover Method and Implementation The set P can grow very big. Challenges: 1 How to select the minimal equality fast. 2 How to store P compactly. 3 How to delete redundant equalities from P fast. Solution idea: 1 Organize P as pairing heaps. 2 Store in heaps only the information necessary to select and delete equalities. 3 Keep terms separately as stringterms and refer to them when needed.

11 Organization of Passive Facts Equational Prover Method and Implementation The set P can grow very big. Challenges: 1 How to select the minimal equality fast. 2 How to store P compactly. 3 How to delete redundant equalities from P fast. Solution idea: 1 Organize P as pairing heaps. 2 Store in heaps only the information necessary to select and delete equalities. 3 Keep terms separately as stringterms and refer to them when needed.

12 Organization of Passive Facts Equational Prover Method and Implementation The set P can grow very big. Challenges: 1 How to select the minimal equality fast. 2 How to store P compactly. 3 How to delete redundant equalities from P fast. Solution idea: 1 Organize P as pairing heaps. 2 Store in heaps only the information necessary to select and delete equalities. 3 Keep terms separately as stringterms and refer to them when needed.

13 Organization of Passive Facts Equational Prover Method and Implementation The set P can grow very big. Challenges: 1 How to select the minimal equality fast. 2 How to store P compactly. 3 How to delete redundant equalities from P fast. Solution idea: 1 Organize P as pairing heaps. 2 Store in heaps only the information necessary to select and delete equalities. 3 Keep terms separately as stringterms and refer to them when needed.

14 Organization of Passive Facts Equational Prover Method and Implementation The set P can grow very big. Challenges: 1 How to select the minimal equality fast. 2 How to store P compactly. 3 How to delete redundant equalities from P fast. Solution idea: 1 Organize P as pairing heaps. 2 Store in heaps only the information necessary to select and delete equalities. 3 Keep terms separately as stringterms and refer to them when needed.

15 Organization of Passive Facts Equational Prover Method and Implementation The set P can grow very big. Challenges: 1 How to select the minimal equality fast. 2 How to store P compactly. 3 How to delete redundant equalities from P fast. Solution idea: 1 Organize P as pairing heaps. 2 Store in heaps only the information necessary to select and delete equalities. 3 Keep terms separately as stringterms and refer to them when needed.

16 Organization of Passive Facts Equational Prover Method and Implementation The set P can grow very big. Challenges: 1 How to select the minimal equality fast. 2 How to store P compactly. 3 How to delete redundant equalities from P fast. Solution idea: 1 Organize P as pairing heaps. 2 Store in heaps only the information necessary to select and delete equalities. 3 Keep terms separately as stringterms and refer to them when needed.

17 Organization of Passive Facts Equational Prover Method and Implementation Each equality carries the following information: Unique number assigned to it at the moment when the equality is generated: an ID. Example Weight (number of symbols in the sides of equality). ID of the First parent. ID of the Second parent. Assume f (x, f (a, x)) = a is the 123rd equality generated by the procedure as a critical pair of equalities 115 and 7. Then the tuple attached to this equality is 123, 6, 115, 7.

18 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) P is organized in paired heaps, two-layers: Lower layer: Collection of heaps, e.g. 3,7,8,10. The heap 3 contains (the encoding of) all critical pairs whose first parent is 3. Each lower heap: ordered by the given priority, e.g. weight, with minimal element in the top (small red triangle).

19 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) P is organized in paired heaps, two-layers: Lower layer: Collection of heaps, e.g. 3,7,8,10. The heap 3 contains (the encoding of) all critical pairs whose first parent is 3. Each lower heap: ordered by the given priority, e.g. weight, with minimal element in the top (small red triangle).

20 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) P is organized in paired heaps, two-layers: Lower layer: Collection of heaps, e.g. 3,7,8,10. The heap 3 contains (the encoding of) all critical pairs whose first parent is 3. Each lower heap: ordered by the given priority, e.g. weight, with minimal element in the top (small red triangle).

21 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) P is organized in paired heaps, two-layers: Lower layer: Collection of heaps, e.g. 3,7,8,10. The heap 3 contains (the encoding of) all critical pairs whose first parent is 3. Each lower heap: ordered by the given priority, e.g. weight, with minimal element in the top (small red triangle).

22 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) Upper heap consists of all top elements of lower heaps. Upper heap is ordered in the same way as the lowers. Select takes the topmost element of the upper heap. Assume its first parent was 7. Then: This element is removed also from the top of the heap 7. Heap 7 is rearranged. New minimal element on the top. The new minimal element of the heap 7 comes to the upper heap that is rearranged. No other heap is touched.

23 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) Upper heap consists of all top elements of lower heaps. Upper heap is ordered in the same way as the lowers. Select takes the topmost element of the upper heap. Assume its first parent was 7. Then: This element is removed also from the top of the heap 7. Heap 7 is rearranged. New minimal element on the top. The new minimal element of the heap 7 comes to the upper heap that is rearranged. No other heap is touched.

24 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) Upper heap consists of all top elements of lower heaps. Upper heap is ordered in the same way as the lowers. Select takes the topmost element of the upper heap. Assume its first parent was 7. Then: This element is removed also from the top of the heap 7. Heap 7 is rearranged. New minimal element on the top. The new minimal element of the heap 7 comes to the upper heap that is rearranged. No other heap is touched.

25 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) Upper heap consists of all top elements of lower heaps. Upper heap is ordered in the same way as the lowers. Select takes the topmost element of the upper heap. Assume its first parent was 7. Then: This element is removed also from the top of the heap 7. Heap 7 is rearranged. New minimal element on the top. The new minimal element of the heap 7 comes to the upper heap that is rearranged. No other heap is touched.

26 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) Upper heap consists of all top elements of lower heaps. Upper heap is ordered in the same way as the lowers. Select takes the topmost element of the upper heap. Assume its first parent was 7. Then: This element is removed also from the top of the heap 7. Heap 7 is rearranged. New minimal element on the top. The new minimal element of the heap 7 comes to the upper heap that is rearranged. No other heap is touched.

27 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) Upper heap consists of all top elements of lower heaps. Upper heap is ordered in the same way as the lowers. Select takes the topmost element of the upper heap. Assume its first parent was 7. Then: This element is removed also from the top of the heap 7. Heap 7 is rearranged. New minimal element on the top. The new minimal element of the heap 7 comes to the upper heap that is rearranged. No other heap is touched.

28 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) Upper heap consists of all top elements of lower heaps. Upper heap is ordered in the same way as the lowers. Select takes the topmost element of the upper heap. Assume its first parent was 7. Then: This element is removed also from the top of the heap 7. Heap 7 is rearranged. New minimal element on the top. The new minimal element of the heap 7 comes to the upper heap that is rearranged. No other heap is touched.

29 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) Upper heap consists of all top elements of lower heaps. Upper heap is ordered in the same way as the lowers. Select takes the topmost element of the upper heap. Assume its first parent was 7. Then: This element is removed also from the top of the heap 7. Heap 7 is rearranged. New minimal element on the top. The new minimal element of the heap 7 comes to the upper heap that is rearranged. No other heap is touched.

30 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) When an active equality from A gets reduced by Interred: Entire heap whose first parent was the reduced equality is deleted at once. (e.g. heap 8) Upper heap is rearranged. Other lower heaps might contain elements whose second parent was the reduced equality. They remain in the heaps and get removed by the orphan test after selection.

31 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) When an active equality from A gets reduced by Interred: Entire heap whose first parent was the reduced equality is deleted at once. (e.g. heap 8) Upper heap is rearranged. Other lower heaps might contain elements whose second parent was the reduced equality. They remain in the heaps and get removed by the orphan test after selection.

32 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) When an active equality from A gets reduced by Interred: Entire heap whose first parent was the reduced equality is deleted at once. (e.g. heap 8) Upper heap is rearranged. Other lower heaps might contain elements whose second parent was the reduced equality. They remain in the heaps and get removed by the orphan test after selection.

33 Equational Prover Method and Implementation Organization of Passive Facts (Cont.) When an active equality from A gets reduced by Interred: Entire heap whose first parent was the reduced equality is deleted at once. (e.g. heap 8) Upper heap is rearranged. Other lower heaps might contain elements whose second parent was the reduced equality. They remain in the heaps and get removed by the orphan test after selection.

34 Normalization Equational Prover Method and Implementation Programming language of Mathematica is a rewrite rule language. Idea: use Mathematica assignment rules for rewriting. Rewrite rules are transformed into Mathematica assignments. Equalities are transformed into Mathematica conditional assignments. Advantages: Probably the fastest way of doing rewriting in Mathematica. No need of implementing special data structures for rewriting. Disadvantages: Minimal control on rewriting strategies. Can not keep track of results of single rewrite steps. Additional effort needed to prevent unrestricted evaluation.

35 Normalization Equational Prover Method and Implementation Programming language of Mathematica is a rewrite rule language. Idea: use Mathematica assignment rules for rewriting. Rewrite rules are transformed into Mathematica assignments. Equalities are transformed into Mathematica conditional assignments. Advantages: Probably the fastest way of doing rewriting in Mathematica. No need of implementing special data structures for rewriting. Disadvantages: Minimal control on rewriting strategies. Can not keep track of results of single rewrite steps. Additional effort needed to prevent unrestricted evaluation.

36 Normalization Equational Prover Method and Implementation Programming language of Mathematica is a rewrite rule language. Idea: use Mathematica assignment rules for rewriting. Rewrite rules are transformed into Mathematica assignments. Equalities are transformed into Mathematica conditional assignments. Advantages: Probably the fastest way of doing rewriting in Mathematica. No need of implementing special data structures for rewriting. Disadvantages: Minimal control on rewriting strategies. Can not keep track of results of single rewrite steps. Additional effort needed to prevent unrestricted evaluation.

37 Normalization Equational Prover Method and Implementation Programming language of Mathematica is a rewrite rule language. Idea: use Mathematica assignment rules for rewriting. Rewrite rules are transformed into Mathematica assignments. Equalities are transformed into Mathematica conditional assignments. Advantages: Probably the fastest way of doing rewriting in Mathematica. No need of implementing special data structures for rewriting. Disadvantages: Minimal control on rewriting strategies. Can not keep track of results of single rewrite steps. Additional effort needed to prevent unrestricted evaluation.

38 Normalization Equational Prover Method and Implementation Programming language of Mathematica is a rewrite rule language. Idea: use Mathematica assignment rules for rewriting. Rewrite rules are transformed into Mathematica assignments. Equalities are transformed into Mathematica conditional assignments. Advantages: Probably the fastest way of doing rewriting in Mathematica. No need of implementing special data structures for rewriting. Disadvantages: Minimal control on rewriting strategies. Can not keep track of results of single rewrite steps. Additional effort needed to prevent unrestricted evaluation.

39 Normalization Equational Prover Method and Implementation Programming language of Mathematica is a rewrite rule language. Idea: use Mathematica assignment rules for rewriting. Rewrite rules are transformed into Mathematica assignments. Equalities are transformed into Mathematica conditional assignments. Advantages: Probably the fastest way of doing rewriting in Mathematica. No need of implementing special data structures for rewriting. Disadvantages: Minimal control on rewriting strategies. Can not keep track of results of single rewrite steps. Additional effort needed to prevent unrestricted evaluation.

40 Normalization Equational Prover Method and Implementation Programming language of Mathematica is a rewrite rule language. Idea: use Mathematica assignment rules for rewriting. Rewrite rules are transformed into Mathematica assignments. Equalities are transformed into Mathematica conditional assignments. Advantages: Probably the fastest way of doing rewriting in Mathematica. No need of implementing special data structures for rewriting. Disadvantages: Minimal control on rewriting strategies. Can not keep track of results of single rewrite steps. Additional effort needed to prevent unrestricted evaluation.

41 Normalization Equational Prover Method and Implementation Programming language of Mathematica is a rewrite rule language. Idea: use Mathematica assignment rules for rewriting. Rewrite rules are transformed into Mathematica assignments. Equalities are transformed into Mathematica conditional assignments. Advantages: Probably the fastest way of doing rewriting in Mathematica. No need of implementing special data structures for rewriting. Disadvantages: Minimal control on rewriting strategies. Can not keep track of results of single rewrite steps. Additional effort needed to prevent unrestricted evaluation.

42 Orderings Equational Prover Method and Implementation The prover implements three orderings: LPO: Lexicographic path ordering. KBO: Knuth-Bendix ordering. MPOSV: Multiset path ordering, extended for sequence variables. Comparison wrt to ordering is costly. LPO and MPOSV compare the same pair of terms many times. To speed up the process, results of the comparisons are cashed. On the next attempt of comparison, first the result is looked up in the cash. Cash size can be changed by the user.

43 Critical Pair Generation Equational Prover Method and Implementation Requires unification between a side of the selected equation and subterms of active facts. To avoid many unsuccessful unification attempts, the subterms of active parts are stored in the index. Unifiability retrieval operation for a given term: Goes through the index. If an element in the index has a chance to be unified with the given term, selects it. Passes the selected element and the given term to the unification algorithm that finally decides whether the pair is indeed unifiable or not. Unification algorithm is the Robinson algorithm extended with sequence variables in the last argument positions (Unification remans unitary).

44 Existential Goals Equational Prover Method and Implementation If the goal contains an existential quantifier, e.g. u s(u) = t(u), then: Introduce a new binary function symbols eq. Introduce two new constants true and false. Add u eq(s(u), t(u)) = false to the knowledge base E. Add x eq(x, x) = true to the knowledge base E. Make a new goal true = false. Run the unfailing completion procedure on the new knowledge base and goal. Keep eye on the binding for u. It will provide the witness term for the original goal.

45 Equational Prover Method and Implementation Equational Problems in Higher Order Form The prover accepts input in the applicative higher order form. The input is translated by Warren s method into first-order syntax. Unfailing completion is run on the problem in the translated form. First-order output is translated back into applicative higher order form. The user sees only higher order input and output, while the deduction is performed on the first-order level.

46 Warren s Translation. Example Equational Prover Method and Implementation Example Equality in the applicative higher order form: Translated into first order form: twice(f)(x) = F(F(X)). twice(f, X) = apply(f, apply(f, X)) apply(twice 0, F) = twice 1 (F) apply(twice 1 (F), X) = twice(f, X) where apply is a new binary function and twice 0 and twice 1 are new constructors representing partial applications.

47 Access to Mathematica Built-Ins Equational Prover Method and Implementation Mathematica built-in functions can be incorporated into the deduction process. It should be explicitly declared a function to be a Mathematica built-in function. A function can get its built-in Mathematica meaning only at the phase of checking joinability of the goal. Result of computation is not checked. Rather, a corresponding warning message is issued.

48 Modes Equational Prover Method and Implementation The prover has two proving modes Unfailing completion. Simplification. In the simplification mode: All equalities are (tried to be) oriented with respect to given ordering and are used rewrite the goal. No critical pairs are generated (Existential goals are treated in a special way. Narrowing).

49 Prover Architecture Equational Prover Method and Implementation The prover consists of three parts: 1 Preprocessor: Checks the input syntax, Skolemizes, sets option values, a proving mode, and an ordering. 2 Kernel: Runs a proof procedure (unfailing completion or simplification) with the chosen settings. 3 Proof presenter: Structures the output of the kernel, Deletes redundant steps, Introduces lemmata, Displays the proof. (Based on Proof Communication Language of Denzinger and Schulz)

50 The Last Demo on Equational Prover Method and Implementation Example: A ring with idempotent multiplication is commutative.

51 Reference Equational Prover Method and Implementation T. Kutsia. Equational prover of THEOREMA. In R. Nieuwenhuis, editor, Proc. of the 14th Int. Conf. on Rewriting Techniques and Applications, RTA 03, volume 2706 of LNCS, pages , Valencia, Spain, Springer.

52 in THEOREMA Methods in THEOREMA Matching with Regular Constraints We have already encountered solving examples: Finding unifiers for building critical pairs: term equations. Finding matchers for rewriting: term equations with one ground side. Orienting equalities into rewrite rules: ordering constraints.

53 in THEOREMA Methods in THEOREMA Matching with Regular Constraints Various solving methods have found its way in different parts of the THEOREMA system: Robinson unification. Unification of higher-order patterns. Unification with sequence variables. LPO, KBO, and MPOSV constraints. MATHEMATICA solving algorithms. Matching.... In this talk: Matching with regular constraints.

54 What is Matching? Methods in THEOREMA Matching with Regular Constraints Match a term s to a term t: Find an substitution ϑ such that sϑ and t are identical. t is a ground term. s might contain various kinds of variables: individual, function, sequence, context. Why do we have so many different kinds of variables?

55 Matching Methods in THEOREMA Matching with Regular Constraints A matching substitution should map individual variables to terms, function variables to function symbols/variables, sequence variables to sequences of terms, context variables to contexts (terms with a single "hole"). How to compute matching substitutions?

56 Matching Methods in THEOREMA Matching with Regular Constraints Moreover, some variables that occur in s may be constrained by regular expressions. What is it good for? How to compute matching substitutions that satisfy the constraints?

57 Try to Match Methods in THEOREMA Matching with Regular Constraints C(f (x)) g(f (a, b), h(f (a), f )) g C f x a f b f a h f C context variable. x sequence variable.

58 First Solution Methods in THEOREMA Matching with Regular Constraints C(f (x)) g(f (a, b), h(f (a), f )) g C f x a f b f a h f {C g(, h(f (a), f )), x a, b }

59 Second Solution Methods in THEOREMA Matching with Regular Constraints C(f (x)) g(f (a, b), h(f (a), f )) g C f x a f b f a h f {C g(f (a, b), h(, f )), x a}

60 Third Solution Methods in THEOREMA Matching with Regular Constraints C(f (x)) g(f (a, b), h(f (a), f )) g C f x a f b f a h f {C g(f (a, b), h(f (a), )), x }

61 Methods in THEOREMA Matching with Regular Constraints Same Example, with a Regular Constraint C(f (x)) g(f (a, b), h(f (a), f )), x in a, b g C f x a f b f a h f Find a matcher σ such that xσ {, a, b, a, b, a, b,...}.

62 First Solution Methods in THEOREMA Matching with Regular Constraints C(f (x)) g(f (a, b), h(f (a), f )), x in a, b g C f x a f b f a h f {C g(, h(f (a), f )), x a, b }

63 Second Solution Methods in THEOREMA Matching with Regular Constraints C(f (x)) g(f (a, b), h(f (a), f )), x in a, b g C f x a f b f a h f {C g(f (a, b), h(f (a), )), x }

64 Variables Methods in THEOREMA Matching with Regular Constraints In context sequence matching, variables help to explore terms (represented as trees) both in breadth and in depth: Individual Sequence Function Context Direction breadth breadth depth depth Steps one any one any

65 In This Talk Methods in THEOREMA Matching with Regular Constraints Description of a framework for matching with context and sequence variables. Integration of regular constraints into matching.

66 Terms Methods in THEOREMA Matching with Regular Constraints Built over 1 Individual and sequence variables 2 Function and context variables 3 A distinguished constant (hole) 4 Flexible arity function symbols

67 Terms Methods in THEOREMA Matching with Regular Constraints More formally: t ::= x x f (t 1,..., t n ) F(t 1,..., t n ) C(t) where 1 x is an individual variable 2 x is a sequence variable 3 f is a function symbol 4 F is a function variable 5 C is a context variable 6 t in C(t) is not a sequence variable

68 Contexts Methods in THEOREMA Matching with Regular Constraints Context: A term with a single occurrence of the hole. Example (Contexts) f (a, g(x, ), b) C(f (a, F( ), x)) C( ) Convention: a, b abbreviate a() and b().

69 Substitutions Methods in THEOREMA Matching with Regular Constraints Mapping: From To Condition Individual Term t t is not a sequence variable variable x t contains no holes t x Sequence Term sequence n 0, variable x t 1,..., t n t s contain no holes if n = 1 then t 1 x Function Function symbols H F variable F and variables H Context Context C C C( ) variable C For finitely many variables.

70 Context Application Methods in THEOREMA Matching with Regular Constraints Operation to "fill up holes C: context t: term that is not a sequence variable C[t] (Application of C on t): A term obtained from C by replacing the hole with t. Example C t C[t] f (a, ) f (b, h(x)) f (a, f (b, h(x))) f (x, C(F(x, )), y) f (x, C(F (x, )), y) f (C(F (x,, y))) g(, ) f (C(F(x, g(, ), y)))

71 Substitution Extension Methods in THEOREMA Matching with Regular Constraints Substitutions are extended to terms: xσ = σ(x) xσ = σ(x) f (t 1,..., t n )σ = f (t 1 σ,..., t n σ) F (t 1,..., t n )σ = σ(f)(t 1 σ,..., t n σ) C(t)σ = σ(c)[tσ].

72 Substitution Extension Methods in THEOREMA Matching with Regular Constraints Example t = D(g(x, y)) σ = {D, x x, C(f (a)), y } tσ = g(x, C(f (a)))

73 Matching Problem, Matcher Methods in THEOREMA Matching with Regular Constraints Matching Problem: a finite multiset of term pairs (matching equations) {s 1 t 1,..., s n t n } s s and the t s contain no holes s s are not sequence variables t s are ground Matcher: a substitution σ such that s 1 σ = t 1,..., s n σ = t n

74 Regular CSM Algorithm Methods in THEOREMA Matching with Regular Constraints The regular context sequence matching algorithm M R is constructed in two steps: 1 Constructing the basic matching algorithm M for unconstrained equations. 2 Extending M with the rules for solving constrained equations.

75 Basic Matching Algorithm M Methods in THEOREMA Matching with Regular Constraints A rule-based algorithm that operates on matching problem/substitution pairs, is sound, terminating, and complete, computes minimal complete set of matchers for solvable problems, reports failure for unsolvable problems. Sample rule Details in [1].

76 Example Methods in THEOREMA Matching with Regular Constraints From a tree extract contexts under which two equal leaves lie. Problem: {F(, C(G()),, D(G()), ) f (a, g(b, c), b, d)}. F, G: function variables, C, D: context variables, : anonymous sequence variables. (Singleton variables whose values are not computed.) Solution: σ = {F f, C g(, c), G b, D }.

77 Regular Expressions Methods in THEOREMA Matching with Regular Constraints A powerful mechanism for restricting data values. Widely used in general-purpose programming and querying semistructured data. Classical approach for regular expression matching: using finite automata. Can be easily integrated into our matching framework.

78 Methods in THEOREMA Matching with Regular Constraints Regular Expressions on Terms and Contexts Regular expressions on terms: R ::= t R 1, R 2 R 1 R 2 R. where t contains no holes. Regular expressions on contexts: Q ::= C Q 1, Q 2 Q 1 Q 2 Q.

79 Regular Expressions on Terms Methods in THEOREMA Matching with Regular Constraints Regular expressions on terms generate regular hedge languages. Example L( f (x, a, x), C(b) ) = {, f (x, a, x), C(b), f (x, a, x), C(b), f (x, a, x), C(b),...}

80 Regular Expressions on Contexts Methods in THEOREMA Matching with Regular Constraints Regular expressions on contexts generate regular tree languages. Example L( f (, a, x), C( ) ) = {, f (C( ), a, x), f (C(f (C( ), a, x)), a, x),...}

81 Regular Constraints. Notation Methods in THEOREMA Matching with Regular Constraints Term regular constraints: (Ts in R, 0), (Ts in R, 1). 0, 1 boolean values (called flags). Intuition: (Ts in R, 0) the sequence Ts belongs to L(R). (Ts in R, 1) the sequence Ts belongs to L(R) \ { }. Note: (Ts in R, 1) is not the same as (Ts in R, R, 0): ( in (a ), 1) is false. ( in a, (a ), 0) is true.

82 Regular Constraints. Notation Methods in THEOREMA Matching with Regular Constraints Term regular constraints: (Ts in R, 0), (Ts in R, 1). 0, 1 boolean values (called flags). Intuition: (Ts in R, 0) the sequence Ts belongs to L(R). (Ts in R, 1) the sequence Ts belongs to L(R) \ { }. Note: (Ts in R, 1) is not the same as (Ts in R, R, 0): ( in (a ), 1) is false. ( in a, (a ), 0) is true.

83 Regular Constraints. Notation Methods in THEOREMA Matching with Regular Constraints Context regular constraints: (C in Q, 0), (C in Q, 1). Intuition: (C in Q, 0) the context C belongs to L(Q). (C in Q, 1) the sequence C belongs to L(Q) \ { }. Note: (C in Q, 1) is not the same as (C in Q, Q, 0)

84 Regular CSM Problem Methods in THEOREMA Matching with Regular Constraints Multiset of matching equations and regular constraints: {s 1 t 1,..., s n t n, (x 1 in R 1, f 1 ),..., (x m in R m, f m ), (C 1 in Q 1, g 1 ),..., (C k in Q k, g k )}, where all x s and all C s are distinct, do not occur in R s and Q s, (This restriction can be relaxed to noncyclic occurrences.) occur in the matching equations, and all f s and g s are boolean expressions.

85 Methods in THEOREMA Matching with Regular Constraints Solution of a Regular CSM Problem Problem: {s 1 t 1,..., s n t n, (x 1 in R 1, f 1 ),..., (x m in R m, f m ), (C 1 in Q 1, g 1 ),..., (C k in Q k, g k )}. Solution: A substitution σ such that for all 1 i n, 1 j m, and 1 l k: s i σ = t i, x j σ L(R j σ) fj σ, f j σ {0, 1}, where L(R) 0 = L(R), L(R) 1 = L(R) \ { }, C l σ L(Q l σ) gl σ, g l σ {0, 1}, where L(Q) 0 = L(Q), L(Q) 1 = L(Q) \ { },

86 Methods in THEOREMA Matching with Regular Constraints Solution of a Regular CSM Problem Problem: {s 1 t 1,..., s n t n, (x 1 in R 1, f 1 ),..., (x m in R m, f m ), (C 1 in Q 1, g 1 ),..., (C k in Q k, g k )}. Solution: A substitution σ such that for all 1 i n, 1 j m, and 1 l k: s i σ = t i, x j σ L(R j σ) fj σ, f j σ {0, 1}, where L(R) 0 = L(R), L(R) 1 = L(R) \ { }, C l σ L(Q l σ) gl σ, g l σ {0, 1}, where L(Q) 0 = L(Q), L(Q) 1 = L(Q) \ { },

87 Methods in THEOREMA Matching with Regular Constraints Solution of a Regular CSM Problem Problem: {s 1 t 1,..., s n t n, (x 1 in R 1, f 1 ),..., (x m in R m, f m ), (C 1 in Q 1, g 1 ),..., (C k in Q k, g k )}. Solution: A substitution σ such that for all 1 i n, 1 j m, and 1 l k: s i σ = t i, x j σ L(R j σ) fj σ, f j σ {0, 1}, where L(R) 0 = L(R), L(R) 1 = L(R) \ { }, C l σ L(Q l σ) gl σ, g l σ {0, 1}, where L(Q) 0 = L(Q), L(Q) 1 = L(Q) \ { },

88 Methods in THEOREMA Matching with Regular Constraints Solution of a Regular CSM Problem Problem: {s 1 t 1,..., s n t n, (x 1 in R 1, f 1 ),..., (x m in R m, f m ), (C 1 in Q 1, g 1 ),..., (C k in Q k, g k )}. Solution: A substitution σ such that for all 1 i n, 1 j m, and 1 l k: s i σ = t i, x j σ L(R j σ) fj σ, f j σ {0, 1}, where L(R) 0 = L(R), L(R) 1 = L(R) \ { }, C l σ L(Q l σ) gl σ, g l σ {0, 1}, where L(Q) 0 = L(Q), L(Q) 1 = L(Q) \ { },

89 Matching with Regular Constraints Methods in THEOREMA Matching with Regular Constraints Example Regular CSM problem: {C(f (x)) g(f (a, b), h(f (a), f )), (x in a, b, 0)} Solutions: {C g(, h(f (a), f )), x a, b } {C g(f (a, b), h(f (a), )), x }

90 Regular CSM Problems Methods in THEOREMA Matching with Regular Constraints A straightforward "generate-and-test approach to solve {s 1 t 1,..., s n t n, (x 1 in R 1, f 1 ),..., (x m in R m, f m ), (C 1 in Q 1, g 1 ),..., (C k in Q k, g k )} : 1 Compute a solution σ for {s 1 t 1,..., s n t n } (e.g. by M) 2 Build an automaton for each R i σ and Q j σ (taking into account the values of f i σ and g j σ) 3 If x i σ and C j σ are accepted by the corresponding automata then add σ to the answer set else discard σ.

91 Regular CSM Problems Methods in THEOREMA Matching with Regular Constraints A straightforward "generate-and-test approach to solve {s 1 t 1,..., s n t n, (x 1 in R 1, f 1 ),..., (x m in R m, f m ), (C 1 in Q 1, g 1 ),..., (C k in Q k, g k )} : 1 Compute a solution σ for {s 1 t 1,..., s n t n } (e.g. by M) 2 Build an automaton for each R i σ and Q j σ (taking into account the values of f i σ and g j σ) 3 If x i σ and C j σ are accepted by the corresponding automata then add σ to the answer set else discard σ.

92 Regular CSM Problems Methods in THEOREMA Matching with Regular Constraints A straightforward "generate-and-test approach to solve {s 1 t 1,..., s n t n, (x 1 in R 1, f 1 ),..., (x m in R m, f m ), (C 1 in Q 1, g 1 ),..., (C k in Q k, g k )} : 1 Compute a solution σ for {s 1 t 1,..., s n t n } (e.g. by M) 2 Build an automaton for each R i σ and Q j σ (taking into account the values of f i σ and g j σ) 3 If x i σ and C j σ are accepted by the corresponding automata then add σ to the answer set else discard σ.

93 Regular CSM Problems Methods in THEOREMA Matching with Regular Constraints A straightforward "generate-and-test approach to solve {s 1 t 1,..., s n t n, (x 1 in R 1, f 1 ),..., (x m in R m, f m ), (C 1 in Q 1, g 1 ),..., (C k in Q k, g k )} : 1 Compute a solution σ for {s 1 t 1,..., s n t n } (e.g. by M) 2 Build an automaton for each R i σ and Q j σ (taking into account the values of f i σ and g j σ) 3 If x i σ and C j σ are accepted by the corresponding automata then add σ to the answer set else discard σ.

94 Regular CSM Problems Methods in THEOREMA Matching with Regular Constraints A straightforward "generate-and-test approach to solve {s 1 t 1,..., s n t n, (x 1 in R 1, f 1 ),..., (x m in R m, f m ), (C 1 in Q 1, g 1 ),..., (C k in Q k, g k )} : 1 Compute a solution σ for {s 1 t 1,..., s n t n } (e.g. by M) 2 Build an automaton for each R i σ and Q j σ (taking into account the values of f i σ and g j σ) 3 If x i σ and C j σ are accepted by the corresponding automata then add σ to the answer set else discard σ. Problematic when regular expressions are nonlinear, contain variables that do not occur in matching equations.

95 Regular CSM Problems Methods in THEOREMA Matching with Regular Constraints We propose a different approach: Integrate regular constraints into matching algorithm. Compute the right answers directly. Save the effort of automata construction and testing for each computed substitution. Regular expressions can be nonlinear. No problem. Regular expressions can contain variables that do not occur in matching equations. No problem.

96 Methods in THEOREMA Matching with Regular Constraints Matching Algorithm M R for Regular CSM Problems A rule based algorithm that extends context sequence matching algorithm M, is sound, terminating, and complete, computes the minimal complete set of matchers for solvable problems, reports failure for unsolvable problems. Sample rule Details in [1].

97 Example Methods in THEOREMA Matching with Regular Constraints Problem: {C(h(x, b, y)) f (a, g(f (a, g(h(b, b, b))))), D(h(y, x)) f (a, g(h(b, b))), (x in y, 0), (C in E( ), 0), (D in E( ), 0)}. Solution: {{ C f (a, g(f (a, g( )))), E f (a, g( )), D f (a, g( )), x, y b, b }, { C f (a, g(f (a, g( )))), E f (a, g( )), D f (a, g( )), x b, y b}}.

98 Applications Methods in THEOREMA Matching with Regular Constraints Some of the applications of (regular) CSM: Rule-based programming XML querying and transformation Schema matching

99 Related Work Methods in THEOREMA Matching with Regular Constraints Rich literature on matching with regular expressions. Approaches closer to ours: Regular expression pattern matching (Hosoya and Pierce, 2003). A rewrite system with incomplete regular expression types (Suzuki and Okui, 2005). CLP(Flex): Constraint logic programming applied to XML processing (Coelho and Florido, 2004).

100 Summarizing Basic Features Methods in THEOREMA Matching with Regular Constraints Context sequence matching with regular constraints allows to explore term trees in two orthogonal directions: in depth and in breadth, gives more freedom in selecting subterms, has a finite minimal complete set of solutions, if used as a computational mechanism for a declarative, rule-based language to query and transform XML, can give it the advantages from both path-based and pattern-based languages.

101 Summarizing Basic Features Methods in THEOREMA Matching with Regular Constraints Context sequence matching with regular constraints allows to explore term trees in two orthogonal directions: in depth and in breadth, gives more freedom in selecting subterms, has a finite minimal complete set of solutions, if used as a computational mechanism for a declarative, rule-based language to query and transform XML, can give it the advantages from both path-based and pattern-based languages.

102 Summarizing Basic Features Methods in THEOREMA Matching with Regular Constraints Context sequence matching with regular constraints allows to explore term trees in two orthogonal directions: in depth and in breadth, gives more freedom in selecting subterms, has a finite minimal complete set of solutions, if used as a computational mechanism for a declarative, rule-based language to query and transform XML, can give it the advantages from both path-based and pattern-based languages.

103 Summarizing Basic Features Methods in THEOREMA Matching with Regular Constraints Context sequence matching with regular constraints allows to explore term trees in two orthogonal directions: in depth and in breadth, gives more freedom in selecting subterms, has a finite minimal complete set of solutions, if used as a computational mechanism for a declarative, rule-based language to query and transform XML, can give it the advantages from both path-based and pattern-based languages.

104 Summarizing Basic Features Methods in THEOREMA Matching with Regular Constraints Context sequence matching with regular constraints allows to explore term trees in two orthogonal directions: in depth and in breadth, gives more freedom in selecting subterms, has a finite minimal complete set of solutions, if used as a computational mechanism for a declarative, rule-based language to query and transform XML, can give it the advantages from both path-based and pattern-based languages.

105 Reference Methods in THEOREMA Matching with Regular Constraints T. Kutsia and M. Marin. Matching with Regular Constraints. In G. Sutcliffe and A. Voronkov, editors, Proc. of the 12th Int. Conf. on Logic in Programming, Artificial Intelligence, and Reasoning, LPAR 05, volume 3835 of LNAI, pages , Montego Bay, Jamaica, Springer.

106 Summary Methods in THEOREMA Matching with Regular Constraints THEOREMA supports proving and solving aspects of equational reasoning. : Unfailing completion based equational prover for unit equality problems. First order and applicative higher order syntax. Sequence variables. by simplification. Human-oriented input and output. : Unification and matching algorithms for various theories. Symbolic constraint solving. Regular expressions.

107 Inference Rules of M Appendix CSM Algorithm M Regular CSM Algorithm M R Trivial: Individual Variable Elimination: {t t} Γ ; σ = Γ ; σ. {x t} Γ ; σ = Γ ϑ; σϑ, where ϑ = {x t}. Function Variable Elimination: {F(s 1,..., s n ) f (t 1,..., t m )} Γ ; σ = {f (s 1 ϑ,..., s n ϑ) f (t 1,..., t m )} Γ ϑ; σϑ, where ϑ = {F f }. Back

108 Inference Rules of M Appendix CSM Algorithm M Regular CSM Algorithm M R Total Decomposition: {f (s 1,..., s n ) f (t 1,..., t n )} Γ ; σ = {s 1 t 1,..., s n t n } Γ ; σ, if f (s 1,..., s n ) f (t 1,..., t n ) and s i / V Seq for all 1 i n. Partial Decomposition: {f (s 1,..., s n ) f (t 1,..., t m )} Γ ; σ = {s 1 t 1,..., s k 1 t k 1, f (s k,..., s n ) f (t k,..., t m )} Γ ; σ, if f (s 1,..., s n ) f (t 1,..., t m ), s k V Seq for some 1 < k min(n, m) + 1, and s i / V Seq for all 1 i < k. Back

109 Inference Rules of M Appendix CSM Algorithm M Regular CSM Algorithm M R Sequence Variable Deletion: {f (x, s 1,..., s n ) t} Γ ; σ = {f (s 1 ϑ,..., s n ϑ) t} Γ ϑ; σϑ, where ϑ = {x }. Widening: {f (x, s 1,..., s n ) f (t, t 1,..., t m )} Γ ; σ = {f (x, s 1 ϑ,..., s n ϑ) f (t 1,..., t m )} Γ ϑ; σϑ, where ϑ = {x t, x }. Back

110 Inference Rules of M Appendix CSM Algorithm M Regular CSM Algorithm M R Context Variable Deletion: {C(s) t} Γ ; σ = {sϑ t} Γ ϑ; σϑ, where ϑ = {C }. Deepening: {C(s) f (t 1,..., t m )} Γ ; σ = {C(sϑ) t j } Γ ϑ; σϑ, where ϑ = {C f (t 1,..., t j 1, C( ), t j+1,..., t m )} for some 1 j m, and m > 0. Back

111 Inference Rules of M Appendix CSM Algorithm M Regular CSM Algorithm M R Symbol Clash: {f (s 1,..., s n ) g(t 1,..., t m )} Γ ; σ =, if f / V Con V Fun and f g. Arity Disagreement: {f (s 1,..., s n ) f (t 1,..., t m )} Γ ; σ =, if m n and s i / V Seq for all 1 i n. Back

112 Appendix CSM Algorithm M Regular CSM Algorithm M R Inference Rules of M R Empty Sequence in Term Regular Expression: {f (x, s 1,..., s n ) t, (x in, f)} Γ; σ = { {f (x, s1,..., s n )ϑ t} Γϑ; σϑ, if f = 0, if f = 1. where ϑ = {x }. Term in Term Regular Expression: {f (x, s 1,..., s n ) t, (x in s, f)} Γ; σ = {f (x, s 1,..., s n )ϑ t} Γϑ; σϑ, where ϑ = {x s} and s / V Seq. Back

113 Appendix CSM Algorithm M Regular CSM Algorithm M R Inference Rules of M R Sequence Variable in Term Regular Expression: {f (x, s 1,..., s n ) t, (x in y, f)} Γ; σ = {f (x, s 1,..., s n )ϑ t} Γϑ; σϑ, where ϑ = {x y} if f = 0. If f = 1 then ϑ = {x y, y, y y, y } where y is a fresh variable. Choice in Term Regular Expression: {f (x, s 1,..., s n ) t, (x in R 1 R 2, f)} Γ; σ = {f (x, s 1,..., s n )ϑ t, (y i in R i, f)} Γϑ; σϑ, for i = 1, 2, where y i s are fresh variables and ϑ = {x y i }. Back

114 Appendix CSM Algorithm M Regular CSM Algorithm M R Inference Rules of M R Concatenation in Term Regular Expression: {f (x, s 1,..., s n ) t, (x in R 1, R 2, f)} Γ; σ = {f (x, s 1,..., s n )ϑ t, (y 1 in R 1, f 1 ), (y 2 in R 2, f 2 )} Γϑ; σϑ, where y 1 and y 2 are fresh variables, ϑ = {x y 1, y 2 }, and f 1 and f 2 are computed as follows: If f = 0 then f 1 = f 2 = 0 else f 1 = 0 and f 2 = NonEmptySeq(y 1 ) XOR 1. NonEmptySeq() = 0 NonEmptySeq(r 1,..., r n ) = 1 if r i / V Seq for some 1 i n. Back

115 Appendix CSM Algorithm M Regular CSM Algorithm M R Inference Rules of M R Repetition in Term Regular Expression 1: {f (x, s 1,..., s n ) t, (x in R, f)} Γ; σ = { {f (x, s1,..., s n )ϑ t} Γϑ; σϑ, if f = 0, if f = 1. where ϑ = {x }. Repetition in Term Regular Expression 2: {f (x, s 1,..., s n ) t, (x in R, f)} Γ; σ = {f (x, s 1,..., s n )ϑ t, (y in R, 1), (x in R, 0)} Γϑ; σϑ, where y is a fresh variable and ϑ = {x y, x }. Back

116 Appendix CSM Algorithm M Regular CSM Algorithm M R Inference Rules of M R Hole in Context Regular Expression: where ϑ = {C }. {C(s) t, (C in, g)} Γ; σ = { {C(s)ϑ t} Γϑ; σϑ, if g = 0, if g = 1. Context in Context Regular Expression: {C(s) t, (C in C, g)} Γ; σ = {C(s)ϑ t} Γϑ; σϑ, where C, Head(C) / V Con, and ϑ = {C C}. Back

117 Appendix CSM Algorithm M Regular CSM Algorithm M R Inference Rules of M R Context Variable in Context Regular Expression: {C(s) t, (C in D( ), g)} Γ; σ = {C(s)ϑ t} Γϑ; σϑ, where ϑ = {C D( )} if g = 0. If g = 1 then ϑ = {C F(x, D( ), y), D F(x, D( ), y)}, where F, x, and y are fresh variables. Choice in Context Regular Expression: {C(s) t, (C in Q 1 Q 2, g)} Γ; σ = {C(s)ϑ t, (D i in Q i, g)} Γϑ; σϑ, for i = 1, 2, where D i s are fresh variables and ϑ = {C D i ( )}. Back

118 Appendix CSM Algorithm M Regular CSM Algorithm M R Inference Rules of M R Concatenation in Context Regular Expression: {C(s) t, (C in Q 1, Q 2, g)} Γ; σ = {C(s)ϑ t, (D 1 in Q 1, g 1 ), (D 2 in Q 2, g 2 )} Γϑ; σϑ, where D 1 and D 2 are fresh variables, ϑ = {C D 1 (D 2 ( ))}, and g 1 and g 2 are computed as follows: If g = 0 then g 1 = g 2 = 0 else g 1 = 0 and g 2 = NonEmptyCtx(D 1 ) XOR 1. NonEmptyCtx( ) = 0. NonEmptyCtx(C) = 1 if the context C contains at least one symbol different from context variables and the hole constant. Back

119 Appendix CSM Algorithm M Regular CSM Algorithm M R Inference Rules of M R Repetition in Context Regular Expression 1: where ϑ = {C }. {C(s) t, (C in Q, g)} Γ; σ = { {C(s)ϑ t} Γϑ; σϑ, if g = 0, if g = 1. Repetition in Context Regular Expression 2: {C(s) t, (C in Q, g)} Γ; σ = {C(s)ϑ t, (D in Q, 1), (C in Q, 0)} Γϑ; σϑ, where D is a fresh variable and ϑ = {C D(C( ))}. Back