Content uploaded by Pierre-Alexandre Murena

Author content

All content in this area was uploaded by Pierre-Alexandre Murena on Jun 28, 2017

Content may be subject to copyright.

A complexity based approach for solving

Hofstadter’s analogies

Pierre-Alexandre Murena1, Jean-Louis Dessalles1, and Antoine Cornu´ejols2

1T´el´ecom ParisTech - Universit´e Paris Saclay,

46 rue Barrault, 75013 Paris, France,

last@telecom-paristech.fr

2UMR MIA-Paris

AgroParisTech, INRA, Universit´e Paris Saclay,

5 rue Claude Bernard, 75005 Paris

antoine.cornuejols@agroparistech.fr

Abstract. Analogical reasoning is a central problem both for human

cognition and for artiﬁcial learning. Many aspects of this problem re-

main unsolved, though, and analogical reasoning is still a diﬃcult task

for machines. In this paper, we consider the problem of analogical rea-

soning and assume that the relevance of a solution can be measured

by the complexity of the analogy. This hypothesis is tested in a basic

alphanumeric micro-world. In order to compute complexity, we present

speciﬁcations for a prototype language used to describe analogies. A few

elementary operators for this language are exposed, and their complex-

ity is discussed both from a theoretical and practical point of view. We

expose several alternative deﬁnitions of relevance in analogical reasoning

and show how they are related to complexity.

Keywords: Analogy, Complexity, Relevance

1 Introduction

Analogical reasoning is a fundamental ability of human mind which consists in

establishing a mapping between two domains based on common representations.

Analogies are involved in particular in the use of metaphors, humour [11] and

in scientiﬁc research [4]. It is also the key ability measured in IQ tests [16].

Although it is perceived as a very basic and natural task by human beings,

transferring this ability to computers remains a challenging task, whether for

detecting, understanding, evaluating or producing analogies. A typical analogy

can be expressed as follows: ‘b’ is to ‘a’ what ‘d’ is to ‘c’, which will be written a

: b :: c : d. This problem involves two domains, called source domain and target

domain. The analogy is based on the pairing of the transformation a : b in the

source domain and the transformation c : d in the target domain. Several models

have been developed so far to cope with analogical reasoning, but they are based

on complex modelings and huge computing power, which is not plausible from

a cognitive point of view. For example, softwares such as Copycat [8] and its

2 A complexity based approach for solving Hofstadter’s analogies

successor Metacat [14] explore the possible mappings between the two involved

problems (source and target problems).

The question of relevance is central in analogical reasoning in the sense that

it deﬁnes the quality of the considered mappings. Because inﬁnitely-many com-

mon properties can be found between two objects, a relevance measure has to be

found to disqualify properties of little interest [6]. Moreover, several criteria may

be considered to measure relevance of a mapping: the number of common proper-

ties [18], the abstraction level of the shared properties, structural alignment [5],

pragmatic centrality [10] or representational distortion [7].

Inspired by some previous works [3], [15], [1], we consider in this paper that

relevance in analogical reasoning can be measured by description length and

Kolmogorov complexity (which is its formal equivalent). We propose the prin-

ciples for a new generative language which can be used to describe analogical

problems. Although it is presented in the domain of Hofstadter’s analogies (i.e.

analogical problems in alphanumerical domain), its principles are general and

could be used in several other contexts. The idea of such a language is similar to

the idea developed by [17] in the context of sequence continuation. This language

oﬀers a strict general framework and oﬀers a cognitively plausible and generative

description of analogies.

2 Representation bias for Hofstadter’s micro-world

2.1 Presentation of Hofstadter’s problem and its variant

In order to study general properties of proportional analogy, Douglas Hofstadter

introduced a micro-world made up of letter-strings [9]. The choice of such a

micro-world is justiﬁed by its simplicity and the wide variety of typical analogical

problems it covers. The base domain of Hofstadter’s micro-world is the alphabet,

in which letters are considered as Platonic objects, hence as abstract entities.

Elementary universal concepts are deﬁned relatively to strings of letters, such as

ﬁrst,last,successor and predecessor. To this domain is added a base of semantic

