Design and Implementation of Multi-Context Rewriting Induction. Haruhiko Sato and Masahito Kurihara Hokkaido University, Japan

Transcription

1 Design and Implementation of Multi-Context Rewriting Induction Haruhiko Sato and Masahito Kurihara Hokkaido University, Japan

2 Outline Inductive Theorem Proving Rewriting Induction Strategic Difficulties in Rewriting Induction Examples Multi-Context Rewriting Induction Experimental Results

3 Inductive theorem proving Mathematical Induction Principle P (0) [P (x) P (x + 1)] = x N. P(x) Well-founded Induction Principle : well-founded order on A [x y P (y)] P (x) = x A. P (x) various properties of programs can be proved by the induction principle

4 Inductive theorems in Programs Program: Term Rewriting System R = +(0,y) y +(s(x), y) s(+(x, y)) len([]) 0 len(x : xs) : xs, ys) x ys) s(0) s(s(0))... [] [x] [x, y]... [] x:[] x :(y : [])... Execution of Program: Rewriting (application of rules) +(s(s(0)), 0) R s(+(s(0), 0)) R s(s(+(0, 0))) R s(s(0)) Property of Program: Inductive Theorem (prop. which holds for any ground-substitution) len(@(xs, ys)) = +(len(xs), len(ys)) resultant term contains no variable

5 Rewriting Induction [Reddy90, Aoto07] Induction principle for programs satisfying termination well-founded induction based on the order: s t s + R t Inference Rules of Rewriting Induction Delete: E {s = s}, H E, H defined on the pair conjectures to be proved E, H inductive hypotheses Simplify: E {s = t}, H E {s = t }, H if t R H t Expand: E {s = t}, H E Expd u (s, t), H {s t} if u B(s), R H {s t} is terminating Theorem E, {} {}, H = E is inductive theorem of R

6 Example: associativity of addition EXPAND R = +(0,y) y +(s(x), y) s(+(x, y)) E = +(+(x, y),z) = +(x, +(y, z)) +(+(x, y),z) = +(x, +(y, z)), {} determine substitutions by unification σ = {x 0}, {x s(x)} choose a +(+(x, y), z) +(+(0,y),z) reduce the +(y, z) basic term instanciated terms to expand +(+(s(x),y),z) +(s(+(x, y)),z) with rules +(y, z) = +(0, +(y, z)), +(+(x, y),z) +(x, +(y, z)) +(s(+(x, y)),z) = +(s(x), +(y, z)) SIMPLIFY R s(+(+(x, y),z)) H s(+(x, +(y, z))) R s(+(x, +(y, z))) +(y, z) = +(y, z) s(+(x, +(y, z))) = s(+(x, +(y, z))) {}, +(+(x, y),z) +(x, +(y, z)) DELETE, +(+(x, y),z) +(x, +(y, z))

7 Problem: How do we apply the inference rules? Standard Strategy 1. apply SIMPLIFY as much as possible 2. apply DELETE as mush as possible 3. apply EXPAND to a conjecture (1) which rewrite rule to be choosed? (2) which direction the conjecture to be oriented for? 4. go back to 1 (3) which basic subterm to be expanded? the way of applying inference rules determines contexts: conjectures to be proved inductive hypotheses choosing appropriate contexts is important to obtain successful proofs

8 Example: appropriate simplification is required ys b([]) [] (x : xs)@ys x :(xs@ys) b(x : xs) b1(x, xs) : b2(x, xs) r([]) [] b1(x, []) x R = r(x : xs) r(xs)@[x] b1(x, y : ys) b1(y, ys) b2(x, []) [] b2(x, y : ys) b(x : b(b2(y, ys))) r(xs) = b(xs) E = b(b(xs)) = xs EXPAND r(xs) = b(xs), {} b(b(xs)) = xs EXPAND b(xs)@[x] = b1(x, xs) :b2(x, xs) r(xs) b(xs), b(b1(x, xs) : b2(x, xs)) = x : xs b(b(xs)) xs (b1(y, ys) : b1(y, ys) : = b2(y, ys))@[x] (b2(y, ys)@[x]) b(b1(x, xs) : b2(x, xs)) = x : xs simplify simplify proof fails (diverge) proof succeeds, r(xs) b(xs) b(b(xs)) xs b1(x, xs) : b2(x, xs) b(xs)@[x]

