Artificial Intelligence
Artificial Intelligence
Artificial Intelligence
5. Predicate Logic
Introduction
Predicate logic is used to represent Knowledge. Predicate logic will be met in Knowledge
Representation Schemes and reasoning methods. There are other ways but this form is popular.
Propositional Logic
It is simple to deal with and decision procedure for it exists. We can represent real-world facts as
logical propositions written as well-formed formulas.
To explore the use of predicate logic as a way of representing knowledge by looking at a specific
example.
.
.
.
ℎ . ∶ ℸ
The above two statements becomes totally separate assertion, we would not be able to draw any
conclusions about similarities between Socrates and Plato.
( )
( )
These representations reflect the structure of the knowledge itself. These use predicates applied to
arguments.
It fails to capture the relationship between any individual being a man and that individual being
a mortal.
We need variables and quantification unless we are willing to write separate statements.
Predicate:
A Predicate is a truth assignment given for a particular statement which is either true or false. To
solve common sense problems by computer system, we use predicate logic.
Predicate Logic
Terms represent specific objects in the world and can be constants, variables or functions.
Predicate Symbols refer to a particular relation among objects.
Sentences represent facts, and are made of terms, quantifiers and predicate symbols.
Functions allow us to refer to objects indirectly (via some relationship).
Quantifiers and variables allow us to refer to a collection of objects without explicitly
naming each object.
Some Examples
o Predicates: Brother, Sister, Mother , Father
o Objects: Bill, Hillary, Chelsea, Roger
o Facts expressed as atomic sentences a.k.a. literals:
Father(Bill,Chelsea)
Mother(Hillary,Chelsea)
Brother(Bill,Roger)
Father(Bill,Chelsea)
Nested Quantification
x,y Parent(x,y) Child(y,x)
x y Loves(x,y)
x [Passtest(x) (x ShootDave(x))]
Functions
• Functions are terms - they refer to a specific object.
• We can use functions to symbolically refer to objects without naming them.
• Examples:
fatherof(x) age(x) times(x,y) succ(x)
• Using functions
o x Equal(x,x)
o Equal(factorial(0),1)
o x Equal(factorial(s(x)), times(s(x),factorial(x)))
If we use logical statements as a way of representing knowledge, then we have available a good
way of reasoning with that knowledge.
Instance Relationship
Isa Relationship
Resolution:
A procedure to prove a statement, Resolution attempts to show that Negation of Statement gives
Contradiction with known statements. It simplifies proof procedure by first converting the
statements into canonical form. Simple iterative process; at each step, 2 clauses called the parent
clauses are compared, yielding a new clause that has been inferred from them.
Resolution refutation:
Convert all sentences to CNF (conjunctive normal
form)
Negate the desired conclusion (converted to CNF)
Apply resolution rule until either
– Derive false (a contradiction)
– Can’t apply any more
Resolution refutation is sound and complete
• If we derive a contradiction, then the conclusion follows from the axioms
• If we can’t apply any more, then the conclusion cannot be proved from the axioms.
Sometimes from the collection of the statements we have, we want to know the answer of this
question - "Is it possible to prove some other statements from what we actually know?" In order
to prove this we need to make some inferences and those other statements can be shown true
using Refutation proof method i.e. proof by contradiction using Resolution. So for the asked goal
we will negate the goal and will add it to the given statements to prove the contradiction.
So resolution refutation for propositional logic is a complete proof procedure. So if the thing that
you're trying to prove is, in fact, entailed by the things that you've assumed, then you
can prove it using resolution refutation.
Clauses:
Resolution can be applied to certain class of wff called clauses.
A clause is defined as a wff consisting of disjunction of literals.
All of the following formulas in the variables A, B, C, D, and E are in conjunctive normal form:
Clause Form:
Algorithm:
1. Eliminate implies relation (→) Using (Ex: → => ⇁ ∨ )
5. Eliminate existential quantifiers. We can eliminate the quantifier by substituting for the
variable a reference to a function that produces the desired value.
∃y: President(y) => President(S1)
∀x,∃y: Fatherof(y,x )=>∀x: Fatherof(S2(s),x)
President(func()) func is called a skolem function.
In general the function must have the same number of arguments as the number of
universal quantifiers in the current scope.
Skolemize to remove existential quantifiers. This step replaces existentially
quantified variables by Skolem functions. For example, convert ( x)P(x) to P(c) where c
is a brand new constant symbol that is not used in any other sentence (c is called a
Skolem constant). More generally, if the existential quantifier is within the scope of a
universal quantified variable, then introduce a Skolem function that depends on the
universally quantified variable. For example, "x y P(x,y) is converted to "x P(x, f(x)). f
is called a Skolem function, and must be a brand new function name that does not occur
in any other part of the logic sentence.
6. Drop the prefix. At this point, all remaining variables are universally quantified.
( ) ∨ ( )
8. Create a separate clause corresponding to each conjunct in order for a well formed
formula to be true, all the clauses that are generated from it must be true.
9. Standardize apart the variables in set of clauses generated in step 8. Rename the variables.
So that no two clauses make reference to same variable.
Basis of Resolution:
Resolution process is applied to pair of parent clauses to produce a derived clause. Resolution
procedure operates by taking 2 clauses that each contain the same literal. The literal must occur
in the positive form in one clause and negative form in the other. The resolvent is obtained by
combining all of the literals of two parent clauses except ones that cancel. If the clause that is
produced in an empty clause, then a contradiction has been found.
⇁ . Hence, R is true.
Unification Algorithm
In propositional logic it is easy to determine that two literals cannot both be true at the
same time.
Simply look for L and ~L . In predicate logic, this matching process is more complicated,
since bindings of variables must be considered.
In order to determine contradictions we need a matching procedure that compares two
literals and discovers whether there exist a set of substitutions that makes them identical.
There is a recursive procedure that does this matching. It is called Unification algorithm.
The process of finding a substitution for predicate parameters is called unification.
We need to know:
– that 2 literals can be matched.
– the substitution is that makes the literals identical.
There is a simple algorithm called the unification algorithm that does this.
( , ) ( , ): ( / )( / ) , ℎ
( ( )) ( )∶ ’ !
( ) ( ) ( ) ( ): ( / , / )
ℎ ( , ℎ ) ℎ ( , ) ℎ ( , )
( ) ( ) ( )
( ℎ ( ), ) ( , ) ( , )
The object of the Unification procedure is to discover at least one substitution that causes two
literals to match. Usually, if there is one such substitution there are many
ℎ ( , )
ℎ ( , )
could be unified with any of the following substitutions:
( / , / )
( / , / )
( / , / , / )
( / , / , / )
In Unification algorithm each literal is represented as a list, where first element is the name of a
predicate and the remaining elements are arguments. The argument may be a single element
(atom) or may be another list.
The unification algorithm recursively matches pairs of elements, one pair at a time. The matching
rules are:
• Different constants, functions or predicates cannot match, whereas identical ones can.
• A variable can match another variable, any constant or a function or predicate
expression, subject to the condition that the function or [predicate expression must not
contain any instance of the variable being matched (otherwise it will lead to infinite
recursion).
• The substitution must be consistent. Substituting y for x now and then z for x later is
inconsistent. (a substitution y for x written as y/x)
Example:
Suppose we want to unify p(X,Y,Y) with p(a,Z,b).
Initially E is {p(X,Y,Y)=p(a,Z,b)}.
The first time through the while loop, E becomes {X=a,Y=Z,Y=b}.
Suppose X=a is selected next.
Then S becomes{X/a} and E becomes {Y=Z,Y=b}.
Suppose Y=Z is selected.
Then Y is replaced by Z in S and E.
S becomes{X/a,Y/Z} and E becomes {Z=b}.
Finally Z=b is selected, Z is replaced by b, S becomes {X/a,Y/b,Z/b},
and E becomes empty.
The substitution {X/a,Y/b,Z/b} is returned as an MGU.
Unification:
∀ : ( ℎ , ) → ℎ ( ℎ , )
( ℎ , )
∀ : ( , )
∀ : ( , ℎ ( ))
∀ : ( , ℎ)
( ( ℎ , ), ( ℎ , )) = { / }
( ( ℎ , ), ( , )) = { / , ℎ / }
( ( ℎ , ), ( , ℎ ( ))) = { ℎ / , ℎ ( ℎ )/ }
( ( ℎ , ), ( , ℎ)) =
Example:
John likes all kinds of food. (a) Convert all the above statements into predicate logic
Apples are food. (b) Show that John likes peanuts using back chaining
Chicken is food. (c) Convert the statements into clause form
Anything anyone eats and it is not killed is food. (d) Using Resolution show that “John likes peanuts”
Bill eats peanuts and is still alive.
Swe eats everything bill eats
Answer:
(a) Predicate Logic:
1. ∀ : ( )→ ( ℎ )
2. ( )
3. ( ℎ )
4. ∀ , ∀ : ( , ) ¬ ( )→ ( )
5. ( , ) ( )
6. ∀ : ( , ) → ( , )
(b) Backward Chaining Proof:
( ℎ , )
↑
( )
↑
( , )⋀ ( )
↑
Answering Questions
We can also use the proof procedure to answer questions such as “who tried to assassinate
Caesar” by proving:
– Tryassassinate(y,Caesar).
– Once the proof is complete we need to find out what was substitution was made
for y.
We show how resolution can be used to answer fill-in-the-blank questions, such as "When did
Marcus die?" or "Who tried to assassinate a ruler?” Answering these questions involves finding a
known statement that matches the terms given in the question and then responding with another
piece of the same statement that fills the slot demanded by the question.
A variety of ways of representing knowledge have been exploited in AI problems. In this regard
we deal with two different kinds of entities:
Facts: truths about the real world and these are the things we want to represent.
Representation of the facts in some chosen formalism. These are the things which we will
actually be able to manipulate.
The model in the above figure focuses on facts, representations and on the 2-way mappings that
must exist between them. These links are called Representation Mappings.
- Forward Representation mappings maps from Facts to Representations.
- Backward Representation mappings maps from Representations to Facts.
English or natural language is an obvious way of representing and handling facts. Regardless of
representation for facts, we use in program, we need to be concerned with English
Representation of those facts in order to facilitate getting information into or out of the system.
The first representation does not directly suggest the answer to the problem. The second may
suggest. The third representation does, when combined with the single additional facts that each
domino must cover exactly one white square and one black square.
The puzzle is impossible to complete. A domino placed on the chessboard will always cover one
white square and one black square. Therefore a collection of dominoes placed on the board will
cover an equal numbers of squares of each color. If the two white corners are removed from the
board then 30 white squares and 32 black squares remain to be covered by dominoes, so this is
impossible. If the two black corners are removed instead, then 32 white squares and 30 black
squares remain, so it is again impossible.
In the above figure, the dotted line across the top represents the abstract reasoning process that a
program is intended to model. The solid line across the bottom represents the concrete reasoning
process that a particular program performs. This program successfully models the abstract process
to the extent that, when the backward representation mapping is applied to the program’s
output, the appropriate final facts are actually generated.
If no good mapping can be defined for a problem, then no matter how good the program to
solve the problem is, it will not be able to produce answers that correspond to real answers to
the problem.
Using Knowledge
Let us consider to what applications and how knowledge may be used.
Learning: acquiring knowledge. This is more than simply adding new facts to a knowledge
base. New data may have to be classified prior to storage for easy retrieval, etc..
Interaction and inference with existing facts to avoid redundancy and replication in the
knowledge and also so that facts can be updated.
Retrieval: The representation scheme used can have a critical effect on the efficiency of
the method. Humans are very good at it. Many AI methods have tried to model human.
Reasoning: Infer facts from existing data.
No single system that optimizes all of the capabilities for all kinds of knowledge has yet been
found. As a result, multiple techniques for knowledge representation exist.
Knowledge Representation Schemes
There are four types of Knowledge Representation:
Relational Knowledge:
– provides a framework to compare two objects based on equivalent attributes
– any instance in which two different objects are compared is a relational type of
knowledge
Inheritable Knowledge:
– is obtained from associated objects
– it prescribes a structure in which new objects are created which may inherit all or a
subset of attributes from existing objects.
Inferential Knowledge
– is inferred from objects through relations among objects
– Example: a word alone is simple syntax, but with the help of other words in
phrase the reader may infer more from a word; this inference within linguistic is
called semantics.
Declarative Knowledge
– a statement in which knowledge is specified, but the use to which that knowledge
is to be put is not given.
– Example: laws, people’s name; there are facts which can stand alone, not
dependent on other knowledge
Procedural Knowledge
– a representation in which the control information, to use the knowledge is
embedded in the knowledge itself.
– Example: computer programs, directions and recipes; these indicate specific use or
implementation
Simple relational knowledge
The simplest way of storing facts is to use a relational method where each fact about a set of
objects is set out systematically in columns. This representation gives little opportunity for
inference, but it can be used as the knowledge basis for inference engines.
• Simple way to store facts.
• Each fact about a set of objects is set out systematically in columns.
• Little opportunity for inference.
• Knowledge basis for inference engines.
Given the facts it is not possible to answer simple question such as "Who is the heaviest player?"
but if a procedure for finding heaviest player is provided, then these facts will enable that
procedure to compute an answer. We can ask things like who "bats - left" and "throws - right".
Inheritable Knowledge
Here the knowledge elements inherit attributes from their parents. The knowledge is embodied
in the design hierarchies found in the functional, physical and process domains. Within the
hierarchy, elements inherit attributes from their parents, but in many cases not all attributes of the
parent elements be prescribed to the child elements.
The inheritance is a powerful form of inference, but not adequate. The basic KR needs to be
augmented with inference mechanism.
Baseball Knowledge
- isa: show class inclusion
- instance: show class membership
The directed arrows represent attributes (isa, instance, team) originates at object being
described and terminates at object or its value.
The box nodes represent objects and values of the attributes.
Viewing a node as a frame
Example: Baseball-player
Isa: Adult-Male
Bats: EQUAL handed
Height: 6-1
Batting-average: 0.252
This algorithm is simple. It describes the basic mechanism of inheritance. It does not say what to
do if there is more than one value of the instance or “isa” attribute.
This can be applied to the example of knowledge base, to derive answers to the following
queries:
team (Pee-Wee-Reese) = Brooklyn-Dodger
batting-average (Three-Finger-Brown) = 0.106
height (Pee-Wee-Reese) = 6.1
bats (Three-Finger-Brown) = right
Inferential Knowledge:
This knowledge generates new information from the given information. This new information
does not require further data gathering from source, but does require analysis of the given
information to generate new knowledge. In this, we represent knowledge as formal logic.
Example:
- given a set of relations and values, one may infer other values or relations
- a predicate logic (a mathematical deduction) is used to infer from a set of attributes.
- inference through predicate logic uses a set of logical operations to relate individual data.
- the symbols used for the logic operations are:
Procedural Knowledge
Procedural knowledge can be represented in programs in many ways. The most common way is
simply as for doing something. The machine uses the knowledge when it executes the code to
perform a task. Procedural Knowledge is the knowledge encoded in some procedures.
Unfortunately, this way of representing procedural knowledge gets low scores with respect to the
properties of inferential adequacy (because it is very difficult to write a program that can reason
about another program’s behavior) and acquisitional efficiency (because the process of updating
and debugging large pieces of code becomes unwieldy).
The most commonly used technique for representing procedural knowledge in AI programs is the
use of production rules.
Production rules, particularly ones that are augmented with information on how they are to be
used, are more procedural than are the other representation methods. But making a clean
distinction between declarative and procedural knowledge is difficult. The important difference is
in how the knowledge is used by the procedures that manipulate it.
Heuristic or Domain Specific knowledge can be represented using Procedural Knowledge.
Below are listed issues that should be raised when using knowledge representation techniques:
The attributes are called a variety of things in AI systems, but the names do not matter. What
does matter is that they represent class membership and class inclusion and that class inclusion is
transitive. The predicates are used in Logic Based Systems.
The second way can be realized using semantic net and frame based systems. This Inverses is
used in Knowledge Acquisition Tools.
This also provides information about constraints on the values that the attribute can have and
mechanisms for computing those values.
Introduce an explicit notation for temporal interval. If two different values are ever
asserted for the same temporal interval, signal a contradiction automatically.
Assume that the only temporal interval that is of interest is now. So if a new value is
asserted, replace the old value.
Provide no explicit support. Logic-based systems are in this category. But in these systems,
knowledge base builders can add axioms that state that if an attribute has one value then
it is known not to have all other values.
Choosing the Granularity of Representation Primitives are fundamental concepts such as holding,
seeing, playing and as English is a very rich language with over half a million words it is clear we
will find difficulty in deciding upon which words to choose as our primitives in a series of
situations. Separate levels of understanding require different levels of primitives and these need
many rules to link together similar primitives.
{ : − ( )∧ℎ − ℎ ( )} –
− ℎ ℎ ℎ
The declarative representation is one in which the knowledge is specified but how to use to
which that knowledge is to be put is not given.
Declarative knowledge answers the question 'What do you know?'
It is your understanding of things, ideas, or concepts.
In other words, declarative knowledge can be thought of as the who, what, when,
and where of information.
Declarative knowledge is normally discussed using nouns, like the names of people,
places, or things or dates that events occurred.
The procedural representation is one in which the control information i.e., necessary to use the
knowledge is considered to be embedded in the knowledge itself.
Procedural knowledge answers the question 'What can you do?'
While declarative knowledge is demonstrated using nouns,
Procedural knowledge relies on action words, or verbs.
It is a person's ability to carry out actions to complete a task.
The real difference between declarative and procedural views of knowledge lies in which the
control information presides.
Example:
1. ( )
2. ( )
3. ∀ : ( )→ ( )
4. ( )
The statements 1, 2 and 3 are procedural knowledge and 4 is a declarative knowledge.
In both the cases, the control strategy is it must cause motion and systematic. The production
system model of the search process provides an easy way of viewing forward and backward
reasoning as symmetric processes.
Consider the problem of solving a particular instance of the 8-puzzle problem. The rules to be
used for solving the puzzle can be written as:
state we want. Use the left sides of the rules to generate the nodes at this second level of
the tree.
Generate the next level of the tree by taking each node at the previous level and finding
all the rules whose right sides match it. Then use the corresponding left sides to generate
the new nodes.
Continue until a node that matches the initial state is generated.
This method of reasoning backward from the desired final state is often called goal-
directed reasoning.
To reason forward, the left sides (preconditions) are matched against the current state and the
right sides (results) are used to generate new nodes until the goal is reached. To reason
backward, the right sides are matched against the current node and the left sides are used to
generate new nodes representing new goal states to be achieved.
Now suppose that at some point, the left side of a rule was nearly satisfied – nine out of ten of its
preconditions were met. It might be efficient to apply backward reasoning to satisfy the tenth
precondition in a directed manner, rather than wait for forward chaining to supply the fact by
accident.
Whether it is possible to use the same rules for both forward and backward reasoning also
depends on the form of the rules themselves. If both left sides and right sides contain pure
assertions, then forward chaining can match assertions on the left side of a rule and add to the
state description the assertions on the right side. But if arbitrary procedures are allowed as the
right sides of rules then the rules will not be reversible.
Logic Programming
Logic Programming is a programming language paradigm in which logical assertions
are viewed as programs.
There are several logic programming systems in use today, the most popular of which
is PROLOG.
A PROLOG program is described as a series of logical assertions, each of which is a
Horn clause.
A Horn clause is a clause that has at most one positive literal. Thus p, p q, p q
are all Horn clauses.
Syntactic Difference between the logic and the PROLOG representations, including:
In logic, variables are explicitly quantified. In PROLOG, quantification is provided
implicitly by the way the variables are interpreted.
o The distinction between variables and constants is made in PROLOG by having all
variables begin with uppercase letters and all constants begin with lowercase
letters.
In logic, there are explicit symbols for and () and or (). In PROLOG, there is an explicit
symbol for and (,), but there is none for or.
In logic, implications of the form “p implies q” as written as pq. In PROLOG, the same
implication is written “backward” as q: -p.
Example:
The first two of these differences arise naturally from the fact that PROLOG programs are actually
sets of Horn Clauses that have been transformed as follows:
1. If the Horn Clause contains no negative literals (i.e., it contains a single literal which is
positive), then leave it as it is.
2. Otherwise, return the Horn clause as an implication, combining all of the negative literals
into the antecedent of the implication and leaving the single positive literal (if there is
one) as the consequent.
This procedure causes a clause, which originally consisted of a disjunction of literals (all but one
of which were negative), to be transformed to single implication whose antecedent is a
conjunction of (what are now positive) literals.
Matching
We described the process of using search to solve problems as the application of appropriate
rules to individual problem states to generate new states to which the rules can then be applied
and so forth until a solution is found.
How we extract from the entire collection of rules those that can be applied at a given point? To
do so requires some kind of matching between the current state and the preconditions of the
rules. How should this be done? The answer to this question can be critical to the success of a
rule based system.
A more complex matching is required when the preconditions of rule specify required properties
that are not stated explicitly in the description of the current state. In this case, a separate set of
rules must be used to describe how some properties can be inferred from others. An even more
complex matching process is required if rules should be applied and if their pre condition
approximately match the current situation. This is often the case in situations involving physical
descriptions of the world.
Indexing
One way to select applicable rules is to do a simple search though all the rules comparing each
one’s precondition to the current state and extracting all the one’s that match. There are two
problems with this simple solution:
i. The large number of rules will be necessary and scanning through all of them at every step
would be inefficient.
ii. It’s not always obvious whether a rule’s preconditions are satisfied by a particular state.
Solution: Instead of searching through rules use the current state as an index into the rules and
select the matching one’s immediately.
Matching process is easy but at the price of complete lack of generality in the statement of the
rules. Despite some limitations of this approach, Indexing in some form is very important in the
efficient operation of rule based systems.
Backward-chaining systems usually use depth-first backtracking to select individual rules, but
forward-chaining systems generally employ sophisticated conflict resolution strategies to choose
among the applicable rules.
While it is possible to apply unification repeatedly over the cross product of preconditions and
state description elements, it is more efficient to consider the many-many match problem, in
which many rules are matched against many elements in the state description simultaneously.
One efficient many-many match algorithm is RETE.
Match
Execute Select
INFERENCE ENGINE
The above cycle is repeated until no rules are put in the conflict set or until stopping condition is
reached. In order to verify several conditions, it is a time consuming process. To eliminate the
need to perform thousands of matches of cycles on effective matching algorithm is called RETE.
RETE Algorithm is many-match algorithm (In which many rules are matched against many
elements). RETE uses forward chaining systems which generally employee sophisticated conflict
resolution strategies to choose among applicable rules. RETE gains efficiency from 3 major
sources.
1. RETE maintains a network of rule condition and it uses changes in the state
description to determine which new rules might apply. Full matching is only
pursued for candidates that could be affected by incoming/outgoing data.
2. Structural Similarity in rules: RETE stores the rules so that they share structures in
memory, set of conditions that appear in several rules are matched once for cycle.
3. Persistence of variable binding consistency. While all the individual preconditions
of the rule might be met, there may be variable binding conflicts that prevent the
rule from firing.
( , ℎ ) ( , )
( , )^ ( , ) ( , )
can be minimized. RETE remembers its previous calculations and is able to merge
new binding information efficiently.
Approximate Matching:
Rules should be applied if their preconditions approximately match to the current situation
Eg: Speech understanding program
Rules: A description of a physical waveform to phones
Physical Signal: difference in the way individuals speak, result of background noise.
Conflict Resolution:
When several rules matched at once such a situation is called conflict resolution. There are 3
approaches to the problem of conflict resolution in production system.
1. Preference based on rule match:
a. Physical order of rules in which they are presented to the system
b. Priority is given to rules in the order in which they appear