CogPrime: An Integrative Architecture for Embodied Artificial General Intelligence

Ben Goertzel

October 2, 2012

Abstract

The CogPrime architecture for embodied AGI is overviewed, covering the core architecture and algorithms, the underlying conceptual motivations, and the emergent structures, dynamics and functionalities expected to arise in a completely implemented CogPrime system once it has undergone appropriate experience and education. A qualitative argument is sketched, in favor of the assertion that a completed CogPrime system, given a modest amount of experience in an embodiment enabling it to experience a reasonably rich human-like world, will give rise to human-level general intelligence (with significant difference from humans, and with potential for progress beyond this level).

This paper, presented here as a set of wiki pages, provides a high-level overview of the CogPrime design & architecture which is partially implemented in the current OpenCog codebase.

See also the PDF version. But, please note that the PDF version may be out of date compared to the wiki version. The wiki version will be kept reasonably current, whereas the PDF version is current as of the date indicated near the top of the PDF.

NOTE FOR THOSE WHO WISH TO BE HELPFUL: This wiki-paper still needs some work. Specifically, the references at the end should be linked to available online papers where possible, especially for OpenCog-related papers. And terms mentioned within the paper should be linked to relevant pages within the OpenCog wiki site. Copious thanks in advance to anyone who is willing to help with this. Also, if you are knowledgeable on some aspect of OpenCog and feel the explanation of that aspect given here can be improved (without drastically increasing its length), please feel free to do so; while it began as a wiki version of a PDF paper, this wiki version is intended to be a living document in the wiki spirit.

One more note: This paper is about the design, not all of which is implemented in the code. For a review of the implementation/testing status of the various OpenCog components, see the Code_Maturity_Guide page.

See also the "Monster OpenCog Diagram" http://goertzel.org/MonsterDiagram.jpg, a conceptual graphical depiction of the key structures and processes in OpenCog. (This is not a real flowchart of everything happening in OpenCog; that would be way too large to show in a single image.)





Introduction

This is a lengthy paper with a substantial ambition: to overview CogPrime, a conceptual and technical design for a thinking machine, a software program capable of the same qualitative sort of general intelligence as human beings. Given the uncertainties attendant on all research, we cannot know for sure how far the CogPrime design will be able to take us; but it seems plausible that once fully implemented, tuned and tested, it will be able to achieve general intelligence at the human level and in some respects perhaps beyond. CogPrime is described in more detail in a 2014 book titled Engineering General Intelligence, volumes 1 and 2, which exceeds 1000 pages including appendices; the goal of this paper is to outline some of the key points in a more compact format.

To allay potential confusion we offer two caveats from the outset. First, CogPrime is not a model of human neural or cognitive structure or activity. It draws heavily on knowledge about human intelligence, especially cognitive psychology; but it also deviates from the known nature of human intelligence in many ways, with a goal of providing maximal humanly-meaningful general intelligence using available computer hardware. Second, CogPrime is not proposed as the one and only holy grail path to advanced AGI. We feel confident there are multiple possible paths to advanced AGI, and that in following any of these paths, multiple theoretical and practical lessons will be learned, leading to modifications of the ideas developed and possessed along the early stages of the path. The goal here is to articulate one path that we believe makes sense to follow, one overall design that we believe can work, for achieving general intelligence that is qualitatively human-level and in many respects human-like, without emulating human neural or cognitive function in detail.

AI versus AGI

An outsider to the AI field might think this sort of paper commonplace in the research literature, but insiders know that’s far from the truth. The field of Artificial Intelligence (AI) was founded in the mid 1950s with the aim of constructing “thinking machines” - that is, computer systems with human-like general intelligence, including humanoid robots that not only look but act and think with intelligence equal to and ultimately greater than that of human beings. But in the intervening years, the field has drifted far from its ambitious roots, and this book represents part of a movement aimed at restoring the initial goals of the AI field, but in a manner powered by new tools and new ideas far beyond those available half a century ago.

After the first generation of AI researchers found the task of creating human-level AGI very difficult given the technology of their time, the AI field shifted focus toward what Ray Kurzweil[1] has called "narrow AI" – the understanding of particular specialized aspects of intelligence; and the creation AI systems displaying intelligence regarding specific tasks in relatively narrow domains. In recent years, however, the situation has been changing. More and more researchers have recognized the necessity – and feasibility – of returning to the original goals of the field.

In the decades since the 1950s, cognitive science and neuroscience have taught us a lot about what a cognitive architecture needs to look like to support roughly human-like general intelligence. Computer hardware has advanced to the point where we can build distributed systems containing large amounts of RAM and large numbers of processors, carrying out complex tasks in real time. The AI field has spawned a host of ingenious algorithms and data structures, which have been successfully deployed for a huge variety of purposes.

Due to all this progress, increasingly, there has been a call for a transition from the current focus on highly specialized “narrow AI” problem solving systems, back to confronting the more difficult issues of “human level intelligence” and more broadly “artificial general intelligence (AGI).” Recent years have seen a growing number of special sessions, workshops and conferences devoted specifically to AGI, including the annual BICA (Biologically Inspired Cognitive Architectures) Conference, and the international AGI conference series (AGI-08 , AGI-09, AGI-10, AGI-11). And, even more exciting, there are a number of contemporary R&D projects focused directly and explicitly on AGI (sometimes under the name "AGI", sometimes using related terms such as "Human Level Intelligence").

In spite of all this progress, however, no one has yet clearly articulated a detailed, systematic design for an AGI, with potential to yield general intelligence at the human level and ultimately beyond. Perhaps the most comprehensive attempts in this direction have been the works of Stan Franklin [2] and Joscha Bach [3], or the more classical SOAR [4] and ACT-R [5] architectures. While we feel there is much to be learned from these designs, we also feel they have significant shortcomings and lacunae alongside their considerable strengths. Detailed discussion and comparison of these and other alternative AGI approaches will not be presented here, as the paper is long enough already, but are given in the above-mentioned book that constitutes a greatly expanded version of this paper [6].

What’s the Secret Sauce?

There is no consensus on why all the related technological and scientific progress mentioned above has not yet yielded AI software systems with human-like general intelligence. However, we hypothesize that the core reason boils down to the following three points:

Intelligence depends on the emergence of certain high-level structures and dynamics across a system’s whole knowledge base;

We have not discovered any one algorithm or approach capable of yielding the emergence of these structures;

Achieving the emergence of these structures within a system formed by integrating a number of different AI algorithms and structures is tricky. It requires careful attention to the manner in which these algorithms and structures are integrated; and so far the integration has not been done in the correct way.

The human brain appears to be an integration of an assemblage of diverse structures and dynamics, built using common components and arranged according to a sensible cognitive architecture. However, its algorithms and structures have been honed by evolution to work closely together – they are very tightly inter-adapted, in somewhat the same way that the different organs of the body are adapted to work together. Due their close interoperation they give rise to the overall systemic behaviors that characterize human-like general intelligence. We believe that the main missing ingredient in AI so far is cognitive synergy: the fitting-together of different intelligent components into an appropriate cognitive architecture, in such a way that the components richly and dynamically support and assist each other, interrelating very closely in a similar manner to the components of the brain or body and thus giving rise to appropriate emergent structures and dynamics. Which leads us to one of the central hypotheses underlying the CogPrime approach to AGI: that the cognitive synergy ensuing from integrating multiple symbolic and subsymbolic learning and memory components in an appropriate cognitive architecture and environment, can yield robust intelligence at the human level and ultimately beyond.

The reason this sort of intimate integration has not yet been explored much is that it’s difficult on multiple levels, requiring the design of an architecture and its component algorithms with a view toward the structures and dynamics that will arise in the system once it is coupled with an appropriate environment. Typically, the AI algorithms and structures corresponding to different cognitive functions have been developed based on divergent theoretical principles, by disparate communities of researchers, and have been tuned for effective performance on different tasks in different environments. Making such diverse components work together in a truly synergetic and cooperative way is a tall order, yet we believe that this – rather than some particular algorithm, structure or architectural principle – is the “secret sauce” needed to create human-level AGI based on technologies available today.

What Kind of ’’Intelligence’’ is CogPrime Aimed At?

We have mentioned "intelligence" frequently in the preceding paragraphs, but haven’t specified precisely what we mean by it. In fact, a host of different definitions of intelligence have been proposed in the AGI, narrow AI, psychology, engineering and philosophy communities; Legg and Hutter [7] have enumerated over 70. The CogPrime design is not particularly tied to any of these; instead, it was primarily motivated by a commonsensical interpretation of intelligence, comprising a mixture of theoretical general problem solving capability, and the practical ability to display the same sorts of intelligence as humans do. However, CogPrime is consistent with a number of different recognized definitions of general intelligence.

There are psychological definitions of intelligence (e.g. the g-factor), based on the ability to carry out particular kinds of common human problem-solving tasks effectively[8]. The design intention of CogPrime is that a fully implemented and reasonably experienced system would be able to do well at these sorts of tasks.

There are pragmatic tests for measuring whether an AGI has achieved human-level, human-like general intelligence. In the paper ’’Mapping the Landscape of Human-Level AI"[9], resultant from the 2009 AGI Roadmap Workshop, the author and a number of co-authors discussed several examples of practical goals plausibly characterizing "human level AGI", e.g.

Turing Test : the classic, involving passing as a human being in an everyday conversation

: the classic, involving passing as a human being in an everyday conversation Virtual World or Telerobotic Turing Test : pass as a human being, in a conversation involving controlling a virtual world avatar or a robot, alongside verbal interaction

: pass as a human being, in a conversation involving controlling a virtual world avatar or a robot, alongside verbal interaction Online University Test : attend an online university just like a human student, and graduate

: attend an online university just like a human student, and graduate Physical University Test : control a robot that attends university just like a human student, and graduates

: control a robot that attends university just like a human student, and graduates Artificial Scientist Test: write and publish original science papers, based on ideas conceived by the AI due to its own reading of the literature