9 Example: appropriate orientation is required R = f(0) 0 f(s(0)) s(0) f(s(s(x))) f(s(x))+f(x) g(0) s(0), 0 g(s(x)) np(g(x)) np(x, y) x+y, x E = f(s(x)), f(x) = g(x) orient from left to right: diverge f(s(x)), f(x) = g(x) f(s(x))+f(x), f(s(x)) = np(g(x)) (f(s(x))+f(x))+f(s(x)), f(s(x))+f(x) = np(np(g(x))). orient from right to left: succeeds f(s(s(x))), f(s(x)) = np(g(x)) H np(f(s(x)), f(x)) R f(s(x))+f(x), f(s(x)) R f(s(x))+f(x), f(s(x))

10 Example: appropriate expansion is required R = or(x, true) true not(true) false or(x, false) x not(false) true and(x, true) x imply(x, y) or(not(x), y) and(x, false) false le(0, x) true eq(x, y) and(le(x, y), le(y, x)) le(s(x), 0) false le(s(x), s(y)) le(x, y) E = imply(and(eq(x, y), eq(y, z)), eq(x, z)) = true expantion with a specific (leftmost-outermost) strategy causes divergence (x = y) (y = z) = (x = z) (x = y) (y + 1 = z) = (x + 1 = z) (x = y) (y + 2 = z) = (x + 2 = z)... the divergence can be avoided by appropriate choice of expansion position

11 Our Approach: Trying multiple contexts in parallel Traditional Approach Our Approach Simplification Orientation Expansion normalize w.r.t. a specific reduction strategy try a direction (w.r.t. the order given by user) try one of basic subterms calculate all of normal forms try both direction try all of basic subterms

12 Example: trying multiple contexts in orientation a process p encounter n nondeterministic choices fork the process p into n different processes, and assign them with the choices Example: orientation process p r(xs) = b(xs) b(b(xs)) = xs, {} orient from left to right orient from right to left process p1 r(xs)@[x] = b(x : xs) b(b(xs)) = xs r(xs) b(xs), process p2 r(x : xs) = b1(x, xs) :b2(x, xs) b(b(xs)) = xs b(xs) r(xs),

13 Representation of Multiple Processes use node-representation in multi-completion [Kurihara et al. 1999, Sato et al. 2008] process p1 = b(x : xs) b(b(xs)) = xs r(xs) b(xs), process p2 r(x : xs) = b1(x, xs) :b2(x, xs) b(b(xs)) = xs b(xs) r(xs), representation by a set of nodes s, t, H 1,H 2,E ordered pair of terms s, t set of processes which keeps: s t t s s = t r(xs)@[x], b(x : xs), {}, {}, {p1} b(b(xs)), xs, {}, {}, {p1,p2} r(xs), b(xs), {p1}, {p2}, {} r(x : xs), b1(x, xs) :b2(x, xs) {}, {}, {p2} can share common inferences among processes efficient to fork/remove processes {..., p,... } {...,p1,p2,..., pn,... } low memory consumption

14 Multi-Context Rewriting Induction (MRI) (a part of) Inference Rules { of MRI } defined on a set of nodes, and simulates a lot of inferences in a single operation Simplify-R: Simplify-H: N { s { : t, H 1,H 2,E } s : t, H1,H N 2, s : t,,,e if E and s R s { } } { processes keeps s = t N { s { : t, H 1,H 2,E } } processes which s : t, H1,H N 2,E\ H can infer s : t,,,e H s {l r} s if E H, l : r, H,...,... N, and s {l r} s, processes keeps l r

15 Experimentation environment: Intel Xeon 2.13GHz, 1GB system memory Problem Time (sec) # of processes Estimated Time (sec) Reduced Time (sec) list reverse fibonacci transitivity of equality our node-based approach is effective for difficult problems which requires large number of processes

16 Conclusion and Future work Conclusion We have shown some examples in which the appropriate choice of contexts is important to obtain successful results in RI We have proposed a new inference system which proves inductive theorems efficiently and automatically Experimentally, we have shown that our system can prove some difficult problems in reasonable time Future Work Strategies for giving precedence to important conjectures More efficient termination checking for incremental systems