Representing and Using Knowledge with the Contextual Evaluation Model

TL;DR

The paper presents the Contextual Evaluation Model (CEM), a new knowledge representation framework that integrates facts, patterns, and sequences, demonstrated through an implementation called V5 with various applications.

Contribution

It introduces the CEM, a novel unified model for knowledge representation and manipulation, along with an implementation and algorithms for pattern learning and natural language understanding.

Findings

CEM effectively integrates facts, patterns, and sequences.

V5 demonstrates practical applications like voice recognition.

The model supports autonomous learning of simplified natural language.

Abstract

This paper introduces the Contextual Evaluation Model (CEM), a novel method for knowledge representation and manipulation. The CEM differs from existing models in that it integrates facts, patterns and sequences into a single contextual framework. V5, an implementation of the model is presented and demonstrated with multiple annotated examples. The paper includes simulations demonstrating how the model reacts to pleasure/pain stimuli. The 'thought' is defined within the model and examples are given converting thoughts to language, converting language to thoughts and how 'meaning' arises from thoughts. A pattern learning algorithm is described. The algorithm is applied to multiple problems ranging from recognizing a voice to the autonomous learning of a simplified natural language.

Tables

Item	Page	Short Description
AS	3.1	The aggregate set used with the opRAS and opRASM instructions.
$𝐁$	6	The binding set where all bindings reside.
binding	4	The associating of a non-null key set to a value point: [$p_1$ $p_1$ $\dots$$p_n$] = $p_{value}$.
$c_x$		A point residing in the context set $𝐂$.
$𝐂$	7	A collection of all points comprising the context.
EC	3.1	The contextual evaluation engine.
CEM	2	The abbreviation of the Contextual Evaluation Model.
chiral	16	A non-grounded point which is split into left hand and right hand parts.
complete	2.4	Evaluating a key set where the points in the key set exactly match the points in the binding.
context	7	An independent collection of points used with a contextual evaluation.
$\Delta$	6	$\Sigma$- $\overline{\Sigma }$
EC	3.1	The contextual evaluation engine.
$f$	5.6	A focus point used in determining whether or not a pattern is active.
fractional	7.1	The representation of is-a twines as fractions: $\frac{isa-point}{base-point}$.
grounded	15	A point that is grounded and can be related to a physical (sensed) object or property.
$𝕀$	1	The intelligence function that in this paper is defined as contextual evaluation.
incomplete	2.4	Evaluating a key set where some of the points required to match a binding are taken from the context.
intity	1	A contraction of intelligent+entity meaning an intelligent natural or man-made entity.
key set	3	A collection of 0 or more points enclosed with brackets ([$p_1$ $p_2$ $\dots$$p_n$].
LTT	9.4	The language-to-thought process.
$m_x$	1	A moment (in time) point that is often represented as $m(num$) where $num$ is a time value.
$mi{n}_{occurs}$	5.1	The minimum number of times a set of points has to occur in a pattern set ($𝕊$) to be considered a pattern.
$mi{n}_{points}$	5.1	The minimum number of points in a set to be considered for inclusion as a pattern.
MR	3.1	A miscellaneous collection of registers used by the V5 engine (see appendix B.3).
PPU	3.1	The point processing unit is the V5 equivalent of a CPU.
PQ	3.1	The print queue that is used for queuing points for output to the console via the opOUTPQ instruction.
PS	11	A point set.
$s_x$	14	A surrogate point.
$𝕊$	5.1	The set of points (i.e. ‘raw material’) used for finding patterns.
sequence	12	A tightly coupled ordered collection of points or loosely coupled collection of patterns defining a goal.
$\Sigma$	6	The sum of $p^{+}$ and $p^{-}$ points.
$\overline{\Sigma }$	6	The weighted average of $\Sigma$.
$t$	13	A thought point.
TC	3.1	The twine context used when creating twines via various V5 instructions.
tree	7.1	The representation of is-a twines as a graphical tree.
twine	10	A binding containing either a value or is-a variant in the key set.
variant	2.5	A variation of a normal point, either $p.i$ for is-a and $p.v$ for value-of.
$w$	5	The binding weight associated with a binding.

Equations

$$\mathbb{I}(q_m,s_m)\to q_{m+1}⟹\mathbb{I}(q_{m+1},s_{m+1})\to q_{m+2}⟹\dots$$

$$\mathbf{b}=({\left\{k^i\right\}}_{i=1}^n,{\left\{v^i\right\}}_{i=1}^{n^{\prime }},w)$$

$$\forall {\mathbf{b}}^i,{\mathbf{b}}^j\in \mathbf{B}\text{if}{\mathbf{b}}_k^i={\mathbf{b}}_k^j\text{then}i=j$$

$$E_s(\mathbf{B},\mathbf{K})={\mathbf{b}}_{v}where\mathbf{b}=\forall {\mathbf{b}}^i\in \mathbf{B}\text{if}{\mathbf{b}}_k^i=\mathbf{K}\text{then}{\mathbf{b}}^i$$

$$E_c(\mathbf{B},\mathbf{C},\mathbf{K})={\mathbf{b}}_v\text{where}\mathbf{b}=\arg \underset{\mathbf{b}\in \mathbf{B}}{\max }\left\{{\mathbf{b}}_w|{\mathbf{b}}_k\in (\mathbf{K}\cup \mathbf{C})\text{and}\mathbf{K}\in {\mathbf{b}}_k\right\}$$

$$E_c(\mathbf{B},\mathbf{C},\mathbf{K})={\mathbf{b}}_v\text{where}b=\arg \underset{\mathbf{b}\in \mathbf{B}}{\max }\left\{{\mathbf{b}}_w|{\mathbf{b}}_k\in \mathbf{C}\right\}$$

$$\displaystyle p^{\prime}<p\$$

$$\displaystyle p^{\prime}<p|c_{1},c_{2},\dots\$$

$$\displaystyle p>p^{\prime}\$$

$$\displaystyle p>p^{\prime}|c_{1},c_{2},\dots\$$

$$\displaystyle p:p^{\prime}\$$

$$\displaystyle p:p^{\prime}|c_{1},c_{2},\dots\$$

$$|a|\ge mi{n}_{points}$$

$$\sum _{i=1}^{|\mathbb{S}|}(\text{if}a\subset {\mathbb{S}}_i\text{then}1\text{else}0)\ge mi{n}_{occurs}$$

$$\left(\log \left(f\right)-5\times 10+0.5\right)\times 100+(\log (mag\times 1000/\sum mag)+0.05)$$

$${\Sigma }_m$$

$${\overline{\Sigma }}_m$$

$${\Delta }_m$$

$$\left\{\begin{array}{c}\frac{big}{s_1}\frac{red}{s_2}\frac{apple}{s_3}\end{array}\right\}⟹\left\{\begin{array}{c}\frac{bigredapple}{s_1}\end{array}\right\}$$

$$ist(context-of(‘SherlockHolmesStorie{s}^{\prime }),‘Holmesisadetectiv{e}^{\prime })$$

$$\frac{ab}{s_1}+\frac{cd}{s_2}⟹\frac{abcd}{s_1}$$

$$\frac{ab}{s_1}+\frac{cd}{s_2}⟹\frac{ab\frac{cd}{s_2}}{s_1}$$

Full text

**keywords: ** knowledge representation, artificial intelligence, context, natural language

1 Introduction

The Contextual Evaluation Model (CEM) is an expansion of Knowledge Representation (KR) models. KR has a long history going back to the beginning of artificial intelligence in the late 1950’s and early 1960’s with IPL and LISP and continuing into the present with projects such as Cyc and OWL [1, 2, 3, 4, 5, 6]. In all these models ‘knowledge’ is represented by ‘facts’ with the goal of using the facts in non-trivial ways. A classic example is taking two facts ‘All men are mortal’ and ‘Socrates is a man’ and deducing that ‘Socrates is mortal’.

It is our view that KR is the foundation upon which intelligence is constructed. For the purposes of this paper, intelligence is broadly defined as an ongoing process by which an intity111The word ‘intity’ is a contraction of ‘intelligent’ and ‘entity’. It will be used in this paper to refer to a natural or artificial intelligent entity. transitions from one moment to the next in such a manner that supports that intity’s ability to thrive. These moment-to-moment decisions of what-to-do-next are determined by both the intity’s knowledge and the changes to the intity’s physical environment as detected by the intity’s senses. Intelligence, as so defined, can be encapsulated by an intelligence function ($\mathbb{I}$) as shown in equation (1). It maps the intity’s state ($q_{m}$) and sensory input ($s_{m}$) at moment222The symbol $t$ while usually used to denote time will be later used to represent a thought. To avoid confusion, the symbol $m$ will be used to denote a moment in time. ($m$) to a new a new state ($q_{m+1}$) at moment $m+1$. Function $\mathbb{I}$ is then reevaluated at moment $m+1$ with new sensory input ($s_{m+1}$) to get state $q_{m+2}$, $\dots$.

[TABLE]

In (1) the state encompasses all the know-how, expertise, physical capabilities, actions, etc. required by the intity to exist and thrive. The sensory input reflects a snapshot of the intity’s current sensory experience of the physical world. KR, in this framework, is the combination of the state and sensory input ($q$ and $s$). Given this, the paper investigates two questions:

How should the $q$ and $s$ parameters of $\mathbb{I}$ be modeled? 2. 2.

What is function $\mathbb{I}$ and how would intelligence arise from its repetitive evaluation?

The first half of this paper is devoted to explaining the Contextual Evaluation Model. The model consists of five components: the point, key set, binding, context and the contextual evaluation operation. By the end of the first half, the reader will be familiar with the components of the model and how the CEM relates to the intelligence function ($\mathbb{I}$). Section 2 of this paper introduces the components the CEM. Section 3 describes the V5 engine, a virtual machine that implements the CEM. Various examples are presented illustrating important features of the model. Section 4 describes sequences: the ordering of points and actions. Sequences that sing a song, learn a maze and implement a Turing machine are presented. In section 5 an algorithm for learning patterns is given and tested against real world data in an example that recognizes voices. Section 6 discusses the modeling of pleasure and pain within the CEM/V5 framework.

Singing a song and running a maze, while interesting examples, do not make a convincing argument that the CEM shows intelligence for anything but the simplest forms of intelligence. Demonstrating that the CEM is a fitting model for all forms of intelligence is a daunting task; especially considering that there are no universally accepted tests for intelligence[7]. Instead, the remainder of the paper focuses on one form of intelligence that is unique to humans: thought and how it manifests as language. The second half of this paper investigates these questions:

What is a thought and how is it represented with the CEM? 2. 2.

What is the relationship between thought and language? 3. 3.

How can an intity learn a language?

Chapter 7 defines the thought and how thoughts relate to language and meaning. Section 8 describes how thoughts are converted to language. Section 10 deconstructs the language acquisition process into four steps: recognizing words, grounding words, syntax acquisition and thought-to-thought meaning. Each of these four steps is shown to be a variation of pattern learning as previously described in section 5.

Appendix A is a glossary and index of terms used in this paper. Appendix B contains tables detailing V5 commands, registers and instruction set. Appendixes C and D contain supplemental material referenced within the paper.

2 The Contextual Evaluation Model

The Contextual Evaluation Model (CEM) is a novel method for storing, retrieving and manipulating four classes of data:

• •

Factual data describing an attribute or component of something such as the name of a person, the temperature of an oven, the reason for an action.

• •

Pattern data that collectively can be used to recognize something.

• •

Sequence data that describe an ordered collection such as the letters in a word, the notes in a song, the steps required to achieve a goal.

• •

Contextual data that influence the interpretation of the above three classes of data.

The basics of the model and the contextual representation of facts are presented in this section. Sequences and patterns are covered in sections 4 and 5 following the introduction of requisite preliminary material.

2.1 Points, Key Sets, Bindings

Definition 1**.**

The point is the atomic unit of the CEM. A point represents something with no restriction as to what that something can be.

A point can represent an object, an idea, a number, a quality. It can represent something specific such as a particular person or an abstract concept such as love. A point can represent a class or category of things (dogs) or a specific instance of that class (your dog). A point can represent sensory input: a sound, visual input, an odor. A point may also trigger an action or movement, the generation of a sound, the transmission of a signal.

Definition 2**.**

Points created by external senses are called sensory points while points that trigger external actions are control points. All other points are internal points.

A point, other than representing something, in and of itself, conveys no additional information about that something (e.g. a point representing your dog does not convey any additional information about your dog or even that it is a dog).

Definition 3**.**

A key set is a set of zero or more points. A key set is denoted as a list of points enclosed in brackets, [$point_{1}$ $point_{2}$ \dots$$point_{n}]. The null key set ([ ]) is an empty key set.

Definition 4**.**

A binding is a key-value or attribute-value relationship between a non-null key set and a value set (of points).

A binding, $\mathbf{b}$, is a 3-tuple:

[TABLE]

where $\mathbf{b}_{k}$ is a key set, $\mathbf{b}_{v}$ is a set of value points and $\mathbf{b}_{w}$ is the binding weight.

Definition 5**.**

The binding weight is proportional to the number of points in the key set ($|\mathbf{b}_{k}|$), i.e. the greater the number of points in the key set the greater the binding weight.

When a value set consists of a single point then $\mathbf{b}_{v}$ will represent $\mathbf{b}_{v}^{1}$. A binding is notated as $keyset=value$: [$point_{1}$ $point_{2}$ \dots$$point_{n}] = $point_{value}$. The binding weight is normally automatically assigned using implementation dependent parameters.

2.2 Evaluation and Contextual Evaluation

Definition 6**.**

A binding set ($\mathbf{B}$) is a set of bindings.

Initially, only binding sets will be considered having the restriction that no two binding key sets are identical within the set333This restriction will be relaxed in subsequent sections.:

[TABLE]

A simple evaluation is a function that given a binding set ($\mathbf{B}$) and key set ($\mathbf{K}$) searches the binding set for a binding with the identical key set and returns that binding’s value:

[TABLE]

Definition 7**.**

A context ($\mathbf{C}$) is a separate dynamic set of points.

How points are inserted into the context and how they are removed from the context is implementation dependent. A more precise definition of the context is provided in sections 2.7 and 3.1. Equation (5) defines a contextual evaluation.

[TABLE]

and this simplifies to (6) when $\mathbf{K}$ is the null key set:

[TABLE]

For an analogy, consider a binding as locking a value with its key set points. The value cannot be obtained without all the keys. A simple evaluation is a search through $\mathbf{B}$ attempting to unlock a binding using all the keys in $\mathbf{K}$. A contextual evaluation searches for a binding with the greatest binding weight (largest number of locks) that is unlocked using all the keys in $\mathbf{K}$ and as many additional key points from the context $\mathbf{C}$ as is necessary. For both $E_{s}$ and $E_{c}$, if no binding is found the operation fails and the result is undefined.

Definition 8**.**

Going forward, evaluating a key set ($\mathbf{K})$ means evaluating $E_{c}(\mathbf{B},\mathbf{C},\mathbf{K})$ where $\mathbf{B}$ and $\mathbf{C}$ are assumed.

2.3 Examples

The statement ‘the boiling point of water is $100\degree$ Celsius’ could be represented with the binding [$p_{1}$ $p_{2}$ $p_{3}$]=$p_{v}$ where $p_{1}$ represents the attribute of the boiling point of something, $p_{2}$ represents water, $p_{3}$ represents the Celsius scale and $p_{v}$ represents $100\degree$. Greater clarity and understanding is obtained by replacing symbolic points ($p_{x}$) with descriptive labels. The same example becomes [$boilingPoint$ $water$ $celsius$]=100. Descriptive labels may optionally be enclosed in double quotes. Below are some binding examples:

• ‘Chocolate tastes good’ - [$chocolate$ $tastes$]=$good$
• ‘John thinks chocolate tastes bad’ - [$johnThinks$ $chocolate$ $tastes$]=$bad$
• ‘The meaning of life is 42 according to the Hitchhiker’s Guide to the Galaxy’ - [$meaningLife$ $HHGuide$]=42
• ‘the factorial of 5 is 120’ - [$factorial$ 5]=120
• ‘representation of the number 22 is “22”’ - [$representation$ 22] = ‘22’
• ‘representation of the number 22 in base 2’ - [$representation$ 22 $base2$] =‘’10110’

Given the above bindings and an empty context ($\mathbf{C}$= $\varnothing$) then the contextual evaluation of [$chocolate$ $tastes$] results in $good$. If the context contains the point $johnThinks$ then the evaluation of the same key set, [$chocolate$ $tastes$], results in $bad$. In this second evaluation, both bindings ([$chocolate$ $tastes$]=$good$ and [$johnThinks$ $chocolate$ $tastes$]=$bad$) satisfy the constraints but since the second binding has a higher binding weight (more points in the binding key set) it is selected.

2.4 Complete vs Incomplete Contextual Evaluations

The greater the number of points in a binding key set, the greater the binding weight and the greater the specificity of the binding. Your pet dog Fido might have multiple descriptions. In general if asked what Fido is, you would reply ‘a dog’. If you met your biology teacher in the park and he or she asked you would reply ‘a beagle’. But if your biology professor asked you in biology class you would reply ‘canis lupis familiaris’. Bindings describing these possible answers might be:

• [$whatIs$ $Fido$]=$dog$
• [$whatIs$ $Fido$ $profKnowItAll$]=$beagle$
• [$whatIs$ $Fido$ $profKnowItAll$ $biologyLecture$]=$CanisLupusFamiliaris$

In each instance, the same question, ‘What is Fido?’, is answered by evaluating the same key set [$whatIs$ $Fido$]. However, the context varies in each instance. If the context contains none of the points in this example the result is $dog$. But if you meet your professor outside of school ($profKnowItAll$ $\in$ $\mathbf{C}$) then the answer would be $beagle$ and if you met in biology class ($profKnowItAll$, $biologyLecture$ $\in$ $\mathbf{C}$) then it would be $CanisLupusFamiliaris$.

A complete evaluation is when the points in the key set are an identical match for the points in the binding key set (i.e. no points in the context were used). An incomplete evaluation is where one or more context points are required in finding a matching binding. The ability to perform incomplete evaluations allows for tremendous flexibility. Examples throughout this paper will demonstrate this flexibility.

2.5 Point Variants and Twines

Definition 9**.**

Every internal point has two variants notatated as: $point.i$ and $point.v$.

The first variant is for representing class membership or is-a membership, i.e. ‘x is a y’ as in ‘an apple is a fruit’. The second variant is for representing a quality of or attribute of something, i.e. ‘the x of y is z’ as in ‘the color of the apple is red’.

Definition 10**.**

A twine is a binding with a variant point in its key set. Only one point of a binding’s key set may be a variant.

Twines have an optional abbreviated notation. A simple is-a relationship is shown in (7a). The syntax in (7b) is used when other conditional/contextual points ($c_{i}$) are included:

[TABLE]

A similar notation is used for value-of twines. (8a) is the basic notation, (8b) is with additional points.

[TABLE]

If two points are doubly twined ($p$>$p^{\prime}$ and $p$<$p^{\prime}$) then the notation in (9a/b) can be used:

[TABLE]

As a general rule, the is-a twine is used to represent relationships and the value-of twine is evaluated to ‘retrieve’ a relationship value. For example, given $color$<$red$ and $red$<$ball$ (red is a color and the ball is red) then evaluating [$color.v$ $ball$] results in $red$ (the color of the ball is red).

2.6 Time

Time is an integral component of knowledge representation and should be included in an AI knowledge representation data model. With a couple of minor changes, time and the flow of time can easily and elegantly be represented in the CEM. The first change creates a time point with an associated magnitude that increments at a constant rate (e.g. every 100 milliseconds). The time point is always in the context. Secondly, the contextual evaluator ($E_{c}$) is modified such that bindings containing a time point will match if the time point in context has a magnitude equal to or greater than the time point in the binding. Thirdly, the binding weight of a binding containing a time point is based, in part, on the magnitude of the time point. Given two bindings each containing a time point and having identical other points then the binding with the greater time point would have the greater binding weight.

In the example below time is notated as m($n$) for the moment in time with magnitude $n$.

⬇

maritalStatus>single|John,m(100)

maritalStatus>married|John,m(200)

maritalStatus>divorced|John,m(300)

maritalStatus>remarried|John,m(400)

With a current time of $m(1000)$ in the context the evaluation of [$maritalStatus.v$ $John$] would return $remarried$. All four bindings would be potential matches but the last one with the largest time magnitude has the greatest binding weight. With time $m(350)$ in the context evaluating [$maritalStatus.v$ $John$] returns $divorced$.

2.7 More on Context and Evaluation of is-a Twines

The context consists of explicit and implicit points. The explicit points are those directly inserted into the context. The implicit points are obtained by evaluating the is-a twine for each point in the context. The results of successful evaluations are additionally added to the context. These is-a context points are linked to the base (explicit) point such that if the base point is removed from the context then any/all is-a points are also removed.

While most contextual evaluations have a single result (the binding with the highest weight), the is-a evaluations return all valid binding results not just the is-a binding with the highest weight. The exception to this is when multiple potential values differ only in the time point ($m$). In these cases the single binding with the highest time point is selected.

Figure 1(a) shows two explicit points in the context: {$Harry$,$m(1000)$}. Point $Harry$ has the following is-a twines represented as a tree444In the tree, nodes are points and branches are is-a twines. See section 7.1 for more on tree representations.: $man$<$Harry$, $human$<$man$, $married$<$Harry$|$m(100)$, $single$<$Harry$|$m(50)$ and $father$<$Harry$. The full context (explicit + implicit) is as shown in figure 1(b).

2.8 Relating the Intelligence Function ($\mathbb{I}$) to the CEM

The introduction posed two questions: what is the intelligence function and what are its arguments? Within the framework of the CEM, the intelligence function is the contextual evaluation function $E_{c}$ (equation 5). The sensory inputs ($s$) are the sense points injected into the context. The state ($q$) is a combination of the binding set and the non-sensory points in the context.

Figure 2 illustrates how an intity would utilize the CEM. Knowledge would be stored as bindings within the binding set ($\mathbf{B}$). The context ($\mathbf{C}$) is both referenced and updated by the contextual evaluation process. The context would also be updated periodically by the intity’s sensory input. Context control points dictate any external actions taken by the intity. Each evaluation of the null key set is the transition from one moment to the next.

Remaining to be demonstrated is how the CEM can effectively compute intelligent behavior. This will be accomplished with the help of the V5 language/engine and working examples.

3 The V5 Language and Engine

V5 is an experimental language and contextual evaluation engine. The low level language is similar to a machine language in that it consists of primitive opcodes that operate within a virtual machine. The machine is accessed through a command interpreter. The components of V5 are its point sets, the opcodes for the virtual machine and a suite of interpreter commands for defining points, loading point sets, running the interpreter and of course debugging. It is written in C and comprises approximately 6,000 lines of code.

The CEM consists solely of points. The sole data type of V5 is the point. There are no integers, floating point numbers or character strings and correspondingly no instructions that operate on those data types. There are only instructions to manipulate points, create bindings/twines and evaluate bindings. The minimalist design is intentional to explore the potential of the CEM.

Points in V5 can be dynamically created using instructions within V5 or points can be declared through the command interpreter using the ‘def’ command. This command creates a new point and associates a text label to the point. Every point has an internal reference number. When a point is output to the console, V5 checks to see if that point has a label. If so then the label is output. If the point has no label then the point is output as $\#nnn$ where $nnn$ is the hexadecimal value of the point’s reference number. Variants have ‘.v’ or ‘.i’ suffix. Surrogate points (see section 14) have a ‘?’ suffix.

Many code examples will be presented. In these examples, comments are enclosed in /* $\dots$*/. V5 output is displayed in boldface. Every line within an example is numbered starting with line 1. Examples may be interspersed with descriptive text. In this case the line numbers continue.

3.1 The Engine

Figure 4 shows a block diagram of the V5 engine and its relationship to the intelligence function ($\mathbb{I}$) and contextual evaluation function. The left-hand side consists of several register sets. These hold sets of points for various V5 instructions.

Definition 11**.**

The point set (PS) serves a dual function as a push down stack and as the context for the engine.

The context consists of all the points in the PS plus all is-a points off of these points, plus all is-a points off of the is-a points$\dots$ as explained in section 2.7. The is-a points for a point $p$ are determined by evaluating the is-a variant of that point ([$p$.i]) and then repeating for each resulting point of the evaluation. This continues until the evaluation fails (e.g. there are no more is-a points). Each evaluation is contextual and uses the points in the context at that instance. This is intentionally chaotic. Any given initial set of PS points may result in one of any number of different contexts due to the ordering and timing of the evaluations of all the possible is-a points. The aggregation set (AS) holds points used by the aggregate set reduce (opRAS and opRASM) instructions. Section 3.2.1 further describes the AS. The print queue (PQ) holds a set of points for output to the console. With the exception of debugging features, the PQ and related instructions are the only output mechanism in V5. The twine context (TC) is a set of points that are automatically inserted into a twine binding when the twine is created. The miscellaneous register set (MR) is a collection of special registers updated with the running of the engine. A list of these can be found in appendix B.3.

The point-processing-unit (PPU) executes V5 instructions. The contextual evaluator (EC) performs all contextual evaluations as requested from the PPU. The BS is the binding set for the engine. All bindings are maintained within the BS. Bindings are created and inserted into BS by the PPU. The command interpreter CI handles the interface via the console between the V5 engine and the user.

3.1.1 Operation

After the engine has been initialized with the necessary points and bindings the ‘run’ command is given to the command interpreter. This initiates the following:

Scan the points in the PS from top to bottom. 2. 2.

If the point is an opcode then remove it from the PS and execute it. 3. 3.

If the point is a register then replace it with the register’s current value. 4. 4.

If the point is a value variant then evaluate the key set ([$point$.v]). If the evaluation succeeds then remove the variant point and push the resulting value(s) onto the PS and continue with step #1.555Except if the result is a single point null. In this case nothing is pushed onto the PS. If any point pushed onto the PS is already in the PS then that instance is removed so that only the instance at the top of the PS remains. If the evaluation fails then leave the value variant unchanged in the PS. 5. 5.

Leave all other points in the PS unchanged. 6. 6.

Stop if there are no remaining instructions or value variants in the PS otherwise continue with step #1.

3.2 Commands and the Instruction Set

The engine interface is command driven. All user input begins with a command followed by command arguments. A list of V5 commands is found in appendix B.1.

V5 is an experimental system and many instructions have been implemented for various experiments. Appendix B.2 lists only the instruction opcodes used in the examples in this document. All instruction opcodes begin with lower case ‘op’ and end with an uppercase mnemonic. If an opcode ends with a lower case ‘t’ then it is identical to the opcode without the suffix. The suffix indicates that trace debugging output is to be performed when the opcode is executed. For example, the instruction opEVAL constructs and evaluates a key set while the instruction opEVALt performs the same action plus outputs trace information to the console. The naming convention for the processing registers (MR) is lower case ‘r’ followed with an upper-case mnemonic. For example, the opNEW instruction creates a new point and updates register rNEW with that new point. A list of the registers is found in appendix B.3.

3.2.1 Aggregate Set (AS) Reduction

The purpose of the AS is to perform evaluations on multiple contiguous pairs of points. It is used primarily for parsing natural language to thoughts and generating natural language from thoughts. The aggregate set (AS) may be loaded with a set of points using the opLASM instruction. The opcode opRASM performs the reduction operation as follows:

Starting at the left side of the AS, add two contiguous points (plus any is-a points) to the PS and evaluate the null key set. If the evaluation succeeds then temporarily hold the result along with the binding weight of the matched binding. 2. 2.

Move right one point and repeat the null key set evaluation again holding a success off to the side. 3. 3.

When all contiguous pairs have been evaluated then select the held binding with the highest binding weight. In the case of multiple bindings choose the left most one. 4. 4.

If any of the points in the binding are prefaced with a minus sign then remove the corresponding point from the AS. 5. 5.

Execute the value of the selected binding. This means to take all value points except for the last, insert into the PS and execute. Take the last value point and insert it into the AS at the point of the matched points (unless it is the $null$ point).

There are extended binding forms that can be used while performing AS reduction. Take the binding found in the example below:

⬇

bind +2 [-np/-noun] eoa,noun,noun.v,opEVAL,np.v,rEVAL,opTWISA,np.v

The weight of a binding is normally determined by the number of points in the binding key set. The ‘+2’ in the above example adds 2 to the weight of the binding giving it a higher precedence over other two-point bindings. The use of the minus sign before a point (-$np$, -$noun$) indicates that the point is to be removed from the AS if this binding is matched. The slash means that the ordering of the points matters. In this example an $np$ point followed by a $noun$ point would match. The reverse would not.

Normally a binding (other than value twine) is only allowed to have one value point. During AS reduction the multiple value points are pushed onto the PS a point at a time. If a point is an opcode then it is immediately executed. Note that pushing the value points from left to right onto a stack effectively reverses the ordering of the arguments.

The evaluation of [$p.v$] is a little different. The AS and all of its is-a points is first searched. If $p$ is located then [$p.v$] is taken as the root point.

After all value points have been handled, the last point (top of the PS) is pulled from the PS. If it is not the $null$ point then it is inserted into the AS at the point of the match.

3.3 Evaluation of [$p.v$] with Respect to the PS

The evaluation of a value variant ([$p.v$]) within V5 is not treated strictly as a CEM evaluation. V5 first examines the is-a points in the PS for an instance of $p$. If found then the value of [$p.v$] is taken as the root value of that is-a tree in the PS as the value. Otherwise the evaluation is performed as a normal CEM evaluation. Note that this only applies with the evaluation of [$p.v$] where $p.v$ is the only point of the key set. For example, if the PS contains {$a$,$b$,$c$} and $p$<$c$ then the evaluation of [$p.v$] results in $c$ ($c$ is-a an instance of $p$ within the current context).

3.4 Simple Examples

This example is about horses and four specific horses. Three of the horses: Pegasus, Mr. Ed and Seabiscuit666Pegasus is a mytholgical winged horse[9], Mr. Ed is a talking horse featured on a TV series of the same name[10], Seabiscuit is a famous race horse[11]. are defined as horses on line 5. The example examines whether or not horses can talk and fly. In general, they cannot as defined on line 7. But Mr. Ed is able to talk (8) and Pegasus can fly (9). Seabiscuit, while being very fast, can neither talk nor fly.

⬇

1def horse, Pegasus, MrEd, Seabiscuit

2def canTalk, canFly

3def yes, no

4

5twine horse<Pegasus,MrEd,Seabiscuit

6

7twine canTalk>no|horse ; canFly>no|horse

8twine canTalk>yes|MrEd,horse

9twine canFly>yes|Pegasus,horse

The evaluations below test the horses for special qualities.

⬇

10eval [canFly.v Seabiscuit]

11** result = no**

12eval [canTalk.v MrEd]

13** result = yes**

14eval [canFly.v Pegasus]

15** result = yes**

16eval [canTalk.v Pegasus]

17** result = no**

A new point is defined for Secretariat777A more recent racehorse without any special abilities other than to win races.[12].. The evaluation on line 19 fails. Why? Because the only knowledge about whether or not something can talk applies to horses and only if Secretariat is declared as a horse (line 21) will the evaluation succeed (line 22).

⬇

18def Secretariat

19eval [canTalk.v Secretariat]

20** ? No result found**

21Twine horse<Secretariat

22eval [canTalk.v Secretariat]

23** result = no**

4 Sequences

Definition 12**.**

A sequence is collection of bindings that define an ordering of points or a set of steps to accomplish a goal.

A sequence may be tightly coupled where the next point of the sequence directly follows the prior. Examples of tightly coupled sequences are: the letters of the alphabet; the letters in a word; the words in a sentence; the digits of $\pi$; the instructions in a computer program. Sequences that are loosely coupled are a collection of bindings defining steps/actions where the next step does not necessarily directly follow the current but from some other triggering context. Loosely coupled sequences are also known as goals. An example would be the goal of driving from home to the grocery store.

Sequences, being solely a collection of bindings do nothing in and of themselves. There is no necessary correlation between the ordering of bindings in a sequence and the resulting ordering of the sequence points. Performing a sequence requires an executing engine. Multiple sequences can be running concurrently. The following examples demonstrate how two concurrent sequences interact to print the spelling of a word. A step within a sequence may itself be the start of another sequence. And everything is contextual. There is tremendous flexibility in the definition and execution of sequences in the ever changing context of the real world.

4.1 Implementing and Running Sequences

There are many ways to represent sequences within the CEM. Suppose we want a sequence for the spelling of ‘book’. The first example below shows a sequence of four points ($sb1$, $sb2$, $sb3$, $sb4$). The twined value of $sb1$ are the two points "b" and $sb2.v$ (line 2). Evaluating [$sb1.v$] results in both "b" and $sb2.v$ being added to the PS. The V5 engine sees $sb2.v$, evaluates it and replaces it with "o" and $sb3.v$. This continues through $sb4$. Its evaluation, [$sb4.v$], is only "k" so after adding "k" to the PS the run is finished. The result is that the PS contains the points "k", "o" and "b". Recall that a given point may only occur once in the PS. That is why only one instance of "o" (line 9) is given. This sequence iterates through the spelling of ‘book’, but not in a particularly useful way.

⬇

1def sb1, sb2, sb3, sb4

2twine sb1>"b",sb2.v

3twine sb2>"o",sb3.v

4twine sb3>"o",sb4.v

5twine sb4>"k"

6ps sb1.v

7run

8show ps

9ps: "k", "o", "b"

The second example outputs the spelling of ‘book’. The evaluation starts with $sb1.v$ in the PS. It is evaluated and the letter ‘b’ is added to the print queue (line 1). It continues until [$sb4$.v] is evaluated and ‘k’ is added to the print queue and the contents of PQ are output to the console. The problem with this sequence is that it is only useful for spelling book and that the spelling is only output to the console. The spelling cannot be referenced in any other way.

⬇

1def sb1, sb2, sb3, sb4

2twine sb1>"b",opADDPQ,sb2.v

3twine sb2>"o",opADDPQ,sb3.v

4twine sb3>"o",opADDPQ,sb4.v

5twine sb4>"k",opADDPQ,opOUTPQ

6ps sb1.v

7run

8PQ(2): "b" "o" "o" "k"

The third example in this series demonstrates a more generalized and useful approach by having two sequences. One sequence is defined for the spelling of ‘book’. Then another sequence is defined that takes the first sequence (or any similar sequence) and outputs the spelling of the word to the console. The sequence points for the spelling are $b1$ through $b4$. They are linked through value twines (line 5). The sequence works/runs as follows: [$spell$ ‘book’] is bound to the first point ($b1$) of the sequence (line 4). The evaluation of [$b1.v$]) gives the next point ($b2$) of the sequence. Each of the points $b1$ through $b4$ has an is-a twine of the corresponding letter. (V5 automatically defines the letters of the alphabet and twines each letter to the $letter$ point: $letter$<‘a’, $letter$<‘b’, $\dots$). Therefore the evaluation of [$letter.v$] with $b1$ in the context results in ‘b’, with $b2$ in the context ‘o’, etc.

