Recent Improvements of Theory Reasoning in Vampire Giles Reger 1 , - - PowerPoint PPT Presentation

SLIDE 1

1/24

Recent Improvements of Theory Reasoning in Vampire

Giles Reger1, Martin Suda2, Andrei Voronkov3,4

1University of Manchester, Manchester, UK 2TU Wien, Vienna, Austria 3Chalmers University of Technology, Gothenburg, Sweden 4EasyChair

IWIL 2017 – Maun, May 7, 2017

SLIDE 2

1/24

Reasoning with quantifiers and theories

Two Dimensions of Complexity

∀∃

Z/R: +-*/ select/store gnd

SLIDE 3

1/24

Reasoning with quantifiers and theories

Two Dimensions of Complexity

∀∃

Z/R: +-*/ select/store gnd ATP

SLIDE 4

1/24

Reasoning with quantifiers and theories

Two Dimensions of Complexity

∀∃

Z/R: +-*/ select/store gnd ATP SMT

SLIDE 5

1/24

Reasoning with quantifiers and theories

Two Dimensions of Complexity

select/store Z/R: +-*/

∀∃

gnd ATP SMT E SPASS VAMPIRE ... CVC4 veriT Z3 ...

SLIDE 6

1/24

Reasoning with quantifiers and theories

Two Dimensions of Complexity

∀∃

Z/R: +-*/ select/store gnd ATP SMT

SLIDE 7

1/24

Reasoning with quantifiers and theories

Two Dimensions of Complexity

SMT

∀∃

Z/R: +-*/

E-matching

... select/store gnd ATP

SLIDE 8

1/24

Reasoning with quantifiers and theories

Two Dimensions of Complexity

SMT

∀∃

Z/R: +-*/ ATP

E-matching

...

theory axioms

... select/store gnd

SLIDE 9

1/24

Reasoning with quantifiers and theories

Two Dimensions of Complexity

SMT

∀∃

Z/R: +-*/ ATP

E-matching

...

theory axioms

... select/store gnd AVATAR

mod

Theories

SLIDE 10

1/24

Reasoning with quantifiers and theories

Two Dimensions of Complexity

SMT

∀∃

Z/R: +-*/ ATP

E-matching

...

theory axioms

... select/store gnd

SLIDE 11

2/24

This talk in one slide

Contribution 1: Theory Instantiation Rule

SLIDE 12

2/24

This talk in one slide

Contribution 1: Theory Instantiation Rule derives a simplifying instance of a non-ground clause

SLIDE 13

2/24

This talk in one slide

Contribution 1: Theory Instantiation Rule derives a simplifying instance of a non-ground clause 14x ≃ x2 + 49 ∨ p(x)

SLIDE 14

2/24

This talk in one slide

Contribution 1: Theory Instantiation Rule derives a simplifying instance of a non-ground clause 14x ≃ x2 + 49 ∨ p(x) = ⇒ p(7)

SLIDE 15

2/24

This talk in one slide

Contribution 1: Theory Instantiation Rule derives a simplifying instance of a non-ground clause 14x ≃ x2 + 49 ∨ p(x) = ⇒ p(7) by utilising ground SMT solving

SLIDE 16

2/24

This talk in one slide

Contribution 1: Theory Instantiation Rule derives a simplifying instance of a non-ground clause 14x ≃ x2 + 49 ∨ p(x) = ⇒ p(7) by utilising ground SMT solving (current) limitation: complete theories (e.g. arithmetic)

SLIDE 17

2/24

This talk in one slide

Contribution 1: Theory Instantiation Rule derives a simplifying instance of a non-ground clause 14x ≃ x2 + 49 ∨ p(x) = ⇒ p(7) by utilising ground SMT solving (current) limitation: complete theories (e.g. arithmetic) Contribution 2: Unification with Abstraction extension of unification that introduces theory constraints

SLIDE 18

2/24

This talk in one slide

