Allocentric navigation is computationally universal

Abstract

I present three proofs that idealized neurocomputational architectures capable of navigation guided by allocentric maps with landmark structure can be computationally universal. Navigation may occur online, in the environment, or offline, in the animal’s head. The first proof encodes the counters of a two-counter machine as positions of movable markers on orthogonal axes. The second directly simulates a one-tape Turing machine using a writable tape-path embedded in the map. The third realizes the tape-path’s predecessor/successor relation through local cues at a two-row landmark track rather than through a globally indexed path primitive. I establish universality in two senses: each class of navigation models is Turing-complete, and each contains a single machine that simulates every machine in its class. These constructions are mathematically close to classical graph-based models, including Kolmogorov–Uspensky machines, storage-modification machines, and graph Turing machines, so the bare computability results are unsurprising. My contribution is to reconstruct them explicitly within an allocentric cognitive-map architecture whose representational and computational primitives are drawn from empirical and theoretical work on spatial navigation and cognitive control. This shows that an allocentric navigation-based architecture can be computationally universal and opens the possibility of reconstructing aspects of biological cognition, including symbolic processing, in navigation-based terms.

Introduction

I prove three sufficiency theorems showing that idealized navigation-based architectures with allocentric maps and landmark structure can be computationally universal. The underlying mathematical ideas are close to classical results from computability theory, especially work on counter machines, graph-based machines, and locally navigable memory structures. My contribution is to reconstruct those results explicitly within the framework of navigation in allocentric cognitive maps, a type of neurocomputational architecture independently motivated by empirical and theoretical neuroscience. I thereby show how established universal computational models can be reformulated within an allocentric navigation-based architecture.

I use “neurocomputational” to characterize the target architecture: its relevant components are neural and their operations are neural computations. I do not mean that the machine models below are artificial neural networks; neural computation need not be modeled using a neural-network formalism [1, 2]. Counter machines, Turing machines, and storage-modification machines are machine models in the same sense. Here I characterize the architecture only finely enough to establish its computational power, leaving its network organization and dynamics open (Section 7). 

In contemporary neuroscience, allocentric cognitive maps and associated cognitive control are widely discussed representational and computational structures that organize knowledge relative to stable environmental features rather than momentary egocentric position [3–5]. Many animals use allocentric, landmark-anchored spatial representations in navigation [6]. In mammals, hippocampal activity can replay previously experienced trajectories and, in some cases, preplay trajectories later expressed during navigation [7, 8]. There is increasing evidence that hippocampal-entorhinal cognitive maps support functions beyond navigation, including memory, inference, and abstract relational knowledge, and that related map-like representations are present in other brain regions [9–12]. There is also evidence that hippocampal map-like activity is organized around action rather than wayfinding alone: in CA1, population activity was better predicted by the animal’s evolving action plan than by sensory or spatial variables themselves, suggesting that hippocampal activity can encode planned action sequences rather than location as such [13]. Prefrontal and orbitofrontal control systems also contribute to goal-directed navigation, route planning, detouring, and prospective or simulated navigation within cognitive maps [14–18]. This evidence raises the question of what representational and computational power allocentric navigation systems possess.

To answer this question, I formulate and prove a family of claims of the following form: an architecture that represents space in an allocentric coordinate system, represents landmarks at locations within that system, stores information at landmarks, can internally simulate navigation among those landmarks, and can internally simulate performing operations at those landmarks can compute any Turing-computable function under idealizations standard in computability theory.

While the primary target of this article is the representational and computational power of architectures capable of simulating navigation and action internally within cognitive maps, the navigation need not occur offline for the universality results to obtain. The sort of allocentric navigation investigated in this article may be entirely simulated in an animal’s head or it may occur partly or wholly within the animal’s environment. The extent to which navigation occurs online or offline makes a difference to how cognitively demanding the task is, because keeping track of all the needed information in one’s head requires more cognitive resources than storing some of that information in the environment. For the purposes of the universality results, however, that difference is immaterial so long as the same operations are available.

The benchmark is Turing universality in the standard sense established by Turing’s analysis of effective calculability [19]. A convenient auxiliary benchmark is universality via counter or register machines, especially the simple two-counter models associated with Minsky and related register-machine formalisms [20–22]. The first proof simulates two-counter machines by using two movable markers on coordinate axes to encode unbounded counters. The second proof simulates standard one-tape Turing machines by embedding a writable tape-path in the allocentric map. The third proof is the most local: it still simulates ordinary Turing machines directly, but it dispenses with any globally indexed path available to the machine itself and uses only local directional information at the landmark it currently occupies.

Computing systems are standardly said to be universal in two senses—for instance, Minsky [21] employs both. In the first sense, a system or a class of systems is Turing-universal, or equivalently Turing-complete, when the systems in that class can compute every Turing-computable function. This is the sense in which the $\lambda$-calculus, tag systems, and elementary cellular automaton Rule 110 are said to be universal [23]. In the second sense, a single machine is universal for a class when, given an encoded description of any machine in the class together with an input, it computes what that machine computes. This is the sense in which universal Turing machines are universal [21, 24, 25]. Definitions 3.6 and 3.7 make both notions precise. Theorems 4.5, 5.4, and 6.5 establish the first for each of the three navigation models; Corollary 6.8 establishes the second.

The constructions are mathematically close to several classical graph-based machine models. Accordingly, the bare universality results are mathematically unsurprising. What is new here, as far as I know, is the explicit reconstruction of those results inside a navigation-based allocentric-map architecture of a kind that is independently motivated by neuroscientific evidence. The significance of this contribution is architectural and interdisciplinary: it shows that a neurocomputational architecture often associated primarily with spatial navigation can, under standard idealizations, realize universal computation.

This conclusion bears on a familiar line of criticism according to which nonclassical neurocomputational architectures cannot by themselves explain the productivity, systematicity, compositionality, or generality of cognition and therefore require supplementation by a classical symbolic architecture [e.g., 26, 54]. It also bears on contemporary debates over whether the available evidence warrants assigning representational functions to neural states [e.g., 27]. The present results show that navigation-based architectures have sufficient representational and computational power. This entails that such architectures can, in principle, realize arbitrarily complex computable transformations, including transformations exhibiting the kinds of productivity, systematicity, and compositionality often taken to require a classical symbolic architecture. This is a claim about computational capacity, not by itself an explanation of how biological cognition exhibits those properties.

The same conclusion also bears on a second and opposite source of pressure. Radical enactivist, ecological, and dynamicist approaches emphasize embodied agent–environment coupling and have often been developed as alternatives to orthodox explanations in terms of internal computation and representation [28–35]. The present results do not vindicate a return to classical internal symbol manipulation. Allocentric navigation is itself embodied, action-oriented, dynamically controlled, and often environmentally embedded. What the results show, rather, is that even architectures situated in all these ways can naturally be analyzed in terms of representational and computational power [cf. 36]. Once an allocentric navigation system includes stable map-like states, landmark relations, stored item information, local transitions, and controllable movement or simulated movement through a map, its operations can, at the relevant level of analysis, be described as computations over representations and assessed for the class of transformations they can realize. Thus, the relevant contrast is not between classical symbolic computation and no computation or representation at all. A navigation-based architecture can be nonclassical, embodied, and dynamically controlled while still having the same computability-theoretic power as classical symbolic models.

Together, these points open the possibility of explaining higher cognition, including symbolic processing itself, in terms of cognitive map-based computation. Cognitive maps do not normally store and process symbols in any linguistic or language-like sense. What they store is information about the allocentric relations among locations, landmarks, and other items located within the map, together with operations that may be performed on such items. The present results show that those resources are sufficient for universal computation. Symbolic processing therefore need not be treated as architecturally basic but may instead be reconstrued in terms of map-like resources already known to exist in the brain.

At the same time, I do not argue that any biological system literally implements a Turing machine or any other classical computing device, whether universal or otherwise. Nor do I imply that implementing classical Turing-style computation within cognitive maps is required to explain cognition. Nor, finally, do I claim that a computational model by itself accounts for a cognitive process; it does not. The point is, rather, that a computational architecture often seen as capable at best of allegedly “low-level” cognitive tasks such as navigation, or perhaps too weak even for navigation without the support of allegedly more powerful symbolic architectures [e.g., 54], can, under standard idealizations, support universal computation. To that extent, cognitive map-based architectures are rich enough in principle to realize any computable cognitive function. Whether they in fact explain cognition, and if so whether they do it by classical or nonclassical means, is a separate empirical question.

The remainder of this article proceeds as follows: Section 2 outlines historical antecedents, Section 3 provides formal preliminaries and finitary conventions, Sections. 4 through 6 present the three models and proofs of universality, Section 7 discusses the significance of the proofs, Section 8 discusses the proofs’ scope, and Section 9 concludes.

Historical background

While the motivation for the present results stems from reflections on the relation between allocentric navigation and computational universality, the proofs have historical antecedents within computability theory. The most relevant predecessors are graph-based machines in which memory is not a linear tape but a mutable or navigable graph with a distinguished active location. The oldest example is Kolmogorov and Uspensky’s graph-based conception of algorithmic computation. In this model, machines operate locally on graph-structured memory, and the resulting class of machines computes all partial recursive functions [37].

A second close predecessor is Schönhage’s storage-modification machine. Here memory is represented by a mutable directed graph and computation proceeds by local pointer manipulations around an active node. This is mathematically very close to a navigation-based architecture in which an agent accesses and updates memory through local moves among landmarks [38].

A third close family is graph Turing machines. Ackerman and Freer formulate computation on vertex-labeled, edge-colored graphs and explicitly prove that ordinary Turing computation can be recovered inside that framework. Their model differs from the present one in being designed first and foremost as a graph-computation formalism rather than as a cognitive-map architecture, but it is relevant for any claim that graph-like spatial organization plus local rules can support universality [39].

There is also a neighboring literature on graph-walking automata and graph exploration. This work is relevant because it treats movement through a graph as a computational primitive and analyzes how much can be achieved when an automaton navigates an environment using only local information. This literature is also useful as a cautionary contrast: finite-state navigation by itself is generally not universal unless one adds unbounded memory resources [40, 41].

On the neurocognitive side, the allocentric-map framework used in this article is motivated by a large literature on hippocampal and entorhinal representations. The original cognitive-map program of O’Keefe and Nadel was linked to evidence of place cells, and subsequent work on place cells, grid cells, boundary cells, head-direction cells, object-vector cells, and related systems has made allocentric spatial coding a central part of contemporary theories of navigation and memory [3, 5, 42, 43].