⬇

1def word,"book",spell,pEnd

2twine word<"book"

3def b1,b2,b3,b4

4bind [spell "book"] b1

5twine b1>b2 ; b2>b3 ; b3>b4 ; b4>pEnd

6twine "b"<b1 ; "o"<b2 ; "o"<b3 ; "k"<b4

7twine spell<b1,b2,b3,b4

The second sequence is defined by points $s$ through $s4$. The start of the sequence evaluates [$spell$ word] to get the starting sequence point for the spelling of the word. Line 10 uses the opcode opPSISAS to re-evaluate all of the is-a points in the PS so that the evaluation of $letter.v$ results in the letter for the current step in the word sequence. That letter is added to the print queue. Line 11 attempts to get the next sequence point of the word [$spell.v$]. If the evaluation results in the next sequence point of the word the opVAL instruction converts the point to its value variant which is then evaluated by the V5 engine. If that result is another $b_{n}$ point then $s4.v$ evaluates to $s2.v$. If it is $pEnd$ then the twine on line 13 is run, the spelling is output and the sequence terminates.

⬇

8def s,s2,s3,s4

9twine s>word.v,spell,eoa,opEVAL,rEVAL,s2.v

10twine s2>opPSISAS,letter.v,opADDPQ,s3.v

11twine s3>spell.v,opVAL,s4.v

