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

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

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.

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)

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.

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)

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 Thoralf Skolem). 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)

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.

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./ 2 nd 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.

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.

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)

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.

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

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

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)

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.

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.

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)

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.

Wrap up Tic Tac Toe example Other Examples