UNIT IV

LOGICAL REASONING

Syllabus : Knowledge-based agents – propositional logic –

propositional theorem proving – propositional model checking – agents
based on propositional logic. First-order logic – syntax and semantics
– knowledge representation and engineering – inferences in first-order
logic – forward chaining – backward chaining – resolution.

Knowledge-based agents

o An intelligent agent needs knowledge about the real world for taking
decisions and reasoning to act efficiently.
o Knowledge-based agents are those agents who have the capability
of maintaining an internal state of knowledge, reason over that
knowledge, update their knowledge after observations and take
actions. These agents can represent the world with some formal
representation and act intelligently.
o Knowledge-based agents are composed of two main parts:
o Knowledge-base and
o Inference system.

A knowledge-based agent must able to do the following:

o An agent should be able to represent states, actions, etc.

o An agent Should be able to incorporate new percepts
o An agent can update the internal representation of the world
o An agent can deduce the internal representation of the world
 o An agent can deduce appropriate actions.

The architecture of knowledge-based agent:

The above diagram is representing a generalized architecture for a knowledge-

based agent. The knowledge-based agent (KBA) take input from the environment
by perceiving the environment. The input is taken by the inference engine of the
agent and which also communicate with KB to decide as per the knowledge store
in KB. The learning element of KBA regularly updates the KB by learning new
knowledge.

Knowledge base: Knowledge-base is a central component of a knowledge-based

agent, it is also known as KB. It is a collection of sentences (here 'sentence' is a
technical term and it is not identical to sentence in English). These sentences are
expressed in a language which is called a knowledge representation language.
The Knowledge-base of KBA stores fact about the world.

Why use a knowledge base?

Knowledge-base is required for updating knowledge for an agent to learn with
experiences and take action as per the knowledge.

Inference system

Inference means deriving new sentences from old. Inference system allows us to
add a new sentence to the knowledge base. A sentence is a proposition about the
world. Inference system applies logical rules to the KB to deduce new
information.

Inference system generates new facts so that an agent can update the KB. An
inference system works mainly in two rules which are given as:

o Forward chaining
o Backward chaining

Operations Performed by KBA

Following are three operations which are performed by KBA in order to

show the intelligent behavior:

1. TELL: This operation tells the knowledge base what it perceives from the

environment.
2. ASK: This operation asks the knowledge base what action it should

perform.
3. Perform: It performs the selected action.

A generic knowledge-based agent:

Following is the structure outline of a generic knowledge-based agents program:

1. function KB-AGENT(percept):

2. persistent: KB, a knowledge base

3. t, a counter, initially 0, indicating time

4. TELL(KB, MAKE-PERCEPT-SENTENCE(percept, t))

5. Action = ASK(KB, MAKE-ACTION-QUERY(t))

6. TELL(KB, MAKE-ACTION-SENTENCE(action, t))

7. t=t+1
8. return action

The knowledge-based agent takes percept as input and returns an action as output.
The agent maintains the knowledge base, KB, and it initially has some
background knowledge of the real world. It also has a counter to indicate the time
for the whole process, and this counter is initialized with zero.

Each time when the function is called, it performs its three operations:

o Firstly it TELLs the KB what it perceives.

o Secondly, it asks KB what action it should take
o Third agent program TELLS the KB that which action was chosen.

The MAKE-PERCEPT-SENTENCE generates a sentence as setting that the

agent perceived the given percept at the given time.

The MAKE-ACTION-QUERY generates a sentence to ask which action should

be done at the current time.

MAKE-ACTION-SENTENCE generates a sentence which asserts that the

chosen action was executed.
Various levels of knowledge-based agent:

A knowledge-based agent can be viewed at different levels which are given below:

1. Knowledge level

Knowledge level is the first level of knowledge-based agent, and in this level, we
need to specify what the agent knows, and what the agent goals are. With these
specifications, we can fix its behavior. For example, suppose an automated taxi
agent needs to go from a station A to station B, and he knows the way from A to
B, so this comes at the knowledge level.

2. Logical level:

At this level, we understand that how the knowledge representation of knowledge

is stored. At this level, sentences are encoded into different logics. At the logical
level, an encoding of knowledge into logical sentences occurs. At the logical level
we can expect to the automated taxi agent to reach to the destination B.

3. Implementation level:

This is the physical representation of logic and knowledge. At the implementation

level agent perform actions as per logical and knowledge level. At this level, an
automated taxi agent actually implement his knowledge and logic so that he can
reach to the destination.

Approaches to designing a knowledge-based agent:

There are mainly two approaches to build a knowledge-based agent:

1. 1. Declarative approach: We can create a knowledge-based agent by

initializing with an empty knowledge base and telling the agent all the
 sentences with which we want to start with. This approach is called
Declarative approach.
2. 2. Procedural approach: In the procedural approach, we directly encode

desired behavior as a program code. Which means we just need to write a

program that already encodes the desired behavior or agent.

Propositional logic

Propositional logic (PL) is the simplest form of logic where all the statements are
made by propositions. A proposition is a declarative statement which is either
true or false. It is a technique of knowledge representation in logical and
mathematical form.

Example:

1. a) It is Sunday.
2. b) The Sun rises from West (False proposition)
3. c) 3+3= 7(False proposition)
4. d) 5 is a prime number.

Following are some basic facts about propositional logic:

o Propositional logic is also called Boolean logic as it works on 0 and 1.

o In propositional logic, we use symbolic variables to represent the logic, and
we can use any symbol for a representing a proposition, such A, B, C, P,
Q, R, etc.
o Propositions can be either true or false, but it cannot be both.
o Propositional logic consists of an object, relations or function, and logical
connectives.
 o These connectives are also called logical operators.
o The propositions and connectives are the basic elements of the
propositional logic.
o Connectives can be said as a logical operator which connects two
sentences.
o A proposition formula which is always true is called tautology, and it is
also called a valid sentence.
o A proposition formula which is always false is called Contradiction.
o A proposition formula which has both true and false values is called
o Statements which are questions, commands, or opinions are not
propositions such as "Where is Rohini", "How are you", "What is your
name", are not propositions.

Syntax of propositional logic:

The syntax of propositional logic defines the allowable sentences for the
knowledge representation. There are two types of Propositions:

a. Atomic Propositions
b. Compound propositions

o Atomic Proposition: Atomic propositions are the simple propositions. It

consists of a single proposition symbol. These are the sentences which
must be either true or false.

Example:

1. a) 2+2 is 4, it is an atomic proposition as it is a true fact.

2. b) "The Sun is cold" is also a proposition as it is a false fact.
 o Compound proposition: Compound propositions are constructed by
combining simpler or atomic propositions, using parenthesis and logical
connectives.

Example:

1. a) "It is raining today, and street is wet."

2. b) "Ankit is a doctor, and his clinic is in Mumbai."

Logical Connectives:

Logical connectives are used to connect two simpler propositions or representing

a sentence logically. We can create compound propositions with the help of
logical connectives. There are mainly five connectives, which are given as
follows:

1. Negation: A sentence such as ¬ P is called negation of P. A literal can be

either Positive literal or negative literal.
2. Conjunction: A sentence which has ∧ connective such as, P ∧ Q is called
a conjunction.
Example: Rohan is intelligent and hardworking. It can be written as,
P= Rohan is intelligent,
Q= Rohan is hardworking. → P∧ Q.
3. Disjunction: A sentence which has ∨ connective, such as P ∨ Q. is called
disjunction, where P and Q are the propositions.
Example: "Ritika is a doctor or Engineer",
Here P= Ritika is Doctor. Q= Ritika is Doctor, so we can write it as P ∨
Q.
4. Implication: A sentence such as P → Q, is called an implication.
Implications are also known as if-then rules. It can be represented as
 If it is raining, then the street is wet.
Let P= It is raining, and Q= Street is wet, so it is represented as P →
Q
5. Biconditional: A sentence such as P⇔ Q is a Biconditional sentence,
example If I am breathing, then I am alive
P= I am breathing, Q= I am alive, it can be represented as P ⇔Q.

Following is the summarized table for Propositional Logic Connectives:

Truth Table:

In propositional logic, we need to know the truth values of propositions in all

possible scenarios. We can combine all the possible combination with logical
connectives, and the representation of these combinations in a tabular format is
called Truth table. Following are the truth table for all logical connectives:
Truth table with three propositions:
We can build a proposition composing three propositions P, Q, and R. This truth
table is made-up of 8n Tuples as we have taken three proposition symbols.

Precedence of connectives:

Just like arithmetic operators, there is a precedence order for propositional

connectors or logical operators. This order should be followed while evaluating
a propositional problem. Following is the list of the precedence order for
operators:

Precedence Operators

First Precedence Parenthesis

Second Precedence Negation

Third Precedence Conjunction(AND)

Fourth Precedence Disjunction(OR)

Fifth Precedence Implication

Six Precedence Biconditional

Logical equivalence:

Logical equivalence is one of the features of propositional logic. Two

propositions are said to be logically equivalent if and only if the columns in the
truth table are identical to each other.

