From OpenCog

Map Encapsulation and Expansion

Previous chapters focus primarily on the Atom level of representation and dynamics, commenting on the map level now and then but primarily leaving it implicit. There are two reasons for this: one theoretical, one pragmatic. The theoretical reason is that the majority of map dynamics and representations are implicit in Atom-level correlates. And the pragmatic reason is that, at this stage, we simply do not know as much about OCP maps as we do about OCP Atoms. Maps are emergent entities and, lacking a detailed theory of OCP dynamics, the only way we have to study them in detail is to run OCP systems and mine their System Activity Tables for information. If research goes well, then later versions of this wiki, revised to account for more extensive experimentation with more complete OCP versions, may include more details on observed map dynamics in various contexts.

In this chapter, however, we will briefly turn our gaze explicitly to maps and their relationships to Atoms, and discuss processes that convert Atoms into maps (expansion) and vice versa (encapsulation). These processes represent a bridge between the concretely-implemented and emergent aspects of OCP's mind.

In MindOntology:SMEPH terms, the encapsulation process is how OCP explicitly studies its own derived hypergraph and then works to implement this derived hypergraph more efficiently by recapitulating it at the concretely-implemented-mind level. This of course may change the derived hypergraph considerably. Among other things, it has the possibility of taking the things that were the most abstract, highest level patterns in the system and forming new patterns involving them and their interrelationships — thus building the highest level of patterns in the system higher and higher. Expansion, on the other hand, is critical in the case of ProcedureNodes, because it involves taking their internal Combo trees and expanding them into distributed processes involving multiple Nodes and Links — a process that, when enacted on a procedure P, enables PLN, attention allocation and other cognitive processes to work on P effectively, as well as increases the odds that P will occupy enough of the system's knowledge and resources to get a significant role in its derived hypergraph.

As of July 2008, this chapter is mainly prospective, describing plans for future implementation rather than existing code and work already done. Map expansion has been coded, but it is fairly trivial software-wise; the bigger job of map encapsulation still remains untouched in the July 2008 codebase. However, it won't require a lot of new implementation either: it will mainly be a matter of tuning, testing and generally experimenting. Implementation-wise, it just requires the creation of some special tables, and code for dynamically maintaining them, and then the application of other (already-described) cognitive processes to the problem of pattern-mining on them. The elegant side of the OCP design shows up here, in terms of the reuse of the same basic cognitive processes for multiple qualitatively different purposes.

In spite of their relative software simplicity in a OCP context, however, the philosophical essentialness of these issues should not be underestimated. As noted above, Atoms created via map encapsulation may then become involved in new maps, which may then be recognized and turned into Atoms. This process of map encapsulation is an important OCP manifestation of the general psynet-model principle that mind is a set of actors that create new actors embodying patterns recognized in and amongst one another. A map is a pattern recognizable amongst a set of Atoms over time; when this pattern is recognized and embodied as an Atom, the emergence of the AtomSpace is passing over into the concrete material making up the AtomSpace. According to the psynet model, any intelligent system is going to manifest this sort of iterative passage from emergence to concreteness somehow. How the brain does it, we really do not yet know. What we have done is to outline how such a thing may happen in the particular context of OCP. How well it will work in practice remains to be seen of course; but so far as we know, no other AI design has seriously addressed such issues.

The Significance of Map Encapsulation and Expansion

Let's start with the less interesting case: map expansion. Converting Atoms into maps is something that normally occurs only implicitly. For instance, a ConceptNode C may turn into a concept map if the importance updating process iteratively acts in such a way as to create/reinforce a map consisting of C and its relata. And we will shortly review another example, where an Atom-level InheritanceLink may implicitly spawn a map-level InheritanceEdge. However, there is one important case in which Atom-to-map conversion must occur explicitly: the expansion of compound ProcedureNodes into procedure maps. This must occur explicitly because the process graphs inside ProcedureNodes have no dynamics going on except evaluation; there is no opportunity for them to manifest themselves as maps, unless a MindAgent is introduced that explicitly does so. Of course, just unfolding a Combo tree into a procedure map doesn't intrinsically make it a significant part of the derived hypergraph — but it opens the door for the inter-cognitive-process integration that may make this occur.

Next, encapsulation may be viewed as a form of symbolization, in which the system creates concrete entities to serve as symbols for its own emergent patterns. It can then study an emergent pattern's interrelationships by studying the interrelationships of the symbol with other symbols. For instance, suppose one has three derived-hypergraph ConceptVertices A, B and C, and observes that:

InheritanceEdge A B
InheritanceEdge B C

Then encapsulation may create ConceptNodes A', B' and C' for A, B and C, and InheritanceLinks corresponding to the InheritanceEdges, where e.g. A' is a set containing all the Atoms contained in the static map A. First-order PLN inference will then immediately conclude:

InheritanceLink A' C'

and it may possibly do so with a higher strength than the strength corresponding to the (perhaps not significant) InheritanceEdge between A and C. But if the encapsulation is done right then the existence of the new InheritanceLink will indirectly cause the formation of the corresponding:

InheritanceEdge A C

via the further action of inference, which will use (InheritanceLink A' C') to trigger the inference of further inheritance relationships between members of A' and members of C', which will create an emergent inheritance between members of A (the map corresponding to A') and C (the map corresponding to C').

The above example involved the conversion of static maps into ConceptNodes. Another approach to map encapsulation is to represent the fact that a set of Atoms constitutes a map as a predicate; for instance if the nodes A, B and C are habitually used together, then the predicate P may be formed, where:

P =
   A is used at time T
   B is used at time T
   C is used at time T

The habitualness of A, B and C being used together will be reflected in the fact that P has a surprisingly high truth value. By a simple concept formation heuristic, this may be used to form a link AND(A, B, C), so that:

AND(A, B, C) is used at time T

This composite link AND(A, B, C) is then an embodiment of the map in single-Atom form.

Similarly, if a set of schemata is commonly used in a certain series, this may be recognized in a predicate, and a composite schema may then be created embodying the component schemata. For instance, suppose it is recognized as a pattern that:

   S1 is used at time T on input I1 producing output O1
   S2 is used at time T+s on input O1 producing output O2

Then we may explicitly create a schema that consists of S1 taking input and feeding its output to S2. This cannot be done via any standard concept formation heuristic; it requires a special process.

One might wonder why this Atom-to-map conversion process is necessary: Why not just let maps combine to build new maps, hierarchically, rather than artificially transforming some maps into Atoms and letting maps then form from these map-representing Atoms. It is all a matter of precision. Operations on the map level are fuzzier and less reliable than operations on the Atom level. This fuzziness has its positive and its negative aspects. For example, it is good for spontaneous creativity, but bad for constructing lengthy, confident chains of thought.