<figure><img src="image_1.png" /></figure>

HAL
open science

Logarithmic Space and Permutations

Clément Aubert, Thomas Seiller

► To cite this version:

Clément Aubert, Thomas Seiller. Logarithmic Space and Permutations. 2013. [hal-01005701]

HAL Id: hal-01005701

https://hal.science/hal-01005701

Preprint submitted on 16 Feb 2015

**HAL** is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_2.png" /></figure>

Open licence - etalab
Logarithmic Space and Permutations☆

Clément Aubert<sup>a</sup>, Thomas Seiller<sup>b</sup>

<sup>a</sup>LIPN – UMR CNRS 7030 Institut Galilée - Université Paris-Nord 99, avenue J.-B. Clément
93430 Villetaneuse – France

<sup>b</sup>Institut des Hautes Études Scientifiques, Le Bois-Marie, 35 Route de Chartres, 91440
Bures-sur-Yvette, France

**Abstract**

In a recent work, Girard [1] proposed a new and innovative approach to computational complexity based on the proofs-as-programs correspondence. In a previous paper [2], the authors showed how Girard's proposal succeeds in obtaining a new characterization of co-NL languages as a set of operators acting on a Hilbert Space. In this paper, we extend this work by showing that it is also possible to define a set of operators characterizing the class L of logarithmic space languages.

**Keywords:** Linear Logic, Complexity, Geometry of Interaction, Pointer Machine, Finite Automata, Logarithmic Space

# 1. Introduction

## 1.1. Linear Logic and Implicit Computational Complexity

Logic, and more precisely proof theory – the domain whose purpose is the formalization and study of mathematical proofs – recently yielded numerous developments in theoretical computer science. These developments are founded on a correspondence, often called Curry-Howard correspondence, between mathematical proofs and computer programs (usually formalized in lambda-calculus). The main interest of this correspondence lies in its

<footnote>☆ Work partially supported by the ANR projects ANR-2010-BLAN-021301 LOGOI and ANR-08-BLAN-0211-01 COMPLICE.</footnote>

<footnote>Email addresses: aubert@lipn.fr (Clément Aubert), seiller@ihes.fr (Thomas Seiller)</footnote>
dynamic nature: program execution corresponds to a procedure on mathematical proofs known as the cut-elimination procedure.

In the eighties, Jean-Yves Girard discovered linear logic through a study of mathematical models of the lambda-calculus. This logical system, as a direct consequence of this correspondence between proofs and programs, is particularly interesting from the point of view of the mathematical foundations of computer science for its resource-awareness. In particular, it gave birth to a number of developments in the field of implicit computational complexity, for instance through the definition and study of restricted logical systems (sub-systems of linear logic) in which the set of representable functions captures a complexity class. For instance, elementary linear logic (ELL) restricts the rules governing the use of exponential connectives – the connectives dealing with the duplication of the arguments of a function – and the set of representable functions in ELL is exactly the set of elementary time functions [3]. It was also shown [4] that a characterization of logarithmic space computation can be obtained if one restricts both the rules of exponential connectives and the use of universal quantifiers. Finally, a variation on the notion of linear logic *proof nets* succeeded in characterizing the classes *NC* of problems that can be efficiently parallelized [5].

## 1.2. Geometry of Interaction

A deep study of the formalization of proofs in linear logic, in particular their formalization as proof nets, led Jean-Yves Girard to initiate a program entitled *geometry of interaction* (GoI) [6]. This program, in a first approximation, intends to define a semantics of proofs that accounts for the dynamics of the cut-elimination procedure. Through the correspondence between proofs and programs, this would define a semantics of programs that accounts for the dynamics of their execution. However, the geometry of interaction program is more ambitious: beyond the mere interpretation of proofs, its purpose is to completely reconstruct logic around the dynamics of the cut-elimination procedure. This means reconstructing the logic of programs, where the notion of formula – or type – accounts for the behavior of algorithms.

Informally, a geometry of interaction is defined by a set of *paraproofs* together with a notion of interaction, in the same way one defines strategies and their composition in game semantics. An important tool in the construction is a binary function that measures the interaction between two paraproofs. With this function one defines a notion of orthogonality that corresponds to the negation of logic and reconstructs the formulas as sets of paraproofs equal
to the orthogonal of a given set of paraproofs: a formula is therefore a set of "programs" that interact in a similar way to a given set of tests.

Since the introduction of this program Jean-Yves Girard proposed different constructions to realize it. These constructions share the notion of paraproofs: operators in a von Neumann algebra. They however differ on the notion of orthogonality they use: in the first constructions, this notion was founded on the nilpotency of the product of two operators, while the more recent construction [7] uses Fuglede-Kadison determinant – a generalization of the usual determinant of matrices that can be defined in type $II_1$ factors.

Since the reconstruction of logic is based on the notion of execution, geometry of interaction constructions are particularly interesting for the study of computational complexity. It is worth noting that the first construction of GoI [8] allowed Abadi, Gonthier, and Lévy [9] to explain the optimal reduction of $\lambda$-calculus defined by Lamping [10]. This first GoI construction was also used to obtain results in the field of implicit computational complexity [11].

### 1.3. *A new approach to complexity*

Recently Jean-Yves Girard proposed a new approach for the study of complexity classes that was inspired by his latest construction of a geometry of interaction. Using the crossed product construction between a von Neumann algebra and a group acting on it, he proposed to characterize complexity classes as sets of operators obtained through the internalization of outer automorphisms of the type $II_1$ hyperfinite factor. The authors showed in a recent paper [2] that this approach succeeds in defining a characterization of the set of **co-NL** languages as a set of operators in the type $II_1$ hyperfinite factor. The proof of this result was obtained through the introduction of *non-deterministic pointer machines*, which are abstract machines designed to mimic the computational behavior of operators. The result was obtained by showing that a **co-NL** complete problem could be solved by these machines.

In this paper, we extend these results in two ways. The first important contribution is that we give an alternative proof of the fact that **co-NL** is indeed characterized by non-deterministic pointer machines. This new proof consists in showing that pointer machines can simulate the well-known and studied two-way multi-head finite automata [12, 13]. The second contribution of this paper consists in obtaining a characterization of the class **L** as a set of operators in the hyperfinite factor of type $II_1$. By studying the set of operators that characterize the class **co-NL** and in particular the encoding of non-deterministic pointer machines as operators, we are able to show that
the operators encoding a deterministic machine satisfy a condition expressed in terms of norm. We then manage to show that the language decided by an operator satisfying this norm condition is in the class $\mathbf{L}$, showing that the set of all such operators characterizes $\mathbf{L}$.

## 2. The Basic Picture

The construction uses an operator-theoretic construction known as the crossed product of an algebra by a group acting on it. The interested reader can find a quick overview of the theory of von Neumann algebras in the appendix of the second author's work on geometry of interaction [14], and a brief presentation of the crossed product construction in the authors' previous work [2] on the characterization of co-NL. For a more complete presentation of the theory of operators and the crossed product construction, we refer to the well-known series of Takesaki [15, 16, 17].

In a nutshell, the crossed product construction $\mathfrak{A} \times_{\alpha} G$ of a von Neumann algebra $\mathfrak{A}$ and a group action $\alpha : G \to \text{Aut}(\mathfrak{A})$ defines a von Neumann algebra containing $\mathfrak{A}$ and unitaries that internalize the automorphisms $\alpha(g)$ for $g \in G$. For this, one considers the Hilbert space$^1 K = L^2(G, \mathbb{H})$ where $\mathbb{H}$ is the Hilbert space $\mathfrak{A}$ is acting on, and one defines two families of unitary operators$^2$ in $\mathcal{L}(K)$:

* the family $\{\pi(u) | u \in \mathfrak{A} \text{ unitary}\}$ which is a representation of $\mathfrak{A}$ on $K$;

* the family $\{\lambda(g) | g \in G\}$ which contains unitaries that internalize the automorphisms $\alpha(g)$.

Then the crossed product $\mathfrak{A} \ltimes_{\alpha} G$ is the von Neumann algebra generated by these two families.

<footnote>$^1$The construction $L^2(G, \mathbb{H})$ is a generalization of the well-known construction of the Hilbert space of square-summable functions: in case $G$ is considered with the discrete topology, the elements are functions $f: G \to \mathbb{H}$ such that $\sum_{g \in G} \|f(g)\|^2 < \infty$.</footnote>

<footnote>$^2$Recall that in the algebra $\mathcal{L}(\mathbb{H})$ of bounded linear operators on the Hilbert space $\mathbb{H}$ (we denote by $\langle \cdot, \cdot \rangle$ its inner product), there exists an anti-linear involution $(\cdot)^*$ such that for any $\xi, \eta \in \mathbb{H}$ and $A \in \mathcal{L}(\mathbb{H})$, $\langle A\xi, \eta \rangle = \langle \xi, A^*\eta \rangle$. This adjoint operator coincides with the conjugate-transpose in the algebras of square matrices. A unitary operator $u$ is an operator such that $uu^* = u^*u = 1$.</footnote>
As a by-product of Girard's work on geometry of interaction [7], we know<fnref n="3" /> how to represent integers as operators in the type $II_1$ hyperfinite factor $\mathfrak{R}$.

This representation comes from logical considerations, and it has some specificities, among which the fact that the integer is represented as a circular binary string, and the fact that every bit is considered as having an input and an output<fnref n="4" />. This representation arises from the interpretation of proofs of the type $\forall X!(X \to X) \to !((X \to X) \to !((X \to X)))$ (the type of binary lists in Elementary Linear Logic) in the setting of geometry of interaction. The obtained interpretation is the image of a matrix through an embedding of the matrix algebra in which it is contained in the hyperfinite factor. Since there are no natural choice of a particular embedding, a given integer does not have a unique representation in $\mathfrak{R}$, but a family of representations. Luckily, any two representations of a given integer are unitarily equivalent (we denote by $\mathfrak{M}_k(\mathbb{C})$ the algebra of $k \times k$ matrices over $\mathbb{C}$):

**Proposition 1** ([2, Proposition 10]). Let $N, N' \in \mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{R}$ be two representations of a given integer. There exists a unitary $u \in \mathfrak{R}$ such that:

$$N = (1 \otimes u)^* N' (1 \otimes u)$$

The next step is then to define a representation of machines, or algorithms, as operators that do not discriminate two distinct representations of a given integer, i.e. operators that act uniformly on the set of representations of a given integer. As the authors have shown in their previous work, the crossed product construction allows one to characterize an algebra of operators acting in such a uniform way. We recall the construction in the particular case of the group of finite permutations, which will be the only setting that will be studied in this work.

The algebra $\mathfrak{R}$ can be embedded in the infinite tensor product algebra $\mathfrak{T} = \bigotimes_{n \in \mathbb{N}} \mathfrak{R}$ through the morphism $\iota_0: x \mapsto x \otimes 1 \otimes 1 \otimes \dots$. We will denote by $\mathfrak{N}_0$ the image of $\mathfrak{R}$ in $\mathfrak{T}$ through $\iota_0$. Notice that this tensor product algebra is isomorphic to $\mathfrak{R}$. The idea of Girard is then to use the action of the group $\mathcal{S}$ of finite permutations of $\mathbb{N}$ onto $\mathfrak{T}$, defined by:

$$\sigma.(x_0 \otimes x_1 \otimes \dots \otimes x_k \otimes \dots) = x_{\sigma^{-1}(0)} \otimes x_{\sigma^{-1}(1)} \otimes \dots \otimes x_{\sigma^{-1}(k)} \otimes \dots$$

<footnote n="3">³A detailed explanation of this representation can be found in Appendix A, in the authors' previous work [2] or in the second author's PhD thesis [18].</footnote>