Let's take two propositions A and B, so for logical equivalence, we can write it
as A⇔B. In below truth table we can see that column for ¬A∨ B and A→B, are
identical hence A is Equivalent to B

Properties of Operators:

o Commutativity:
o P∧ Q= Q ∧ P, or
o P ∨ Q = Q ∨ P.
o Associativity:
o (P ∧ Q) ∧ R= P ∧ (Q ∧ R),
o (P ∨ Q) ∨ R= P ∨ (Q ∨ R)
o Identity element:
o P ∧ True = P,
o P ∨ True= True.
o Distributive:
o P∧ (Q ∨ R) = (P ∧ Q) ∨ (P ∧ R).
o P ∨ (Q ∧ R) = (P ∨ Q) ∧ (P ∨ R).
 o DE Morgan's Law:
o ¬ (P ∧ Q) = (¬P) ∨ (¬Q)
o ¬ (P ∨ Q) = (¬ P) ∧ (¬Q).
o Double-negation elimination:
o ¬ (¬P) = P.

Limitations of Propositional logic:

o We cannot represent relations like ALL, some, or none with propositional

logic. Example:
a. All the girls are intelligent.
b. Some apples are sweet.
o Propositional logic has limited expressive power.
o In propositional logic, we cannot describe statements in terms of their
properties or logical relationships.

The Wumpus World in Artificial intelligence

Wumpus world:

 The Wumpus world is a simple world example to illustrate the worth of a

knowledge-based agent and to represent knowledge representation. It was
inspired by a video game Hunt the Wumpus by Gregory Yob in 1973.
  The Wumpus world is a cave which has 4/4 rooms connected with
passageways. So there are total 16 rooms which are connected with each
other.

 We have a knowledge-based agent who will go forward in this world. The

cave has a room with a beast which is called Wumpus, who eats anyone
who enters the room.

 The Wumpus can be shot by the agent, but the agent has a single arrow. In
the Wumpus world, there are some Pits rooms which are bottomless, and
if agent falls in Pits, then he will be stuck there forever.

 The exciting thing with this cave is that in one room there is a possibility
of finding a heap of gold. So the agent goal is to find the gold and climb
out the cave without fallen into Pits or eaten by Wumpus.

 The agent will get a reward if he comes out with gold, and he will get a
penalty if eaten by Wumpus or falls in the pit.

Following is a sample diagram for representing the Wumpus world. It is showing

some rooms with Pits, one room with Wumpus and one agent at (1, 1) square
location of the world.
There are also some components which can help the agent to navigate the
cave. These components are given as follows:

a. The rooms adjacent to the Wumpus room are smelly, so that it would have
some stench.
b. The room adjacent to PITs has a breeze, so if the agent reaches near to PIT,
then he will perceive the breeze.
c. There will be glitter in the room if and only if the room has gold.
d. The Wumpus can be killed by the agent if the agent is facing to it, and
Wumpus will emit a horrible scream which can be heard anywhere in the
cave.
PEAS description of Wumpus world:

To explain the Wumpus world we have given PEAS description as below:

Performance measure:

o +1000 reward points if the agent comes out of the cave with the gold.
o -1000 points penalty for being eaten by the Wumpus or falling into the pit.
o -1 for each action, and -10 for using an arrow.
o The game ends if either agent dies or came out of the cave.

Environment:

o A 4*4 grid of rooms.

o The agent initially in room square [1, 1], facing toward the right.
o Location of Wumpus and gold are chosen randomly except the first square
[1,1].
o Each square of the cave can be a pit with probability 0.2 except the first
square.

Actuators:

o Left turn,
o Right turn
o Move forward
o Grab
o Release
o Shoot.
Sensors:

o The agent will perceive the stench if he is in the room adjacent to the
Wumpus. (Not diagonally).
o The agent will perceive breeze if he is in the room directly adjacent to the
Pit.
o The agent will perceive the glitter in the room where the gold is present.
o The agent will perceive the bump if he walks into a wall.
o When the Wumpus is shot, it emits a horrible scream which can be
perceived anywhere in the cave.
o These percepts can be represented as five element list, in which we will
have different indicators for each sensor.
o Example if agent perceives stench, breeze, but no glitter, no bump, and no
scream then it can be represented as:
[Stench, Breeze, None, None, None].

The Wumpus world Properties:

o Partially observable: The Wumpus world is partially observable because

the agent can only perceive the close environment such as an adjacent
room.
o Deterministic: It is deterministic, as the result and outcome of the world
are already known.
o Sequential: The order is important, so it is sequential.
o Static: It is static as Wumpus and Pits are not moving.
o Discrete: The environment is discrete.
o One agent: The environment is a single agent as we have one agent only
and Wumpus is not considered as an agent.
Exploring the Wumpus world:

Now we will explore the Wumpus world and will determine how the agent will
find its goal by applying logical reasoning.

Agent's First step:

Initially, the agent is in the first room or on the square [1,1], and we already know
that this room is safe for the agent, so to represent on the below diagram (a) that
room is safe we will add symbol OK. Symbol A is used to represent agent, symbol
B for the breeze, G for Glitter or gold, V for the visited room, P for pits, W for
Wumpus.

At Room [1,1] agent does not feel any breeze or any Stench which means the
adjacent squares are also OK.
Agent's second Step:

Now agent needs to move forward, so it will either move to [1, 2], or [2,1]. Let's
suppose agent moves to the room [2, 1], at this room agent perceives some breeze
which means Pit is around this room. The pit can be in [3, 1], or [2,2], so we will
add symbol P? to say that, is this Pit room?

Now agent will stop and think and will not make any harmful move. The agent
will go back to the [1, 1] room. The room [1,1], and [2,1] are visited by the agent,
so we will use symbol V to represent the visited squares.

Agent's third step:

At the third step, now agent will move to the room [1,2] which is OK. In the room
[1,2] agent perceives a stench which means there must be a Wumpus nearby. But
Wumpus cannot be in the room [1,1] as by rules of the game, and also not in [2,2]
(Agent had not detected any stench when he was at [2,1]). Therefore agent infers
that Wumpus is in the room [1,3], and in current state, there is no breeze which
means in [2,2] there is no Pit and no Wumpus. So it is safe, and we will mark it
OK, and the agent moves further in [2,2].
Agent's fourth step:

At room [2,2], here no stench and no breezes present so let's suppose agent
decides to move to [2,3]. At room [2,3] agent perceives glitter, so it should grab
the gold and climb out of the cave.

Propositional theorem proving

a different approach to using logic to solve problems is to use logical rules of

inference to generate logical implications

in some cases, this can be less work than model-checking (i.e. generating a truth
table) or even SAT solving

plus, logical rules of inference are at the level of logical reasoning that humans
consciously strive to do

theorem-proving is interested in entailment, e.g. given a logical sentence A and a

logical sentence B, we can ask if A entails B

the general idea is that sentence A is what the agent knows, and sentence B is
something that the agent can infer from what it knows

sentence A might be very big, i.e. the entire “brain” of an agent encoded in logic

an important basic result in logic is the deduction theorem, which says:

A entails B if, and only if, A => B (A implies B) is a tautology (i.e. valid for all
assignments of values to its variables)

so we can answer the question “Does A entail B?” by showing that the sentence
A => B is a tautology
recall that a sentence is unsatisfiable if no assignment of values to its variables
makes it true

so A => B is a tautology, then !(A=>B) is unsatisfiable, and !(A=>B) == !(!(A &

!B)) == A & !B

so we can re-write the deduction theorem like this:

A entails B if, and only if, A & !B is unsatisfiable

this means you can use a SAT solver to figure out entailment!

Rules of Inference

recall that there are various rules of inference that can be used to create proofs,
i.e. chains of correct inferences

e.g. modus ponens is this rule of inference:

A, A => B

--------- modus ponens

this rule says that if you are given a sentence A, and a sentence A => B, you may
infer B

e.g. and-elimination is this pair of rules:

A&B
----- and-elimination

A&B

-----

these two rules encode the (obvious!) fact that if the sentence A & B is true, then
A is true, and also B is true

logical equivalences can also be stated as inference rules, e.g.:

A <==> B

---------------

(A=>B) & (B=>A)

there are many inference rules, and choosing a reasonable set of rules for a
theorem-prover turns out to be important

we can think of the application of one rule of inference as an action performed to

the state of the world, i.e. the rule of inference adds more facts to the knowledge
base

if there are multiple inference rules to choose from, then we need knowledge (i.e.
heuristics) to help decide which rule to use
or we could rely on backtracking, i.e. just pick a rule at random, apply it, and keep
going until it “seems” like a proof is not being reached

plus, how do we know that the rules of inference we are using are complete, i.e.
if a proof exists, how do we know our set of inference rules will find it?

e.g. suppose the two and-elimination rules were our only rules of inference; is
this enough to prove any entailment in propositional logic?

no!

for example, (P | P) -> P is clearly true, but and-elimination doesn’t apply to this
sentence

Proof by Resolution

it turns out that only one particular inference rule is needed to prove any logical
entailment (that can be proved): the resolution rule

in a 2-variable form, the resolution inference rule is this (| here means “or”):

A | B, !B

----------

resolution