Again, while we don’t necessarily consider all of these as useful for motivating the early steps of AGI research, we intend that a fully realized CogPrime system would be able to succeed at them.

There are mathematical definitions of general intelligence, involving formalizations of the idea that an intelligence should be judged via its average capability to achieve goals in environments (where the average is weighted so that more complex goals and environments get less weight)[10]. CogPrime is also intended to display intelligence in this sense, but with the caveat that a complete and mature CogPrime functioning as intended, would perform better according to such a measure if the goals and environments similar to everyday human goals and environments were weighted more highly.

A variant of this mathematical approach to intelligence measures not only the ability of a system to achieve certain goals in certain environments, but also the amount of space and time resources expended in doing so.[10] A system that can do the same things using fewer resources would be rated more intelligent. Since CogPrime is not a theoretical design like AIXI [11], but one intended for real-world near-term implementation, it is intended to be intelligent in this sense as well. That is, informally speaking: CogPrime is intended as ’’wholly general in principle’’, but, able to carry out certain kinds of intelligence-requiring tasks more rapidly and using fewer computational resources. And the kinds of tasks it can do more easily, are biased by design to reflect the nature of the human everyday world.

There is a school of thought that defines intelligence via adaptiveness: the capability of a system to adapt to its environment effectively . CogPrime is also intended to display intelligence in this sense. Indeed, it seems to us that achieving goals in environments requires adaptation to these environments, and vice versa; so that qualitatively the various approaches to defining intelligence are largely getting at the same thing.

All in all, we pragmatically conceive of general intelligence as ’’the ability to achieve complex goals in complex environments, using limited resources"; and we accept that any real-world general intelligence is going to be more intelligent with respect to some sorts of goals and environments than others. CogPrime has been designed with careful attention toward human-relevant goals and environment, yet is also expected to have a particular set of intellectual strengths and weaknesses different from that of humans.

Key Claims

We conclude this Introduction with a systematic list of some of the key claims to be argued for here. Not all the terms and ideas in these claims will be familiar to the reader in their technical details, but we hope their qualitative sense will be reasonably clear nonetheless. This list of claims will be revisited toward the end of the paper, where we will look back at the ideas and arguments that have been put forth in favor of them, in the intervening sections.

In essence this is a list of claims such that, if the reader accepts these claims, they should probably accept that the CogPrime approach to AGI is a viable one. On the other hand if the reader rejects one or more of these claims, they may find one or more aspects of CogPrime unacceptable for a related reason:

General intelligence (at the human level and ultimately beyond) can be achieved via creating a computational system that uses much of its resources seeking to achieve its goals, via using perception and memory to predict which actions will achieve its goals in the contexts in which it finds itself. To achieve general intelligence in the context of human-intelligence-friendly environments and goals using feasible computational resources, it’s important that an AGI system can handle different kinds of memory (declarative, procedural, episodic, sensory, intentional, attentional) in customized but interoperable ways. Cognitive synergy: It’s important that the cognitive processes associated with different kinds of memory can appeal to each other for assistance in overcoming bottlenecks in a manner that enables each cognitive process to act in a manner that is sensitive to the particularities of each others’ internal representations, and that doesn’t impose unreasonable delays on the overall cognitive dynamics. As a general principle, neither purely localized nor purely global memory is sufficient for general intelligence under feasible computational resources; “glocal” memory will be required. To achieve human-like general intelligence, it’s important for an intelligent agent to have sensory data and motoric affordances that roughly emulate those available to humans. We don’t know exactly how close this emulation needs to be, which means that our AGI systems and platforms need to support fairly flexible experimentation with virtual-world and/or robotic infrastructures. To work toward adult human-level, roughly human-like general intelligence, one fairly easily comprehensible path is to use environments and goals reminiscent of human childhood, and seek to advance one’s AGI system along a path roughly comparable to that followed by human children. It is most effective to teach an AGI system aimed at roughly human-like general intelligence via a mix of spontaneous learning and explicit instruction, and to instruct it via a combination of imitation, reinforcement and correction, and a combination of linguistic and nonlinguistic instruction. One effective approach to teaching an AGI system human language is to supply it with some in-built linguistic facility, in the form of rule-based and statistical-linguistics-based NLP systems, and then allow it to improve and revise this facility based on experience. An AGI system with adequate mechanisms for handling the key types of knowledge mentioned (in item 2) above, and the capability to explicitly recognize large-scale pattern in itself, should, upon sustained interaction with an appropriate environment in pursuit of appropriate goals, emerge a variety of complex structures in its internal knowledge network, including, but not limited to: a hierarchical network, representing both a spatiotemporal hierarchy and an approximate “default inheritance” hierarchy, cross-linked;

a heterarchical network of associativity, roughly aligned with the hierarchical network;

a self network which is an approximate micro image of the whole network;

inter-reflecting networks modeling self and others, reflecting a “mirrorhouse” design pattern [12]. Given the strengths and weaknesses of current and near-future digital computers, a (loosely) neural-symbolic network is a good representation for directly storing many kinds of memory, and interfacing between those that it doesn’t store directly; Uncertain logic is a good way to handle declarative knowledge. To deal with the problems facing a human-level AGI, an uncertain logic must integrate imprecise probability and fuzziness with a broad scope of logical constructs. PLN is one good realization. Programs are a good way to represent procedures (both cognitive and physical-action, but perhaps not including low-level motor-control procedures). Evolutionary program learning is a good way to handle difficult program learning problems. Probabilistic learning on normalized programs is one effective approach to evolutionary program learning. MOSES is one good realization of this approach. Multistart hill-climbing, with a strong Occam prior, is a good way to handle relatively straightforward program learning problems. Activation spreading and Hebbian learning comprise a reasonable way to handle attentional knowledge (though other approaches, with greater overhead cost, may provide better accuracy and may be appropriate in some situations). Artificial economics is an effective approach to activation spreading and Hebbian learning in the context of neural-symbolic networks;

ECAN is one good realization of artificial economics;

A good trade-off between comprehensiveness and efficiency is to focus on two kinds of attention: processor attention (represented in CogPrime by ShortTermImportance) and memory attention (represented in CogPrime by LongTermImportance). Simulation is a good way to handle episodic knowledge (remembered and imagined). Running an internal world simulation engine is an effective way to handle simulation. Hybridization of one’s integrative neural-symbolic system with a spatiotemporally hierarchical deep learning system is an effective way to handle representation and learning of low-level sensorimotor knowledge. DeSTIN is one example of a deep learning system of this nature that can be effective in this context. One effective way to handle goals is to represent them declaratively, and allocate attention among them economically. CogPrime ’s PLN/ECAN based framework for handling intentional knowledge is one good realization. It is important for an intelligent system to have some way of recognizing large-scale patterns in itself, and then embodying these patterns as new, localized knowledge items in its memory ( a dynamic called the "cognitive equation" in [13]),. Given the use of a neural-symbolic network for knowledge representation, a graph-mining based “map formation” heuristic is one good way to do this. Occam’s Razor: Intelligence is closely tied to the creation of procedures that achieve goals in environments in the simplest possible way. Each of an AGI system’s cognitive algorithms should embody a simplicity bias in some explicit or implicit form. An AGI system, if supplied with a commonsensically ethical goal system and an intentional component based on rigorous uncertain inference, should be able to reliably achieve a much higher level of commonsensically ethical behavior than any human being. Once sufficiently advanced, an AGI system with a logic-based declarative knowledge approach and a program-learning-based procedural knowledge approach should be able to radically self-improve via a variety of methods, including supercompilation and automated theorem-proving.

CogPrime and OpenCog

Many of the technical details of the CogPrime design have been previously presented online in a wikibook ; and the basic ideas of the design have been presented briefly in a series of conference papers . But the overall design has not been presented in a coherent and systematic way before this paper and the associated book[6].

CogPrime is closely allied with the OpenCog open-source AI software framework. But the two are not synonymous. OpenCog is a more general framework, suitable for implementation of a variety of specialized AI applications as well as, potentially, alternate AGI designs. And CogPrime could potentially be implemented other than within the OpenCog framework. The particular implementation of CogPrime in OpenCog is called OpenCogPrime. OpenCog was designed with the purpose, alongside others, of enabling efficient, scalable implementation of the full CogPrime design. [1]

Current and Prior Applications of OpenCog

To give greater understanding regarding the practical platform for current work aimed at realizing CogPrime, we now briefly discuss some of the practicalities of work done with the OpenCog system that currently implements parts of the CogPrime architecture.

OpenCog, the open-source software framework underlying the “OpenCogPrime” (currently partial) implementation of the CogPrime architecture, has been used for commercial applications in the area of natural language processing and data mining. For instance, see where OpenCogPrime’s PLN reasoning and RelEx language processing are combined to do automated biological hypothesis generation based on information gathered from PubMed abstracts. describes the use of OpenCog’s MOSES component for biological data analysis; this use has been extended considerably in a variety of unpublished commercial applications since that point, in domains such as financial prediction, genetics, marketing data analysis and natural language processing. Most relevantly to the present work, OpenCog has also been used to control virtual agents in virtual worlds .

OpenCog for Virtual Agents

Prototype work done during 2007-2008 involved using an OpenCog variant called the OpenPetBrain to control virtual dogs in a virtual world (see Figure 'dog' for a screenshot of an OpenPetBrain-controlled virtual dog). While these OpenCog virtual dogs did not display intelligence closely comparable to that of real dogs (or human children), they did demonstrate a variety of interesting and relevant functionalities including

learning new behaviors based on imitation and reinforcement

responding to natural language commands and questions, with appropriate actions and natural language replies

spontaneous exploration of their world, remembering their experiences and using them to bias future learning and linguistic interaction

Figure: dog

One current OpenCog initiative involves extending the virtual dog work via using OpenCog to control virtual agents in a game world inspired by the game Minecraft. These agents are initially specifically concerned with achieving goals in a game world via constructing structures with blocks and carrying out simple English communications. Representative example tasks would be:

Learning to build steps or ladders to get desired objects that are high up

Learning to build a shelter to protect itself from aggressors

Learning to build structures resembling structures that it's shown (even if the available materials are a bit different)

Learning how to build bridges to cross chasms

Of course, the AI significance of learning tasks like this all depends on what kind of feedback the system is given, and how complex its environment is. It would be relatively simple to make an AI system do things like this in a highly specialized way, but that is not the intent of the project – the goal is to have the system learn to carry out tasks like this using general learning mechanisms and a general cognitive architecture, based on embodied experience and only scant feedback from human teachers. If successful, this will provide an outstanding platform for ongoing AGI development, as well as a visually appealing and immediately meaningful demo for OpenCog.

A few of the specific tasks that are the focus of this project team's current work at time of writing include:

Watch another character build steps to reach a high-up object

Figure out via imitation of this that, in a different context, building steps to reach a high up object may be a good idea

Also figure out that, if it wants a certain high-up object but there are no materials for building steps available, finding some other way to get elevated will be a good idea that may help it get the object (including e.g. building a ladder, or asking someone tall to pick it up, etc.)

Figure out that, if the character wants to hide its valued object from a creature much larger than it, it should build a container with a small hole that the character can get through, but the creature cannot

Transitioning from Virtual Agents to a Physical Robot

In 2009-2010, preliminary experiments were conducted using OpenCog to control a Nao robot . These involved hybridizing OpenCog with a separate subsystem handling low-level perception and action. This hybridization was accomplished in an extremely simplistic way, however. How to do this right is a topic treated in detail in [6] and [14] and only briefly touched here.

We suspect that reasonable level of capability will be achievable by simply interposing DeSTIN (or some other reasonably capable "hierarchical temporal memory" type sensorimotor system) as a perception/action “black box” between OpenCog and a robot. However, we also suspect that to achieve robustly intelligent robotics we must go beyond this approach, and connect robot perception and actuation software with OpenCogPrime in a “white box” manner that allows intimate dynamic feedback between perceptual, motoric, cognitive and linguistic functions. We suspect this may be achievable, for example, via the creation and real-time utilization of links between the nodes in CogPrime ’s and DeSTIN’s internal networks.

(this looks like it needs an update Adam (talk) 06:43, 20 February 2017 (UTC))

The overall OpenCog framework could be used to support natural language processing in a variety of different ways. Ideally an OpenCog system would use CogPrime learning dynamics to learn language based on its experience, in the context of virtual or robotic embodied experience, perhaps combined with reading information online.

In practice, so far, a combination of rule-based and statistical NLP tools have been integrated with OpenCog, serving as a (more functional in some respects than others) pragmatic pipeline translating English into OpenCog Atoms and vice versa. Key aspects include