constructs deﬁned by Hofstadter: copy-groups, successor-groups and predecessor-

groups [8]. The typical problem considered by Hofstadter in this micro-world is

the

We consider a slightly modiﬁed version of Hofstadter’s problem. Our modi-

ﬁcations correspond to an extension of the micro-world.

First, we consider an additional base alphabet: the number alphabet. This

alphabet adds an inﬁnite number of elements to the problem but does not make

the base problem more complicated. Furthermore, this addition encourages the

use of user-deﬁned base structures and raises the issue of transfer between diﬀer-

ent domains. In particular, the analogy equation ABC : ABD :: 123 : x seems

very basic for a human mind while it corresponds to a change of representation

from the world of letters to the world of numbers. Besides, the use of other base

alphabets can be justiﬁed by some prior knowledge of the users: for instance, it

can be thought that the problem ABC : ABD :: QWE : x will admit a simple

solution for any system familiar with the English keyboard layout.

A complexity based approach for solving Hofstadter’s analogies 3

Secondly, we consider a mapping from numbers to any base alphabet. This

operation was discarded by Hofstadter’s rules but seems important to us. The

problem ABC : ABD :: ABBCCC : x relies on a such a mapping: the string

ABBCCC is naturally described as “n-th letter of the alphabet repeated n times

for n∈ {1,2,3}”.

The third major diﬀerence between our approach and Hofstadter’s original

works lies in the consideration of descriptive groups. While Hofstadter’s ap-

proach is merely descriptive, we adopt a generative formalism in which the way

strings were formed is taken into account. The static description of copy-groups,

successor-groups or predecessor-groups is replaced in our framework by methods

such as copy,succession or predecession.

2.2 Complexity-based description

In this paper, we will focus on the resolution of analogy equations of the form A :

B :: C : x where xis unknown. We submit that the solution of such an equation

is given by x= arg minxC(A,B,C,x) where the function Ccorresponds to the

(minimum) description length for the four terms. Such a hypothesis is related to

the well-known philosophical principle of Occam’s razor stating the best choice

is the shortest.

A strict deﬁnition for the description length is oﬀered by algorithmic theory of

information with Kolmogorov complexity [13]. Basically, the complexity CM(x)

of a string xcorresponds to the length (in bits) of the shortest program on a

Universal Turing Machine (UTM) Mthat produces x.

In practice, this quantity is not calculable, hence only upper-bounds are used

to estimate the complexity of an object. An upper-bound corresponds to a re-

stricted choice of programs or equivalently to the choice of a limited Turing

Machine. In this paper, we consider a particular machine by deﬁning an elemen-

tary language. The language we develop is an ad hoc construction encoding a

theory of the domain of interest.

We do not consider here preﬁx codes, ie. decodable codes in which no code

word can be the preﬁx of another code word. To cope with decoding, we consider

that the code is space-delimited, which means that costless delimiters are present

in it. This idea is in use in the Morse code for example. Morse code encodes letters

by sequences of dashes and dots (ie. with a binary alphabet). A full word is given

by a succession of letters separated by short breaks. These breaks are not part of

the Morse code but are used to indicate the transition from one letter to another.

In such contexts, the delimiters are supposed to be processed by the physical

layer of the system, hence to ensure a uniquely decodable code while having no

inﬂuence on complexity.

2.3 A generative language

Based on the speciﬁcations listed above, we develop a prototype language de-

signed to produce and solve analogies. We present here the global characteristics

of our language.

4 A complexity based approach for solving Hofstadter’s analogies

As mentioned, a major diﬀerence between our perspective and Hofstadter’s

works is the generative point of view. Largely inspired by Leyton’s theory of

shapes [12], we consider a description of the process generating analogies rather

than a description of the analogies themselves. Any string will result from a

transformation of the base alphabet: for instance, ABCDE is perceived as the

sequence of the ﬁrst ﬁve letters in the alphabet and ZYX as the sequence of the

ﬁrst three letters in the reversed alphabet.

In order to integrate this sequential transformation of an original string, we

consider that the machine has access to a one-dimensional discrete tape. At each

time step, the machine writes on this tape or modiﬁes the previously written