12twine s4>s2.v

13twine s4>opOUTPQ | pEnd

14ps "book",opPSISAS,s.v

15run

16PQ(2): "b" "o" "o" "k"

The next section shows how context can be used to add a plural ending to a word. The spelling for ‘spy’ is defined just as ‘book’ was above using points $t1$, $t2$ and $t3$. At line 25 an alternative value for $t2.v$ is given in the context of $plural$. Instead of linking to $t3$ (‘y’) it links to $pEnd2$. The value of $s4$ is also redefined in the context of $plural$ and $pEnd2$ to add ‘ies’ to the PQ and then output the PQ to the console. Line 29 show the output for spelling the word ‘spy’ with the addition of plural to the context.

⬇

17twine word<"spy"

18def t1,t2,t3

19bind [spell "spy"] t1

20twine t1>t2 ; t2>t3 ; t3>pEnd

21twine "s"<t1 ; "p"<t2 ; "y"<t3

22twine spell<t1 ; spell<t2 ; spell<t3

23

24def pEnd2,"ies"

25twine t2>pEnd2 | plural

26twine s4>"ies",opADDPQ,opOUTPQ | pEnd2,plural

27ps "spy",plural,opPSISAS,s.v

28run

29PQ(2): "s" "p" "ies"

4.2 Singing a Song

Singing the first few notes of the song ‘Mary had a little lamb’ is the purpose of this example. Currently, V5 output is limited to console text so the singing is emulated by the outputting of pitch and lyrics with the proper timing. The example uses future time points to control the timing of the console output. If the PS contains a value variant and the twine defining the value contains a future moment (time) point ($p$>$value$|$m$(future-time)) then it will remain (unevaluated) in the PS until the current time is equal to or greater than the future-time in the twine binding.

This first section below defines the basic points of the song and song sequence. The points $n1$ through $n13$ are for the first 13 notes of ‘Mary had a little lamb’. Line 7 twines all the notes to the note point. Line 8 links each note to the subsequent note ($note_{n}.v$ $\rightarrow$ $note_{n+1}$). Line 10 associates the words/lyrics with each of the notes.

⬇

1def song,lyrics,note,songEnd

2twine songEnd>null

3def MarySong,Mar,ee,had,a,lit,tle,lamb

4twine song<MarySong

5twine lyrics<Mar,ee,had,a,lit,tle,lamb

6def n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13

7twine note<n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13

8twine n1>n2 ; n2>n3 ; n3>n4 ; n4>n5 ; n5>n6 ; n6>n7 ; n7>n8 ;

9 n8>n9 ; n9>n10 ; n10>n11 ; n11>n12 ; n12>n13 ; n13>songEnd

10twine Mar<n1 ; ee<n2 ; had<n3 ; a<n4 ; lit<n5 ; tle<n6 ; lamb<n7 ;

11 lit<n8 ; tle<n9 ; lamb<n10 ; lit<n11 ; tle<n12 ; lamb<n13

12twine MarySong>n1 /* n1 is first point in sequence */

The timings of the notes are specified below. The timing point is twined to different numbers of opINCT instructions based on the tempo and note type ($half$ or $qtr$/quarter notes). Line 23 twines $half$ or $qtr$ to each of the notes. The opINCT instruction increases the time point within the twine context set (TC).

⬇

13def timing,tempofast,temposlow,qtr,half

14twine timing>opINCT,opINCT,opINCT|qtr,tempofast

15twine timing>opINCT,opINCT,opINCT,opINCT,opINCT,

16 opINCT,opINCT,opINCT,opINCT,opINCT|half,tempofast

17twine timing>opINCT,opINCT,opINCT,opINCT,opINCT,

18 opINCT|qtr,temposlow

19twine timing>opINCT,opINCT,opINCT,opINCT,opINCT,

20 opINCT,opINCT,opINCT,opINCT,opINCT,opINCT,opINCT,

21 opINCT,opINCT,opINCT,opINCT,opINCT,opINCT,opINCT,

22 opINCT|half,temposlow

23twine qtr<n1 ; qtr<n2 ; qtr<n3 ; qtr<n4 ; qtr<n5 ; qtr<n6 ; half<n7 ;

24 qtr<n8 ; qtr<n9 ; half<n10 ; qtr<n11 ; qtr<n12 ; half<n13

Similarly, pitches are associated with each note. Each note now has two is-a twines: one for timing and one for pitch. The value (note.v) of each note links to the next note. Pitch is represented with a letter-number pair. Each letter (A-G) represents a note on the scale and the number corresponds to the octave above middle C. For example, the note B1 represents the B above middle C (C0).

⬇

25def pitch,a0,b0,c0,d0,e0,f0,g0,a1,b1,c1,d1,e1,f1,g1

26twine pitch<a0,b0,c0,d0,e0,f0,g0,a1,b1,c1,d1,e1,f1,g1

27twine b1<n1 ; a1<n2 ; g0<n3 ; a1<n4 ; b1<n5 ; b1<n6 ; b1<n7 ;

28 a1<n8 ; a1<n9 ; a1<n10 ; b1<n11 ; d1<n12 ; d1<n13

Below sets up another sequence to iterate through all the notes of a song (points $swt$ through $swt5$). Line 30 gets the first note of the sequence. This line also creates a new point to be used to distinguish one execution of this sequence from another. Line 31 gets the lyric and pitch associated with the current note and places each into the print queue. Then it outputs the queue and clears it. On line 32, $note.v$ results in the note, opVAL converts the note to its value variant. The evaluation of the value variant gives the next note. The next/new note is saved in working memory register 1 (opLWM1). If the next note is $songEnd$ then the next step is at line 34, otherwise at line 33 where $swt5$ is twined to $swt2.v$ to continue with the next note. This twine contains a future time point. Evaluations fail until the future time is reached (twine $swt5$>$swt2.v$|$instancepoint,m(future),note$).

⬇

29def swt,swt2,swt3,swt4,swt5

30twine swt>song.v,opVAL,opNEW,rNEW,swt2.v

31twine swt2>opPSISAS,lyrics.v,opADDPQ,pitch.v,opADDPQ,opOUTPQ,opCLRPQ,swt3.v

32twine swt3>opRCTX,timing.v,note.v,opVAL,opLWM1,rWM1,swt4.v

33twine swt4>opPSISAS,rWM1,opACTX,rNEW,opACTX,swt5,@swt2.v,opTWVAL,swt5.v

34twine swt4>opSTATE,songEnd,opVAL|songEnd

All the components of the sequences are now ready to run. The song is started by placing the song point, $MarySong$, into the PS along with the tempo point $tempSlow$ and the starting point for the sequence ($swt.v$). The output below shows the current moment (time) point enclosed in parentheses. The time delay between lyric-note output can be determined by taking the difference between two moment points. The delay between outputs is 6 (quarter notes) until ‘lamb’ (half notes) with a delay is 20. At the end of the sequence the opSTATE instruction (line 34) results in a debugging output line (50).

⬇

35ps MarySong,opPSISAS,temposlow,swt.v

36run

37PQ(2): Mar b1

38PQ(8): ee a1

39PQ(14): had g0

40PQ(20): a a1

41PQ(26): lit b1

42PQ(32): tle b1

43PQ(38): lamb b1

44PQ(58): lit a1

45PQ(64): tle a1

46PQ(70): lamb a1

47PQ(90): lit b1

48PQ(96): tle d1

49PQ(102): lamb d1

50state: ps: songEnd, opVAL, #338, temposlow

4.3 Running a Maze

A V5 sequence for running a simple T-maze is presented in this next example. The maze, shown in figure 5, is represented in V5 as a tree.

The section below defines the layout of the maze. In particular, the bindings on lines 5-9 define the linked right-hand and left-hand nodes at any given node. If a node has no left or right binding then going that direction at that node leads to a dead end.

⬇

1def node,success,isSuccess, n1,n2,n3,n4,n5, direction,left,right,nextDirection

2twine node<n1,n2,n3,n4,n5

3bind [success isSuccess] success

4bind [nextDirection left] right

5bind [n1 left] n2

6bind [n1 right] n3

7bind [n3 left] n4

8bind [n4 right] n5

9bind [n5 left] success

The maze running strategy is to begin with the left-hand side of a node (turn left). If that fails then try the right-hand side. If that fails then backtrack to the prior node and continue. If the maze is considered a tree then running the maze begins with the left most leaf and moves clockwise from leaf to leaf. Eventually it will hit the successful leaf and exit the maze.

The value of $pos$ ($pos.v$) is used to track the position within the maze. The time point ($m$) is included in the twine as the value will be changing. The twine on line 11 sets the initial position at node 1. Bindings will be created to keep track of the direction taken at a node [turn node] and to keep track of the prior node [prior node]. The latter is for use in backtracking.

⬇

10def pos, turn, prior

11twine pos>n1|rCTP

The logic for running the maze is below. Points $m1$ through $m7$ are for the main sequence loop, $mf1$ through $mf3$ are when a node fails, $mb1$ and $mb2$ are for backtracking to a prior node and $ms1$ through $ms5$ are for outputting the correct path on success. The first step is to determine the direction to turn at the current node ($pos.v$). The binding [node $pos$] is evaluated. If it succeeds then continue with line 16, otherwise continue at line 14 and perform the binding [node $pos$]=$left$ and start from the top. At line 16 the register rEVAL has the direction to turn (left or right). Evaluate [node direction] to get the next node. If that fails continue at $mf1$. If it succeeds and done with the maze then continue with $ms1$ otherwise set $pos.v$ to the new node (line 21) and continue back at $m1$.

⬇

12def m1,m2,m2a,m3,m4,m5,m6,m7, mf1,mf2,mf3, mb1,mb2, ms1,ms2,ms3,ms4,ms5

13twine m1>opINCCTP,pos.v,turn,eoa,opEVAL,m2.v

14twine m2>evalFail,opVAL,m2a.v|evalFail

15twine m2a>pos.v,turn,eoa,left,opBIND,m1.v

16twine m2>pos.v,rEVAL,eoa,opEVAL,m4.v

17twine m4>evalFail,opVAL,mf1.v|evalFail

18twine m4>rEVAL,opLWM1,isSuccess,rEVAL,eoa,opEVAL,m5.v

19twine m5>ms1.v

20twine m5>evalFail,opVAL,m6.v|evalFail

21twine m6>rWM1,prior,eoa,pos.v,opBIND,m7.v

22twine m7>pos,rWM1,opTWVAL,m1.v

