Problem Solving and Truth Maintenance Systems

Truth Maintenance Systems (TMS), also called Reason Maintenance Systems,
are used within Problem Solving Systems,
in conjunction with Inference Engines (IE) such as rule-based
inference systems, to manage as a Dependency Network
the inference engine's beliefs in given sentences.

Provide justifications for conclusions

When a problem solving system gives an answer to a user's query,
an explanation of the answer is usually required. If the advice
to a stockbroker
is to invest millions of dollars, an explanation of the reasons for
that advice can help the broker reach a reasonable decision.
An explanantion can be constructed by the IE by tracing the justification
of the assertion.

Recognise inconsistencies

The IE may tell the TMS that some sentences are
contradictory. Then, if on the basis of other IE commands and of inferences
we find that all those sentences are believed true, then the TMS reports
to the IE that a contradiction has arisen.
For instance, in the ABC example the statement
that either Abbott, or Babbitt, or Cabot is guilty together with the statements
that Abbott is not guilty, Babbitt is not guilty, and Cabot is not guilty,
form a contradiction.
The IE can eliminate an inconsistency by determining the assumptions
used and changing them appropriately, or by presenting the contradictory
set of sentences to the users and asking them to choose which
sentence(s) to retract.

Support default reasoning

In many situations we want, in the absence of firmer knowledge,
to reason from default assumptions. If Tweety is a bird, until told
otherwise, we will assume that Tweety flies and use as justification the fact
that Tweety is a bird and the assumption that birds fly.

Remember derivations computed previously

In the process of determining what is responsible for a network problem,
we may have derived, while examining the performance of a name server, that
Ms.Doe is an expert on e-mail systems. That conclusion will not need to
be derived again when the name server ceases to be the potential culprit
for the problem and we examine instead the routers.

Support dependency driven backtracking

The justification of a sentence, as maintained by the TMS, provides
the natural indication of what assumptions need to be changed if we want to
invalidate that sentence.

Our belief [by "our belief" we mean the "inference-engine's belief"]
about a sentence can be:

false, the sentence is believed to be unconditionally false;
this is also called a contradiction

true, the sentence is believed unconditionally true; this is also
called a premise

assumed-true, the sentence is assumed true [we may change our belief
later]; this is also called an enabled assumption

assumed-false, the sentence is assumed false [we may change our
belief later]; this is also called a retracted assumption

assumed, the sentence is believed by inference from other sentences

don't-care.

We say a sentence in in if true or assumed-true; it is out if false,
assumed-false, or don't-care.

A TMS maintains a Dependency Network. The network is bipartite,
with nodes representing sentences and justifications.
A sentence may correspond to a fact, such as "Socrates is a man",
or a rule, such as "if ?x is a man then ?x is mortal".
We will say that a sentence node is a premise if its sentence is true,
is a contradiction if its sentence is false, is an assumption
if its sentence is assumed-true or assumed-false or assumed.
A sentence node receives arcs from justification nodes. Each such
justification node provides an argument for believing the given sentence node.
In turn a sentence node has arcs to the justification nodes that use it
as a premise.

A justification node has inputs from sentence nodes, its premises or justifiers,
and has output to a sentence node, its conclusion or justificand.
A justification node
represents the inference of the conclusion from the conjunction
of the stated premises.

The conventions used in representing graphically dependency networks are
summarized here.

The TMS maintains the following information with each sentence node:

a sentence

a label expressing the current belief in the sentence;
it is IN for sentences that are believed, and OUT for sentences that are
not believed.

a list of the justification nodes that support it

a list of the justification nodes supported by it

an indication if the node is an assumption, contradiction, or premise.

The TMS maintains very little information with justification nodes. Only a
label with value IN or OUT depending if we believe the justification
valid or not.

The IE can give at least the following orders to the TMS:

create a sentence node with specific properties

create a justification with specific premises and conclusions

attach rules to sentence nodes and execute them when
specific beliefs hold at those nodes [these are like callbacks or triggers;
a standard callback informs the IE when a contradiction becomes true]

retrieve the properties of a sentence node or its justifications and
consequences.

Truth Maintenance Systems can have different characteristics:

Justification-Based Truth Maintenance System (JTMS)

It is a simple TMS where one can examine the consequences of the
current set of assumptions. The meaning of sentences is not known.

