Analogical reasoning has a long history in artificial intelligence research, primarily because of its promise for Ike acquisition unit effective use of knowledge. Defined as a representational mapping from a known "source " domain into a novel "target" domain, analogy provides a basic mechanism for effectively connecting a reasoner's past and present experience. Using a four-component process model of analogical reasoning, this paper reviews sixteen computational studies of analogy. These studies are organized chronologically within broadly defined task domains of automated deduction, problem solving and planning, natural language comprehension, and machine learning. Drawing on these detailed reviews, a comparative analysis of diverse contributions to basic analogy processes identifies recurrent problems for studies of analogy and common approaches to their solution. The paper concludes by arguing that computational studies of analogy are in a slate of adolescence: looking to more mature research areas in artificial intelligence for robust accounts of basic reasoning processes and drawing upon a long tradition of research in other disciplines.

Our ability to see a particular object or situation in one context as being “the same as” another object or situation in another context is the essence of analogy-making. It encompasses our ability to explain new concepts in terms of already-familiar ones, to emphasize particular aspects of situations, to generalize, to characterize situations, to explain

Machine Due to the current technology of the computers we can use, we have chosen an extremely abridged emulation of the machine that will effectively run the programs, instead of more proper languages, like l-calculus (or LISP). We have adapted the "toy RISC" machine of [Hernndez & Hernndez 1993] with two remarkable features inherited from its object-oriented coding in C++: it is easily tunable for our needs, and it is efficient. We have made it even more reduced, removing any operand in the instruction set, even for the loop operations. We have only three registers which are AX (the accumulator), BX and CX. The operations Q b we have used for our experiment are in Table 1: LOOPTOP Decrements CX. If it is not equal to the first element jump to the program top.

This paper is concerned with establishing broadly-based system-theoretic foundations and practical techniques for the problem of system identification that are rigorous, intuitively clear and conceptually powerful. A general formulation is first given in which two order relations are postulated on a class of models: a constant one of complexity; and a variable one of approximation induced by an observed behaviour. An admissible model is such that any less complex model is a worse approximation. The general problem of identification is that of finding the admissible subspace of models induced by a given behaviour. It is proved under very general assumptions that, if deterministic models are required then nearly all behaviours require models of nearly maximum complexity. A general theory of approximation between models and behaviour is then developed based on subjective probability concepts and semantic information theory The role of structural constraints such as causality, locality, finite memory, etc., are then discussed as rules of the game. These concepts and results are applied to the specific problem or stochastic automaton, or grammar, inference. Computational results are given to demonstrate that the theory is complete and fully operational. Finally the formulation of identification proposed in this paper is analysed in terms of Klir’s epistemological hierarchy and both are discussed in terms of the rich philosophical literature on the acquisition of knowledge. 1

Problems stemming from the study of logic calculi in connection with an inference rule called "condensed detachment" are widely acknowledged as prominent test sets for automated deduction systems and their search guiding heuristics. It is in the light of these problems that we demonstrate the power of heuristics that make use of past proof experience with numerous experiments. We present two such heuristics. The first heuristic attempts to re-enact a proof of a proof problem found in the past in a flexible way in order to find a proof of a similar problem. The second heuristic employs "features" in connection with past proof experience to prune the search space. Both these heuristics not only allow for substantial speed-ups, but also make it possible to prove problems that were out of reach when using so-called basic heuristics. Moreover, a combination of these two heuristics can further increase performance. We compare our results with the results the creators of Otter obtained with t...