string. Thus, the base operation consists in copying the alphabet onto the tape.

Thus, the generative procedure consists in a sequence of operations read from

left to right and separated by commas. The operations are applied one by one

and refer to understandable manipulations. Even if any operation may be incor-

porated to the language, we will consider here only a restricted set of predeﬁned

transformations, called operators {O1,O2, . . . }. The complexity of an operator

is independent of the operation it performs. An upper bound of this complexity

is the rank of the operator in the list of operators. For instance, the complexity

of operator O1is equal to 0, no matter how complex the corresponding operation

actually is.

Besides, the instruction next_block is used to move to the next term in the

analogy deﬁnition. For the analogy A : B :: C : D, the order of the blocks is

A,B,Cand D.

The core of the language is the use of a triple memory: a long-term domain

memory, a long-term operator memory and a short-term memory. A string or a

new operator can be put into short-term memory by means of the instruction

let. The short-term memory can be accessed with the key instruction mem.

More precise information on the exact grammar chosen for the language can

be found as supplementary material on the authors’ webpage.

2.4 Basic operators

The list of operators available for the language determines the bias of the ma-

chine. The more operators are given to the system, the more sophisticated the

obtained expressions can be.

The most basic set of programs is empty: it corresponds to a system capable

of giving letters one by one only. Such a system is suﬃcient in some contexts.

Consider for example the real problem of learning declension in a language.

In order to learn a declension, students learn by heart a single example and

transfer the acquired knowledge to new words. This corresponds for instance to

the analogy rosa : rosam :: vita : vitam for a simple Latin declension. This

analogy is encoded by the following code:

let(‘r’,‘o’,‘s’,‘a’), let(‘v’,‘i’,‘t’,‘a’),

let(?, next_block, ?, ’m’),

mem, 0, mem, 2, next_block, mem, 0, mem, 1;

A complexity based approach for solving Hofstadter’s analogies 5

This program has to be interpreted as follows: In the ﬁrst line, the groups

‘rosa’ and ‘vita’ are put in short-term memory. The second line deﬁnes a new

operator which displays the argument, switches to the next block, displays the

argument again and ﬁnally adds the character ‘m’. The third line retrieves the

just-deﬁned operation and applies it successively to the two words, also retrieved

from memory.

In order to build eﬀective descriptions for more complex systems, additional

operators can be deﬁned. A list of possible operators is given in table 1.

Name Description Example

copy Repeats the group a given num-

ber of times. Equivalent of Hofs-

tadter’s copy-group.

‘a’, copy, 4; outputs aaaa

sequence Outputs the sequence of the ﬁrst

nelements of the group. Equiva-

lent of Hofstadter’s copy-group.

alphabet, sequence, 3; out-

puts abc

shift Shifts the subgroups of nposi-

tions.

alphabet, shift, 3; outputs

defg...yz

shift_circular Circular version of the shift op-

erator

alphabet, shift_circular, 3;

outputs defg...yzabc

reverse Reverses the order of elements in

a group.

alphabet,sequence,3,reverse;

outputs cba

find Searches all occurrences of a

group given as parameter.

‘a’,‘b’,‘a’,find,‘a’,copy,2;

outputs aabaa

find Selects last group ‘a’,‘b’,‘a’, last, copy, 2;

outputs abaa

Table 1. Example of operators used by the language.

2.5 Using memory

The strength of the proposed language lies in its use of a triple memory to access

elements of diﬀerent nature: a long-term domain memory Mdstoring domain

descriptions (e.g. alphabets), a long-term operator description Mostoring sys-

tem procedures to modify objects, and a short-term memory storing temporary

elements. Managing memory is of major importance when it comes to producing

programs of minimal length.

The access to elements in long-term memories Mdand Mois hidden in

the language for simplicity purpose, but it cannot be ignored. The designation

of support alphabets (alphabet,numbers,utf8,qwerty-keyboard...), hence

of the domain, and the designation of operators (copy,sequence,find...) are

treated as proper nouns to encapsulate an access to an ordered memory. The

rank of entities in memory is a characteristics of the machine and cannot be

changed.

6 A complexity based approach for solving Hofstadter’s analogies