The section below is executed when the evaluation of [node direction] fails. It attempts to get the direction currently associated with the node (line 23 and evaluate [nextDirection direction]. If that succeeds (i.e. [nextDirection left]=right) continue with $mf3$ and bind [turn node] to the new direction and continue with $m1$. If it fails then both directions failed at the node and backtracking needs to be done ($mb1$).

⬇

23twine mf1>pos.v,turn,eoa,opEVAL,mf2.v

24twine mf2>rEVAL,nextDirection,eoa,opEVAL,mf3.v

25twine mf3>pos.v,turn,rCTP,eoa,rEVAL,opBIND,m1.v

26twine mf3>evalFail,opVAL,mb1.v|evalFail

Backtracking is simple. Evaluation of [node $prior$] gives the prior node ($mb1$). Set the current position to this node ($mb2$) and continue back at $mf1$.

⬇

27twine mb1>pos.v,prior,eoa,opEVAL,mb2.v

28twine mb2>pos,rEVAL,opTWVALt,mf1.v

The next portion of the sequence outputs the correct path through the maze. Set the current node ($pos.v$) back to the first node ($n1$). Evaluate the correct turn for the node, output the node and turn ($ms3$). Then continue with the next node. If there is no next node then the traversal through the maze is complete and the sequence is finished.

⬇

29twine ms1>pos,n1,opTWVAL,ms2.v

30twine ms2>pos.v,turn,eoa,opEVAL,ms3.v

31twine ms3>opCLRPQ,pos.v,opADDPQ,rEVAL,opADDPQ,opOUTPQ,ms4.v

32twine ms3>evalFail,opVAL|evalFail

33twine ms4>pos.v,rEVAL,eoa,opEVAL,ms5.v

34twine ms5>opINCCTP,pos,rEVAL,opTWVAL,ms2.v

Running the sequence is done by initializing the PS with the current position ($pos.v$) to $n1$ and then running the V5 engine. The solution to the maze is then output.

⬇

35ps pos,n1,opTWVAL,m1.v

36run

37PQ(15): n1 right

38PQ(16): n3 left

39PQ(17): n4 right

40PQ(18): n5 left

4.4 A Turing Machine

This example constructs a Turing machine[13] to demonstrate that V5 is Turing complete and that, in theory, any computable function can be implemented with V5.888This is not to suggest that V5 is suitable for general purpose computing[14]. An overview of the example is below:

• •

The infinite tape is implemented as a series of linked points as described in figure 7. The tape, at any given point is finite in size. When the tape is positioned past the last tape cell on the right, a new tape cell is automatically allocated and appended to the tape.

• •

The states of this (simple) machine are declared points: $sInit$ and $sHalt$.

• •

Actions are defined with bindings with sdcn points as shown in figure 6.

• •

The machine operates much like any other Turing machine. It repeatedly reads the contents of the current cell, uses that value with the current state to determine the new tape cell contents, new tape position and new state. The machine halts when its current state is $sHalt$.

The V5 commands to define points will no longer be included in the examples. The ‘set autodef’ command below instructs the V5 command interpreter to automatically define any new point it encounters.

⬇

1set autodef on

The machine runs as follows:

• $tm1$- get the contents of the current tape position in rEVAL
• $tm2$ - eval [tape content current state] to get the next sdc (new state, tape direction, new tape contents) point
• $tm3$ - twine $curSDC$>new $sdc$ (in rEVAL)
• $tm4$ - eval [$sdc$ $newTapeContent$] for new tape contents
• $tm5$ - set the new tape contents
• $tm6$ - evaluate [$sdc$ $tapeMove$] to see which direction to move
• $tm7$ - move the tape to $tm8$ on line 9 if the tape cell exists, or line 16 if the tape cell does not exist and needs to be created

⬇

2twine tm1>curPos.v,contents,eoa,opEVAL,tm2.v

3twine tm2>rEVAL,curState.v,sdc,eoa,opEVAL,tm3.v

4twine tm3>curSDC,rEVAL,opTWVAL,tm4.v

5twine tm4>curSDC.v,newTapeContent,eoa,opEVAL,tm5.v

6twine tm5>contents,curPos.v,rCTP,eoa,rEVAL,opBIND,tm6.v

7twine tm6>curSDC.v,tapeMove,eoa,opEVAL,tm7.v

8twine tm7>curPos.v,rEVAL,eoa,opEVAL,tm8.v

• $tm8$ - twine $curPos$>new tape position
• $tm9$ - eval [sdc $newState$] for the new $sdc$
• $tm10$ - twine $curState$>new state
• $tm11$ - force an increment of the time point
• $tm12$ - check to see if the new state is $sHalt$, goto line 15 if yes, line 14 if not
• $tm13$ - either resume loop at $tm1$ or leave with $sHalt$ in the PS if done

⬇

9twine tm8>curPos,rEVAL,opTWVAL,tm9.v

10twine tm9>curSDC.v,newState,eoa,opEVAL,tm10.v

11twine tm10>curState,rEVAL,opTWVAL,tm11.v

12twine tm11>opINCCTP,tm12.v

13twine tm12>curState.v,checkHalt,eoa,opEVAL,tm13.v

14twine tm13>evalFail,opVAL,tm1.v|evalFail

15twine tm13>sHalt

When a tape move to the right fails the section below is run.

• $tm8$ - clear out the $evalFail$ point and create a new tape cell point
• $tm8a$ - link the current last tape cell to the new point
• $tm8b$ - left link the new cell to prior last cell
• $tm8c$ - define $moveNone$ to remain on current new cell
• $tm8d$ - set the contents of new cell to $tBlank$
• $tm8e$ - set the current tape position to the new cell
• $tm8f$ - resume at $tm9$ above

⬇

16twine tm8>evalFail,opVAL,opNEW,tm8a.v|evalFail

17twine tm8a>curPos.v,moveRight,eoa,rNEW,opBIND,tm8b.v

18twine tm8b>rNEW,moveLeft,eoa,curPos.v,opBIND,tm8c.v

19twine tm8c>rNEW,moveNone,eoa,rNEW,opBIND,tm8d.v

20twine tm8d>rNEW,contents,eoa,tBlank,opBIND,tm8e.v

21twine tm8e>curPos,rNEW,opTWVAL,tm8f.v

22twine tm8f>tm9.v

The points $sdc1$ and $sdc2$ are used to define the new state, tape move direction and new tape contents based on the current state and tape contents. Line 23 defines the sdc ($sdc1$) if state is $SInit$ and tape contents is $tBlank$.

⬇

23bind [sInit tBlank sdc] sdc1

24bind [sdc1 newTapeContent] tX

25bind [sdc1 tapeMove] moveNone

26bind [sdc1 newState] sInit

27

28bind [sInit tX sdc] sdc2

29bind [sdc2 newTapeContent] tX

30bind [sdc2 tapeMove] moveRight

31bind [sdc2 newState] sHalt

The following lines define the initial tape. It consists of one cell containing $tBlank$. Each cell is left and right linked to its previous/next cell. If there is no right link then that cell is last cell to the right (and a new cell will be automatically appended if necessary).

⬇

32bind [tPos1 contents rCTP] tBlank

33bind [tPos1 moveLeft] tPos1

34bind [tPos1 moveNone] tPos1

The sequence is now ready to execute. First define the current state as $sInit$ (line 35), then twine the current tape position to $tPos1$ (line 37), add the staring sequence point ($tm1$) to the PS and run.

⬇

35ps curState,sInit,opTWVAL

36run

37ps curPos,tPos1,opTWVAL

38run

39ps tm1.v /* Start running with tm1 */

40run

41show ps

42ps: sHalt

4.5 Recapping Tightly Coupled Sequences

All of the sequences described thus far have been tightly coupled sequences, i.e. the next point in a sequence is determined by the prior point. Defining tightly coupled sequences with contextual twines has several benefits:

Multiple sequences can be running simultaneously as demonstrated with the prior examples. 2. 2.

The order in which sequence twines are created is independent of the order in which they are executed. This may become useful with the incremental learning of sequences. 3. 3.

All evaluations are contextual and that offers tremendous flexibility when running sequences in a variety of contexts. 4. 4.

The V5 engine is always doing next whatever is most appropriate. It is not explicitly running a sequence as a traditional computer would run a subroutine or function.

4.6 Loosely Coupled Sequences (aka Goals)

A loosely coupled sequence is a collections of bindings that collectively work to achieve a (long term) goal. Sequences that operate (apply) over long time periods and usually invoke other (sub)sequences are loosely coupled. An example would be the sequence/goal of grocery shopping. The steps to achieve this goal are:

Get the shopping list 2. 2.

Go to the grocery store 3. 3.

Purchase the items on the list 4. 4.

Go home 5. 5.

Put the groceries away

The twines and bindings to achieve this goal will differ from the twines used in the tightly coupled sequences. Patterns will be used instead of linked twine points. The V5 code below gives a possible example of how this might be done. The goal point used is $doShopping$. Line 1 is the binding to start the shopping. It invokes the sequence $getShoppingList$. The actions for this sequence would be defined separately and would depend on many factors such as, does the list already exist or not. The step in achieving the goal would be triggered by recognizing the pattern (see section 5) [$haveShoppingList$ $doShopping$]. When this is recognized the sequence $gotoGroceryStore$ is triggered. These patterns $\Rightarrow$ sub-action continue until the goal is satisfied.

⬇

1bind [start doShopping] getShoppingList.v

2bind [haveShoppingList doShopping] gotoGroceryStore.v

3bind [atGroceryStore doShopping] purchaseItems.v

4bind [haveGroceryItems doShopping] goHome.v

5bind [atHome withGroceries doShopping] putAwayGroceries.v

6bind [groceriesPutAway doShoping] shoppingGoalFinished.v

5 Patterns

A pattern is a binding that is used to recognize something. In the CEM framework a pattern would consist primarily of sensory points: auditory to recognize a sound, visual to recognize an object, tactile to recognize a touch, etc. A pattern is represented as a binding: [$r_{1}$ $r_{2}$ $\dots$] = $r_{thing}$ where $r_{n}$ are the recognition descriptor points and $r_{thing}$ is the point that is recognized.

In the CEM, everything is a point and all points are treated identically. Therefore it is possible to mix sensory modes. For example visual and smell points could be used in combination. Sensory and internal points may be combined.

5.1 Learning Patterns

A sample ($\mathbb{S}$) is a set of sets of points, typically sense points. A pattern ($a$) within $\mathbb{S}$  is a set of points satisfying the following two conditions: the cardinality of $a$ is greater than or equal to a minimum number of points $min_{points}$ (equation 11); and that $a$ is a subset of at least $min_{occurs}$ sets within $\mathbb{S}$(equation 11).

[TABLE]

[TABLE]

Patterns are found within $\mathbb{S}$ with the following algorithm: Intersect each set in $\mathbb{S}$ with all the other sets within $\mathbb{S}$ saving all resulting sets with a cardinality greater than or equal to $min_{points}$ as new set of sets, $\mathbb{A}$. Then count the number of times any given set occurs within $\mathbb{A}$. Any set within $\mathbb{A}$ that occurs at least $min_{occurs}$ times is considered a pattern and a binding is created with the key set consisting of points in the set and the value being a new internal point.

It may be necessary to perform the pattern learning process multiple times. If none of the saved intersected sets occur at least $min_{occurs}$ times then repeating the learning process on the intersected sets will result in one or more patterns, if any patterns are to be found.

As an example, appendix C shows a set of sets. Each set contains approximately 20 points with each point represented as an integer number between 0 and 999. There are 40 rows of points. The challenge is to determine whether or not a pattern exists within these 40 rows where, for this example, a pattern is defined as a set of at least 5 points ($min_{points}$) found in at least 5 ($min_{occurs}$) rows.

The first step is to intersect each row with all of the others. With 40 rows this requires ${}_{n}C_{r}$ =${}_{40}C_{2}$ = $\frac{40!}{(40-2)!\times 2!)}$ = $780$ intersections. Figure 8(a) shows the results of the intersections where the cardinality of the result is at least 3 points. Figure 8(b) shows a consolidated result by set. The first two columns are the lines within the data, the third column shows the points resulting from the intersection of the two lines. There are 7 occurrences of {101 211 307 401 503 601}. While this count exceeds the $min_{occurs}$(5), it is not the count of occurrences in the first set. If a pattern occurs $n$ times then the number of intersections after the first pass would be $\frac{n\times(n-1)}{2}$, giving 10 for $n=5$.999Or given the number of sets after the intersections ($x$) then $\frac{1\pm\sqrt{1+8x}}{2}$ is the maximum value of $min_{occurs}$possible for a pattern. The additional pass through the aggregated sets adding in for any set that is a super-set gives a final count of 10 (the pattern occurs 5 times in the original data set). Thus a new binding would be created [101 211 307 401 503 601]=$p_{new}$ and those points are now recognized as point $p_{new}$.

5.2 Patterns in Sequences

The patterns mentioned so far have not depended on any type of point ordering. But in many cases, the ordering of points does matter. A pattern to recognize the word ‘tea’ cannot be represented with the binding [$t$ $e$ $a$] = $tea$ because the ordering of points in a binding is irrelevant. This binding for ‘ate’ would be [$a$ $t$ $e$] = $ate$. The key sets [$t$ $e$ $a$] and [$a$ $t$ $e$] are equivalent.

One way to get around this problem and be able to recognize a specific sequence is to have incremental bindings for each subsequent point in a sequence. For example ‘tea’ would be represented with the points $\vdash t\ e\ a\dashv$ ($\vdash$ and $\dashv$ indicate begin and end of word). The following bindings would be used: [$\vdash$ $t$]=$r_{1}$, [$r_{1}$ $e$]=$r_{2}$, [$r_{2}$ $a$]=$r_{3}$ and finally [$r_{3}$ $\dashv$]=$tea$.

Another approach is to encode the points with additional positional information. For instance encoding ‘tea’ would be with [$t$ $pos1$]=$t_{1}$, [$e$ $pos_{2}$]=$e_{2}$ and [$a$ $pos_{3}$]=$a_{3}$ and [$t_{1}$ $e_{2}$ $a_{3}$]=$tea$. The recognition of ‘eat’ would be [$e_{1}$ $a_{2}$ $t_{3}$]=$eat$.

Some sequences may be recognized by a combination of points of different modalities. A melody consists of a sequence of notes with each note having a pitch and duration. The points representing the beginning of a melody would be the set of points $p_{1}$, $d_{1}$, $p_{2}$, $d_{2}$, $\dots$ where $p_{x}$ is the pitch for the $x^{th}$ note and $d_{x}$ is the duration. A recognition binding for the (beginning) of the melody would be [$p_{1}$ $d_{1}$ $p_{2}$ $d_{2}$ $\dots$] = $melody$ where $melody$ is the point recognized as the beginning of the melody. The start of the recognition pattern need not necessarily be only the first few notes, it could anywhere throughout the melody. Pitch and duration are just two qualities that are used to recognize a melody. Orchestration and harmonic structure might also be included in the recognition binding.

5.3 Embedded Patterns within Patterns

A set of points that represent a pattern may also contain the points of one or more other patterns. Consider the two patterns [$p_{1}$ $p_{2}$ \dots$$p_{n} $q_{1}$ $q_{2}$ \dots$$q_{n^{\prime}}] = $a_{main}$ and [$p_{1}$ $p_{2}$ \dots$$p_{n}] = $a_{sub}$. The points of the second pattern are found within the first. When this situation occurs the resulting pattern points are twined. In this case, the twine $a_{sub}$:$a_{main}$ would be created.

An example of this is the recognition of a visual object as a red ball (i.e. a set of visual points is recognized as a discrete object point $obj$). Within the points recognizing $obj$ are the points recognizing the properties of $red$ and $ball$, therefore $red$:$obj$ and $ball$:$obj$.

5.4 The Recognition of a Pattern

When a pattern is recognized from a set of points the resulting pattern point is inserted into the PS with its value variant. For example if the pattern [$p_{1}$ $p_{2}$ \dots$$p_{n}] = $a_{r}$ is recognized then $a_{r}.v$ is added to the PS, not $a_{r}$.

5.5 An Experiment with Voice Recognition

An experiment was performed to determine if the pattern recognition process could be used in a real world example. A voice sample recorded as a standard WAV file[15] was converted to a set of points and put through the pattern learning process. Bindings were created for all learned patterns. Then other test WAV files were similarly converted to sets of points. These test points were inserted into the context and the null key set was evaluated. A successful evaluation indicated that the test points were matched by a previously learned pattern. A failure indicated no pattern.

The WAV files used in this experiment were first pre-processed using the FFT algorithm101010FFT or Fast Fourier Transform is an efficient algorithm for converting a time domain signal into the frequency domain[16, Chapters 12-13] into encoded fft files, a text file consisting of one line per sample of the WAV file. In this experiment the sample duration is $\frac{1}{8}$ of a second. The preprocessing requires two passes through the file. In the first pass, each sample of the WAV file was processed with the FFT. The resulting frequency/magnitude buckets were converted to four digit numbers as shown in (12).

[TABLE]

where $f$ is the frequency (0-99), $mag$ is the magnitude (0-99). Per FFT convention the magnitude is calculated from the real ($mag_{r}$) and imaginary ($mag_{i}$) parts: $\sqrt{(mag_{r})^{2}+(mag_{i})^{2})}$ This four digit number is then saved in a bin along with the count of the number of times that number was seen.

The second pass is similar to the first except that an output file was created for all samples that occurred more than once. Below is a sample of an fft file. Each line represents an encoding of the spectral analysis of a $\frac{1}{8}$ second sample. Each four digit number represents a frequency and magnitude ($f\times 100+m$). Figure 9 shows the first few lines of a preprocessed WAV file.

The second part of this experiment was finding any patterns in a test fft file by first converting each four digit frequency-magnitude into a point using a simple dictionary mapping four-digit numbers to points. Then the pattern learning process as described in section 5.1 was performed. The resulting sets of points were bound to a single recognition point. Below is a sample output of the recognition process. Lines 1-2 show the learning phase with the training file (FV1MessageMenu.fft).

After any patterns were found, tests were performed using WAV files from the same speaker and different speakers. Lines 3-4 show the result of the first test: 96% of the lines resulted in a successful evaluation indicating a strong resemblance between the file and the training file. Compare this with lines 9-10 showing very few successful evaluations.

⬇

1w: 0.0 c: 0.0 - Starting pattern search phase

2w: 68.6 c: 68.6 - Created 2744 bindings

3w: 68.6 c: 68.6 - Starting scan of test file (\vic\fft\samples\FV1MessagesUndeleted.fft)

4w: 68.7 c: 68.6 - 26 matches (96%) in 27 lines

5w: 68.7 c: 68.6 - Starting scan of test file (\vic\fft\samples\see_ya.fft)

6w: 68.7 c: 68.6 - 0 matches (0%) in 11 lines

7w: 68.7 c: 68.6 - Starting scan of test file (\vic\fft\samples\FV1recordAfterTone.fft)

8w: 68.7 c: 68.6 - 33 matches (91%) in 36 lines

9w: 68.7 c: 68.6 - Starting scan of test file (\vic\fft\samples\VN_UrgentPager_3.fft)

10w: 68.7 c: 68.6 - 3 matches (3%) in 83 lines

5.6 Focus

In the ‘real world’ all senses are simultaneously and continuously updating the context. It would be desirable to have the ability to limit recognition to only one sensory mode (e.g. visual versus auditory) or a subset of a mode (e.g. words on a page rather than the page itself). This is trivially achieved with the addition of discriminating or focus points. For example, assume a visual object ($o_{v}$) is recognized by the visual points $v_{1}$, $v_{2}$, $\dots$([$v_{1}$ $v_{2}$ $\dots$] = $o_{v}$) and a sound ($o_{s}$) is recognized with the binding [$s_{1}$ $s_{2}$ $\dots$] = $o_{s}$. If the context includes both sets of points {$v_{1}$,$v_{2}$,$\dots$,$s_{1}$,$s_{2}$,$\dots$} then either/both $o_{v}$ or $o_{s}$ could be recognized. However, if we included focus points, $f_{x}$ in each of these bindings giving [$f_{v}$ $v_{1}$ $v_{2}$ $\dots$] = $o_{v}$ and [$f_{s}$ $s_{1}$ $s_{2}$ $\dots$] = $o_{s}$ then it would be possible to control or focus on visuals or sounds with the inclusion of either $f_{v}$ or $f_{s}$ into the context.

A practical example of sensory focus would be the focus of attention to words spoken by a specific individual in a room with others speaking simultaneously. If the patterns that recognized phonemes/words included a focus point ($f_{w}$) then words would only be recognized when that focus point was in the context. Assume that the particular individual’s voice is recognized (as in the prior example) as $p_{voice}$ and that point was twined with point $f_{w}$ ($p_{voice}$ > $f_{w}$) then word recognition would only occur when the individual’s voice was detected/recognized.

6 Motivation: The Good and the Bad

Some points may have one of two additional attributes: ‘+’ and ‘-’. This optional attribute is used to ascribe good/pleasure or bad/pain to a point. Good points are tagged with the positive $p^{+}$ and bad points are tagged with the negative $p^{-}$. Most points are neither good nor bad and thus have neither. The V5 engine continuously tracks the number of good/bad points in the PS and sums them by assigning +1 to good points and -1 to bad points. This sum is referred to as $\Sigma$; $\overline{\Sigma}$ represents a smoothed value of $\Sigma$; $\Delta$ is the difference between the two. These relationships are summarized in equations (13a/b/c) for moment (int time) $m$ and where $s$ is a smoothing factor between 0.0 and 1.0.

[TABLE]

A long term goal of the V5 engine is to maximize $\Sigma$ by maximizing $p^{+}$ points and minimizing $p^{-}$ points. $\Sigma$ indicates the current (instantaneous) good/bad state, $\Delta$ reflects whether $\Sigma$ is increasing or decreasing. A positive $\Delta$ means the current value of $\Sigma$ is greater than the recent average (getting better). Conversely, a negative $\Delta$ indicates that $\Sigma$ is smaller than the recent average (getting worse). Given the V5 engine’s goal of maximizing $\Sigma$ over time, what steps can be taken to achieve this?

Make the V5 processing clock speed inversely related to $\Sigma$. As $\Sigma$ increases, slow processing clock to maintain the status quo. As $\Sigma$ decreases, increase the clock speed to facilitate change to the status quo. 2. 2.

if $\Delta$ goes positive then conditions are improving; continue with current actions. 3. 3.

if $\Delta$ goes negative then conditions are worsening; perform different actions. 4. 4.

if both $\Sigma$ and $\Delta$ are negative then bind neutral points to a minus point.

Many situational factors dictate what ‘continue with current actions’ and ‘perform different actions’ mean. Two different situations are presented in the following simulation examples. The first simulation shows the use of $p^{+}$ points locating a target. The second simulation demonstrates the use of $p^{-}$ points in learning to avoid a ‘painful’ situation.

6.1 Simulation 1: A Sensor Locking onto a Target

The first simulation investigates how an intity locates a target through the utilization of $p^{+}$ points. The intity has directional sensors such that when a sensor is pointed directly at a target (within $1\degree$) it generates a $p^{+}$ point. There are multiple sensors that span an arc of $90\degree$. The action of the intity is to move ahead a unit distance then decide to turn left $\Theta$ degrees, right $\Theta$ degrees or continue straight ahead. The specific actions are:

If $\Delta$ < -5 and the prior action was move left, then move right. If it was move right then move left. If it was move straight then move left or right, each with a probability of 0.5. 2. 2.

If $\Delta$ > 5 then continue moving left/straight/right as before. 3. 3.