Contribution 1: Theory Instantiation Rule derives a simplifying instance of a non-ground clause 14x ≃ x2 + 49 ∨ p(x) = ⇒ p(7) by utilising ground SMT solving (current) limitation: complete theories (e.g. arithmetic) Contribution 2: Unification with Abstraction extension of unification that introduces theory constraints p(2x) against ¬p(10)

SLIDE 19

2/24

This talk in one slide

Contribution 1: Theory Instantiation Rule derives a simplifying instance of a non-ground clause 14x ≃ x2 + 49 ∨ p(x) = ⇒ p(7) by utilising ground SMT solving (current) limitation: complete theories (e.g. arithmetic) Contribution 2: Unification with Abstraction extension of unification that introduces theory constraints p(2x) against ¬p(10) = ⇒ 2x ≃ 10

SLIDE 20

2/24

This talk in one slide

Contribution 1: Theory Instantiation Rule derives a simplifying instance of a non-ground clause 14x ≃ x2 + 49 ∨ p(x) = ⇒ p(7) by utilising ground SMT solving (current) limitation: complete theories (e.g. arithmetic) Contribution 2: Unification with Abstraction extension of unification that introduces theory constraints p(2x) against ¬p(10) = ⇒ 2x ≃ 10 a lazy approach to abstraction

SLIDE 21

2/24

This talk in one slide

Contribution 1: Theory Instantiation Rule derives a simplifying instance of a non-ground clause 14x ≃ x2 + 49 ∨ p(x) = ⇒ p(7) by utilising ground SMT solving (current) limitation: complete theories (e.g. arithmetic) Contribution 2: Unification with Abstraction extension of unification that introduces theory constraints p(2x) against ¬p(10) = ⇒ 2x ≃ 10 a lazy approach to abstraction new constrains can be often “discharged” by 1.

SLIDE 22

3/24

Outline

1

Short preliminaries

2

Theory instantiation

3

Abstraction through unification

4

Experiments

5

Conclusion

SLIDE 23

4/24

Short preliminaries

Main Arsenal for Theory reasoning in Vampire

SLIDE 24

4/24

Short preliminaries

Main Arsenal for Theory reasoning in Vampire evaluate ground terms: 1 + 1 = ⇒ 2

SLIDE 25

4/24

Short preliminaries

Main Arsenal for Theory reasoning in Vampire evaluate ground terms: 1 + 1 = ⇒ 2 add theory axioms: x + 0 = x, x + y = y + x, . . .

SLIDE 26

4/24

Short preliminaries

Main Arsenal for Theory reasoning in Vampire evaluate ground terms: 1 + 1 = ⇒ 2 add theory axioms: x + 0 = x, x + y = y + x, . . . AVATAR modulo theories

SLIDE 27

4/24

Short preliminaries

Main Arsenal for Theory reasoning in Vampire evaluate ground terms: 1 + 1 = ⇒ 2 add theory axioms: x + 0 = x, x + y = y + x, . . . AVATAR modulo theories Theory abstraction rule L[t] ∨ C = ⇒ x ≃ t ∨ L[x] ∨ C, where L is a theory literal, t a non-theory term, and x fresh.

SLIDE 28

4/24

Short preliminaries

Main Arsenal for Theory reasoning in Vampire evaluate ground terms: 1 + 1 = ⇒ 2 add theory axioms: x + 0 = x, x + y = y + x, . . . AVATAR modulo theories Theory abstraction rule L[t] ∨ C = ⇒ x ≃ t ∨ L[x] ∨ C, where L is a theory literal, t a non-theory term, and x fresh. Example 5 < f (y) ∨ p(y) = ⇒ x ≃ f (y) ∨ 5 < x ∨ p(y)

SLIDE 29

4/24

Short preliminaries

Main Arsenal for Theory reasoning in Vampire evaluate ground terms: 1 + 1 = ⇒ 2 add theory axioms: x + 0 = x, x + y = y + x, . . . AVATAR modulo theories Theory abstraction rule L[t] ∨ C = ⇒ x ≃ t ∨ L[x] ∨ C, where L is a theory literal, t a non-theory term, and x fresh. Example 5 < f (y) ∨ p(y) = ⇒ x ≃ f (y) ∨ 5 < x ∨ p(y) NB: abstraction can be “undone” by the equality factoring rule