A | !B, B
----------

in English, the first rules says that if A or B is true, and B is not true, then A must
be true; the second rule says the same thing, but B and !B are swapped

note that A | !B is logically equivalent to B -> A, and so the resolution rules can
be translated to this:

!B -> A, !B

----------- variation of modus ponens

B -> A, B

--------- modus ponens

in other words, resolution inference could be viewed as a variation of inference

with modus ponens

we can generalize resolution as follows:

A_1 | A_2 | ... | A_i | ... | A_n !A_i

----------------------------------------- resolution generalized

A_1 | A_2 | ... | A_i-1 | A_i+1... | A_n

we’ve written A_i and !A_i, but those could be swapped: the key is that they are
complementary literals

notice that both sentence above and below the inference line are CNF clauses

recall that a CNF clause consists of literals (a variable, or the negation of a

variable), or-ed together

so resolution can be stated conveniently in terms of clauses, e.g.:

Clause_1 L_i opposite of literal L_i is in Clause_1

--------------

Clause_2 Clause_2 is Clause_1 with opposite of literal L_i removed

here, L_i is a literal that has the opposite sign of a literal in Clause_1

i.e. L_i is the complement of a literal in Clause_1

Clause_2 is the same as Clause_1, but with the literal that is the opposite of L_i
removed

e.g.:

(A | !B | !C) !A A and !A are complementary literals

-----------------

!B | !C

(A | !B | !C) C C and !C are complementary literals

-----------------

A | !B

full resolution generalizes this even further to two clauses:

Clause_1 Clause_2

------------------ full resolution

Clause_3

here, we assume that some literal L appears in Clause_1, and the complement of
L appears in Clause_2

Clause_3 contains all the literals (or-ed together) from both Clause_1 and
Clause_2, except for L and its opposite — those are not in Clause_3

e.g.:

(A | !B | !C) (!A | !C | D) A and !A are complementary literals

----------------------------

!B | !C | D

what is surprising is that full resolution is complete: it can be used to proved any
entailment (assuming the entailment can be proven)

to do this, resolution requires that all sentences be converted to CNF

this can always be done … see the textbook for a sketch of the basic idea

the same requirement for most SAT solvers!

next, recall from above that if A entails B, then A & !B is unsatisfiable

this is a consequence of the deduction theorem

resolution theorem proving proves that A entails B by proving that A & !B is

unsatisfiable

it follows these steps:

A & !B is converted to CNF

clauses with complementary literals are chosen and resolved (i.e. the resolution
rule is applied to them to remove the literal and its complement) and added as a
new clause in the knowledge base

this continues until one of two things happens:

no new clause can be added, which means that A does not entail B

in other words, A & !B is satisfiable

two clauses resolve to yield the empty clause, which means that A entails B

the empty clause means there is a contradiction, i.e. if P and !P are clauses then
we can apply resolution to them to get the “empty clause”

clearly, if both P and !P are in the same knowledge base, then it is inconsistent
since P & !P is false for all values of P
Example. KB = {P->Q, Q->R}

does KB entail P->R?

yes it does, and lets use resolution to prove this

to prove KB entails P->R, we will prove that KB & !(P->R) is unsatisfiable

first we convert KB & !(P->R) to CNF:

!P | Q

!Q | R

!R

next we pick pairs of clauses and resolve them (i.e. apply the resolution inference
rule) if we can; we add any clauses produced by this to the collection of clauses:

!P | Q

!Q | R

!R

!P | R // from resolving (!P | Q) with (!Q | R)

Q // from resolving (!P | Q) with (P)

!Q // from resolving (!Q | R) with (!R)

we have Q and !Q, meaning we’ve reach a contradiction

this means KB & !(P->R) is unsatisfiable

which means KB entails P->R

this is a proof of entailment, and the various resolutions are the steps of the proof

the exact order in which clauses are resolved could result in shorter or longer
proofs, and in practice you usually want short proofs, and so heuristic would be
needed to help make decisions

Horn Clauses and Definite Clauses

a fundamental difficulty with SAT solvers and algorithms like resolution is that,
for propositional logic, they have exponential running time

SAT solvers are fast, but in the worst case they can still take an exponential
amount of time to finish

plus, many problems require thousands or more variables when encoded in

propositional logic, and that alone makes some problems simply too big to be
handled by SAT solvers

so, some AI researchers have explored the possibility of using a logic that is less
expressive than propositional logic, but for which entilaments can be computed
more efficiently

for example, a definite clause is a clause in which exactly 1 literal is positive, e.g.:
A | !B | !C definite clause

!A | !W | E | !S definite clause

P definite clause

A | B | !C not a definite clause

!T not a definite clause

a horn clause is a clause with 0 or 1 positive literals (i.e. at most one positive
literal), e.g.:

A | !B | !C horn clause

!A | !B | !C horn clause (but not a definite clause)

!A horn clause (but not a definite clause)

A horn clause

note that every definite clause is a horn clause, but some horn clauses are not
definite clauses

these restricted forms of clauses are interesting for a few reasons:

entailment of horn clauses can be decided in time linear with respect to the size
of the knowledge base – much more efficient than full resolution

reasoning with horn clauses can be done in a straightforward way that humans
find easier to follow than resolution
definite clauses can be written in an appealing form using implication, i.e. the
definite clause A | !B | !C can be written (B & C) -> A

more generally, the definite clause A | !B1 | !B2 | … | !Bn can be written as (B1
& B2 & … & Bn) -> A

the implication is sometimes written in reverse:

A <- B1 & B2 & ... & Bn

for some real-world problems, this is can be a natural way to encode knowledge,
i.e. A is true if B1, B2, …, and Bn are all true

horn clauses are used extensively in the logic programming language Prolog

however, the problem with Horn clauses is that not all problems can be
represented with them: they’re less expressive than propositional logic

this seems to be a fundamental trade-off: the more expressive the logic, the less
efficient entailment algorithms are

but research continues!

Propositional model checking

In this section, we describe two families of efficient algorithms for general

propositional inference based on model checking: One approach based on
backtracking search, and one on local hill-climbing search. These algorithms are
part of the “technology” of propositional logic. This section can be skimmed on
a first reading of the chapter
The algorithms we describe are for checking satisfiability: the SAT problem. (As
noted earlier, testing entailment, α |= β, can be done by testing unsatisfiability of
α ∧ ¬β.) We have already noted the connection between finding a satisfying
model for a logical sentence and finding a solution for a constraint satisfaction
problem, so it is perhaps not surprising that the two families of algorithms closely
resemble the backtracking algorithms of Section 6.3 and the local search
algorithms of Section 6.4. They are, however, extremely important in their own
right because so many combinatorial problems in computer science can be
reduced to checking the satisfiability of a propositional sentence. Any
improvement in satisfiability algorithms has huge consequences for our ability to
handle complexity in general.

7.6.1 A complete backtracking algorithm

The first algorithm we consider is often called the Davis–Putnam algorithm, after
the seminal paper by Martin Davis and Hilary Putnam (1960). The algorithm is
in fact the version described by Davis, Logemann, and Loveland (1962), so we
will call it DPLL after the initials of all four authors. DPLL takes as input a
sentence in conjunctive normal form—a set of clauses. Like BACKTRACKING-
SEARCH and TT-ENTAILS?, it is essentially a recursive, depth-first
enumeration of possible models. It embodies three improvements over the simple
scheme of TT-ENTAILS?:
• Early termination: The algorithm detects whether the sentence must be true or
false, even with a partially completed model. A clause is true if any literal is true,
even if the other literals do not yet have truth values; hence, the sentence as a
whole could be judged true even before the model is complete. For example, the
sentence (A ∨ B) ∧ (A ∨ C) is true if A is true, regardless of the values of B and
C. Similarly, a sentence is false if any clause is false, which occurs when each of
its literals is false. Again, this can occur long before the model is complete. Early
termination avoids examination of entire subtrees in the search space.

• Pure symbol heuristic: A pure symbol is a symbol that always appears with the
same “sign” in all clauses. For example, in the three clauses (A ∨ ¬B), (¬B ∨
¬C), and (C ∨ A), the symbol A is pure because only the positive literal appears,
B is pure because only the negative literal appears, and C is impure. It is easy to
see that if a sentence has a model, then it has a model with the pure symbols
assigned so as to make their literals true, because doing so can never make a
clause false. Note that, in determining the purity of a symbol, the algorithm can
ignore clauses that are already known to be true in the model constructed so far.
For example, if the model contains B = false, then the clause (¬B ∨ ¬C) is already
true, and in the remaining clauses C appears only as a positive literal; therefore C
becomes pure.

• Unit clause heuristic: A unit clause was defined earlier as a clause with just one
literal. In the context of DPLL, it also means clauses in which all literals but one
are already assigned false by the model. For example, if the model contains B =
true, then (¬B ∨ ¬C) simplifies to ¬C, which is a unit clause. Obviously, for this
clause to be true, C must be set to false. The unit clause heuristic assigns all such
symbols before branching on the remainder. One important consequence of the
heuristic is that any attempt to prove (by refutation) a literal that is already in the
knowledge base will succeed immediately (Exercise 7.23). Notice also that
assigning one unit clause can create another unit clause—for example, when C is
set to false, (C ∨ A) becomes a unit clause, causing true to be assigned to A. This
“cascade” of forced assignments is called unit propagation. It resembles the
process of forward chaining with definite clauses, and indeed, if the CNF
expression contains only definite clauses then DPLL essentially replicates
forward chaining. (See Exercise 7.24.)

