AI Notes_module 2 Conti..
AI Notes_module 2 Conti..
Knowledge Representation
REPRESENTING KNOWLEDGE USING RULES
We have discussed some techniques to represent real word facts. Now we would discuss the
use of rules to encode that knowledge. Rule based reasoning systems are very important as
we already talked about the rules as the basis for search programs. In this chapter we will
consider a set of rules that represent relationships among facts and tell about how to solve a
particular problem using the existing knowledge base.
Procedural Knowledge
It is a representation in which the control information that is necessary to use the knowledge
is embedded in the knowledge itself. To use a procedural representation, we need to augment
it with an interpreter that follows the instructions given in the knowledge.
A set of logical assertions can combine with a resolution theorem prover to give a complete
program for solving problems but in some cases, the logical assertions can view as a program
rather than data to a program.
Hence the implication statements define the legitimate reasoning paths and automatic
assertions provide the starting points of those paths. These paths define the execution paths
which is similar to the ‘if then else “in traditional programming. So, logical assertions
sometimes can be viewed as a procedural representation of knowledge.
The real difference between declarative and procedural views of knowledge lies in where
control information reside.
For example, consider the following
Man (Marcus)
Man (Caesar)
Person (Cleopatra)
∀x: Man(x) → Person(x)
Now, try to answer the question. Person(y)?
Logic Programming: Representing Knowledge Using Rules. Logic programming is a programming paradigm in
which logical assertions viewed as programs. These are several logic programming systems, PROLOG, ASP etc.
Logic Programming – Representing Knowledge Using Rules
Logic programming is a programming paradigm in which logical assertions viewed as
programs.
These are several logic programming systems, PROLOG is one of them.
A PROLOG program consists of several logical assertions where each is a horn clause
i.e. a clause with at most one positive literal.
Ex : P, P V Q, P → Q
The facts are represented on Horn Clause for two reasons.
1. Because of a uniform representation, a simple and efficient interpreter can write.
2. The logic of Horn Clause decidable.
Also, The first two differences are the fact that PROLOG
programs are actually sets of Horn clause that have been
transformed as follows:-
1. If the Horn Clause contains no negative literal then leave it as it is.
2. Also, Otherwise rewrite the Horn clauses as an implication,
combining all of the negative literals into the antecedent of
the implications and the single positive literal into the
consequent.
Moreover, This procedure causes a clause which originally
consisted of a disjunction of literals (one of them was positive) to
be transformed into a single implication whose antecedent is a
conjunction universally quantified.
But when we apply this transformation, any variables that occurred
in negative literals and so now occur in the antecedent become
existentially quantified, while the variables in the consequent are still
universally quantified.
For example the PROLOG clause P(x): – Q(x, y) is equal to logical
expression ∀x: ∃y: Q (x, y) → P(x).
The difference between the logic and PROLOG representation
is that the PROLOG interpretation has a fixed control strategy.
And so, the assertions in the PROLOG program define a
particular search path to answer any question.
But, the logical assertions define only the set of answers but not
about how to choose among those answers if there is more than
one.
Consider the following example:
1. Logical representation
∀x : pet(x) ◻ small (x) → apartmentpet(x)
∀x : cat(x) ◻ dog(x) → pet(x)
∀x : poodle (x) →
dog (x) ◻ small (x)
poodle (fluffy)
2. Prolog representation
The production system views the forward and backward as symmetric processes. We can
solve a search problem in 2 ways:
1. Reason forward from the initial state: Begin building a tree of move sequences by
starting with the initial configuration at the root of the tree. Generate the next level of the
tree by finding all rules whose left-hand side matches against the root node. The right-
hand side is used to create new configurations. Generate the next level by considering the
nodes in the previous level and applying it to all rules whose left-hand side match.
2. Reasoning backward from the goal states: Begin building a tree of move sequences by
starting with the goal node configuration at the root of the tree. Generate the next level of
the tree by finding all rules whose right-hand side matches against the root node. The left-
hand side used to create new configurations. Generate the next level by considering the
nodes in the previous level and applying it to all rules whose right-hand side match. It is
sometimes called the goal-directed reasoning.
So, in forward reasoning, the left-hand sides of the rules matched against the current state and
right sides used to generate the new state. In backward reasoning, the right-hand sides of the
rules matched against the current state and left sides are used to generate the new state.
There are four factors influencing the decision of what type of reasoning to use:
1. Are there more possible start or goal states? We move from smaller set of states to the
larger set of the states.
2. In which direction is the branching factor greater? We proceed in the direction with the
lower branching factor.
3. Will the program be asked to justify its reasoning process to a user? If, so then it is important to proceed in
the direction that is very close to the way in which the user thinks.
4. What kind of event is going to trigger a problem-solving episode? If it is the arrival of a new fact, the forward
reasoning makes sense. If it is a query to which a response is desired, backward reasoning is more natural.
It is easier to drive from an unfamiliar place to home, rather than from home to an unfamiliar place. If you
consider a home as starting place and an unfamiliar place as a goal then we have to backtrack from unfamiliar
place to home.
Consider a problem of symbolic integration. Moreover, the problem space is a set of formulas, which contains
integral expressions. Here START is equal to the given formula with some integrals. GOAL is equivalent to the
expression of the formula without any integral. Here we start from the formula with some integrals and proceed to
an integral free expression rather than starting from an integral free expression.
Another factor is deciding whether the reasoning process can justify its reasoning. If it justifies then it can apply.
For example, doctors are usually unwilling to accept any advice from diagnostics process because it cannot
explain its reasoning.
So, in a nutshell,
Forward rules encode knowledge about how to respond to certain input configuration. Forward reasoning
is goal driven.
Backward rules encode knowledge about how to achieve particular goals. Backward reasoning is data
driven.
Also, instead of searching either forward or backward, you can search both simultaneously. That is, start forward
from a starting state and backward from a goal state simultaneously until the paths meet. This strategy called Bi-
directional search.