The user is in charge of the management of short-term memory. Entities

(operators or strings) are stored in memory with the let meta-operator and

accessed with the mem meta-operator. For example, the instruction let(‘a’)

will store the generation of abut the string is not written on the band. It will be

written only when invoked from memory. The short-term memory is organized

as a stack (hence last-in ﬁrst-out): the parameter given to the mem operator is

the depth of the element in the stack.

Using short-term memory is not compulsory to describe a string: the language

syntax does not prevent from repeating identical instructions. However, in a

context of ﬁnding a minimal description (which is the purpose of our framework),

using memory is an important way to pool identical entities.

3 Relevance of a solution

3.1 From language to code

The principles outlined in previous section form a simpliﬁed grammar for our

generative language. They are not suﬃcient yet to calculate the complexity of an

analogy. The missing step is the formation of a binary code from an instruction.

The basic idea we use to obtain an eﬃcient code consists in using a positional

code in lists. This code associates element 0 to the blank symbol, 0to element 1

and increments of 1 bit at for each element (0,1,00,01,10...). Using this code,

the complexity of the n-th element of a list is dlog2ne.

The global description of the language is organized as a list of lists: a word is

designated by the path inside the sequence of lists. For instance, the code for the

character dcorresponds to the code of domain memory (1), alphabet (0) and d

(01), hence 1,0,01. The code is not self-delimited: the delimiter is the comma

symbol and can delimit a blank symbol. For instance, the number 2 is encoded

by 1,,00. Because a language word corresponds necessarily to a tree leaf, the

code is uniquely decodable.

The complexity of an instruction is determined from the corresponding code.

We propose to consider that the complexity corresponds directly to the number

of bits required in the code. For instance, the complexity of the character 2 will

be the number of bits in 1,0,0, hence C(2) = 3. The same reasoning is applied

to any instruction, including complex instructions describing complete analogies.

A way to build a cognitively plausible language encoding would consist in

evaluating the ordering based on human experiments. Such experiments will have

to be made in future research.

3.2 Relevance of a description

Several acceptable instructions can generate a given string. For example, the

string abc can be produced either by alphabet, sequence, 3; (instruction 1)

or ‘a’,‘b’,‘c’; (instruction 2) or alphabet, sequence, 2, ‘c’; (instruc-

tion 3). These three instructions do not seem equally satisfying from a human

A complexity based approach for solving Hofstadter’s analogies 7

point of view. We submit that the diﬀerence in terms of relevance can be quanti-

ﬁed by their description length. Using a speciﬁc code description, the description

lengths for the three previous instructions are respectively DL1= 8, DL2= 10

and DL3= 12. In this example, it is clear that the instruction with minimal de-

scription length corresponds to the most relevant description of the string. As a

ﬁrst step of our reasoning, we state that the most relevant generative description

of a string is the description of minimal description length. An upper-bound for

the Kolmogorov complexity of a string is deﬁned as the description length of

the most relevant instruction which outputs the string of interest. Despite the

huge restriction applied to a general UTM by the choice of our language, the

complexity remains non computable: its computation requires an exploration of

all instructions producing the string, hence of an inﬁnite space. Several solutions

can be adopted in order to build the optimal program. First, greedy approaches

would impose a research bias by the mean of a locally optimal exploration of

the space of programs. Additionally to this guided exploration of the space of

programs, a resource-bounded research can be considered [2].

3.3 Relevance of a solution for an analogy equation

Using the version of Kolmogorov complexity obtained by our system as described

above, it is possible to apply the minimum complexity decision rule.

In order to evaluate the way human beings react to analogy problems, we

proposed an experiment with several Hofstadters analogy problems.

Participants were 68 (36 female), ages 16-72, from various social and educa-

tional backgrounds. Each participant was given a series of analogies. The series

were in the same order for all participants, and some questions were repeated

several times in the experiment. All analogies had in common the source trans-

formation ABC : ABD. The main results are presented in Table 2.

The results presented in Table 2 conﬁrm that in most cases the most chosen

solution corresponds to a minimum of cognitive complexity. The complexity is

calculated here using our small language and the coding rules exposed earlier.