Otherwise move left with a probability of 0.5, right with a probability of 0.25 or straight with a probability of 0.25. The reason for bias to the left is to ensure that the intity’s sensors sweep the entire plane of the simulation space in a reasonable number of steps.

The number of $p^{+}$ points needs to increase as the intity points more directly at the target reaching a maximum when it is heading directly towards the target. As it turns into the target $\Sigma$ increases and $\Delta$ is positive so that it continues its current action (turning or going straight). As it turns away from the target $\Sigma$ decreases and $\Delta$ goes negative so the intity changes direction. In this way it can home in on the target. Packing sensors more densely towards the center of the $90\degree$ arc for a gradient is necessary to achieve the desired result (figure 10).

The three example runs below show the action of the intity based on various starting positions with respect to the target. The small dot indicates the starting point. The larger dot is the target. The initial bearing is $0\degree$, due east. Runs (a) and (b) the show the bias to move to the left. All three demonstrate that once the target is detected the intity moves to the target.

6.2 Simulation 2: Learning to Avoid a ‘Painful’ Wall

The second simulation has an intity enclosed within a square pen. The intity is free to roam randomly within the pen. If the intity hits any of the sides of the pen then it receives a painful jolt. The intity’s sensors register the pain by inserting $p^{-}$ points into the context. The intity has additional sensors that create normal (i.e. neither + nor -) sensory points whenever it is in close proximity to any of the four sides. All of these sensed points are inserted into the intity’s processing context. With each processing step, the null key set is evaluated. Any result is additionally added into the context. If $\Sigma$ goes negative (from $p^{-}$ points) then it immediately reverses direction (i.e. when it senses pain it reverses).

In the two runs below, the intity starts in the middle of the pen facing north. Both figures below show the intity’s path over 5000 moves. There is no learning in the first run (figure LABEL:v5demo2-1) and the intity repeatedly hits the boundaries. In the second run (figure LABEL:v5demo2-2) it learns by binding the sensory points (proximity to a boundary) with pain points whenever $\Delta$ goes negative. The intity recognizes pain before experiencing it and can reverse itself before hitting a boundary.

7 Thoughts, Language and Meaning

The CEM has now been introduced and with the V5 engine many examples have been presented. Mazes have been solved, songs have been sung. A Turing machine has been implemented demonstrating that at least in principle, any computable function can be calculated with CEM/V5. None of the examples presented so far would be considered difficult AI problems. None of them are novel and all have been ‘solved’ with many different AI and non-AI paradigms.

The second half of this paper is devoted to a more challenging and fundamental problem in AI: what are thoughts and how do thoughts relate to language and meaning? This section defines thoughts within the CEM framework. Section 8 demonstrates a sequence for translating thoughts to language by taking a single thought and generating both English and French output sentences. The converse problem of converting a string of words to a thought is covered in section 9. Examples showing how meaning arises from thought patterns are given in section 10.4.

7.1 Thoughts

Definition 13**.**

A thought is a point, $t$, at the base of a multi-branch is-a tree (is-a twines) where the separate branches of the tree are the components of the thought.

At its simplest, the thought of ‘x’ (as represented as point $x$) would be point $x$ is-a twined to a thought point ($x$<$t$). More complex thoughts have multiple branches with additional points that relate the branches to each other. For example, the thought corresponding to the sentence ‘Sue walked her dog’ is (thought) point with two is-a branches. The first would be the point representing Sue, the second would be the point representing her dog: $pSue$<$t$ and $pDog$<$t$. Additional is-a twines would relate the Sue point ($pSue$) to her dog point ($pDog$) as the subject and object of the verb walk: $subWalk$<$pSue$ and $objWalk$<$pSue$. But these last two twines are not quite correct. $pSue$ is not always the subject of $walk$ and $pDog$ is not always the object. They are subject/object only for this thought. Or to restate only in the context of this thought. So these two twines are more properly written as $subWalk$<$pSue$|$t$ and $objWalk$<$pDog$|$t$.

Representing a thought as a collection of twines can be difficult to visualize especially for complicated thoughts. However, showing a thought graphically as a tree makes it easier to understand the structure of a thought. In a thought tree, the nodes represent points and the branches represent is-a twines. To further simplify, specific contextual restrictions on a twine are not shown (e.g. $subWalk$<$pSue$ and $subWalk$<$pSue$|t would have identical tree representations. A more compact fractional notation may also be used when representing is-a relationships. Figure 13 shows both the tree and fractional representations of the thought ‘Sue walked her dog’.

Thoughts are points so it is possible to include one thought within another. Consider the thought ‘The man I knew from high school said that Fred ate the cookie’. This thought can be decomposed into two sub-thoughts within a third. Figure 14 shows$t1$, the main thought, linking the subject ’man I knew from high school’ ($t2$) to the object ’Fred ate the cookie’ ($t3$).

7.2 Meaning of a Thought

The meaning of a thought is defined as the subsequent actions taken by an intity as a consequence of the thought. A single thought may have different meanings for different people. An individual’s interpretation of a thought may change over time. Consider the thought shown in figure 15.

What is the meaning to the reader? No prior mention was made as to whom Jack or Jill are. There was no prior mention of hills in this paper. Yet each reader will interpret the sentence and have subsequent thoughts, for example:

• •

Think that it’s just an example to define the author’s point. There is no meaning per se.

• •

Recall the old nursery rhyme and maybe continue it in their mind (‘to fetch a pail of water’).

• •

Mentally picture two children jointly holding a bucket walking up a hill towards a well.

Adding a thought point to the context (or the PS for V5) effectively adds all of the is-a points of the thought to the context. These points as well as any other points in the context (sensory, control and internal) can be used to recognize patterns. The value of a pattern can be another thought point, the starting point of a sequence, a long term goal point, etc. The constant processing of sensory input and thoughts leading to other (new) thoughts results in a chaotic stream of points flowing through the intity.

8 Converting Thoughts to Language

The conversion of a thought to a sequence of words requires bindings representing information for:

• •

words corresponding to the various points comprising the thought (e.g. ‘John’ for point $nounJohn$);

• •

rules for converting a point to one or more words (e.g. the ordering of adjectives before a noun);

• •

rules for the overall structure of the resulting sentence (e.g. active versus passive voice);

• •

a sequence to accomplish the task given the above information.

• •

and the thought point to be converted to a sequence of words;

The example below demonstrates one way this can be done. It is self-contained with all the bindings necessary to convert the thought representing ‘John has the red ball’ into an appropriate sequence of words reflecting the thought.

Everything in the CEM is contextual. First, an English sentence is generated. Then a few more bindings are added to demonstrate contextual flexibility. The addition of point $french$ and associated bindings results in the thought generating a French language sentence.

The example begins with bindings defining the value for point $label$ in various contexts corresponding to different points in the thought. Line 3 declares output labels in various contexts. For example, the value of $label$ given the context of $nounJohn$ is “John”.

⬇

1twine noun<nounJohn,nounBall

2twine adj<adjRed|english,adjBig

3twine daLabel>"the" ; label>"John"|nounJohn ; twine label>"He"|pnounJohn ;

4 label>"big"|adjBig ; label>"red"|adjRed ; label>"ball"|nounBall ; label>"has"|verbHas

The code in lines 6 through 10 are instructions to create the thought in figure 16 of ‘John has the big red ball”. Line 6 inserts instructions and arguments into the PS to create twines corresponding to the tree below. The branches of the tree are is-a twines. The nodes are points. Points of the form ‘$\#number$’ are internal points created with the opNEW opcode.

⬇

5trace opTWISA

6ps opNEW,rNEW,base,opTWISA,sub,rNEW,opTWISA,nounJohn,rNEW,opTWISA,

7 opNEW,rNEW,base,opTWISA,obj,rNEW,opTWISA,defArt,rNEW,opTWISA,adjRed,

8 rNEW,opTWISA,adjBig,rNEW,opTWISA,nounBall,rNEW,opTWISA,opNEW,rNEW,

9 base,opTWISA,verbHas,rNEW,opTWISA

10run

11opTWISA: #44: [base.i rCTP(1)] = #2e8

12opTWISA: #45: [#2e8.i rCTP(1)] = sub

13opTWISA: #46: [#2e8.i rCTP(1)] = nounJohn

14opTWISA: #47: [base.i rCTP(1)] = #2ec

15opTWISA: #48: [#2ec.i rCTP(1)] = obj

16opTWISA: #49: [#2ec.i rCTP(1)] = defArt

17opTWISA: #50: [#2ec.i rCTP(1)] = adjRed

18opTWISA: #51: [#2ec.i rCTP(1)] = adjBig

19opTWISA: #52: [#2ec.i rCTP(1)] = nounBall

20opTWISA: #53: [base.i rCTP(1)] = #2f0

21opTWISA: #54: [#2f0.i rCTP(1)] = verbHas

The next several groupings define bindings to be used by the opRASM111111See section 3.2.1 for more detail on the opRASM instruction. instruction. Line 21 states that a definite article ($defArt$) followed by an adjective ($adj$) should trigger the adding of the label of the article ($daLabel.v$) to the print queue (opADDPQ). The reference to the definite article should be removed (-$defArt$) with no replacement (the value list ends with the $null$ point). Note that the $asPH$ point is automatically appended to the AS with opISATOAS instruction and is used to mark the end of a series of points.

⬇

21bind +10 [-defArt/adj] daLabel.v,opADDPQ,null

22bind +10 [adj/-defArt] daLabel.v,opADDPQ,null

23bind +10 [-defArt/noun] daLabel.v,opADDPQ,null

24bind +10 [noun/-defArt] daLabel.v,opADDPQ,null

25bind +10 [-defArt/asPH] daLabel.v,opADDPQ,null

26bind +5 [-adj/noun] eoa,@label.v,adj.v,opEVAL,rEVAL,opADDPQ,null

27bind +5 [noun/-adj] eoa,@label.v,adj.v,opEVAL,rEVAL,opADDPQ,null

28bind +5 [-adj/asPH] eoa,@label.v,adj.v,opEVAL,rEVAL,opADDPQ,null

29bind +2 [-noun/asPH] eoa,@label.v,noun.v,opEVAL,rEVAL,opADDPQ,null

30bind +2 [-noun/adjpost] eoa,@label.v,noun.v,opEVAL,rEVAL,opADDPQ,null

31bind +2 [adjpost/-noun] eoa,@label.v,noun.v,opEVAL,rEVAL,opADDPQ,null

32bind [-adjpost/asPH] eoa,@label.v,adjpost.v,opEVAL,rEVAL,opADDPQ,null

33bind [-sub/asPH] null

34bind [-obj/asPH] null

The following twines define the sequence that convert a thought into a series of words. Line 35 evaluates [$speak$] to get the ‘next’ step of the sequence. The binding on line 42 defines [$speak$] in the context of the additional points ($sub$, $verbHas$ and $obj$) to have the value $lsr.v$ (line 36). This clears the PQ (opCLRPQ), pushes the value of the subject onto the PS ($sub.v$), runs the opISATOAS instruction to insert all is-a points of the subject into the AS and then run the AS reduction instruction (opRASM). This results in the words representing the subject to be appended to the PQ. The word for the $verbHas$ is appended and then the words for the object. The last step of the sequence outputs the contents to the PQ to the console.

⬇

35twine lsa>opPSISAS,speak,eoa,opEVAL,rEVAL

36twine lsr>opCLRPQ,sub.v,opISATOAS,lsr2.v

37twine lsr2>opRASM,lsr3,lsr3.v

38twine lsr3>@label.v,verbHas,eoa,opEVAL,rEVAL,opADDPQ,lsr4.v

39twine lsr4>obj.v,opISATOAS,lsr5.v

40twine lsr5>opRASM,lsr6.v

41twine lsr6>opOUTPQ

42bind [speak sub verbHas obj] lsr.v

Starting up the sequence is done by adding the base thought ($base$), the language ($english$) and the starting point ($lsa.v$) for the sequence. The run command starts the execution and the sentence corresponding to the thought is output.

⬇

43ps base,english,lsa.v

44run

45PQ(3): "John" "has" "the" "big" "red" "ball"

The remainder of the example demonstrates how a few additional bindings can be used to convert the same thought into French. Twines with the additional context point ($french$) are given for the French equivalents of several word/points (lines starting at 47). The twine on line 46 specifies that in the context of $french$ the $adjRed$ point is-a $adjPost$. This, in combination with the binding on line 52, ensures that the word for the color red appears after the noun as is typical for color adjectives in French.

⬇

46twine adjpost<adjRed|french

47twine daLabel>"la"|french

48twine label>"grande"|adjBig,french

49twine label>"rouge"|adjRed,french

50twine label>"balle"|nounBall,french

51twine label>"a"|verbHas,french

52bind +10 [-defArt/adjpost] daLabel.v,opADDPQ,null

53bind +10 [adjpost/-defArt] daLabel.v,opADDPQ,null

Finally, rerun the sequence but this time with $french$ in the context.

⬇

54ps base,french,lsa.v

55run

56PQ(5): "John" "a" "la" "grande" "balle" "rouge"

The key points of this example are:

The thought is the starting point. A thought is fundamentally independent of language. 2. 2.

A generating sequence is determined from the overall structure and content of the thought (line 42). Different sequences may be evaluated for different modes of expression (active voice versus passive voice) or any other contextual conditions. This implies that any thought can be expressed as many different sentences. 3. 3.

The words for each element of the sentence are determined contextually. For example an additional twine ($label$>‘Johnny’|$nounJohn$,$diminutive$) specifies that ‘Johnny’ instead of ‘John’ should be output when the point $diminutive$ is in the context.

9 Converting Language to Thoughts

Language is the medium used to communicate a thought from one intity (the speaker) to another (the listener) where the speaker and listener have different internal point structures. A simple example is communicating a reference to an object (a particular red ball) that both the speaker and listener are familiar with. The speaker has the thought $ball_{s}$<$t_{s}$ where $ball_{s}$ is the speaker’s internal point for the ball and $t_{s}$ is the speaker’s corresponding thought. The corresponding thought for the listener is $ball_{l}$<$t_{l}$ where $ball_{l}$ is the listener’s internal point for the (same) ball and $t_{l}$ is a listener’s thought point. How does the speaker communicate the thought $ball_{l}$<$t_{l}$ to the listener without having access to the listener’s point $ball_{l}$?

9.1 Language to Thought with Surrogates

The answer is that the speaker uses attributes of $ball_{s}$ to describe it in words. In this example $colorRed_{s}$<$ball_{s}$ and $shapeBall_{s}$<$ball_{s}$ result in the phrase ‘red ball’. Upon hearing this phrase, the listener converts the spoken/heard word ‘red’ to $colorRed_{l}$ and the word ‘ball’ to $shapeBall_{l}$ and uses these points to locate/find/deduce $ball_{l}$.

A new type of point is needed for this process to work in the CEM environment.

Definition 14**.**

A surrogate is a point ($s_{x}$), a stand-in for another to-be-determined point.

In figure 17 the speaker’s thought ($t_{s}$) is converted to the words ‘red ball’. The listener, upon hearing, creates a thought ($t_{l}$) with the surrogate point $s_{l}$. Surrogate $s_{l}$ has two qualifying attributes linked via is-a twines ($colorRed_{l}$ and $shapeBall_{l}$). The listener searches prior thoughts for a point having the same two points as is-a twines. A match is found with thought $t^{\prime}_{l}$ with point $ball_{l}$ so surrogate $s_{l}$ is bound to point $ball_{l}$.

9.2 Resolving Surrogates

While the issue of resolving a surrogate to its corresponding point is an area of ongoing research, the simplest approach is to search backward through prior thoughts looking for a point with is-as covering the is-a attributes of the surrogate. For example a surrogate ($s_{x}$) having the twines $rare$<$s_{x}$, $juicy$<$s_{x}$ and $steak$<$s_{x}$ (rare juicy steak) would be resolved by locating another point with at least those same attributes.

Surrogates will have is-a attributes that are not to be included in the searching. These would be syntactic attributes local to the current thought. The inclusions or exclusion of these attributes can be handled with additional points in the is-a twines.

The is-a twines off of a surrogate constitute a logical and condition. A ‘rare juicy steak’ must be rare and juicy and a steak. Logical or conditions (‘chocolate or strawberry milkshake’) can be easily accommodated with the addition of thought specific twines. In figure 18 the point $csflavor$ is twined to both $chocolate$ and $strawberry$ ($csflavor$<$chocolate$|$t_{2}$, $csflavor$<$strawberry$|$t_{2}$) within the context of the thought $t_{2}$. The twine $csflavor$<$surrogate$ links the surrogate to this new point. Now either a chocolate or strawberry milkshake would match the $csflavor$ attribute. A similar strategy is shown in figure 18 with the ‘red [and] blue ball’ versus ‘red or blue ball’.

The handling of definite versus indefinite articles may be as simple as resolving an indefinite surrogate to a new point rather than performing any type of search. With ‘You will meet a tall dark stranger’ the surrogate for ‘a tall dark stranger’ can be replaced with just a new point. Nested clauses (‘the fish that got away’) require searching for prior conditional thoughts. Finally, in many instances, a surrogate may never be resolved. In ‘Jack and Jill went up the hill’, the reader has no idea who either Jack or Jill are.

9.3 Grounded versus Non-Grounded Chiral Points

The task of converting a sequence of words into a thought is primarily the process of converting those words into surrogates, all is-a twined to a thought point.

Definition 15**.**

A grounded point is a point that has an is-a twine to an external sensory point.121212See [17] for more on the grounding problem.

The first step is to distinguish grounded points from non-grounded points. This is done with an is-a twine to the $grounded$ point ($grounded$<$p$). Nouns and adjectives are grounded.

Definition 16**.**

Points that are not grounded are considered chiral131313The word chiral is related to handedness (left hand, right hand)..

Verbs, articles, adverbs and prepositions are not grounded. These points have a related left hand point and right hand point ($p\_L$ and $p\_R$). For example the non-grounded point $verbWalk$ has left and right hand counterparts ($verbWalk\_L$ and $verbWalk\_R$). The reason for this is explained in section 10.4.

Prior examples of thoughts have not been consistent in how verbs are represented in thoughts. From this point forward, a verb will not be represented with its own is-a branch on a thought tree. The verb will be split into its left and right hand parts. The two trees in figure 19 show the difference.

Note that with the new representation there is no explicit subject or object. These have been replaced with $verb$_L (subject side) and $verb$_R points (object side) respectively. Section 10.4 will demonstrate how these new points are used.

9.4 Overview of the Language to Thought (LTT) Process

Converting a series of words into a thought is achieved with the opLUPARSE instruction. The execution of this instruction consists of several phases. A very simple sentence, ‘little boy threw ball’, will be used as an example in the description of this process.

The first phase is to load the AS with points from the PS. This is done on a point by point basis until the $eoa$ point is detected in the PS. For each point, a determination is made as to whether or not the point is grounded. If it is grounded then a new surrogate point is created, the point taken from the PS is is-a twined to the surrogate and the surrogate is appended to the AS. If the point pulled from the PS is not grounded then the corresponding left hand and right chiral points are appended to the AS, not the original point. As an example, if the PS contains the points $\begin{Bmatrix}little&boy&threw&ball&eoa\end{Bmatrix}$ with $little$, $boy$ and $ball$ being grounded then the AS would contain five points: $\begin{Bmatrix}\frac{little}{s_{1}}&\frac{boy}{s_{2}}&threw\_L&threw\_R&\frac{ball}{s_{3}}\end{Bmatrix}$. 2. 2.

The next phase is to look at all combinations of contiguous surrogates. For each combination, temporarily add the surrogates (with is-a points) to the PS and evaluate the binding [$surAction$]. If the evaluation fails go on to the next contiguous pair. If the evaluation is successful then the result should be either the opJOIN or opLULINK points/opcodes. If it is one of these two points then execute the instruction for the pair of points. In this example, the first two points would be combined with the opJOIN instruction/point. The AS would then be $\begin{Bmatrix}\frac{little\;boy}{s_{1}}&threw\_L&threw\_R&\frac{ball}{s_{3}}\end{Bmatrix}$ 3. 3.

This phase looks to join left and right hand chiral points to adjacent surrogates. If a surrogate is followed with a left hand point then the left hand point is-a twined to the surrogate. Similarly if a right hand point is immediately followed with a surrogate then it is is-a twined to that surrogate unless the surrogate has already been is-a twined with a left handed point. If a right handed point is immediately followed with a left handed point then remove the left handed point from the AS. The AS after this phase contains $\begin{Bmatrix}\frac{little\;boy\;threw_{L}}{s_{1}}&\frac{ball\;threw\_R}{s_{3}}\end{Bmatrix}$ 4. 4.

If there are only surrogate points in the AS then continue phase 6. If there are other (chiral) points then continue with phase 2 unless phases 2 and 3 have already been repeated with no actions taken. In this case remove any remaining chiral points from the AS and continue with phase 6. In our example, continue with phase 6. 5. 5.

Perform one final check for contiguous surrogates (similar to phase 2). 6. 6.

In the final phase is-a twine each remaining surrogate point in the AS to the current thought point (register rT) and remove all points from the AS. This example ends with the thought shown in figure 20. The thought point ($t_{x}$) has two surrogate points is-a twined. Surrogate $s_{1}$ representing a point described by $little$ and $boy$, and surrogate $s_{2}$ representing a point described by $ball$.

Below is a more complicated example with the sentence ‘The little boy threw the big red ball on the table to John’:

⬇

1twine grounded<boy,ball,John,little,red,big,table

2twine obj<boy,ball,John,objSurface

3twine adjObj<little,red,big

4twine objSurface<table

5bind [surAction adjObj obj] opLUJOIN

6bind [surAction obj objSurface on_R] opLULINK

7ps the,little,boy,threw,the,big,red,ball,on,the,table,to,John,eoa

8run opLUPARSE

The resulting thought is shown by the tree in figure 21. The surrogate points created in the execution of the opLUPARSE instruction are shown as ‘surn?’ where n is a unique suffix for each surrogate. Note that the tree includes only surrogates 1, 3, 6 and 7. The other surrogates (2, 4, and 5) were merged with the opJOIN instruction.

9.5 Limitations of this Approach

The parsing algorithm as just described is limited in its abilities to parse natural language. This is intentional as the next section (10) will describe how an intity can autonomously learn the bindings (rules) necessary to accomplish this level of linguistic sophistication.

Linguistic parsing using the opRASM instruction does not have these two restrictions. See appendix D for several examples of parsing using opRASM. Merging this parsing sophistication into the LTT process is another area of ongoing research.

10 How a Language is Learned

How a natural language is learned is the topic of this section. A simplified subset of English consisting of nouns, adjectives, prepositions and verbs is used. Only simple noun phrases are considered; no nested clauses (e.g. ‘The man John saw at the park’). Verb tenses are not considered. Even with these simplifications, language learning is a daunting task. Consider what a toddler acquires to understand this limited subset of English:

• •

recognize and discriminate sounds into different points;

• •

learn to recognize visual objects (e.g. form a pattern that recognizes apples);

• •

learn the meaning of a word (the grounding problem) by associating sounds with physical objects (e.g. associate the spoken or written word ‘apple’ with the visual pattern for an apple);

• •

learn the syntax of the language (e.g. ‘John ate the cookie’ is not the same as ‘The cookie ate John’);

• •

learn the meaning of thought (e.g. what does it mean to throw something, what are the consequences of throwing something).

The parsing process used in this section is the same as that described in section 9.4. The process requires that certain knowledge, in the form of bindings, be available to:

recognize words (i.e. patterns that recognize words from spoken sounds); 2. 2.

recognize grounded word (i.e. points that have is-twines to physical descriptions); 3. 3.

combine contiguous surrogate points in the AS using bindings of the form [$surAction$ $s_{1}$ $s_{2}$]; 4. 4.

use the context of the resulting thought (all the is-a points linked to that thought) to find patterns resulting in consequential thoughts and/or actions.

The following four sections address the four points just mentioned above. In all four cases the ‘learning’ is just a form of pattern learning as discussed in section 5.1 albeit with different sets of pattern data. It should also be noted that although these four cases of learning are presented in a logical order, the actual learning need not be sequential.

10.1 Learning to Recognize Words

Spoken words enter the context as sensory input. Given sufficient repetition, the recognition process described in section 5.1 creates patterns that associate specific words with internal points. In this way, words are recognized. Embedded patterns (and points) are created distinguishing spoken words from other sounds, i.e. words have an is-a twine of the form $spokenByPerson$<$recognizedSound$.

Visual objects are recognized with the same learning process. The only difference between the learning of sounds versus visual objects is the source of the sensory points. All recognized visual points have a common embedded pattern that is recognized as point $visualObj$ (i.e. all visual points are is-a twined to $visualObj$) and that is-a twine $grounded$<$visualObj$141414This would be a predefined twine within the intity. exists (i.e. all recognized visual points are grounded).

10.2 Grounding: Associating Words with Visual Objects and Attributes

Associating a spoken word point with its visual object point is again achieved with the pattern recognition algorithm. For the association to occur, both the word and object sensory points must reside in the PS concurrently over multiple instances (e.g. the sounds for the word ‘apple’ and the visual image of an apple). Given a word that is recognized with the following pattern/binding: [$w_{1}$ $w_{2}$ \dots$$w_{n}]=$word$ and a visual object is recognized with the binding [$v_{1}$ $v_{2}$ \dots$$v_{n^{\prime}}]=$visObj$ then if both the word is spoken and the corresponding object seen at the same time the context would contain {$w_{1}$ $w_{2}$ \dots$$w_{n} $v_{1}$ $v_{2}$ \dots$$v_{n^{\prime}}} (in addition to other points). With enough repetitions, a new pattern would be detected= [$w_{1}$ $w_{2}$ \dots$$w_{n} $v_{1}$ $v_{2}$ \dots$$v_{n^{\prime}}]=$wvpoint$. However, the points comprising $wvpoint$ have embedded sub-patterns for both the word and visual objects resulting in the twines $word$:$wvpoint$ and $visObj$:$wvpoint$ (section 5.3).

Now if the PS contains $\begin{Bmatrix}w_{1}\ w_{2}\dots w_{n}\end{Bmatrix}$ then $word$ is recognized resulting in $word$.v being added to the PS (section 5.4). The evaluation of [$word$.v] results in $wvpoint$ and since $visualObj$<$wvpoint$ and $grounded$<$visualObj$ the resulting point is grounded.

Only words associated with visual objects would be grounded. Any other recognized words would have the is-a twine $spokenByPerson$<$otherWord$, but not be grounded.

10.3 Combining Surrogate Points via Join and Link

Once the AS is loaded with points (grounded and chiral) then only two operations are used to combine them. The V5 opJOIN instruction is used to merge two surrogate points into one surrogate by combining the is-a points of each (e.g. combine an adjective and noun). The opLULINK instruction is used to is-a twine one surrogate to another (e.g. link a prepositional phrase to a noun phrase). This section describes how an intity learns to join/link two surrogates together as in:

[TABLE]

with bindings of the form [$surAction$ $p_{1}$ $p_{2}$ $\dots$] = opJOIN. Initially an intity has no [$surAction$] bindings. During the LTT process (section 9.4) for each pair of contiguous surrogate points, the intity attempts to evaluate [$surAction$]. If it fails, it looks at recent thoughts for points similar to the two surrogates in question. For example if the two surrogates are $\frac{big}{s_{1}}$ and $\frac{red}{s_{2}}$ then look through past thoughts ($t$ points) for is-a points having either the $big$ point or $red$ point. If the intity had recently noticed or thought of ‘big red apple’ then there would be a thought with the branch $\frac{big\;red\;apple}{p_{x}}$. Both the $big$ point and the $red$ point have a common parent (in this case $p_{x}$). The intity would then proceed and join the two surrogates in the AS as part of the LTT process. Additionally, the intity would save all the is-a points of the two LTT surrogates in a buffer for a future recognition run. When this buffer reached a certain number of entries or a certain amount of time has passed, the pattern learning process (section 5.1) would run. If a pattern was detected then the recognized points would be used to create a binding of the form [$surAction$ $r_{1}$ $r_{2}$ \dots$$r_{n}]=opLUJOIN where $r_{i}$ are the recognized points. In this way the intity learns to join adjectives and nouns to form a single surrogate.

As an example, if the surrogate points $\frac{red}{s_{1}}$ and $\frac{apple}{s_{2}}$ (corresponding to the grounded words ‘red’ and ‘apple’) are repeatedly encountered in the AS and repeatedly combined into a single surrogate then multiple sets of {$red$,$apple$,opLUJOIN} would be appended to the pattern learning buffer. During the pattern learning phase this set of points would be recognized as a pattern and the binding [$red$ $apple$ $surAction$]=$opJOIN$ would be created.

Success requires that the intity has a (previous) thought matching the spoken words. In other words it must have noticed a ‘big red ball’ prior hearing the words ‘big’, ‘red’ and ‘ball’. As the intity learns more about the world it develops more sophisticated is-a twines and the patterns recognized for the surrogate action become more generalized.

Learning when to apply the opLULINK operation is handled in a similar fashion. In this case the reference thought is not a single point but two points with one an is-a of the other. The learning processes are identical, the only difference is the use of the opLULINK instruction instead of the opJOIN instruction.

The phrase ‘ball on table’ maps into two surrogate points in the AS: {$\frac{ball}{s_{1}},\frac{on\ table}{s_{2}}$}. If the evaluation of [$surAction$] in the context of the two surrogates fails then a search of prior thoughts is performed looking for the match on the is-a points. Assuming the ball is perceived to be on the table then the thought $\frac{\frac{ball\ \frac{on\ p_{table}}{p_{x}}}{p_{apple}}}{t}$ exists. Matches would be found between the $ball$ and $table$ resulting in the set {$ball$,$table$,$on$,$opLULINK$}. With enough repetitions a pattern would be found resulting in the binding [$surAction$ $ball$ $table$ $on$] = $opLULINK$.

10.4 Meaning / Consequences of a Thought

The meaning of a thought is defined as the effect that thought has on subsequent actions and thoughts. How those subsequent actions/thoughts arise from a given thought is presented in this section. A general overview of the steps required is:

• •

Look at pairs of thoughts that were both created within a specific time interval.

• •

Create a set of points that relate the before and after points from the two thoughts and save these sets in a reserved pattern learning buffer.

• •

After a certain number of sets have been created (or a specified amount of time has passed) perform the pattern learning process (section 5.1).

• •

If a pattern is found, use the matched points to create another twine of the form [$cons$.v $b_{1}$ $b_{2}$ $\dots$]=$consequences$, where $b_{x}$ are trigger points from the initial (before) thought) and $consequences$ are a series of points to create a consequential thought or initiate a consequential action/sequence.