As far as I have been able to determine, no prior source makes universality arguments explicit in the distinctive vocabulary of allocentric coordinates, landmarks, and navigation while simultaneously situating the architecture within the empirical cognitive-map literature. In this respect the results are mathematically unsurprising but conceptually novel and theoretically significant for the mind sciences.

The three models presented below may be summarized as follows. The counter-based model uses two movable marker positions on orthogonal axes to simulate a two-counter machine, thereby showing how spatial position alone can encode unbounded memory. The tape-path model uses writable labels on landmarks along a designated bi-infinite path to simulate an ordinary one-tape Turing machine, thereby identifying landmarks with memory cells. The local-layout model uses writable labels plus only local predecessor/successor cues in a two-dimensional field to simulate an ordinary one-tape Turing machine while staying closest to navigation among landmarks using local structure. The three models differ in which representational and operational resources the machine is granted: two axis-bound markers with zero-detection tests and no writable labels; writable labels together with a path whose adjacency relation is given as a primitive; and writable labels together with nothing but locally stored direction data, with no globally indexed path supplied to the transition rule.

Preliminaries and finitary conventions

Throughout, $\mathbb{N}=\{0,1,2,\cdots \}$ and $\mathbb{Z}$ is the set of integers. For a function $f$ and arguments $u,v$ in its domain and codomain respectively, $f\left[u,\mapsto ,v\right]$ denotes the function agreeing with $f$ everywhere except at $u$, where it takes the value $v$. Monus, or truncated subtraction, is written $\dot{-}$: $a\dot{-}b=a-b$ if $a\ge b$ and $a\dot{-}b=0$ otherwise. Only the case $b=1$ is used below.

Definition 3.1 (deterministic one-tape Turing machine)

A deterministic one-tape Turing machine is a tuple

$$M=\left(Q,,,\mathrm{\Gamma },,,\square ,,,q_0,,,q_h,,,\delta \right)$$

where $Q$ is a finite set of states, $\mathrm{\Gamma }$ is a finite tape alphabet, $\square \in \mathrm{\Gamma }$ is the distinguished blank symbol, $q_0\in Q$ is the start state, $q_h\in Q$ is the halting state, and

$$\delta :\left(Q,\backslash ,\{,q_h,\}\right)\times \mathrm{\Gamma }\to Q\times \mathrm{\Gamma }\times \{L,R\}$$

is the transition function. Let $T_{\mathrm{\Gamma }}=\left\{t:\mathbb{Z}\to \mathrm{\Gamma }|t,\left(i\right),=,\square ,,\mathrm{for},,\mathrm{all},,\mathrm{but},,\mathrm{finitely},,\mathrm{many},,i,\in ,\mathbb{Z}\right\}$ be the set of tape functions: the finite-support functions from cell indices to letters. A configuration of $M$ is a triple

$$\left(q,,,h,,,t\right)\in Q\times \mathbb{Z}\times T_{\mathrm{\Gamma }}$$

where $q$ is the current state, $h$ is the integer head position, and $t$ is the current tape function. Thus $h$ is not an element of $\mathrm{\Gamma }$: $\mathrm{\Gamma }$ is the tape alphabet, $h$ is an integer indexing a tape cell, and $t$ is one member of the set $T_{\mathrm{\Gamma }}$, different configurations in general having different tape functions.

The one-step relation ⊦_M on configurations is defined as follows. Let $a=t\left(h\right)$ and suppose $\delta \left(q,,,a\right)=\left(q^{\prime },,,b,,,D\right)$. Then

$$\left(q,,,h,,,t\right){⊢}_M\left(q^{\prime },,,h^{\prime },,,t,\left[h,\mapsto ,b\right]\right)$$

where $h^{\prime }=h-1$ if $D=L$ and $h^{\prime }=h+1$ if $D=R$.

Note that $T_{\mathrm{\Gamma }}$ is closed under single-cell updates, so $t\left[h,\mapsto ,b\right]\in T_{\mathrm{\Gamma }}$. Configurations with state $q_h$ have no ⊢_M -successor; every other configuration has exactly one. Hence ⊢_M is a partial function and $M$ is deterministic. Write ${⊢}_M^{*}$ for its reflexive-transitive closure.

Definition 3.2 (CM2-programs and their semantics)

Let $\mathit{Lab}$ be a finite set of labels containing a distinguished start label ${\ell }_0$ and a distinguished halt label ${\ell }_h$. The set $Instr\left(L,a,b\right)$ of CM2-instructions over $\mathit{Lab}$ is generated by the grammar

$$Instr::=inc\left(k,,,\ell \right)\mid jzdec\left(k,,,\ell ,,,{\ell }^{\prime }\right),k\in \{1,2\},\ell ,{\ell }^{\prime }\in Lab$$

A CM2-program is a pair $P=\left(L,a,b,,,\iota \right)$, where $\iota :Lab\backslash \{{\ell }_h\}\to Instr\left(L,a,b\right)$ assigns exactly one instruction to each non-halting label. A CM2-configuration is a triple $\left(\ell ,,,m,,,n\right)\in Lab\times \mathbb{N}\times \mathbb{N}$, where $\ell$ is the current label and $m,n$ are the values of the two counters $c_1,c_2$. The one-step relation ${⊢}_P$ is defined by cases on $\iota \left(\ell \right)$:

(i) $\iota \left(\ell \right)=inc\left(1,,,{\ell }^{\prime }\right):\left(\ell ,,,m,,,n\right){⊢}_P\left({\ell }^{\prime },,,m,+,1,,,n\right)$; (ii) $\iota \left(\ell \right)=inc\left(2,,,{\ell }^{\prime }\right):\left(\ell ,,,m,,,n\right){⊢}_P\left({\ell }^{\prime },,,m,,,n,+,1\right)$; (iii) $\iota (\ell )=\mathit{jzdec}(1,{\ell }^{\prime },{\ell }^{\prime \prime }):(\ell ,0,n){⊢}_P({\ell }^{\prime },0,n)\text{and}(\ell ,m+1,n){⊢}_P({\ell }^{\prime \prime },m,n)$; (iv) $\iota \left(\ell \right)=jzdec\left(2,,,{\ell }^{\prime },,,{\ell }^{″}\right):\left(\ell ,,,m,,,0\right){⊢}_P\left({\ell }^{\prime },,,m,,,0\right)$ and $\left(\ell ,,,m,,,n,+,1\right){⊢}_P\left({\ell }^{″},,,m,,,n\right)$.

Configurations with label ${\ell }_h$ have no ${⊢}_P$-successor; every other configuration has exactly one. Hence ${⊢}_P$ is a partial function and every CM2-program is deterministic. The partial function ${\varphi }_P:\mathbb{N}\rightharpoonup \mathbb{N}$ computed by $P$ is defined by: ${\varphi }_P\left(a\right)=b$ if and only if $\left({\ell }_0,,,a,,,0\right)⊢_P^{\ast }\left({\ell }_h,,,b,,,n\right)$ for some $n\in \mathbb{N}$.

Remark 3.3 (universality of CM2 and input conventions)

Deterministic two-counter machines are a standard universal model of computation [20–22]. The input convention matters. Two counters suffice to simulate any Turing machine when inputs and outputs are exponentially coded, as $2^a$ and $2^{\text{answer}}$; with the identity convention they are strictly weaker, because a two-counter machine cannot compute $a\mapsto 2^a$ [44]. Nothing below depends on the choice of convention. Theorem 4.5 simulates CM2-programs instruction by instruction, so the counter-based navigation model inherits whatever functions CM2-programs compute under the chosen convention.

Two features of these standard results are used below. First, the simulations can be chosen to be step-for-step in the sense of Definition 3.5, including its injectivity requirement. To make this explicit, begin with a standard two-stack encoding of the tape relative to the head and adjoin the absolute head position, represented by h⁺ = max(h, 0) and h⁻ = max(−h, 0), using two additional prime exponents in the numerical code. The resulting configuration code is injective. Each Turing-machine step updates the two stack codes and the signed head-position code by a finite CM2 macro. By assigning fresh auxiliary labels to the interior of each macro, we ensure that no intermediate CM2 configuration lies in the image of the encoding; mapping the Turing-machine halt state to the CM2 halt label preserves terminality. Second, because the machines so simulated include the universal one-tape Turing machines, there is a CM2-program $P_U$ that, given a Gödel-coded description of an arbitrary one-tape Turing machine together with a coded input, computes what that machine computes on that input.

Definition 3.4 (navigation architecture and navigation model)

I use “navigation neurocomputational architecture” in the cognitive-neuroscientific sense: a system of computing components that represents locations, allocentric relations, landmarks, items stored at landmarks, movements or simulated movements among landmarks, and operations or simulated operations performed at landmarks.

A navigation model is the corresponding mathematical model: a finitely described machine whose configurations include a finite control state, a current map location or cursor position, and a finitely represented arrangement of markers or stored landmark labels. The three navigation models used below are defined explicitly in Definitions 4.1, 5.1, and 6.1, together with their instruction syntax and their one-step relations.

This terminology is meant to keep two issues apart. As navigation models, the machines below are ordinary effective machines. As neurocomputational architectures, they are redescriptions of computation in the vocabulary of allocentric maps and navigation.

Definition 3.5 (step-for-step simulation)

Let $S$ and $S^{\prime }$ be deterministic machines with configuration sets $C$ and $C^{\prime }$ and one-step relations $⊢$ and $\Rightarrow$ respectively. An injection $E:C\to C^{\prime }$ is a step-for-step simulation of $S$ in $S^{\prime }$ if

1. for every $c\in C$ that has a $⊢$-successor $d$, there is $k\ge 1$ such that $E\left(c\right){\Rightarrow }^{k}E\left(d\right)$ and, for every j with $0<j<k$, no configuration reached from $E\left(c\right)$ in exactly $j$ steps lies in the image of $E$; and

2. for every $c\in C$ $c$ is $⊢$-terminal if and only if $E\left(c\right)$ is $\Rightarrow$-terminal. 

The derivation in (a) is called a macro-step. When $k=1$ for every $c$, the simulation is lock-step. Because both machines are deterministic, (a) and (b) jointly imply that for all $c,d\in C$: $c⊢_{}^{\ast }d$ and $d$ is terminal if and only if $E\left(c\right)\Rightarrow _{}^{\ast }E\left(d\right)$ and $E\left(d\right)$ is terminal. Halting behavior, final control state, and final memory contents are therefore preserved in both directions.