Assumption-Based Truth Maintenance System (ATMS)

It allows to maintain and reason with a number of simultaneous,
possibly incompatible, current sets of assumption. Otherwise it is
similar to JTMS, i.e. it does not recognise the meaning of sentences.

Logical-Based Truth Maintenance System (LTMS)

Like JTMS in that it reasons with only one set of current
assumptions at a time. More powerful than JTMS in that it recognises
the propositional semantics of sentences, i.e. understands the relations
between p and ~p, p and q and p&q, and so on.
We will not discuss further LTMSs.

A Justification-based truth maintenance system (JTMS)
is a simple TMS where one can examine the consequences of the
current set of assumptions. In JTMS labels are attacched to arcs from
sentence nodes to justification nodes. This label is either "+" or "-".
Then, for a justification node we can talk of its in-list,
the list of its inputs with "+" label, and of its out-list,
the list of its inputs with "-" label.

The meaning of sentences is not known.
We can have a node representing a sentence p and one representing ~p
and the two will be totally unrelated, unless relations are
established between them by justifications. For example, we can write:

Algorithms are available to propage changes in assumptions, either asserting a sentence, or
retracting it. Further, algorithms are available to determine the maximally
consistent sets of assumptions
supporting a given sentence.

In a JTMS, we change assumptions by relabeling the nodes of a
dependency network. Any time we switch among alternative sets of assumptions,
we re-label the net. This may lead to considerable work.
Another possibility is to maintain information at each node
within a single dependency network for
all the alternative sets of assumptions that we may hold, also called
worlds or environments.
That is, we can use as label of a node
the set consisting of all the environments that justify this node.
This is the path taken in Assumption-Based Truth Maintenance Systems (ATMS).
Since all environments are simultaneously available,
it is not necessary to enable
or retract sentences, and thus re-label the network. It is only necessary
to switch from one environment to another.

The problem of the ATMS approach is that if we are given n assumptions,
there are 2**n possible selections of all these assumptions, that is
2**n environments.
This, except in trivial cases, is more than we can work with.

Two observations simplify this problem:

If we find out that a set A of assertions is inconsistent, in which
case we say that A is a no-good set,
then any set B of assertions such that A is contained in B will also
be inconsistent. [Notice that we need to label a node only with consistent
environments.]

If we find that a node has a justification based on
a set of assertions A, in which case we say that the node holds in A,
then we do not need to consider any context B, where
B contains A.

We define the context of a set A of assumptions to be the set
consisting of all the nodes that hold in A, i.e. that have a
justification based on A.

Here are examples of ATMS operations (see Forbus&deKleer, pg440):

create-atms (title node-string enqueue-procedure)

creates a dependency network with the same parameters as create-jtms,
except that now we do not have a contradiction-handler, since the
relevant information is recorded by the label.

true-node? (node)

recognises if node is a premise

why-node(node)

returns the label of node

atms-assumptions(an-atms)

returns a list of all the assumptions enabled for this atms

interpretations(atms choice-sets defaults)

returns all the environments that are consistent with
defaults and include at least an element from choice-sets.

Forbus,K.,deKleer,J.: Building Problem Solvers
MIT Press, 1993
Forbus is the most comprehensive reference on Truth Maintenance in
problem solving systems. The programs described in the book are available
on line.

An example by Quine and Ullian, as reported by Rich&Knight,
shows typical circumstances under which people operate. We would like
a problem solving system to be able to reason about cases such as this.

We know that:
Abbott, Babbitt, Cabot are suspects in a murder.
Abbott has an alibi, the registration at a good hotel in
Albany at the time of the crime
Babbitt has an alibi, his brother-in-law says they were
together at the time of the crime
Cabot says he was at a Catskills ski resort, but with no
witnesses.
Our other premises (i.e. assumed unconditionally) are:
The hotel in Albany is reliable
Babbitt's bother-in-law is reliable
We have as current assumptions:
(1) Abbott did not commit crime
(2) Babbitt did not commit crime
(3) Abbott, Babbitt, or Cabot committed the crime.
We then find a newsreel showing Cabot at the ski resort:
(4) Cabott did not commit the crime.
Thus:
(1) & (2) & (3) & (4) are contradictory beliefs