SLIDE 30

5/24

Outline

1

Short preliminaries

2

Theory instantiation

3

Abstraction through unification

4

Experiments

5

Conclusion

SLIDE 31

6/24

Theory instantiation by examples

Example Consider the conjecture (∃x)(x + x ≃ 2) negated and clausified to x + x ≃ 2. It takes Vampire 15 seconds to solve using theory axioms deriving lemmas such as x + 1 ≃ y + 1 ∨ y + 1 ≤ x ∨ x + 1 ≤ y.

SLIDE 32

6/24

Theory instantiation by examples

Example Consider the conjecture (∃x)(x + x ≃ 2) negated and clausified to x + x ≃ 2. It takes Vampire 15 seconds to solve using theory axioms deriving lemmas such as x + 1 ≃ y + 1 ∨ y + 1 ≤ x ∨ x + 1 ≤ y. Example (ARI120=1) Initial clauses: x ∗ x ≃ 4 ∨ x ≃ y ∨ ¬p(y) p(2)

SLIDE 33

6/24

Theory instantiation by examples

Example Consider the conjecture (∃x)(x + x ≃ 2) negated and clausified to x + x ≃ 2. It takes Vampire 15 seconds to solve using theory axioms deriving lemmas such as x + 1 ≃ y + 1 ∨ y + 1 ≤ x ∨ x + 1 ≤ y. Example (ARI120=1) Initial clauses: x ∗ x ≃ 4 ∨ x ≃ y ∨ ¬p(y) p(2) immediately resolve to x ∗ x ≃ 4 ∨ 2 ≃ x, but this cannot be solved with axioms only in reasonable time.

SLIDE 34

7/24

Theory instantiation more formally

As an inference rule C (D[x])θ TheoryInst where A(P)(C) = T[x] → D[x] is a (partial) abstraction of C, and θ a subst. such thatT[x]θ is valid in the underlying theory.

SLIDE 35

7/24

Theory instantiation more formally

As an inference rule C (D[x])θ TheoryInst where A(P)(C) = T[x] → D[x] is a (partial) abstraction of C, and θ a subst. such thatT[x]θ is valid in the underlying theory. Implementation: Abstract relevant literals Collect relevant pure theory literals L1, . . . , Ln Run an SMT solver on T[x] = ¬L1 ∧ . . . ∧ ¬Ln If the SMT solver returns a model, transform it into a substitution θ and produce an instance If the SMT solver returns unsatisfiable then C is a theory tautology and can be removed

SLIDE 36

7/24

Theory instantiation more formally

As an inference rule C (D[x])θ TheoryInst where A(P)(C) = T[x] → D[x] is a (partial) abstraction of C, and θ a subst. such thatT[x]θ is valid in the underlying theory. Implementation: Abstract relevant literals Collect relevant pure theory literals L1, . . . , Ln Run an SMT solver on T[x] = ¬L1 ∧ . . . ∧ ¬Ln If the SMT solver returns a model, transform it into a substitution θ and produce an instance If the SMT solver returns unsatisfiable then C is a theory tautology and can be removed

SLIDE 37

8/24

When (not) to abstract

Example Consider a unit clause p(1, 5) abstracted as (x ≃ 1 ∧ y ≃ 5) → p(x, y). The only “solution substitution” is θ = {x → 1, y → 5}.

SLIDE 38

8/24

When (not) to abstract

Example Consider a unit clause p(1, 5) abstracted as (x ≃ 1 ∧ y ≃ 5) → p(x, y). The only “solution substitution” is θ = {x → 1, y → 5}. Example Consider a theory instantiation step x ≃ 1 + y ∨ p(x, y) = ⇒ p(1, 0).

SLIDE 39

8/24

