Analogical Reasoning for Logic Programming
Birgit Tausend Siegfried Bell
Institut ffir Informatik, Universit£t Stuttgart
Forststr. 86, D-7000 Stuttgart 1, Germany
emaih tausend@informatik.uni-stuttgart.de
Abstract
Analogical reasoning is useful to exploit
knowledge about similar predicates to
define new ones. This paper presents
MARs 1, a tool that supports the defini-
tion of new Prolog predicates with respect
to known ones. Starting from similar ex-
amples, one of the known predicate and
one of the new, the tool proposes a def-
inition for the new predicate. The algo-
rithm for constructing this new definition
by analogy includes four main steps that
will be described in detail in this paper.
1 Introduction
Analogical reasoning is concerned with
finding a solution for a new problem by
making use of the known solution of a
similar problem. Basically, analogical rea-
soning aims at mapping knowledge from
a well understood domain, the so called
source domain, to a new domain called the
target domain in order to solve the new
problem. According to this terminology
the new problem is called target problem
and the solved one source problem.
The process of analogical reasoning in-
1MARsis a n acronymfor Model of Analogical
Reasoning
cludes four main steps, recognition, elab-
oration, evaluation, and consolidation, as
described in [Hall 89]. First, recognition
determines a minimal set of source prob-
lems that are analogical to a given target
problem. The next step is to elaborate a
mapping between the source and the tar-
get problem and to make analogical infer-
ences. Then the mapping and the infer-
ences have to be evaluated in a particular
context and in addition justified, extended
or repaired if necessary. The last step con-
cerns the consolidation of the result of the
analogical reasoning process to make fur-
ther use of it.
Most of the machine learning approaches
to analogical reasoning can be described
and compared within this framework, as
shown in [Hall 89]. They mainly differ in
the particular method preferred in each
step and in the application domain.
The organization of this paper is as fol-
lows: in the first section we introduce ba-
sic terms and a four step model of analog-
ical reasoning. The next section presents
the learning situation of MARs. Section
3 describes each of the four steps of the
analogical reasoning process of MARs in
detail. The last section discusses briefly
some limitations of the existing approach
and concludes with the goals of further
work.
 392