The encoding of the before and after points is the key to making this a simple process of pattern learning.

10.4.1 Action Verbs

Figure 22 shows two thoughts. The first corresponds to ‘John threw the ball to Bob’. The second (subsequent) thought corresponds to ‘Bob has the ball’. These two thoughts are related by two pairs of surrogate points. Surrogates $s_{2}$ and $s_{5}$ both resolve to ‘the ball’ and surrogates $s_{3}$ and $s_{4}$ resolve to ‘Bob’. For each of these pairs of points, a binding is created with a new link point as the value. For the ‘ball’ this becomes [$threw$_R $has$_R]=$link1$. For ‘Bob’ it is [$to$_R $has$_L]=$link2$. Additional twines are created so that given either $link1$ or $link2$ the cause and effect points can be determined. This is reflected in lines 1 through 4 in the example below. An additional link point is created for the surrogate point $s_{1}$. Since this surrogate point is not related to any point in the second thought, the binding contains all of the surrogate is-a twine points. Again, an additional twine is created for just the cause since there is no corresponding effect side. Line 5 and 6 show this third link. The pattern data generated by this pair of thoughts would be $\begin{Bmatrix}link1\ link2\ link3\end{Bmatrix}$.

Now consider a similar pair of thoughts represented by the two thoughts: ‘Mary threw the bone to Fido’ and ‘Fido has the bone’. In this case ‘bone’ and ‘Fido’ are identical. The links generated for this pair of thoughts would be $link1$, $link2$ and $link4$. The links $link1$ and $link2$ would be identical to the first pair because the binding key sets [$threw$_R $has$_R] and [$to$_R $has$_L] are identical. But ‘John’ is not the same as ‘Mary’ so while [$john$ $threw$_L]=$link3$, [$mary$ $threw$_L]=$link4$. The pattern data for this pair of thoughts would be $\begin{Bmatrix}link1\ link2\ link4\end{Bmatrix}$.

Given a sufficient number of thought pairs, the standard pattern matching algorithm would find the pattern {$link1$,$link2$}. But rather than bind the pattern to a recognition point, a consequence would be created from the cause/effect is-a points of the pattern links. In this example (line 8) the trigger points are $to\_R$ and $threw\_R$ and the consequence is to create a new thought relating a value to an attribute.

(Note in above figure arrows linking Bob and ball are to the surrogate nodes, not to leaf points.)

⬇

1bind [to_R has_L] link1

2twine to_R<link1|cause ; has_L<link1|effect

3bind [threw_R has_R] link2

4twine threw_R<link2|cause ; has_R<link2|effect

5bind [threw_L John] link3

6twine threw_L,John<link3|cause

7

8twine cons>to_R.v,has_L,eoa,opSURISA,threw_R.v,has_R,eoa,opSURISA | to_R,threw_R

The consequence defined on line 8 is tested with the thought representing the sentence ‘Jill threw the keychain to Helen’ (line 9). The thought $t1$ is added to the PS (context). Then $cons.v$ is added and evaluated. The result are the twines shown below (lines 15 through 20) corresponding to figure 23; i.e. Helen has the keychain.

⬇

9twine Jill,keychain,Helen<t1

10twine threw_L<Jill ; threw_R<keychain ; to_R<Helen

11

12ps t1,opPSISAS,cons.v

13trace bind

14run

15bind: #48: [#2b4?.i] = Helen

16bind: #49: [#2b4?.i] = has_L

17bind: #50: [T(2).i] = #2b4?

18bind: #51: [#2b8?.i] = keychain

19bind: #52: [#2b8?.i] = has_R

20bind: #53: [T(2).i] = #2b8?

The next example shows how a consequence that is not based solely on linked nodes can be derived.

The first thought is identical to that of the previous example. The second thought is ‘The ball flew through the air’. These two thoughts are inter-linked only once with the ball. This creates link point $linka$. The other points are created from the other nodes: $link3$ would be same as from the above example, $linkc$ and $linkd$ would be different points. The pattern data from this pair of thoughts is $\begin{Bmatrix}linka,\ link3,\ linkc,\ linkd\end{Bmatrix}$. Other similar pairs of thoughts (‘Harry threw the stick to his dog’ ‘The stick flew through the air’) would generate pattern data duplicating $linka$ and $linkd$ but other link points would vary. The pattern would be detected and the consequence (line 10) would be created.

⬇

1bind [threw_R flew_L] linka

2twine threw_R<linka|cause ; flew_L<linka|effect

3bind [threw_L John] link3

4twine threw_L,John<link3|cause

5bind [to_R Bob] linkc

6twine to_R,Bob<linkc|cause

7bind [through_R air] linkd