<footnote n="4">⁴Something that will be proven useful in Section 5, for it will help us to determine in which direction the integer is read.</footnote>
This group action defines a sub-algebra $\mathfrak{G}$ of the crossed product algebra $\mathfrak{R} = (\otimes_{n \in \mathbb{N}} \mathfrak{R}) \times \mathcal{S}$. This algebra $\mathfrak{G}$ is the algebra generated by the family of unitaries $\lambda(\sigma)$ for $\sigma \in \mathcal{S}$, and we think of it as the algebra of machines, or algorithms. As it turns out, the elements of this algebra act uniformly on the set of representations of a given integer:

**Proposition 2** ([2, Proposition 11]). Let $N, N' \in \mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{N}_0$ be two representations of a given integer, and $\phi \in \mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{G}$. Then:

$\phi N$ is nilpotent iff $\phi N'$ is nilpotent

To be a bit more precise, we will be interested in the elements of the algebras of operators $\mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{G} \otimes \mathfrak{M}_k(\mathbb{C})$. By tensoring with a matrix algebra, which we call the *algebra of states*, we will be able to develop more computational power. An element of one of these algebras will be called an *observation*, and it still acts uniformly on distinct representations $N_n, N'_n$ of a given integer: if $\phi$ is an observation, $\phi(N_n \otimes 1_{\mathfrak{M}_k(\mathbb{C})})$ is nilpotent if and only if $\phi(N'_n \otimes 1_{\mathfrak{M}_k(\mathbb{C})})$ is nilpotent$^5$. From this proposition, one can justify that the following definition makes sense:

**Definition 3.** Let $\phi \in \mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{G} \otimes \mathfrak{M}_k(\mathbb{C})$ be an observation. We define the language accepted by $\phi$ by $(N_n$ denotes any representation of the integer $n$):

$$[\phi] = \{n \in \mathbb{N} \mid \phi(N_n \otimes 1) \text{ nilpotent}\}$$

By extension, if $P$ is a set of observations, we denote by $[P]$ the set $\{[\phi] \mid \phi \in P\}$.

To sum up the construction, one has the following objects:

* an algebra containing representations of integers: the hyperfinite factor $\mathfrak{R}$ of type $II_1$, embedded in $\mathfrak{R}$ through the morphism $\pi \circ \iota_0$;

* an algebra containing the representations of machines, or algorithms: the von Neumann sub-algebra $\mathfrak{G}$ of $\mathfrak{R}$ generated by the set of unitaries $\{\lambda(\sigma) \mid \sigma \in \mathcal{S}\}$;

* a notion of acceptance: if $N$ is a representation of an integer and $\phi$ is a representation of a machine, we say that $\phi$ accepts $N$ when $\phi N$ is nilpotent.

<footnote>$^5$We will in the following simply write 1 for the identity element of $\mathfrak{M}_k(\mathbb{C})$.</footnote>
### 3. Pointer Machines

We previously introduced [2] non-deterministic pointers machines that were designed to mimic the computational behavior of operators: they do not have the ability to write, their input tape is cyclic, and they are “universally non-deterministic”, i.e. rejection is meaningful whereas acceptation is the default behavior. We exhibited a non-deterministic pointer machine that decides a **co-NL**-complete language and showed how a reduction could be performed with pointers. Here, we complete this result by simulating multi-head finite automata [19], a method that allows us to get a deeper understanding of pointer machines, in both their deterministic and non-deterministic versions.

A pointer machine is given by a set of pointers that can move back and forth on the input tape and read (but not write) the values it contains, together with a set of states. For $1 \le i \le p$, given a pointer $p_i$, only one of three different instructions can be performed at each step: $p_i+$, i.e. “move one step forward”, $p_i-$, i.e. “move one step backward” and $\epsilon_i$, i.e. “do not move”. In the following definition, we let $I^k = \{p_k+, p_k-, \epsilon_k\}$ be the set of instructions for the $k$-th pointer and $\Sigma = \{0, 1, \star\}$ be the alphabet. We will denote by $\#p_i$ the address of the pointer.

**Definition 4.** A non-deterministic pointer machine with $p \ge 1$ pointers is a couple $M = \{Q, \rightarrow\}$ where $Q$ is the set of states and $\rightarrow \subseteq (\Sigma^p \times Q) \times \prod_{i=1}^p I^i \times Q) \cup \{\text{accept, reject}\}$ is the transition relation and it is total. We write $\text{NDPM}(p)$ the set of non-deterministic pointer machines with $p$ pointers.

A configuration of $M \in \text{NDPM}(p)$ is as usual a “snapshot” of $M$ at a given time, and we define a *pseudo-configuration* $c$ of $M \in \text{NDPM}(p)$ as a “partial snapshot”: $c \in \Sigma^p \times Q$ contains the last values read by the $p$ pointers and the current state, but does not contain the addresses of the $p$ pointers. It is therefore impossible to resume the computation from a pseudo-configuration provided the description of $M$ and the input, but one can know what would be the set of instructions and the new state resulting from the application of $\rightarrow$. The set of pseudo-configurations of a machine $M$ is written $C_M$ and it is the domain of the transition relation. If $\rightarrow$ is functional, $M$ is a *deterministic pointer machine*. We write $\text{DPM}(p)$ the set of deterministic pointer machines with $p$ pointers.

Let $M \in \text{NDPM}(p)$, $s \in C_M$ and $n \in \mathbb{N}$ an input. We define $M_s(n)$ as $M$ with
$n$ encoded as a string$^6$ on its circular input tape (as $\star a_1 \dots a_k$ for $a_1 \dots a_k$ the binary encoding of $n$ and $a_{k+1} = a_0 = \star$) starting in the pseudo-configuration $s$ with $\#p_i = 0$ for all $1 \le i \le p$ (that is, the pointers are initialized with the address of the symbol $\star$). The pointers may be considered as variables that have been declared but not initialized yet. They are associated with *memory slots* that store the values and are updated only when the pointer moves, so as the pointers did not move yet, those memory slots haven't been initialized. The *initial pseudo-configuration* $s$ initializes those $p$ registers, not necessarily in a faithful way (it may not reflect the values contained at $\#p_i$). The entry $n$ is *accepted* (resp. *rejected*) by $M$ with *initial pseudo-configuration* $s \in C_M$ if after a finite number of transitions every branch of $M_s(n)$ reaches **accept** (resp. at least a branch of $M$ reaches **reject**). We say that $M_s(n)$ halts if it accepts or rejects $n$ and that $M$ decides a set $S$ if there exists a pseudo-configuration $s \in C_M$ such that $M_s(n)$ accepts if and only if $n \in S$.

As we will see, this notion of non-deterministic pointer machines is similar to the classical notion of multi-head finite automata:

**Definition 5.** [13, Definition 1] For $k \ge 1$, a non-deterministic two-way $k$-head finite automaton is a tuple $M = \{S, A, k, \Delta, \lhd, s_0, F, \sigma\}$ where:

* $S$ is the finite set of states;

* $A$ is the alphabet$^7$;

* $k$ is the number of heads;

* $\Delta$ and $\lhd$ are the *left and right endmarkers*;

* $s_0 \in S$ is the *initial state*;

* $F \subseteq S$ is the set of *accepting states*;

* $\sigma \subseteq (S \times (A \cup \{\Delta, \lhd\})^k) \times (S \times \{-1, 0, 1\}^k)$ is the *transition relation*, where $-1$ means to move the head one square to the left, $0$ means to keep the

<footnote>$^6$Of course, one could do the exact same work taking binary words instead of integers. This choice of presentation was originally driven by Girard's will to enlighten that, among the infinitely many isomorphic representations of an integer, "none of them [was] more 'standard' than the others." [1, p. 244]</footnote>

<footnote>$^7$We take it to be always equal to $\{0, 1\}$, as any alphabet is equivalent to this one modulo a reasonable translation.</footnote>
head on the current square and 1 means to move it one square to the right.