Definition 3.6 (Turing-completeness of a class)

A class $K$ of machines is Turing-complete, equivalently Turing-universal, if for every deterministic one-tape Turing machine $M$ there exists a machine $A\in K$ and a computable injection $E$ that is a step-for-step simulation of $M$ in $A$.

Definition 3.7 (universal machine for a class)

A machine $A_{}^{\ast }\in K$ is universal for $K$ if there are a computable coding $⟨·⟩$ of the machines in $K$ and computable input and output codings such that, for every $A\in K$ and every input $w$ for $A$, $A_{}^{\ast }$ on input $⟨A⟩$ followed by $w$ halts if and only if $A$ halts on $w$, and then yields the encoded output of $A$ on $w$.

Definitions 3.6 and 3.7 are logically independent in general, and both are called universality in the literature. Both are established below: Theorems 4.5, 5.4, and 6.5 give Turing-completeness for the three classes; Corollary 6.8 gives a universal machine within each class.

Note that when $K$ is Turing-complete, a machine universal for $K$ is thereby able to compute every Turing-computable function; the two notions are independent in general but coincide in that respect here.

Convention 3.8 (finite descriptions and finite support)

All machines considered in this article are finitely described. Their control sets and transition tables are finite. Their maps are unbounded only in the ordinary potential-infinity sense in which a Turing tape is unbounded. At any moment, only finitely many markers or nonblank landmark labels need to be represented explicitly. Sets such as $T_{\mathrm{\Gamma }}$, and the set ${\mathrm{\Lambda }}_{\mathrm{\Gamma }}$ of landmark labelings introduced in Definition 5.1, are sets of finite-support functions; their members are metatheoretic descriptions of finite memory states, not completed infinite objects made available to the machine as oracles. This is the standard finitary interpretation of effective computation [19, 45].

With this convention in place, the theorems below establish ordinary Turing universality. The reverse direction, that each of the navigation models is itself simulable by a Turing machine, is verified in Corollary 6.7.

Universality by navigation on two coordinate axes

The first navigation model uses two one-dimensional axes embedded in a two-dimensional allocentric frame. One movable marker $X$ is constrained to the horizontal axis and one movable marker $Y$ is constrained to the vertical axis. Their distances from the origin encode the values of two unbounded counters. The internal control state of the machine plays the role of the finite control of a counter machine. Thus, the model does not require a rich two-dimensional field of memory locations; it uses two spatial registers distinguished by their allocentric axes.

Definition 4.1 (counter-based allocentric navigation machine)

Let $D=\{E,W,N,S\}$ be the set of directions and $B=\{atO,atX,atY\}$ the set of tests. For a finite set $Q$, the set of navigation instructions over $Q$ is generated by the grammar

$$NInstr\left(Q\right)::=move\left(d,,,q\right)\mid shift\left(d,,,q\right)\mid test\left(\beta ,,,q,,,q^{\prime }\right),d\in D,\beta \in B,q,q^{\prime }\in Q$$

A counter-based allocentric navigation machine is a tuple

$$A=\left({\mathbb{N}}^2,,,O,,,Q,,,q_0,,,q_h,,,\mathrm{\Pi }\right)$$

where ${\mathbb{N}}^2$ is the map, $O=\left(0,,,0\right)$ is the origin, $Q$ is a finite set of control states, $q_0\in Q$ is the start state, $q_h\in Q$ is the halt state, and

$$\mathrm{\Pi }:Q\backslash \{q_h\}\to NInstr\left(Q\right)$$

is the navigation program, which assigns exactly one instruction to each non-halting control state. Control states thus play the role of instruction labels, and a program is a finite labeled instruction list.

Two things should be kept apart here. The navigation program $\mathrm{\Pi }$ is an aspect of the machine, in the same way that the transition table $\delta$ of a Turing machine is an aspect of that machine: it is fixed structure, not an object stored at locations in the map and read off during computation. Calling $\mathrm{\Pi }$ a program therefore imports no stored-program or von Neumann organization—an ordinary Turing machine is not stored-program either. A fortiori, nothing in the models below requires that a navigation architecture store, address, or interpret encoded instructions. Corollary 6.8 does exhibit a navigation machine that reads an encoded description of another machine from the map itself; but that is a result about one thing that such architectures can do, not a claim that biological navigation is generally organized that way.

A configuration of $A$ is a quadruple

$$\gamma =\left(q,,,p,,,x,,,y\right)\in Q\times {\mathbb{N}}^2\times \mathbb{N}\times \mathbb{N}$$

where $q$ is the control state, $p$ is the position of the cursor, and $x$ and $y$ are the positions of the two markers: marker $X$ occupies $\left(x,,,0\right)$ and marker $Y$ occupies $\left(0,,,y\right)$. The cursor and the two markers are three distinct components of a configuration. The cursor is where the machine currently is, or simulates being; the markers are items located in the map. Marker positions are not projections of the cursor position, and neither determines the other.

Definition 4.2 (primitive operations and one-step relation)

The four move functions on ${\mathbb{N}}^2$ are total:

$$E\left(a,,,b\right)=\left(a,+,1,,,b\right),W\left(a,,,b\right)=\left(a,,\dot{-},,1,,,b\right),N\left(a,,,b\right)=\left(a,,,b,+,1\right),S\left(a,,,b\right)=\left(a,,,b,,\dot{-},,1\right)$$

Using monus makes $W$ and $S$ total: at the corresponding axis boundary they leave the cursor in place. The three tests are predicates on configurations:

$$atO\left(\gamma \right)⟺p=O;atX\left(\gamma \right)⟺p=\left(x,,,0\right);atY\left(\gamma \right)⟺p=\left(0,,,y\right)$$

The one-step relation ${\Rightarrow }_A$ is defined by cases on $\mathrm{\Pi }\left(q\right)$:

(i) $\mathrm{\Pi }\left(q\right)=move\left(d,,,q^{\prime }\right)$: $\left(q,,,p,,,x,,,y\right){\Rightarrow }_A\left(q^{\prime },,,d,\left(p\right),,,x,,,y\right)$. (ii) $\mathrm{\Pi }\left(q\right)=test\left(\beta ,,,q^{\prime },,,q^{″}\right)$: $\left(q,,,p,,,x,,,y\right){\Rightarrow }_A\left(q^{\prime },,,p,,,x,,,y\right)$ if $\beta \left(q,,,p,,,x,,,y\right)$ holds, and $\left(q,,,p,,,x,,,y\right){\Rightarrow }_A\left(q^{″},,,p,,,x,,,y\right)$ otherwise. Every conditional instruction thus has both a true branch and an explicit false branch. (iii) $\mathrm{\Pi }\left(q\right)=shift\left(d,,,q^{\prime }\right)$. The direction of a shift determines which marker it affects: $E$ and $W$ shift $X$, while $N$ and $S$ shift $Y$. A shift takes effect only if the cursor coincides with the marker in question. For each direction $d$, exactly one of the following five sub-cases applies:

• $d=E:\left(q,,,\left(x,,,0\right),,,x,,,y\right)\Rightarrow _A^{}\left(q^{\prime },,,\left(x,,,0\right),,,x,+,1,,,y\right)$;

• $d=W:\left(q,,,\left(x,,,0\right),,,x,,,y\right)\Rightarrow _A^{}\left(q^{\prime },,,\left(x,,,0\right),,,x,,\dot{-},,1,,,y\right)$;

• $d=N:\left(q,,,\left(0,,,y\right),,,x,,,y\right)\Rightarrow _A^{}\left(q^{\prime },,,\left(0,,,y\right),,,x,,,y,+,1\right)$;

• $d=S:\left(q,,,\left(0,,,y\right),,,x,,,y\right)\Rightarrow _A^{}\left(q^{\prime },,,\left(0,,,y\right),,,x,,,y,,\dot{-},,1\right)$;

• in every other case, $\left(q,,,p,,,x,,,y\right)\Rightarrow _A^{}\left(q^{\prime },,,p,,,x,,,y\right)$ 

Configurations with control state $q_h$ have no ${\Rightarrow }_A$-successor; every other configuration has exactly one, so ${\Rightarrow }_A$ is a partial function and $A$ is deterministic.

Clause (iii) fires only when the cursor already occupies the marker’s location, and that requirement is the model’s locality constraint: markers are items at locations, and the machine can act on an item only where the item is. Dropping the constraint would turn the model into an ordinary register machine with random access to its registers and would remove precisely what makes it a navigation model. Because of the locality constraint, a CM2-instruction is not translated by a single primitive operation but by a macro that travels to the relevant marker, acts on it, and returns to the origin.

Definition 4.3 (translation of CM2-programs into navigation programs)

Let $P=\left(L,a,b,,,\iota \right)$ be a CM2-program. Define the counter-based allocentric navigation machine

$$A_P=\left({\mathbb{N}}^2,,,O,,,Q_P,,,q_{{\ell }_0},,,q_{{\ell }_h},,,{\mathrm{\Pi }}_P\right)$$

where $Q_P$ consists of one control state $q_{\ell }$ for each $\ell \in Lab$ together with at most five auxiliary states ${\ell }^1,\cdots ,{\ell }^5$ for each $\ell \in Lab\backslash \{{\ell }_h\}$, all distinct. The translation ${\mathrm{\Pi }}_P$ is defined by cases on $\iota \left(\ell \right)$. The four instruction forms are handled as follows:

• (i)
  $\iota \left(\ell \right)=inc\left(1,,,{\ell }^{\prime }\right)$:

  • $\begin{array}{cc}{\mathrm{\Pi }}_P\left(q_{\ell }\right)=test\left(a,t,X,,,{\ell }^1,,,{\ell }^2\right)& {\mathrm{\Pi }}_P\left({\ell }^2\right)=move\left(E,,,q_{\ell }\right)\end{array}$ 
  • $\begin{array}{ccc}{\mathrm{\Pi }}_P\left({\ell }^1\right)=shift\left(E,,,{\ell }^3\right)& {\mathrm{\Pi }}_P\left({\ell }^3\right)=test\left(a,t,O,,,q_{\ell \prime },,,{\ell }^4\right)& {\mathrm{\Pi }}_P\left({\ell }^4\right)=move\left(W,,,{\ell }^3\right)\end{array}$ 