The DPLL algorithm is shown in Figure 7.17, which gives the the essential
skeleton of the search process.

What Figure 7.17 does not show are the tricks that enable SAT solvers to scale
up to large problems. It is interesting that most of these tricks are in fact rather
general, and we have seen them before in other guises:

1. Component analysis (as seen with Tasmania in CSPs): As DPLL assigns truth
values to variables, the set of clauses may become separated into disjoint subsets,
called components, that share no unassigned variables. Given an efficient way to
detect when this occurs, a solver can gain considerable speed by working on each
component separately.

2. 2. Variable and value ordering (as seen in Section 6.3.1 for CSPs): Our simple
implementation of DPLL uses an arbitrary variable ordering and always tries the
value true before false. The degree heuristic (see page 216) suggests choosing the
variable that appears most frequently over all remaining clauses.

3. Intelligent backtracking (as seen in Section 6.3 for CSPs): Many problems that
cannot be solved in hours of run time with chronological backtracking can be
solved in seconds with intelligent backtracking that backs up all the way to the
relevant point of conflict. All SAT solvers that do intelligent backtracking use
some form of conflict clause learning to record conflicts so that they won’t be
repeated later in the search. Usually a limited-size set of conflicts is kept, and
rarely used ones are dropped.

4. Random restarts (as seen on page 124 for hill-climbing): Sometimes a run
appears not to be making progress. In this case, we can start over from the top of
the search tree, rather than trying to continue. After restarting, different random
choices (in variable and value selection) are made. Clauses that are learned in the
first run are retained after the restart and can help prune the search space.
Restarting does not guarantee that a solution will be found faster, but it does
reduce the variance on the time to solution.

5. Clever indexing (as seen in many algorithms): The speedup methods used in
DPLL itself, as well as the tricks used in modern solvers, require fast indexing of
such things as “the set of clauses in which variable Xi appears as a positive
literal.” This task is complicated by the fact that the algorithms are interested only
in the clauses that have not yet been satisfied by previous assignments to
variables, so the indexing structures must be updated dynamically as the
computation proceeds.

With these enhancements, modern solvers can handle problems with tens of
millions of variables. They have revolutionized areas such as hardware
verification and security protocol verification, which previously required
laborious, hand-guided proofs.

7.6.2 Local search algorithms

We have seen several local search algorithms so far in this book, including HILL-
CLIMBING (page 122) and SIMULATED-ANNEALING (page 126). These
algorithms can be applied directly to satisfiability problems, provided that we
choose the right evaluation function. Because the goal is to find an assignment
that satisfies every clause, an evaluation function that counts the number of
unsatisfied clauses will do the job. In fact, this is exactly the measure used by the
MIN-CONFLICTS algorithm for CSPs (page 221). All these algorithms take
steps in the space of complete assignments, flipping the truth value of one symbol
at a time. The space usually contains many local minima, to escape from which
various forms of randomness are required. In recent years, there has been a great
deal of experimentation to find a good balance between greediness and
randomness.

One of the simplest and most effective algorithms to emerge from all this work is
called WALKSAT (Figure 7.18). On every iteration, the algorithm picks an
unsatisfied clause and picks a symbol in the clause to flip. It chooses randomly
between two ways to pick which symbol to flip: (1) a “min-conflicts” step that
minimizes the number of unsatisfied clauses in the new state and (2) a “random
walk” step that picks the symbol randomly.
When WALKSAT returns a model, the input sentence is indeed satisfiable, but
when it returns failure, there are two possible causes: either the sentence is
unsatisfiable or we need to give the algorithm more time. If we set max flips = ∞
and p > 0, WALKSAT will eventually return a model (if one exists), because the
random-walk steps will eventually hit upon the solution. Alas, if max flips is
infinity and the sentence is unsatisfiable, then the algorithm never terminates!

For this reason, WALKSAT is most useful when we expect a solution to exist—
for example, the problems discussed in Chapters 3 and 6 usually have solutions.
On the other hand, WALKSAT cannot always detect unsatisfiability, which is
required for deciding entailment. For example, an agent cannot reliably use
WALKSAT to prove that a square is safe in the wumpus world. Instead, it can
say, “I thought about it for an hour and couldn’t come up with a possible world
in which the square isn’t safe.” This may be a good empirical indicator that the
square is safe, but it’s certainly not a proof.

7.6.3 The landscape of random SAT problems

Some SAT problems are harder than others. Easy problems can be solved by any
old algorithm, but because we know that SAT is NP-complete, at least some
problem instances must require exponential run time. In Chapter 6, we saw some
surprising discoveries about certain kinds of problems. For example, the n-queens
problem—thought to be quite tricky for backtracking search algorithms—turned
out to be trivially easy for local search methods, such as min-conflicts. This is
because solutions are very densely distributed in the space of assignments, and
any initial assignment is guaranteed to have a solution nearby. Thus, n-queens is
easy because it is underconstrained.

When we look at satisfiability problems in conjunctive normal form, an

underconstrained problem is one with relatively few clauses constraining the
variables. For example, here is a randomly generated 3-CNF sentence with five
symbols and five clauses:

(¬D ∨ ¬B ∨ C) ∧ (B ∨ ¬A ∨ ¬C) ∧ (¬C ∨ ¬B ∨ E) ∧ (E ∨ ¬D ∨ B) ∧ (B ∨

E ∨ ¬C) .

Sixteen of the 32 possible assignments are models of this sentence, so, on average,
it would take just two random guesses to find a model. This is an easy
satisfiability problem, as are most such underconstrained problems. On the other
hand, an overconstrained problem has many clauses relative to the number of
variables and is likely to have no solutions.

To go beyond these basic intuitions, we must define exactly how random

sentences are generated. The notation CNFk(m, n) denotes a k-CNF sentence with
m clauses and n symbols, where the clauses are chosen uniformly, independently,
and without replacement from among all clauses with k different literals, which
are positive or negative at random. (A symbol may not appear twice in a clause,
nor may a clause appear twice in a sentence.)
Given a source of random sentences, we can measure the probability of
satisfiability. Figure 7.19(a) plots the probability for CNF3(m, 50), that is,
sentences with 50 variables and 3 literals per clause, as a function of the
clause/symbol ratio, m/n. As we expect, for small m/n the probability of
satisfiability is close to 1, and at large m/n the probability is close to 0. The
probability drops fairly sharply around m/n = 4.3. Empirically, we find that the
“cliff” stays in roughly the same place (for k = 3) and gets sharper and sharper as
n increases. Theoretically, the satisfiability threshold conjecture says that for
every k ≥ 3,there is a threshold ratio rk such that, as n goes to infinity, the
probability that CNFk(n, rn) is satisfiable becomes 1 for all values of r below the
threshold, and 0 for all values above. The conjecture remains unproven.

Now that we have a good idea where the satisfiable and unsatisfiable problems
are, the next question is, where are the hard problems? It turns out that they are
also often at the threshold value. Figure 7.19(b) shows that 50-symbol problems
at the threshold value of 4.3 are about 20 times more difficult to solve than those
at a ratio of 3.3. The underconstrained problems are easiest to solve (because it is
so easy to guess a solution); the overconstrained problems are not as easy as the
underconstrained, but still are much easier than the ones right at the threshold.

Agents based on propositional logic

Introduction

An agent learns to make decisions by interacting with its surroundings in a type

of machine learning known as reinforcement learning. By getting feedback for its
activities in the form of incentives or penalties, the agent learns. Robotics, video
games, and self-driving cars are just a few examples of the many applications for
reinforcement learning. We will thoroughly examine the theories and methods
underlying reinforcement learning in this article.

Propositional Logic based Agent: A Comprehensive Overview

Throughout the last few decades, the field of artificial intelligence (AI) has
experienced significant advancement. Scientists and researchers are developing a
variety of AI models to mimic human intelligence as a result of advances in
technology and computer science. The agent based on propositional logic is one
of the foundational AI techniques. This article will examine the definition,
operation, and numerous uses of a propositional logic-based agent.

What is Propositional Logic?

A subset of mathematical logic known as propositional logic deals with

propositions, which are statements that can either be true or wrong. Sentential
logic or statement logic are other names for it. The symbols P, Q, R, and other
symbols are used in propositional logic to express propositions. Compound
propositions, which are composed of one or more separate propositions, are
created using these symbols. Moreover, to link propositions, propositional logic
makes use of logical connectives like "and," "or," "not," "implies," and "if and
only if."

What is a Propositional Logic-based Agent?

An AI agent that utilises propositional logic to express its knowledge and make
decisions is known as a propositional logic-based agent. A straightforward form
of agent, it decides what to do depending on what it knows about the outside
world. A knowledge base, which is made up of a collection of logical phrases or
sentences, serves as a representation of the propositional logic-based agent's
knowledge.