Moreover, whenever<fnref n="8" /> $(s', (d_1, \dots, d_k)) \in \sigma(s, (a_1, \dots, a_k))$, then $a_i = \Delta (1 \le i \le k)$ implies $d_i \in \{0, 1\}$, and $a_i = \lhd (1 \le i \le k)$ implies $d_i \in \{-1, 0\}$.

In the following, we will denote by 2NDFA($k$) the set of non-deterministic two-ways $k$-head finite automata.

One defines configurations and transitions in a classical way. One should however notice that the heads cannot move beyond the endmarkers because of the definition of the transition relation.

Let $M \in 2\text{NDFA}(k)$ and $n \in \mathbb{N}$ an input whose binary writing is $w$. We say that $M$ accepts $n$ if $M$ starts in state $s_0$, with $\Delta w \lhd$ written on its input tape and all of its heads on $\Delta$, and if after a finite number of transitions at least one branch of $M$ reaches a state belonging to $F$. We say that $M$ always halt if for all input all branches of $M$ reach after a finite number of transitions a configuration such that no transition may be applied. If $\sigma$ is functional, $M$ is said to be *deterministic*. We write $2\text{DFA}(k)$ the set of deterministic two-way $k$ heads automata.

**4. Simulation and first results**

Multi-head finite automata were introduced in the early seventies [12] and provided many promising perspectives<fnref n="9" />. Their nice characterization of **L** and **NL** and the similarities they share with non-deterministic pointer machines will be the key to prove (anew) that non-deterministic pointer machines characterize **co-NL** and that their deterministic restriction characterizes **L**.

We will denote by **DPM**, **NDPM**, **2DFA** and **2NDFA** the sets of languages decided by respectively the sets $\cup_{k \ge 1}\text{DPM}(k)$, $\cup_{k \ge 1}\text{NDPM}(k)$, $\cup_{k \ge 1}\text{2DFA}(k)$ and $\cup_{k \ge 1}\text{2NDFA}(k)$.

**Theorem 6** ([12], p. 338). $L = \text{2DFA}$ and $\text{NL} = \text{2NDFA}$.

We will denote in the following by $\mathcal{L}(X)$ (resp. $\overline{\mathcal{L}(X)}$) the language accepted (resp. rejected) by $X$.

<footnote n="8">⁸Of course, one may see $\sigma$ as a partial function from $S \times (A \cup \{\Delta, \lhd\})^k$ to $\mathcal{P}(S \times \{-1, 0, 1\}^k)$, and that justifies this notation that we will use from now on.</footnote>

<footnote n="9">⁹An overview of the main results and open problems of the theory was recently published [13].</footnote>
**Proposition 7.** For all $M \in 2NDFA(k)$ (resp. $M \in 2DFA(k)$), there exists $k'$ and $M' \in 2NDFA(k')$ (resp. $M' \in 2DFA(k')$) such that $M'$ always halt and $\mathcal{L}(M) = \mathcal{L}(M')$.

*Proof.* Given an input $n \in \mathbb{N}$, we know that the number of configurations of $M$ is bounded by $\text{Card}(S) \times (\log_2(n)+2)^k$, that is to say by $\log_2(n)^d$ for $d$ a constant fixed with $M$. We will construct $M'$ so that it halts rejecting after performing more than this number of transitions.

We set $k' = k + d + 1$, and we construct $M'$ so that its $k$ first heads act as the heads of $M$, and the $d+1$ heads act as the hands of a clock, going back and forth between the two endmarkers. For all $s \in S$ of $M$, $S'$ contains the set of states $s \times \{\to, \leftarrow\}^{d+1}$ that give the current direction of the $d+1$ heads. At every transition the $k+1$-th head moves according to its direction. For $k < i < k'$, when the $i$-th head has made a round-trip on $n$, the $i+1$-th head moves one square according to its direction. If the $k$-th head has made a round-trip on $n$ – that is, is back on $\triangleright - M'$ halts rejecting$^{10}$.

Now remark that if a branch of $M$ accepts, there exists a branch of $M$ that accepts without ever looping, i.e. without going through the same configuration twice. Moreover, branches without loops are of length at most $\text{Card}(S) \times (\log_2(n)+2)^k$. Thus, if $M$ has no branches of length less than $\log_2(n)^d$ for the suitable $d$, then it has no accepting branch. By construction, $M'$ always halts after $\log_2(n)^{d+1}$ transitions and accepts exactly as $M$ does, so we proved that $\mathcal{L}(M) = \mathcal{L}(M')$ and that $M'$ always halts. Notice that if $M$ was deterministic, so is $M'$. $\square$

**Proposition 8.** For all $k \ge 1$, for all $M \in 2NDFA(k)$ (resp. $M \in 2DFA(k)$) that always halts, there exists $M' \in NDPM(k)$ (resp. $M' \in 2DFA(k)$) such that $\mathcal{L}(M) = \mathcal{L}(M')$.

*Proof.* There is only little work to do, since NDPMs are essentially “re-arrangements” of NDFAs. Given $M = \{S, A, k, \triangleright, \triangleleft, s_0, F, \sigma\}$, we design $M' = \{Q, \to\} \in \text{NDPM}(k)$ that rejects an input iff $M$ accepts it. We set $Q = S \setminus F$. The transition relation $\to$ is obtained from $\sigma$ as follows:

* If the state of the resulting configuration of a transition belongs to $F$, the same transition belongs to $\to$ with its right-hand side replaced by **reject**;

<footnote n="10">¹⁰That can be simply done by halting the computation in a state not belonging to $F$.</footnote>
• The role of both endmarkers $▷$ and $◁$ is played by the symbol $★$;

• The instructions $-1, 0$ and $1$ in position $i \in \mathbb{N}$ are translated by $p_i -, \epsilon_i$ and $p_i +$.

There is one point that needs some care. If a transition $t_1$ in $\sigma$ have for premise $(q, (..., \triangleleft, ...))$ and another one $t_2$ have for premise $(q, (..., \triangleright, ...))$, we cannot translate in $\rightarrow$ both with $(q, (..., ★, ...))$: that would introduce non-determinism in deterministic machines, and could lead to false positive as well as false negative. Remark that this "critical pair" may involve more than one pointer.

If such a situation occurs in $\sigma$, one may patch it by creating duplicates of each states, to label them with the last directions of each pointer. This modification provokes a global rewriting of $\rightarrow$ to take into account new states, but do not raise any particular difficulty. Thanks to a slight overhead in the number of state, it is possible to encode if $★$ was read from the right (and hence encode $▷$) or from the left (and hence encode $◁$).

At last, to make $\rightarrow$ total, one just have to complement it by adding, from any pseudo-configuration not in the domain of definition of $\sigma$, transitions leading to **accept**. Finally, we chose the initial pseudo-configuration $c$ to be $\{★, ..., ★, s_0\}$.

As $M$ always halts, rejection is exactly “not accepting”, and $M'$ always halts. One can check that $M'_c(n)$ accepts iff $M(n)$ rejects. Moreover, if $M$ is deterministic, so is $M'$. □

This proposition has as an immediate corollary the inclusions **co-2DFA** $\subseteq$ **DPM** and **co-2NDFA** $\subseteq$ **NDPM**. By combining this result with Theorem 6 and the fact that **L** is closed under complementation$^{11}$, we obtain the expected result:

**Corollary 9.** $L \subseteq DPM$ and $co-NL \subseteq NDPM$.

The converse inclusion will be a by-product of the encoding of NDPMs into operators and won't be proved directly, but it is reasonable to think of NDPMs

<footnote>11Using the fact that NL = co-NL [20], we could show that NL $\subsetneq$ NDPM. However, we choose not to use the well-known equality between NL and co-NL in the hope that this new approach to complexity may provide a new proof of this result. Moreover, it is easier to grasp the computation of observations as "universally non-deterministic".</footnote>
as “modified” 2NFAs. Those modifications are introduced to ease the simulation by operators: we already mentioned that the transition relation was total, the input circular, the importance of the initial pseudo-configuration to initialize the computation, but we should also mention that any NDPM can be modified so that it does not move more than one pointer at each transition.

## 5. Pointer Machines and Operators

In this section, we will briefly explain the encoding of pointer machines as operators. The non-deterministic case, which was already defined in our previous work [2], will be given in Section 5.1. The specifics of the deterministic case, which is a novelty, concludes in Section 5.2 this section. An example, detailed in Appendix A, will help the reader to grasp the main steps of that encoding.

### 5.1. Encoding NDPMs

We will begin by a definition of two families of observations.

**Definition 10.** Let $\phi \in \mathfrak{M}_6(\mathbf{C}) \otimes \mathfrak{G} \otimes \mathfrak{M}_k(\mathbf{C})$ be an observation that we will write as a $6k \times 6k$ matrix $(a_{i,j})_{1 \le i,j \le 6k}$ with coefficients in $\mathfrak{G}$. We say that $\phi$ is:

* A positive observation if for all $1 \le i,j \le 6k$, we have $a_{i,j} = \sum_{m=0}^{l} \alpha_{m}^{i,j} \lambda(g_{m}^{i,j})$ where $l$ is an integer (possibly null), and $\alpha_{m}^{i,j}$ are positive real numbers.

* A boolean observation if for all $1 \le i,j \le 6k$, we have $a_{i,j} = \sum_{m=0}^{l} \lambda(g_{m}^{i,j})$ where $l$ is an integer (possibly null).

**Definition 11.** We define the following sets:

$$P_{\ge 0} = \{\phi \mid \phi \text{ is a positive observation}\}$$

$$P_{+} = \{\phi \mid \phi \text{ is a boolean observation}\}$$

We showed [2] that any non-deterministic pointer machine $M$ can be encoded as an operator in $P_+$, implying that $\mathbf{co-NL} \subseteq [P_+]$.

The encoding of non-deterministic pointer machines was defined as follows: we encode each couple $(c,t) \in \mathbb{N}$ by an operator $\phi_{c,t}$, and then the encoding of the transition relation corresponds to the sum:

$$\mathbb{N} \to \sum_{c \in C_M} \left( \sum_{t \text{ s.t. } c \to t} \phi_{c,t} \right)$$
To define the encoding correctly, we need to introduce a number of additional states. We will denote by $Q^\uparrow$ the extended set of states obtained from $Q$. According to the notation introduced in Figs. 1 and 2, this set has cardinality $\text{Card}(Q) + p \times (\text{Card}(Q)^2 + 2)$ and is (a subset of):

$$Q^\uparrow = Q \cup \bigcup_{j=1}^{p} \left( \{\text{mov-back}_j, \text{back}_j\} \cup \{\text{mov}_j^{q,q'} | \mathbf{q}, \mathbf{q}' \in Q\} \right)$$

The machine will then be encoded as an operator in $\mathfrak{M}_6(\mathfrak{G}) \otimes \mathfrak{P}$, where $\mathfrak{P}$ is the algebra of pseudo-states, i.e. an algebra that will encode the memory slots that contain the last value read by the pointers, and the extended set of states $Q^\uparrow$. That is:

$$\mathfrak{P} = \underbrace{\mathfrak{M}_6(\mathbf{C}) \otimes \mathfrak{M}_6(\mathbf{C}) \otimes \cdots \otimes \mathfrak{M}_6(\mathbf{C})}_{p \text{ times}} \otimes \mathfrak{M}_{\text{Card}(Q^\uparrow)}(\mathbf{C})$$

Summing up, the encoding of a non-deterministic pointer machine with a set of states $Q$ will be an observation in the algebra $\mathfrak{M}_6(\mathbf{C}) \otimes \mathfrak{G} \otimes \mathfrak{M}_k(\mathbf{C})$ with $k = 6^p \times \text{Card}(Q^\uparrow) = 6^p \times (\text{Card}(Q) + p \times (\text{Card}(Q)^2 + 2)).$

The following encoding differs from the one used in our earlier work [2]. The reason for this (small) change is that the encoding of the “move forward” and “move backward” instructions were defined as operators whose norm was strictly greater than 1. Since we want the encoding of a deterministic machine to be of norm at most 1 (see the next subsection), it is necessary to define a more convenient encoding. The encoding of acceptance and rejection are not modified, but we recall them anyway. The reader should also keep in mind that the encoding of the integer is somehow redundant, for every bit will have an input and an output: this will help us to discriminate between the movements of a pointer from right to left and the movements from left to right.

Before describing the encoding in details, we need to introduce several notations that will be used for the definition of operators. We recall that the integer is encoded as a circular string, whose start and end is $\star$, and that every bit has an output that is connected to the input of the following bit. So for instance “reading” $0i$ amounts to asking (the integer) what is the bit before the bit 0 under treatment, “reading” $\star o$ amounts to asking what is the first bit of the integer. The way the “pointer” will parse the entry is highly interactive, or dynamic, for it is always on the edge of reading the next bit. So we define the projections $\pi_*$ of $\mathfrak{M}_6(\mathbf{C})$ ($* \in \{0i, 0o, 1i, 1o, e, s\}$) as the projections on the
subspace induced by the basis element<fnref n="12" />. We will sometimes denote $e$ (resp. $s$) by $\star i$ (resp. $\star o$), and we also define the projections $\pi_{in} = \pi_{0i} + \pi_{1i} + \pi_e$ and $\pi_{out} = \pi_{0o} + \pi_{1o} + \pi_s$. Those projections correspond to the following matrices.

$$ \pi_{\text{in}} = \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} \qquad \pi_{\text{out}} = \begin{pmatrix} 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 \end{pmatrix} $$

We will moreover use matrices named $(\text{in} \to \text{out})$ and $(\text{out} \to \text{in})$, shown below. Those matrices will be used for continuing a movement in the same direction as the last movement, i.e. if the integer answered that the last read value was a 0, it will answer on the basis element $0i$ – for “0 in” – if the pointer is moving forward. Then, to ask the next value, the pointer needs to ask the next value on the basis element $0o$ – for “0 out”. To go from $0i$ to $0o$, one can apply the matrix $(\text{in} \to \text{out})$. The matrix $(\text{out} \to \text{in})$ plays the same role when moving in the opposite direction. Moreover, changes of directions are dealt with the projections $\pi_{\text{in}}$ and $\pi_{\text{out}}$.

$$ (\text{in} \to \text{out}) = \begin{pmatrix} 0 & 0 & 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 \end{pmatrix} \qquad (\text{out} \to \text{in}) = \begin{pmatrix} 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} $$

For the sake of simplicity, we also define the following operators in $\mathfrak{P}$: if $c = (a_1, \dots, a_p, \mathbf{q})$ and $c' = (a'_1, \dots, a'_p, \mathbf{q}')$, we define the partial isometry:

$$ (c \to c') = (a_1 \to a'_1) \otimes \dots \otimes (a_p \to a'_p) \otimes (\mathbf{q} \to \mathbf{q}') $$

<footnote n="12">¹²To be coherent with the notations of our earlier paper, we will always denote by $\{0i, 0o, 1i, 1o, e, s\}$ the basis of $\mathfrak{M}_6(\mathbf{C})$ we are working with.</footnote>
where $(p \to p')$ (for $p, p' \in Q^\uparrow$ or $p, p' \in \{0i, 0o, 1i, 1o, e, s\}$) is defined as:

$$p' \quad \begin{pmatrix} 0 & \dots & 0 & \dots & 0 \\ \vdots & \ddots & \vdots & \ddots & \vdots \\ 0 & \dots & 1 & \dots & 0 \\ \vdots & \ddots & \vdots & \ddots & \vdots \\ 0 & \dots & 0 & \dots & 0 \end{pmatrix}$$

For $S$ a set of states, we will use the notation $(S \to a'_i)$ (denoted $(\to a'_i$) when $S$ contains all possible states) for the sum of partial isometries $\sum_{s \in S} (s \to a'_i)$ that encodes a transition from any state in $S$ to $a'_i$. The notation $(S \to)$ will denote the projection on the subspace generated by $S$.

A transition that impacts only on the values stored in the subset of pointers<fnref n="13" /> $p_{i_1}, \dots, p_{i_l}$ and the state $q$ will be denoted by

$$((a_{i_1} \to a'_{i_1})_{i_1}; \dots; (a_{i_l} \to a'_{i_l})_{i_l}; q \to q')$$

This operator is defined as

$$u_1 \otimes u_2 \otimes \dots \otimes u_p \otimes (q \to q')$$

where $u_i = (a_{i_j} \to a'_{i_j})$ if $\exists j, i = i_j, u_i = 1$ elsewhere.

Finally, we will denote by $\tau_{i,j}$ the operator in $\mathfrak{G}$ induced by the transposition exchanging the integers $i$ and $j$.

Now, we can explain how the different transitions are encoded. Figures 1 and 2 give the definitions of the operators used in the following description.

*Move a pointer, read a value and change state.* We first explain how to encode the action “move forward the pointer $j$”. When we are in the pseudo-configuration $c = (a_1, \dots, a_p; q)$, the machine, during this transition, moves the pointer $j$ one step to the right, reads the value $a'_j$ stored at $\#p_j$, updates the memory slot in consequence and changes the state from $q$ to $q'$. There are two cases: either the last movement of the pointer $j$ was a forward move,

<footnote n="13">¹³In fact this subset will always be a singleton, for our encoding corresponds to a NDPM that moves at most one pointer at each transition and any NDPM can be replaced by another NDPM that moves its pointers one at a time.</footnote>
$$
\begin{align*}
\mathrm{bf}_{j,q'}^{c} &= \pi_{\mathrm{out}} \otimes \tau_{0,j} \otimes ((\{0o, 1o, \star o\} \to)_j \mathbf{q} \to \mathrm{mov}_{j}^{q,q'}) \\
\mathrm{ff}_{j,q'}^{c} &= (\mathrm{in} \to \mathrm{out}) \otimes \tau_{0,j} \otimes ((\{0i, 1i, \star i\} \to)_j \mathbf{q} \to \mathrm{mov}_{j}^{q,q'}) \\
\mathrm{fb}_{j,q'}^{c} &= \pi_{\mathrm{in}} \otimes \tau_{0,j} \otimes ((\{0i, 1i, \star i\} \to)_j \mathbf{q} \to \mathrm{mov}_{j}^{q,q'}) \\
\mathrm{bb}_{j,q'}^{c} &= (\mathrm{out} \to \mathrm{in}) \otimes \tau_{0,j} \otimes ((\{0o, 1o, \star o\} \to)_j \mathbf{q} \to \mathrm{mov}_{j}^{q,q'}) \\
\mathrm{rec}_{j,q'}^{c} &= \sum_{\bullet \in \{0,1,\star\}} (\pi_{\bullet i} \otimes \tau_{0,j} \otimes ((\to \bullet i)_j; \mathrm{mov}_{j}^{q,q'} \to \mathbf{q'}))
\end{align*}
$$

<caption>Figure 1: The operators in $\mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{G} \otimes \mathfrak{P}$ encoding forward and backward move instructions</caption>

$$
\begin{align*}
\mathrm{rm}_j &= 1 \otimes \tau_{0,j} \otimes (\mathbf{back}_j \to \mathbf{mov-back}_j) \\
\mathrm{rr}_j^0 &= \pi_{0o} \otimes \tau_{0,j} \otimes ((\to 0o)_j; \mathbf{mov-back}_j \to \mathbf{back}_j) \\
\mathrm{rr}_j^1 &= \pi_{1o} \otimes \tau_{0,j} \otimes ((\to 1o)_j; \mathbf{mov-back}_j \to \mathbf{back}_j) \\
\mathrm{rc}_j &= \begin{cases}
\pi_{\star o} \otimes \tau_{0,j} \otimes ((\to a_j)_j; \mathbf{mov-back}_j \to \mathbf{back}_{j+1}) & (1 \le j < p) \\
\pi_{\star o} \otimes \tau_{0,p} \otimes ((\to a_p)_p; \mathbf{mov-back}_p \to \mathbf{q}_0) & (j = p)
\end{cases}
\end{align*}
$$

<caption>Figure 2: The operators in $\mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{G} \otimes \mathfrak{P}$ encoding rejection.
The operator $\mathrm{rc}_j$ is parametric on an initial pseudo-configuration $s = (a_1, \dots, a_p; \mathbf{q}_0)$.</caption>
or it was a backward move. The case we are dealing with is obtained from
the value stored in memory slot of the *j*-th pointer: if the value is $0i$, $1i$ or
$★i$, then the last move was a forward move, if the value is $0o$, $1o$ or $★o$, the
last move was a backward move. In the first case, the operator $ff_{j,q'}^c$ will be
applied (notice the projection $\pi_{in}$ on the *j*-th memory slot), and in the second
the $bf_{j,q'}^c$ operator will be applied. Both these operators somehow *activate*
the *j*-th pointer by using the transposition $\tau_{0,j}$ and prepare for reading the
representation of the integer. This representation will then give the value
of the next (when moving forward) digit of the input. The $rec_{j,q'}^c$ operator is
then applied in order to simultaneously update the value of the *j*-th memory
slot and *deactivate* the *j*-th pointer.

The operator that will encode the moving forward instruction is then
defined as $\text{forward}_{j,q'}^c = bf_{j,q'}^c + ff_{j,q'}^c + \text{rec}_{j,q'}^c$, which is an element of the algebra
$\mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{G} \otimes \mathfrak{P}$.

In case of a “move backwards pointer *j*” instruction, the operator encoding
the transition is $\text{backward}_{j,q'}^c = fb_{j,q'}^c + bb_{j,q'}^c + \text{rec}_{j,q'}^c$, one again an element of
the algebra $\mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{G} \otimes \mathfrak{P}$.

In the following, we will forget about the subscripts and superscripts of
these operators<fnref n="14" /> and write $ff$, $fb$, $bf$, $bb$ and $rec$ in order to simplify notations.

*Accept.* The case of acceptance is especially easy: we want to stop the computation<fnref n="15" />, so every transition $(a_1, \dots, a_n; q) \to \textbf{accept}$ will be encoded by $0$.

*Reject.* The transitions of the form $(a_1, \dots, a_n; q) \to \textbf{reject}$ are encoded by the
operator that represents the “transition” $(a_1, \dots, a_n; q) \to (a_1, \dots, a_n; \mathbf{back}_1)$.

This defines the operator $\to^*$ encoding the transition relation $\to$. But we
need a bit more to interpret a machine. Indeed, as we already explained, the
representation of an integer is accepted by an observation $\phi$ if the product of
the two operators is nilpotent. Hence, a rejection should lead to the creation
of a loop. We therefore add two new states – **back**$_j$ and **mov-back**$_j$ – for
each $j = 1, \dots, p$. We can then define $\text{reject}_s = \sum_{j=1}^p \text{rm}_j + \text{rr}_j^0 + \text{rr}_j^1 + \text{rc}_j$. This

<footnote n="14">¹⁴Remark by the way that all those indices were redundant, for the pseudo-configuration *c* entails a choice of *j* and *q*′.</footnote>

<footnote n="15">¹⁵This is one of the reasons we did not considered **accept** to be a state: we want the computation to stop immediately, there is no need to provide “one last set of instructions”.</footnote>
operator actually encodes a reinitialization<fnref n="16" /> of the machine that starts when the computation reaches the state **back**₁: the pointers are moved back one after the other until they point on the symbol ⋆, and the memory slots and the state are initialized according to the given initial pseudo-configuration s = (a₁, ..., aₚ; **q**₀). The reason for this complicated way of encoding rejection comes from the fact that the computation simulated by the operators is massively parallel: the operator $M_s^*$ is a big sum that recollect every single evolution from a pseudo-configuration to any other “reachable” with →, and it starts moreover in all pseudo-configurations at the same time.

Another complication due to this parallel computation and this particular way of defining rejection is that the operators simulate correctly only *acyclic machines*, i.e. machines that never enter a computational loop whichever configuration – including intermediary ones – is chosen as a starting point for computation<fnref n="17" />. This is necessary because we want the entering of a loop to be the result of rejection. Fortunately, it can be shown that:

**Proposition 12** ([2, Lemma 25]). For all $M \in \text{NDPM}(p)$ there exists $M' \in \text{NDPM}(p')$ such that $M'$ is acyclic and $\mathcal{L}(M) = \mathcal{L}(M')$.

In the particular case of acyclic machines, one can show that the encoding is sound:

**Proposition 13** ([2, Lemma 29]). Let $M \in \text{NDPM}(p)$ be acyclic, $c \in C_M$ and $M_s^* = \rightarrow^* + \text{reject}_s$. For all $n \in \mathbb{N}$ and every binary representation $N_n \in \text{vnM}_6(\mathbb{C}) \otimes \mathbb{N}_0$ of the integer $n$:

$$M_s(n) \text{ accepts} \Leftrightarrow M_s^*(N_n \otimes 1) \text{ is nilpotent.}$$

These two results can then be combined with the results of the previous section to get the following proposition:

<footnote n="16">¹⁶And this is why the encoding of a NDPM is done provided an initial pseudo-configuration $s$. In practice, one can always take $s$ to be the “faithful” pseudo-configuration, i.e. $s = \star, \dots, \star; \mathbf{q}_0$. We choose to dwell on the parametricity of the encoding to highlight the particular mechanism of rejection, and its flexibility.</footnote>

<footnote n="17">¹⁷For instance, let us consider a machine $M$ that contains a state **loop** and, for a chosen pseudo-configuration $c$, the transition $(c, \text{loop}) \rightarrow (\epsilon_1, \dots, \epsilon_p, \text{loop})$. Then this machine is not acyclic, even if the state **loop** cannot be accessed during the computation, i.e. even if $M$ do not contain any transition leading to the state **loop**.</footnote>
**Proposition 14.**

$$ \mathit{co-NL} \subseteq [P_+] $$

We will now study the encoding of deterministic pointer machines in more detail.

## 5.2. The Encoding of DPMs

We will show that the encoding of deterministic pointer machines satisfies a particular property: their 1-norm is less or equal to 1. We first define what is the 1-norm on the algebras $M_k(M_6(\mathbb{R}))$; this defines in particular the 1-norm of observations since $M_6(\mathbb{C}) \otimes \mathfrak{G} \otimes \mathfrak{P}$ is a subalgebra of $M_6(\mathbb{C}) \otimes \mathfrak{R} \otimes M_k(\mathbb{C})$ (for $k = 6^p \times \mathrm{Card}(\mathbb{Q}^\dagger)$), which is isomorphic to $M_k(M_6(\mathbb{R}))$.

**Definition 15.** We define the family of norms $\|\cdot\|_1^k$ on $M_k(M_6(\mathbb{R}))$ by:

$$ \|(a_{i,j})_{1 \le i,j \le k}\|_1^k = \max_{1 \le j \le k} \sum_{i=1}^k \|a_{i,j}\| $$

where $\|a_{i,j}\|$ is the usual norm (the $C^*$-algebra norm) on $M_6(\mathbb{R})$. We will simply write $\|\cdot\|_1$ when the superscript is clear from the context.

*Remark.* For each $k$, the map $\|\cdot\|_1^k : M_k(M_6(\mathbb{R})) \to \mathbb{R}_{\ge 0}$ just defined is a norm and, as such, does not depend on the chosen basis. To understand this, notice that this norm can be defined – considering the isomorphism between $M_k(M_6(\mathbb{R}))$ and $M_k(\mathbb{C}) \otimes M_6(\mathbb{R})$ – as the tensor product of the 1-norm on $M_k(\mathbb{C})$ and the usual norm on $M_6(\mathbb{R})$. The 1-norm on $M_k(\mathbb{C})$ is formally defined from the usual 1-norm on vectors as $\|A\|_1 = \sup_{\|x\|_1 = 1} \frac{\|Ax\|_1}{\|x\|_1}$. It can then be shown equal, for any (orthonormal) basis in which one may write $A$ as a matrix $(a_{i,j})_{1 \le i,j \le k}$, to the expression $\max_{1 \le j \le k} \sum_{i=1}^k |a_{i,j}|$.

A corollary of the following proposition will be used extensively in the proofs.

**Proposition 16.** Let $A, B$ be operators such that $AB^* = B^*A = 0$. Then:

$$ \|A + B\| = \max\{\|A\|, \|B\|\} $$

*Proof.* Actually, this proposition appears as Theorem 1.7 (b) in an article by P. J. Maher [21]. This last theorem is stated differently (with conditions on ranges) in the given reference. To obtain the result as we stated it, simply notice that $AB^* = 0$ implies $\mathrm{Ran}(B^*) \subseteq \mathrm{ker}(A) = (\mathrm{Ran}(A^*))^\perp$ so $\mathrm{Ran}(B^*) \perp$
Ran(A*). Similarly, $B^*A = 0$ implies that $\mathrm{Ran}(A) \subseteq \mathrm{ker}(B^*) = (\mathrm{Ran}(B))^{\perp}$ so $\mathrm{Ran}(A) \perp \mathrm{Ran}(B)$. Thus, if $AB^* = B^*A = 0$, we have $\mathrm{Ran}(A) \perp \mathrm{Ran}(B)$ and $\mathrm{Ran}(A^*) \perp \mathrm{Ran}(B^*)$ and one can then apply the theorem of Maher. $\square$

**Corollary 17.** The operators $ff+bf$, $rec$, $bb+fb$, and $rr_j^0+rr_j^1+rc_j$ ($j$ fixed) are of norm 1.

*Proof.* It is clear that $bf \times ff^* = 0$ since $\pi_{\mathrm{out}}\pi_{\mathrm{in}} = 0$. Similarly, $ff^* \times bf = 0$. Thus, using the preceding proposition, we have $\|ff+bf\| = \max\{\|bf\|, \|ff\|\} = 1$.

A similar argument shows that $\|fb+bb\| = 1$.

Clearly, as a consequence of $\pi_{ai}\pi_{bi} = 0$ for $a \neq b$, we deduce $\|\mathrm{rec}\| = 1$ by Proposition 16.

We are now proving the result for $rr_j^0 + rr_j^1 + rc_j$, so we fix $1 \le j \le p$. First, notice that $rc_j \times (rr_j^0)^* = 0$ as a consequence of $\pi_{\mathbf{mov-back}_j} \times \pi_{\mathbf{back}_j} = 0$. Conversely, $(rr_j^0)^* \times rc_j = 0$ as a consequence of $\pi_{\mathbf{back}_{j+1}} \times \pi_{\mathbf{mov-back}_j} = 0$. A similar argument shows that $rc_j \times (rr_j^1)^* = 0$ and $(rr_j^1)^* \times rc_j = 0$. Moreover, we know that $(rr_j^0)^* \times rr_j^1 = 0$ and $rr_j^1 \times (rr_j^0)^* = 0$ by just looking at the first term of the tensor in their definition. By an iterated use of Proposition 16, we get that $\|rr_j^0 + rr_j^1 + rc_j\| = \max\{\|rr_j^0\|, \|rr_j^1\|, \|rc_j\|\} = 1$. $\square$

We are now in possession of all the material needed to characterize the operators coming from the encoding of a deterministic pointer machine.

**Proposition 18.** Let $M \in \mathrm{DPM}(p)$ be an acyclic machine, and $M_s^* = \rightarrow \cdot +\mathrm{reject}_s$ its encoding as an operator, $\|M_s^*\|_1 \le 1$.

*Proof.* Since we are working with deterministic machines, the transition relation is functional: for each $\rho \in C_M$ there is at most one $t$, say $t_\rho$, such that $\rho \rightarrow t_\rho$. Thus:

$$M_s^* = \sum_{\rho \in C_M} \phi_{\rho, t_\rho} + \mathrm{reject}_s$$

Since $M_s^*$ is an element of $\mathfrak{M}_k(\mathfrak{M}_6(\mathfrak{R}))$, we will now compute $\|M_s^*\|_1^k$. We first show that this matrix has at most one non-null coefficient in each column. Then we will use the fact that these coefficients are of norm at most 1.

<footnote n="18">¹⁸When $j = p$, we consider that $\mathbf{back}_{j+1} = \mathbf{q}_0$ to ease the argument.</footnote>
To prove this we introduce the set $P = \{0i, 0o, 1i, 1o, \star i, \star o\}^p \times Q^\uparrow$ of extended pseudo-configurations. This set is a basis of the algebra of pseudo-states, and we write $M_s^\bullet = (a_{\rho, \rho'})_{\rho, \rho' \in P}$. This way, the 1-norm of $M_s^\bullet$ is

$$ \|M_s^\bullet\|_1 = \max_{\rho' \in P} \{ \sum_{\rho \in P} \|a_{\rho, \rho'}\| \} $$

Let $\rho = (a_1, \dots, a_p; q)$ be a (non-extended) pseudo-configuration. If $\rho$ is a pseudo-configuration of the machine (i.e. $q$ is an element of $Q$), then there is at most one pseudo-configuration $t_\rho$ such that $\rho \to t_\rho$. This atomic transition can be:

* Accept: in this case the operator $\phi_{\rho, t_\rho}$ is equal to 0 and the column is empty.

* Reject: in this case the column corresponding to $\rho$ contains only the operator $(q \to \mathbf{back}_1)$ that encodes the transition $\rho \to (a_1, \dots, a_p; \mathbf{back}_1)$, and the norm of this operator is equal to 1.

* Move forward a pointer, read a value and change state to $q'$: then the only extended pseudo-configurations introduced by the encoding is $\tilde{\rho} = (a_1, \dots, a_n; \mathbf{mov}_j^{q, q'})$. The column corresponding to $\rho$ contains the operator $ff+bf$, which is of norm 1 by Corollary 17. The column corresponding to $\tilde{\rho}$ contains only the operator $\mathrm{rec}$ whose norm is equal to 1 by Corollary 17.

* Move backwards: this case is similar to the previous one.

Now let us take a look at the operator $\mathrm{reject}_s$. The extended pseudo-configurations introduced for the encoding of the rejection are, for $j = 1, \dots, p$, $\tilde{\rho}_j^m = (a_1, \dots, a_n; \mathbf{mov-back}_j)$ and $\tilde{\rho}_j^b = (a_1, \dots, a_n; \mathbf{back}_j)$. The column corresponding to $\rho$ contains only the operator encoding the transition from $\rho$ to $\tilde{\rho}_1^b$, which is a norm 1 operator. Let us now fix $1 \le j \le p$. The column corresponding to the extended pseudo-state $\tilde{\rho}_j^b$ contains only the operator $\mathrm{rm}_j$, which is of norm 1. The column corresponding to $\tilde{\rho}_j^m$ contains the operator $\mathrm{rr}_j + \mathrm{rc}_j$, which is of norm 1 by Corollary 17.

We just showed that each column of the matrix contains at most one operator different from 0, and that this operator is always of norm 1. Hence, for any fixed extended pseudo-configuration $\rho$:

$$ \sum_{\rho \in P} a_{\rho, \rho'} \le 1 $$
As a consequence of the definition of the 1-norm, we have:

$$ \|M^*\|_1 = \max_{\rho' \in P} \left\{ \sum_{\rho \in P} \alpha_{\rho, \rho'} \right\} \le 1 $$

<figure><img src="image_3.png" /></figure>

The last proposition motivates the following definition:

**Definition 19.**

$$ P_{+,1} = \{ \phi \mid \phi \in P_+ \text{ and } \|\phi\|_1 \le 1 \} $$

Now, by looking carefully at the proof of Proposition 12, one can show that a similar result holds in the particular case of deterministic pointer machines. Indeed, if $M$ is deterministic, the machine $M'$ constructed from $M$ in the proof is also deterministic:

**Proposition 20.** For all $M \in DPM(p)$, there exists $M' \in DPM(p)$ such that $M'$ is acyclic and $\mathcal{L}(M) = \mathcal{L}(M')$.

As a consequence, one gets the following result:

**Proposition 21.**

$$ L \subseteq [P_{+,1}] $$

The question is then: is this inclusion strict or did we find a characterization of the class $L$? To answer this question, we need to look at the proof of the inclusion $[P_{\ge 0}] \subseteq \text{co-NL}$ and see what happens when we restrict to the operators in $P_{+,1}$.

**6. Operators and Logarithmic Space**

In this section, we will show that $[P_{+,1}] \subseteq L$, concluding the proof that $[P_{+,1}] = L$. To prove this inclusion, we need a technical lemma, which we proved in our earlier paper.

**Lemma 22 ([2, Lemma 31]).** Let $N_n$ be a binary representation of an integer $n$ in $\mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{N}_0$ and $\Phi \in \mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{S} \otimes \mathfrak{M}_k(\mathbb{C})$ be an observation in $P_{\ge 0}$. There exist an integer $f$, an injective morphism $\psi: \mathfrak{M}_f(\mathbb{C}) \to \mathfrak{R}$ and two matrices $M \in \mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{M}_f(\mathbb{C})$ and $\bar{\Phi} \in \mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{M}_f(\mathbb{C}) \otimes \mathfrak{M}_k(\mathbb{C})$ such that $\mathrm{Id} \otimes \psi(M) = N_n$ and $\mathrm{Id} \otimes \psi \otimes \mathrm{Id}_\mathfrak{C}(\bar{\Phi}) = \Phi$.
This lemma is of the utmost importance. Even though the hyperfinite factor $\mathfrak{R}$ is necessary to have a uniform representation of integers, it is an algebra of operators acting on an infinite-dimensional Hilbert space. It is therefore not obvious that one can check the nilpotency of such an operator with finite resources, and it is of course not possible in general.

However, the technical lemma above has as a direct consequence that checking the nilpotency of a product $\Phi(N_n \otimes 1)$ where $\Phi$ is an observation in $P_{\ge 0}$ is equivalent to checking the nilpotency of a product of matrices.

**Corollary 23.** Let $\Phi \in \mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{G} \otimes \mathfrak{M}_k(\mathbb{C})$ be an observation and $N_n \in \mathfrak{M}_6(\mathbb{C}) \otimes \mathfrak{N}_0$ a representation of the integer $n$. There exists matrices (i.e. operators acting on a finite-dimensional Hilbert space) $\bar{\Phi}$ and $M$ such that:

$\Phi(N_n \otimes 1_{\mathfrak{M}_k(\mathbb{C})})$ is nilpotent if and only if $\bar{\Phi}(M \otimes 1_{\mathfrak{M}_k(\mathbb{C})})$ is nilpotent

The matrices $\bar{\Phi}$ and $M \otimes 1_{\mathfrak{M}_k(\mathbb{C})}$ are acting on a Hilbert space of dimension $6 \times (\log_2(n)+1)^p p! \times k$, i.e. the integer $f$ in Lemma 22 is equal to $(\log_2(n)+1)^p p!$. Moreover the degree of nilpotency of the two products is equal. We can then show that there exists a Turing machine that decides the nilpotency of the product $\Phi N_n$ using only logarithmic space (i.e. in $\log_2(n)$).

**Proposition 24** ([2, Proposition 32]). If $\Phi \in P_{\ge 0}$ and $N_n$ is a representation of $n \in \mathbb{N}$, there is a co-NL machine that checks if $\bar{\Phi}(M \otimes 1_{\mathfrak{M}_k(\mathbb{C})})$ is nilpotent.

This proposition, together with Proposition 14 and the fact that $[P_+] \subseteq [P_{\ge 0}]$ gives us a proof of the following equality:

**Theorem 25** ([2, Theorem 33]).

$$ \mathbf{co-NL} = [P_+] = [P_{\ge 0}] $$

We recall how the proof of Proposition 24 works. The algebra we are working with is:

$$ \mathfrak{F} = \mathfrak{M}_6(\mathbb{C}) \otimes \underbrace{((\mathfrak{M}_{\log_2(n)+1}(\mathbb{C}) \otimes \cdots \otimes \mathfrak{M}_{\log_2(n)+1}(\mathbb{C})))}_{p \text{ copies}} \times \mathfrak{S}_p \otimes \mathfrak{M}_k(\mathbb{C}) $$

We let in the following $K = 6k(\log_2(n)+1)^p p!$ be the dimension of the Hilbert space the algebra $\mathfrak{F}$ is acting on.
We chose the basis of this algebra defined as the set of elements of the
form:

$$ (\pi, a_0, a_1, \dots, a_p; \sigma; e) $$

where $\pi$ is an element of the basis ($0o, 0i, 1o, 1i, s, e$) of $\mathfrak{M}_6(\mathbf{C})$, $a_i$ ($i \in \{1, \dots, p\}$) are the elements of the basis chosen to represent the integer $n$, $\sigma \in \mathfrak{S}_p$ and $e$ is an element of a basis of $\mathfrak{M}_k(\mathbf{C})$. When we apply $M \otimes 1_{\mathfrak{M}_k(\mathbf{C})}$ representing the integer to an element of this basis, we obtain one and only one vector of the basis $(\pi, a_0, a_1, \dots, a_p; \sigma; e)$. When we apply to this element the matrix $\bar{\Phi}$ we obtain a (positive) linear combination of $l \in \mathbf{N}$ elements of the basis:

$$ \bar{\Phi}(\pi, a_0, a_1, \dots, a_p; \sigma; e) = \sum_{i=0}^{l} \alpha_i(\rho, a_{\tau_i(0)}, \dots, a_{\tau_i(p)}; \tau_i \sigma; e_i) \quad (1) $$

So we obtain the following picture:

<figure><img src="image_4.png" /></figure>

To decide if the product $\bar{\Phi}(M \otimes 1_{\mathfrak{M}_k(\mathbf{C})})$ is nilpotent, it is then sufficient to check, for each possible value of $b_{i_0}^0$, that the branches of this tree are finite. Since they are either infinite or of length at most $K$, this can be checked by a non-deterministic (to deal with the branchings that appears in the figure above) Turing machine. This machine only uses logarithmic space since it needs only to store at each step the value of $b_{i_0}^0$, the current basis element $b_{i_{2j}^h}$, and the number of iterations $j$ of $\bar{\Phi}(M \otimes 1_{\mathfrak{M}_k(\mathbf{C})})$ that were computed to get from $b_{i_0}^0$ to $b_{i_{2j}^h}$.

Now, let us look at the case when $\Phi \in P_{+,1}$. In this particular case, Eq. (1) becomes:

$$ \bar{\Phi}(\pi, a_0, a_1, \dots, a_p; \sigma; e) = (\rho, a_{\tau_{b_0}(0)}, \dots, a_{\tau_{b_0}(p)}; \tau_{b_0} \sigma; e_{b_0}) \quad (2) $$
Let us write $\bar{\Phi}$ as a $\mathrm{Card}(Q) \times \mathrm{Card}(Q)$ matrix $(\bar{\Phi}_{q,q'})_{q,q' \in Q}$ (here $Q$ denotes a
basis of $\mathfrak{M}_k(\mathbf{C})$, which is a matrix algebra from the definition of observations).
We can deduce from $\|\bar{\Phi}\|_1 \le 1$ that for all $q \in Q$, $\sum_{q' \in Q} \|\bar{\Phi}_{q,q'}\| \le 1$.

As $\Phi$ is an element of $P_+$, the matrix $\bar{\Phi}$ satisfies the following equation:

$$
\bar{\Phi}(\pi, a_0, a_1, \dots, a_p; \sigma; e) = \sum_{i=0}^{l} (\rho, a_{\tau_i(0)}, \dots, a_{\tau_i(p)}; \tau_i \sigma; e_i) \quad (3)
$$

We deduce that $\|\bar{\Phi}_{e,e_i}\| \ge 1$ ($i=1,\dots,l$), and therefore $\sum_{e' \in Q} \|\bar{\Phi}_{e,e'}\| \ge l$. Since $\Phi \in P_{+,1}$, we know that $\|\bar{\Phi}_{q,q'}\| \le 1$ from which we deduce that $l \le 1$.

That is, the previous picture becomes:

$$
\begin{array}{r@{\;}c@{\;}l@{\quad}l@{\quad}l}
 & b_{i_0}^{i_0} & \raisebox{1.5ex}{M \otimes 1_{\mathfrak{M}_k(\mathbf{C})}} & \\
 & b_{i_1}^{i_0} & \raisebox{1.5ex}{\bar{\Phi}} & \\
 & b_{i_2}^{i_0} & \raisebox{1.5ex}{M \otimes 1_{\mathfrak{M}_k(\mathbf{C})}} & \\
 & b_{i_3}^{i_0} & \raisebox{1.5ex}{\bar{\Phi}} & \\
 & \multicolumn{2}{c}{\vdots} &
\end{array}
$$

Notice that the nilpotency degree of $\bar{\Phi}(M \otimes 1_{\mathfrak{M}_k(\mathbf{C})})$ is again at most $K$. One
can thus easily define a deterministic Turing machine that takes the basis
elements one after the other and compute the sequence $b_{i_0}^0, b_{i_1}^0, \dots$: if the
sequence stops before the $K$-th step, the machine starts with the next basis
element as $b_{i_0}^0$, and if the sequence did not stop at step $K$ it means the matrix
was not nilpotent. This Turing machine needs no more than logarithmic
space since it stores only the current starting basis element (i.e. $b_{i_0}^0$), the last
computed term of the sequence $b_{i_2}^0$ and the number of iterations computed
so far $j$. We thus obtain the following proposition.

**Proposition 26.** If $\Phi \in P_{+,1}$ and $N_n$ is a representation of $n \in \mathbb{N}$, there is a $\mathbf{L}$-machine that checks if $\bar{\Phi}M$ is nilpotent.

Putting together the results of this section and the last, we can finally
state the main theorem of this paper:
**Theorem 27.**

$$L = [P_{+,1}]$$

Together with Theorem 25, we thus obtained two sets of observations $P_+$ and $P_{+,1}$, satisfying $P_{+,1} \subsetneq P_+$ and such that $L = [P_{+,1}] \subseteq [P_+] = \textbf{co-NL}$.

**7. Conclusion**

This work both completes and extends the results obtained in our earlier paper [2] where we showed that the approach recently proposed by Girard [1] for studying complexity classes succeeds in characterizing the complexity class co-NL. On the one hand, we showed that the non-deterministic pointer machines, which were designed to mimic the computational behavior of operators, are really close to a well-known abstract machine, two-way multi-head finite automata. This result gives a much better insight on the pointer machines, and we hope this will help us in extending the model of pointer machines to study others complexity classes. It moreover strengthens the proof of the fact that the set of operators $P_+$ characterizes the class co-NL. On the other hand, we extended the result by finding a subset of $P_+$, defined through a condition on the norm, that corresponds to the encoding of deterministic pointer machines. We showed first that deterministic pointer machines were equivalent to the notion of deterministic two-way multi-head finite automata, hence that L is a subset of the language associated to $P_{+,1}$. We then showed that the converse inclusion holds, showing that the set of operators $P_{+,1}$ is indeed a characterization of the complexity class L.

The notion of acceptance used in this work (nilpotency) is closely related [22] to the notion of interaction in Girard's geometry of interaction in the hyperfinite factor (GoI5). This should leads to the possibility of defining types in GoI5 corresponding to complexity classes. For this reason, and the fact that the GoI5 construction allows more classical implicit computational complexity approaches such as defining constrained exponential connectives, the GoI5 framework seems a perfect candidate for a general mathematical framework for the study of complexity. The combined tools offered by geometry of interaction and the numerous tools and invariants of the theory of operators that could be used in this setting offer new perspectives for the obtention of separation results.

We also believe that the approach explored in this paper can be used to obtain characterizations of other complexity classes, and in particular the
classes **P** and **co-NP**. These characterizations may be obtained through the use of a more complex group action in the crossed product construction, or by defining a suitable superset of $P_+$. An approach for obtaining such a result would be to generalize the notion of pointer machines to get a characterization of **P** or **co-NP**. Since the pointer machines are closely related to the operators and the way the latter interact with the representation of integers, such a result would be a great step towards a characterization of these classes.

References

[1] J.-Y. Girard, Normativity in logic, in: P. Dybjer, S. Lindström, E. Palmgren, G. Sundholm (Eds.), Epistemology versus Ontology, Vol. 27 of Logic, Epistemology, and the Unity of Science, Springer, 2012, pp. 243–263.
doi:10.1007/978-94-007-4435-6_12.

[2] C. Aubert, T. Seiller, Characterizing co-nl by a group action, Mathematical Structures in Computer Science (FirstView) (2014) 1–33.
doi:10.1017/S0960129514000267.

[3] V. Danos, J.-B. Joinet, Linear logic & elementary time, Information and Computation 183 (1) (2003) 123–137.
doi:10.1016/S0890-5401(03)00010-5.

[4] U. Schöpp, Stratified bounded affine logic for logarithmic space, in: LICS, IEEE Computer Society, 2007, pp. 411–420.
doi:10.1109/LICS.2007.45.

[5] K. Terui, Proof nets and boolean circuits, in: LICS, IEEE Computer Society, 2004, pp. 182–191.
doi:10.1109/LICS.2004.1319612.

[6] J.-Y. Girard, Towards a geometry of interaction, in: J. W. Gray, A. Ščedrov (Eds.), Proceedings of the AMS-IMS-SIAM Joint Summer Research Conference held June 14-20, 1987, Vol. 92 of Categories in Computer Science and Logic, American Mathematical Society, 1989, pp. 69–108.
doi:10.1090/conm/092/1003197.

[7] J.-Y. Girard, Geometry of interaction V: logic in the hyperfinite factor, Theoretical Computer Science 412 (20) (2011) 1860–1883.
doi:10.1016/j.tcs.2010.12.016.
[8] J.-Y. Girard, Geometry of interaction 1: Interpretation of system F, Studies in Logic and the Foundations of Mathematics 127 (1989) 221–260. doi:10.1016/S0049-237X(08)70271-4.

[9] G. Gonthier, M. Abadi, J.-J. Lévy, The geometry of optimal lambda reduction, in: R. Sethi (Ed.), POPL, ACM Press, 1992, pp. 15–26. doi: 10.1145/143165.143172.

[10] J. Lamping, An algorithm for optimal lambda calculus reduction, in: F. E. Allen (Ed.), POPL, Association for Computing Machinery, ACM Press, 1990, pp. 16–30. doi:10.1145/96709.96711.

[11] P. Baillot, M. Pedicini, Elementary complexity and geometry of interaction, Fundamenta Informaticae 45 (1–2) (2001) 1–31.

[12] J. Hartmanis, On non-determinancy in simple computing devices, Acta Informatica 1 (4) (1972) 336–344. doi:10.1007/BF00289513.

[13] M. Holzer, M. Kutrib, A. Malcher, Multi-head finite automata: Characterizations, concepts and open problems, in: T. Neary, D. Woods, A. K. Seda, N. Murphy (Eds.), CSP, Vol. 1 of Electronic Proceedings in Theoretical Computer Science, 2008, pp. 93–107. doi:10.4204/EPTCS.1.9.

[14] T. Seiller, Interaction graphs: Multiplicatives, Annals of Pure and Applied Logic 163 (2012) 1808–1837. doi:10.1016/j.apal.2012.04.005.

[15] M. Takesaki, Theory of Operator Algebras 1, Vol. 124 of Encyclopedia of Mathematical Sciences, Springer, 2001.

[16] M. Takesaki, Theory of Operator Algebras 2, Vol. 125 of Encyclopedia of Mathematical Sciences, Springer, 2003.

[17] M. Takesaki, Theory of Operator Algebras 3, Vol. 127 of Encyclopedia of Mathematical Sciences, Springer, 2003.

[18] T. Seiller, Logique dans le facteur hyperfini : géometrie de l'interaction et complexité, Ph.D. thesis, Université de la Méditerranée (2012). URL http://tel.archives-ouvertes.fr/tel-00768403/

[19] A. L. Rosenberg, On multi-head finite automata, IBM Journal of Research and Development 10 (5) (1966) 388–394. doi:10.1147/rd.105.0388.
[20] N. Immerman, Nondeterministic space is closed under complementation, in: CoCo, IEEE Computer Society, 1988, pp. 112–115. doi:10.1109/SCT.1988.5270.

[21] P. J. Maher, Some operator inequalities concerning generalized inverses, Illinois Journal of Mathematics 34 (3) (1990) 503–514.

[22] T. Seiller, Interaction graphs: Additives, Arxiv preprint abs/1205.6557, accepted for publication in Annals of Pure and Applied Logic. arXiv: 1205.6557.

**A. Examples**

We develop below some examples that should enlighten the encoding of integers, the notion of pointer machine, and the encoding of the latter as operators. We begin by recalling the encoding of the input adopted, with two examples. Then, we briefly sketch a pointer machine that accepts palindromes and encode it as an observation. This allows us to make general remarks on the “tricks” one can adopt to lighten the encoding, which is in all generality unnecessarily heavy. Although this makes this example somehow strange to illustrate the paper as it is not encoded using the method employed for the proofs, we believe it gives a number of insights on how the observations interact with integers and how the computation actually takes place.

**A.1. Integers**

As explained in details in our earlier paper [2], integers are represented as matrices which are then embedded into the hyperfinite factor ℜ. The matrices are themselves adjacency matrices of a graph representing the links between two adjacent symbols in the binary representation of the integer. Let us work out two examples.

First, the integer $★010$ will be represented by the adjacency matrix of the following graph. Notice the integers on top of the circled symbols which represent a sort of “state” – or sorts of “locations” for symbols –, with a unique such state for each symbol in the list (counting the symbol $★$).

<figure><img src="image_5.png" /></figure>
This adjacency matrix is a 6 × 6 matrix with 4 × 4 matrices as coefficients, where the number 4 stands for the length of the list (these are the “states” mentioned above) and the number 6 stand for the 6 different types of vertices: 0i, 0o, 1i, 1o, e (i.e. ★i) and s (i.e. ★o). Here is the corresponding matrix:

$$ M_{★010} = \left\{ \begin{array}{c|c} \begin{array}{cccccc} 0 & & & & & \\ & 0 & & & & \\ & & l_{10} & & & \\ & & & s_0 & & \\ & & & & e_0^* & \\ & & & & & \end{array} & \begin{array}{c} 0 \\ 1 \\ \vdots \\ \vdots \\ \vdots \\ \vdots \end{array} \\ \begin{array}{cccccc} 0 & & & & & \\ & 0 & & & & \\ & & l_{01}^* & & & \\ & & & s_0 & & \\ & & & & e_0 & \\ & & & & & \end{array} & \begin{array}{c} 0 \\ 1 \\ \vdots \\ \vdots \\ \vdots \\ \vdots \end{array} \\ \begin{array}{cccccc} 0 & & & & & \\ & 0 & & & & \\ & & l_{01} & & & \\ & & & s_0 & & \\ & & & & e_0 & \\ & & & & & \end{array} & \begin{array}{c} 0 \\ 1 \\ \vdots \\ \vdots \\ \vdots \\ \vdots \end{array} \end{array} \right\} $$

where 0 stands for the zero 4 × 4 matrix, the adjoint (·)* corresponds to the conjugate-transpose, and the matrices $l_{10}$, $l_{01}$, $s_0$ and $e_0$ are defined as follows:

$$ l_{01} = \begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix}, \quad l_{10} = \begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \end{pmatrix} $$

$$ s_0 = \begin{pmatrix} 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix}, \quad e_0 = \begin{pmatrix} 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix} $$

The matrix $l_{01}$ express the edges of the above graph that are going from left to right, whose source is a 0 and whose target is a 1. This matrix is therefore located – in the 6 × 6 matrix – on the column corresponding to “0o” (for “0 out”) – because its source is a vertex “0o” – and on the row “1i” – because its target is a “1i” vertex. This matrix then contains a single non-zero element because the list contains exactly one such edge going left-to-right from a 0 to a 1, and shows how this edge connects the locations; in this case, the only such edge goes from the location named 1 to the location named 2, which explains why the non-zero element is located in the second column (locations are numbered starting from 0) and the third row.

The definition and placement of the matrix $l_{10}$ is explained in the same fashion, while the matrix $s_0$ (resp. $e_0$) represent those edges going from left
to right whose source is a "s" vertex (resp. a "0" vertex) and target is a "0" vertex (resp. a "e" vertex). Similar matrices named $l_{00}$ and $l_{11}$ could appear in the encoding of an integer if its binary writing contained two symbols 0 or two symbols 1 following each other; in our example, however, these matrices are empty.

Lastly, the adjoint matrices such as $l_{01}^*$ actually correspond to the right-to-left edge in the above graph.

As a second example, we consider the integer $\star 1100$. It is represented as a 6 × 6 matrix with 5 × 5 matrices as coefficients. The corresponding graph is as follows.

<figure><img src="image_6.png" /></figure>

The corresponding matrix is then:

$$M_{\star 1110} = \begin{pmatrix} 0 & 0 & 0 & l_{10} & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & e_0^* \\ 0 & 0 & 0 & l_{11} & s_1 & 0 \\ l_{10}^* & 0 & l_{11}^* & 0 & 0 & 0 \\ 0 & 0 & s_1^* & 0 & 0 & 0 \\ 0 & e_0 & 0 & 0 & 0 & 0 \end{pmatrix}$$

where the matrices $l_{10}$, $l_{11}$, $s_1$ and $e_0$ are defined as:

$$l_{10} = \begin{pmatrix} 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 \end{pmatrix}, \quad l_{11} = \begin{pmatrix} 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \end{pmatrix}$$

$$s_0 = \begin{pmatrix} 0 & 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \end{pmatrix}, \quad e_0 = \begin{pmatrix} 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \end{pmatrix}$$
## A.2. The Palindrome DPM

We will now define a deterministic pointer machine $P = \{Q, \to\}$ that decides the language of palindromes:

$$ \mathrm{Pal} = \{ \star a_0 a_1 \dots a_n \mid \forall i \in \{0, \dots, n\}, a_i = a_{n-i} \} $$

To decide Pal, the machine $P$ will make use of two pointers. It will start with both pointers on $\star$ and move one pointer from left to right over the input and move the second pointer from right to left – or from the end to the beginning. It will move the pointers alternatively and check if the $i$-th symbol is indeed equal to the $n-i$-th one. It will be defined with five states: an initial state **init**, and states **pass**<sub>1</sub>, **pass**<sub>2</sub>, **fail**<sub>1</sub> and **fail**<sub>2</sub>. The subscript will be used to remember which pointer will be moving next. We now define formally the machine $P$.

**Definition 28** (The Palindrome Pointer Machine). Let $P = \{Q, \to\}$ be the DPM(2) defined as follows: $Q = \{\mathbf{init}, \mathbf{pass}_1, \mathbf{pass}_2, \mathbf{fail}_1, \mathbf{fail}_2\}$, and the following transitions, where “.” (resp. “0/1”) is a notation standing for any value in $\{0, 1, \star\}$ (resp. in $\{0, 1\}$):

$$ (\star, \star, \mathbf{init}) \to (p_1+, \epsilon_2, \mathbf{pass}_2) \qquad (A.1) $$

$$ (\cdot, \cdot, \mathbf{pass}_2) \to (\epsilon_1, p_2-, \mathbf{pass}_1) \qquad (A.2) $$

$$ (0, 0, \mathbf{pass}_1) \to (p_1+, \epsilon_2, \mathbf{pass}_2) \qquad (A.3) $$

$$ (1, 1, \mathbf{pass}_1) \to (p_1+, \epsilon_2, \mathbf{pass}_2) \qquad (A.4) $$

$$ (0, 1, \mathbf{pass}_1) \to (p_1+, \epsilon_2, \mathbf{fail}_2) \qquad (A.5) $$

$$ (1, 0, \mathbf{pass}_1) \to (p_1+, \epsilon_2, \mathbf{fail}_2) \qquad (A.6) $$

$$ (0/1, 0/1, \mathbf{fail}_1) \to (p_1+, \epsilon_2, \mathbf{fail}_2) \qquad (A.7) $$

$$ (\cdot, \cdot, \mathbf{fail}_2) \to (\epsilon_1, p_2-, \mathbf{fail}_1) \qquad (A.8) $$

$$ (\star, \star, \mathbf{pass}_1) \to \mathbf{accept} \qquad (A.9) $$

$$ (\star, \star, \mathbf{fail}_1) \to \mathbf{reject} \qquad (A.10) $$

This transition relation is then completed into a total relation by considering that each configuration not appearing above leads to an acceptation. The machine $P$ is then a deterministic pointer machine.

To represent rejection when encoding this machine as an observation, we will have to create a loop by returning to the initial state (the “re-initialisation
trick"). The formal encoding defined in the paper works for any machine,
but it is a bit heavy. In the case of P, we use a simple trick to simplify the
representation: we consider the machine defined as above but:

* without the state **init** and with initial configuration $(\star, \star, \mathbf{fail}_1)$ – thus the transition A.1 is replaced by $(\star, \star, \mathbf{fail}_1) \rightarrow (p_1+, \epsilon_2, \mathbf{pass}_2)$;

• in which the transition A.10 is replaced by $(\star, \star, \mathbf{fail}_1) \to (p_1+, \mathbf{pass}_2)$.

This modified machine then either accepts – if the input is a palindrome – or loops by going through the initial state over and over – this loop replaces rejection. By encoding this modified machine as is, we obtain an observation that will accept the same language as P; this observation is however simpler than the one we would obtain from applying mindlessly the translation presented in Section 5.1.

### A.3. The Palindrome Observation

As explained above, we will actually encode the following transitions, and
no other – none of the transitions steps ending with acceptation are encoded
since acceptance corresponds to putting a stop to the computation.

$$ (\star, \star, \mathbf{fail}_1) \rightarrow (p_1+, \epsilon_2, \mathbf{pass}_2) \qquad (A.11) $$

$$ (\cdot, \cdot, \mathbf{pass}_2) \rightarrow (\epsilon_1, p_2-, \mathbf{pass}_1) \qquad (A.12) $$

$$ (\cdot, \cdot, \mathbf{fail}_2) \rightarrow (\epsilon_1, p_2-, \mathbf{fail}_1) \qquad (A.13) $$

$$ (0, 0, \mathbf{pass}_1) \rightarrow (p_1+, \epsilon_2, \mathbf{pass}_2) \qquad (A.14) $$

$$ (1, 1, \mathbf{pass}_1) \rightarrow (p_1+, \epsilon_2, \mathbf{pass}_2) \qquad (A.15) $$

$$ (0, 1, \mathbf{pass}_1) \rightarrow (p_1+, \epsilon_2, \mathbf{fail}_2) \qquad (A.16) $$

$$ (1, 0, \mathbf{pass}_1) \rightarrow (p_1+, \epsilon_2, \mathbf{fail}_2) \qquad (A.17) $$

$$ (0/1, 0/1, \mathbf{fail}_1) \rightarrow (p_1+, \epsilon_2, \mathbf{fail}_2) \qquad (A.18) $$

We will moreover use a number of small “hacks” that will decrease the
size of the resulting observation. Indeed, the encoding described in this paper
is general and therefore applies blindly to every pointer machines; it may
however be optimized in specific cases. The first optimization concerns the
set of additional states. The second concerns the way the representation
deals with pointers. The third “hack” will be used to decrease the size of the
matrices that represent the pointers “memory cells”.
Here is the first “hack”. The set of states we are starting from is $Q = \{pass_1, pass_2, fail_1, fail_2\}$. As it contains 4 elements, the set $Q^\uparrow$ should have $4+2(4^2+2) = 40$ elements. Of course, not all these elements are needed here. First, we won’t need the specific states introduced to deal with rejection since — as we already explained — rejection is already represented by the creation of a loop through the initial state. We are thus left with $4+2 \times 4^2 = 36$ states. It turns out that only $4+6=10$ states is enough in this case, as all we need are states to transition:

• from **pass**₁ to **pass**₂ (transitions A.14 and A.15); we write it as **pass**₁₋₂;

• from **pass**₁ to **fail**₂ (transitions A.16 and A.17); we write it as **error**;

• from **pass**₂ to **pass**₁ (transition A.12); we write it as **pass**₂₋₁;

• from **fail**₂ to **fail**₁ (transition A.13); we write it as **fail**₂₋₁;

• from **fail**₁ to **fail**₂ (transition A.18); we write it as **fail**₁₋₂;

• from **fail**₁ to **pass**₂ (transition A.11); we write it as **reinit**.

Let us now explain the second “hack”. We notice that this machine never uses any “$\epsilon$ transition” — i.e. the machine moves a pointer at each transition step — and always alternates the movements of the first and second pointer. The encoding presented in Section 5.1 makes use of a kind of “dummy pointer”, and then activates/deactivates pointers in order to move them. We will here get rid of this “dummy pointer” by considering that it represents the first pointer. As a consequence, the use of the operator $\tau_{0,1}$ will represent the simultaneous activation of a pointer and the deactivation of the other pointer. Moreover, it has an effect on the set of additional states needed to encode the operators: since we simultaneously activate a pointer and deactivate the other, we can get rid of the six additional states explained above and work with the 4 states of the original pointer machine. This will however complicate the understanding of the encoding in that an operator encoding a given transition will also encode the “recording” of the value read during the previous transition into memory cells. i.e. we will consider operators that are a mixing of the operators $bf_{j,q'}^c + ff_{j,q'}^c$, for the currently encoded transition and the operator $rec_{k,q}^{c'}$ encoding the recording of the value read during the previous transition. This complication is however worth considering since it will greatly reduce the size of the resulting matrices.
Lastly, let us recall the value last read by a pointer is stored as a state in
the encoding of machines. In the general encoding presented in this paper, we
store those as 6 × 6 matrices, which is coherent with the fact that the integer
answers belong to a six-elements set {0i, 0o, 1i, 1o, s, e}. However, all we will
need is the information about the symbol read, and we won't care whether
we read this symbol by moving left or moving right. This allows us to use
3 × 3 matrices as memory cells, decreasing once again the size of the resulting
observation.

Finally, each transition will be represented as an element of $M_6(C) \otimes
\mathfrak{G} \otimes M_3(C) \otimes M_3(C) \otimes M_4(C)$. The algebra $M_6(C)$ will allow the observation
to interact with the integer, i.e. ask what is the next or previous symbol
on the input tape. The two copies of $M_3(C)$ represent the “memory cells”
corresponding to the pointers, i.e. they will be used to record the last values
read by the pointers. The algebra $M_4(C)$ is used to deal with states. We
represent the 6×6, 3×3 matrices and 4×4 matrices using the respective bases
{0i, 0o, 1i, 1o, s, e}, {0, 1, ⋆} and {pass₁, pass₂, fail₁, fail₂} with basis elements
considered in this order exactly.

We first represent the transitions A.12 and A.13. We represent them
simultaneously to gain some space; this is possible because they are the same
transition but for the involved states. These transitions do not depend on
the values read by the pointers, but will write down the new values in the
two copies of $M_3(C)$ that represent the “memory cells”. It will therefore be
represented as a sum of the following nine operators:

$$
\begin{pmatrix}
0 & 0 & 0 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0
\end{pmatrix}
\otimes \tau_{0,1}
\begin{pmatrix}
1 & 1 & 1 \\
0 & 0 & 0 \\
0 & 0 & 0
\end{pmatrix}
\otimes
\begin{pmatrix}
1 & 0 & 0 \\
0 & 0 & 0 \\
0 & 0 & 0
\end{pmatrix}
\otimes
\begin{pmatrix}
0 & 1 & 0 & 0 \\
0 & 0 & 0 & 0 \\
0 & 0 & 0 & 1 \\
0 & 0 & 0 & 0
\end{pmatrix}
$$

$$
\begin{pmatrix}
0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0
\end{pmatrix}
\otimes \tau_{0,1} \otimes
\begin{pmatrix}
1 & 1 & 1 \\
0 & 0 & 0 \\
0 & 0 & 0
\end{pmatrix}
\otimes
\begin{pmatrix}
0 & 0 & 0 \\
0 & 0 & 0 \\
0 & 0 & 1
\end{pmatrix}
\otimes
\begin{pmatrix}
0 & 1 & 0 & 0 \\
0 & 0 & 0 & 0 \\
0 & 0 & 0 & 1 \\
0 & 0 & 0 & 0
\end{pmatrix}
$$
$$ \begin{pmatrix} 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} \otimes \tau_{0,1} \begin{pmatrix} 1 & 1 & 1 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{pmatrix} \begin{pmatrix} 1 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{pmatrix} \begin{pmatrix} 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \end{pmatrix} $$

$$ \begin{pmatrix} 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} \otimes \tau_{0,1} \begin{pmatrix} 0 & 0 & 0 \\ 1 & 1 & 1 \\ 0 & 0 & 0 \end{pmatrix} \begin{pmatrix} 1 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{pmatrix} \begin{pmatrix} 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \end{pmatrix} $$

$$ \begin{pmatrix} 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} \otimes \tau_{0,1} \begin{pmatrix} 0 & 0 & 0 \\ 1 & 1 & 1 \\ 0 & 0 & 0 \end{pmatrix} \begin{pmatrix} 0 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 1 \end{pmatrix} \begin{pmatrix} 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \end{pmatrix} $$

