Forward and Backward

Chaining
Rule-Based Systems

• Instead of representing knowledge in a relatively

declarative, static way (as a bunch of things that are
true), rule-based system represent knowledge in
terms of a bunch of rules that tell you what you
should do or what you could conclude in different
situations.
• A rule-based system consists of a bunch of IF-THEN
rules, a bunch of facts, and some interpreter
controlling the application of the rules, given the
facts.
Two broad kinds of rule system

• forward chaining systems, and backward chaining

systems.
• In a forward chaining system you start with the
initial facts, and keep using the rules to draw new
conclusions (or take certain actions) given those
facts
• In a backward chaining system you start with some
hypothesis (or goal) you are trying to prove, and
keep looking for rules that would allow you to
conclude that hypothesis, perhaps setting new
subgoals to prove as you go.
Data or Goal Driven?

• Forward chaining systems are primarily data-driven

• backward chaining systems are goal-driven
• We'll look at both, and when each might be useful.
• I previously used the term production system to refer to rule-based
systems
Forward Chaining Systems

• facts in the system are represented in a working

memory which is continually updated.
• Rules in the system represent possible actions to
take when specified conditions hold on items in the
working memory
• they are sometimes called condition-action rules
• The conditions are usually patterns that must match
items in the working memory
Forward Chaining Systems
• actions usually involve adding or deleting items from
the working memory.
• interpreter controls the application of the rules, given
the working memory, thus controlling the system's
activity.
• It is based on a cycle of activity sometimes known as a
recognize-act cycle
• The system first checks to find all the rules whose
conditions hold
• selects one and performs the actions in the action part
of the rule
• selection of a rule to fire is based on fixed strategies,
known as conflict resolution strategies
Forward Chaining Systems

• The actions will result in a new working memory, and the cycle
begins again.
• This cycle will be repeated until either no rules fire, or some specified
goal state is satisfied.
• Rule-based systems vary greatly in their details and syntax, so the
following examples are only illustrative
1. IF (lecturing X)
AND (marking-practicals X)
THEN ADD (overworked X)
2. IF (month february)
THEN ADD (lecturing ali)

3. IF (month february)
THEN ADD (marking-practicals ali)
4. IF (overworked X)
OR (slept-badly X)
THEN ADD (bad-mood X)
5. IF (bad-mood X)
THEN DELETE (happy X)
6. IF (lecturing X)
THEN DELETE (researching X)
Example

• Let us assume that initially we have a working

memory with the following elements
• (month february)
(happy ali)
(researching ali)
• Rules 2 and 3 both apply, so the system has to
choose between them, using its conflict resolution
strategies.
• Let us say that rule 2 is chosen. So, (lecturing ali) is
added to the working memory
Example
• (lecturing ali)
(month february)
(happy ali)
(researching ali)
• Now the cycle begins again
• This time rule 3 and rule 6 have their preconditions
satisfied
• Lets say rule 3 is chosen and fires, so (marking-
practicals ali) is added to the working memory
• On the third cycle rule 1 fires, so, with X bound to ali,
(overworked ali) is added to working memory which is
now:
Example

• (overworked ali)
(marking-practicals ali)
(lecturing ali)
(month february)
(happy ali)
(researching ali)
• Now rules 4 and 6 can apply. Suppose rule 4 fires,
and (bad-mood ali) is added to the working
memory.
• And in the next cycle rule 5 is chosen and fires, with
(happy ali) removed from the working memory.
Example

• Finally, rule 6 will fire, and (researching ali) will be

