Implementation of Lambda-Free Higher-Order Superposition. Petar Vukmirović

Transcription

1 Implementation of Lambda-Free Higher-Order Superposition Petar Vukmirović

2 Automatic theorem proving state of the art FOL HOL 2

3 Automatic theorem proving challenge HOL High-performance higher-order theorem prover that extends first-order theorem proving gracefully. 3

4 My approach FOL prover Add HO feature Optimize Fast HOL prover Test 4

5 Syntax Types: Terms: τ ::= a τ τ t ::= X f tt variable symbol application 5

6 Supported HO features Example: X (f a) f Applied variable Partial application Applied variables + Partial application = Lambda-Free Higher-Order Logic 6

7 LFHOL iteration E LFHOL Optimize hoe Test 7

8 Generalization of term representation Approach 1: Native representation Approach 2: Applicative encoding X (f a)), f) 8

9 Differences between the approaches Approach 1: Native representation Compact Approach 2: Applicative encoding Easy to implement Fast Works well with E heuristics 9

10 Unification problem Given the set of equations { s1 =? t1,, sn =? tn } find the substitution σ such that { σ(s1) = σ(t1),, σ(sn) = σ(tn) } 10

11 FOL unification algorithm Initial set of equations S Remove an equation s =? t S=Ø S is unifiable No failure is reported S Ø Transform S Failure is reported S is not unifiable 11

12 Transformation of the equation set Match s =? t f(s1,, sn) =? f(t1,, tn) f(s1,, sn) =? g(t1,, tm) f(s1,, sn) =? X X =? f(s1,, sn); X not in t X =? f(s1,, sn); X in t X =? X Add { s1 =? t1,, sn =? tn} Report failure Add { t =? s } Apply [X f(s1,, sn)] Report failure No changes decomposition collision reorientation application occurs-check identity 12

13 FOL algorithm fails on LFHOL terms X b =? f a b X f Report failure collision Yet, { X f a } is a unifier. 13

14 Example X2 (Z2 b c) d =? f a (Y1 c) d X fa prefix match Z b c =? Y c, d =? d orientation?? Y Zb Y c = Z b c, d = d c =? c, d =? d prefix match decomposition d =? d decomposition Unifier { X f a, Y Z b } 14

15 LFHOL equation set transformation Match s =? t s1 sn =? t1 tn Add { s1 =? t1,, sn =? tn} β is var, either is not or n > m s1 sn =? β t1 tm X =? f s1 sn; X not in t X =? f s1 sn; X in t X =? X Neither nor β vars is var, matches prefix of t decomposition Add { t =? s } reorientation Report failure collision Add { =? t[:p], s1=? tp+1,, sn=? tm} Apply [X f s1 sn] Report failure No changes prefix match application occurs-check identity 15

16 Standard FOL operations s t unifiable/matchable? 16

17 are performed on subterms recursively, f(t1, t2,, tn) s unifiable/matchable? 17

18 and there are twice as many subterms in HOL prefix subterms s f t1 t2 tn argument subterms unifiable/matchable? 18

19 Prefix optimization Traverse only argument subterms Use types & arity to determine the only unifiable/matchable prefix Report 1 argument trailing fxy fabc 19

20 Advantages of prefix optimization 2x fewer subterms No unnecessary prefixes created No changes to E term traversal 20

21 Indexing data structures Generalizations s =? σ(t) f(x,g(h(y),a)) Instances σ(s) =? t f(a,g( b,a)) Query term ) ) ) x,x f(x,y) ( f, (x h(g f(f(x Unifiable terms σ(s) =? σ(t) c a,x), f x (y,y) ) Set of terms 21

22 E s indexing data structures Discrimination trees Fingerprint indexing Feature vector indexing 22

23 Discrimination trees Factor out operations common for many terms Flatten the term and use it as a key Query term: Flattening: f(x, f(h(x), y)) fxfhxy 23

24 Example Query term: 24

25 Example Query term: 25

26 Example Query term: 26

27 Example Query term: Backtrack to where we can make choice No neighbour can generalize the term 27

28 Example Query term: Backtrack further Mismatch 28

29 Example Query term: 29

30 Example Query term: 30

31 Example Query term: 31

32 Example Query term: 32

33 LFHOL challenges 1. Applied variables 2. Terms prefixes of one another 3. Prefix optimization 33

34 LFHOL challenges Query term: g a b 1. Applied variables Variable can match a prefix 2. Terms prefixes of one another 3. Prefix optimization 34

35 LFHOL challenges Query term: g a b 1. Applied variables Variable can match a prefix 2. Terms prefixes of one another 3. Prefix optimization 35

36 LFHOL challenges Query term: g a b 1. Applied variables Variable can match a prefix 2. Terms prefixes of one another 3. Prefix optimization 36

37 LFHOL challenges 1. Applied variables 2. Terms prefixes of one another Terms can be stored in inner nodes 3. Prefix optimization 37

38 LFHOL challenges Query term: f a b 1. Applied variables 2. Terms prefixes of one another 3. Prefix optimization Prefix matches are allowed 38

39 Experimentation results HOL FOL Two compilation modes: hoe - support for LFHOL foe - support only for FOL 39

40 Gain on LFHOL problems hoe vs. original E E 995 (encoded) LFHOL TPTP problems hoe 40

41 Gain on LFHOL problems Both finished on 872/995 problems hoe: 8 unique, E: 11 unique Mean runtime: hoe E 0.010s 0.013s Total runtime: hoe 17.1s E 113.9s 41

42 Overhead on FOL problems hoe vs. E foe vs. E Minimize the overhead for existing E users Tested on 7789 FOL TPTP problems 42

43 foe vs. E Median runtime: foe E 1.4s 1.3s E Total runtime: foe s E s foe 43

44 hoe vs. E Median runtime: 1.5s hoe E 1.3s E Total runtime: hoe E s s hoe 44

45 Summary Engineering viewpoint New type module Native term representation Elegant algorithm extensions Prefix optimizations Theoretical viewpoint Graceful algorithm extension Graceful data structures extension 45

46 Future work Integration with official E New features First-class LFHOL booleans E Full HOL hoeprover λs Optimize Test 46

47 Implementation of Lambda-Free Higher-Order Superposition Petar Vukmirović