Its limits are visible with the two examples ABC : ABD :: 135 : x and

ABC : ABD :: 147 : x. In these examples, the language fails at describing the

progression of the sequence “two by two” (1-3-5-7) or “three by three” (1-4-7-10)

which would decrease the overall complexity.

However, despite the simplicity of the language used to calculate the com-

plexity, it is noticeable that the most frequent solution adopted by the users

corresponds a complexity drop. This property is not veriﬁed with only two prob-

lems: for the problem ABC : ABD :: 122333 : x, the large value of the

complexity in the most frequent case is due to the limitations of the language

which fails at providing a compact description of the complete analogy because

of a too rigid grammar. In the case of the analogy ABC : ABD :: XYZ : x,

adding the circularity constraint has a cost in the language, while it seems to be

a natural operation for human beings.

The experiment also reveals a major weakness of our modeling: The descrip-

tions provided by our language are static and do not depend on the environment.

8 A complexity based approach for solving Hofstadter’s analogies

Problem Solution Propostion Complexity

IJK IJL 93% 37

IJD 2.9% 38

BCA BCB 49% 42

BDA 43% 46

AABABC AABABD 74% 33

AACABD 12% 46

IJKLM IJKLN 62% 40

IJLLM 15% 41

123 124 96% 27

123 3% 31

KJI KJJ 37% 43

LJI 32% 46

IJK IJL 93% 37

IJD 2.9% 38

135 136 63% 35

137 8.9% 37

BCD BCE 81% 35

BDE 5.9% 44

IJJKKK IJJLLL 40% 52

IJJKKL 25% 53

XYZ XYA 85% 40

IJD 4.4% 34

122333 122444 40% 56

122334 31% 49

RSSTTT RSSUUU 41% 54

RSSTTU 31% 55

IJJKKK IJJLLL 41% 52

IJD 28% 53

AABABC AABABD 72% 33

AACABD 12% 46

MRRJJJ MRRJJK 28% 64

MRRKKK 19% 65

147 148 69% 36

1410 10% 38

Table 2. Main results of the survey. For each problem, only the two main solutions

are presented, with their frequency and the corresponding complexity.

A complexity based approach for solving Hofstadter’s analogies 9

On the contrary, the variations of the average answering time and the changes

in the answers (when a same problem is repeated at several places) indicates

clearly that having faced similar structures in the past helps in solving a new

analogy. Finally, the relative relevance of two solutions is not necessarily suﬃ-

cient to explain human preference in this matter, though. For instance, on the

ﬁrst problem, a large majority of people choose the IJL answer despite the

small complexity diﬀerence. This possible divergence is related to research bi-

ases which are not taken into account in our approach. This eﬀect is particularly

visible with the more diﬃcult analogy equation ABC : ABD :: AABABC :

x. Very few humans notice the structure A-AB-ABC, hence the corresponding

solution x=AABABCD. However, the structure A-AB-ABC is perceived as

more relevant when presented.

We have shown that complexity oﬀers a criterion to compare two given so-

lutions to an analogy equation. This sole property is not suﬃcient in practice

to obtain an analogy solver. Since the space of solutions is inﬁnite, additional

hypotheses must be considered in order to restrict the exploration space.

4 Conclusion

In this paper, we proposed to interpret analogical reasoning as a complexity

minimization problem and to solve an analogy equation by taking the solution

minimizing total complexity. Our approach relies on a restricted Turing ma-

chine: we proposed basic rules deﬁning a small language adapted to Hofstadter’s

analogies. The language has been chosen to be generative (hence consistent with

Leyton’s theory of shapes) and not self-delimited (which allows compression with

unspeciﬁed parameters). We gave general principles governing such a language.

The system is ﬂexible in the choice of the operations that can be involved for

the description of an analogy. This language is associated to a code directly used

in the computation of complexity. We use this code to measure the relative rel-

evance of descriptions for a same string and the global relevance of a solution

to an analogy. We used this code to measure the complexity of several analogies

and noticed that the minimum complexity solution corresponds in most cases to

the most frequent solution given by human beings.

Although the considered case might seem restrictive, our approach applies on