• (ii)$\iota \left(\ell \right)=inc\left(2,,,{\ell }^{\prime }\right)$: as in (i), with $\mathit{atY}$ for $\mathit{atX}$, $N$ for $E$, and $S$ for $W$.
• (iii)
  $\iota \left(\ell \right)=jzdec\left(1,,,{\ell }^{\prime },,,{\ell }^{″}\right)$:

  • $\begin{array}{ccc}{\mathrm{\Pi }}_P\left(q_{\ell }\right)=test\left(a,t,X,,,q_{\ell \prime },,,{\ell }^1\right)& {\mathrm{\Pi }}_P\left({\ell }^1\right)=move\left(E,,,{\ell }^2\right)& {\mathrm{\Pi }}_P\left({\ell }^2\right)=test\left(a,t,X,,,{\ell }^3,,,{\ell }^1\right)\end{array}$ 
    $\begin{array}{ccc}{\mathrm{\Pi }}_P\left({\ell }^3\right)=shift\left(W,,,{\ell }^4\right)& {\mathrm{\Pi }}_P\left({\ell }^4\right)=test\left(a,t,O,,,q_{\ell ″},,,{\ell }^5\right)& {\mathrm{\Pi }}_P\left({\ell }^5\right)=move\left(W,,,{\ell }^4\right)\end{array}$ 
• (iv)$\iota \left(\ell \right)=jzdec\left(2,,,{\ell }^{\prime },,,{\ell }^{″}\right)$: as in (iii), with $\mathit{atY}$ for $\mathit{atX}$, $N$ for $E$, and $S$ for $W$ 

The map $P\mapsto A_P$ is computable; indeed, it is given by a finite table. Its intended reading is navigational. In case (i) the machine walks east from the origin until it reaches $X$, shifts $X$ one step further east, walks back west to the origin, and enters the state corresponding to the next CM2-label. In case (iii) it first checks, without moving, whether $X$ is at the origin, which is the zero test for $c_1$; if it is not, the machine walks east to $X$, shifts $X$ one step west, and walks back to the origin. The zero test is a test on the simulating machine’s configuration, not an operation of the simulated CM2-program, whose instruction jzdec has no origin to check.

Each of the four cases assigns a finite set of labeled instructions to the control state $q_{\ell }$ and its auxiliary states; that set is the macro for the instruction $\iota \left(\ell \right)$, and the program ${\mathrm{\Pi }}_P$ is the union of the macros over all non-halting labels.

Lemma 4.4 (traversal)

In any counter-based allocentric navigation machine, move and test instructions leave the marker components $x$ and $y$ unchanged; only shift instructions change them. Consequently, for any control states involved:

1. from a configuration with cursor at (𝑘,0), where 𝑘 ≤ 𝑥, iterated eastward moves place the cursor at (𝑥,0) after exactly 𝑥 − 𝑘 moves; 𝑎𝑡𝑋 is false at every earlier point of the walk and true then;

2. from a configuration with cursor at (𝑘,0), iterated westward moves place the cursor at O after exactly 𝑘 moves; 𝑎𝑡𝑂 is false at every earlier point and true then;

3. the analogues of (a) and (b) hold on the vertical axis: from a configuration with cursor at (0,𝑘), where 𝑘 ≤ 𝑦, iterated northward moves place the cursor at (0,𝑦) after exactly 𝑦 − 𝑘 moves, with 𝑎𝑡𝑌 false at every earlier point of the walk and true then; and from a configuration with cursor at (0,𝑘), iterated southward moves place the cursor at 𝑂 after exactly 𝑘 moves, with 𝑎𝑡𝑂 false at every earlier point and true then.

Proof.

Immediate from Definition 4.2. Clauses (i) and (ii) of the one-step relation leave $x$ and $y$ untouched. Since $E\left(a,,,b\right)=\left(a,+,1,,,b\right)$, after $j$ eastward moves from $\left(k,,,0\right)$ the cursor is at $\left(k,+,j,,,0\right)$, and $\mathit{atX}$ holds exactly when $k+j=x$. Since $W\left(a,,,b\right)=\left(a,,\dot{-},,1,,,b\right)$, after $j\le k$ westward moves from $\left(k,,,0\right)$ the cursor is at $\left(k,-,j,,,0\right)$, and $\mathit{atO}$ holds exactly when $j=k$. $\blacksquare$

Theorem 4.5.

For every CM2-program $P$, the machine $A_P$ of Definition 4.3 simulates $P$ step for step under the encoding.

$$E_P\left(\ell ,,,m,,,n\right)=\left(q_{\ell },,,O,,,m,,,n\right).$$

Consequently, the class of counter-based allocentric navigation machines is Turing-complete.

Proof.

$E_P$ is injective, since distinct CM2-configurations differ in a component that $E_P$ preserves. Condition (b) of Definition 3.5 holds because ${\mathrm{\Pi }}_P$ is undefined exactly at $q_{{\ell }_h}$ and ${⊢}_P$ is undefined exactly at configurations labeled ${\ell }_h$. For condition (a), fix $\ell \ne {\ell }_h$ and argue by cases on $\iota \left(\ell \right)$, starting from $E_P\left(\ell ,,,m,,,n\right)=\left(q_{\ell },,,O,,,m,,,n\right)$.

Case $\iota \left(\ell \right)=inc\left(1,,,{\ell }^{\prime }\right)$

 The instruction at $q_{\ell }$ tests $\mathit{atX}$ with the cursor at $O$, so $\mathit{atX}$ holds if and only if $m=0$. If $m=0$, the machine enters ${\ell }^1$, shifts $X$ east (permitted, since the cursor coincides with $X$ at $O$), reaching $\left({\ell }^3,,,O,,,1,,,n\right)$; the test at ${\ell }^3$ succeeds and the machine enters $q_{{\ell }^{\prime }}$, giving $\left(q_{{\ell }^{\prime }},,,O,,,1,,,n\right)=E_P\left({\ell }^{\prime },,,1,,,n\right)$. If $m>0$, then by Lemma 4.4 (a) the alternation of tests at $q_{\ell }$ and moves at ${\ell }^2$ brings the cursor to $\left(m,,,0\right)$ after exactly $m$ moves, with $x$ and $y$ unchanged; $\mathit{atX}$ then holds, the machine enters ${\ell }^1$ and shifts $X$ east, reaching $\left({\ell }^3,,,\left(m,,,0\right),,,m,+,1,,,n\right)$; by Lemma 4.4 (b) the alternation of tests at ${\ell }^3$ and moves at ${\ell }^4$ returns the cursor to $O$ after exactly $m$ moves; the test at ${\ell }^3$ then succeeds and the machine enters $q_{{\ell }^{\prime }}$, giving $E_P\left({\ell }^{\prime },,,m,+,1,,,n\right)$. Either way the resulting configuration is the encoding of the ${⊢}_P$-successor, and the total number of primitive steps is $4m+3$. No intermediate configuration lies in the image of $E_P$. During the outward loop, a configuration with a nonauxiliary control state has the cursor away from the origin; every other intermediate configuration has an auxiliary control state. During the return loop, all intermediate configurations have auxiliary states.

Case $\iota \left(\ell \right)=jzdec\left(1,,,{\ell }^{\prime },,,{\ell }^{″}\right)$

The test at $q_{\ell }$ with the cursor at $O$ succeeds if and only if $m=0$. If $m=0$, the machine enters $q_{{\ell }^{\prime }}$ without moving anything, giving $\left(q_{{\ell }^{\prime }},,,O,,,0,,,n\right)=E_P\left({\ell }^{\prime },,,0,,,n\right)$, which is the ${⊢}_P$-successor by Definition 3.2 (iii). If $m>0$, the machine enters ${\ell }^1$ and, by Lemma 4.4 (a) applied to the loop ${\ell }^1$–${\ell }^2$, reaches $\left({\ell }^3,,,\left(m,,,0\right),,,m,,,n\right)$ after exactly $m$ moves and $m$ tests; the shift at ${\ell }^3$ moves $X$ one step west, giving $\left({\ell }^4,,,\left(m,,,0\right),,,m,-,1,,,n\right)$; by Lemma 4.4 (b) the loop ${\ell }^4$–${\ell }^5$ returns the cursor to $O$, and the machine enters $q_{{\ell }^{″}}$, giving $E_P\left({\ell }^{″},,,m,-,1,,,n\right)$, which is again the ${⊢}_P$-successor. The same reasoning excludes intermediate encoded configurations.

Cases (ii) and (iv) are the images of (i) and (iii) under the exchange of axes, and the verification is identical with $atY,N$, and $S$ in place of $atX,E$, and $W$.

Hence $E_P$ is a step-for-step simulation. By Remark 3.3, for every one-tape Turing machine $M$ there is a CM2-program $P_M$ that simulates $M$ step for step in the sense of Definition 3.5; composing the two simulations, and noting that the composition of computable injections satisfying Definition 3.5 again satisfies it, yields a counter-based allocentric navigation machine simulating $M$. To see this, let $E_1$ and $E_2$ be the two encodings and concatenate the $E_2$-macros corresponding to the successive steps of the first simulation. Configurations strictly inside an $E_2$-macro lie outside im($E_2$). At a boundary between two such macros, injectivity of $E_2$ implies that $E_2$(c′) lies in im($E_2$∘$E_1$) only if c′ lies in im($E_1$). Terminality is also preserved by composition. So the class is Turing-complete in the sense of Definition 3.6. ∎

Example 4.6 (how the model computes)

The following exhibits the primitive operations of Definition 4.2 in action.

Let $P_{\mathit{succ}}=\left(\{,{\ell }_0,,,{\ell }_h,\},,,\iota \right)$ with $\iota \left({\ell }_0\right)=inc\left(1,,,{\ell }_h\right)$, so that ${\varphi }_{P_{\mathit{succ}}}\left(a\right)=a+1$. Definition 4.3 (i) yields $A_{P_{\mathit{succ}}}$ with control states $q_{{\ell }_0},q_{{\ell }_h},{\ell }_0^1,{\ell }_0^2,{\ell }_0^3,{\ell }_0^4$ and program

$$\mathrm{\Pi }\left(q_{{\ell }_0}\right)=test\left(a,t,X,,,{\ell }_0^1,,,{\ell }_0^2\right),\mathrm{\Pi }\left({\ell }_0^2\right)=move\left(E,,,q_{{\ell }_0}\right),\mathrm{\Pi }\left({\ell }_0^1\right)=shift\left(E,,,{\ell }_0^3\right),\mathrm{\Pi }\left({\ell }_0^3\right)=test\left(a,t,O,,,q_{{\ell }_h},,,{\ell }_0^4\right),\mathrm{\Pi }\left({\ell }_0^4\right)=move\left(W,,,{\ell }_0^3\right)$$

