Your SlideShare is downloading. ×

Otter 1

76

Published on

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

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

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
76
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
0
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 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 1970 1980 19 90 20 00 Java(1990-) assembler 20 10 Ruby / Python C言語(1972-) Lisp (1958-) Haskel Ocaml prolog(1972-) 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.

×