Upcoming SlideShare
×

# Otter 1

249 views
181 views

Published on

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

Published in: Technology
0 Likes
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

• Be the first to like this

Views
Total views
249
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
1
0
Likes
0
Embeds 0
No embeds

No notes for slide

### Otter 1

1. 1. OTTER 1
2. 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. 3. Two streams of computing １９７０ １９８０ １９ ９０ ２０ ００ Java（１９９０－） assembler ２０ １０ Ruby / Python C言語（１９７２－） Lisp (1958-) Haskel Ocaml prolog（１９７２－） mapReduce
4. 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. 5. Background: Resolution Principle applied Hilbert System Sequent calculus Proof Theory Gentzen System Tableau Calculus Resolution Principle Applied to computation
6. 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. 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. 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. 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. 10. Main loop of OTTER - + + + + - clash clash ++ + - Search stopped because sos empty. pick up pick up + + + + + + + - + + + - -
11. 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. 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. 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. 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. 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. 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.