2 Learning Situation
Machine learning approaches to analog-
ical reasoning aim at solving problems
in very different domains, as shown in
[Hall 89]. Some apply to physical do-
mains [Greiner 88], [Gentner 881, oth-
ers are concerned with concept learning
[KedarCabelli 88],[Burstein86] or plan-
ning [Carbonell 83].
The application problem we address is
the analogical definition of a new Prolog
predicate according to a known one. This
is a task novices in programming language
are often involved with. In exercises they
are told to find a solution for a problem
that is similar to one solved before. Thus,
they are requested to slightly modify a
known piece of code instead of program-
ming the solution from scratch.
The task of MARs is nearly the same as
the students task. Starting from an ex-
ample of the source predicate and a sim-
ilar of the target predicate MARs should
construct a definition of the new predicate
by analogical reasoning. Figure 1 shows
an example where the Prolog predicate
member should be defined analogically to
the predicate append.
Target a n d s o u r c e example:
member(2,[l,2,3D ~ append([l],[2,3],[1,2,3])
Source problem: append(Ill,[2,3],[1,2,3])
Knowledge base: append(~,L,L)
append([XlT],L,[XlT1]) ~append(W,L,Wl)
New definition: member(L,[LIT1])
member(L,[X]T1]) ~-- member(L,T1)
Figure h Analogical definition
Before explaining how MARs constructs
the new predicate we have to clarify which
problems we consider to be analogical.
In general the hint that two problems are
analogical can address two different kinds
of similarity. In one case the problems are
similar because they can be programmed
in a similar way. So the Prolog predicates
member and append could be defined ana-
logically because their structure and their
arguments are similar. In the other case
similarity concerns the meaning that is the
relation of input and output of the pro-
gram pieces and disregards any structural
similarity. For instance the Prolog predi-
cates first and last could be said to have
a similar meaning because they cut one el-
ement off a list, first at the beginning and
last at the end of the list, but they have to
be programmed in a different way. MARs
deals with the first kind of similarity that
is the source and the target problem are
supposed to have a both similar structure
and arguments.
3 A M o d e l of Analogi-
cal Reasoning
MARs intends to support the definition of
new Prolog predicates with respect to sim-
ilar known predicates. The input required
includes two analogical examples and a
knowledge base. Both examples have to
be ground literals. The knowledge base
is supposed to store at least all rules and
facts needed to prove the source example.
The target example can not be solved di-
rectly according to the knowledge base,
but it is required to be provable in a sim-
ilar way. The output of MARs consists of
the rules and facts necessary to prove the
target problem. This knowledge has to be
justified by an oracle before it is added to
the knowledge base for further use.
The construction of the missing rules
and facts involves four basic steps. First,
the recognition step compares the argu-
ments of the source and the target ex-
ample. In addition, the proof tree of the
source example is constructed. The elab-
oration step maps the ground literals of
the proved source example onto the target
 393
problem. During evaluation MARs uses
forward chaining to construct a proof tree
for the target problem. The last step gen-
eralizes the proof tree in order to get the
missing predicates.
3.1 Recognition
Recognition starts with the determination
of the analogical argument terms of the ex-
amples. In general, there are many possi-
bilities to map argument terms but we as-
sume that the user has given the most sim-
ilar examples. Therefore, we prefer iden-
tical terms to be mapped first and then
try to find further similarities between the
unmapped terms with the help of other re-
lations, e.g. subset or membership. Thus,
the mapping relations are ranked where
the identity relation has the highest rank.
The term mapping Mt¢~m is stored in a
replacement list with the following struc-
ture:
{(Pt,P,)(..., (argt,, i, arg,j,j),.. .))}
where Pt is the target predicate symbol,
p, is the source predicate symbol. The 4-
tuples (argti, i, arg,~, j) describe the term
mappings where argt~ is the ith argument
of the target example, arg,~ is the j t h ar-
gument of the source example, and i and
j are the argument positions needed for
later recovery of the term mappings.
Figure 2 shows an example of two ana-
logical predicates, where six mappings of
terms are possible. Given a ranking of
the candiate mapping relations, we use the
highest ranking relation, identity, to corre-
late the third argument of append with the
second argument of member. Also, using
the same ranking, the membership rela-
tion is established between the first term
of member and the second of append. This
term mapping is choosen for further pro-
cessing and only if the analogical reason-
ing fails MARs tries to establish another
term mapping with lower ranked relations.
Example of analogy:
member(2,[l,2,3]) ,,~ append([l],[2,3],[1,2,3])
Source problem: append([1],[2,3],[1,2,3])
Mter,n: {(member, append)
((2,1, [2, ai, 2), ([1, 2, al, 2, [1, 2, a], a))}
Figure 2: A recognition step
In addition to the term mapping the
refutation tree of the append example has
to be constructed. The refutation tree is
built up using resolution.
A single resolution step can be repre-
sented by a V representing an inverted
tree, as shown in Figure 3. The clause
Resi+l is inferred from the two given
clauses Resl and Cll with the particular
substitutions ORes~ and Oct,. The refuta-
tions are established using a special kind
of resolution, the SLD resolution, that ap-
plies to a negative clause, the so called re-
solvent, and a positive clause to transform
them into a negative clause.
Resi Cli
R e si+ 1
Figure 3: A single resolution step
Resolvent: Let Resl and Cll be two
clauses with no variables in common.
Let L1 E Resl, L= E Cl and 0 is the
most general unifier or mgu such that
L10 -- ~-~. We write the resolvent
as
Resi+t = (Real \ {L1})O O (ell \ {L2})O
The result of recognition includes the
term mapping and the refutation tree. For
 394
further work we have to extend the refu-
tation tree so that the resolvent and the
positive clauses of each particular resolu-
tion step together with their substitutions
are contained. We use the following struc-
ture of a refutation tree where the symbol
[] stands for an empty clause:
Tree= { (Resl,Cll, 01),...,
(Res,,_l, Ct,,-1, ON-l>,
(o) }
where Oi = Oct,, because Resl are in-
stantiated clauses and On,s~ is empty.
--,append([1],[2, 3], [1, 2, 3])
append([XlT], L, [XIT1])
append(T, L, T1)
-~appc,d(O, [2, 31,[2, 31)
t/append(0,L, L)
O p~(..., arg~i,...) of the source proof tree
Figure 4: The refutation tree
The following tree is generated of the ex-
ample of figure 4.
Tree =
{ (~append([1],[2,3],[1,2,3])),
(append([XIT],L,[XIT1])
V-~append(T,L,T1)),
(X--,1, T~[], L~[2,3], T1~[2,3])),
(-~append([],[2,3],[2,3])),
(append([],L,L)),
(L-*[2,3])),
o)}
3.2 Elaboration
Elaboration maps all ground literals of
the proof tree into the domain of the tar-
get example. Two cases can be distin-
guished depending on the ground literals
and the term mapping Mte~,~: if the pred-
icate symbol occurs in Mt,~m, then, the
argument mapping can be used simply in
reverse. The other case is more compli-
cated because we do not have any infor-
mation about the corresponding literal in
the target domain. So, only the argument
terms will be replaced but the predicate
symbols will not be changed.
The definition for determining the
ground literals needed to prove the target
example is given by the following replace
mapping M, ept where f is a mapping rela-
tion like identity, inclusion or subset:
M, ept(ps(. . . , ar gs~, . . .) ) =
I p~(...,arg,,,...) : (pt,p,) e M,,~,~
and (argt,,i,arg~,j) • Mte~m
pt(...,argt,,...) : (pt,p~) • Mte,n
and (f(argt,),i,f(arg~,),j) • Mt~,~
pt(...,argtj,...) : (pt,ps) ¢ Mte,~
and (argt¢,j, arg~,j) • Mt~m
pt(...,arg~,...) :otherwise
M~vt transforms the ground literal
into the ground literal needed for the tar-
get proof tree according to the informa-
tion about term mappings stored in Mt~,~.
Figure 5 shows an example of elabora-
tion where the terms and the predicate
symbol of the ground literal of the source
refutation tree, append([], [2, 3], [2, 3]), are
mapped onto member(2, [2, 31). For exam-
ple, the first rule of M~pt applies to the
second argument of append([], [2, 3], [2, 3])
and the second rule to the third argument.
Mt~m: ((member, append)
((2, 1, [2, 3], 2), ([1, 2, 3], 2, [1, 2, 3], 3))}
Ground literal: append(I],[2,3],[2,3])
Mrepz(append([], [2, 31, [2, 3]))
= member(2, [2, 31)
Figure 5: An elaboration step
3.3 Evaluation
The evaluation step uses the mapped
ground literals and the refutation tree of
 395
the known example to construct a refuta-
tion tree for the target example. Start-
ing from the ground literals the missing
nodes of the new refutation tree are de-
termined by forward chaining. In general,
the search space of this problem is large
but the structure of the known proof tree
restricts it considerably because the new
proof tree should be as similar as possible.
Forward chaining can be done by simply
inverting the resolution step as described
in [MuggletonBuntine 88],[Wirth 89].
With this mechanism, called inverse reso-
lution, we can determine clause Resi from
the clauses Cli and Resi+l in a configura-
tion like it is shown in figure 3.
The formula of the inverse resolution
Resi is a simple algebraic manipulation of
the resolution formula with five unknown
parameters in the general case as shown in
[Wirth 89]:
[Resi+l \ clleol, u { ~ e c t , } U SOct,]OR~,,
-~
Here, we make the assumption for Resl
that we only use instantiated clauses and
that S is empty. Therefore, the formula
used for forward chaining in the source do-
main is defined by:
Res,, = ( Res,,+, \ Cl,, Ocz,, u {-q,, Oct,, })
where all parameters are known and
l,~ E Cl,,. The formula of the target do-
main is:
Re,,, = (Re,,,+, \ eli, U {-~It,})
where Itl E Clti. Itl and Clti are instanti-
ate& Clti can be conjectured by M,,pt and
the resolution literal can be effectively de-
termined.
Figure 6 shows one forward chaining step
for each example. For efficient construc-
tion of the refutation tree it is useful to
tie together both refutation resolvents into
one. Figure 7 shows the same example re-
solvents as figure 6 but tied together in a
double resolvent.
-.append([l], [2, 3], [1, 2, 31)
append([1], [2, 3], [1, 2, 31)V
~pp~,,d(l], [2, 3], [2, 31)
-~vv~n~([1], [2, 3], [1, 2, 3])
..-imembe~(~} [1, 2,
3])member(2, [1, 2, 3])V
~ -..~.~b~(2, [2, 31/
-,m~mbeK2, [2, 31)
Figure 6: A forward chaining step
The double resolvent of n resolution
steps is determined by:
Resd. = {(~t~ i, ~%)}
where sii represents the j ground liter-
als included in the refutation tree of the
source domain and tit are the j resulting
ground literals of the elaboration step.
ne~d, = he.d,+, \ { (ti., %)} 0 { (-.l,,, -q.,)}
where s b E Res,~+~, Cl,~Ovt, = 1~ V
",si,... V "~slk, (Ress~, Clsi, Oct,) E Tree
and0 <i<n.
Forward chaining suceeds if the resolvent
Resaa contains both examples.
The unknown clauses Clt, = It~ V
"~ti~,...,'~tlk are conjectured using M~pt
ReSd, = { (-,member(2, [1,2, 3]),
--,append([1], [2, 3], [1, 2, 3])) }
\ \ append([1], [2, 3], [1,2, 31)
~ V-~append(~,[2, 31, [2, 31:
x.x~v-.memb~K2, [2, all
Resd,+t = { (--,member(2, [2, 3]),
-..pp~.d([l], [2, 3], [x, 2, 31)) }
Figure 7: Refutation with a double resol-
vent
 396
and the instantiated clauses Cl,,.
M~,pt(l~, V "-'si,... V ",si~) =
Itl V "tla , . . . , V"~ti~
The result of the evaluation step is a
refutation tree of the target example with
the instantiated clauses Cltl. Figure 7
shows an example of a forward chaining
step.
3.4 Consolidation
The last step called consolidation general-
izes the conjectured rules of the previous
step. For this purpose we use the term re-
placement set Mt,r,~ and the substitutions
of the refutation tree generated during the
recognition step. Thus, generalization is
performed through inverse substitution as
defined by
O.~(Oct~) =
O . ~ ( { . . . , X j --. arg,;,...}) =
{
{..., ( ( a r g , , , 0 ---, x,)...}
: (argt,,i, a r g , j , j ) E Mt~,m
{ . . , ((a,'o,,, i) --, x~)...}
: (f(arg,,),i,f(arg,~),j) ~ M,o,,,
{..,0,...} : otherwise
where Oolk are the substitutions of the
recognition step and Mt,,m is the term re-
placement set. f is a mapping relation for
two argument terms.
Mt~m: {(member, append)
((2,1, [2, 31,2), ([1, 2, 3], 2, [1, 2, 3], 3)))
OClk :
{ X--*l, T-*[], L--*[2,3],TI--*[2,3])}
Oi,k (Ocl,,) =
{((2,1)~L),((1,2)~X),(([2,3],2)-+T1)}
Figure 8: The inverse substitution
Figure 8 shows an example of establish-
ing the inverse substitution. For instance,
the application of the first rule of O;~k to
the substitution ( X ~ I ) of Ocz~ results in
the inverse substitution ((2,1)--+L).
The inverse substitution is applied in or-
der to generalize each literal of the con-
jectured clauses of the target domain as
shown in figure 9. Using this procedure
the m e m b e r clause of the example is con-
structed. For instance, the inverse sub-
tltution Octk applied to member(2,[2,3])
results in mcmber(L,T1).
Ois,(Ool,) =
{((2,1)-~L),((1,2)-~x),(([2,aI,2)~T1)}
(Ois Octk)(member(2,[1,2,3])) =
member(L,[XIT1])
( Oi~ Octk)(member(2,[2,3])) =
member(L,T1)
Result:
member(L,[XlTll) ,- meinber(L,T1)
Figure 9: A consolidation step
4 Concluding Remarks
In this paper we introduced MARs, a tool
for defining new Prolog predicates by anal-
ogy. Particular methods are presented for
each of the four steps of the analogical rea-
soning process. The main contribution of
MARs is that it is a logically well founded
but simple model of analogical reasoning.
However, MARs has to be evaluated in
more detail and to be extended to be ap-
plicable for more complex kinds of anal-
ogy.
We plan to improve MARs along serveral
lines. First, applying MARs to other ana-
logical pairs of predicates, e.g. union ..,
intersection or s u m I i s t ,.. multlist, has
shown that it is useful to submit more
than one example or to use an oracle. In
many cases the information included in
the term mappings and the source proof
 397

tree is not sufllcent to determine the cor-
rect target literals. For instance, using
more examples, e.g. union([], [2, 3], [2, 31),
union([1,21, [2, 31, [1, 2, 3]), in addition to
the analogical example union(J1,21, [2, 31,
[1,2,31) ..o intersection([1,2], [2,31, [2])
makes it possible to define union analog-
ically to intersection without asking an
oracle.
Second, we intend to resolve the limita-
tions on the structure of the known pred-
icates that have to be very similar. Espe-
cially the treatment of the predicates ap-
pearing in the proof tree of an example
but not in the replacement list has to be
investigated in more detail.
Third, we plan to apply MARs to other
domains like language processing in or-
der to define new grammar rules analog-
ically. Comparing grammar rules shows
that they are often very similar especiMly
in their structure so that an analogical def-
inition will succeed in many cases. Using
the DCG formalism to describe grammar
rules makes it possible to use MARs be-
cause the grammar rules can be treated in
a similar way as logical predicates.
References
A. Prieditis (Hrsg.), Analogica. Mor-
gan Kaufmann, 1988.
[Greiner 88] R. Greiner. Learning by un-
derstanding analogies. PhD thesis,
Stanford University, 1988.
[Hall 89] R. P. Hall. Computational ap-
proaches to analogical reasoning: A
comparative analysis. Artificial In-
telligence, 39:3-120, 1989.
[KedarCabelli 88] S. Kedar-Cabelli. To-
wards a computational model of pur-
pose-directed analogy. In A. Priedi-
tis (Hrsg.), Analogica. Morgan Kauf-
mann, 1988.
[MuggletonBuntine 88] S. Muggleton und
W. Buntine. Machine invention
of first-order predicates by inverting
resolution. In A. Arbor (Hrsg.), Fifth
International Conference on Mach-
ine Learning. Morgan Kaufmann,
1988.
[Wirth 89] R. Wirth. Lernverfahren zur
Vervollstiindigung yon Hornklausel-
mengen durch inverse Resolution.
Doktorarbeit, Institut ffir Informa-
tik, Universit£t Stuttgart, 1989.

[Burstein 86] M. Burstein. Incremen-

tal learning from multiple analogies.
In R. Michalski, J. Carbonell und
T. Mitchell (Hrsg.), Machine Learn-
ing: An Artificial Intelligence Ap-
proach. Morgan Kaufmann, 1986.
[Carbonell 83] J. Carbonell. Learning
by analogy: Formulating and gener-
alizing plans from past experience.
In R. Michalski, J. Carbonell und
T. Mitchell (Hrsg.), Machine Learn-
ing: An Artificial Intelligence Ap-
proach. Tioga, 1983.
[Gentner 88] D. Gentner. Analogical in-
ference and analogical access. In