The agent's knowledge is empty, however as it observes the outside world, it fills
it with fresh data. To decide what actions to do in response to the environment,
the agent uses its knowledge base. Depending on the logical inference it makes
on its knowledge base, the agent takes judgements.

How does a Propositional Logic-based Agent work?

A propositional logic-based agent functions by expressing its understanding of

the outside world as logical statements. The knowledge base is initially empty,
but as the agent explores the environment, it fills it with fresh data. The agent
draws new knowledge from its knowledge base through logical inference.
Deductive or inductive reasoning can be used to draw a conclusion.

Deductive inference is the process of inferring new information using logical

principles from already known information. The process of generalizing from
specific data to arrive at a broader conclusion is known as inductive inference.
Based on the objectives it seeks to attain, the agent decides what course of action
to take.
Perception, reasoning, and action are the three stages of the agent's decision-
making process. Observing the surroundings and updating the information base
are steps in the perception process. In order to generate new information, the
reasoning stage requires using logical inference to the knowledge base. The
action phase entails choosing an action based on the information that was
gathered and the agent's objectives.

Applications of Propositional Logic-based Agents

In the field of AI, propositional logic-based agents have several uses. Expert
system applications are one of the most popular uses. Expert systems are artificial
intelligence programs created to address difficulties in a particular field. They
represent their subject knowledge in a knowledge base, and they draw new
information from the knowledge base using a reasoning engine.

In the area of natural language processing, propositional logic-based agents are

also used (NLP). The area of AI known as NLP deals with how computers and
human languages interact. The meaning of natural language phrases can be
represented by and new information can be derived from them using propositional
logic-based agents.

Knowledge Representation

Propositional logic-based agents' core feature is knowledge representation. A

collection of logical clauses that represent the agent's knowledge of the outside
world make up the knowledge base of the agent. Depending on how much
knowledge the agent has about the outside world, the knowledge base may be
either complete or lacking. The agent's capacity to make informed decisions is
impacted by the knowledge base's completeness.
The fact that propositional logic offers a straightforward and understandable
method of conveying knowledge is one of its benefits. Propositional logic uses
simple to comprehend logical symbols and logical connectives to depict
relationships between propositions.

Logical Inference

The technique of inferring new knowledge from knowledge already known is

known as logical inference. Propositional logic-based agents should have logical
inference because it enables the agent to reason regarding the external world and
gather new knowledge that can be applied to decision-making. Deductive
inference as well as inductive inference are the two different categories of logical
inference.

By using logical principles, deductive inference is the act of obtaining new

knowledge based on previously data obtained. It is predicated on the idea that if
an argument's premises are true, then it follows that the argument's conclusion
must also be true. Propositional logic-based agents draw new knowledge from
the body of knowledge through deductive inference.

Decision Making

A crucial function of propositional logic-based agents is decision-making. The

agent bases its decisions on knowledge of the outside world and its desired
outcomes. Three steps make up the decision-making process: perception,
justification, and execution.

Observing the environment and updating the agent's knowledge base is the
process of perception. Using logical inference to extract new information from
the knowledge base is the process of reasoning. Action is the process of choosing
a course of action based on the knowledge that has been obtained and the agent's
goals.

Making judgements in a transparent and understandable manner is one of the

advantages of employing propositional logic-based agents for decision making.
It is simpler to trust the agent's conclusions since the logical rules it uses to decide
are simple enough for humans to understand.

Limitations

Although agents based on propositional logic offer numerous benefits, they also
have certain drawbacks. One of the drawbacks is that they lack expressiveness
and are unable to depict intricate interactions between propositions. They are
unable to depict, for instance, causal or temporal links between assertions.

Another drawback is that propositional logic-based agents are unable to deal with
uncertainty or inadequate data. As a result, they are unable to handle
circumstances in which there is a lack of information or uncertainty regarding the
environment.

Fuzzy logic, Bayesian networks, and neural networks, among other forms of AI
models, have been developed to get around these restrictions. These models offer
a more powerful and expressive means of describing knowledge and making
judgements.

Conclusion

In conclusion, Propositional rationale-based specialists give a primary simulated

intelligence strategy to data portrayal and direction. They can be used in a variety
of ways and can be combined with other AI models to make better systems. They
are useful in industries that require trust and transparency, despite their
limitations. Propositional logic-based agents will continue to be crucial to the
development of intelligent systems as AI research advances. Where information
can be expressed as propositions and decision-making follows logical principles,
their effectiveness shines especially brightly.

First-order logic

o First-order logic is another way of knowledge representation in artificial

intelligence. It is an extension to propositional logic.
o FOL is sufficiently expressive to represent the natural language statements
in a concise way.
o First-order logic is also known as Predicate logic or First-order
predicate logic. First-order logic is a powerful language that develops
information about the objects in a more easy way and can also express the
relationship between those objects.
o First-order logic (like natural language) does not only assume that the
world contains facts like propositional logic but also assumes the following
things in the world:
o Objects: A, B, people, numbers, colors, wars, theories, squares, pits,
wumpus, ......
o Relations: It can be unary relation such as: red, round, is
adjacent, or n-any relation such as: the sister of, brother of, has
color, comes between
o Function: Father of, best friend, third inning of, end of, ......
o As a natural language, first-order logic also has two main parts:
a. Syntax
b. Semantics

syntax and semantics

Syntax of First-Order logic:

The syntax of FOL determines which collection of symbols is a logical expression

in first-order logic. The basic syntactic elements of first-order logic are symbols.
We write statements in short-hand notation in FOL.

Basic Elements of First-order logic:

Following are the basic elements of FOL syntax:

Constant 1, 2, A, John, Mumbai, cat,....

Variables x, y, z, a, b,....

Predicates Brother, Father, >,....

Function sqrt, LeftLegOf, ....

Connectives ∧ , ∨ , ¬, ⇒, ⇔

Equality ==

Quantifier ∀, ∃

Atomic sentences:
 o Atomic sentences are the most basic sentences of first-order logic. These
sentences are formed from a predicate symbol followed by a parenthesis
with a sequence of terms.
o We can represent atomic sentences as Predicate (term1, term2, ......, term
n).

Example: Ravi and Ajay are brothers: => Brothers(Ravi, Ajay).

Chinky is a cat: => cat (Chinky).

Complex Sentences:

o Complex sentences are made by combining atomic sentences using

connectives.

First-order logic statements can be divided into two parts:

o Subject: Subject is the main part of the statement.

o Predicate: A predicate can be defined as a relation, which binds two atoms
together in a statement.

Consider the statement: "x is an integer.", it consists of two parts, the first part
x is the subject of the statement and second part "is an integer," is known as a
predicate.

Quantifiers in First-order logic:

 o A quantifier is a language element which generates quantification, and
quantification specifies the quantity of specimen in the universe of
discourse.
o These are the symbols that permit to determine or identify the range and
scope of the variable in the logical expression. There are two types of
quantifier:
a. Universal Quantifier, (for all, everyone, everything)
b. Existential quantifier, (for some, at least one).

Universal Quantifier:

Universal quantifier is a symbol of logical representation, which specifies that the

statement within its range is true for everything or every instance of a particular
thing.

The Universal quantifier is represented by a symbol ∀ , which resembles an

inverted A.

f x is a variable, then ∀ x is read as:

o For all x
o For each x
o For every x.

Example:

All man drink coffee.

Let a variable x which refers to a cat so all x can be represented in UOD as below:
∀ x man(x) → drink (x, coffee).

It will be read as: There are all x where x is a man who drink coffee.

Existential Quantifier:

Existential quantifiers are the type of quantifiers, which express that the statement
within its scope is true for at least one instance of something.

It is denoted by the logical operator ∃ , which resembles as inverted E. When it is

used with a predicate variable then it is called as an existential quantifier.

If x is a variable, then existential quantifier will be ∃ x or ∃ (x). And it will be

read as:

o There exists a 'x.'

o For some 'x.'
o For at least one 'x.'
Example:

Some boys are intelligent.

∃ x: boys(x) ∧ intelligent(x)

It will be read as: There are some x where x is a boy who is intelligent.

Points to remember:

o The main connective for universal quantifier ∀ is implication →.

o The main connective for existential quantifier ∃ is and ∧ .

Properties of Quantifiers:

o In universal quantifier, ∀ x∀ y is similar to ∀ y∀ x.

o In Existential quantifier, ∃ x∃ y is similar to ∃ y∃ x.
o ∃ x∀ y is not similar to ∀ y∃ x.
Some Examples of FOL using quantifier:

1. All birds fly.

In this question the predicate is "fly(bird)."
And since there are all birds who fly so it will be represented as follows.
∀ x bird(x) →fly(x).

2. Every man respects his parent.

In this question, the predicate is "respect(x, y)," where x=man, and y= parent.
Since there is every man so will use ∀ , and it will be represented as follows:
∀ x man(x) → respects (x, parent).

3. Some boys play cricket.

In this question, the predicate is "play(x, y)," where x= boys, and y= game. Since
there are some boys so we will use ∃ , and it will be represented as:
∃ x boys(x) → play(x, cricket).

