The Computational Origin of Representation

Abstract

Each of our theories of mental representation provides some insight into how the mind works. However, these insights often seem incompatible, as the debates between symbolic, dynamical, emergentist, sub-symbolic, and grounded approaches to cognition attest. Mental representations—whatever they are—must share many features with each of our theories of representation, and yet there are few hypotheses about how a synthesis could be possible. Here, I develop a theory of the underpinnings of symbolic cognition that shows how sub-symbolic dynamics may give rise to higher-level cognitive representations of structures, systems of knowledge, and algorithmic processes. This theory implements a version of conceptual role semantics by positing an internal universal representation language in which learners may create mental models to capture dynamics they observe in the world. The theory formalizes one account of how truly novel conceptual content may arise, allowing us to explain how even elementary logical and computational operations may be learned from a more primitive basis. I provide an implementation that learns to represent a variety of structures, including logic, number, kinship trees, regular languages, context-free languages, domains of theories like magnetism, dominance hierarchies, list structures, quantification, and computational primitives like repetition, reversal, and recursion. This account is based on simple discrete dynamical processes that could be implemented in a variety of different physical or biological systems. In particular, I describe how the required dynamics can be directly implemented in a connectionist framework. The resulting theory provides an “assembly language” for cognition, where high-level theories of symbolic computation can be implemented in simple dynamics that themselves could be encoded in biologically plausible systems.

Appendix A: Sketch of Universality

It may not be obvious that any statement about the relation between objects can be encoded into an LCL system. Here, I sketch a simple proof that this is possible when we are allowed to define what function composition means. My focus is on the high-level logic of the proof while attempting to minimize the amount of notation required. Let’s suppose that we are given an arbitrary base fact like,

We may re-write this into binary constraints, with a single variable on the left and a single function application on the right, by introducing “dummy” variables , , etc:

This is akin to Chomsky normal form for a context-free grammar.

The challenge then is to find a mapping from symbols to combinators that satisfies these expressions. A difficulty to note is that some variables, like , may appear on the left and the right, meaning that their combinator structure must be the output of a function (appearing on the left) as well as a function that itself does something useful (on the right). To address this, the proof sketch here will assume that we are allowed to define the way functions are applied. For instance, instead of requiring $\rightarrow$, we will replace the function application with our own custom one, . When , we are left with ordinary function application. I do not determine here if requiring permits universal isomorphism. But we can show that if we are free to choose , we can satisfy any constraints.

With this change, we can re-write our base facts as,

With this addition, we can take each of the symbols ( and ) and give them each an integer with Church encoding. Standard schemes for this can be found in Pierce (2002). Integers in Church encoding also support addition, subtraction, and multiplication. We may therefore view these facts as a set of integer-values, where is a function from two (integer) arguments to a single (integer) outcome:

Note that at this point we may check if the facts are logically consistent—they may not state, for instance, that $\rightarrow$, $\rightarrow$, and $\ne$.

Assuming consistency, we may then explicitly encode the facts by setting to be a polynomial which encodes these facts. To see how this is possible, suppose we have constraints

It is well-known that in one dimension, any set of x, y points can be approximated by a polynomial. The same holds for two dimensions, with a variety of available techniques. This means that we can set to be the combinator that implements the polynomial mapping each $\alpha _i$, $\beta _i$ to $\gamma _i$ with the desired accuracy.

An alternative to 2D polynomials is to use Gödel numbering to convert the two-dimensional problem to a one-dimensional one. If first converts its arguments to a single integer, for instance $2^{\alpha _i} 3^{\beta _i}$, then the problem of finding the right polynomial reduces to a one-dimensional interpolation problem. Explicit solutions then exist, such as this version of Lagrange’s solution to the general problem,

(2)

To check this, note that when $i=j$, the fractions inside the product cancel and the coefficient for $\gamma _j$ becomes 1. However, when $i \ne j$, then there will be some numerator term which is zero, canceling out all of the other $\gamma _m$. Together, these give the output of as $\gamma _i$ when given $\alpha _i$ and $\gamma _i$ as input.

Note that this construction does not guarantee sensible generalizations when running on new symbols. The specific patterns of generalization will depend on how symbols are mapped to integers, but more problematically, polynomial interpolation famously exhibits chaotic or wild behavior on points other than those that are fixed, a fact known as Runge’s phenomenon (Runge 1901). As a result, the polynomial mapping should be taken only as an existence proof that some mapping of combinators will be able to satisfy the base facts, or the combinatory logic can in principle encode any isomorphism when we define function application with .