ii Class organizations (schemas) evolve over the life cycle of object-oriented systems for avariety of reasons. This issue has recently been a subject of increasing attention in the literature of both object-oriented languages and object-oriented database systems. One of the most common forms of evolution involves the extension of an existing system by addition of new classes of objects or the addition of attributes to the original objects. Sometimes class structures are reorganized even when the set of objects is unchanged. In this case the reorganization might represent an optimization of the system, or just a change in the users ' perspective. At the other extreme, a class reorganization might re ect not only the extension and reclassi cation of existing objects, but also structural changes (other than addition of attributes) in the original objects. This work provides a mathematical treatment of a calculus of class transformations. Three kinds of transformations that commonly occur in the evolution of class structures are considered: object-extending, object-preserving, and language-preserving. For each kind of transformation, methods for automating the maintenance of systems based on the evolving class structure are discussed. The language-preserving transformations are a special case of transformations that change the structure of existing objects. If an object schema is decorated with concrete syntax, it de nes not only a class structure, but also a language for describing the objects. When two schemas de ne the same language but di erent classes, the language may be used to guide the discovery of analogies between the classes. The resulting analogies may then be used to transport functionality between domains. iii Acknowledgments Iwould like to thank my advisor, Karl Lieberherr, for his generous support, guidance, and feedback. I would also like to thank my wife, Vickie, for her constant encouragement and understanding without which thiswork would not have been possible. iv

This paper analyzes how mathematicians prove theorems. The analysis is based upon several empirical sources such as reports of mathematicians and mathematical proofs by analogy. In order to combine the strength of traditional automated theorem provers with human-like capabilities, the questions arise: Which problem solving strategies are appropriate? Which representations have to be employed? As a result of our analysis, the following reasoning strategies are recognized: proof planning with partially instantiated methods, structuring of proofs, the transfer of subproofs and of reformulated subproofs. We discuss the representation of a component of these reasoning strategies, as well as its properties. We find some mechanisms needed for theorem proving by analogy, that are not provided by previous approaches to analogy. This leads us to a computational representation of new components and procedures for automated theorem proving systems.

Constructing an analogy between a known and already proven theorem (the base case) and another yet to be proven theorem (the target case) often amounts to finding the appropriate representation at which the base and the target are similar. This is a well-known fact in mathematics, and it was corroborated by our empirical study of a mathematical textbook, which showed that a reformulation of the representation of a theorem and its proof is indeed more often than not a necessary prerequisite for an analogical inference. Thus machine supported reformulation becomes an important component of automated analogy-driven theorem proving too. The reformulation component proposed in this paper is embedded into a proof plan methodology based on methods and meta-methods, where the latter are used to change and appropriately adapt the methods. A theorem and its proof are both represented as a method and then reformulated by the set of metamethods presented in this paper. Our approach supports analog...

We describe here a prover PC that normally acts as an ordinary theorem prover, but which returns a "precondition" when it is unable to prove the given formula. If F is the formula attempted to be proved and PC returns the precondition Q, then (Q \Gamma! F ) is a theorem (that PC can prove). This prover, PC, uses a Proof-Plan. In its simplest mode, when there is no proof-plan, it acts like ordinary Abduction. We show here how this method can be used to derive certain proofs by analogy. To do this, it uses a proof-plan from a given guiding proof to help construct the proof of a similar theorem, by "debugging" (automatically) that proof-plan. We show here the analogy proofs of a few simple example theorems and one hard pair, Ex4 and Ex4L. The given proof-plan for Ex4 is used by the system to prove automatically Ex4; and that same proof-plan is then used to prove Ex4L, during which the proof-plan is "debugged" (automatically). These two examples are similar to two other, more difficult, t...

Using formal specifications to represent software components facilitates the determination of reusability because they more precisely characterize the functionality of the software, and the well-defined syntax makes processing amenable to automation. This paper presents an approach, based on formal methods, to the search, retrieval, and modification of reusable software components. From a two-tiered hierarchy of reusable software components, the existing components that are analogous to the query specification are retrieved from the hierarchy. The specification for an analogous retrieved component is compared to the query specification to determine what changes need to be applied to the corresponding program component in order to make it satisfy the query specification. This paper also describes an approach for assisting the modification of analogous components and gives an example to demonstrate its use. Keywords: Software reuse, formal methods, analogical reasoning, program modifica...