Otter 2014-12-01-01-slideshare-2

OTTER

(Organized Techniques

for Theorem-proving and

Effective Research)

Heuristics computing

2014/12/01 9:25 – 11:00

Keio University, SFC

OTTER

(Organized Techniques

for Theorem-proving and Effective Research)

■ OTTER is a resolution-style theorem-proving program for first-order

logic with equality.

■ OTTER adopts a heuristic of atom-electron model. quantum mechanics

■ Basic representation is First-Order Logic of Horn Logic.

Argonne National Laboratory the largest national laboratory by size and scope in the Midwest. Argonne

was initially formed to carry out Enrico Fermi's work on nuclear reactors as part of the Manhattan

Project. Today it maintains a broad portfolio in basic science research, energy storage and renewable

energy, environmental sustainability, SuperComputing, and national security.

http://en.m.wikipedia.org/wiki/Argonne_National_Laboratory

Larry Wos is a mathematician, a researcher in the

Mathematics and Computer Science Division of

Argonne National Laboratories.

Wos studied at the University of Chicago, receiving a

bachelor's degree in 1950 and a master's in

mathematics in 1954, and went on for doctoral studies

at the University of Illinois at Urbana-Champaign. He

joined Argonne in 1957, and began using computers to

prove mathematical theorems in 1963.[

http://en.m.wikipedia.org/wiki/Larry_Wos

http://www.mcs.anl.gov/research/projects/A

R/otter/dist33/

量子力学：quantum mechanics

imperative

declarative

compiler

Interpreter

(scripting)

Lamda calculator

Prover

C, C++

Java

Python

ruby

perl

Haskell

Ocaml

PrologIsabelle

scala

proverif

Involves Assembly

Intermediate representation

NOT Assembly

Immutable variables

Resolution, SAT computation

-< x { -< y { x.call(y) } } OTTER

clock

Immutable tape

Boost

Template

Two streams of computing paradigm: Imperative vs Declarative

(language classification)

Languages on Turing machine

algorithm device language

Turing machine Turing tape Computer

Recursive function Kleene Loop C language

lambda calculus Church recursion Haskell

National deduction Gentzen Mathematical recursion Proof

Mathematical recursion

Based on natural number. We can

invoke recursive functions endlessly.

Proof

A chain of clauses logically

connected from Axioms.

Proof Theory

Hilbert System

Gentzen System

Sequent calculus

Tableau Calculus

Resolution Principle Applied to

computationOTTER is resolution style theorem prover.

Four interactions and OTTER

+

+ +-

-

-

+-

Gravitational interaction

(weighting)weight_list(pick_and_purge).

weight(P(rew($(0),$(0)),$(1)), 99)

Electromagnetic interaction (resolution)-father(x,y) | -mother(x,z) | grandmother(x,z)

Strong interaction (modulation)(a=b) | (c=d).

P(a) | Q(n, f(c,g(d))).

Main loop of

OTTER

+

-

+

+

+

+

-

-

+

+

++

-

+ -+

+

+

+ -

clash

+-+

clash

+-

pick up pick up

Search stopped

because sos

empty.

Rules (usable)

Set of support (facts)

Clash (resolve.c)

225 |static void clash(struct clash_nd *c_start,

226 | struct context *nuc_subst,

227 | struct literal *nuc_lits,

228 | struct clause *nuc,

229 | struct context *giv_subst,

230 | struct literal *giv_lits,

231 | struct clause *giv_sat,

232 | int (*sat_proc)(struct clause *c),

233 | int inf_clock,

234 | int nuc_pos,

235 | int ur_box)

Hyper resolution: atom electron model

+

-+

+

+

+- +

+

+

+

+

+

1 |set(hyper_res).

2 |assign(stats_level,1).

3 |

4 |list(usable).

5 | -Sibling(x,y) | Brother(x,y) |

Sister(x,y).

6 |end_of_list.

7 |

8 |list(sos).

9 | Sibling(pat, ray) | Cousin(pat, ray).

10 |end_of_list.

clash

Set of Support

Pick up

Set of Support

++

yielded state

(clause sets)

Hyperresolution focuses on two or

more clauses, requiring that one of

the clauses (the nucleus) contain

at least one negative literal and

the remaining (the satellites) contain

no negative literals.

proof and satisfiability

Always true Always false

satisfiable

unsatisfiable

unsatisfiablesatisfiable

AB

C

A ∩ B → empty set

B∪￢A → not Ф

Syntax “-A | B”: proof by contradiction

A

B

C

A ⊃ B

B → A

There exists Ai where

B∪￢A → Ф

1 [] -Greek(x)|Person(x).

2 [] -Person(x)|Mortal(x).

3 [] Greek(socrates).

4 [] -Mortal(socrates).

5 [hyper,3,1] Person(socrates).

6 [hyper,5,2] Mortal(socrates).

7 [binary,6.1,4.1] $F.

3 |list(usable).

4 | -Greek(x) | Person(x).

5 | -Person(x) | Mortal(x).

6 |end_of_list.

8 |list(sos).

9 | Greek(socrates).

10 |end_of_list.

12 |list(passive).

13 | -Mortal(socrates).

14 |end_of_list.

Syntax “A | B”

(exclusive, fermi particle model)

AB

C

a

A ∩ B → empty set

B∪￢A → not Ф

b

c

fermi particle model bose particle model

X

Y

Z

X

Y

Z

a

ab

c

c

a

X(a) | Y(b)

either, exclusive

electron, proton

X(a) or Y(b)

inclusive

photon

Main loop of OTTER clause.c3384 |struct clause *extract_given_clause(void)

3385 |{

3386 | struct clause *giv_cl;

3387 |

3388 | CLOCK_START(PICK_GIVEN_TIME);

3389 | giv_cl = find_given_clause();

3390 | if (giv_cl) {

3391 | rem_from_list(giv_cl);

3392 | }

3393 | CLOCK_STOP(PICK_GIVEN_TIME);

3394 | return(giv_cl);

3395 |} /* extract_given_clause */3334 |struct clause *find_given_clause(void)

3335 |{

3336 | struct clause *giv_cl;

3343 | if (Flags[SOS_QUEUE].val)

3344 | giv_cl = find_first_cl(Sos);

3345 |

3346 | else if (Flags[SOS_STACK].val)

3347 | giv_cl = find_last_cl(Sos);

3348 |

3368 | else

3369 | giv_cl = find_lightest_cl(Sos);

3370 | }

There are three kinds of

searching state space

1)Stack

