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

Petar Vukmirović

Implementation of Lambda-Free Higher-Order Superposition

Automatic theorem proving ‒ state of the art

FOL HOL

2

Automatic theorem proving ‒ challenge

HOL

High-performance higher-order theorem proverthat extends first-order theorem proving gracefully.

3

My approach

FOL prover

TestOptimize

Fast HOL proverAdd HO feature

4

Syntax

Types:

τ ::= a | τ → τ

Terms:

t ::= X | f | t t

variable

symbol

application

5

Supported HO features

Example:

X (f a) f

Applied variables+

Partial application=

Lambda-Free Higher-Order Logic Applied variable Partial application

6

LFHOL iteration

E

TestOptimize

hoELFHOL

7

Generalization of term representation

Approach 1:Native representation

X (f a) f

Approach 2:Applicative encoding

@(@(X, @(f, a)), f)

8

Differences between the approaches

Approach 1:Native representation

Approach 2:Applicative encoding

Compact

Fast

Works well with E heuristics

Easy to implement

9

Unification problem

Given the set of equations

{ s1 =? t1, …, sn =? tn }

find the substitution σ such that

{ σ(s1) = σ(t1), …, σ(sn) = σ(tn) }

10

FOL unification algorithm

Initial set of equations S

Remove an equation s =? t

Transform S

S is not unifiable

S is unifiable

S = Ø S ≠ Ø

Failure is reported

No failure is reported

11

Transformation of the equation setMatch s =? t

Match s , Match s , t

Add { s1 =? t1, …, sn =? tn}

Report failure

Add { t =? s }

Apply [X ← f(s1, …, sn)]

Report failure

No changes

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

decomposition

collision

reorientation

application

occurs-check

identity

12

FOL algorithm fails on LFHOL terms

Yet, { X ← f a } is a unifier.

13

X b =? f a b

Report failureX ≠ f

collision

Example

X2 (Z

2 b c) d =? f a (Y1 c) d Z b c =? Y c, d =? d

Y c =? Z b c, d =?d c =? c, d =? d

d =? d

X ← f a

Y ← Z b

prefix match

prefix match

orientation

decomposition

decomposition

Unifier{ X ← f a, Y ← Z b }

14

LFHOL equation set transformationMatch s =? t

Match s , Match s , t

Add { s1 =? t1, …, sn =? tn}

Apply [X ← f s1 … sn]

Report failure

No changes

⍺ s1 … sn =? ⍺ t1 … tn

⍺ s1 … sn =? β t1 … tm

X =? f s1 … sn; X not in t

X =? f s1 … sn; X in t

X =? X

decomposition

application

occurs-check

identity

Add { t =? s }β is var, either⍺ is not or n > m

Report failureNeither ⍺ nor β vars

Add {⍺ =? t[:p], s1=? tp+1, …, sn=? tm}

⍺ is var, matchesprefix of t

reorientation

collision

prefix match

15

Standard FOL operations

s t

unifiable/matchable?

16

… are performed on subterms recursively,

s


f(t1, t2 ,…, tn)

17

… and there are twice as many subterms in HOL

s f t1 t2 … tnf t1 t2 … tnf t1 t2 … tnf t1 t2 … tn

18


argument subterms

prefix subterms

Prefix optimization

● Traverse only argument subterms

● Use types & arity to determine the only unifiable/matchable prefix

19

f a b cf X Y

Report 1 argument trailing

Advantages of prefix optimization

2x fewer subterms

No unnecessary prefixes created

No changes to E term traversal

20

Indexing data structures

f(a,g(b,a))

f(x,y)

h(g(x,f(x,x)))

a

c

xf(f(x,x), f(y,y))

Query term

f(x,g(h(y),a))

Set of terms

Generalizationss =? σ(t)

Instancesσ(s) =? t

Unifiable termsσ(s) =? σ(t)

21

E’s indexing data structures

Discrimination trees

Fingerprint indexing

Feature vector indexing


22


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))

f x f h x y

23

Example Query term:

24

Example Query term:

25

Example Query term:

26

Example Query term:

No neighbour can generalize the term

Backtrack to where we can make choice

27

Example Query term:

Mismatch

Backtrack further

28

Example Query term:

29

Example Query term:

30

Example Query term:

31

Example Query term:

32

LFHOL challenges

1. Applied variables

2. Terms prefixes of one another

3. Prefix optimization

33

LFHOL challenges

1. Applied variablesVariable can match a prefix



Query term: g a b

34

LFHOL challenges




Query term: g a b

35

LFHOL challenges




Query term: g a b

36

LFHOL challenges


2. Terms prefixes of one anotherTerms can be stored in inner nodes


37

LFHOL challenges



3. Prefix optimizationPrefix matches are allowed

Query term: f a b

38

Experimentation results

Two compilation modes:

hoE - support for LFHOL

foE - support only for FOL

HOL

FOL

39

Gain on LFHOL problems

hoE vs. original E

995 (encoded)LFHOL TPTP

problems

hoE

E

40

Gain on LFHOL problems

Both finished on 872/995 problemshoE: 8 unique, E: 11 unique

Total runtime:

41

hoE

E

17.1s

113.9s

Mean runtime:

hoE

E

0.010s

0.013s

Overhead on FOL problems

hoE vs. E foE vs. E

Minimize the overhead for existing E users

Tested on 7789 FOL TPTP problems

42

foE vs. E

Total runtime:

43foE

E

foE

E

845909s

844212s

Median runtime:

foE

E

1.4s

1.3s

hoE vs. E

44hoE

ETotal runtime:

hoE

E

846897s

844212s

Median runtime:

hoE

E

1.5s

1.3s

Summary

● New type module● Native term representation● Elegant algorithm extensions● Prefix optimizations

● Graceful algorithm extension● Graceful data structures extension

45

Engineering viewpoint Theoretical viewpoint

Future work

Integration with official E

E

TestOptimize

hoELFHOL

New features

First-class booleans

λs

Full HOL prover

46

Petar Vukmirović

Implementation of Lambda-Free Higher-Order Superposition

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

Documents

Transcript of Petar Vukmirović Implementation of Lambda-Free Higher...