OTTER (Organized Techniques for Theorem-proving and Effective Research) is a first-order logic based theorem prover.

1. OTTER 1

2. Language classification and OTTER
C, C++
compiler
imperative
Interpreter
(scripting)
Java
Assembler
Python
perl
ruby
Haskell
Lamda calculator
Ocaml
declarative
Prolog
Prover
Isabelle
OTTER

3. Two streams of computing
１９７０
１９８０
１９
９０
２０
００
Java（１９９０－）
assembler
２０
１０
Ruby / Python
C言語（１９７２－）
Lisp (1958-)
Haskel
Ocaml
prolog（１９７２－）
mapReduce

4. Languages on Turing machine
Turing machine
Turing
tape
Computer
Recursive
function
Kleene
Loop
C language
lambda calculus
Church
recursion
Haskell
National
deduction
Gentzen
Mathematical
recursion
Proof
Mathematical recursion
Proof
Based on natural number. We can
invoke recursive functions endlessly.
I don’t know about
flag and loop
A chain of clauses logically
connected from
Axioms.

5. Background: Resolution Principle applied
Hilbert System
Sequent calculus
Proof Theory
Gentzen System
Tableau Calculus
Resolution Principle
Applied to
computation

6. OTTER’s basic methodology
Binary resolution
Modus potens, one by one
resolution
Hyper resolution
Nucleus and satellite, All at one
Demoulation
Term rewriting
modulation
Paramodulation
Equational reasoning
list(usable).
-Greek(x) | Person(x).
-Person(x) | Mortal(x).
end_of_list.
list(sos).
Greek(sorates).
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.
list(usable).
-A(x,y) | A(x, S(y)).
end_of_list.
list(demodulators).
S(S(x)) = x.
end_of_list.
list(usable).
(a=b) | (c=d).
end_of_list.
list(sos).
P(a) | Q(n, f(c,g(d))).
end_of_list.

7. Four interactions and OTTER
Gravitational interaction
(weighting)
+
-
weight_list(pick_and_purge).
weight(P(rew($(0),$(0)),$(1)), 99)
+
+
-
+
Strong interaction (modulation)
Electromagnetic interaction (resolution)
-father(x,y) | -mother(x,z) | grandmother(x,z)
(a=b) | (c=d).
P(a) | Q(n, f(c,g(d))).

8. Liar paradox: three cases
P(says(A, L(B)).
P(says(B, L(A)).
P(says(A, T(B)).
P(says(B, T(A)).
P(says(A, L(B)).
P(says(B, T(A)).
satisfiable
satisfiable
unsatisfiable

9. Main loop of OTTER main.c
59 | while (giv_cl != NULL && status == KEEP_SEARCHING) {
81 |
82 |
83 |
84 |
85 |
101 |
102 |
103 |
104 |
105 |
106 |
107 |
108 |
109 |
110 |
111 |
index_lits_clash(giv_cl);
append_cl(Usable, giv_cl);
if (splitting())
possible_given_split(giv_cl);
infer_and_process(giv_cl);
if (status == KEEP_SEARCHING) {
if (Parms[CHANGE_LIMIT_AFTER].val == Stats[CL_GIVEN]) {
int new_limit;
new_limit = Parms[NEW_MAX_WEIGHT].val;
Parms[MAX_WEIGHT].val = new_limit;
printf("nreducing weight limit to %d.n", new_limit);
}
if (splitting())
possible_split(); /* parent does not return if successful */
giv_cl = extract_given_clause();
}
Loop until no clause can be extracted from set of support

10. Main loop of
OTTER
-
+
+
+
+
-
clash
clash
++
+
-
Search stopped
because sos empty.
pick up
pick up
+
+
+
+
+
+
+ -
+
+
+ -
-

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

12. Main loop of OTTER clause.c
3384 |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 */
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.
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 | }

13. Hyper resolution
-
+
+
- +
+
+
+
-
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.
+
-
+
+
+
+
-

14. 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.

15. Paramodulation 1
1 |set(para_into).
2 |assign(max_given,3).
3 |assign(stats_level,1).
4|
5 |list(usable).
6|
(a=b) | (c=d).
7 |end_of_list.
8|
9 |list(sos).
10 |
P(a) | Q(n, f(c,g(d))).
11 |end_of_list.

16. Paramodulation 2
1 |set(para_into).
2 |assign(stats_level,1).
3|
4 |list(usable).
5|
father(ken)=jim.
6|
mother(jim)=fay.
7 |end_of_list.
8|
9 |list(sos).
10 |
Grandmother(mother(father(x)),x).
11 |end_of_list.