$$ \begin{pmatrix} 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} \otimes \tau_{0,1} \begin{pmatrix} 0 & 0 & 0 \\ 1 & 1 & 1 \\ 0 & 0 & 0 \end{pmatrix} \begin{pmatrix} 1 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{pmatrix} \begin{pmatrix} 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \end{pmatrix} $$

$$ \begin{pmatrix} 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} \otimes \tau_{0,1} \begin{pmatrix} 0 & 0 & 0 \\ 0 & 0 & 0 \\ 1 & 1 & 1 \end{pmatrix} \begin{pmatrix} 1 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{pmatrix} \begin{pmatrix} 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \end{pmatrix} $$

$$ \begin{pmatrix} 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} \otimes \tau_{0,1} \begin{pmatrix} 0 & 0 & 0 \\ 0 & 0 & 0 \\ 1 & 1 & 1 \end{pmatrix} \begin{pmatrix} 0 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 1 \end{pmatrix} \begin{pmatrix} 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \end{pmatrix} $$
$$ \begin{pmatrix} 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} \otimes \tau_{0,1} \otimes \begin{pmatrix} 0 & 0 & 0 \\ 0 & 0 & 0 \\ 1 & 1 & 1 \end{pmatrix} \otimes \begin{pmatrix} 1 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{pmatrix} \otimes \begin{pmatrix} 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \end{pmatrix} $$