4. Not all students like both Mathematics and Science.

In this question, the predicate is "like(x, y)," where x= student, and y= subject.
Since there are not all students, so we will use ∀ with negation, so following
representation for this:
¬∀ (x) [ student(x) → like(x, Mathematics) ∧ like(x, Science)].

5. Only one student failed in Mathematics.

In this question, the predicate is "failed(x, y)," where x= student, and y=
subject.
Since there is only one student who failed in Mathematics, so we will use
following representation for this:
∃ (x) [ student(x) → failed (x, Mathematics) ∧ ∀ (y) [¬(x==y) ∧
student(y) → ¬failed (x, Mathematics)].
Free and Bound Variables:

The quantifiers interact with variables which appear in a suitable way. There are
two types of variables in First-order logic which are given below:

Free Variable: A variable is said to be a free variable in a formula if it occurs

outside the scope of the quantifier.

Example: ∀ x ∃ (y)[P (x, y, z)], where z is a free variable.

Bound Variable: A variable is said to be a bound variable in a formula if it occurs

within the scope of the quantifier.

Example: ∀ x [A (x) B( y)], here x and y are the bound variables.

Knowledge representation and engineering

What is knowledge representation?

Humans are best at understanding, reasoning, and interpreting knowledge.

Human knows things, which is knowledge and as per their knowledge they
perform various actions in the real world. But how machines do all these things
comes under knowledge representation and reasoning. Hence we can describe
Knowledge representation as following:

o Knowledge representation and reasoning (KR, KRR) is the part of

Artificial intelligence which concerned with AI agents thinking and how
thinking contributes to intelligent behavior of agents.
o It is responsible for representing information about the real world so that a
computer can understand and can utilize this knowledge to solve the
 complex real world problems such as diagnosis a medical condition or
communicating with humans in natural language.
o It is also a way which describes how we can represent knowledge in
artificial intelligence. Knowledge representation is not just storing data into
some database, but it also enables an intelligent machine to learn from that
knowledge and experiences so that it can behave intelligently like a human.

What to Represent:

Following are the kind of knowledge which needs to be represented in AI

systems:

o Object: All the facts about objects in our world domain. E.g., Guitars
contains strings, trumpets are brass instruments.
o Events: Events are the actions which occur in our world.
o Performance: It describe behavior which involves knowledge about how
to do things.
o Meta-knowledge: It is knowledge about what we know.
o Facts: Facts are the truths about the real world and what we represent.
o Knowledge-Base: The central component of the knowledge-based agents
is the knowledge base. It is represented as KB. The Knowledgebase is a
group of the Sentences (Here, sentences are used as a technical term and
not identical with the English language).

Knowledge: Knowledge is awareness or familiarity gained by experiences of

facts, data, and situations. Following are the types of knowledge in artificial
intelligence:

Types of knowledge
1. Declarative Knowledge:

o Declarative knowledge is to know about something.

o It includes concepts, facts, and objects.
o It is also called descriptive knowledge and expressed in declarative
sentences.
o It is simpler than procedural language.

2. Procedural Knowledge

o It is also known as imperative knowledge.

o Procedural knowledge is a type of knowledge which is responsible for
knowing how to do something.
o It can be directly applied to any task.
o It includes rules, strategies, procedures, agendas, etc.
o Procedural knowledge depends on the task on which it can be applied.
3. Meta-knowledge:

o Knowledge about the other types of knowledge is called Meta-knowledge.

4. Heuristic knowledge:

o Heuristic knowledge is representing knowledge of some experts in a filed

or subject.
o Heuristic knowledge is rules of thumb based on previous experiences,
awareness of approaches, and which are good to work but not guaranteed.

5. Structural knowledge:

o Structural knowledge is basic knowledge to problem-solving.

o It describes relationships between various concepts such as kind of, part of,
and grouping of something.
o It describes the relationship that exists between concepts or objects.

AI knowledge cycle:

An Artificial intelligence system has the following components for displaying

intelligent behavior:

o Perception
o Learning
o Knowledge Representation and Reasoning
o Planning
o Execution
The above diagram is showing how an AI system can interact with the real world
and what components help it to show intelligence. AI system has Perception
component by which it retrieves information from its environment. It can be
visual, audio or another form of sensory input. The learning component is
responsible for learning from data captured by Perception comportment. In the
complete cycle, the main components are knowledge representation and
Reasoning. These two components are involved in showing the intelligence in
machine-like humans. These two components are independent with each other
but also coupled together. The planning and execution depend on analysis of
Knowledge representation and reasoning.

Techniques of knowledge representation

There are mainly four ways of knowledge representation which are given as
follows:

1. Logical Representation
2. Semantic Network Representation
3. Frame Representation
4. Production Rules

1. Logical Representation

Logical representation is a language with some concrete rules which deals with
propositions and has no ambiguity in representation. Logical representation
means drawing a conclusion based on various conditions. This representation lays
down some important communication rules. It consists of precisely defined
syntax and semantics which supports the sound inference. Each sentence can be
translated into logics using syntax and semantics.
Syntax:

o Syntaxes are the rules which decide how we can construct legal sentences
in the logic.
o It determines which symbol we can use in knowledge representation.
o How to write those symbols.

Semantics:

o Semantics are the rules by which we can interpret the sentence in the logic.
o Semantic also involves assigning a meaning to each sentence.

Logical representation can be categorised into mainly two logics:

a. Propositional Logics
b. Predicate logics

Advantages of logical representation:

1. Logical representation enables us to do logical reasoning.

2. Logical representation is the basis for the programming languages.

Disadvantages of logical Representation:

1. Logical representations have some restrictions and are challenging to work

with.
2. Logical representation technique may not be very natural, and inference
may not be so efficient.

2. Semantic Network Representation

Semantic networks are alternative of predicate logic for knowledge
representation. In Semantic networks, we can represent our knowledge in the
form of graphical networks. This network consists of nodes representing objects
and arcs which describe the relationship between those objects. Semantic
networks can categorize the object in different forms and can also link those
objects. Semantic networks are easy to understand and can be easily extended.

This representation consist of mainly two types of relations:

a. IS-A relation (Inheritance)

b. Kind-of-relation

Example: Following are some statements which we need to represent in the form
of nodes and arcs.

Statements:

a. Jerry is a cat.
b. Jerry is a mammal
c. Jerry is owned by Priya.
d. Jerry is brown colored.
e. All Mammals are animal.
Drawbacks in Semantic representation:

1. Semantic networks take more computational time at runtime as we need to

traverse the complete network tree to answer some questions. It might be
possible in the worst case scenario that after traversing the entire tree, we
find that the solution does not exist in this network.
2. Semantic networks try to model human-like memory (Which has 1015
neurons and links) to store the information, but in practice, it is not possible
to build such a vast semantic network.
3. These types of representations are inadequate as they do not have any
equivalent quantifier, e.g., for all, for some, none, etc.
4. Semantic networks do not have any standard definition for the link names.
5. These networks are not intelligent and depend on the creator of the system.
Advantages of Semantic network:

1. Semantic networks are a natural representation of knowledge.

2. Semantic networks convey meaning in a transparent manner.
3. These networks are simple and easily understandable.

3. Frame Representation

A frame is a record like structure which consists of a collection of attributes and

its values to describe an entity in the world. Frames are the AI data structure
which divides knowledge into substructures by representing stereotypes
situations. It consists of a collection of slots and slot values. These slots may be
of any type and sizes. Slots have names and values which are called facets.

Facets: The various aspects of a slot is known as Facets. Facets are features of
frames which enable us to put constraints on the frames. Example: IF-NEEDED
facts are called when data of any particular slot is needed. A frame may consist
of any number of slots, and a slot may include any number of facets and facets
may have any number of values. A frame is also known as slot-filter knowledge
representation in artificial intelligence.

Frames are derived from semantic networks and later evolved into our modern-
day classes and objects. A single frame is not much useful. Frames system consist
of a collection of frames which are connected. In the frame, knowledge about an
object or event can be stored together in the knowledge base. The frame is a type
of technology which is widely used in various applications including Natural
language processing and machine visions.
Example: 1

Let's take an example of a frame for a book

Slots Filters

Title Artificial Intelligence

Genre Computer Science

Author Peter Norvig

Edition Third Edition

Year 1996

Page 1152

Advantages of frame representation:

1. The frame knowledge representation makes the programming easier by

grouping the related data.
2. The frame representation is comparably flexible and used by many
applications in AI.
3. It is very easy to add slots for new attribute and relations.
4. It is easy to include default data and to search for missing values.
5. Frame representation is easy to understand and visualize.

Disadvantages of frame representation:

1. In frame system inference mechanism is not be easily processed.

2. Inference mechanism cannot be smoothly proceeded by frame
representation.
 3. Frame representation has a much generalized approach.

4. Production Rules

Production rules system consist of (condition, action) pairs which mean, "If
condition then action". It has mainly three parts:

o The set of production rules

o Working Memory
o The recognize-act-cycle

In production rules agent checks for the condition and if the condition exists then
production rule fires and corresponding action is carried out. The condition part
of the rule determines which rule may be applied to a problem. And the action
part carries out the associated problem-solving steps. This complete process is
called a recognize-act cycle.

The working memory contains the description of the current state of problems-
solving and rule can write knowledge to the working memory. This knowledge
match and may fire other rules.

If there is a new situation (state) generates, then multiple production rules will be
fired together, this is called conflict set. In this situation, the agent needs to select
a rule from these sets, and it is called a conflict resolution.

Example:

o IF (at bus stop AND bus arrives) THEN action (get into the bus)
o IF (on the bus AND paid AND empty seat) THEN action (sit down).
o IF (on bus AND unpaid) THEN action (pay charges).
o IF (bus arrives at destination) THEN action (get down from the bus).
Advantages of Production rule:

1. The production rules are expressed in natural language.

2. The production rules are highly modular, so we can easily remove, add or
modify an individual rule.

Disadvantages of Production rule:

1. Production rule system does not exhibit any learning capabilities, as it does
not store the result of the problem for the future uses.
2. During the execution of the program, many rules may be active hence rule-
based production systems are inefficient.

Inferences in first-order logic

Inference in First-Order Logic is used to deduce new facts or sentences from

existing sentences. Before understanding the FOL inference rule, let's understand
some basic terminologies used in FOL.

Substitution:

Substitution is a fundamental operation performed on terms and formulas. It

occurs in all inference systems in first-order logic. The substitution is complex in
the presence of quantifiers in FOL. If we write F[a/x], so it refers to substitute a
constant "a" in place of variable "x".

Equality:

First-Order logic does not only use predicate and terms for making atomic
sentences but also uses another way, which is equality in FOL. For this, we can
use equality symbols which specify that the two terms refer to the same object.

Example: Brother (John) = Smith.

As in the above example, the object referred by the Brother (John) is similar to
the object referred by Smith. The equality symbol can also be used with negation
to represent that two terms are not the same objects.

Example: ￢(x=y) which is equivalent to x ≠y.

FOL inference rules for quantifier:

As propositional logic we also have inference rules in first-order logic, so

following are some basic inference rules in FOL:

o Universal Generalization
o Universal Instantiation
o Existential Instantiation
o Existential introduction

1. Universal Generalization:

o Universal generalization is a valid inference rule which states that if

premise P(c) is true for any arbitrary element c in the universe of discourse,
then we can have a conclusion as ∀ x P(x).

o It can be represented as: .

o This rule can be used if we want to show that every element has a similar
property.
o In this rule, x must not appear as a free variable.

Example: Let's represent, P(c): "A byte contains 8 bits", so for ∀ x P(x) "All
bytes contain 8 bits.", it will also be true.

2. Universal Instantiation:
 o Universal instantiation is also called as universal elimination or UI is a
valid inference rule. It can be applied multiple times to add new sentences.
o The new KB is logically equivalent to the previous KB.
o As per UI, we can infer any sentence obtained by substituting a ground
term for the variable.
o The UI rule state that we can infer any sentence P(c) by substituting a
ground term c (a constant within domain x) from ∀ x P(x) for any object
in the universe of discourse.

o It can be represented as: .

Example:1.

IF "Every person like ice-cream"=> ∀ x P(x) so we can infer that

"John likes ice-cream" => P(c)

Example: 2.

Let's take a famous example,

"All kings who are greedy are Evil." So let our knowledge base contains this
detail as in the form of FOL:

∀ x king(x) ∧ greedy (x) → Evil (x),

So from this information, we can infer any of the following statements using
Universal Instantiation:

o King(John) ∧ Greedy (John) → Evil (John),

o King(Richard) ∧ Greedy (Richard) → Evil (Richard),
o King(Father(John)) ∧ Greedy (Father(John)) → Evil (Father(John)),
3. Existential Instantiation:

o Existential instantiation is also called as Existential Elimination, which is

a valid inference rule in first-order logic.
o It can be applied only once to replace the existential sentence.
o The new KB is not logically equivalent to old KB, but it will be satisfiable
if old KB was satisfiable.
o This rule states that one can infer P(c) from the formula given in the form
of ∃ x P(x) for a new constant symbol c.
o The restriction with this rule is that c used in the rule must be a new term
for which P(c ) is true.

o It can be represented as:

Example:

From the given sentence: ∃ x Crown(x) ∧ OnHead(x, John),

So we can infer: Crown(K) ∧ OnHead( K, John), as long as K does not appear

in the knowledge base.

o The above used K is a constant symbol, which is called Skolem constant.

o The Existential instantiation is a special case of Skolemization process.

4. Existential introduction

o An existential introduction is also known as an existential generalization,

which is a valid inference rule in first-order logic.
o This rule states that if there is some element c in the universe of discourse
which has a property P, then we can infer that there exists something in the
universe which has the property P.
 o It can be represented as:
o Example: Let's say that,
"Priyanka got good marks in English."
"Therefore, someone got good marks in English."

Generalized Modus Ponens Rule:

For the inference process in FOL, we have a single inference rule which is called
Generalized Modus Ponens. It is lifted version of Modus ponens.

Generalized Modus Ponens can be summarized as, " P implies Q and P is asserted
to be true, therefore Q must be True."

According to Modus Ponens, for atomic sentences pi, pi', q. Where there is a
substitution θ such that SUBST (θ, pi',) = SUBST(θ, pi), it can be represented as:

Example:

We will use this rule for Kings are evil, so we will find some x such that x is
king, and x is greedy so we can infer that x is evil.

1. Here let say, p1' is king(John) p1 is king(x)

2. p2' is Greedy(y) p2 is Greedy(x)
3. θ is {x/John, y/John} q is evil(x)
4. SUBST(θ,q).

Forward chaining
In artificial intelligence, forward and backward chaining is one of the important
topics, but before understanding forward and backward chaining lets first
understand that from where these two terms came.

Inference engine:

The inference engine is the component of the intelligent system in artificial

intelligence, which applies logical rules to the knowledge base to infer new
information from known facts. The first inference engine was part of the expert
system. Inference engine commonly proceeds in two modes, which are:

a. Forward chaining

b. Backward chaining

Horn Clause and Definite clause:

Horn clause and definite clause are the forms of sentences, which enables
knowledge base to use a more restricted and efficient inference algorithm.
Logical inference algorithms use forward and backward chaining approaches,
which require KB in the form of the first-order definite clause.

Definite clause: A clause which is a disjunction of literals with exactly one

positive literal is known as a definite clause or strict horn clause.

Horn clause: A clause which is a disjunction of literals with at most one positive
literal is known as horn clause. Hence all the definite clauses are horn clauses.

Example: (¬ p V ¬ q V k). It has only one positive literal k.

It is equivalent to p ∧ q → k.

A. Forward Chaining
Forward chaining is also known as a forward deduction or forward reasoning
method when using an inference engine. Forward chaining is a form of reasoning
which start with atomic sentences in the knowledge base and applies inference
rules (Modus Ponens) in the forward direction to extract more data until a goal is
reached.

The Forward-chaining algorithm starts from known facts, triggers all rules whose
premises are satisfied, and add their conclusion to the known facts. This process
repeats until the problem is solved.

Properties of Forward-Chaining:

o It is a down-up approach, as it moves from bottom to top.

o It is a process of making a conclusion based on known facts or data, by
starting from the initial state and reaches the goal state.
o Forward-chaining approach is also called as data-driven as we reach to the
goal using available data.
o Forward -chaining approach is commonly used in the expert system, such
as CLIPS, business, and production rule systems.

Consider the following famous example which we will use in both approaches:

Example:

"As per the law, it is a crime for an American to sell weapons to hostile
nations. Country A, an enemy of America, has some missiles, and all the
missiles were sold to it by Robert, who is an American citizen."

Prove that "Robert is criminal."

To solve the above problem, first, we will convert all the above facts into first-
order definite clauses, and then we will use a forward-chaining algorithm to reach
the goal.

Facts Conversion into FOL:

o It is a crime for an American to sell weapons to hostile nations. (Let's say

p, q, and r are variables)
American (p) ∧ weapon(q) ∧ sells (p, q, r) ∧ hostile(r) →
Criminal(p) ...(1)
o Country A has some missiles. ?p Owns(A, p) ∧ Missile(p). It can be
written in two definite clauses by using Existential Instantiation,
introducing new Constant T1.
Owns(A, T1) ......(2)
Missile(T1) .......(3)
o All of the missiles were sold to country A by Robert.
?p Missiles(p) ∧ Owns (A, p) → Sells (Robert, p, A) ......(4)
o Missiles are weapons.
Missile(p) → Weapons (p) .......(5)
o Enemy of America is known as hostile.
Enemy(p, America) →Hostile(p) ........(6)
o Country A is an enemy of America.
Enemy (A, America) .........(7)
o Robert is American
American(Robert). ..........(8)

Forward chaining proof:

Step-1:
In the first step we will start with the known facts and will choose the sentences
which do not have implications, such as: American(Robert), Enemy(A,
America), Owns(A, T1), and Missile(T1). All these facts will be represented as
below.

Step-2:

At the second step, we will see those facts which infer from available facts and
with satisfied premises.

Rule-(1) does not satisfy premises, so it will not be added in the first iteration.

Rule-(2) and (3) are already added.

Rule-(4) satisfy with the substitution {p/T1}, so Sells (Robert, T1, A) is added,
which infers from the conjunction of Rule (2) and (3).

Rule-(6) is satisfied with the substitution(p/A), so Hostile(A) is added and which

infers from Rule-(7).

Step-3:
At step-3, as we can check Rule-(1) is satisfied with the substitution {p/Robert,
q/T1, r/A}, so we can add Criminal(Robert) which infers all the available facts.
And hence we reached our goal statement.

Hence it is proved that Robert is Criminal using forward chaining approach.

Backward chaining

Backward-chaining is also known as a backward deduction or backward

reasoning method when using an inference engine. A backward chaining
algorithm is a form of reasoning, which starts with the goal and works backward,
chaining through rules to find known facts that support the goal.

Properties of backward chaining:

o It is known as a top-down approach.

o Backward-chaining is based on modus ponens inference rule.
o In backward chaining, the goal is broken into sub-goal or sub-goals to
prove the facts true.
 o It is called a goal-driven approach, as a list of goals decides which rules
are selected and used.
o Backward -chaining algorithm is used in game theory, automated theorem
proving tools, inference engines, proof assistants, and various AI
applications.
o The backward-chaining method mostly used a depth-first search strategy
for proof.

Example:

In backward-chaining, we will use the same above example, and will rewrite all
the rules.

o American (p) ∧ weapon(q) ∧ sells (p, q, r) ∧ hostile(r) → Criminal(p)

...(1)
Owns(A, T1) ........(2)
o Missile(T1)
o ?p Missiles(p) ∧ Owns (A, p) → Sells (Robert, p, A) ......(4)
o Missile(p) → Weapons (p) .......(5)
o Enemy(p, America) →Hostile(p) ........(6)
o Enemy (A, America) .........(7)
o American(Robert). ..........(8)

Backward-Chaining proof:

In Backward chaining, we will start with our goal predicate, which

is Criminal(Robert), and then infer further rules.

Step-1:
At the first step, we will take the goal fact. And from the goal fact, we will infer
other facts, and at last, we will prove those facts true. So our goal fact is "Robert
is Criminal," so following is the predicate of it.

Step-2:

At the second step, we will infer other facts form goal fact which satisfies the
rules. So as we can see in Rule-1, the goal predicate Criminal (Robert) is present
with substitution {Robert/P}. So we will add all the conjunctive facts below the
first level and will replace p with Robert.

Here we can see American (Robert) is a fact, so it is proved here.

Step-3:t At step-3, we will extract further fact Missile(q) which infer from
Weapon(q), as it satisfies Rule-(5). Weapon (q) is also true with the substitution
of a constant T1 at q.
Step-4:

At step-4, we can infer facts Missile(T1) and Owns(A, T1) form Sells(Robert, T1,
r) which satisfies the Rule- 4, with the substitution of A in place of r. So these
two statements are proved here.
Step-5:

At step-5, we can infer the fact Enemy(A, America) from Hostile(A) which
satisfies Rule- 6. And hence all the statements are proved true using backward
chaining.

Resolution

Resolution in FOL

Resolution

Resolution is a theorem proving technique that proceeds by building refutation

proofs, i.e., proofs by contradictions. It was invented by a Mathematician John
Alan Robinson in the year 1965.
Resolution is used, if there are various statements are given, and we need to prove
a conclusion of those statements. Unification is a key concept in proofs by
resolutions. Resolution is a single inference rule which can efficiently operate on
the conjunctive normal form or clausal form.

Clause: Disjunction of literals (an atomic sentence) is called a clause. It is also

known as a unit clause.

Conjunctive Normal Form: A sentence represented as a conjunction of clauses

is said to be conjunctive normal form or CNF.

The resolution inference rule:

The resolution rule for first-order logic is simply a lifted version of the
propositional rule. Resolution can resolve two clauses if they contain
complementary literals, which are assumed to be standardized apart so that they
share no variables.

Where li and mj are complementary literals.

This rule is also called the binary resolution rule because it only resolves
exactly two literals.

Example:

We can resolve two clauses which are given below:

[Animal (g(x) V Loves (f(x), x)] and [￢ Loves(a, b) V ￢Kills(a, b)]

Where two complimentary literals are: Loves (f(x), x) and ￢ Loves (a, b)
These literals can be unified with unifier θ= [a/f(x), and b/x] , and it will generate
a resolvent clause:

[Animal (g(x) V ￢ Kills(f(x), x)].

Steps for Resolution:

1. Conversion of facts into first-order logic.

2. Convert FOL statements into CNF
3. Negate the statement which needs to prove (proof by contradiction)
4. Draw resolution graph (unification).

To better understand all the above steps, we will take an example in which we
will apply resolution.

Example:

a. John likes all kind of food.

b. Apple and vegetable are food
c. Anything anyone eats and not killed is food.
d. Anil eats peanuts and still alive
e. Harry eats everything that Anil eats.
Prove by resolution that:
f. John likes peanuts.

Step-1: Conversion of Facts into FOL

In the first step we will convert all the given statements into its first order logic.
Step-2: Conversion of FOL into CNF

In First order logic resolution, it is required to convert the FOL into CNF as CNF
form makes easier for resolution proofs.

o Eliminate all implication (→) and rewrite

a. ∀ x ¬ food(x) V likes(John, x)
b. food(Apple) Λ food(vegetables)
c. ∀ x ∀ y ¬ [eats(x, y) Λ ¬ killed(x)] V food(y)
d. eats (Anil, Peanuts) Λ alive(Anil)
e. ∀ x ¬ eats(Anil, x) V eats(Harry, x)
f. ∀ x¬ [¬ killed(x) ] V alive(x)
g. ∀ x ¬ alive(x) V ¬ killed(x)
h. likes(John, Peanuts).
o Move negation (¬)inwards and rewrite
. ∀ x ¬ food(x) V likes(John, x)
a. food(Apple) Λ food(vegetables)
b. ∀ x ∀ y ¬ eats(x, y) V killed(x) V food(y)
c. eats (Anil, Peanuts) Λ alive(Anil)
 d. ∀ x ¬ eats(Anil, x) V eats(Harry, x)
e. ∀ x ¬killed(x) ] V alive(x)
f. ∀ x ¬ alive(x) V ¬ killed(x)
g. likes(John, Peanuts).
o Rename variables or standardize variables
. ∀ x ¬ food(x) V likes(John, x)
a. food(Apple) Λ food(vegetables)
b. ∀ y ∀ z ¬ eats(y, z) V killed(y) V food(z)
c. eats (Anil, Peanuts) Λ alive(Anil)
d. ∀ w¬ eats(Anil, w) V eats(Harry, w)
e. ∀ g ¬killed(g) ] V alive(g)
f. ∀ k ¬ alive(k) V ¬ killed(k)
g. likes(John, Peanuts).
o Eliminate existential instantiation quantifier by elimination.
In this step, we will eliminate existential quantifier ∃ , and this process is
known as Skolemization. But in this example problem since there is no
existential quantifier so all the statements will remain same in this step.
o Drop Universal quantifiers.
In this step we will drop all universal quantifier since all the statements are
not implicitly quantified so we don't need it.
. ¬ food(x) V likes(John, x)
a. food(Apple)
b. food(vegetables)
c. ¬ eats(y, z) V killed(y) V food(z)
d. eats (Anil, Peanuts)
e. alive(Anil)
 f. ¬ eats(Anil, w) V eats(Harry, w)
g. killed(g) V alive(g)
h. ¬ alive(k) V ¬ killed(k)
i. likes(John, Peanuts).

o Distribute conjunction ∧ over disjunction ¬.

This step will not make any change in this problem.

Step-3: Negate the statement to be proved

In this statement, we will apply negation to the conclusion statements, which will
be written as ¬likes(John, Peanuts)

Step-4: Draw Resolution graph:

Now in this step, we will solve the problem by resolution tree using substitution.
For the above problem, it will be given as follows:
Hence the negation of the conclusion has been proved as a complete contradiction
with the given set of statements.

Explanation of Resolution graph:

o In the first step of resolution graph, ¬likes(John, Peanuts) ,

and likes(John, x) get resolved(canceled) by substitution of {Peanuts/x},
and we are left with ¬ food(Peanuts)
o In the second step of the resolution graph, ¬ food(Peanuts) ,
and food(z) get resolved (canceled) by substitution of { Peanuts/z}, and
we are left with ¬ eats(y, Peanuts) V killed(y) .
o In the third step of the resolution graph, ¬ eats(y, Peanuts) and eats (Anil,
Peanuts) get resolved by substitution {Anil/y}, and we are left
with Killed(Anil) .
o In the fourth step of the resolution graph, Killed(Anil) and ¬ killed(k) get
resolve by substitution {Anil/k}, and we are left with ¬ alive(Anil) .
o In the last step of the resolution graph ¬ alive(Anil) and alive(Anil) get
resolved.