When (not) to abstract

Example Consider a unit clause p(1, 5) abstracted as (x ≃ 1 ∧ y ≃ 5) → p(x, y). The only “solution substitution” is θ = {x → 1, y → 5}. Example Consider a theory instantiation step x ≃ 1 + y ∨ p(x, y) = ⇒ p(1, 0). But we can obtain a “more general” instance p(y + 1, y) using equality resolution.

SLIDE 40

9/24

Selecting Pure Theory Literals

Example (some literals constrain less/more than others) (x ≃ 0) → p(x)

SLIDE 41

9/24

Selecting Pure Theory Literals

Example (some literals constrain less/more than others) (x ≃ 0) → p(x) Three options for thi: strong: Only select strong literals where a literal is strong if it is a negative equality or an interpreted literal

• verlap: Select all strong literals and additionally those

theory literals whose variables overlap with a strong literal all: Select all non-trivial pure theory literals

SLIDE 42

10/24

Interacting with the SMT solver

Recall that we collect relevant pure theory literals L1, . . . , Ln to run an SMT solver on T[x] = ¬L1 ∧ . . . ∧ ¬Ln the negation step involves Skolemization the we just translate the terms via Z3 API

SLIDE 43

10/24

Interacting with the SMT solver

Recall that we collect relevant pure theory literals L1, . . . , Ln to run an SMT solver on T[x] = ¬L1 ∧ . . . ∧ ¬Ln the negation step involves Skolemization the we just translate the terms via Z3 API Example (The Division by zero catch!) The following two clauses are satisfiable: 1/x ≃ 0 ∨ p(x) 1/x ≃ 0 ∨ ¬p(x).

SLIDE 44

10/24

Interacting with the SMT solver

Recall that we collect relevant pure theory literals L1, . . . , Ln to run an SMT solver on T[x] = ¬L1 ∧ . . . ∧ ¬Ln the negation step involves Skolemization the we just translate the terms via Z3 API Example (The Division by zero catch!) The following two clauses are satisfiable: 1/x ≃ 0 ∨ p(x) 1/x ≃ 0 ∨ ¬p(x). However, instances p(0) and ¬p(0) could be obtained by an “unprotected” instantiation rule.

SLIDE 45

10/24

Interacting with the SMT solver

Recall that we collect relevant pure theory literals L1, . . . , Ln to run an SMT solver on T[x] = ¬L1 ∧ . . . ∧ ¬Ln the negation step involves Skolemization the we just translate the terms via Z3 API Example (The Division by zero catch!) The following two clauses are satisfiable: 1/x ≃ 0 ∨ p(x) 1/x ≃ 0 ∨ ¬p(x). However, instances p(0) and ¬p(0) could be obtained by an “unprotected” instantiation rule. Evaluation may fail: result out of Vampire’s internal range result is a proper algebraic number

SLIDE 46

11/24

A new redundancy rule

Theory Tautology Deletion Recall we abstract C as T[x] → D[x]. If the SMT solver shows that T[x] is unsatisfiable, we can remove C from the search space.

SLIDE 47

11/24

A new redundancy rule

Theory Tautology Deletion Recall we abstract C as T[x] → D[x]. If the SMT solver shows that T[x] is unsatisfiable, we can remove C from the search space. Be careful about:

SLIDE 48

11/24

A new redundancy rule

Theory Tautology Deletion Recall we abstract C as T[x] → D[x]. If the SMT solver shows that T[x] is unsatisfiable, we can remove C from the search space. Be careful about: the interaction with theory axiom support

SLIDE 49

11/24

A new redundancy rule

Theory Tautology Deletion Recall we abstract C as T[x] → D[x]. If the SMT solver shows that T[x] is unsatisfiable, we can remove C from the search space. Be careful about: the interaction with theory axiom support handling of division by zero

SLIDE 50

12/24

Outline

1

Short preliminaries

2

Theory instantiation

3

Abstraction through unification

4

Experiments

5

Conclusion

SLIDE 51

