Clément Aubert
email: aubert@lipn.fr

Thomas Seiller
email: seiller@ihes.fr

Logarithmic Space and Permutations

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

come   L'archive ouverte pluridisciplinaire

Introduction

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 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 [START_REF] Danos | Linear logic & elementary time[END_REF]. It was also shown [START_REF] Schöpp | Stratified bounded affine logic for logarithmic space[END_REF] 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 [START_REF] Terui | Proof nets and boolean circuits[END_REF].

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) [START_REF] Girard | Towards a geometry of interaction[END_REF]. 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 [START_REF] Girard | Geometry of interaction V: logic in the hyperfinite factor[END_REF] 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 [START_REF] Girard | Geometry of interaction 1: Interpretation of system F[END_REF] allowed Abadi, Gonthier, and Lévy [START_REF] Gonthier | The geometry of optimal lambda reduction[END_REF] to explain the optimal reduction of λ-calculus defined by Lamping [START_REF] Lamping | An algorithm for optimal lambda calculus reduction[END_REF]. This first GoI construction was also used to obtain results in the field of implicit computational complexity [START_REF] Baillot | Elementary complexity and geometry of interaction[END_REF].

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 [START_REF] Aubert | Characterizing co-nl by a group action[END_REF] 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 [START_REF] Hartmanis | On non-determinancy in simple computing devices[END_REF][START_REF] Holzer | Multi-head finite automata: Characterizations, concepts and open problems[END_REF]. 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 L, showing that the set of all such operators characterizes L.

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 [START_REF] Seiller | Interaction graphs: Multiplicatives[END_REF], and a brief presentation of the crossed product construction in the authors' previous work [START_REF] Aubert | Characterizing co-nl by a group action[END_REF] 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 [START_REF] Takesaki | Theory of Operator Algebras[END_REF][START_REF] Takesaki | Theory of Operator Algebras[END_REF][START_REF] Takesaki | Theory of Operator Algebras[END_REF].

In a nutshell, the crossed product construction A α G of a von Neumann algebra A and a group action α : G → Aut(A) defines a von Neumann algebra containing A and unitaries that internalize the automorphisms α(g) for g ∈ G.

For this, one considers the Hilbert space 1 K = L 2 (G, H) where H is the Hilbert space A is acting on, and one defines two families of unitary operators 2 in L (K):

• the family {π(u) | u ∈ A unitary} which is a representation of A on K;

• the family {λ(g) | g ∈ G} which contains unitaries that internalize the automorphisms α(g).