removed from working memory, to leave:
• (bad-mood ali)
(overworked ali)
(marking-practicals ali)
(lecturing ali)
(month february)
The order that rules fire may be crucial, especially
when rules may result in items being deleted from
working memory.
• A number of conflict resolution strategies are typically used to decide
which rule to fire
• Don't fire a rule twice on the same data. (We don't want to keep on
adding (lecturing ali) to working memory).
• Fire rules on more recent working memory elements before older
ones. This allows the system to follow through a single chain of
reasoning, rather than keeping on drawing new conclusions from old
data.
• Fire rules with more specific preconditions before
ones with more general preconditions. This allows
us to deal with non-standard cases. If, for example,
we have a rule ``IF (bird X) THEN ADD (flies X)'' and
another rule ``IF (bird X) AND (penguin X) THEN
ADD (swims X)'' and a penguin called tweety, then
we would fire the second rule first and start to draw
conclusions from the fact that tweety swims.
Strategies

• These strategies may help in getting reasonable

behavior from a forward chaining system,
• but the most important thing is how we write the
rules.
• They should be carefully constructed, with the
preconditions specifying as precisely as possible
when different rules should fire.
• Otherwise we will have little idea or control of what
will happen
Backward Chaining Systems

• So far we have looked at how rule-based systems

can be used to draw new conclusions from existing
data, adding these conclusions to a working
memory
• This approach is most useful when you know all the
initial facts, but don't have much idea what the
conclusion might be
• If you DO know what the conclusion might be, or
have some specific hypothesis to test, forward
chaining systems may be inefficient
Backward Chaining Systems

• You COULD keep on forward chaining until no more

rules apply or you have added your hypothesis to
the working memory
• But in the process the system is likely to do a lot of
irrelevant work, adding uninteresting conclusions to
working memory
• This can be done by backward chaining from the
goal state (or on some hypothesized state that we
are interested in)
Backward Chaining Systems
• This is essentially what Prolog does, so it should be
fairly familiar to you by now
• Given a goal state to try and prove (e.g., (bad-mood
ali)) the system will first check to see if the goal
matches the initial facts given
• If it does, then that goal succeeds
• If it doesn't the system will look for rules whose
conclusions (previously referred to as actions) match
the goal
• One such rule will be chosen, and the system will then
try to prove any facts in the preconditions of the rule
using the same procedure, setting these as new goals
to prove
backward chaining system

• Note that a backward chaining system does NOT need to update a

working memory
• Instead it needs to keep track of what goals it needs to prove its
main hypothesis.
• Lets take an example
1. IF (lecturing X)
AND (marking-practicals X)
THEN (overworked X)
2. IF (month february)
THEN (lecturing ali)

3. IF (month february)
THEN (marking-practicals ali)
4. IF (overworked X)
THEN (bad-mood X)
5. IF (slept-badly X)
THEN (bad-mood X)
6. IF (month february)
THEN (weather cold)
7. IF (year 1993)
THEN (economy bad)
Example

• and initial facts:

• (month february)
(year 1993) and we're trying to prove:
• (bad-mood ali)
• First we check whether the goal state is in the initial
facts
• As it isn't there, we try matching it against the
conclusions of the rules
• It matches rules 4 and 5. Let us assume that rule 4 is
chosen first
Example

• it will try to prove (overworked ali).

• Rule 1 can be used, and the system will try to prove
(lecturing ali) and (marking practicals ali).
• Trying to prove the first goal, it will match rule 2
and try to prove (month february).
• This is in the set of initial facts
• We still have to prove (marking-practicals ali).
• Rule 3 can be used, and we have proved the original
goal (bad-mood ali).
Forwards vs Backwards
Reasoning

• Whether you use forward or backwards reasoning

to solve a problem depends on the properties of
your rule set and initial facts.
• Sometimes, if you have some particular goal (to test
some hypothesis), then backward chaining will be
much more efficient, as you avoid drawing
conclusions from irrelevant facts.
• However, sometimes backward chaining can be
very wasteful - there may be many possible ways
of trying to prove something, and you may have to
try almost all of them before you find one that
works.
• Forward chaining may be better if you have lots of
things you want to prove
• when you have a small set of initial facts; and when
there tend to be lots of different rules which allow
you to draw the same conclusion
• Backward chaining may be better if you are trying
to prove a single fact, given a large set of initial
facts, and where, if you used forward chaining, lots
of rules would be eligible to fire in any cycle.