13/24

Abstraction for unification example

Example Consider two clauses r(14y) ¬r(x2 + 49) ∨ p(x).

SLIDE 52

13/24

Abstraction for unification example

Example Consider two clauses r(14y) ¬r(x2 + 49) ∨ p(x). We could fully abstract them to obtain: r(u) ∨ u ≃ 14y ¬r(v) ∨ v ≃ x2 + 49 ∨ p(x),

SLIDE 53

13/24

Abstraction for unification example

Example Consider two clauses r(14y) ¬r(x2 + 49) ∨ p(x). We could fully abstract them to obtain: r(u) ∨ u ≃ 14y ¬r(v) ∨ v ≃ x2 + 49 ∨ p(x), then resolve to get u ≃ 14y ∨ u ≃ x2 + 49 ∨ p(x).

SLIDE 54

13/24

Abstraction for unification example

Example Consider two clauses r(14y) ¬r(x2 + 49) ∨ p(x). We could fully abstract them to obtain: r(u) ∨ u ≃ 14y ¬r(v) ∨ v ≃ x2 + 49 ∨ p(x), then resolve to get u ≃ 14y ∨ u ≃ x2 + 49 ∨ p(x). Finally, Theory Instantiation could produce p(7).

SLIDE 55

14/24

Why one might not like full abstraction

1 Fully abstracted clauses are much longer

SLIDE 56

14/24

Why one might not like full abstraction

1 Fully abstracted clauses are much longer 2 The AVATAR modulo theories approach cannot help

(full abstraction destroys ground literals)

SLIDE 57

14/24

Why one might not like full abstraction

1 Fully abstracted clauses are much longer 2 The AVATAR modulo theories approach cannot help

(full abstraction destroys ground literals)

3 incompatible with theory axiom reasoning

(theory part requires special treatment)

SLIDE 58

14/24

Why one might not like full abstraction

1 Fully abstracted clauses are much longer 2 The AVATAR modulo theories approach cannot help

(full abstraction destroys ground literals)

3 incompatible with theory axiom reasoning

(theory part requires special treatment)

4 inferences need to be protected from undoing abstraction

(recall equality resolution)

SLIDE 59

15/24

Unification with constraints

Instead of full abstraction . . . incorporate the abstraction process into unification thus abstractions are “on demand” and lazy

SLIDE 60

15/24

Unification with constraints

Instead of full abstraction . . . incorporate the abstraction process into unification thus abstractions are “on demand” and lazy We define a function mguAbs(t, s) = (θ, Γ) such that (Γ → t ≃ s)θ is valid and θ is the most general such substitution given Γ.

SLIDE 61

15/24

Unification with constraints

Instead of full abstraction . . . incorporate the abstraction process into unification thus abstractions are “on demand” and lazy We define a function mguAbs(t, s) = (θ, Γ) such that (Γ → t ≃ s)θ is valid and θ is the most general such substitution given Γ. Example (strive for generality) Unifying a + b with c + d should produce ({}, a + b = c + d) and not ({}, a = c ∧ b = d).

SLIDE 62

16/24

Unification with constraints Algorithm part I

function mguAbs(s, t) if t is a variable and not occurs(t, s) then return ({t → s}, true) if s is a variable and not occurs(s, t) then return ({s → t}, true) if s and t have different top-level symbols then if canAbstract(s, t) then return ({}, s = t) return (⊥, ⊥) if s and t are constants then return ({}, true) . . .

SLIDE 63

17/24

Unification with constraints Algorithm part II

. . . let s = f (s1, . . . , sn) and t = f (t1, . . . , tn) in θ = {} and Γ = true for i = 1 to n do (θi, Γi) = mguAbs((siθ), (tiθ)) if (θi, Γi) = (⊥, ⊥) or canAbstract(s, t) and Γi = true then if canAbstract(s, t) then return ({}, s = t) return (⊥, ⊥) θ = θ ◦ θi and Γ = Γ ∧ Γi return (θ, Γ)