Then the crossed product A α G is the von Neumann algebra generated by these two families. 1 The construction L 2 (G, 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 → H such that g∈G f (g) 2 < ∞. 2 Recall that in the algebra L (H) of bounded linear operators on the Hilbert space H (we denote by 〈•, •〉 its inner product), there exists an anti-linear involution (•) * such that for any ξ, η ∈ H and A ∈ L (H), 〈Aξ, η〉 = 〈ξ, A * η〉. 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.

As a by-product of Girard's work on geometry of interaction [START_REF] Girard | Geometry of interaction V: logic in the hyperfinite factor[END_REF], we know3 how to represent integers as operators in the type II 1 hyperfinite factor 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 4 . This representation arises from the interpretation of proofs of the type ∀X !(X X ) (!(X X ) !(X 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 R, but a family of representations. Luckily, any two representations of a given integer are unitarily equivalent (we denote by Proposition 10]). Let N, N ∈ M 6 (C) ⊗ R be two representations of a given integer. There exists a unitary u ∈ R such that:

M k (C) the algebra of k × k matrices over C): Proposition 1 ([2,
N = (1 ⊗ u) * N (1 ⊗ 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 R can be embedded in the infinite tensor product algebra T = n∈N R through the morphism ι 0 : x → x ⊗ 1 ⊗ 1 ⊗ . . . . We will denote by N 0 the image of R in T through ι 0 . Notice that this tensor product algebra is isomorphic to R. The idea of Girard is then to use the action of the group S of finite permutations of N onto T, defined by:

σ.(x 0 ⊗ x 1 ⊗ • • • ⊗ x k ⊗ . . . ) = x σ -1 (0) ⊗ x σ -1 (1) ⊗ • • • ⊗ x σ -1 (k) ⊗ . . .
This group action defines a sub-algebra G of the crossed product algebra K = ( n∈N R) S . This algebra G is the algebra generated by the family of unitaries λ(σ) for σ ∈ 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 11]). Let N, N ∈ M 6 (C) ⊗ N 0 be two representations of a given integer, and φ ∈ M 6 (C) ⊗ G. Then:

Proposition 2 ([2,
φN is nilpotent iff φN is nilpotent
To be a bit more precise, we will be interested in the elements of the algebras of operators M 6 (C) ⊗ G ⊗ M k (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: 5 . From this proposition, one can justify that the following definition makes sense:

if φ is an observation, φ(N n ⊗ 1 M k (C) ) is nilpotent if and only if φ(N n ⊗ 1 M k (C) ) is nilpotent
Definition 3. Let φ ∈ M 6 (C) ⊗ G ⊗ M k (C)
be an observation. We define the language accepted by φ by (N n denotes any representation of the integer n):

[φ] = {n ∈ N | φ(N n ⊗ 1) nilpotent}
By extension, if P is a set of observations, we denote by [P] the set {[φ] | φ ∈ P}.

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

• an algebra containing representations of integers: the hyperfinite factor R of type II 1 , embedded in K through the morphism π • ι 0 ;

• an algebra containing the representations of machines, or algorithms: the von Neumann sub-algebra G of K generated by the set of unitaries {λ(σ) | σ ∈ S };

• a notion of acceptance: if N is a representation of a integer and φ is a representation of a machine, we say that φ accepts N when φN is nilpotent.

Pointer Machines

We previously introduced [START_REF] Aubert | Characterizing co-nl by a group action[END_REF] 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 [START_REF] Rosenberg | On multi-head finite automata[END_REF], 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 i 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 i , i.e. "do not move". In the following definition, we let I k = {p k +, p k -, k } be the set of instructions for the k-th pointer and Σ = {0, 1, } be the alphabet. We will denote by #p i the address of the pointer. Definition 4. A non-deterministic pointer machine with p 1 pointers is a couple M = {Q, →} where Q is the set of states and →⊆ (Σ p ×Q)× p i=1 I i ×Q)∪ {accept, reject}) is the transition relation and it is total. We write NDPM(p) the set of non-deterministic pointer machines with p pointers.

A configuration of M ∈ NDPM(p) is as usual a "snapshot" of M at a given time, and we define a pseudo-configuration c of M ∈ NDPM(p) as a "partial snapshot": c ∈ Σ p × 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 →. The set of pseudo-configurations of a machine M is written C M and it is the domain of the transition relation. If → is functional, M is a deterministic pointer machine. We write DPM(p) the set of deterministic pointer machines with p pointers.

Let M ∈ NDPM(p), s ∈ C M and n ∈ N an input. We define M s (n) as M with n encoded as a string 6 on its circular input tape (as a 1 . . . a k for a 1 . . . a k the binary encoding of n and a k+1 = a 0 = ) starting in the pseudo-configuration s with #p i = 0 for all 1 i p (that is, the pointers are initialized with the address of the symbol ). 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. 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 1, a non-deterministic two-way khead finite automaton is a tuple M = {S, A, k, , , s 0 , F, σ} where:

• S is the finite set of states;

• A is the alphabet 7 ;

• k is the number of heads;

• and are the left and right endmarkers;

• s 0 ∈ S is the initial state;

• F ⊆ S is the set of accepting states;

• σ ⊆ (S × (A ∪ { , }) k ) × (S × {-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 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] 7 We take it to be always equal to {0, 1}, as any alphabet is equivalent to this one modulo a reasonable translation.

head on the current square and 1 means to move it one square to the right.

Moreover, whenever8 (s , (d 1 , . . . , d k )) ∈ σ(s, (a 1 , . . . , a k )), then a i = (1 i k) implies d i ∈ {0, 1}, and

a i = (1 i k) implies d i ∈ {-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 ∈ 2NDFA(k) and n ∈ N an input whose binary writing is w. We say that M accepts n if M starts in state s 0 , with w written on its input tape and all of its heads on , 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 σ is functional, M is said to be deterministic. We write 2DFA(k) the set of deterministic two-way k heads automata.

Simulation and first results

Multi-head finite automata were introduced in the early seventies [START_REF] Hartmanis | On non-determinancy in simple computing devices[END_REF] and provided many promising perspectives 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

∪ k 1 DPM(k), ∪ k 1 NDPM(k), ∪ k 1 2DFA(k) and ∪ k 1 2NDFA(k).
Theorem 6 ([12], p. 338). L = 2DFA and NL = 2NDFA.

We will denote in the following by L (X ) (resp. L (X )) the language accepted (resp. rejected) by X .

Proposition 7. For all M

∈ 2NDFA(k) (resp. M ∈ 2DFA(k)), there exists k and M ∈ 2NDFA(k ) (resp. M ∈ 2DFA(k )) such that M always halt and L (M) = L (M ).
Proof. Given an input n ∈ N, we know that the number of configurations of M is bounded by Card(S) × (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 ∈ S of M, S contains the set of states s × {→, ←} 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 -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 Card(S) × (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 L (M) = L (M ) and that M always halts. Notice that if M was deterministic, so is M .

Proposition 8. For all k 1, for all M ∈ 2NDFA(k) (resp. M ∈ 2DFA(k)) that always halts, there exists M ∈ NDPM(k) (resp. M ∈ 2DFA(k)) such that L (M) = L (M ).
Proof. There is only little work to do, since NDPMs are essentially "rearrangements" of NDFAs. Given M = {S, A, k, , , s 0 , F, σ}, we design M = {Q, →} ∈ NDPM(k) that rejects an input iff M accepts it. We set Q = S \ F. The transition relation → is obtained from σ as follows:

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

• The role of both endmarkers and is played by the symbol ;

• The instructions -1, 0 and 1 in position i ∈ N are translated by p i -, i and p i +.

There is one point that needs some care. If a transition t 1 in σ have for premise (q, (. . . , , . . .)) and another one t 2 have for premise (q, (. . . , , . . .)), we cannot translate in → both with (q, (. . . , , . . .)): that would introduce nondeterminism 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 σ, 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 → 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 → total, one just have to complement it by adding, from any pseudo-configuration not in the domain of definition of σ, 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 ⊆ DPM and co-2NDFA ⊆ 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 ⊆ DPM and co-NL ⊆ 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 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.

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 [START_REF] Aubert | Characterizing co-nl by a group action[END_REF], 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.

Encoding NDPMs

We will begin by a definition of two families of observations. Definition 10. Let φ ∈ M 6 (C) ⊗ G ⊗ M k (C) be an observation that we will write as a 6k × 6k matrix (a i, j ) 1 i, j 6k with coefficients in G. We say that φ is:

• A positive observation if for all 1 i, j 6k, we have a i, j = l m=0 α i, j m λ(g i, j m ) where l is an integer (possibly null), and α i, j m are positive real numbers.

• A boolean observation if for all 1 i, j 6k, we have a i, j = l m=0 λ(g i, j m ) where l is an integer (possibly null). Definition 11. We define the following sets:

P 0 = {φ | φ is a positive observation} P + = {φ | φ is a boolean observation}
We showed [START_REF] Aubert | Characterizing co-nl by a group action[END_REF] that any non-deterministic pointer machine M can be encoded as an operator in P + , implying that co-NL

⊆ [P + ].
The encoding of non-deterministic pointer machines was defined as follows: we encode each couple (c, t) ∈→ by an operator φ c,t , and then the encoding of the transition relation corresponds to the sum:

→ • = c∈C M t s.t. c→t φ c,t
To define the encoding correctly, we need to introduce a number of additional states. We will denote by Q ↑ the extended set of states obtained from Q. According to the notation introduced in Figs. 1 and2, this set has cardinality Card(Q) + p × (Card(Q) 2 + 2) and is (a subset of):

Q ↑ = Q ∪ p j=1 {mov-back j , back j } ∪ {mov q,q' j | q, q' ∈ Q}
The machine will then be encoded as an operator in M 6 (G) ⊗ P, where 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 ↑ . That is:

P = M 6 (C) ⊗ M 6 (C) ⊗ • • • ⊗ M 6 (C) p times ⊗M Card(Q ↑ ) (C)
Summing up, the encoding of a non-deterministic pointer machine with a set of states Q will be an observation in the algebra

M 6 (C) ⊗ G ⊗ M k (C) with k = 6 p × Card(Q ↑ ) = 6 p × (Card(Q) + p × (Card(Q) 2 + 2).
The following encoding differs from the one used in our earlier work [START_REF] Aubert | Characterizing co-nl by a group action[END_REF]. 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 , 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" 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 π * of M 6 (C) ( * ∈ {0i, 0o, 1i, 1o, e, s}) as the projections on the subspace induced by the basis element 12 . We will sometimes denote e (resp. s) by i (resp. o), and we also define the projections π in = π 0i + π 1i + π e and π out = π 0o + π 1o + π s . Those projections correspond to the following matrices.

π in =         
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

         π out =         
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

        
We will moreover use matrices named (in → out) and (out → 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 (in → out). The matrix (out → in) plays the same role when moving in the opposite direction. Moreover, changes of directions are dealt with the projections π in and π out .

(in → out) =         
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

         (out → in) =         
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

        
For the sake of simplicity, we also define the following operators in P: if c = (a 1 , . . . , a p , q) and c = (a 1 , . . . , a p , q ), we define the partial isometry:

(c → c ) = (a 1 → a 1 ) ⊗ • • • ⊗ (a p → a p ) ⊗ (q → q )
where (p → p ) (for p, p ∈ Q ↑ or p, p ∈ {0i, 0o, 1i, 1o, e, s}) is defined as:

p p         0 . . .
       
For S a set of states, we will use the notation (S → a i ) (denoted (→ a i ) when S contains all possible states) for the sum of partial isometries s∈S (s → a i ) that encodes a transition from any state in S to a i . The notation (S →) will denote the projection on the subspace generated by S.

A transition that impacts only on the values stored in the subset of pointers 13 p i 1 , . . . , p i l and the state q will be denoted by ((a

i 1 → a i 1 ) i 1 ; . . . ; (a i l → a i l ) i l ; q → q')
This operator is defined as

u 1 ⊗ u 2 ⊗ • • • ⊗ u p ⊗ (q → q')
where u i = (a i j → a i j ) if ∃ j, i = i j , u i = 1 elsewhere.

Finally, we will denote by τ i, j the operator in G induced by the transposition exchanging the integers i and j. Now, we can explain how the different transitions are encoded. Figures 1 and2 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 pseudoconfiguration c = (a 1 , . . . , 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, bf c j,q' = π out ⊗ τ 0, j ⊗ (({0o, 1o, o} →) j ; q → mov q,q' j ) ff c j,q' = (in → out) ⊗ τ 0, j ⊗ (({0i, 1i, i} →) j ; q → mov q,q' j ) fb c j,q' = π in ⊗ τ 0, j ⊗ (({0i, 1i, i} →) j ; q → mov q,q' j ) bb c j,q' = (out → in) ⊗ τ 0, j ⊗ (({0o, 1o, o} →) j ; q → mov q,q'

j ) rec c j,q' = •∈{0,1, } π •i ⊗ τ 0, j ⊗ ((→ •i) j ; mov q,q' j → q') Figure 1:
The operators in M 6 (C) ⊗ G ⊗ P encoding forward and backward move instructions rm j = 1 ⊗ τ 0, j ⊗ (back j → mov-back j ) rr 0 j = π 0o ⊗ τ 0, j ⊗ ((→ 0o) j ; mov-back j → back j ) rr 1 j = π 1o ⊗ τ 0, j ⊗ ((→ 1o) j ; mov-back j → back j ) The operator rc j is parametric on an initial pseudo-configuration s = (a 1 , . . . , a p ; q 0 ).

rc j = π o ⊗ τ 0, j ⊗ ((→ a j ) j ; mov-back j → back j+1 ) (1 j < p) π o ⊗ τ 0,p ⊗ ((→ a p ) p ; mov-back p → q 0 ) ( j = p)
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 c j,q' will be applied (notice the projection π in on the j-th memory slot), and in the second the bf c j,q' operator will be applied. Both these operators somehow activate the j-th pointer by using the transposition τ 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 c j,q' 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 forward c j,q' = bf c j,q' +ff c j,q' +rec c j,q' which is an element of the algebra

M 6 (C) ⊗ G ⊗ P.
In case of a "move backwards pointer j" instruction, the operator encoding the transition is backward c j,q' = fb c j,q' + bb c j,q' + rec c j,q' , one again an element of the algebra M 6 (C) ⊗ G ⊗ P.

In the following, we will forget about the subscripts and superscripts of these operators 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 15 , so every transition (a 1 , . . . , a n ; q) → accept will be encoded by 0.

Reject. The transitions of the form (a 1 , . . . , a n ; q) → reject are encoded by the operator that represents the "transition" (a 1 , . . . , a n ; q) → (a 1 , . . . , a n ; back 1 ).

This defines the operator → • encoding the transition relation →. 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 φ 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, . . . , p. We can then define reject s = p j=1 rm j + rr 0 j + rr 1 j + rc j . This operator actually encodes a reinitialization 16 of the machine that starts when the computation reaches the state back 1 : 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 1 , . . . , a p ; q 0 ). 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 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 ∈ NDPM(p) there exists M ∈ NDPM(p ) such that M is acyclic and L (M) = L (M ).
In the particular case of acyclic machines, one can show that the encoding is sound: Proposition 13 ([2, Lemma 29]). Let M ∈ NDPM(p) be acyclic, c ∈ C M and M • s =→ • +reject s . For all n ∈ N and every binary representation N n ∈ vnM 6 (C) ⊗ N 0 of the integer n:

M s (n) accepts ⇔ M • s (N n ⊗ 1) is nilpotent.
These two results can then be combined with the results of the previous section to get the following proposition: 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 = , . . . , ; q 0 ). We choose to dwell on the parametricity of the encoding to highlight the particular mechanism of rejection, and its flexibility. 17 For instance, let us consider a machine M that contains a state loop and, for a chosen pseudo-configuration c, the transition (c, loop) → ( 1 , . . . , p , 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.

Proposition 14.

co-NL ⊆ [P + ]

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

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 (R))); this defines in particular the 1-norm of observations since

M 6 (C) ⊗ G ⊗ P is a subalgebra of M 6 (C) ⊗ R ⊗ M k (C) (for k = 6 p × Card(Q ↑ )), which is isomorphic to M k (M 6 (R)).

Definition 15. We define the family of norms

• k 1 on M k (M 6 (R)) by: (a i, j ) 1 i, j k k 1 = max 1 j k k i=1 a i, j
where a i, j is the usual norm (the C * -algebra norm) on M 6 (R).

We will simply write • 1 when the superscript is clear from the context.

Remark. For each k, the map • k 1 : M k (M 6 (R)) → R 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 (R)) and M k (C) ⊗ M 6 (R) -as the tensor product of the 1-norm on M k (C) and the usual norm on M 6 (R). The 1-norm on M k (C) is formally defined from the usual 1-norm on vectors as

A 1 = sup 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 i, j k , to the expression max 1 j k k i=1 |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 [START_REF] Maher | Some operator inequalities concerning generalized inverses[END_REF]. 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 Ran(B * ) ⊆ ker(A) = (Ran(A * )) ⊥ so Ran(B * ) ⊥ Ran(A * ). Similarly, B * A = 0 implies that Ran(A) ⊆ ker(B * ) = (Ran(B)) ⊥ so Ran(A) ⊥ Ran(B). Thus, if AB * = B * A = 0, we have Ran(A) ⊥ Ran(B) and Ran(A * ) ⊥ Ran(B * ) and one can then apply the theorem of Maher.

Corollary 17. The operators ff+bf, rec, bb+fb, and rr 0 j +rr 1 j +rc j ( j fixed) are of norm 1.

Proof. It is clear that bf×ff * = 0 since π out π in = 0. Similarly, ff * ×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 π ai π bi = 0 for a = b, we deduce rec = 1 by Proposition 16.

We are now proving the result for rr 0 j + rr 1 j + rc j , so we fix 1 j p. First, notice that rc j × (rr 0 j ) * = 0 as a consequence of π mov-back j × π back j = 0. Conversely, (rr 0 j ) * × rc j = 0 as a consequence of18 π back j+1 × π mov-back j = 0. A similar argument shows that rc j × (rr 1 j ) * = 0 and (rr 1 j ) * × rc j = 0. Moreover, we know that (rr 0 j ) * × rr 1 j = 0 and rr 1 j × (rr 0 j ) * = 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 0 j + rr 1 j + rc j = max{ rr 0 j , rr 1 j , rc j } = 1.

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 ∈ DPM(p) be an acyclic machine, and M • s =→ • +reject s its encoding as an operator, M • s 1 1.

Proof. Since we are working with deterministic machines, the transition relation is functional: for each ρ ∈ C M there is at most one t, say t ρ , such that ρ → t ρ . Thus:

M • s = ρ∈C M φ ρ,t ρ + reject s Since M • s is an element of M k (M 6 (R)), we will now compute M • s k 1 .
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.

To prove this we introduce the set P = {0i, 0o, 1i, 1o, i, o} p × Q ↑ of extended pseudo-configurations. This set is a basis of the algebra of pseudostates, and we write M • s = (a ρ,ρ ) ρ,ρ ∈P . This way, the 1-norm of M • s is

M • s 1 = max ρ ∈P { ρ∈P a ρ,ρ }
Let ρ = (a 1 , . . . , a p ; q) be a (non-extended) pseudo-configuration. If ρ is a pseudo-configuration of the machine (i.e. q is an element of Q), then there is at most one pseudo-configuration t ρ such that ρ → t ρ . This atomic transition can be:

• Accept: in this case the operator φ ρ,t ρ is equal to 0 and the column is empty.

• Reject: in this case the column corresponding to ρ contains only the operator (q → back 1 ) that encodes the transition ρ → (a 1 , . . . , a p ; 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 ρ = (a 1 , . . . , a n ; mov q,q' j ). The column corresponding to ρ contains the operator ff + bf, which is of norm 1 by Corollary 17. The column corresponding to ρ contains only the operator 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 reject s . The extended pseudo-configurations introduced for the encoding of the rejection are, for j = 1, . . . , p, ρm j = (a 1 , . . . , a n ; mov-back j ) and ρb j = (a 1 , . . . , a n ; back j ). The column corresponding to ρ contains only the operator encoding the transition from ρ to ρb 1 , which is a norm 1 operator. Let us now fix 1 j p. The column corresponding to the extended pseudo-state ρb j contains only the operator rm j , which is of norm 1. The column corresponding to ρm j contains the operator rr j + 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 ρ:

ρ∈P a ρ,ρ 1
As a consequence of the definition of the 1-norm, we have:

M • 1 = max ρ ∈P { ρ∈P a ρ,ρ } 1
The last proposition motivates the following definition:

Definition 19. P +,1 = {φ | φ ∈ P + and φ 1 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 ∈ DPM(p), there exists M ∈ DPM(p) such that M is acyclic and

L (M) = L (M ).
As a consequence, one gets the following result:

Proposition 21. L ⊆ [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 0 ] ⊆ co-NL and see what happens when we restrict to the operators in P +,1 .

Operators and Logarithmic Space

In this section, we will show that [P +,1 ] ⊆ 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 M 6 (C) ⊗ N 0 and Φ ∈ M 6 (C) ⊗ S ⊗ M k (C) be an observation in P 0 . There exist an integer f , an injective morphism ψ :

M f (C) → R and two matrices M ∈ M 6 (C)⊗M f (C) and Φ ∈ M 6 (C)⊗M f (C)⊗M k (C) such that Id⊗ψ(M) = N n and Id ⊗ ψ ⊗ Id E ( Φ) = Φ.
This lemma is of the utmost importance. Even though the hyperfinite factor 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 Φ(N n ⊗ 1) where Φ is an observation in P 0 is equivalent to checking the nilpotency of a product of matrices.

Corollary 23. Let Φ ∈ M 6 (C)⊗G⊗M k (C) be an observation and N n ∈ M 6 (C)⊗ N 0 a representation of the integer n. There exists matrices (i.e. operators acting on a finite-dimensional Hilbert space) Φ and M such that:

Φ(N n ⊗ 1 M k (C) ) is nilpotent if and only if Φ(M ⊗ 1 M k (C) ) is nilpotent
The matrices Φ and M ⊗ 1 M k (C) are acting on a Hilbert space of dimension 6×(log 2 (n)+1) p p!×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 ΦN n using only logarithmic space (i.e. in log 2 (n)).

Proposition 24 ([2, Proposition 32]). If Φ ∈ P 0 and N n is a representation of n ∈ N, there is a co-NL machine that checks if

Φ(M ⊗ 1 M k (C) ) is nilpotent.
This proposition, together with Proposition 14 and the fact that [P + ] ⊆ [P 0 ] gives us a proof of the following equality:

Theorem 25 ([2, Theorem 33]).

co-NL

= [P + ] = [P 0 ]
We recall how the proof of Proposition 24 works. The algebra we are working with is:

F = M 6 (C) ⊗ ((M log 2 (n)+1 (C) ⊗ • • • ⊗ M log 2 (n)+1 (C) p copies ) S p ) ⊗ M k (C)
We let in the following K = 6k(log 2 (n) + 1) p p! be the dimension of the Hilbert space the algebra F is acting on.

We chose the basis of this algebra defined as the set of elements of the form:

(π, a 0 , a 1 , . . . , a p ; σ; e)

where π is an element of the basis (0o, 0i, 1o, 1i, s, e) of M 6 (C), a i (i ∈ {1, . . . , p}) are the elements of the basis chosen to represent the integer n, σ ∈ S p and e is an element of a basis of M k (C). When we apply

M ⊗ 1 M k (C) representing
the integer to an element of this basis, we obtain one and only one vector of the basis (π, a 0 , a 1 , . . . , a p ; σ; e). When we apply to this element the matrix Φ we obtain a (positive) linear combination of l ∈ N elements of the basis:

Φ(π, a 0 , a 1 , . . . , a p ; σ; e) = l i=0 α i (ρ, a τ i (0) , . . . , a τ i (p) ; τ i σ; e i ) (1)
So we obtain the following picture:

b i 0 0 b i 0 1 b i 0 2 b i l 2 2 . . . Φ b i 0 3 b i l 2 3 . . . Φ . . . Φ M ⊗ 1 M k (C) M ⊗ 1 M k (C) M ⊗ 1 M k (C) To decide if the product Φ(M ⊗ 1 M k (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 h 2 j
, and the number of iterations j of Φ(M ⊗ 1 M k (C) ) that were computed to

get from b i 0 0 to b i h 2 j
. Now, let us look at the case when Φ ∈ P +,1 . In this particular case, Eq. (1) becomes: Φ(π, a 0 , a 1 , . . . , a p ; σ; e) = (ρ, a τ b 0 (0) , . . . , a τ b 0 (p) ;

τ b 0 σ; e b 0 ) (2)
Let us write Φ as a Card(Q) × Card(Q) matrix ( Φq,q ) q,q ∈Q (here Q denotes a basis of M k (C), which is a matrix algebra from the definition of observations).

We can deduce from Φ 1 1 that for all q ∈ Q, q ∈Q Φq,q 1. As Φ is an element of P + , the matrix Φ satisfies the following equation:

Φ(π, a 0 , a 1 , . . . , a p ; σ; e) = l i=0 (ρ, a τ i (0) , . . . , a τ i (p) ; τ i σ; e i ) (3)
We deduce that Φe,e i 1 (i = 1, . . . , l), and therefore e ∈Q Φe,e l. Since Φ ∈ P +,1 , we know that Φq,q 1 from which we deduce that l 1. That is, the previous picture becomes:

b i 0 0 b i 0 1 b i 0 2 b i 0 3 . . . M ⊗ 1 k (C) M ⊗ 1 M k (C) Φ Φ Notice that the nilpotency degree of Φ(M ⊗1 M k (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 0 1 , . . . : 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 0 2 j and the number of iterations computed so far j. We thus obtain the following proposition.

Proposition 26. If Φ ∈ P +,1 and N n is a representation of n ∈ N, there is a L machine that checks if Φ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 P + and such that L = [P +,1 ] ⊆ [P + ] = co-NL.

Conclusion

This work both completes and extends the results obtained in our earlier paper [START_REF] Aubert | Characterizing co-nl by a group action[END_REF] where we showed that the approach recently proposed by Girard [START_REF] Girard | Normativity in logic[END_REF] 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 [START_REF] Seiller | Annals of Pure and Applied Logic[END_REF] 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.

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 [START_REF] Aubert | Characterizing co-nl by a group action[END_REF], integers are represented as matrices which are then embedded into the hyperfinite factor R. 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 ).

• s • e 0 0 • o • i 1 1 • o • i 2 0 • o • i 3 29
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: 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.

M 010 = 0 1 *                 0
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 rightto-left edge in the above graph.

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

• s • e 0 1 • o • i 1 1 • o • i 2 1 • o • i 3 0 • o • i 4
The corresponding matrix is then: where the matrices l 10 , l 11 , s 1 and e 0 are defined as:

M 1110 =          0
l 10 =       
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

       l 11 =       
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

       s 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

       e 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

      
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 ( , , fail 1 ) -thus the transition A.1 is replaced by ( , , fail 1 ) → (p 1 +, 2 , pass 2 );

• in which the transition A.10 is replaced by ( , , fail 1 ) → (p 1 +, pass 2 ).

This modified machine then either accepts -if the input is a palindromeor 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.

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 ↑ 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 × 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 1 to pass 2 (transitions A.14 and A.15); we write it as pass 1→2 ;

• from pass 1 to fail 2 (transitions A.16 and A.17); we write it as error;

• from pass 2 to pass 1 (transition A.12); we write it as pass 2→1 ;

• from fail 2 to fail 1 (transition A.13); we write it as fail 2→1 ;

• from fail 1 to fail 2 (transition A.18); we write it as fail 1→2 ;

• from fail 1 to pass 2 (transition A.11); we write it as reinit.

Let us now explain the second "hack". We notice that this machine never uses any " 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 τ 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 c j,q' + ff c j,q' for the currently encoded transition and the operator rec c k,q 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) ⊗ G ⊗ M 3 (C) ⊗ M 3 (C) ⊗ 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 1 , pass 2 , fail 1 , fail 2 } 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:

        
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

         ⊗ τ 0,1 ⊗   1 1 1 0 0 0 0 0 0   ⊗   1 0 0 0 0 0 0 0 0   ⊗      0 1 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 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

         ⊗ τ 0,1 ⊗   1 1 1 0 0 0 0 0 0   ⊗   0 0 0 0 0 0 0 0 1   ⊗      0 1 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 0 0 0 1 0 0 0 0 0 0 0 0 0 0

         ⊗ τ 0,1 ⊗   1 1 1 0 0 0 0 0 0   ⊗   1 0 0 0 0 0 0 0 0   ⊗      0 1 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 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

         ⊗ τ 0,1 ⊗   0 0 0 1 1 1 0 0 0   ⊗   1 0 0 0 0 0 0 0 0   ⊗      0 1 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 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0

         ⊗ τ 0,1 ⊗   0 0 0 1 1 1 0 0 0   ⊗   0 0 0 0 0 0 0 0 1   ⊗      0 1 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 0 0 0 0 0 1 0 0 0 0 0 0 0 0 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 τ 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 . 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 .

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. [START_REF] Holzer | Multi-head finite automata: Characterizations, concepts and open problems[END_REF].

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 × 3 matrix ensures that the last value read by the first pointer was indeed 0, and the second 3 × 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 × 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 1 to pass 2 (for transition A.14) but also a transition from fail 1 to fail 2 .

        
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

         ⊗ τ 0,1 ⊗   1 0 0 0 0 0 0 0 0   ⊗   1 1 1 0 0 0 0 0 0   ⊗      0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0     
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.

Figure 2 :

 2 Figure 2: The operators in M 6 (C) ⊗ G ⊗ P encoding rejection.

  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:

0 0 l 10

 10

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

  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 ∈ 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 ∈ C M such that M s (n) accepts if and only if n ∈ S.

A detailed explanation of this representation can be found in Appendix A, in the authors' previous work[START_REF] Aubert | Characterizing co-nl by a group action[END_REF] or in the second author's PhD thesis[START_REF] Seiller | Logique dans le facteur hyperfini : géometrie de l'interaction et complexité[END_REF].

Something that will be proven useful in Section

[START_REF] Terui | Proof nets and boolean circuits[END_REF], for it will help us to determine in which direction the integer is read.

We will in the following simply write 1 for the identity element of M k (C).

Of course, one may see σ as a partial function from S × (A ∪ { , }) k to P (S × {-1, 0, 1} k ), and that justifies this notation that we will use from now on.

An overview of the main results and open problems of the theory was recently published[START_REF] Holzer | Multi-head finite automata: Characterizations, concepts and open problems[END_REF].

That can be simply done by halting the computation in a state not belonging to F.

Using the fact that NL = co-NL[START_REF] Immerman | Nondeterministic space is closed under complementation[END_REF], we could show that NL ⊂ 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".

To be coherent with the notations of our earlier paper, we will always denote by {0i, 0o, 1i, 1o, e, s} the basis of M 6 (C) we are working with.

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.

Remark by the way that all those indices were redundant, for the pseudo-configuration c entails a choice of j and q .

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".

When j = p, we consider that back j+1 = q 0 to ease the argument.

$ Work partially supported by the ANR projects ANR-2010-BLAN-021301 LOGOI and ANR-08-BLAN-0211-01 COMPLICE.

A.2. The Palindrome DPM

We will now define a deterministic pointer machine P = {Q, →} that decides the language of palindromes: Pal = { a 0 a 1 . . . a n | ∀i ∈ {0, . . . , 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 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 ni-th one. It will be defined with five states: an initial state init, and states pass 1 , pass 2 , fail 1 and fail 2 . 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, →} be the DPM(2) defined as follows: Q = {init, pass 1 , pass 2 , fail 1 , fail 2 }, and the following transitions, where "•" (resp. "0/1") is a notation standing for any value in {0, 1, } (resp. in {0, 1}):

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

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. 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".