The computation on input $a=2$ begins at $E_P\left({\ell }_0,,,2,,,0\right)=\left(q_{{\ell }_0},,,\left(0,,,0\right),,,2,,,0\right)$ and proceeds as shown in Table 1.

Table 1.

Primitive navigation steps in the successor example on input 2

Step	Instruction executed	Resulting configuration
1	$test\left(a,t,X,,,{\ell }_0^1,,,{\ell }_0^2\right)$, $\mathit{atX}$ false	$\left({\ell }_0^2,,,\left(0,,,0\right),,,2,,,0\right)$
2	$move\left(E,,,q_{{\ell }_0}\right)$	$\left(q_{{\ell }_0},,,\left(1,,,0\right),,,2,,,0\right)$
3	$test\left(a,t,X,,,\cdots \right)$, $\mathit{atX}$ false	$\left({\ell }_0^2,,,\left(1,,,0\right),,,2,,,0\right)$
4	$move\left(E,,,q_{{\ell }_0}\right)$	$\left(q_{{\ell }_0},,,\left(2,,,0\right),,,2,,,0\right)$
5	$test\left(a,t,X,,,\cdots \right)$, $\mathit{atX}$ true	$\left({\ell }_0^1,,,\left(2,,,0\right),,,2,,,0\right)$
6	$shift\left(E,,,{\ell }_0^3\right)$	$\left({\ell }_0^3,,,\left(2,,,0\right),,,3,,,0\right)$
7	$test\left(a,t,O,,,\cdots \right)$, $\mathit{atO}$ false	$\left({\ell }_0^4,,,\left(2,,,0\right),,,3,,,0\right)$
8	$move\left(W,,,{\ell }_0^3\right)$	$\left({\ell }_0^3,,,\left(1,,,0\right),,,3,,,0\right)$
9	$test\left(a,t,O,,,\cdots \right)$, $\mathit{atO}$ false	$\left({\ell }_0^4,,,\left(1,,,0\right),,,3,,,0\right)$
10	$move\left(W,,,{\ell }_0^3\right)$	$\left({\ell }_0^3,,,\left(0,,,0\right),,,3,,,0\right)$
11	$test\left(a,t,O,,,\cdots \right)$, $\mathit{atO}$ true	$\left(q_{{\ell }_h},,,\left(0,,,0\right),,,3,,,0\right)$

The final configuration is $E_P\left({\ell }_h,,,3,,,0\right)$: the machine halts with marker $X$ at $\left(3,,,0\right)$ and the cursor back at the origin, so the output is $3$. The single CM2-instruction is realized by $11$ primitive navigation steps, in accordance with the count $4m+3$ established in the proof of Theorem 4.5.

Branching is exercised by $P_{\mathit{tr}}=\left(\{,{\ell }_0,,,{\ell }_1,,,{\ell }_h,\},,,\iota \right)$ with $\iota \left({\ell }_0\right)=jzdec\left(1,,,{\ell }_h,,,{\ell }_1\right)$ and $\iota \left({\ell }_1\right)=inc\left(2,,,{\ell }_0\right)$, which transfers $c_1$ into $c_2$. On input $\left(m,,,n\right)=\left(2,,,0\right)$ the CM2-computation is

$$\left({\ell }_0,,,2,,,0\right)⊢\left({\ell }_1,,,1,,,0\right)⊢\left({\ell }_0,,,1,,,1\right)⊢\left({\ell }_1,,,0,,,1\right)⊢\left({\ell }_0,,,0,,,2\right)⊢\left({\ell }_h,,,0,,,2\right)$$

and by Theorem 4.5 the corresponding navigation computation consists of five macro-steps, each beginning and ending with the cursor at the origin: two east-walk-and-decrement macros on the horizontal axis (taking the false branch of the zero test), two north-walk-and-increment macros on the vertical axis, and a final zero test that succeeds without moving anything and passes control to $q_{{\ell }_h}$. Both branches of the conditional and both axes are thus used.

This first proof is mathematically straightforward and historically unsurprising, but it makes vivid the idea that two allocentrically distinguished axes can function as two unbounded spatial registers.

Direct universality via a writable tape-path in the map

The second navigation model makes the simulation more direct. Instead of encoding memory arithmetically as distances of markers from the origin, it places writable labels on landmarks along a distinguished bi-infinite path through the allocentric map. The current simulated location plays the role of the Turing head, and movement along the path plays the role of left and right head motion. In effect, this model is an isomorphic recoding of an ordinary one-tape Turing machine into allocentric-map terms: the path realizes the tape, the current simulated location realizes the head position, and the stored labels on path landmarks realize the tape contents.

Definition 5.1 (tape-path allocentric navigation machine)

Fix a finite alphabet $\mathrm{\Gamma }$ with blank $\square \in \mathrm{\Gamma }$. Let ${\mathrm{\Lambda }}_{\mathrm{\Gamma }}=\{\lambda :{\mathbb{Z}}^2\to \mathrm{\Gamma }\mid \lambda \left(z\right)=\square$ for all but finitely many $z\in {\mathbb{Z}}^2\}$ be the set of landmark labelings: like $T_{\mathrm{\Gamma }}$, it is a set of finite-support functions, from which each configuration draws one member. Let

$$\pi :\mathbb{Z}\to {\mathbb{Z}}^2,\pi \left(i\right)=\left(i,,,0\right)$$

and write $L_{\pi }=\pi \left(\mathbb{Z}\right)$ for the set of path landmarks. Note that $\pi$ is injective and that $\pi \left(i,\pm ,1\right)$ is a four-neighbor of $\pi \left(i\right)$ for every $i\in \mathbb{Z}$.

A tape-path allocentric navigation machine is a tuple

$$A=\left({\mathbb{Z}}^2,,,\pi ,,,Q,,,\mathrm{\Gamma },,,\square ,,,q_0,,,q_h,,,{\delta }_A\right),{\delta }_A:\left(Q,\backslash ,\{,q_h,\}\right)\times \mathrm{\Gamma }\to Q\times \mathrm{\Gamma }\times \{pred,succ\}.$$

A configuration is a triple $\left(q,,,c,,,\lambda \right)\in Q\times L_{\pi }\times {\mathrm{\Lambda }}_{\mathrm{\Gamma }}$, where $c$ is the current simulated location, constrained to lie on the path. The one-step relation is: with $a=\lambda \left(c\right)$ and ${\delta }_A\left(q,,,a\right)=\left(q^{\prime },,,b,,,\mu \right)$,

$$\left(q,,,c,,,\lambda \right){\Rightarrow }_A\left(q^{\prime },,,c^{\prime },,,\lambda ,\left[c,\mapsto ,b\right]\right)$$

where $c^{\prime }=\pi \left(i,-,1\right)$ if $\mu =pred$ and $c^{\prime }=\pi \left(i,+,1\right)$ if $\mu =succ$, $i$ being the unique index with $c=\pi \left(i\right)$.

Configurations with control state $q_h$ are terminal; all others have exactly one successor.

In one computational step the machine therefore checks the stored label at the current path location, replaces that label, changes control state, and moves to the predecessor or successor location on the path. The path is unbounded in the same sense as a Turing tape, and by Convention 3.8 a concrete configuration represents only finitely many nonblank labels.

Remark 5.2 (on the choice of embedding)

Any injection ${\pi }^{\prime }:\mathbb{Z}\to {\mathbb{Z}}^2$ such that ${\pi }^{\prime }\left(i,\pm ,1\right)$ is a four-neighbor of ${\pi }^{\prime }\left(i\right)$ for every $i$—for example, the vertical embedding ${\pi }^{\prime }\left(i\right)=\left(0,,,,i\right)$—yields a computationally equivalent tape-path model under the relabeling ${\pi }^{\prime }\circ {\pi }^{-1}$ of path locations. The geometric locus of the simulated tape therefore carries no mathematical weight. The substantive assumption is that the path’s adjacency structure is handed to the machine as a primitive: $\mathit{pred}$ and $\mathit{succ}$ are defined by reference to $\pi$. Section 6 removes that primitive.

Definition 5.3 (translation and encoding)

Let $tr\left(L\right)=pred$ and $tr\left(R\right)=succ$. Given a one-tape Turing machine $M=\left(Q,,,\mathrm{\Gamma },,,\square ,,,q_0,,,q_h,,,\delta \right)$, define

$$A_M=\left({\mathbb{Z}}^2,,,\pi ,,,Q,,,\mathrm{\Gamma },,,\square ,,,q_0,,,q_h,,,{\delta }^{\mathit{tr}}\right)$$

where ${\delta }^{\mathit{tr}}\left(q,,,a\right)=\left(q^{\prime },,,b,,,t,r,\left(D\right)\right)$ whenever $\delta \left(q,,,a\right)=\left(q^{\prime },,,b,,,D\right)$.

The map $M\mapsto A_M$ is computable: it is the identity on states, alphabet, blank, start state, and halt state, and it relabels the third component of each entry of the transition table. Define the encoding

$$E_M:Conf\left(M\right)\to Conf\left(A_M\right),E_M\left(q,,,h,,,t\right)=\left(q,,,\pi ,\left(h\right),,,{\lambda }_t\right)$$

where ${\lambda }_t\left(\pi ,\left(i\right)\right)=t\left(i\right)$ for every $i\in \mathbb{Z}$ and ${\lambda }_t\left(z\right)=\square$ for every $z\notin L_{\pi }$. Since $t\in T_{\mathrm{\Gamma }}$ has finite support, ${\lambda }_t\in {\mathrm{\Lambda }}_{\mathrm{\Gamma }}$; and $t\mapsto {\lambda }_t$ is injective, so $E_M$ is injective. The notation ${\lambda }_t$ is a compact metatheoretic name for a finite-support labeling; it is not an infinite object supplied to the machine.

Theorem 5.4.

For every deterministic one-tape Turing machine $M$, the encoding $E_M$ of Definition 5.3 is a lock-step simulation of $M$ in $A_M$. Consequently, the class of tape-path allocentric navigation machines is Turing-complete.

Proof.