SLIDE 64

18/24

When do we abstract?

Example (do not produce unsatisfiable constraints) Allowing p(1) and p(2) to unify under the constraint that 1 ≃ 2 is not useful in any context. canAbstract will always be false if the two terms are always non-equal in the underlying theory.

SLIDE 65

18/24

When do we abstract?

Example (do not produce unsatisfiable constraints) Allowing p(1) and p(2) to unify under the constraint that 1 ≃ 2 is not useful in any context. canAbstract will always be false if the two terms are always non-equal in the underlying theory. On top of that For option to choose from: interpreted_only: only produce a constraint if the top-level symbol of both terms is a theory-symbol,

• ne_side_interpreted: only produce a constraint if the

top-level symbol of at least one term is a theory symbol,

• ne_side_constant: as one_side_interpreted but if the
• ther side is uninterpreted it must be a constant,

all: allow all terms of theory sort to unify and produce constraints.

SLIDE 66

19/24

Updated calculus

New inference rule: Resolution-wA A ∨ C1 ¬A′ ∨ C2 (Γ → (C1 ∨ C2))θ , where (θ, Γ) = mguAbs(A, A′) and A is not an equality literal.

SLIDE 67

19/24

Updated calculus

New inference rule: Resolution-wA A ∨ C1 ¬A′ ∨ C2 (Γ → (C1 ∨ C2))θ , where (θ, Γ) = mguAbs(A, A′) and A is not an equality literal. Example (eager evaluation is not a problem anymore) When starting from an obvious conflict: p(1 + 3) ¬p(x + 3)

SLIDE 68

19/24

Updated calculus

New inference rule: Resolution-wA A ∨ C1 ¬A′ ∨ C2 (Γ → (C1 ∨ C2))θ , where (θ, Γ) = mguAbs(A, A′) and A is not an equality literal. Example (eager evaluation is not a problem anymore) When starting from an obvious conflict: p(1 + 3) ¬p(x + 3) eager evaluation destroys this by simplifying p(1 + 3) = ⇒ p(4).

SLIDE 69

19/24

Updated calculus

New inference rule: Resolution-wA A ∨ C1 ¬A′ ∨ C2 (Γ → (C1 ∨ C2))θ , where (θ, Γ) = mguAbs(A, A′) and A is not an equality literal. Example (eager evaluation is not a problem anymore) When starting from an obvious conflict: p(1 + 3) ¬p(x + 3) eager evaluation destroys this by simplifying p(1 + 3) = ⇒ p(4). But Resolution-wA allows us to still derive 4 ≃ x + 3 and Theory Instantiation could derive the empty clause.

SLIDE 70

20/24

Outline

1

Short preliminaries

2

Theory instantiation

3

Abstraction through unification

4

Experiments

5

Conclusion

SLIDE 71

21/24

Experiments

The setup: implemented in Vampire Manchester cluster: 2x4core @ 2.4 GHz and 24GiB per node all SMTLIB with quantifiers and theories (-BV)

SLIDE 72

21/24

Experiments

The setup: implemented in Vampire Manchester cluster: 2x4core @ 2.4 GHz and 24GiB per node all SMTLIB with quantifiers and theories (-BV) How to assess the value of a new technique?

SLIDE 73

21/24

Experiments

The setup: implemented in Vampire Manchester cluster: 2x4core @ 2.4 GHz and 24GiB per node all SMTLIB with quantifiers and theories (-BV) How to assess the value of a new technique? it can interact in many ways (with around 60 other options)

SLIDE 74

21/24

Experiments

The setup: implemented in Vampire Manchester cluster: 2x4core @ 2.4 GHz and 24GiB per node all SMTLIB with quantifiers and theories (-BV) How to assess the value of a new technique? it can interact in many ways (with around 60 other options)

• ur methodology:

discard easy and unsolvable problems generate random strategy and vary the interesting part

SLIDE 75

21/24

Experiments