Notice that these operators are all morally the same. One should consider them by groups of three. The first three correspond to the case when the value read by the first pointer during the last transition was a 0. In this case, the integer answered on the second column of the $M_6(C)$ matrix since this column corresponds to the basis element $0o$ (for "0 out") and the first pointer moves forward. Then the first operator corresponds to the case of the last value read by the second pointer is also a 0. Thus, to ask what is the next value read by this second pointer one needs to activate it – this is the role of $\tau_{0,1}$ – and the machine needs to output on the second row of the 6 × 6 matrix: this is because we want to know what symbol *preceded* the last 0 read by the second pointer (remember that the second pointer moves backwards). The second operator in this first group corresponds to the case when the last value read by the second pointer was 1. Then, the 6 × 6 matrix used moves from the basis element $0o$ – which corresponds to the previous answer given by the integer – to the basis element $1o$ – to ask what symbol preceded the last 1 read by the second pointer. The third operator corresponds to the case when the last symbol read by the second pointer was a $\star$. Finally, the two following groups of three matrices play the same role as this first group in the eventuality that the last value read by the first pointer was a 1 or a $\star$.

Notice also the right-hand matrix in each of these transitions. This matrix takes care of the states. This is why there are two non-zero coefficients in those matrices here: one represents the transition A.12 and the second represent the transition A.13.