Terminality: $A_M$-configurations with state $q_h$ are $\Rightarrow$-terminal and $M$-configurations with state $q_h$ are $⊢$-terminal, and ${\delta }^{\mathit{tr}}$ is defined exactly where $\delta$ is; this gives condition (b) of Definition 3.5. For condition (a), take any non-terminal configuration $\gamma =\left(q,,,h,,,t\right)$ of $M$, let $a=t\left(h\right)$ and $\delta \left(q,,,a\right)=\left(q^{\prime },,,b,,,D\right)$, so that $\gamma {⊢}_M{\gamma }^{\prime }=\left(q^{\prime },,,h^{\prime },,,t,\left[h,\mapsto ,b\right]\right)$ with $h^{\prime }=h-1$ if $D=L$ and $h^{\prime }=h+1$ if $D=R$. Now $E_M\left(\gamma \right)=\left(q,,,\pi ,\left(h\right),,,{\lambda }_t\right)$ and ${\lambda }_t\left(\pi ,\left(h\right)\right)=t\left(h\right)=a$, so the machine $A_M$ applies ${\delta }^{\mathit{tr}}\left(q,,,a\right)=\left(q^{\prime },,,b,,,t,r,\left(D\right)\right)$. It writes $b$ at $\pi \left(h\right)$, yielding the labeling ${\lambda }_t[\pi (h)\mapsto b]={\lambda }_{t[h\mapsto b]}$—the two labelings agree at every path landmark by construction and are both blank off the path—changes state to $q^{\prime }$, and moves to $\pi \left(h,-,1\right)$ if $tr\left(D\right)=pred$ and to $\pi \left(h,+,1\right)$ if $tr\left(D\right)=succ$. The result is $\left(q^{\prime },,,\pi ,\left(h^{\prime }\right),,,{\lambda }_{t[h\mapsto b]}\right)=E_M\left({\gamma }^{\prime }\right)$. Since $k=1$, no intermediate configuration arises and the simulation is lock-step. By Definition 3.6, the class is Turing-complete. $\blacksquare$

Relative to the first proof, this model is more direct and conceptually closer to standard Turing-machine organization. Relative to older graph-based formalisms, however, it remains a familiar kind of tape-on-graph encoding.

Corollary 5.5.

Let $U$ be a universal one-tape Turing machine, of which many small examples are known [25, 46]. Then $A_U$ is a single tape-path allocentric navigation machine that simulates every one-tape Turing machine, given an encoding of that machine and its input on the path.

Proof.

Immediate from Theorem 5.4 applied to $U$, together with the universality of $U$.$\blacksquare$ 

Corollary 6.8 below strengthens this to universality for the class itself.

Direct universality via a fully local two-dimensional landmark layout

The third navigation model replaces the globally indexed path primitive of Section 5 with local predecessor/successor information at the landmarks. Memory is realized on a two-row track embedded in the allocentric map, and the machine moves by consulting only the type of the landmark it currently occupies together with fixed local direction tables. The resulting landmark structure still forms a bi-infinite path, but the machine is not given a global enumeration of that path; the enumeration introduced below is used only in the metatheory to prove correctness.

Definition 6.1 (local-layout allocentric navigation machine)

Let the internal map be ${\mathbb{Z}}^2$ and let the memory landmarks occupy the two-row track

$$T=\{\left(x,,,y\right)\in {\mathbb{Z}}^2\mid y\in \{0,1\}\}.$$

Define the landmark type function $\tau :T\to \{A,B,C,D\}$ by: $\tau \left(x,,,y\right)=A$ if $y=0$ and $x$ is even; $B$ if $y=1$ and $x$ is even; $C$ if $y=1$ and $x$ is odd; $D$ if $y=0$ and $x$ is odd. Identify each direction with a unit vector: $E=\left(1,,,0\right),W=\left(-,1,,,0\right),N=\left(0,,,1\right),S=\left(0,,,-,1\right)$. Define the two local direction dictionaries $pred\_dir,succ\_dir:\{A,B,C,D\}\to \{E,W,N,S\}$ as listed in Table 2.

Table 2.

Local predecessor and successor directions by landmark type

Type	Occupies	Pred_dir	Succ_dir
A	(2k, 0)	W	N
B	(2k, 1)	S	E
C	(2k + 1, 1)	W	S
D	(2k + 1, 0)	N	E

A local-layout allocentric navigation machine is a tuple

$$A=\left({\mathbb{Z}}^2,,,T,,,\tau ,,,Q,,,\mathrm{\Gamma },,,\square ,,,q_0,,,q_h,,,{\delta }_A\right),{\delta }_A:\left(Q,\backslash ,\{,q_h,\}\right)\times \mathrm{\Gamma }\to Q\times \mathrm{\Gamma }\times \{pred,succ\}$$

A configuration is a triple $\left(q,,,c,,,\lambda \right)\in Q\times T\times {\mathrm{\Lambda }}_{\mathrm{\Gamma }}$, where $c$ is the landmark bearing the head marker and $\lambda$, as in Definition 5.1, is a finite-support labeling, here supported in $T$. The one-step relation is: with $a=\lambda \left(c\right)$ and ${\delta }_A\left(q,,,a\right)=\left(q^{\prime },,,b,,,\mu \right)$,

$$\left(q,,,c,,,\lambda \right){\Rightarrow }_A\left(q^{\prime },,,c,+,v,,,\lambda ,\left[c,\mapsto ,b\right]\right)$$

where $v=pred\_dir\left(\tau ,\left(c\right)\right)$ if $\mu =pred$ and $v=succ\_dir\left(\tau ,\left(c\right)\right)$ if $\mu =succ$.

Configurations with control state $q_h$ are terminal; all others have exactly one successor.

The landmarks are thereby arranged in a zigzag chain through the plane:

$$\cdots \to \left(-,2,,,0\right)\to \left(-,2,,,1\right)\to \left(-,1,,,1\right)\to \left(-,1,,,0\right)\to \left(0,,,0\right)\to \left(0,,,1\right)\to \left(1,,,1\right)\to \left(1,,,0\right)\to \left(2,,,0\right)\to \cdots$$

Remark 6.2 (what is and is not available to the machine)

The type function τ is part of the machine’s readable environment: at each step, the next location is determined by the type of the landmark currently occupied together with the fixed dictionaries pred_dir and succ_dir in finite control. The machine is not given the global enumeration η used in Lemma 6.3. Collectively, however, the landmark types and direction tables determine a bi-infinite predecessor/successor path. Thus, this model does not eliminate path structure. Rather, it represents that structure locally instead of supplying the transition rule with a globally indexed embedding such as π. Removing the landmark types would leave the machine with no move relation, because the geometric directions of pred and succ are defined nowhere else.

Lemma 6.3.

Define $\eta :\mathbb{Z}\to T$ by

$$\eta \left(4,k\right)=\left(2,k,,,0\right),\eta \left(4,k,+,1\right)=\left(2,k,,,1\right),\eta \left(4,k,+,2\right)=\left(2,k,+,1,,,1\right),\eta \left(4,k,+,3\right)=\left(2,k,+,1,,,0\right),k\in \mathbb{Z}.$$

Then $\eta$ is a bijection and, for every $i\in \mathbb{Z}$, $\eta \left(i\right)+succ\_dir\left(\tau ,\left(\eta ,\left(i\right)\right)\right)=\eta \left(i,+,1\right)$ and $\eta \left(i\right)+pred\_dir\left(\tau ,\left(\eta ,\left(i\right)\right)\right)=\eta \left(i,-,1\right)$.

Proof.

For each $k$, the four values $\eta \left(4,k\right),\cdots ,\eta \left(4,k,+,3\right)$ are $\left(2,k,,,0\right),\left(2,k,,,1\right),\left(2,k,+,1,,,1\right),\left(2,k,+,1,,,0\right)$, so as $k$ ranges over $\mathbb{Z}$ every element of $T$ is hit exactly once; $\eta$ is a bijection. For the successor claim, take the four residues in turn. If $i=4k$, then $\eta \left(i\right)=\left(2,k,,,0\right)$ has type A, so $succ\_dir=N$ and $\eta \left(i\right)+N=\left(2,k,,,1\right)=\eta \left(4,k,+,1\right)$. If $i=4k+1$, then $\eta \left(i\right)=\left(2,k,,,1\right)$ has type B, so $succ\_dir=E$ and $\eta \left(i\right)+E=\left(2,k,+,1,,,1\right)=\eta \left(4,k,+,2\right)$. If $i=4k+2$, then $\eta \left(i\right)=\left(2,k,+,1,,,1\right)$ has type C, so $succ\_dir=S$ and $\eta \left(i\right)+S=\left(2,k,+,1,,,0\right)=\eta \left(4,k,+,3\right)$. If $i=4k+3$, then $\eta \left(i\right)=\left(2,k,+,1,,,0\right)$ has type D, so $succ\_dir=E$ and $\eta \left(i\right)+E=\left(2,k,+,\text{2,,0}\right)=\eta \left(4,\left(k,+,1\right)\right)=\eta \left(i,+,1\right)$. The predecessor claim is verified by the same four cases: from type A, $pred\_dir=W$ and $\left(2,k,,,0\right)+W=\left(2,k,-,1,,,0\right)=\eta \left(4,k,-,1\right)$; from type B, $\left(2,k,,,1\right)+S=\left(2,k,,,0\right)=\eta \left(4,k\right)$; from type C, $\left(2,k,+,1,,,1\right)+W=\left(2,k,,,1\right)=\eta \left(4,k,+,1\right)$; from type D, $\left(2,k,+,1,,,0\right)+N=\left(2,k,+,1,,,1\right)=\eta \left(4,k,+,2\right)$. Hence following the local pointers coincides exactly with increment and decrement of the index $i$. $\blacksquare$

Definition 6.4 (translation and encoding)

With $\mathit{tr}$ as in Definition 5.3, define for each one-tape Turing machine $M$ the local-layout machine

$$A_{}^{\prime }_M^{}=\left({\mathbb{Z}}^2,,,T,,,\tau ,,,Q,,,\mathrm{\Gamma },,,\square ,,,q_0,,,q_h,,,{\delta }^{\mathit{tr}}\right)$$

and the encoding

$$E_{}^{\prime }_M^{}:Conf\left(M\right)\to Conf\left(A,_{}^{\prime }_M^{}\right),E_{}^{\prime }_M^{}\left(q,,,h,,,t\right)=\left(q,,,\eta ,\left(h\right),,,{\lambda }_t\right)$$