The setup: implemented in Vampire Manchester cluster: 2x4core @ 2.4 GHz and 24GiB per node all SMTLIB with quantifiers and theories (-BV) How to assess the value of a new technique? it can interact in many ways (with around 60 other options)

• ur methodology:

discard easy and unsolvable problems generate random strategy and vary the interesting part

For this experiment: 24 reasonable combinations of option values: fta, uwa, thi

• approx. 100 000 runs in total

SLIDE 76

22/24

Comparison of Three Options

fta uwa thi solutions

• n
• ff

all 252

• n
• ff
• verlap

265

• n
• ff

strong 266

• n
• ff
• ff

276

• ff

all all 333

• ff

all

• verlap

351

• ff

all strong 354

• ff
• ne_side_interpreted

all 364

• ff

all

• ff

364

• ff
• ne_side_constant

all 374

• ff

interpreted_only all 379

• ff
• ne_side_interpreted
• verlap

385

• ff
• ne_side_interpreted

strong 387

• ff
• ff

all 392

• ff
• ne_side_constant

strong 397

• ff
• ne_side_constant
• verlap

401

• ff

interpreted_only

• verlap

407

• ff
• ne_side_interpreted
• ff

407

• ff

interpreted_only strong 409

• ff
• ne_side_constant
• ff

417

• ff
• ff
• verlap

428

• ff

interpreted_only

• ff

430

• ff
• ff

strong 431

• ff
• ff
• ff

450

SLIDE 77

23/24

Contribution of New Options to Strategy Building

A new technique in the context of a portfolio approach:

1 helps to solve problems faster 2 solves previously unsolved problems

SLIDE 78

23/24

Contribution of New Options to Strategy Building

A new technique in the context of a portfolio approach:

1 helps to solve problems faster 2 solves previously unsolved problems

The latter dominates in FO reasoning since . . . If a problem is solvable by a prover, it is usually solvable with a short running time.

SLIDE 79

23/24

Contribution of New Options to Strategy Building

A new technique in the context of a portfolio approach:

1 helps to solve problems faster 2 solves previously unsolved problems

The latter dominates in FO reasoning since . . . If a problem is solvable by a prover, it is usually solvable with a short running time. Problems newly solved thanks to thi and uwa: ALIA (arrays and linear integer arithmetic): 2 AUFNIRA: 3 LIA : 10 LRA : 1 UFLIA : 1 UFNIA : 1

SLIDE 80

24/24

Conclusion

Two new techniques for reasoning with theories and quantifiers

SLIDE 81

24/24

Conclusion

Two new techniques for reasoning with theories and quantifiers technique 1 (thi): simplifying instances via SMT

SLIDE 82

24/24

Conclusion

Two new techniques for reasoning with theories and quantifiers technique 1 (thi): simplifying instances via SMT technique 2 (uwa): lazy abstraction during unification

SLIDE 83

24/24

Conclusion

Two new techniques for reasoning with theories and quantifiers technique 1 (thi): simplifying instances via SMT technique 2 (uwa): lazy abstraction during unification implemented in Vampire promising first results

SLIDE 84

24/24

Conclusion

Two new techniques for reasoning with theories and quantifiers technique 1 (thi): simplifying instances via SMT technique 2 (uwa): lazy abstraction during unification implemented in Vampire promising first results Directions for future work combine (thi) with the information in AVATAR modulo theory

SLIDE 85

24/24

Conclusion

Two new techniques for reasoning with theories and quantifiers technique 1 (thi): simplifying instances via SMT technique 2 (uwa): lazy abstraction during unification implemented in Vampire promising first results Directions for future work combine (thi) with the information in AVATAR modulo theory “general solutions” in terms of “parameters”

SLIDE 86

24/24

Conclusion

Two new techniques for reasoning with theories and quantifiers technique 1 (thi): simplifying instances via SMT technique 2 (uwa): lazy abstraction during unification implemented in Vampire promising first results Directions for future work combine (thi) with the information in AVATAR modulo theory “general solutions” in terms of “parameters” Thank you for your attention!