a wider range of problems. Humans often justify their analogies with a seman-

tic description. We consider our developed language as such. Similar languages

can be developed for other analogies. Several issues remain open. A future re-

search would be to develop a system able to generate descriptions automatically,

hence to solve analogy equations automatically. The question of the performance

evaluation of an analogy solver remains open: our framework measures only the

relevance of a single solution. Some work has to be done to oﬀer either a the-

oretical measure of the global quality for an analogy solver or an experimental

validation of its eﬃciency. Finally, a real investigation on an extension of this

language to other domains is needed in order to conclude on its actual general-

ization properties.

10 A complexity based approach for solving Hofstadter’s analogies

Acknowledgments. This research is supported by the program Futur & Rup-

tures (Institut Mines T´el´ecom).

References

1. Bayoudh, M., Prade, H., Richard, G.: Evaluation of analogical proportions through

Kolmogorov complexity. Knowledge-Based Systems 29, 20–30 (2012)

2. Buhrman, H., Fortnow, L., Laplante, S.: Resource-Bounded Kolmogorov Complex-

ity Revisited. SIAM J. Comput. 31(3), 887–905 (2001)

3. Cornu´ejols, A., Ales-Bianchetti, J.: Analogy and induction : which (missing) link?

In: Workshop “Advances in Analogy Research : Integration of Theory and Data

from Cognitive, Computational and Neural Sciences”. Soﬁa, Bulgaria (1998)

4. Dunbar, K.: Designing for science: Implications from everyday, classroom, and pro-

fessional settings. chap. What scientiﬁc thinking reveals about the nature of cog-

nition., pp. 115–140. Mahwah, NJ, US: Lawrence Erlbaum Associates Publishers

(2001)

5. Gentner, D., Markman, A.B.: Structure mapping in analogy and similarity. Amer-

ican psychologist 52(1), 45 (1997)

6. Goodman, N.: Problems and Projects. Indianapolis: Bobbs-Merrill (1972)

7. Hodgetts, C.J., Hahn, U., Chater, N.: Transformation and alignment in similarity.

Cognition 113(1), 62–79 (2009)

8. Hofstadter, D.: The Copycat Project: An Experiment in Nondeterminism and Cre-

ative Analogies. AI Memo 755, Artiﬁcial Intelligence Laboratory, Massachusetts

Institute of Technology (1984)

9. Hofstadter, D., Mitchell, M.: Fluid concepts and creative analogies. chap. The

Copycat Project: A Model of Mental Fluidity and Analogy-making, pp. 205–267.

Basic Books, Inc., New York, NY, USA (1995)

10. Holyoak, K.J., Thagard, P.: Analogical Mapping by Constraint Satisfaction. Cog-

nitive Science 13(3), 295–355 (1989)

11. Holyoak, K., Holyoak, K., Thagard, P.: Mental Leaps: Analogy in Creative

Thought. A Bradford book, Bradford Books (1996)

12. Leyton, M.: A Generative Theory of Shape. Springer (2001)

13. Li, M., Vitanyi, P.M.: An Introduction to Kolmogorov Complexity and Its Appli-

cations. Springer Publishing Company, Incorporated, 3 edn. (2008)

14. Marshall, J.B.: Metacat: a self-watching cognitive architecture for analogy-making

and high-level perception. In: In Proceedings of the 24th Annual Conference of the

Cognitive Science Society. Citeseer (1999)

15. Prade, H., Richard, G.: Testing Analogical Proportions with Google using Kol-

mogorov Information Theory. In: FLAIRS Conference (2009)

16. Ragni, M., Neubert, S.: Solving Raven’s IQ-tests: an AI and cognitive modeling ap-

proach. In: Proceedings of the 20th European Conference on Artiﬁcial Intelligence.

pp. 666–671. IOS Press (2012)

17. Stranneg˚ard, C., Nizamani, A.R., Sj¨oberg, A., Engstr¨om, F.: Bounded Kolmogorov

Complexity Based on Cognitive Models, pp. 130–139. Springer Berlin Heidelberg,

Berlin, Heidelberg (2013)

18. Tversky, A.: Features of similarity. Psychological review 84(4), 327 (1977)