8twine through_R,air<linkd|effect

9

10twine cons>threw_R.v,flew_L,eoa,opSURISA,through_R,air,eoa,opSURISA | threw_R

A new thought corresponding to ‘Harry threw the rock’ (thought $2$ on line 11) can now be tested. The resulting (consequential) thought, ‘the rock flew through the air’, is shown in figure 25 and in the bindings starting at line 15.

⬇

11twine Harry,rock<t2 ; threw_L<Harry ; threw_R<rock

12ps t2,opPSISAS,cons.v

13trace bind

14run

15bind: #71: [#2e8?.i] = rock

16bind: #72: [#2e8?.i] = flew_L

17bind: #73: [T(3).i] = #2e8?

18bind: #74: [#2ec?.i] = through_R

19bind: #75: [#2ec?.i] = air

20bind: #76: [T(3).i] = #2ec?

10.4.2 Copula (To Be)

In our simplified language, the sentence ‘$x$ is $y$’ (e.g. ‘the ball is red’) is very similar to the noun phrase ’the red ball’ in that the thoughts generated by each would reduce to the same tree structure as shown in figure 26.

There is a subtle semantic difference between ‘the red ball’ and ‘the ball is red’. In the first phrase, a single surrogate has both the ‘red’ and ‘ball’ is-a links. Resolution of the surrogate would require matching on both points. In the second phrase, the subject surrogate only has the $ball$ point. Resolution requires only that the target point also have the $ball$ point. After resolution, the additional $red$ point would be twined. There is an unresolved timing issue with the phrase ‘The ball is red’. What happens if the $ball$ surrogate is not resolved when the $red$ point is-a twined?

11 Conclusions

This paper introduced the contextual evaluation model for representing knowledge. The model is conceptually simple consisting of only four elements: the point, the key set, the binding and context. Contextual evaluation is the only operation. A single simple algorithm is used for learning patterns. Despite the simplicity of the model, it is shown to be Turing complete. More importantly, many examples demonstrate how the model performs a range of artificial intelligence tasks from the simple (learning a maze) to the difficult (learning a natural language). It is the hope of the author that it will interest others to investigate the potential of the contextual evaluation model.

The major contributions of this paper are:

• •

The CEM - the simplicity of the model and its ability to integrate internal, sensory and control data (points) into a contextual framework of facts, patterns and sequences.

• •

V5 - proof that the CEM is viable and that with relatively few primitive instructions ($\approx$ 25) much can be accomplished.

• •

The incorporation of time - how time naturally fits into the CEM model.

• •

Patterns as bindings - how the CEM binding is used for pattern matching; how points of different modalities (e.g. sound, smell, vision, internal) can be incorporated into a single pattern and how focus points can be used to implement focus and direct attention.

• •

The thought- defined as a collection of is-a twines linked to a base thought point; using sequences to convert thoughts to natural language utterances; converting natural language utterances to thoughts.

• •

Meaning - the meaning of a thought, not as anything inherent in the thought but as the subsequent actions of an intity as a consequence of the thought.

• •

Motivation - the $p^{+}$ and $p^{-}$ points to represent good/pleasure and bad/pain and the effect these points have on the operation of the V5 engine.

• •

Natural Language Acquisition - that each of the steps in autonomous language acquisition is accomplished with the simple tools of this model.

11.1 Major Unanswered Questions

The CEM provides a concise methodology for handling many disparate AI situations. The CEM and V5 are works in progress and much remains to be resolved:

• •

How are sense points encoded? The CEM assumes that all senses are encoded such that pattern learning and pattern recognition are possible using the techniques discussed in section 5. Could it be that a neural-network pre-processor is required to convert raw sensory data into a point based format?

• •

How would the V5 engine scale to perform useful tasks? Despite decades of experience working with an earlier contextual engine, the effort required to scale up the V5 engine is an unknown.

• •

Would the language parsing and generation techniques scale up to handle a more complete language subset? This paper describes only the simplest forms of language parsing and generation for English. Can additional rules (bindings) be developed to handle complex English? Would similar rules or completely different rules be required for the majority of languages where syntax is not based on word position but word endings?

• •

How are surrogate points resolved? Only the simplest rules for surrogate resolution were given in this paper. How should surrogates resolve that are qualified with multiple points and thoughts? When should surrogates be resolved? Once resolved should they continue to be re-resolved?

• •

Does the CEM reflect, at some level, how brains actually operate? And if so then how did it evolve? What can be inferred from the similarities between viewing the EC engine as a set of rules (bindings) operating within a constantly changing context and a living cell having a set of rules (DNA/RNA) operating within a constantly changing environment (context)?

• •

How are sequences learned? The methods described in section 10.4 for learning consequences of a thought would be one approach, albeit slow and inefficient for any sequence consisting of more than a few points. Another possible approach is to have a basic sequence scaffolding or framework on which points of a sequence could be twined.

As with everything else in science and technology, the ideas presented in this paper stand on the shoulders of many others in a diverse range of AI endeavors. The following sections of the conclusion point out some of the many areas of prior research utilized in developing the CEM and V5 engine.

11.2 Other Models of Knowledge Representation

Knowledge representation (KR) is the represention of information for solving non-trivial problems with a capability similar to that of a human. First order logic has been a key component of KR systems since the late 1950’s with the IPL/GPS[1] programs. IPL introduced the concept of the list. McCarthy expanded on that concept, added ideas from lambda calculus and developed LISP[2, 18].

First order logic, while mathematically rigorous, was found to be difficult to apply to many real world situations. Other KR models moved from strictly declarative structures to formats allowing for procedural and frame-based formats[19, 20, 21, 22]. Larger, ongoing KR projects have expanded on the idea of semantic webs[3, 4, 5].

11.3 Comparison of the CEM Context with Other Contextual Models

Intensional logic is a group of formal systems allowing expressions or statements whose values depend on hidden contexts. It was originally developed to help understand the contextual nature of natural languages. In this logic, the extension of an expression is the value in a specific context. The intension of an expression is the function that maps from a context the value of each expression within that context[23].

Lucid is a programming language developed in this format[24]. Early versions of the language supported only time and space as the context. Current versions permit the users to define their own dimensions. In Lucid, the context and the expressions are separate, while in the CEM, the context consists of the same points as the other components of the model. The expressions within Lucid are based on variables, functions, constants, and operations. These can be assembled into programs. The CEM has no explicit variables, functions, or constants, just bindings. This is not to say that the equivalent of variables, functions and constants cannot be implemented with the CEM, but that there is nothing intrinsic to the model implementing these concepts. There is no concept of a program within the CEM yet sophisticated programming can be achieved through contextual sequences.

McCarthy and later Guha[25] attempted to define context through the $ist(c,p)$ relation that asserts that $p$ is true in the context of $c$. In this model the “Contexts are abstract objects. We don’t offer a definition”.[26] The propositions, p’s, are expressions based on the predicate logic. As an example, McCarthy gives the following:

[TABLE]

that states, in the context of Sherlock Holmes stories, the character Holmes is a detective. In another context, Holmes might be a short order cook or somebody’s dog.

Lenat further extends this thinking in the Cyc project by defining contexts within a 12 dimensional space. As with McCarthy and Guha, Cyc facts and propositions are stated within a context. There does not appear to be any overlap between context and proposition. A comparison of contexts based (or derivative) of the McCarthy model can be found in Akman[27]. Another review of contextual models can be found in Serafini[28].

11.4 V5 Language and Engine

V5 has its roots in the V4 language[29, 8]. V4 was started in the mid-1990s and is currently used as a production language for web-based data analysis. V4 is based on points, bindings and contextual evaluations. It differs from V5 in several significant ways:

In V4, every point belongs to a dimension. Dimensions are typed and supported types include integer, floating point, logical, string, date-time and dictionary. A point is specified as dimension:value as in date:23-Apr-2015. 2. 2.

V4 supports modules that perform typical language functions such as string manipulation, mathematical and statistical analysis and input/output. 3. 3.

The V4 context is ‘stacked’ meaning that a new stack frame is created with each execution frame. Points inserted into a frame take precedence over points in prior frames. Context frames are removed when the execution frame is exited. Recursive binding definitions are thus supported. The factorial function for integers greater than zero could be defined as shown in (15)151515With some syntactic sugaring, points on the NId dimension (named identifier dimension) can be written without the dimension prefix (e.g. NId:factorial $\equiv$ factorial). Similarly, integers can be written without the Int dimension prefix (e.g. Int:1 $\equiv$ 1). A dimension with an asterisk suffix references the value of that dimension in the context. Arithmetic expressions are enclosed in braces. If the evaluation of a key set fails and the key set is followed with a comma and another point then that point is taken as the value (e.g. evaluating [factorial 0],1 returns 1)..

[TABLE] 4. 4.

V4 may be programmed much like any other functional language. The binding in figure 27, when evaluated, generates HTML to display ‘Hello World’.

What V4 has demonstrated over the years is that an efficient algorithm for contextual evaluations exists and the binding / contextual evaluation paradigm is a practical tool for real world problems. The author is not aware of any work on contextual sequences other than his own[30].

11.5 Language, Thought and Meaning

In this paper, a thought is defined in section 7.1 as a point with is-a twines linked to it. While the example thoughts presented throughout this paper all had points with English labels, the thought itself, is not tied to any language. Several sections of this paper are devoted to mapping from a thought to a natural language utterance and from an utterance to a thought. This begs the question, ‘Is language necessary for thought?’ There are two philosophical schools on this issue. Lingualism, most notably the Sapir-Whorf hypothesis, claims that language, to a greater or lesser degree, determines thoughts[31]. Another school, the ‘language of thought hypothesis’ (LOTH)[32, 33], claims that thought is independent of language. The author tends more towards the LOTH school, not because of any philosophical reasons but because of empirical studies showing that people with aphasia (an inability to use language) still possess other mental faculties[34].

There are any number of theories related to the meaning of language[35]. In this paper meaning arises from the consequences of the thought. A thought, in and of itself, does not have meaning. Meaning is an ongoing process, not a static attribute or quality. Searle in his book The Language of Thought makes a somewhat similar argument[36, p. 120]:

$\dots$I shall argue that for a large number of cases the notion of literal meaning of a sentence only has application relative to a set of background assumptions, and furthermore these background assumptions are not all and could not all be realized in the semantic structure of the sentence in the way that presupposition and indexically dependent elements of the sentence’s truth conditions are realized in the semantic structure of the sentence.

The language learning process presented in this paper differs from many of the existing models[37, 38] in several respects. First is that it assumes no a priori knowledge and no external ‘guidance’. Secondly it spans the learning process from distinguishing words from other sounds to learning the meanings of utterances (as mapped to thoughts). And thirdly it does so in a logical, easily explained way using no special techniques other than bindings and pattern learning.

11.6 Motivation

The point types $p^{+}$ and $p^{-}$ are used to differentiate good/pleasure and bad/pain points from other points. These +/- points impact the operation of an intity in such a way as to maximize $\Sigma$ thus favoring good over bad. Given that the intity reacts appropriately to the +/- points, does the intity feel the points? Others have asked this very question. For Dennet it is the notion of qualia[39]. For Chalmers it is the discussion of philosophical zombies[40]. This question is best left for the philosophers.

Emotions are an important component to human level intelligence. Thirty years ago Minsky recognized the importance of emotions: “The question is not whether intelligent machines can have any emotions but whether machines can be intelligent without any emotions.”[41, p.163] Picard writes in her book Affective Computing[42]: “The latest scientific findings indicate that emotions play an essential role in rational decision making, perception, learning, and a variety of other cognitive functions”. Do the +/- points have any relationship to emotions? Could $p^{+}$ points unrelated to senses (i.e. not associated with a sensory experience) be related to the feelings of happiness or contentment? Similarly, could $p^{-}$ points unrelated to senses be the root of fear and/or anxiety? Recall that the intity is constantly matching patterns in the PS. What if the PS is suddenly swamped with a novel set of points and was unable to recognize anything in the set? Would it momentarily freeze up in a way that is similar to our reaction of surprise?

This paper is all about models: modeling knowledge using points and bindings, modeling thoughts as trees of is-a twines, modeling language as a medium for communicating thoughts, modeling meaning as a process, modeling motivation with $p^{+/-}$ points. Are these models valid? Might they reflect how we actually think? To paraphrase George Box[43], all models are wrong, but some are useful. My hope is that some will find this paper useful.

Appendix A Glossary of Terms and Symbols

The following table lists the major terms and symbols used within this paper. The page number indicates where the term/symbol first appears.

Appendix B V5 Commands, Opcodes, Registers and Reserved Words

B.1 V5 Commands

{labeledpar}

twinebind Creates a binding consisting of a key set and value. Note that the equal sign between the key set and value is optional.

• bind [$set\ of\ points$] = $value$
• bind [$set\ of\ points$] $value$

{labeledpar}

twinedef Defines one or more labeled points. Multiple points are separated with commas.

• def $point1$, $point2$, $\dots$, $pointn$

{labeledpar}

twineeval This command evaluates its argument and outputs the value to the console. All evaluations are with respect to the context (PS).

• eval key set - evaluates the key set and prints the value
• eval $point.v$ - evaluates [$point.v$] and prints the value
• eval $point.i$ - determines and outputs is-a points for $point$ but no is-a points off of those points
• eval opcode - executes the opcode, nothing is printed except as a result of the execution of the instruction
• eval register - prints the contents of the named register
• eval sur - prints the resolution of the surrogate point

{labeledpar}

twinerun Begin execution with the current contents of the PS.

{labeledpar}twineset Set various V5 internal paramters.

• set autodef {on,off} - if enabled then any referenced undefined point is automatically defined.
• set newthought - creates a new thought point and copies it to register rT.

{labeledpar}

twineshow A debugging command to show various V5 sets and states.

• show aggset - outputs the points currently in the AS (aggregate set)
• show opcodes - outputs the number of times each opcode has been executed
• show ps - outputs the content of the PS
• show tcs - outputs the contents of the twine context

{labeledpar}

twinetrace Control various trace/debugging features.

• trace autodef - output a trace of all points automatically created (without the def command)
• trace binding - trace all created bindings
• trace eval - trace all evaluations
• trace off - turn off all tracing
• trace opxxxx - trace specific opcode execution
• trace reduce - trace the operation of the agg set (AS) reduction operation
• trace sequence $pattern$ - trace the evaluation of any [$p.v$] where the label associated with $p$ begins with $pattern$ (in the Turing machine example (section 4.4), the lines 16-22 could be traced with the command ‘trace sequence tm8’)
• trace twine - trace the creation of any twine

{labeledpar}

twinetwine Creates one or more twines. Multiple twines can be entered delimited with semicolons. Multiple points can be separately twined to a single point with the construct:

• twine $p1$>$p2$ - create a value twine [$p1$.v] = $p2$
• twine $p1$>$p2$|$p_{3}$,$\dots$,$p_{n}$ - create a value twine with additional point(s) - [$p1$.v $p_{3}$ \dots$$p_{n}]=$p2$
• twine $p1$<$p2$ - create an is-a twine [$p2$.i] = $p1$
• twine $p1$<$p2$|$p_{3}$,$\dots$,$p_{n}$ - create an is-a twine [$p2$.i $p_{3}$ \dots$$p_{n}] = $p1$
• twine $p1$<$p2$,$p3$,$\dots$- create multiple is-a twines each with value of $p1$
• twine $p1$<$p2$ ; $p3$>$p4$ ; $\dots$- multiple twines may be delimited with semicolons

B.2 V5 Opcodes

{labeledpar}

opISATOASopACTX Pops the head (top) point in the PS and adds it to the current twine context set (TC). On line 3 the opACTX instruction adds point $a$ to TC. The opTWVAL instruction twines $b$ to $c$ and includes point $a$ in the twine key set as shown by the trace output.

⬇

1def a,b,c

2trace opTWVAL

3ps a,opACTX,b,c,opTWVAL

4run

5opTWVAL: #32: [a b.v rCTP(1)] = c

{labeledpar}

opISATOASopADDPQ Pops the head point in the PS and appends it to the print queue set (PQ).