The link parser, [created by Carnegie Mellon University http://www.link.cs.cmu.edu/link/] and currently maintained via an [ open source community http://www.abisource.com/projects/link-grammar/], which maps English sentences into parse structures. A couple variants of the link parser have been created, including the SAT link parser (based on Boolean satisfaction solver) and the Viterbi link parser (which tries to more closely simulate the human reading process, but as of April 13 is fairly incomplete).

RelEx, which translates link parser parse-structures into more abstract syntactico-semantic parses. RelEx also handles some other odds and ends like anaphor resolution.

Two approaches for translating RelEx output into OpenCog Atoms:

RelEx2Frame and Frame2Atom, which approached the project using the FrameNet ontology, and are now deprecated



RelEx2Atom and Link2Atom, which now (as of April 2013) are incomplete and hoped to be ready during Summer 2013



NLGen, which translates RelEx relationship-sets into link parses and thus into sentences. The current version works only for simple sentences

Atom2Link, which will replace NLGen but is currently very incomplete and expected/hoped to be released in Fall 2013

The relationships between these different entities are described roughly in the diagram

File:OpenCog NLP Diagram.pdf

, current as of April 2013.

The intended development path for OpenCog/CogPrime NLP is to:

Move toward approaches, like the Viterbi link parser, Link2Atom and Atom2Link, which represent all linguistic content (e.g. grammar rules, semantic mapping rules, etc.) as Atoms in the Atomspace

Ultimately, use various OpenCog reasoning and learning methods to adapt the linguistic content used by these NLP methods based on experience

If this is followed, then we will eventually end up with an adaptive, experiential learning based NLP system that begins from the initial seed of a rule-based NLP system.

Philosophical Background

The creation of advanced AGI systems is an engineering endeavor, whose achievement will require significant input from science and mathematics; and also, we believe, guidance from philosophy. Having an appropriate philosophy of mind certainly is no guarantee of creating advanced AGI system; philosophy only goes so far. However, having a badly inappropriate philosophy of mind may be a huge barrier in the creation of AGI systems. For instance, we believe that philosophical views holding that

the contents of a mind are best understood purely as a set of logical propositions, terms or predicates; or that

brains and other intelligence-substrate systems are necessarily so complex and emergence-dependent that it’s hopeless to try to understand how they represent any particular thing, or carry out any particular action

are particularly poorly suited to guide AGI development, and are likely to directly push adherents in the wrong directions AGI-design-wise.

The development of the CogPrime design has been substantially guided by a philosophy of mind called ’’patternism’’ . This guidance should not be overstated; CogPrime is an integrative design formed via the combination of a number of different philosophical, scientific and engineering ideas, and the success or failure of the design doesn’t depend on any particular philosophical understanding of intelligence. In that sense, the more abstract notions summarized in this section should be considered “optional” rather than critical in a CogPrime context. However, due to the core role patternism has played in the development of CogPrime , understanding a few things about general patternist philosophy will be helpful for understanding CogPrime , even for those readers who are not philosophically inclined. Those readers who are philosophically inclined, on the other hand, are urged to read The Hidden Pattern and then interpret the particulars of CogPrime in this light.

The patternist philosophy of mind is a general approach to thinking about intelligent systems. It is based on the very simple premise that mind is made of pattern – and that a mind is a system for recognizing patterns in itself and the world, critically including patterns regarding which procedures are likely to lead to the achievement of which goals in which contexts.

Pattern as the basis of mind is not in itself a very novel idea; it is present, for instance, in the 19th century philosophy of Charles Peirce, in the writings of contemporary philosophers Daniel Dennett and Douglas Hofstadter, in Benjamin Whorf’s linguistic philosophy and Gregory Bateson’s systems theory of mind and nature. Bateson spoke of the Metapattern: “that it is pattern which connects.” In our prior writings on philosophy of mind, an effort has been made to pursue this theme more thoroughly than has been done before, and to articulate in detail how various aspects of human mind and mind in general can be well-understood by explicitly adopting a patternist perspective. [2]

In the patternist perspective, "pattern" is generally defined as "representation as something simpler." Thus, for example, if one measures simplicity in terms of bit-count, then a program compressing an image would be a pattern in that image. But if one uses a simplicity measure incorporating run-time as well as bit-count, then the compressed version may or may not be a pattern in the image, depending on how one’s simplicity measure weights the two factors. This definition encompasses simple repeated patterns, but also much more complex ones. While pattern theory has typically been elaborated in the context of computational theory, it is not intrinsically tied to computation; rather, it can be developed in any context where there is a notion of "representation" or "production" and a way of measuring simplicity. One just needs to be able to assess the extent to which '"`UNIQ--postMath-00000001-QINU`"' represents or produces '"`UNIQ--postMath-00000002-QINU`"', and then to compare the simplicity of '"`UNIQ--postMath-00000003-QINU`"' and '"`UNIQ--postMath-00000004-QINU`"'; and then one can assess whether '"`UNIQ--postMath-00000005-QINU`"' is a pattern in '"`UNIQ--postMath-00000006-QINU`"'. A formalization of this notion of pattern is given in ; the crux is simply

Given a metric space '"`UNIQ--postMath-00000007-QINU`"', and two functions '"`UNIQ--postMath-00000008-QINU`"' (the “simplicity measure”) and '"`UNIQ--postMath-00000009-QINU`"' (the “production relationship”), we say that '"`UNIQ--postMath-0000000A-QINU`"' is a pattern in '"`UNIQ--postMath-0000000B-QINU`"' to the degree

'"`UNIQ--postMath-0000000C-QINU`"'

This degree is called the pattern intensity of '"`UNIQ--postMath-0000000D-QINU`"' in '"`UNIQ--postMath-0000000E-QINU`"'.

Next, in patternism the mind of an intelligent system is conceived as the (fuzzy) set of patterns in that system, and the set of patterns emergent between that system and other systems with which it interacts. The latter clause means that the patternist perspective is inclusive of notions of distributed intelligence . Basically, the mind of a system is the fuzzy set of different simplifying representations of that system that may be adopted.

In the patternist perspective, intelligence is conceived as roughly indicated above: as the ability to achieve complex goals in complex environments; where complexity itself may be defined as the possession of a rich variety of patterns. A mind is thus a collection of patterns that is associated with a persistent dynamical process that achieves highly-patterned goals in highly-patterned environments.

An additional hypothesis made within the patternist philosophy of mind is that reflection is critical to intelligence. This lets us conceive an intelligent system as a dynamical system that recognizes patterns in its environment and itself, as part of its quest to achieve complex goals.

While this approach is quite general, it is not vacuous; it gives a particular structure to the tasks of analyzing and synthesizing intelligent systems. About any would-be intelligent system, we are led to ask questions such as:

How are patterns represented in the system? That is, how does the underlying infrastructure of the system give rise to the displaying of a particular pattern in the system’s behavior?

What kinds of patterns are most compactly represented within the system?

What kinds of patterns are most simply learned?

What learning processes are utilized for recognizing patterns?

What mechanisms are used to give the system the ability to introspect (so that it can recognize patterns in itself)?

Now, these same sorts of questions could be asked if one substituted the word “pattern” with other words like “knowledge” or “information”. However, we have found that asking these questions in the context of pattern leads to more productive answers, avoiding unproductive byways and also tying in very nicely with the details of various existing formalisms and algorithms for knowledge representation and learning.

Among the many kinds of patterns in intelligent systems, semiotic patterns are particularly interesting ones. Peirce decomposed these into three categories:

iconic patterns, which are patterns of contextually important internal similarity between two entities (e.g. an iconic pattern binds a picture of a person to that person)

patterns, which are patterns of contextually important internal similarity between two entities (e.g. an iconic pattern binds a picture of a person to that person) indexical patterns, which are patterns of spatiotemporal co-occurrence (e.g. an indexical pattern binds a wedding dress and a wedding)

patterns, which are patterns of spatiotemporal co-occurrence (e.g. an indexical pattern binds a wedding dress and a wedding) symbolic patterns, which are patterns indicating that two entities are often involved in the same relationships (e.g. a symbolic pattern between the number “5” (the symbol) and various sets of 5 objects (the entities that the symbol is taken to represent))

Of course, some patterns may span more than one of these semiotic categories; and there are also some patterns that don’t fall neatly into any of these categories. But the semiotic patterns are particularly important ones; and symbolic patterns have played an especially large role in the history of AI, because of the radically different approaches different researchers have taken to handling them in their AI systems. Mathematical logic and related formalisms provide sophisticated mechanisms for combining and relating symbolic patterns (“symbols”), and some AI approaches have focused heavily on these, sometimes more so than on the identification of symbolic patterns in experience or the use of them to achieve practical goals.

Pursuing the patternist philosophy in detail leads to a variety of particular hypotheses and conclusions about the nature of mind. Following from the view of intelligence in terms of achieving complex goals in complex environments, comes a view in which the dynamics of a cognitive system are understood to be governed by two main forces:

self-organization, via which system dynamics cause existing system patterns to give rise to new ones

goal-oriented behavior, which has been defined more rigorously in [10], but basically amounts to a system interacting with its environment in a way that appears like an attempt to maximize some reasonably simple function

Self-organized and goal-oriented behavior must be understood as cooperative aspects. For instance – to introduce an example that will be elaborated in more detail below – an agent is asked to build a surprising structure out of blocks and does so, this is goal-oriented. But the agent’s ability to carry out this goal-oriented task will be greater if it has previously played around with blocks a lot in an unstructured, spontaneous way. And the “nudge toward creativity” given to it by asking it to build a surprising blocks structure may cause it to explore some novel patterns, which then feed into its future unstructured blocks play.

Based on these concepts, as argued in detail in , several primary dynamical principles may be posited, including the following. For consistency of explanation, we will illustrate these principles with examples from the "playing with blocks" domain, which has the advantage of simplicity, and also of relating closely to our current work with OpenCog-controlled video game agents. However, the readers should not get the impression that CogPrime has somehow been specialized for this sort of domain; it has not been. The principles:

Evolution , conceived as a general process via which patterns within a large population thereof are differentially selected and used as the basis for formation of new patterns, based on some “fitness function” that is generally tied to the goals of the agent Example: If trying to build a blocks structure that will surprise Bob, an agent may simulate several procedures for building blocks structures in its “mind’s eye”, assessing for each one the expected degree to which it might surprise Bob. The search through procedure space could be conducted as a form of evolution, via an evolutionary algorithm such as CogPrime’s MOSES (to be discussed below).

, conceived as a general process via which patterns within a large population thereof are differentially selected and used as the basis for formation of new patterns, based on some “fitness function” that is generally tied to the goals of the agent Autopoiesis the process by which a system of interrelated patterns maintains its integrity, via a dynamic in which whenever one of the patterns in the system begins to decrease in intensity, some of the other patterns increase their intensity in a manner that causes the troubled pattern to increase in intensity again Example: An agent’s set of strategies for building the base of a tower, and its set of strategies for building the middle part of a tower, are likely to relate autopoietically. If the system partially forgets how to build the base of a tower, then it may regenerate this missing knowledge via using its knowledge about how to build the middle part (i.e., it knows it needs to build the base in a way that will support good middle parts). Similarly if it partially forgets how to build the middle part, then it may regenerate this missing knowledge via using its knowledge about how to build the base (i.e. it knows a good middle part should fit in well with the sorts of base it knows are good). This same sort of interdependence occurs between pattern-sets containing more than two elements Sometimes (as in the above example) autopoietic interdependence in the mind is tied to interdependencies in the physical world, sometimes not.

Association . Patterns, when given attention, spread some of this attention to other patterns that they have previously been associated with in some way. Furthermore, there is Peirce’s law of mind , which could be paraphrased in modern terms as stating that the mind is an associative memory network, whose dynamics dictate that every idea in the memory is an active agent, continually acting on those ideas with which the memory associates it. Example: Building a blocks structure that resembles a tower, spreads attention to memories of prior towers the agents has seen, and also to memories of people whom the agent knows has seen towers, and structures it has built at the same time as towers, structures that resemble towers in various respects, etc.

. Patterns, when given attention, spread some of this attention to other patterns that they have previously been associated with in some way. Furthermore, there is Peirce’s law of mind , which could be paraphrased in modern terms as stating that the mind is an associative memory network, whose dynamics dictate that every idea in the memory is an active agent, continually acting on those ideas with which the memory associates it. Differential attention allocation / credit assignment . Patterns that have been valuable for goal-achievement are given more attention, and are encouraged to participate in giving rise to new patterns. Example: Perhaps in a prior instance of the task “build me a surprising structure out of blocks,” searching through memory for non-blocks structures that the agent has played with has proved a useful cognitive strategy. In that case, when the task is posed to the agent again, it should tend to allocate disproportionate resources to this strategy.

. Patterns that have been valuable for goal-achievement are given more attention, and are encouraged to participate in giving rise to new patterns. Pattern creation . Patterns that have been valuable for goal-achievement are mutated and combined with each other to yield new patterns. Example: Building towers has been useful in a certain context, but so has building structures with a large number of triangles. Why not build a tower out of triangles? Or maybe a vaguely tower-like structure that uses more triangles than a tower easily could? Example: Building an elongated block structure resembling a table was successful in the past, as was building a structure resembling a very flat version of a chair. Generalizing, maybe building distorted versions of furniture is good. Or maybe it is building distorted version of any previously perceived objects that is good. Or maybe both, to different degrees....

. Patterns that have been valuable for goal-achievement are mutated and combined with each other to yield new patterns.

Next, for a variety of reasons outlined in it becomes appealing to hypothesize that the network of patterns in an intelligent system must give rise to the following large-scale emergent structures

Hierarchical network. Patterns are habitually in relations of control over other patterns that represent more specialized aspects of themselves. Example: The pattern associated with “tall building” has some control over the pattern associated with “tower”, as the former represents a more general concept ... and “tower” has some control over “Eiffel tower”, etc.

Heterarchical network. The system retains a memory of which patterns have previously been associated with each other in any way. Example: “Tower” and “snake” are distant in the natural pattern hierarchy, but may be associatively/heterarchically linked due to having a common elongated structure. This heterarchical linkage may be used for many things, e.g. it might inspire the creative construction of a tower with a snake’s head.

Dual network. Hierarchical and heterarchical structures are combined, with the dynamics of the two structures working together harmoniously. Among many possible ways to hierarchically organize a set of patterns, the one used should be one that causes hierarchically nearby patterns to have many meaningful heterarchical connections; and of course, there should be a tendency to search for heterarchical connections among hierarchically nearby patterns. Example: While the set of patterns hierarchically nearby “tower” and the set of patterns heterarchically nearby “tower” will be quite different, they should still have more overlap than random pattern-sets of similar sizes. So, if looking for something else heterarchically near “tower”, using the hierarchical information about “tower” should be of some use, and vice versa In PLN, hierarchical relationships correspond to Atoms '"`UNIQ--postMath-0000000F-QINU`"' and '"`UNIQ--postMath-00000010-QINU`"' so that '"`UNIQ--postMath-00000011-QINU`"' and '"`UNIQ--postMath-00000012-QINU`"' have highly dissimilar strength; and heterarchical relationships correspond to IntensionalSimilarity relationships. The dual network structure then arises when intensional and extensional inheritance approximately correlate with each other, so that inference about either kind of inheritance assists with figuring out about the other kind.

Self structure. A portion of the network of patterns forms into an approximate image of the overall network of patterns. Example: Each time the agent builds a certain structure, it observes itself building the structure, and its role as “builder of a tall tower” (or whatever the structure is) becomes part of its self-model. Then when it is asked to build something new, it may consult its self-model to see if it believes itself capable of building that sort of thing (for instance, if it is asked to build something very large, its self-model may tell it that it lacks persistence for such projects, so it may reply “I can try, but I may wind up not finishing it”).



If the patternist theory of mind presented in is indeed appropriate as a guide for AGI work, then the success of CogPrime as a design will depend largely on whether these high-level structures and dynamics can be made to emerge from the synergetic interaction of CogPrime ’s representation and algorithms, when they are utilized to control an appropriate agent in an appropriate environment. The extended treatment of CogPrime given in [6], takes care to specifically elaborate how each of these abstract concepts arises concretely from CogPrime ’s structures and algorithms. In the more concise treatment given here, we will touch this aspect only lightly.

A Mind-World Correspondence Principle

Beyond patternist philosophy per se, an additional philosophical principle has guided CogPrime design; this is the "mind-world correspondence principle", which enlarges on the notion of "intelligence as adaptation to environments" mentioned above.

Real-world minds are always adapted to certain classes of environments and goals. As we have noted above, even a system of vast general intelligence, subject to real-world space and time constraints, will necessarily be more efficient at some kinds of learning than others. Thus, one approach to analyzing general intelligence is to look at the relationship between minds and worlds — where a “world” is conceived as an environment and a set of goals defined in terms of that environment.

An informal version of the "mind-world correspondence principle" given in is as follows: For intelligence to occur, there has to be a natural correspondence between the transition-sequences of world-states and the corresponding transition-sequences of mind-states, at least in the cases of transition-sequences leading to relevant goals. A slightly more rigorous version is:

MIND-WORLD CORRESPONDENCE-PRINCIPLE:

For a mind to work intelligently toward certain goals in a certain world, there should be a nice mapping from goal-directed sequences of world-states into sequences of mind-states, where "nice" means that a world-state-sequence '"`UNIQ--postMath-00000013-QINU`"' composed of two parts '"`UNIQ--postMath-00000014-QINU`"' and '"`UNIQ--postMath-00000015-QINU`"', gets mapped into a mind-state-sequence '"`UNIQ--postMath-00000016-QINU`"' composed of two corresponding parts '"`UNIQ--postMath-00000017-QINU`"' and '"`UNIQ--postMath-00000018-QINU`"'.

What’s nice about this principle is that it relates the decomposition of the world into parts, to the decomposition of the mind into parts. (A more fully formalized statement of the principle involves mathematical concepts that won’t be introduced here for risk of digression. [3]

Each component of CogPrime has been carefully thought-through in terms of this conceptual principle; i.e. it has been designed so that its internal dynamics are decomposable in a way that maps into everyday human goals and environment in a way that matches the natural decomposition of the dynamics of these goals and environments. This aspect of the CogPrime design will not be highlighted here due to space considerations, but is a persistent theme in the longer treatment in [6].

High-Level Architecture of CogPrime

The above philosophical principles would be consistent with a very wide variety of concrete AGI designs. CogPrime has not been directly derived from these philosophical principles; rather, it has been created via beginning with a combination of human cognitive psychology and computer science algorithms and structures, and then shaping this combination so as to yield a system that appears likely to be conformant with these philosophical principles, as well as being computationally feasible on current hardware and containing cognitive structures and dynamics roughly homologous to the key human ones.

Figures CogPrime1, CogPrime2, CogPrime3 and CogPrime4 depict the high-level architecture of CogPrime. A key underlying principle is: the use of multiple cognitive processes associated with multiple types of memory to enable an intelligent agent to execute the procedures that it believes have the best probability of working toward its goals in its current context. In a robot preschool context, for example, the top-level goals would be everyday things such as pleasing the teacher, learning new information and skills, and protecting the robot’s body. Figure [fig:MindAgents] shows part of the architecture via which cognitive processes interact with each other, via commonly acting on the AtomSpace knowledge repository.

It is interesting to compare these diagrams to the integrative human cognitive architecture diagram given in , which is intended to compactly overview the structure of human cognition as currently understood. The main difference is that the CogPrime diagrams commit to specific structures (e.g. knowledge representations) and processes, whereas the generic integrative architecture diagram refers merely to types of structures and processes. For instance, the integrative diagram refers generally to declarative knowledge and learning, whereas the CogPrime diagram refers to PLN, as a specific system for reasoning and learning about declarative knowledge. In [6] a table is provided articulating the key connections between the components of the CogPrime diagram and the well-known human cognitive structures/processes represented in integrative diagram, thus indicating the general cognitive functions instantiated by each of the CogPrime components.

[fig:CogPrime1]

[fig:CogPrime2]

[fig:MindAgents]

[fig:CogPrime3]

[fig:CogPrime4]

Local and Global Knowledge Representation

One of the biggest decisions to make in designing an AGI system is how the system should represent knowledge. Naturally any advanced AGI system is going to synthesize a lot of its own knowledge representations for handling particular sorts of knowledge – but still, an AGI design typically makes at least some sort of commitment about the category of knowledge representation mechanisms toward which the AGI system will be biased.

OpenCog’s knowledge representation mechanisms are all based fundamentally on networks. This is because we feel that, on a philosophical level, one of the most powerful known metaphors for understanding minds is to view them as networks of interrelated, interconnected elements. The view of mind as network is implicit in the patternist philosophy, because every pattern can be viewed as a pattern in something, or a pattern of arrangement of something – thus a pattern is always viewable as a relation between two or more things. A collection of patterns is thus a pattern-network. Knowledge of all kinds may be given network representations; and cognitive processes may be represented as networks also, for instance via representing them as programs, which may be represented as trees or graphs in various standard ways. The emergent patterns arising in an intelligence as it develops may be viewed as a pattern network in themselves; and the relations between an embodied mind and its physical and social environment may be viewed in terms of ecological and social networks.

The two major supercategories of knowledge representation systems are local (also called explicit) and global (also called implicit) systems, with a hybrid category we refer to as glocal that combines both of these. In a local system, each piece of knowledge is stored using a small percentage of cognitive system elements; in a global system, each piece of knowledge is stored using a particular pattern of arrangement, activation, etc. of a large percentage of cognitive system elements; in a glocal system, the two approaches are used together. All three of these knowledge representation types may be realized using networks. In CogPrime, all three are realized using the same (AtomSpace) network.

In the first part of this section we discuss the symbolic, semantic-network aspects of knowledge representation in CogPrime. Then, at the end of the section we turn to distributed, neural-net-like knowledge representation, focusing largely on CogPrime’s “glocal” knowledge representation mechanisms.

Weighted, Labeled Hypergraphs

There are many different mechanisms for representing knowledge in AI systems in an explicit, localized way, most of them descending from various variants of formal logic. Here we briefly describe how it is done in CogPrime. On the surface, CogPrime’s explicit representation scheme is not that different from a number of prior approaches. However, the particularities of CogPrime’s explicit knowledge, representation, however, are carefully tuned to match CogPrime’s cognitive processes, which are more distinctive in nature than the corresponding representational mechanisms.

One useful way to think about CogPrime’s explicit, localized knowledge representation is in terms of hypergraphs. A hypergraph is an abstract mathematical structure , which consists of objects called Nodes and objects called Links which connect the Nodes. In computer science, a graph traditionally means a bunch of dots connected with lines (i.e. Nodes connected by Links, or nodes connected by links). A hypergraph, on the other hand, can have Links that connect more than two Nodes.

In CogPrime it is most useful to consider “generalized hypergraphs” that extend ordinary hypergraphs by containing two additional features:

Links that point to Links instead of Nodes

Nodes that, when you zoom in on them, contain embedded hypergraphs.

Properly, such “hypergraphs” should always be referred to as generalized hypergraphs, but this is cumbersome, so we will persist in calling them merely hypergraphs. In a hypergraph of this sort, Links and Nodes are not as distinct as they are within an ordinary mathematical graph (for instance, they can both have Links connecting them), and so it is useful to have a generic term encompassing both Links and Nodes; for this purpose, we use the term Atom.

A weighted, labeled hypergraph is a hypergraph whose Links and Nodes come along with labels, and with one or more numbers that are generically called weights. A label associated with a Link or Node may sometimes be interpreted as telling you what type of entity it is, or alternatively as telling you what sort of data is associated with a Node. On the other hand, an example of a weight that may be attached to a Link or Node is a number representing a probability, or a number representing how important the Node or Link is.

Obviously, hypergraphs may come along with various sorts of dynamics. Minimally, one may think about:

Dynamics that modify the properties of Nodes or Links in a hypergraph (such as the labels or weights attached to them.)

Dynamics that add new Nodes or Links to a hypergraph, or remove existing ones.

Both types of dynamics are very important in CogPrime.

Atoms : Their Types and Weights

This section reviews a variety of CogPrime Atom types and gives simple examples of each of them. The Atom types considered are drawn from those currently in use in the OpenCog system. This does not represent a complete list of Atom types required for optimally efficient implementation of a complete CogPrime system, nor a complete list of those used in OpenCog currently (though it does cover a substantial majority of those used in OpenCog currently, omitting only some with specialized importance or intended only for temporary use).

The partial nature of the list given here reflects a more general point: The specific collection of Atom types in an OpenCog system is bound to change as the system is developed and experiment with. CogPrime specifies a certain collection of representational approaches and cognitive algorithms for acting on them; any of these approaches and algorithms may be implemented with a variety of sets of Atom types. The specific set of Atom types in the OpenCog system currently does not necessarily have a profound and lasting significance – the list might look a bit different five years from time of writing, based on various detailed changes.

The treatment here is informal and intended to get across the general idea of what each Atom type does. A longer and more formal treatment of the Atom types is given in the online OpenCog wikibook [15] and in [6].

Some Basic Atom Types

We begin with ConceptNode – and note that a ConceptNode does not necessarily refer to a whole concept, but may refer to part of a concept; it is essentially a "basic semantic node" whose meaning comes from its links to other Atoms. It would be more accurately, but less tersely, named "concept or concept fragment or element node." A simple example would be a ConceptNode grouping nodes that are somehow related, e.g.

ConceptNode: C InheritanceLink (ObjectNode: BW) C InheritanceLink (ObjectNode: BP) C InheritanceLink (ObjectNode: BN) C ReferenceLink BW (PhraseNode "Ben's watch") ReferenceLink BP (PhraseNode "Ben's passport") ReferenceLink BN (PhraseNode "Ben's necklace")

indicates the simple and uninteresting ConceptNode grouping three objects owned by Ben (note that the above-given Atoms don’t indicate the ownership relationship, they just link the three objects with textual descriptions). In this example, the ConceptNode links transparently to physical objects and English descriptions, but in general this won’t be the case – most ConceptNodes will look to the human eye like groupings of links of various types, that link to other nodes consisting of groupings of links of various types, etc.

There are Atoms referring to basic, useful mathematical objects, e.g. NumberNodes like

NumberNode #4 NumberNode #3.44

The numerical value of a NumberNode is explicitly referenced within the Atom.

A core distinction is made between ordered links and unordered links; these are handled differently in the AtomSpace software. A basic unordered link is the SetLink, which groups its arguments into a set. For instance, the ConceptNode C defined by

ConceptNode C MemberLink A C MemberLink B C

is equivalent to

SetLink A B

On the other hand, ListLinks are like SetLinks but ordered, and they play a fundamental role due to their relationship to predicates. Most predicates are assumed to take ordered arguments, so we may say e.g.

EvaluationLink PredicateNode eat ListLink ConceptNode cat ConceptNode mouse

to indicate that cats eat mice.

Note that by an expression like

ConceptNode cat

is meant

ConceptNode C ReferenceLink W C WordNode W #cat

since it’s WordNodes rather than ConceptNodes that refer to words. (And note that the strength of the ReferenceLink would not be 1 in this case, because the word "cat" has multiple senses.) However, there is no harm nor formal incorrectness in the "ConceptNode cat" usage, since "cat" is just as valid a name for a ConceptNode as, say, "C."

We’ve already introduced above the MemberLink, which is a link joining a member to the set that contains it. Notable is that the truth value of a MemberLink is fuzzy rather than probabilistic, and that PLN (CogPrime’s logical reasoning component ) is able to inter-operate fuzzy and probabilistic values.

SubsetLinks also exist, with the obvious meaning, e.g.

ConceptNode cat ConceptNode animal SubsetLink cat animal

Note that SubsetLink refers to a purely extensional subset relationship, and that InheritanceLInk should be used for the generic "intensional + extensional" analogue of this – more on this below. SubsetLink could more consistently (with other link types) be named ExtensionalInheritanceLink, but SubsetLink is used because it’s shorter and more intuitive.

There are links representing Boolean operations AND, OR and NOT. For instance, we may say

ImplicationLink ANDLink ConceptNode young ConceptNode beautiful ConceptNode attractive

or, using links and VariableNodes instead of ConceptNodes,

AverageLink $X ImplicationLink ANDLink EvaluationLink young $X EvaluationLink beautiful $X EvaluationLink attractive $X

NOTLink is a unary link, so e.g. we might say

AverageLink $X ImplicationLink ANDLink EvaluationLink young $X EvaluationLink beautiful $X EvaluationLink NOT EvaluationLink poor $X EvaluationLink attractive $X

ContextLink allows explicit contextualization of knowledge, which is used in PLN, e.g.

ContextLink ConceptNode golf InheritanceLink ObjectNode BenGoertzel ConceptNode incompetent

says that Ben Goertzel is incompetent in the context of golf.

We have already introduced VariableNodes above; it’s also possible to specify the type of a VariableNode via linking it to a VariableTypeNode via a TypedVariableLink, e.g.

VariableTypeLink VariableNode $X VariableTypeNode ConceptNode

which specifies that the variable $X should be filled with a ConceptNode.

Variables are handled via quantifiers; the default quantifier being the AverageLink, so that the default interpretation of

ImplicationLink InheritanceLink $X animal EvaluationLink PredicateNode: eat ListLink \$X ConceptNode: food

is

AverageLink $X ImplicationLink InheritanceLink $X animal EvaluationLink PredicateNode: eat ListLink \$X ConceptNode: food

The AverageLink invokes an estimation of the average TruthValue of the embedded expression (in this case an ImplicationLink) over all possible values of the variable $X. If there are type restrictions regarding the variable $X, these are taken into account in conducting the averaging. ForAllLink and ExistsLink may be used in the same places as AverageLink, with uncertain truth value semantics defined in PLN theory using third-order probabilities. There is also a ScholemLink used to indicate variable dependencies for existentially quantified variables, used in cases of multiply nested existential quantifiers.

EvaluationLink and MemberLink have overlapping semantics, allowing expression of the same conceptual/logical relationships in terms of predicates or sets, i.e.

EvaluationLink PredicateNode: eat ListLink $X ConceptNode: food

has the same semantics as

MemberLink ListLink $X ConceptNode: food ConceptNode: EatingEvents

The relation between the predicate "eat" and the concept "EatingEvents" is formally given by

ExtensionalEquivalenceLink ConceptNode: EatingEvents SatisfyingSetLink PredicateNode: eat

In other words, we say that "EatingEvents" is the SatisfyingSet of the predicate "eat": it is the set of entities that satisfy the predicate "eat". Note that the truth values of MemberLink and EvaluationLink are fuzzy rather than probabilistic.

There is a host of link types embodying logical relationships as defined in the PLN logic system , e.g.

InheritanceLink

SubsetLink (aka ExtensionalInheritanceLink)

Intensional InheritanceLink

which embody different sorts of inheritance, e.g.

SubsetLink salmon fish IntensionalInheritanceLink whale fish InheritanceLink fish animal

and then

SimilarityLink

ExtensionalSimilarityLink

IntensionalSimilarityLink

which are symmetrical versions, e.g.

SimilarityLink shark barracuda IntensionalSimilarityLink shark dolphin ExtensionalSimiliarityLink American obese_person

There are also higher-order versions of these links, both asymmetric

ImplicationLink

ExtensionalImplicationLink

IntensionalImplicationLink

and symmetric

EquivalenceLink

ExtensionalEquivalenceLink

IntensionalEquivalenceLink

These are used between predicates and links, e.g.

ImplicationLink EvaluationLink eat ListLink $X dirt EvaluationLink feel ListLink $X sick

or

ImplicationLink EvaluationLink eat ListLink $X dirt InheritanceLink $X sick

or

ForAllLink $X, $Y, $Z ExtensionalEquivalenceLink EquivalenceLink $Z EvaluationLink + ListLink $X $Y EquivalenceLink $Z EvaluationLink + ListLink $Y $X

Note, the latter is given as an extensional equivalence because it’s a pure mathematical equivalence. This is not the only case of pure extensional equivalence, but it’s an important one.

There are also temporal versions of these links, such as

PredictiveImplicationLink

PredictiveAttractionLink

SequentialANDLink

SimultaneousANDLink

which combine logical relation between the argument with temporal relation between their arguments. For instance, we might say

PredictiveImplicationLink PredicateNode: JumpOffCliff PredicateNode: Dead

or including arguments,

PredictiveImplicationLink EvaluationLink JumpOffCliff $X EvaluationLink Dead $X

The former version, without variable arguments given, shows the possibility of using higher-order logical links to join predicates without any explicit variables. Via using this format exclusively, one could avoid VariableAtoms entirely, using only higher-order functions in the manner of pure functional programming formalisms like combinatory logic. However, this purely functional style has not proved convenient, so the AtomSpace in practice combines functional-style representation with variable-based representation.

Temporal links often come with specific temporal quantification, e.g.

PredictiveImplicationLink <5 seconds> EvaluationLink JumpOffCliff $X EvaluationLink Dead $X

indicating that the conclusion will generally follow the premise within 5 seconds. There is a system for managing fuzzy time intervals and their interrelationships, based on a fuzzy version of Allen Interval Algebra.

SequentialANDLink is similar to PredictiveImplicationLink but its truth value is calculated differently. The truth value of

SequentialANDLink <5 seconds> EvaluationLink JumpOffCliff $X EvaluationLink Dead $X

indicates the likelihood of the sequence of events occurring in that order, with gap lying within the specified time interval. The truth value of the PredictiveImplicationLink version indicates the likelihood of the second event, conditional on the occurrence of the first event (within the given time interval restriction).

There are also links representing basic temporal relationships, such as BeforeLink and AfterLink. These are used to refer to specific events, e.g. if X refers to the event of Ben waking up on July 15 2012, and Y refers to the event of Ben getting out of bed on July 15 2012, then one might have

AfterLink X Y

And there are TimeNodes (representing time-stamps such as temporal moments or intervals) and AtTimeLinks, so we may e.g. say

AtTimeLink X TimeNode: 8:24AM Eastern Standard Time, July 15 2012 AD

There are links representing associative, attentional relationships,

HebbianLink

AsymmetricHebbianLink

InverseHebbianLink

SymmetricInverseHebbianLink

These connote associations between their arguments, i.e. they connote that the entities represented by the two arguments occurred in the same situation or context, for instance

HebbianLink happy smiling AsymmetricHebbianLink dead rotten InverseHebbianLink dead breathing

The asymmetric HebbianLink indicates that when the first argument is present in a situation, the second is also often present. The symmetric (default) version indicates that this relationship holds in both directions. The inverse versions indicate the negative relationship: e.g. when one argument is present in a situation, the other argument is often not present.

There are nodes representing various sorts of procedures; these are kinds of ProcedureNode, e.g.

SchemaNode, indicating any procedure

GroundedSchemaNode, indicating any procedure associated in the system with a Combo program or C++ function allowing the procedure to be executed

PredicateNode, indicating any predicate that associates a list of arguments with an output truth value

GroundedPredicateNode, indicating a predicate associated in the system with a Combo program or C++ function allowing the predicate’s truth value to be evaluated on a given specific list of arguments

ExecutionLinks and EvaluationLinks record the activity of SchemaNodes and PredicateNodes. We have seen many examples of EvaluationLinks in the above. Example ExecutionLinks would be:

ExecutionLink step\_forward ExecutionLink step\_forward 5 ExecutionLink + ListLink NumberNode: 2 NumberNode: 3

The first example indicates that the schema "step forward" has been executed. The second example indicates that it has been executed with an argument of "5" (meaning, perhaps, that 5 steps forward have been attempted). The last example indicates that the "+" schema has been executed on the argument list (2,3), presumably resulting in an output of 5.

The output of a schema execution may be indicated using an ExecutionOutputLink, e.g.

ExecutionOutputLink + ListLink NumberNode: 2 NumberNode: 3

refers to the value "5" (as a NumberNode).

Finally, there are also Atom types referring to specific types of data important to using OpenCog in specific contexts.

For instance, there are Atom types referring to general natural language data types, such as

plus more specific ones referring to relationships that are part of link-grammar parses of sentences

or RelEx semantic interpretations of sentences

There are also Atom types corresponding to entities important for embodying OpenCog in a virtual world, e.g.

Truth Values and Attention Values

CogPrime Atoms (Nodes and Links) of various types are quantified with truth values that, in their simplest form, have two components, one representing probability (strength) and the other representing weight of evidence; and also with attention values that have two components, short-term and long-term importance, representing the estimated value of the Atom on immediate and long-term time-scales.

It is important to note that the CogPrime declarative knowledge representation is neither a neural net nor a semantic net, though it does have some commonalities with each of these traditional representations. It is not a neural net because it has no activation values, and involves no attempts at low-level brain modeling. However, attention values are very loosely analogous to time-averages of neural net activations. On the other hand, it is not a semantic net because of the broad scope of the Atoms in the network: for example, Atoms may represent percepts, procedures, or parts of concepts. Most CogPrime Atoms have no corresponding English label. However, most CogPrime Atoms do have probabilistic truth values, allowing logical semantics.

Glocal Memory

Now we move on from localized memory to the "glocal" coordination of local and global memory, which plays a large role in the OpenCog architecture. A glocal memory is one that transcends the global/local dichotomy and incorporates both aspects in a tightly interconnected way. The notion of glocal memory has implicitly occurred in a number of neural theories (without use of the neologism “glocal”), e.g. and , but was never extensively developed prior to the advent of CogPrime theory. In we describe glocality in attractor neural nets, a close analogue to CogPrime’s attention allocation subsystem.

Glocal memory overcomes the dichotomy between localized memory (in which each memory item is stored in a single location within an overall memory structure) and global, distributed memory (in which a memory item is stored as an aspect of a multi-component memory system, in such a way that the same set of multiple components stores a large number of memories). In a glocal memory system, most memory items are stored both locally and globally, with the property that eliciting either one of the two records of an item tends to also elicit the other one.

Glocal memory applies to multiple forms of memory; however we will focus largely on perceptual and declarative memory in our detailed analyses here, so as to conserve space and maintain simplicity of discussion.

The central idea of glocal memory is that (perceptual, declarative, episodic, procedural, etc.) items may be stored in memory in the form of paired structures that are called (key, map) pairs. Of course the idea of a “pair” is abstract, and such pairs may manifest themselves quite differently in different sorts of memory systems (e.g. brains versus non-neuromorphic AI systems). The key is a localized version of the item, and records some significant aspects of the items in a simple and crisp way. The map is a dispersed, distributed version of the item, which represents the item as a (to some extent, dynamically shifting) combination of fragments of other items. The map includes the key as a subset; activation of the key generally (but not necessarily always) causes activation of the map; and changes in the memory item will generally involve complexly coordinated changes on the key and map level both.

Memory is one area where animal brain architecture differs radically from the von Neumann architecture underlying nearly all contemporary general-purpose computers. Von Neumann computers separate memory from processing, whereas in the human brain there is no such distinction. Human memories are generally constructed in the course of remembering , which gives human memory a strong capability for “filling in gaps” of remembered experience and knowledge; and also causes problems with inaccurate remembering in many contexts e.g. We believe the constructive aspect of memory is largely associated with its glocality.

Neural-Symbolic Glocality in CogPrime

In CogPrime, we have explicitly sought to span the symbolic/emergentist pseudo-dichotomy, via creating an integrative knowledge representation that combines logic-based aspects with neural-net-like aspects. As reviewed above, these function not in the manner of a multimodular system, but rather via using (probabilistic logical) truth values and (attractor neural net like) attention values as weights on nodes and links of the same (hyper) graph. The nodes and links in this hypergraph are typed, like a standard semantic network approach for knowledge representation, so they’re able to handle all sorts of knowledge, from the most concrete perception and actuation related knowledge to the most abstract relationships. But they’re also weighted with values similar to neural net weights, and pass around quantities (importance values) similar to neural net activations, allowing emergent attractor/assembly based knowledge representation similar to attractor neural nets.

The concept of glocality lies at the heart of this combination, in a way that spans the pseudo-dichotomy:

Local knowledge is represented in abstract logical relationships stored in explicit logical form, and also in Hebbian-type associations between nodes and links.

Global knowledge is represented in large-scale patterns of node and link weights, which lead to large-scale patterns of network activity, which often take the form of attractors qualitatively similar to Hopfield net attractors. These attractors are called maps.

The result of all this is that a concept like “cat” might be represented as a combination of:

A small number of logical relationships and strong associations, that constitute the “key” subnetwork for the “cat” concept.

A large network of weak associations, binding together various nodes and links of various types and various levels of abstraction, representing the “cat map”.

The activation of the key will generally cause the activation of the map, and the activation of a significant percentage of the map will cause the activation of the rest of the map, including the key. Furthermore, if the key were for some reason forgotten, then after a significant amount of effort, the system would likely to be able to reconstitute it (perhaps with various small changes) from the information in the map. We conjecture that this particular kind of glocal memory will turn out to be very powerful for AGI, due to its ability to combine the strengths of formal logical inference with those of self-organizing attractor neural networks.

As a simple example, consider the representation of a “tower”, in the context of an artificial agent that has built towers of blocks, and seen pictures of many other kinds of towers, and seen some tall buildings that it knows are somewhat like towers but perhaps not exactly towers. If this agent is reasonably conceptually advanced (say, at Piagetan the concrete operational level) then its mind will contain some declarative relationships partially characterizing the concept of “tower,” as well as its sensory and episodic examples, and its procedural knowledge about how to build towers.

The key of the “tower” concept in the agent’s mind may consist of internal images and episodes regarding the towers it knows best, the essential operations it knows are useful for building towers (piling blocks atop blocks atop blocks...), and the core declarative relations summarizing “towerness” – and the whole “tower” map then consists of a much larger number of images, episodes, procedures and declarative relationships connected to “tower” and other related entities. If any portion of the map is removed – even if the key is removed – then the rest of the map can be approximately reconstituted, after some work. Some cognitive operations are best done on the localized representation – e.g. logical reasoning. Other operations, such as attention allocation and guidance of inference control, are best done using the globalized map representation.

Memory Types and Associated Cognitive Processes in CogPrime

Now we dig deeper into the internals of the CogPrime approach, turning to aspects of the relationship between structure and dynamics. Architecture diagrams are all very well, but, ultimately it is dynamics that makes an architecture come alive. Intelligence is all about learning, which is by definition about change, about dynamical response to the environment and internal self-organizing dynamics.

CogPrime relies on multiple memory types and, as discussed above, is founded on the premise that the right course in architecting a pragmatic, roughly human-like AGI system is to handle different types of memory differently in terms of both structure and dynamics.

CogPrime’s memory types are the declarative, procedural, sensory, and episodic memory types that are widely discussed in cognitive neuroscience , plus attentional memory for allocating system resources generically, and intentional memory for allocating system resources in a goal-directed way. Table [tab:opencog] overviews these memory types, giving key references and indicating the corresponding cognitive processes, and also indicating which of the generic patternist cognitive dynamics each cognitive process corresponds to (pattern creation, association, etc.). Figure [fig:mem t ypes] illustrates the relationships between several of the key memory types in the context of a simple situation involving an OpenCogPrime -controlled agent in a virtual world.

[fig:mem t ypes]

In terms of patternist cognitive theory, the multiple types of memory in CogPrime should be considered as specialized ways of storing particular types of pattern, optimized for spacetime efficiency. The cognitive processes associated with a certain type of memory deal with creating and recognizing patterns of the type for which the memory is specialized. While in principle all the different sorts of pattern could be handled in a unified memory and processing architecture, the sort of specialization used in CogPrime is necessary in order to achieve acceptable efficient general intelligence using currently available computational resources. And as we have argued in detail in [10], efficiency is not a side-issue but rather the essence of real-world AGI (since as Hutter has shown, if one casts efficiency aside, arbitrary levels of general intelligence can be achieved via a trivially simple program).

The essence of the CogPrime design lies in the way the structures and processes associated with each type of memory are designed to work together in a closely coupled way, yielding cooperative intelligence going beyond what could be achieved by an architecture merely containing the same structures and processes in separate “black boxes.”

The inter-cognitive-process interactions in OpenCog are designed so that

conversion between different types of memory is possible, though sometimes computationally costly (e.g. an item of declarative knowledge may with some effort be interpreted procedurally or episodically, etc.)

when a learning process concerned centrally with one type of memory encounters a situation where it learns very slowly, it can often resolve the issue by converting some of the relevant knowledge into a different type of memory: i.e. cognitive synergy

To put a little meat on the bones of the "cognitive synergy" idea mentioned above, we now elaborate a little on the role it plays in the interaction between procedural and declarative learning.

While MOSES handles much of CogPrime’s procedural learning, and CogPrime’s internal simulation engine handles most episodic knowledge, CogPrime’s primary tool for handling declarative knowledge is an uncertain inference framework called Probabilistic Logic Networks (PLN). The complexities of PLN are the topic of a lengthy technical monograph ; here we will eschew most details and focus mainly on pointing out how PLN seeks to achieve efficient inference control via integration with other cognitive processes.

As a logic, PLN is broadly integrative: it combines certain term logic rules with more standard predicate logic rules, and utilizes both fuzzy truth values and a variant of imprecise probabilities called indefinite probabilities. PLN mathematics tells how these uncertain truth values propagate through its logic rules, so that uncertain premises give rise to conclusions with reasonably accurately estimated uncertainty values. This careful management of uncertainty is critical for the application of logical inference in the robotics context, where most knowledge is abstracted from experience and is hence highly uncertain.

PLN can be used in either forward or backward chaining mode; and in the language introduced above, it can be used for either analysis or synthesis. As an example, we will consider backward chaining analysis, exemplified by the problem of a robot preschool-student trying to determine whether a new playmate “Bob” is likely to be a regular visitor to is preschool or not (evaluating the truth value of the implication '"`UNIQ--postMath-00000019-QINU`"'). The basic backward chaining process for PLN analysis looks like:

Given an implication '"`UNIQ--postMath-0000001A-QINU`"' whose truth value must be estimated (for instance '"`UNIQ--postMath-0000001B-QINU`"' as discussed above), create a list '"`UNIQ--postMath-0000001C-QINU`"' of (inference rule, stored knowledge) pairs that might be used to produce '"`UNIQ--postMath-0000001D-QINU`"' Using analogical reasoning to prior inferences, assign each '"`UNIQ--postMath-0000001E-QINU`"' a probability of success If some of the '"`UNIQ--postMath-0000001F-QINU`"' are estimated to have reasonable probability of success at generating reasonably confident estimates of '"`UNIQ--postMath-00000020-QINU`"'’s truth value, then invoke Step 1 with '"`UNIQ--postMath-00000021-QINU`"' in place of '"`UNIQ--postMath-00000022-QINU`"' (at this point the inference process becomes recursive)

If none of the '"`UNIQ--postMath-00000023-QINU`"' looks sufficiently likely to succeed, then inference has “gotten stuck” and another cognitive process should be invoked, e.g. Concept creation may be used to infer new concepts related to '"`UNIQ--postMath-00000024-QINU`"' and '"`UNIQ--postMath-00000025-QINU`"', and then Step 1 may be revisited, in the hope of finding a new, more promising '"`UNIQ--postMath-00000026-QINU`"' involving one of the new concepts MOSES may be invoked with one of several special goals, e.g. the goal of finding a procedure '"`UNIQ--postMath-00000027-QINU`"' so that '"`UNIQ--postMath-00000028-QINU`"' predicts whether '"`UNIQ--postMath-00000029-QINU`"'. If MOSES finds such a procedure '"`UNIQ--postMath-0000002A-QINU`"' then this can be converted to declarative knowledge understandable by PLN and Step 1 may be revisited.... Simulations may be run in CogPrime ’s internal simulation engine, so as to observe the truth value of '"`UNIQ--postMath-0000002B-QINU`"' in the simulations; and then Step 1 may be revisited....



The combinatorial explosion of inference control is combatted by the capability to defer to other cognitive processes when the inference control procedure is unable to make a sufficiently confident choice of which inference steps to take next. Note that just as MOSES may rely on PLN to model its evolving populations of procedures, PLN may rely on MOSES to create complex knowledge about the terms in its logical implications. This is just one example of the multiple ways in which the different cognitive processes in CogPrime interact synergetically; a more thorough treatment of these interactions is given in .

In the “new playmate” example, the interesting case is where the robot initially seems not to know enough about Bob to make a solid inferential judgment (so that none of the '"`UNIQ--postMath-0000002C-QINU`"' seem particularly promising). For instance, it might carry out a number of possible inferences and not come to any reasonably confident conclusion, so that the reason none of the '"`UNIQ--postMath-0000002D-QINU`"' seem promising is that all the decent-looking ones have been tried already. So it might then recourse to MOSES, simulation or concept creation.

For instance, the PLN controller could make a list of everyone who has been a regular visitor, and everyone who has not been, and pose MOSES the task of figuring out a procedure for distinguishing these two categories. This procedure could then used directly to make the needed assessment, or else be translated into logical rules to be used within PLN inference. For example, perhaps MOSES would discover that older males wearing ties tend not to become regular visitors. If the new playmate is an older male wearing a tie, this is directly applicable. But if the current playmate is wearing a tuxedo, then PLN may be helpful via reasoning that even though a tuxedo is not a tie, it’s a similar form of fancy dress – so PLN may extend the MOSES-learned rule to the present case and infer that the new playmate is not likely to be a regular visitor.

Goal-Oriented Dynamics in CogPrime

CogPrime’s dynamics has both goal-oriented and “spontaneous” aspects; here for simplicity’s sake we will focus more heavily on the goal-oriented ones, although both are important. The basic goal-oriented dynamic of the CogPrime system, within which the various types of memory are utilized, is driven by implications known as “cognitive schematics”, which take the form

'"`UNIQ--postMath-0000002E-QINU`"'

(summarized '"`UNIQ--postMath-0000002F-QINU`"'). Semi-formally, this implication may be interpreted to mean: “If the context '"`UNIQ--postMath-00000030-QINU`"' appears to hold currently, then if I enact the procedure '"`UNIQ--postMath-00000031-QINU`"', I can expect to achieve the goal '"`UNIQ--postMath-00000032-QINU`"' with certainty represented by truth value object '"`UNIQ--postMath-00000033-QINU`"'.” Cognitive synergy means that the learning processes corresponding to the different types of memory actively cooperate in figuring out what procedures will achieve the system’s goals in the relevant contexts within its environment.

CogPrime’s cognitive schematic is significantly similar to production rules in classical architectures like SOAR and ACT-R; however, there are significant differences which are important to CogPrime’s functionality. Unlike with classical production rules systems, uncertainty is core to CogPrime’s knowledge representation, and each CogPrime cognitive schematic is labeled with an uncertain truth value, which is critical to its utilization by CogPrime’s cognitive processes. Also, in CogPrime, cognitive schematics may be incomplete, missing one or two of the terms, which may then be filled in by various cognitive processes (generally in an uncertain way). A stronger similarity is to MicroPsi’s triplets; the differences in this case are more low-level and technical and are reviewed in [6].

Finally, the biggest difference between CogPrime’s cognitive schematics and production rules or other similar constructs, is that in CogPrime this level of knowledge representation is not the only important one. CLARION , as reviewed above, is an example of a cognitive architecture that uses production rules for explicit knowledge representation and then uses a totally separate subsymbolic knowledge store for implicit knowledge. In CogPrime, both explicit and implicit knowledge are stored in the same graph of nodes and links, with

explicit knowledge stored in probabilistic logic based nodes and links such as cognitive schematics (see Figure [fig:ExplicitKnowledge] for a depiction of some explicit linguistic knowledge.)

implicit knowledge stored in patterns of activity among these same nodes and links, defined via the activity of the “importance” values (see Figure [fig:ImplicitKnowledge] for an illustrative example thereof) associated with nodes and links and propagated by the ECAN attention allocation process

[fig:ExplicitKnowledge]

[fig:ImplicitKnowledge]

The meaning of a cognitive schematic in CogPrime is hence not entirely encapsulated in its explicit logical form, but resides largely in the activity patterns that ECAN causes its activation or exploration to give rise to. And this fact is important because the synergetic interactions of system components are in large part modulated by ECAN activity. Without the real-time combination of explicit and implicit knowledge in the system’s knowledge graph, the synergetic interaction of different cognitive processes would not work so smoothly, and the emergence of effective high-level hierarchical, heterarchical and self structures would be less likely.

Analysis and Synthesis Processes in CogPrime

The cognitive schematic '"`UNIQ--postMath-00000034-QINU`"' leads to a conceptualization of the internal action of an intelligent system as involving two key categories of learning:

Analysis : Estimating the probability '"`UNIQ--postMath-00000035-QINU`"' of a posited '"`UNIQ--postMath-00000036-QINU`"' relationship

: Estimating the probability '"`UNIQ--postMath-00000035-QINU`"' of a posited '"`UNIQ--postMath-00000036-QINU`"' relationship Synthesis: Filling in one or two of the variables in the cognitive schematic, given assumptions regarding the remaining variables, and directed by the goal of maximizing the probability of the cognitive schematic

To further flesh these ideas out, we will now use examples from the “virtual dog” application to motivate the discussion.

For example, where synthesis is concerned,

The MOSES probabilistic evolutionary program learning algorithm is applied to find '"`UNIQ--postMath-00000037-QINU`"', given fixed '"`UNIQ--postMath-00000038-QINU`"' and '"`UNIQ--postMath-00000039-QINU`"'. Internal simulation is also used, for the purpose of creating a simulation embodying '"`UNIQ--postMath-0000003A-QINU`"' and seeing which '"`UNIQ--postMath-0000003B-QINU`"' lead to the simulated achievement of '"`UNIQ--postMath-0000003C-QINU`"'. Example: A virtual dog learns a procedure '"`UNIQ--postMath-0000003D-QINU`"' to please its owner (the goal '"`UNIQ--postMath-0000003E-QINU`"') in the context '"`UNIQ--postMath-0000003F-QINU`"' where there is a ball or stick present and the owner is saying “fetch”.

PLN inference, acting on declarative knowledge, is used for choosing '"`UNIQ--postMath-00000040-QINU`"', given fixed '"`UNIQ--postMath-00000041-QINU`"' and '"`UNIQ--postMath-00000042-QINU`"' (also incorporating sensory and episodic knowledge as appropriate). Simulation may also be used for this purpose. Example: A virtual dog wants to achieve the goal '"`UNIQ--postMath-00000043-QINU`"' of getting food, and it knows that the procedure '"`UNIQ--postMath-00000044-QINU`"' of begging has been successful at this before, so it seeks a context '"`UNIQ--postMath-00000045-QINU`"' where begging can be expected to get it food. Probably this will be a context involving a friendly person.

PLN-based goal refinement is used to create new subgoals '"`UNIQ--postMath-00000046-QINU`"' to sit on the right hand side of instances of the cognitive schematic. Example: Given that a virtual dog has a goal of finding food, it may learn a subgoal of following other dogs, due to observing that other dogs are often heading toward their food.

Concept formation heuristics are used for choosing '"`UNIQ--postMath-00000047-QINU`"' and for fueling goal refinement, but especially for choosing '"`UNIQ--postMath-00000048-QINU`"' (via providing new candidates for '"`UNIQ--postMath-00000049-QINU`"'). They are also used for choosing '"`UNIQ--postMath-0000004A-QINU`"', via a process called “predicate schematization” that turns logical predicates (declarative knowledge) into procedures. Example: At first a virtual dog may have a hard time predicting which other dogs are going to be mean to it. But it may eventually observe common features among a number of mean dogs, and thus form its own concept of “pit bull,” without anyone ever teaching it this concept explicitly.



Where 