where ${\lambda }_t\left(\eta ,\left(i\right)\right)=t\left(i\right)$ for every $i\in \mathbb{Z}$ and ${\lambda }_t\left(z\right)=\square$ for $z\notin T$. As in Definition 5.3, ${\lambda }_t\in {\mathrm{\Lambda }}_{\mathrm{\Gamma }}$ and $E_{}^{\prime }_M^{}$ is an injection. The order of the components matches Definition 5.3: control state, current location, labeling.

Theorem 6.5.

For every deterministic one-tape Turing machine $M$, the encoding $E_{}^{\prime }_M^{}$ of Definition 6.4 is a lock-step simulation of $M$ in $A_{}^{\prime }_M^{}$. Consequently, the class of local-layout allocentric navigation machines is Turing-complete.

Proof.

Terminality is as in Theorem 5.4. For the step condition, let $\gamma =\left(q,,,h,,,t\right)$ be non-terminal, $a=t\left(h\right)$, $\delta \left(q,,,a\right)=\left(q^{\prime },,,b,,,D\right)$, and $\gamma {⊢}_M{\gamma }^{\prime }=\left(q^{\prime },,,h^{\prime },,,t,\left[h,\mapsto ,b\right]\right)$ with $h^{\prime }=h-1$ if $D=L$ and $h^{\prime }=h+1$ if $D=R$. Then $E_{}^{\prime }_M^{}\left(\gamma \right)=\left(q,,,\eta ,\left(h\right),,,{\lambda }_t\right)$ and ${\lambda }_t\left(\eta ,\left(h\right)\right)=t\left(h\right)=a$, so $A_{}^{\prime }_M^{}$ applies ${\delta }^{\mathit{tr}}\left(q,,,a\right)=\left(q^{\prime },,,b,,,t,r,\left(D\right)\right)$. It writes $b$ at $\eta \left(h\right)$, giving ${\lambda }_t[\eta (h)\mapsto b]={\lambda }_{t[h\mapsto b]}$, changes state to $q^{\prime }$, and moves by the vector $pred\_dir\left(\tau ,\left(\eta ,\left(h\right)\right)\right)$ or $succ\_dir\left(\tau ,\left(\eta ,\left(h\right)\right)\right)$ according to $tr\left(D\right)$. By Lemma 6.3 that move reaches $\eta \left(h,-,1\right)$ in the $\mathit{pred}$ case and $\eta \left(h,+,1\right)$ in the $\mathit{succ}$ case, that is, $\eta \left(h^{\prime }\right)$. The result is $E_{}^{\prime }_M^{}\left({\gamma }^{\prime }\right)$, and the simulation is lock-step. By Definition 3.6, the class is Turing-complete. $\blacksquare$

This third proof is the most faithful to the idea of computation by navigation among landmarks, because the machine accesses the map only through local landmark information. In that respect it lies especially close, in mathematical spirit, to local graph-based machine models studied in computability theory, even though it is recast here in allocentric cognitive-map terms.

Remark 6.6 (on the word “symbol”)

In philosophy of mind and the mind sciences, “symbol” often carries commitments absent in computability theory. The proofs of Theorems 5.4 and 6.5 assign items stored at locations within a cognitive map formal roles corresponding to letters of the tape alphabet $\mathrm{\Gamma }$, but this does not imply that allocentric navigation requires symbols in the sense of having language-like structure, or even in the weaker sense of having arbitrary semantic content. Letters of a finite alphabet are just reliably distinguishable labels; nothing in the proofs depends on stored map items being symbolic in a richer sense. To make this explicit, let $\mathrm{\Omega }$ be a finite set of reliably distinguishable stored item-types and let $\rho :\mathrm{\Omega }\to \mathrm{\Gamma }$ be a fixed bijection. Each relevant map location stores an item of type $\omega \in \mathrm{\Omega }$, realizing the tape letter $\rho (\omega )$. Thus, the map need only store one of finitely many reliably distinguishable item-types, not literal elements of $\mathrm{\Gamma }$. This relabeling changes no mathematics; it blocks only a misleading identification of finitely many labels with symbols in stronger senses. Defenders of the classical Language of Thought hypothesis have argued that architectures without language-like symbols lack the power to explain cognition. The proofs above assume no such symbols. This is one respect in which the navigation-based neurocomputational architectures explored here are nonclassical.

Corollary 6.7 (Turing equivalence)

Under Convention 3.8, every machine in each of the three navigation-model classes is simulable by an ordinary Turing machine. Therefore, the three classes are Turing-equivalent to standard universal models.

Proof.

In the counter-based model, a configuration is the finite tuple $\left(q,,,p,,,x,,,y\right)$, and each primitive test and update of Definition 4.2 is a computable operation on natural numbers, monus included. In the tape-path model, a configuration is represented by the finite control state, the current path index or coordinate, and the finite list of nonblank path labels; $\pi$ and its inverse on $L_{\pi }$ are computable. In the local-layout model, a configuration is represented by the finite control state, the current landmark coordinate, and the finite list of nonblank landmark labels; $\tau$ is computable from the parity of the first coordinate and the value of the second, and $pred\_dir$ and $succ\_dir$ are finite tables. In each case a standard Turing machine can store the finite description of the machine and the finite representation of the current configuration, compute the next primitive step, and iterate. No infinite completed function, oracle, or non-effective operation is added. Combined with Theorems 4.5, 5.4, and 6.5, this yields Turing equivalence. $\blacksquare$

Corollary 6.8 (universal navigation machines)

Each of the three classes of navigation machines contains a machine that is universal for that class in the sense of Definition 3.7.

Proof.

First let $K$ be the tape-path class or the local-layout class, and let $A\in K$ be arbitrary. By Corollary 6.7 there exist a Turing machine $M_A$ and computable codings such that $M_A$ simulates $A$; the construction there is uniform in $A$, so the map $⟨\text{A}⟩\mapsto ⟨M_A⟩$ is computable. Let $U$ be a universal one-tape Turing machine. Define the input coding for $A_U$ to transform $\left(〈A〉,,,w\right)$ computably into the navigation encoding of the $U$-input consisting of $〈M_A〉$ together with the encoded input under which $M_A$ simulates $A$. Then $U$ simulates $M_A$, and by Theorem 5.4 (respectively Theorem 6.5) the machine $A_U\in K$ simulates $U$ lock-step. Thus $A_U$ computes what $A$ computes on w. Since $A\in K$ was arbitrary, $A_U$ is universal for $K$.

For the counter-based class the composition differs at its middle step. Let $A$ be an arbitrary counter-based allocentric navigation machine and let $M_A$ be as above. By Remark 3.3 there is a CM2-program $P_U$ that, given a Gödel-coded description of an arbitrary one-tape Turing machine together with a coded input, computes what that machine computes; and by Theorem 4.5 the machine $A_{P_U}$ simulates $P_U$ step for step. Composing, $A_{P_U}$ computes what $A$ computes, given $⟨M_A⟩$ together with a coded input. The input coding is defined analogously: from $\left(〈A〉,,,w\right)$, it first computes $〈M_A〉$, combines it with the encoded input on which $M_A$ simulates $A$, and then applies the CM2 input coding expected by $P_U$. Since $A$ was arbitrary, $A_{P_U}$ is universal for the counter-based class, under the input convention noted in Remark 3.3. $\blacksquare$

Corollary 6.8 matters for the interpretation of the results. It is not merely that for each Turing machine there exists some navigation machine that does what it does. There is a single, fixed navigation machine that, supplied with a description of an arbitrary machine of its class and an input, computes what that machine computes. The word “universal” in the title of this article is therefore warranted in both of the senses distinguished in Definitions 3.6 and 3.7.

Comparative significance

The three theorems establish the same computability-theoretic conclusion while differing in how they apply navigation-based processing. Together with Corollaries 6.7 and 6.8, they show Turing equivalence under ordinary finitary assumptions and the existence of universal machines within each class. The result is that the representational and operational primitives of allocentric navigation are sufficient, once idealized, to realize the same class of computable transformations as standard symbolic models. This should not be mistaken for a novel or more powerful kind of Turing-style machine; as with familiar Turing-machine variants, changes in storage format can preserve ordinary computable power [47].

The counter-based proof is the most austere. It uses two one-dimensional axes embedded in a common allocentric frame rather than a fully exploited two-dimensional map. The orthogonality of the axes separates the two unbounded stores, while marker position encodes counter value. Its distinctive resource is the locality constraint of Definition 4.2 (iii): the machine cannot touch a marker without first traveling to it, which is why each counter instruction compiles into a macro whose length grows with the counter value. In this respect the proof is closer to register-machine computation than to ordinary wayfinding in a two-dimensional environment.

The tape-path proof is more direct. In fact, it is essentially an isomorphic recoding of an ordinary one-tape Turing machine into an allocentric cognitive map. In the broad sense of “map” used in this article, a Turing-machine tape is already a one-dimensional map: it is an ordered array of locations, each of which can store one of finitely many item-types. If a navigation architecture can maintain a track of landmarks with replaceable stored items and move a simulated location along that track, then the standard Turing model is already present almost verbatim. The advantage we gain here is interpretive clarity: landmarks are memory cells, their stored items are tape entries, and navigation is head movement. The disadvantage is that the proof still presupposes a globally distinguished path whose adjacency relations are simply handed to the machine.

The local-layout proof makes the representation of path adjacency local. It realizes the same bi-infinite predecessor/successor structure as the tape-path model, but distributes that structure across landmark types and local direction tables rather than supplying the transition rule with a global path index. For the horizontal embedding π(i) = (i,0) used in Section 5, predecessor and successor can already be implemented uniformly as west and east, so the distinction is operationally slight in that special case. The point of Section 6 is not a stronger universality result or a different storage topology, but an explicit demonstration that a nonstraight embedded tape-path can be traversed from local landmark cues without access to a global enumeration. The three models therefore differ in their primitive representational and operational resources. Section 4 uses two axis-bound markers, three tests, and no writable labels. Sections 5 and 6 both use a writable bi-infinite path, but Section 5 presents its adjacency relation through the globally indexed embedding π, whereas Section 6. represents it through locally readable landmark types and direction tables.

The two-dimensional grid in the third model is not essential from the standpoint of computability theory. Any graph containing a bi-infinite simple path—or, for a particular finite computation, a simple path long enough to contain the portion of tape it visits—together with the appropriate writable local memory and local predecessor/successor cues can support the same type of simulation. The reason for using a two-dimensional allocentric layout is not mathematical necessity but architectural interpretation: it keeps the formal model close to the language of landmarks, directions, and local navigation within a map.

