Logic Languages - PowerPoint PPT Presentation

logic languages n.
Skip this Video
Loading SlideShow in 5 Seconds..
Logic Languages PowerPoint Presentation
Download Presentation
Logic Languages

play fullscreen
1 / 20
Download Presentation
Download Presentation

Logic Languages

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Logic Languages Source: Scott, Michael Programming Language Pragmatics 3rd Ed.

  2. Overview • Predicate Calculus • Some History and Background • Operators & Quantifiers • Predicates • Horn Clause • Resolution and Unification • ProLog • Basics • Examples • Limitations, Execution and Wrap up

  3. History and Background • 1970’s – Alain Clomeraurer & Philippe Roussel of the Univ. of Aix-Marseille (France) with associates at the Univ. of Edinburgh (Scotland), due to their work, the process of logical deduction began to be used as a general-purpose model of computing. • Logic Languages are based on first-order predicate calculus. • Predicate Calculus is composed of predicates, operators and quantifiers for statements (propositions). • Logic languages however cannot capture the full power of predicate calculus, therefore we have limitations as we will see later.

  4. Operators & Quantifiers • Operators: • And (∧) • Or (∨) • Not (¬) • Implication (→) • Equivalence (↔) • Quantifiers: • For all (∀) (Universal-indicates true for all values) • There Exists (∃) (Existential-indicates true for at least one value)

  5. Predicates • Definition from section 11.3 (On CD section): • A Predicate is a function that maps constants (atoms) or variables to the values true and false.

  6. Examples from Text: • ∀C [rainy(C) ∧ cold(C) → snowy(C)] (For all cities C, if C is rainy and C is cold, then C is snowy.) • ∀A, ∀B [( ∃C [takes(A, C) ∧ takes(B, C)]) → classmates(A, B)] (For all students A and B, if there exists a class C such that A takes C and B takes C, then A and B are classmates.) • In Predicate calculus the same thing can be said in different ways. ( P  Q) can be written as (¬P ∨ Q) (P implies Q) — (Not P or Q)

  7. Clausal Form: • 5 Step procedure referred to in 11.3 on cd to translate first order into clausal form. • Step 1: Rewrite the expression to eliminate implication (→) and equivalence (↔) operators. • Step 2: Move any negations (¬) outside parenthesis as far inside as you can. • Step 3: Technique called Skolemization (after logician ThoralfSkolem). • Uses Math theorem: Axiom of choice to replace X with x in the following to remove ∃: ∃X[takes(X, cs254) ∧ class year(X, 2)] then becomes: takes(x, cs254), class year(x, 2)

  8. Clausal Form Continued: • Step 4: Move all universal quantifiers (∀) to the outside then drop it. • Step 5: Use Boolean algebra to form a conjunctive normal form. • - And (∧) & Or (∨) operators can’t be nested any more than 2 levels deep with ∧ on the outside and ∨ on the outside.

  9. Example from text: • ∀A [¬student(A) → (¬dorm resident(A)∧ ¬∃B[takes(A, B) ∧ class(B)])] (For all students A, if A is not Student, then A is not Dorm Resident and there doesn’t exist Class B such that A takes B and B is a class) –My interpretation of the above logical equation. • Step 1: ∀A[student(A) ∨ (¬dorm resident(A)∧ ¬∃B[takes(A, B) ∧ class(B)])] (For all students A, A is student or (not a dorm resident and there doesn’t exist a class B such that student A takes class B and B is a class.)) • Step 2: ∀A[student(A) ∨ (¬dorm resident(A) ∧ ∀B[¬(takes(A, B) ∧ class(B))])] ∀A[student(A) ∨ (¬dorm resident(A) ∧ ∀B[¬takes(A, B)∨ ¬class(B)])] (For all students A, A is a student or ( A is not a dorm resident and for all classes B student A doesn’t take class B and B is a class./ 2nd one or B is not a class.)) • Step 3: -NO CHANGE in this Example- • Step 4: ∀(student(A) ∨ (¬dorm resident(A) ∧ (¬takes(A, B)∨ ¬class(B)))) student(A) ∨ (¬dorm resident(A) ∧ (¬takes(A, B)∨ ¬class(B))) (For all A is a student or (A is not a dorm resident and A doesn’t take class B or B isn’t a class) • Step 5: (student(A)∨ ¬dorm resident(A)) ∧ (student(A)∨ ¬takes(A, B)∨ ¬class(B)) (A is a student or A is not a dorm resident) and (A is a student or A doesn’t take class B or B isn’t a class) • Completed, it is now in clause form.

  10. Horn Clause • Almost all logic languages follow the standard form called the Horn clause. • Every clause consists of a head and a body • H  B1, B2, …, Bn. (read: H if B1,…, and Bn) • As we noted earlier, Horn clauses cannot capture all logical statements, but most. We will revisit in limitations later.

  11. Resolution and Unification • Resolution: • The process in which we derive a new statement by combining existing statements. • Example: • If A , B  C and C  D • We can use resolution to obtain A, B  D • Unification • During Resolution, free variables may acquire values. • Example: • flowery(X)  rainy(X) and we have rainy(Rochester) • We can use Resolution to get flowery(Rochester)

  12. ProLog • After translating the expression into the Clausal form, we will need to translate into ProLog. • The Clausal form of Predicate Calculus is very close to ProLog language. • A minor drawback we will see in limitations is as ProLog cannot capture all of Predicate Calculus, Predicate Calculus does not encompass all that ProLog can do. • For running ProLog, I found a java embedded version called tuProlog ide. Google search: tuProLog and it is located in the Google code online.

  13. Translate to Prolog: • The next step is to now translate what we have into Prolog. • Simply enough, we convert each logical clause to a Prolog fact or rule. 1. (student(A) ∨ ¬dorm resident(A)) ∧ (student(A) ∨ ¬takes(A, B)∨ ¬class(B)) 2. (student(A) ← ¬(¬dorm resident(A))) ∧ (student(A) ← ¬(¬takes(A, B)∨ ¬class(B))) 3. (student(A) ← dorm resident(A)) ∧ (student(A) ← (takes(A, B) ∧ class(B))) In step three, we now have 2 Horn Clauses, and the translation into ProLog rules becomes: student(A) :- dorm_resident(A). student(A) :- takes(A, B), class(B).

  14. Syntax and Notations • ProLog runs off of a database of clauses. • A Clause is composed of terms. • A term can be composed of constants, variables, or structures. • Constants are either an atom or a number. A number which of course is a number. • An atom starts with a lowercase letter followed by any type of punctuation or can be a quoted string. Example: • foo • my_Const+ • ‘Hi,Everyone’ • A Variable starts with an uppercase letter : • Foo • My_var • X • Structures consist of an atom called the functor and it’s arguments which can be constants, variables or nested structures. • bin_tree(foo, bin_tree(bar,glarch))

  15. More about ProLog • ProLog like Scheme is homoiconic, it can represent itself and modify itself. • Keywords assert and retract add and remove clauses to the database respectively. • ProLog can only return true or false. (Or Yes or No)

  16. Advanced ProLog • Facts are like Horn Clauses without the Head • We also use these as a Query to give the ProLog interpreter. • A rule has a right-hand side. • Variable only become instantiated when unified and given a value. • Unification rules of ProLog: • Constants unifies only with itself. • Two structures unify iff the functer name and arity are the same, and the arguments unify recursively. • A variable unifies with anything. If it’s a value, great its instantiated. If it’s another non-instantiated variable, then if either get a value later, they both will be instantiated.

  17. Execution • ProLog is defined as Backward Chaining • Backward Chaining is defined as starting with the goal and working backward, attempting to “un-resolve” it into a set of preexisting clauses.

  18. Limitations • So what is missing and what can go wrong? • Consequence could result in a disjunction on the left-hand-side or a headless clause. • Example of disjunctive head: Every living thing is an animal or a plant animal(X) ∨ plant(X) ∨ ¬living(X) animal(X) ∨ plant(X) ← living(X) (two left hand side) The Prolog then would be: (as close as can) animal(X) :- living(X), \+(plant(X)) (\+ is a form of negation used to solve plant(X) :- living(X), \+(animal(X)) some of the issues that arise with negations as seen here)

  19. Limitations continued • Example of empty head: ∀N[big(N)→ ¬(∃A, ∃B, ∃C[works(A, B, C,N)])] (For all N, if N is Big, then not(there exists A, B, C such that A, B, C and N works) Clausal form is: ¬big(N)∨ ¬works(A, B, C,N) (N isn’t big or A, B, C and N don’t work) Prolog: big(N), works(A, B, C, N). But this will never terminate and is only a query, it can’t be stated as a fact or a rule.

  20. Wrap up • Tic Tac Toe example • Other Examples