2)Queue

3)weghting

If there is no clause found in

set of support,

reasoning process is

terminated.

OTTER’s basic methodology

resolution

modulation

Binary resolutionModus potens, one by one

Hyper resolutionNucleus and satellite, All at one

DemoulationTerm rewriting

ParamodulationEquational reasoning

list(usable).

(a=b) | (c=d).

end_of_list.

list(sos).

P(a) | Q(n, f(c,g(d))).

end_of_list.

list(usable).

-Greek(x) | Person(x).

-Person(x) | Mortal(x).

end_of_list.

list(sos).

Greek(sorates).

end_of_list.

list(usable).

-A(x,y) | A(x, S(y)).

end_of_list.

list(demodulators).

S(S(x)) = x.

end_of_list.

|list(usable).

-Sibling(x,y) | Brother(x,y) | Sister(x,y).

end_of_list.

list(sos).

Sibling(pat, ray) | Cousin(pat, ray).

end_of_list.

Clause Sets (節集合構成）

SoS

(Set of Support)

Demodulators

Usable

Passive

Term

rewriting

Resolution

Detect

paramodulation

1 |set(para_into).

4 |assign(stats_level,1).

5 |

6 |list(usable).

7 | a1 = b1.

8 | a2 = b2.

9 |end_of_list.

10 |

11 |list(sos).

12 | P(a1,a2).

13 |end_of_list.

Clauses

are generated

according to

line 7 and 8.