{labeledpar}opISATOASopBIND Pops points off the head of the PS until the $eoa$ point is hit. These points are inserted into a key set. Then the next point after the $eoa$ point is popped off of the PS and a binding is created linking the key set to this point. The trace output on line 5 shows the created binding. The number after the crosshatch (#) is the internal binding reference number.

⬇

1def a,b,c,d

2trace bind

3ps a,b,c,eoa,d,opBIND

4run

5bind: #32: [a b c] = d

{labeledpar}

opISATOASopCLRPQ Removes (clears) all points from the PQ set.

{labeledpar}opISATOASopEVAL Pops points off of the PS until the $eoa$ point is hit. These points are inserted into a key set. The key set is evaluated within the context of the PS. If the evaluation succeeds the result point is inserted into the rEVAL register. If the evaluation fails rEVAL is set to $null$ and the point $evalFail$ is pushed onto the PS. In the example below assume the binding [$a$ $b$ $c$]=$d$. The first example run (line 3) fails evaluating [$a$ $b$]. Note that $evalFail$ was added to the PS. On line 8 the evaluation of [$a$ $b$ $c$] succeeds and the PS is empty and register rEVAL contains point $d$ (line 13).

⬇

1trace opEVAL

2ps a,b,eoa,opEVAL

3run

4opEVAL: [a b] failed, ps: empty

5show ps

6ps: evalFail

7ps a,b,c,eoa,opEVAL

8run

9opEVAL: [a b c] => #32: [a b c] = d

10show ps

11ps: empty

12ps rEVAL

13run

14show ps

15ps: d

{labeledpar}

opISATOASopINCCTP Increments the current time point by 1. This is used to force a change in the time point before it would normally be updated by the internal V5 wall clock.

{labeledpar}opISATOASopINCT Copies the current time point into the twine current time point and increments it by one. If there is a sequence of consecutive opINCT opcodes then the twine current time point is incremented for each opcode instance.

{labeledpar}opISATOASopISATOAS Pops the first point off of the PS, recalculates all is-a points for that point and appends the is-a points to the AS. After all is-a points are appended it appends the $asPH$ point.

⬇

1twine big,red,ball<brb

2ps brb,opISATOAS,opSTATE

3run

4state: ps: empty

5aggset: big, red, ball, asPH

6** pq: empty**

7** prNEW: none**

8** prEVAL: none**

9** tCTX: empty**

10** ctp: CTP(2)**

11** tCTP: CTP(1)**

{labeledpar}

opISATOASopLASM Pops points off of the PS and appends them to the AS until the $eoa$ point is reached.

⬇

1ps a,b,c,d,eoa

2run opLASM

3show AS

4aggset: a, b, c, d

{labeledpar}

opISATOASopLUJOIN This opcode is only valid when run within the opLUPARSE operation. It combines two adjacent surrogate points in the AS into one surrogate point.

[TABLE]

{labeledpar}

opISATOASopLULINK This opcode is only valid when run within the opLUPARSE operation. It combines two adjacent surrogate points by twining the second as an is-a of the first (e.g. $p_{1}$ followed by $p_{2}$ twines $p_{2}$<$p_{1}$).

[TABLE]

{labeledpar}

opISATOASopLUPARSE The opcode first clears the AS. It then pops points off of the PS until the eoa point is reached. For each $point$ it determines if the $point$ is grounded (i.e. grounded<$point$). If so then it creates a new surrogate point, twines the point to the surrogate ($point$<$surrogate$) and appends the surrogate to the AS. If the $point$ is not grounded then it appends the left and right chiral points to the AS ($point_{L}$ and $point_{R}$). When all points have been popped off the PS, the language parsing routine as described in section 9 is performed.

{labeledpar}opISATOASopLW1 Pops the top point from the PS and saves it in working memory location 1. It can be referenced via register rWM1.

⬇

1eval rWM1

2**? Internal register (op=507) has no value**

3def a

4ps a,opLWM1

5run

6V5>show ps

7ps: empty

8eval rWM1

9** Register rWM1 = a**

{labeledpar}

opISATOASopPSISAS Recalculate all is-a points off of the points currently in the PS.

{labeledpar}opISATOASopNEW Creates a new point and copies it to register rNEW.

⬇

1eval rNEW

2**? Internal register (op=502) has no value**

3eval opNEW

4eval rNEW

5** Register rNEW = #270**

6ps opNEW,rNEW

7run

8show ps

9ps: #274

{labeledpar}

opISATOASopNEWSUR This instruction is identical to opNEW except that it creates a new surrogate point.

{labeledpar}opISATOASopNEWT Creates a new $t$ (thought) point and copies to the rT register. The engine automatically creates an initial thought point at startup (line 2).

⬇

1eval rT

2** Register rT = T(1)**

3eval opNEWT

4eval rT

5** Register rT = T(2)**

{labeledpar}

opISATOASopOUTPQ Outputs the contents of the print queue (PQ) to the console. The output is prefaced with ‘PQ(m)’ where m is the value of the current-time point.

⬇

1def a,b,c

2ps a,b,c,opADDPQ,opADDPQ,opADDPQ,opOUTPQ

3run

4PQ(1): a b c

{labeledpar}

opISATOASopRASM This instruction performs multiple cycles of aggregate set (AS) reduction until a failure occurs. See section 3.2.1 for more details.

{labeledpar}opISATOASopSURISA This instruction creates a new surrogate point and then pops off points from the PS until the $eoa$ point is detected. Each popped point is is-a twined to the new surrogate point. If rT contains a valid thought point (i.e. opNEWT been executed) then the surrogate is additionally is-a twined to the thought point.

⬇

1def a,b,c,d

2trace bind

3ps opNEWT,a,b,eoa,opSURISA,c,d,eoa,opSURISA

4run

5bind: #32: [#284?.i] = a

6bind: #33: [#284?.i] = b

7bind: #34: [T(2).i] = #284?

8bind: #35: [#288?.i] = c

9bind: #36: [#288?.i] = d

10bind: #37: [T(2).i] = #288?

{labeledpar}

opISATOASopPSISAS (Re)calculates all is-A points for all points currently in the PS.

⬇

1def dog,animal,barney,cat,fluffy

2twine animal<dog ; dog<barney

3twine animal<cat ; cat<fluffy

4ps barney,fluffy,opPSISAS

5show ps

6ps: barney, fluffy, opPSISAS

7run

8show ps

9ps: barney+<dog,animal>, fluffy+<cat,animal>

{labeledpar}

opISATOASopRCTX Removes all points from the twine context set (TC).

{labeledpar}opISATOASopSTATE This is a debugging tool that outputs a short summary of all current V5 states to the console. The example below shows the PS is empty, the PQ (print queue) is empty, no value for rNEW, no value for rEVAL, the twine context set (tCTX) is empty, the current time point is 220 and the twine time point is 1.

⬇

1eval opSTATE

2state: ps: empty

3** pq: empty**

4** prNEW: none**

5** prEVAL: none**

6** tCTX: empty**

7** ctp: CTP(220)**

8** tCTP: CTP(1)**

{labeledpar}

opISATOASopTWVAL Pops the top two points off of the PS. The second point is twined as the value to the first point. Any points in the twine context set are included in the twine.

⬇

1trace opTWVAL

2ps a,b,opTWVAL

3show ps

4ps: a, b, opTWVAL

5run

6opTWVAL: #143: [a.v rCTP(122)] = b

{labeledpar}

opISATOASopVAL Pops the first point off of the PS, converts it to its value variant and repushes back onto the PS. The first run (line 4) pops $a$ off of the PS, converts it to $a.v$ and pushes it back onto the PS. On the second pass the engine sees the $a.v$, evaluates it and replaces it with $b$. The second run (line 9) does the same for point $b$. The evaluation of [$b.v$] is $null$ so nothing is put back onto the PS.

⬇

1def a,b

2twine a>b

3ps a,opVAL

4run

5show ps

6ps: b

7twine b>null

8ps b,opVAL

9run

10show ps

11ps: empty

B.3 Registers

{labeledpar}

rEVALrCTP The current time point.

{labeledpar}rEVALrNEW Holds the new point created by the last opNEW opcode.

{labeledpar}rEVALrEVAL Holds the value point of the last opEVAL opcode.

{labeledpar}rEVALrWM1 Holds the value point of the last point loaded into working memory #1 with the opLWM1 opcode.

{labeledpar}rEVALrTCTX Returns the time point in the twine context set.

{labeledpar}rEVALrT Holds the last thought point created by opNEWT.

B.4 Reserved/Predefined Points

{labeledpar}

determiner$asPH$The AS placeholder point appended to the end of the AS with the opISATOAS instruction (page B.2). {labeledpar}determiner$eoa$ The end-of-arguments point. It is used by various opcodes to indicate the end of a list of arguments in the PS.

{labeledpar}determiner$grounded$ The twine $grounded$<$p$ indicates that the point $p$ is grounded, i.e. it has is-a points that are sensory.

{labeledpar}determiner$determiner$ The twine $determiner$<$p$ indicates that the point $p$ is a noun phrase determiner (e.g. ‘a’, ‘the’).

{labeledpar}determiner$surAction$ This point is within the opLUPARSE instruction. The evaluation of [$surAction$] determines whether or not two contiguous surrogate points are joined or linked.

{labeledpar}determiner$letter$ The letters of the alphabet are predefined within V5 as ‘a’, ‘b’, $\dots$, ‘z’. Each of the letters is twined to the point letter: twine $letter$<‘a’,‘b’,$\dots$,‘z’. {labeledpar}determiner$null$ The $null$ point is used to represent no point. It is also used to indicate no action when the single value of a value twine (p>$null$).

{labeledpar}determiner$evalFail$ This point is added to the PS when the opEVAL operation fails.

{labeledpar}determiner$rasFail$ This point is added to the PS when the opRAS/opRASM operation fails.

{labeledpar}determiner$parse$ This point is inserted into the TC so that is-a twines created as a result of parsing natural language include this point (to distinguish them from is-a points actually describing the surrogate).

Appendix C Initial Data for Pattern Recognition Example

{002 068 082 223 263 295 422 435 489 493 615 672 724 743 744 812 860 887 912 942} 2. 2.

{055 061 062 083 113 205 288 353 476 483 494 520 648 673 780 800 805 938 965 983} 3. 3.

{011 018 146 189 209 271 300 320 477 536 577 578 598 661 748 775 882 909 939 984} 4. 4.

{121 226 246 296 304 518 621 647 711 739 760 782 819 833 878 925 946 963 980} 5. 5.

{056 098 137 152 174 184 329 369 372 376 445 477 491 492 568 578 634 846 866 975} 6. 6.

{007 032 208 228 235 275 276 303 331 344 376 401 411 440 478 571 590 711 805 893} 7. 7.

{035 039 098 116 131 146 211 231 269 285 471 480 481 518 554 576 620 736 790} 8. 8.

{014 032 147 269 316 325 350 499 537 619 628 764 816 825 833 834 864 889 982 999} 9. 9.

{016 045 058 073 136 201 370 420 472 492 543 550 562 711 746 838 938 941 948 972} 10. 10.

{061 117 167 220 257 264 356 362 535 554 595 625 712 751 757 781 804 832 885 994} 11. 11.

{009 012 048 105 189 264 285 321 346 477 538 780 783 800 814 816 875 879 919 920} 12. 12.

{007 031 047 069 085 144 337 420 450 467 546 548 583 604 662 666 688 801 822 857} 13. 13.

{042 090 220 260 268 377 417 457 472 516 517 566 590 630 650 776 816 897 944} 14. 14.

{086 124 125 169 259 276 283 298 307 326 432 457 593 605 617 649 724 805 946} 15. 15.

{006 064 085 156 160 170 212 231 300 371 546 572 638 651 661 682 879 883 900 987} 16. 16.

{013 088 177 218 265 272 275 333 409 495 608 621 710 795 850 873 887 889 933} 17. 17.

{004 145 180 322 330 347 512 568 615 623 657 685 709 750 766 799 805 899 947 982} 18. 18.

{014 087 101 109 110 113 228 248 298 312 313 338 485 564 586 652 725 799 840 877} 19. 19.

{042 043 101 211 307 326 350 352 401 418 443 457 503 528 563 591 601 803 849} 20. 20.

{067 101 169 211 225 250 264 307 401 439 503 542 548 601 638 668 709 738 880 944} 21. 21.

{007 008 018 027 123 136 152 162 188 214 216 220 253 325 711 734 759 843 871 956} 22. 22.

{190 267 313 340 352 367 394 417 489 497 593 595 726 734 853 870 882 905 920 967} 23. 23.

{000 016 071 091 097 151 156 193 213 223 309 521 545 569 571 672 723 763 765 996} 24. 24.

{066 111 147 203 270 311 333 337 452 455 475 492 521 575 641 653 655 859 960} 25. 25.

{101 192 211 282 307 317 401 425 503 506 528 548 563 567 601 656 664 691 825 940} 26. 26.

{028 032 114 130 132 133 136 184 262 406 452 460 498 619 643 739 742 852 915 997} 27. 27.

{031 102 105 135 138 147 198 204 374 408 539 547 564 584 586 784 792 808 917 995} 28. 28.

{001 123 137 146 211 244 250 285 308 563 600 612 632 677 694 777 799 875 886 992} 29. 29.

{081 101 158 196 211 277 307 309 401 430 483 503 599 601 626 653 727 749 819 885} 30. 30.

{002 051 060 121 180 246 267 369 411 450 469 541 582 645 647 722 757 812 866 903} 31. 31.

{012 048 078 146 332 425 527 567 646 658 693 718 723 747 809 813 834 866 982} 32. 32.

{008 033 103 218 224 275 307 330 337 486 495 512 523 553 583 636 702 707 909 928} 33. 33.

{028 045 101 160 190 211 215 266 307 385 401 503 529 591 601 608 751 815 881 893} 34. 34.

{027 064 191 219 246 319 323 368 379 444 539 623 691 827 870 884 896 903 936 954} 35. 35.

{064 073 087 132 213 300 322 339 409 434 447 487 510 535 620 684 852 875 952} 36. 36.

{047 178 197 232 359 384 460 481 627 634 702 707 830 839 879 888 891 898 955 968} 37. 37.

{030 055 087 161 223 385 391 409 515 570 615 689 726 761 814 820 834 845 922 965} 38. 38.

{041 067 115 179 188 212 314 361 405 636 669 705 757 759 770 787 841 846 952 953} 39. 39.

{018 059 076 193 243 315 377 419 485 488 560 606 723 758 788 870 908 931 941} 40. 40.

{171 189 219 277 294 332 335 336 358 421 426 430 489 589 738 787 843 850 933 998}

Appendix D Parsing Speech using the opRASM Instruction

A few examples of parsing with speech with the opRASM are presented in this appendix. The capabilities of this approach go beyond those of the LTT process. The abbreviations (points) used in these examples for the different parts of speech are described in figure 28.

The first section of this example defines the relationships of words to parts of speech. Note that some of the words can have multiple syntactic meanings (lines 1, 3, 6).

⬇

1twine artD<the ; noun<man,ball,tuxedo ; prep<to ; infP<to

2twine prep<in ; pnoun<john,mary ; adj<red ; pnoun<mary

3twine noun<ball ; verbT<ball,threw ; prep<threw

4twine noun<question ; pronoun<you ; noun<saw ; verb2b<is

5twine gerundI<going ; tspec<today ; verbT<saw ; tspec<yesterday

6twine pnoun<google ; verbT<google ; person<nounMan

7twine clothes<nounTuxedo

8

9bind [john pnoun] pnounJohn

10bind [mary pnoun] pnounMary

11bind [ball noun] nounBall

12bind [man noun] nounMan

13bind [tuxedo noun] nounTuxedo

14bind [question noun] nounQuestion

15bind [adj red] adjRed

16bind [verbT threw] verbTthrow

17bind [verbT google] verbTGoogle

18bind [pnoun google] pnounGoogle

19bind [prep to] prepTo

20bind [prep in] prepIn

The next section of the example defines the rules for parsing a string of words via the AS reduction instruction (opRASM).

⬇

21bind +2 [-artD/-noun] opNEWSUR,rNEW,np,opTWISA,eoa,noun,noun.v,opEVAL,rNEW,

22 rEVAL,opTWISA,rNEW

23bind +2 [-artD/-adj] opNEWSUR,rNEW,np,opTWISA,eoa,adj,adj.v,opEVAL,rNEW,rEVAL,

24 opTWISA,rNEW

25bind +2 [-np/-noun] eoa,noun,noun.v,opEVAL,np.v,rEVAL,opTWISA,np.v

26bind [-np/pronoun] dnp

27bind [-np/-verbT] vtws

28bind [vtws/-tspec] null

29bind [dnp/-vtws] null

30bind [-verb2b/-gerundI] opNEWSUR,rNEW,gerundI.v,opTWISA,vpI

31bind [-dnp/-vpI] viws

32bind [-dnp/-vpT] vtws

33bind [-dnp/-verbT] vtws

34bind +1 [-verbT/-np] opNEWSUR,eoa,verbT,verbT.v,opEVAL,rNEW,rEVAL,opTWISA, np.v,obj,

35 opTWISA, rNEW,tvobj,opTWISA,vtwo

36bind +1 [-infP/-vtwo] null

37bind [-vtws/-vpI] null

38bind [-pnoun/-vpI] viws

39bind [-prep/-pnoun] opNEWSUR,rNEW,prep,opTWISA,eoa,prep,prep.v,opEVALt,rNEW,rEVAL,

40 opTWISA,eoa,pnoun,pnoun.v,opEVALt,rNEW,rEVAL,opTWISA,null

41bind [-prep/-np] np.v,prep.v,opTWISA,np.v

42bind +2 [-prep/-clothes] np.v,prepToWear,opTWISA,np.v

43bind [-viws/-tspec] null

44bind [-pnoun/-vtwo] opNEWSUR,rNEW,sub,opTWISA,eoa,pnoun.v,pnoun,opEVAL,rNEW,

45 rEVAL,opTWISA,null

46bind [-np/-vtwo] np.v,sub,opTWISA,np.v

47bind [-np/-vpI] np.v,sub,opTWISA,null

48bind [-person/-prepToWear] person.v,prepToWear.v,opTWISA,null

The first two examples demonstrate how the contextual evaluation selection of the highest binding weight can be used to disambiguate words. In the first example, the word ‘google’ in the phrase ‘to google’ is taken as a verb. The parse tree generated for the sentence ‘The man is going to google the question’ is shown in figure 29.

⬇

44ps the,man,is,going,to,google,the,question,eoa

45run opLASM

46trace opTWISA

47run opRASM

In the second example, the word ‘google’ in the phrase ‘to google’ is taken as a noun (place). The parse tree for the sentence ‘The man is going to google’ is shown in figure 30.

⬇

48ps the,man,is,going,to,google,eoa

49run opLASM

50trace opTWISA

51run opRASM

The last example demonstrates how semantic knowledge can be utilized to resolve a dangling prepositional phrase. In the sentence ‘The man threw the ball in the tuxedo’ the phrase ‘in the tuxedo’ is associated with the subject (‘the man’). The resulting parse tree is shown in figure 31.

⬇

52ps the,man,threw,the,ball,in,the,tuxedo,eoa

53run opLASM

54trace opTWISA

55run opRASM