A separate issue concerns finite control. The models do require a finite internal state and a finite transition table. That component is not itself a map-like memory store; it is the finite control component familiar from ordinary Turing machines, counter machines, graph Turing machines, and storage-modification machines. The claim that the models are map-based is therefore not the claim that everything in the computation is literally stored in the map. It is the claim that the unbounded memory, the accessed items, and the head or cursor movements are realized in map-like terms. In that respect, the models resemble ordinary graph-search algorithms such as Dijkstra’s algorithm and A*, which also combine a graph or map with finite control and update rules [48, 49]. The difference is that the present models use writable landmark memory to perform arbitrary effective computation, not merely shortest-path search.

At the neurocognitive level, this finite-control component is where prefrontal control systems are most relevant. Prefrontal cortex (PFC) and related orbitofrontal (OFC) and cingulate systems provide goal, rule, and policy signals that regulate which map states are accessed, which transitions are selected, and whether navigation is continued, inhibited, or replanned. This is the kind of architectural role played by finite control acting through the head in classical machines: a finite control resource coordinates operations over a memory substrate. This analogy is consistent with general accounts of PFC as cognitive control [50] and with evidence that prefrontal systems contribute to both online navigation and offline navigational simulation: prefrontal-thalamic circuits are required for hippocampal route representations in goal-directed spatial navigation [16], OFC represents future navigational goals [14], hippocampal goal representations in human route planning covary with goal-related coding in PFC [15], medial PFC perturbation alters hippocampal sequences during deliberative decision making [18], and medial PFC replay can represent generalized trajectories during rule switching [17, 51].

This role for transitions among states or locations is not foreign to cognitive-map theorizing. Contemporary work often treats cognitive maps as structures that support transitions, planning, and prediction over states or locations, including successor or predictive-map models and more general accounts of cognitive maps as structured representations for flexible behavior [3, 4, 11, 52]. The present models extend, generalize, and idealize those ideas: their transitions are exact, their labels are perfectly writable, and their maps are unbounded. But the abstract ingredients—locations, local transitions, stored information, and finite control—are recognizable extensions of resources already invoked in the literature on cognitive maps.

It might be objected that questions of this kind are already settled by the observation that neural networks are computationally universal, so that the architecture at issue must be a network architecture. This objection fails to distinguish three issues. First, neural-network models are computationally universal only when supplied with some unbounded computational resource, such as indefinitely extensible memory or, in some finite recurrent models, arbitrarily precise internal states [e.g., 53]. A fixed finite network with only finitely many distinguishable internal states cannot realize unbounded computation and so is not computationally universal. Therefore, idealization enabling unbounded computation is needed, just as it is in the present models. Second, even if some neural-network model is universal, that fact by itself says nothing about which architecture the brain realizes. Third, the foundational disputes mentioned in Section 1 concern architecture at the level of maps, landmarks, and navigational operations, not network or circuit organization [26, 54]. A general-purpose network is compatible with many neurocomputational architectures, and pointing to a network formalism does not identify which architecture biological cognition uses. The present results concern the power of one empirically motivated architecture, described in the vocabulary used by the relevant neuroscience.

The results of this article have implications for the claim that navigation-based or otherwise nonclassical architectures lack sufficient representational or computational power to support cognition. This sort of objection depends on an additional assumption, namely that adequate representation must take a symbolic, language-like form. The results developed here undermine that assumption. They show that systems grounded in structured spatial relations and local transition rules can realize the same class of computable transformations typically associated with symbolic architectures—and they do so from resources that such critics have tended to treat as noncomputational, as merely implementational, or as barely cognitive: what they have taken to be the neural machinery of getting from one place to another.

The point extends to stored-program organization, which might seem the strongest case for the other side (the models of Sections 4 through 6 do not require it; see Definition 4.1). Even if a navigation architecture supported it, classical symbolic architecture would not thereby be vindicated; what would follow is that the map-based resources are sufficient to realize it. The more such resources turn out to support, the less need there is to posit a separate symbolic architecture alongside them. Accordingly, symbolic processing itself could be understood as a special case of navigation, where symbols are items represented at locations within a cognitive map and symbolic operations are actions taken on such items. Developing this suggestion in detail is a research program I pursue in separate work.

Limitations and scope

These universality theorems require standard idealizations. They assume an unbounded allocentric map, perfectly reliable landmark identity, exact storage, exact local movement, and arbitrarily long navigation. None of those assumptions should be attributed to biological systems. Therefore, these results do not establish that animals, humans, or hippocampal-entorhinal systems ordinarily implement Turing-universal navigation machines. They establish only that allocentric navigation-based computational models, if idealized in the usual way familiar from computability theory, are computationally universal. These are sufficiency results: they do not show that allocentric coding is necessary for universality, and the constructions deliberately exploit only a restricted subset of the resources available to a full allocentric navigation architecture.

The unbounded maps used here should be understood as potential infinities, not as completed infinite resources. This is the role played by the tape in the ordinary Turing-machine model. At any finite time in any finite computation, only finitely many locations have been visited and only finitely many nonblank labels or marker positions must be represented. The constructions therefore remain within the finitary conception of effective computation.

The evidence from neuroscience supports allocentric spatial representation, place and grid coding, and map-like navigation capacities, including offline navigation. It does not by itself support the stronger assumptions required for universal computation, such as exact unbounded writable memory at landmarks. The contribution is thus a formal reconstruction that begins from an empirically motivated representational vocabulary and then idealizes it into a universal machine model.

The reconstruction assumes that a navigational map is a structure on which operations are performed and through which action is organized, rather than only a device for finding or choosing paths. The evidence supports that reading. Hippocampal-entorhinal map-like codes are recruited for memory, inference, and abstract relational structure as well as for wayfinding [9–12], and hippocampal population activity during behavior tracks the animal’s evolving goal and action plan rather than only sensory or spatial variables [13]. These maps are also used offline: replay may support consolidation and retrieval, and preplay can express sequences related to future navigation [7, 8]. The primitives idealized in Sections 4 through 6—locations, items at locations, movement among them, and operations performed at them—are drawn from that broader, action-oriented picture.

The theorems also do not show that every navigation architecture is universal. Universality depends on specific structural enrichments: unbounded storage, reliable update operations, and sufficiently precise control. A purely finite navigation system, or a system lacking sufficiently stable memory, could not be strictly universal. However, the navigation and action processes discussed here may also occur partly within the external environment, which under suitable idealization may be treated as an external memory store. External media including paper, diagrams, or other items can in principle supply some of the structure used by a navigation system. In that case, the same universal computational models can be realized by allocentric navigation architectures that distribute storage across both internal and environmental resources. This observation is relevant to the architecture of human mathematical calculation: the same kinds of mapping and control resources involved in allocentric navigation may be involved in mathematical calculation and may help organize the spatially structured external memory used in such tasks.

Explaining human calculational competence requires additional neurocognitive assumptions. Miguel-Tomé’s 2024 preprint, The Numeric Map Principle: A Navigational-Based Hypothesis to Explain the Human Skills to Perform and Understand Basic Arithmetic (https://doi.org/10.5281/zenodo.13921658), addresses that more restricted question directly. It hypothesizes that the human navigational system can construct a one-dimensional numeric map isomorphic to a fragment of arithmetic and thereby help ground basic whole-number arithmetic in navigational operations. That hypothesis is complementary to the present results and independent of them. My target here is more abstract and general: I use standard computability-theoretic simulations to ask whether idealized allocentric-map computational models can realize arbitrary Turing-computable transformations. I do not claim that allocentric navigation by itself explains human mathematical understanding, and nothing in the argument presupposes the Numeric Map Principle. The claim is that map-based architectures have enough computational power in principle to support arbitrarily complex computable cognition.

The present results concern the computational power of idealized allocentric navigation architectures once their operative map structure, landmark relations, and transition resources are fixed. Under such conditions, allocentric navigation is Turing-computable in the ordinary sense. This does not imply that all biological processes involved in map formation, map revision, exploratory behavior, learning, or environmental interaction are themselves Turing-computable or fully capturable as computational processes. Real biological navigation unfolds in open-ended interaction with changing environments and dynamically evolving neural and bodily systems. I do not attempt to characterize the full dynamics of such processes here. My more limited claim is that allocentric navigation architectures possess sufficient representational and operational resources to realize universal computation under standard computability-theoretic idealizations.

Conclusion

I have presented three formal routes from allocentric cognitive-map architectures to computational universality. The first uses two allocentrically distinguished axes to encode counter values. The second turns a distinguished path of writable landmarks into a direct analogue of a Turing tape. The third replaces the globally indexed path primitive with local landmark cues encoding the same predecessor/successor structure. Each model has been specified as a tuple with an explicit instruction syntax and one-step relation, each simulation proceeds by a translation function together with an explicit encoding of configurations, and universality has been established both for the classes and, within each class, for a machine that simulates every machine in it.

These results are mathematically continuous with earlier work on graph-based computation, but they make explicit how universal computational capacity can be reconstructed within the framework of navigation within allocentric cognitive maps. With the finitary restrictions made explicit above, the three model classes are Turing-equivalent to standard universal models. In that way, they clarify the representational and computational significance of a class of architectures that are independently motivated by empirical work in neuroscience.

None of this is to say that biological navigation literally implements classical Turing-style computation. On the contrary, if allocentric navigation—which is nonclassical in many respects—is expressive enough to implement classical Turing computation, it may be expressive enough to explain cognition nonclassically (as I argue more generally in Neural Hardware for the Language of Thought: New Rules for an Old Game; https://arxiv.org/abs/2510.10251). That is enough to motivate the research program mentioned in Section 7, in which higher cognition, including symbolic processing, is reconstructed in navigation-based terms.

Author Contribution

Gualtiero Piccinini conceived the study, developed the arguments and proofs, and wrote and revised the manuscript.

Funding

No funding was received to assist with the preparation of this manuscript.

Data availability

No datasets were generated or analysed during the current study.

Declarations

Competing interests

The author declares no competing interests.

Use of generative AI

I used ChatGPT, Google Gemini, and Claude for research assistance, drafting and checking proofs, feedback on drafts, and editing. I reviewed and revised all output. I am solely responsible for all substantive ideas, arguments, interpretations, final source selection, and final wording.