Let us now deal with the representation of the transition A.14. It records the last value read by the second pointer, which should be 0, and asks the value following the last value read by the first pointer, which is 0 also. Thus, the first matrix goes from $0i$ (since the second pointer goes backwards) to $0i$ (since the first pointer moves forward). Then, the first $3 \times 3$ matrix ensures that the last value read by the first pointer was indeed 0, and the second $3 \times 3$ matrix records the new value read by the second pointer: whichever value was stored beforehand, it is now replaced by a 0. Lastly, the $4 \times 4$
matrix deals with the change of states. As before, we use the fact that this transition is almost similar to the transition A.18 when both values are equal to 0 and represent both by a single operator: this is shown by the fact that the right-hand matrix not only contains a transition from **pass**<sub>1</sub> to **pass**<sub>2</sub> (for transition A.14) but also a transition from **fail**<sub>1</sub> to **fail**<sub>2</sub>.

$$ \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} \otimes \tau_{0,1} \otimes \begin{pmatrix} 1 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{pmatrix} \otimes \begin{pmatrix} 1 & 1 & 1 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{pmatrix} \otimes \begin{pmatrix} 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \end{pmatrix} $$

The operator encoding the transitions A.15, A.16 and A.17 and the corresponding cases of transition A.18 are quite similar and are shown below in that order.

