Your SlideShare is downloading. ×
  • Like
Otter 1
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Now you can save presentations on your phone or tablet

Available for both IPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Otter 1

  • 63 views
Published

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
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
63
On SlideShare
0
From Embeds
0
Number of Embeds
0

Actions

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