$$ \begin{pmatrix} 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} \otimes \tau_{0,1} \otimes \begin{pmatrix} 0 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 0 \end{pmatrix} \otimes \begin{pmatrix} 0 & 0 & 0 \\ 1 & 1 & 1 \\ 0 & 0 & 0 \end{pmatrix} \otimes \begin{pmatrix} 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \end{pmatrix} $$

$$ \begin{pmatrix} 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} \otimes \tau_{0,1} \otimes \begin{pmatrix} 1 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{pmatrix} \otimes \begin{pmatrix} 0 & 0 & 0 \\ 1 & 1 & 1 \\ 0 & 0 & 0 \end{pmatrix} \otimes \begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 1 & 0 \end{pmatrix} $$

$$ \begin{pmatrix} 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} \otimes \tau_{0,1} \otimes \begin{pmatrix} 0 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 0 \end{pmatrix} \otimes \begin{pmatrix} 1 & 1 & 1 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{pmatrix} \otimes \begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 1 & 0 \end{pmatrix} $$

Finally, we represent the transition A.11. It is represented as the following
operator:

$$ \begin{pmatrix} 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} \otimes \tau_{0,1} \otimes \begin{pmatrix} 0 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 1 \end{pmatrix} \otimes \begin{pmatrix} 0 & 0 & 0 \\ 0 & 0 & 0 \\ 1 & 1 & 1 \end{pmatrix} \otimes \begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix} $$