Pointers in Recursion: Exploring the Tropics

Paulin Jacob\'e de Naurois (CNRS/universit\'e paris13)

arXiv:1908.04922·cs.CC·August 15, 2019·DICE-FOPARA@ETAPS

Pointers in Recursion: Exploring the Tropics

Paulin Jacob\'e de Naurois (CNRS/universit\'e paris13)

PDF

TL;DR

This paper introduces pointer recursion and tropical tiering, a new discipline that characterizes various complexity classes including logspace, polylogtime, P, and NC, by translating recursive functions into a pointer-based framework.

Contribution

It develops a novel pointer recursion framework and tropical tiering discipline, unifying and capturing multiple complexity classes within a single algebraic setting.

Findings

01

Pointer recursive functions are equivalent to classical partial/primitive recursive functions.

02

Tropical tiering captures classes like logspace, polylogtime, P, and NC.

03

Pointer recursion with tropical tiering characterizes key complexity classes.

Abstract

We translate the usual class of partial/primitive recursive functions to a pointer recursion framework, accessing actual input values via a pointer reading unit-cost function. These pointer recursive functions classes are proven equivalent to the usual partial/primitive recursive functions. Complexity-wise, this framework captures in a streamlined way most of the relevant sub-polynomial classes. Pointer recursion with the safe/normal tiering discipline of Bellantoni and Cook corresponds to polylogtime computation. We introduce a new, non-size increasing tiering discipline, called tropical tiering. Tropical tiering and pointer recursion, used with some of the most common recursion schemes, capture the classes logspace, logspace/polylogtime, ptime, and NC. Finally, in a fashion reminiscent of the safe recursive functions, tropical tiering is expressed directly in the syntax of the…

Equations60

\begin{array}[]{rclrclrcl}{\tt hd}(a.\overline{x})&=&a&\;\;\;{\tt tl}(a.\overline{x})&=&\overline{x}&\;\;\;{\tt s}_{0}(\overline{x})&=&0.\overline{x}\\ {\tt hd}(\varepsilon)&=&\varepsilon&{\tt tl}(\varepsilon)&=&\varepsilon&{\tt s}_{1}(\overline{x})&=&1.\overline{x}\\ \end{array}

\begin{array}[]{rclrclrcl}{\tt hd}(a.\overline{x})&=&a&\;\;\;{\tt tl}(a.\overline{x})&=&\overline{x}&\;\;\;{\tt s}_{0}(\overline{x})&=&0.\overline{x}\\ {\tt hd}(\varepsilon)&=&\varepsilon&{\tt tl}(\varepsilon)&=&\varepsilon&{\tt s}_{1}(\overline{x})&=&1.\overline{x}\\ \end{array}

Pr_{i}^{n} (\overline{x_{1}}, \dots, \overline{x_{n}}) = \overline{x_{i}}

Pr_{i}^{n} (\overline{x_{1}}, \dots, \overline{x_{n}}) = \overline{x_{i}}

f (x) = g (h_{1} (x), \dots, h_{n} (x)) .

f (x) = g (h_{1} (x), \dots, h_{n} (x)) .

f (ε, y)

f (ε, y)

f (s_{a} (\overline{x}), y)

\mu\overline{x}(h(\overline{x},{\bf y}))=\left\{\begin{array}[]{lr}\perp&\mbox{ if }\forall t\in{\mathbb{N}},{\tt hd}(h(s_{0}^{(t)}(\varepsilon),{\bf y}))\neq{\tt s}_{1}(\varepsilon)\\ s_{0}^{(k)}(\varepsilon)&\mbox{where }k=\min\{t\;:{\tt hd}(h(s_{0}^{(t)}(\varepsilon),{\bf y}))={\tt s}_{1}(\varepsilon)\}\;\;\mbox{ otherwise.}\end{array}\right.

\mu\overline{x}(h(\overline{x},{\bf y}))=\left\{\begin{array}[]{lr}\perp&\mbox{ if }\forall t\in{\mathbb{N}},{\tt hd}(h(s_{0}^{(t)}(\varepsilon),{\bf y}))\neq{\tt s}_{1}(\varepsilon)\\ s_{0}^{(k)}(\varepsilon)&\mbox{where }k=\min\{t\;:{\tt hd}(h(s_{0}^{(t)}(\varepsilon),{\bf y}))={\tt s}_{1}(\varepsilon)\}\;\;\mbox{ otherwise.}\end{array}\right.

f (x; y) = g (h_{1} (x;), \dots, h_{m} (x;); h_{m + 1} (x; y), \dots, h_{m + n} (x; y)) .

f (x; y) = g (h_{1} (x;), \dots, h_{m} (x;); h_{m + 1} (x; y), \dots, h_{m + n} (x; y)) .

f (ε, y; z)

f (ε, y; z)

f (a . \overline{x}, y; z)

s (\overline{x}) = E (D (\overline{x}) + 1)

s (\overline{x}) = E (D (\overline{x}) + 1)

f (ε, y)

f (ε, y)

f (s (\overline{x}), y)

\begin{array}[]{rclrclrcl}T_{j\neq i}({\tt Pr}_{i}^{n})&=&-\infty&\;\;\;T_{1}({\tt hd})&=&-\infty&\;\;\;T_{1}({\tt Read})&=&-\infty\\ T_{1}({\tt tl})&=&-1&&&&&&\\ T_{i}({\tt Pr}_{i}^{n})&=&0&&&&&&\\ T_{1}({\tt s}_{0})&=&1&T_{1}({\tt s}_{1})&=&1&T_{1}({\tt s})&=&1\end{array}

\begin{array}[]{rclrclrcl}T_{j\neq i}({\tt Pr}_{i}^{n})&=&-\infty&\;\;\;T_{1}({\tt hd})&=&-\infty&\;\;\;T_{1}({\tt Read})&=&-\infty\\ T_{1}({\tt tl})&=&-1&&&&&&\\ T_{i}({\tt Pr}_{i}^{n})&=&0&&&&&&\\ T_{1}({\tt s}_{0})&=&1&T_{1}({\tt s}_{1})&=&1&T_{1}({\tt s})&=&1\end{array}

T_{t} (f) = i max {T_{i} (g) + T_{t} (h_{i})} .

T_{t} (f) = i max {T_{i} (g) + T_{t} (h_{i})} .

f (ε, y)

f (ε, y)

f (s (\overline{x}), y)

∣ f (\overline{x_{1}}, \dots, \overline{x_{n}}) ∣ \leq t max {T_{t} (f) + ∣ \overline{x_{t}} ∣, c_{f}} .

∣ f (\overline{x_{1}}, \dots, \overline{x_{n}}) ∣ \leq t max {T_{t} (f) + ∣ \overline{x_{t}} ∣, c_{f}} .

f (a . \overline{x}) = s_{a} (f (\overline{x})) .

f (a . \overline{x}) = s_{a} (f (\overline{x})) .

f (\overline{x} ≀ \overline{y} ≀ \overline{z} ≀ \overline{t}) = g (≀ \overline{y} ≀ \overline{x}, \overline{z} ≀ \overline{t}) .

f (\overline{x} ≀ \overline{y} ≀ \overline{z} ≀ \overline{t}) = g (≀ \overline{y} ≀ \overline{x}, \overline{z} ≀ \overline{t}) .

\begin{array}[]{rclrcl}{\tt hd}({\;\wr\;}{\;\wr\;}{\;\wr\;}a.\overline{x})&=&a&{\tt tl}({\;\wr\;}{\;\wr\;}a.\overline{x}{\;\wr\;})&=&\overline{x}\\ {\tt hd}({\;\wr\;}{\;\wr\;}{\;\wr\;}\varepsilon)&=&\varepsilon&{\tt tl}({\;\wr\;}{\;\wr\;}\varepsilon{\;\wr\;})&=&\varepsilon\\ {\tt s}_{0}(\overline{x}{\;\wr\;}{\;\wr\;}{\;\wr\;})&=&0.\overline{x}&{\tt s}_{1}(\overline{x}{\;\wr\;}{\;\wr\;}{\;\wr\;})&=&1.\overline{x}\\ {\tt s}(\overline{x}{\;\wr\;}{\;\wr\;}{\;\wr\;})&=&E(D(\overline{x})+1)&{\tt Read}({\;\wr\;}{\;\wr\;}{\;\wr\;}\overline{x})&=&a\in\{0,1\}\\ \lx@intercol\hfil{\tt Pr}_{i}^{n}({\;\wr\;}\overline{x_{i}}{\;\wr\;}{\;\wr\;}\overline{x_{1}},\cdots,\overline{x_{i-1}},\overline{x_{i+1}},\cdots,\overline{x_{n}})\lx@intercol&=&\overline{x_{i}}\\ \end{array}

\begin{array}[]{rclrcl}{\tt hd}({\;\wr\;}{\;\wr\;}{\;\wr\;}a.\overline{x})&=&a&{\tt tl}({\;\wr\;}{\;\wr\;}a.\overline{x}{\;\wr\;})&=&\overline{x}\\ {\tt hd}({\;\wr\;}{\;\wr\;}{\;\wr\;}\varepsilon)&=&\varepsilon&{\tt tl}({\;\wr\;}{\;\wr\;}\varepsilon{\;\wr\;})&=&\varepsilon\\ {\tt s}_{0}(\overline{x}{\;\wr\;}{\;\wr\;}{\;\wr\;})&=&0.\overline{x}&{\tt s}_{1}(\overline{x}{\;\wr\;}{\;\wr\;}{\;\wr\;})&=&1.\overline{x}\\ {\tt s}(\overline{x}{\;\wr\;}{\;\wr\;}{\;\wr\;})&=&E(D(\overline{x})+1)&{\tt Read}({\;\wr\;}{\;\wr\;}{\;\wr\;}\overline{x})&=&a\in\{0,1\}\\ \lx@intercol\hfil{\tt Pr}_{i}^{n}({\;\wr\;}\overline{x_{i}}{\;\wr\;}{\;\wr\;}\overline{x_{1}},\cdots,\overline{x_{i-1}},\overline{x_{i+1}},\cdots,\overline{x_{n}})\lx@intercol&=&\overline{x_{i}}\\ \end{array}

f (x ≀ y ≀ z ≀ t)

f (x ≀ y ≀ z ≀ t)

f (x ≀ ε, y ≀ z ≀ t)

f (x ≀ ε, y ≀ z ≀ t)

f (x ≀ s_{a} (\overline{r} ≀ ≀ ≀), y ≀ z ≀ t)

f (≀ ε ≀ ≀ t)

f (≀ ε ≀ ≀ t)

f (≀ s_{a} (\overline{r} ≀ ≀ ≀) ≀ ≀ t)

f (x ≀ ε, y ≀ z ≀ t)

f (x ≀ ε, y ≀ z ≀ t)

f (x ≀ s (\overline{r} ≀ ≀ ≀), y ≀ z ≀ t)

Step_{1} (≀ ε, \overline{s}, c ≀ ≀)

Step_{1} (≀ ε, \overline{s}, c ≀ ≀)

Step_{1} (≀ s (\overline{t} ≀ ≀ ≀), \overline{s}, c ≀ ≀)

Step_{2} (≀ ε, \overline{s}, c ≀ ≀)

Step_{2} (≀ s (\overline{t} ≀ ≀ ≀), \overline{s}, c ≀ ≀)

Step_{k} (≀ ε, \overline{s}, c ≀ ≀)

Step_{k} (≀ s (\overline{t} ≀ ≀ ≀), \overline{s}, c ≀ ≀)

\begin{array}[]{rcl}f({\bf x}{\;\wr\;}\varepsilon,\overline{u},{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})&=&h({\bf x}{\;\wr\;}\overline{u},{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})\\ f({\bf x}{\;\wr\;}{\tt s}_{a}(\overline{r}{\;\wr\;}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}\overline{u},{\bf z}{\;\wr\;}{\bf t})&=&g_{a}({\bf x}{\;\wr\;}\overline{r},f({\bf x}{\;\wr\;}\overline{r},k_{1}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t}),\\ \lx@intercol\hfil f({\bf x}{\;\wr\;}\overline{r},k_{2}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})\lx@intercol.\\ \end{array}

\begin{array}[]{rcl}f({\bf x}{\;\wr\;}\varepsilon,\overline{u},{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})&=&h({\bf x}{\;\wr\;}\overline{u},{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})\\ f({\bf x}{\;\wr\;}{\tt s}_{a}(\overline{r}{\;\wr\;}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}\overline{u},{\bf z}{\;\wr\;}{\bf t})&=&g_{a}({\bf x}{\;\wr\;}\overline{r},f({\bf x}{\;\wr\;}\overline{r},k_{1}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t}),\\ \lx@intercol\hfil f({\bf x}{\;\wr\;}\overline{r},k_{2}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})\lx@intercol.\\ \end{array}

\begin{array}[]{rcl}f({\bf x}{\;\wr\;}\varepsilon,\overline{u},{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})&=&h({\bf x}{\;\wr\;}\overline{u},{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})\\ f({\bf x}{\;\wr\;}{\tt s}(\overline{r}{\;\wr\;}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}\overline{u},{\bf z}{\;\wr\;}{\bf t})&=&g({\bf x}{\;\wr\;}\overline{r},f({\bf x}{\;\wr\;}\overline{r},k_{1}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t}),\\ \lx@intercol\hfil f({\bf x}{\;\wr\;}\overline{r},k_{2}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})\lx@intercol.\\ \end{array}

\begin{array}[]{rcl}f({\bf x}{\;\wr\;}\varepsilon,\overline{u},{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})&=&h({\bf x}{\;\wr\;}\overline{u},{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})\\ f({\bf x}{\;\wr\;}{\tt s}(\overline{r}{\;\wr\;}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}\overline{u},{\bf z}{\;\wr\;}{\bf t})&=&g({\bf x}{\;\wr\;}\overline{r},f({\bf x}{\;\wr\;}\overline{r},k_{1}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t}),\\ \lx@intercol\hfil f({\bf x}{\;\wr\;}\overline{r},k_{2}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})\lx@intercol.\\ \end{array}

\begin{array}[]{rcl}{\tt Accept}({\;\wr\;}\varepsilon,\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})&=&{\tt isPositive}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})\\ {\tt Accept}({\;\wr\;}{\tt s}(\overline{t}),\overline{s},{\bf c}{\;\wr\;}{\;\wr\;}))&=&{\tt match}\;{\tt IsUniversal}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})\;{\tt with}\\ \lx@intercol\;\;|{\tt true}->{\tt AND}\;({\;\wr\;}{\tt Accept}({\;\wr\;}\overline{t},{\tt Next}_{0}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;}),{\bf c}{\;\wr\;}{\;\wr\;}),\hfil\lx@intercol\\ \lx@intercol\hfil\;\;{\tt Accept}({\;\wr\;}\overline{t},{\tt Next}_{1}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})){\;\wr\;}{\;\wr\;})\lx@intercol\\ \lx@intercol\;\;|{\tt false}->{\tt OR}\;({\;\wr\;}{\tt Accept}({\;\wr\;}\overline{t},{\tt Next}_{0}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})),{\bf c}{\;\wr\;}{\;\wr\;}),\hfil\lx@intercol\\ \lx@intercol\hfil\;\;{\tt Accept}({\;\wr\;}\overline{t},{\tt Next}_{1}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})){\;\wr\;}{\;\wr\;})\lx@intercol.\end{array}

\begin{array}[]{rcl}{\tt Accept}({\;\wr\;}\varepsilon,\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})&=&{\tt isPositive}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})\\ {\tt Accept}({\;\wr\;}{\tt s}(\overline{t}),\overline{s},{\bf c}{\;\wr\;}{\;\wr\;}))&=&{\tt match}\;{\tt IsUniversal}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})\;{\tt with}\\ \lx@intercol\;\;|{\tt true}->{\tt AND}\;({\;\wr\;}{\tt Accept}({\;\wr\;}\overline{t},{\tt Next}_{0}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;}),{\bf c}{\;\wr\;}{\;\wr\;}),\hfil\lx@intercol\\ \lx@intercol\hfil\;\;{\tt Accept}({\;\wr\;}\overline{t},{\tt Next}_{1}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})){\;\wr\;}{\;\wr\;})\lx@intercol\\ \lx@intercol\;\;|{\tt false}->{\tt OR}\;({\;\wr\;}{\tt Accept}({\;\wr\;}\overline{t},{\tt Next}_{0}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})),{\bf c}{\;\wr\;}{\;\wr\;}),\hfil\lx@intercol\\ \lx@intercol\hfil\;\;{\tt Accept}({\;\wr\;}\overline{t},{\tt Next}_{1}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})){\;\wr\;}{\;\wr\;})\lx@intercol.\end{array}

Peer Reviews

No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.

Videos

No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.

Full text

Pointers in Recursion: Exploring the Tropics ††thanks: Work partially supported by ANR project ELICA - ANR-14-CE25-0005

Paulin Jacobé de Naurois CNRS, Université Paris 13, Sorbonne Paris Cité, LIPN, UMR 7030, F-93430 Villetaneuse, France. [email protected]

Abstract. We translate the usual class of partial/primitive recursive functions to a pointer recursion framework, accessing actual input values via a pointer reading unit-cost function. These pointer recursive functions classes are proven equivalent to the usual partial/primitive recursive functions. Complexity-wise, this framework captures in a streamlined way most of the relevant sub-polynomial classes. Pointer recursion with the safe/normal tiering discipline of Bellantoni and Cook corresponds to polylogtime computation. We introduce a new, non-size increasing tiering discipline, called tropical tiering. Tropical tiering and pointer recursion, used with some of the most common recursion schemes, capture the classes logspace, logspace/polylogtime, ptime, and NC. Finally, in a fashion reminiscent of the safe recursive functions, tropical tiering is expressed directly in the syntax of the function algebras, yielding the tropical recursive function algebras.

Introduction

Characterizing complexity classes without explicit reference to the computational model used for defining these classes, and without explicit bounds on the resources allowed for the calculus, has been a long term goal of several lines of research in computer science. One rather successful such line of research is recursion theory. The foundational work here is the result of Cobham [8], who gave a characterization of polynomial time computable functions in terms of bounded recursion on notations - where, however, an explicit polynomial bound is used in the recursion scheme. Later on, Leivant [12] refined this approach with the notion of tiered recursion: explicit bounds are no longer needed in his recursion schemes. Instead, function arguments are annotated with a static, numeric denotation, a tier, and a tiering discipline is imposed upon the recursion scheme to enforce a polynomial time computation bound. A third important step in this line of research is the work of Bellantoni and Cook [3], whose safe recursion scheme uses only syntactical constraints akin to the use of only two tier values, to characterize, again, the class of polynomial time functions.

Cobham’s approach has also later on been fruitfully extended to other, important complexity classes. Results relevant to our present work, using explicitly bounded recursion, are those of Lind [16] for logarithmic space, and Allen [2] and Clote [7] for small parallel classes.

Later on, Bellantoni and Cook’s purely syntactical approach proved also useful for characterizing other complexity classes. Leivant and Marion [15, 14] used a predicative version of the safe recursion scheme to characterize alternating complexity classes, while Bloch [4], Bonfante et al [5] and Kuroda[11], gave characterizations of small, polylogtime, parallel complexity classes. An important feature of these results is that they use, either explicitly or not, a tree-recursion on the input. This tree-recursion is implicitly obtained in Bloch’s work by the use of an extended set of basic functions, allowing for a dichotomy recursion on the input string, while it is made explicit in the recursion scheme in the two latter works. As a consequence, these characterizations all rely on the use of non-trivial basic functions, and non-trivial data structures. Moreover, the use of distinct basic function sets and data structures make it harder to express these charcterizations in a uniform framework.

Among all these previous works on sub-polynomial complexity classes, an identification is assumed between the argument of the functions of the algebra, on one hand, and the computation input on the other hand: an alternating, logspace computation on input $\overline{x}$ is denoted by a recursive function with argument $\overline{x}$ . While this seems very natural for complexity classes above linear time, it actually yields a fair amount of technical subtleties and difficulties for sub-linear complexity classes. Indeed, following Chandra et al. [6] seminal paper, sub-polynomial complexity classes need to be defined with a proper, subtler model than the one-tape Turing machine: the random access Turing machine (RATM), where computation input is accessed via a unit-cost pointer reading instruction. RATM input is thus accessed via a read-only instruction, and left untouched during the computation - a feature quite different to that of a recursive function argument. Our proposal here is to use a similar construct for reading the input in the setting of recursive functions: our functions will take as input pointers on the computation input, and one-bit pointer reading will be assumed to have unit cost. Actual computation input are thus implicit in our function algebras: the fuel of the computational machinery is only pointer arithmetics. This proposal takes inspiration partially from the Rational Bitwise Equations of [5].

Following this basic idea, we then introduce a new tiering discipline, called tropical tiering, to enforce a non-size increasing behavior on our recursive functions, with some inspirations taken from previous works of M. Hofmann [9, 10]. Tropical tiering induces a polynomial interpretation in the tropical ring of polynomials (hence its name), and yields a characterization of logarithmic space. The use of different, classical recursion schemes yield characterizations of other, sub-polynomial complexity classes such as polylogtime, NC, and the full polynomial time class. Following the approach of Bellantoni and Cook, we furthermore embed the tiering discipline directly in the syntax, with only finitely many different tier values - four tier values in our case, instead of only two tier values for the safe recursive functions, and provide purely syntactical characterizations of these complexity classes in a unified, simple framework. Compared to previous works, our framework uses a unique, and rather minimal set of unit-cost basic functions, computing indeed basic tasks, and a unique and also simple data structure.

The paper is organized as follows. Section 1 introduces the notations, and the framework of pointer recursion. Section 2 applies this framework to primitive recursion. Pointer partial/primitive recursive functions are proven to coincide with their classical counterparts in Theorem 2.1. Section 3 applies this framework to safe recursion on notations. Pointer safe recursive functions are proven to coincide with polylogtime computable functions in Theorem 3.1. Tropical tiering is defined in Section 4. Proposition 4.1 establishes the tropical interpretation induced by tropical tiering. Tropical recursive functions are then introduced in Subsection 4.3. Section 5 gives a sub-algebra of the former, capturing logspace/polylogtime computable functions in Theorem 5.2. Finally, Section 6 explores tropical recursion with substitutions, and provides a characterization of P in Theorem 6.2 and of NC in Theorem 6.4.

1 Recursion

1.1 Notations, and Recursion on Notations

Data structures considered in our paper are finite words over a finite alphabet. For the sake of simplicity, we consider the finite, boolean alphabet $\{{\bf 0},{\bf 1}\}$ . The set of finite words over $\{{\bf 0},{\bf 1}\}$ is denoted as $\{{\bf 0},{\bf 1}\}^{*}$ .

Finite words over $\{{\bf 0},{\bf 1}\}$ are denoted with overlined variables names, as in $\overline{x}$ . Single values in $\{{\bf 0},{\bf 1}\}$ are denoted as plain variables names, as in $x$ . The empty word is denoted by $\varepsilon$ , while the dot symbol ”.” denotes the concatenation of two words as in $a.\overline{x}$ , the finite word obtained by adding an $a$ in front of the word $\overline{x}$ . Finally, finite arrays of boolean words are denoted with bold variable names, as in ${\bf x}=(\overline{x_{1}},\cdots,\overline{x_{n}})$ . When defining schemes, we will often omit the length of the arrays at hand, when clear from context, and use bold variable names to simplify notations. Similarly, for mutual recursion schemes, finite arrays of mutually recursive functions are denoted by a single bold function name. In this case, the width of this function name is the size of the array of the mutually recursive functions.

Natural numbers are identified with finite words over $\{{\bf 0},{\bf 1}\}$ via the usual binary encoding. Yet, in most of our function algebras, recursion is not performed on the numerical value of an integer, as in classical primitive recursion, but rather on its boolean encoding, that is, on the finite word over $\{{\bf 0},{\bf 1}\}$ identified with it: this approach is denoted as recursion on notations.

1.2 Turing Machines with Random Access

When considering sub-polynomial complexity class, classical Turing Machines often fail to provide a suitable cost model. A crucial example is the class DLOGTIME: in logarithmic time, a classical Turing machine fails to read any further than the first $k.\log(n)$ input bits. In order to provide a suitable time complexity measure for sub-polynomial complexity classes, Chandra et al [6] introduced the Turing Machine with Random Access (RATM), whose definition follows.

Definition 1.1

RATM

A Turing Machine with Random Access (RATM) is a Turing machine with no input head, one (or several) working tapes and a special pointer tape, of logarithmic size, over a binary alphabet. The Machine has a special Read state such that, when the binary number on the pointer tape is $k$ , the transition from the Read state consists in writing the $k^{th}$ input symbol on the (first) working tape.

1.3 Recursion on Pointers

In usual recursion theory, a function computes a value on its input, which is given explicitly as an argument. This, again, is the case in classical primitive recursion. While this is suitable for describing explicit computation on the input, as, for instance for single tape Turing Machines, this is not so for describing input-read-only computation models, as, for instance, RATMs. In order to propose a suitable recursion framework for input-read-only computation, we propose the following pointer recursion scheme, whose underlying idea is pretty similar to that of the RATM.

As above, recursion data is given by finite, binary words, and the usual recursion on notation techniques on these recursion data apply. The difference lies in the way the actual computation input is accessed: in our framework, we distinguish two notions, the computation input, and the function input: the former denotes the input of the RATM, while the latter denotes the input in the function algebra. For classical primitive recursive functions, the two coincide, up to the encoding of integer into binary strings. In our case, we assume an explicit encoding of the former into the latter, given by the two following constructs.

Let $\overline{w}=w_{1}.\cdots.w_{n}\in\{{\bf 0},{\bf 1}\}^{*}$ be a computation input. To $\overline{w}$ , we associate two constructs,

•

the Offset: a finite word over $\{{\bf 0},{\bf 1}\}$ , encoding in binary the length $n$ of $\overline{w}$ , and

•

the Read construct, a 1-ary function, such that, for any binary encoding $\overline{i}$ of an integer $0<i\leq n$ , ${\tt Read}(\overline{i})=w_{i}$ , and, for any other value $\overline{v}$ , ${\tt Read}(\overline{v})=\varepsilon$ .

Then, for a given computation input $\overline{w}$ , we fix accordingly the semantics of the Read and Offset constructs as above, and a Pointer Recursive function over $\overline{w}$ is evaluated with sole input the Offset, accessing computation input bits via the Read construct. For instance, under these conventions, ${\tt Read}({\tt hd}({\tt Offset}))$ outputs the first bit of the computational input $\overline{w}$ . In some sense, the two constructs depend on $\overline{w}$ , and can be understood as functions on $\overline{w}$ . However, in our approach, it is important to forbid $\overline{w}$ from appearing explicitly as a function argument in the syntax of the function algebras we will define, and from playing any role in the composition and recursion schemes. Since $\overline{w}$ plays no role at the syntactical level - its only role is at the semantical level- we chose to remove it completely $\overline{w}$ from the syntactical definition of our functions algebras.

2 Pointers Primitive Recursion

Let us first detail our pointer recursive framework for the classical case of primitive recursion on notations.

Basic pointer functions.

Basic pointer functions are the following kind of functions:

Functions manipulating finite words over $\{{\bf 0},{\bf 1}\}$ . For any $a\in\{{\bf 0},{\bf 1}\},\overline{x}\in\{{\bf 0},{\bf 1}\}^{*}$ ,

[TABLE] 2. 2.

Projections. For any $n\in{\mathbb{N}}$ , $1\leq i\leq n$ ,

[TABLE] 3. 3.

and, finally, the Offset and Read constructs, as defined above.

Composition.

Given functions $g$ , and $h_{1},\cdots,h_{n}$ , we define $f$ by composition as

[TABLE]

Primitive Recursion on Notations.

Let $\perp$ denote non-terminating computation. Given functions $h$ , $g_{0}$ and $g_{1}$ , we define $f$ by primitive recursion on notations as

[TABLE]

Minimization.

For a function $s$ , denote by $s^{(n)}$ its $n^{th}$ iterate. Then, given a function $h$ , we define $f$ by minimization on $\overline{x}$ as

[TABLE]

In other words, a function $f$ defined by minimization on $h$ produces the shortest sequence of [math] symbols satisfying a simple condition on $h$ , if it exists.

Let now $PR_{not}^{point}$ be the closure of basic pointer functions under composition and primitive recursion on notations, and $REC_{not}^{point}$ be the closure of basic pointer functions under composition, primitive recursion on notations, and minimization. Then, as expected,

Theorem 2.1

Modulo the binary encoding of natural integers, $PR_{not}^{point}$ is the classical class of primitive recursive functions, and $REC_{not}^{point}$ is the classical class of recursive functions.

Proof. It is already well known that primitive recursive functions on notations are the classical primitive recursive functions, and recursive functions on notations are the classical recursive functions. Now, for one direction, it suffices to express the Read and Offset basic pointer functions as primitive recursive functions on the computation input. For the other direction, it suffices to reconstruct with pointer primitive recursion the computation input from the Read and Offset basic pointer functions.

3 Pointer Safe Recursion

We recall the tiering discipline of Bellantoni and Cook [3]: functions arguments are divided into two tiers, normal arguments and safe arguments. Notation-wise, both tiers are separated by a semicolon symbol in a block of arguments, the normal arguments being on the left, and the safe arguments on the right. We simply apply this tiering discipline to our pointer recursion framework.

Basic Pointer Safe Functions.

Basic pointer safe functions are the basic pointer functions of the previous section, all their arguments being considered safe.

Safe Composition.

Safe composition is somewhat similar to the previous composition scheme, with a tiering discipline, ensuring that safe arguments cannot be moved to a normal position in a function call. The reverse however is allowed.

[TABLE]

Calls to functions $h_{m+i}$ , where safe arguments are used, are placed in safe position in the argument block of $g$ . A special case of safe composition is $f(\overline{x};\overline{y})=g(;\overline{x},\overline{y})$ , where a normal argument $\overline{x}$ is used in safe position in a call. Hence, we liberally use normal arguments in safe position, when necessary.

Safe Recursion.

The recursion argument is normal. The recursive call is placed in safe position, a feature that prevents nesting recursive calls exponentially.

[TABLE]

Let now $SR_{not}^{point}$ be the closure of the basic pointer safe functions under safe composition and safe recursion.

Theorem 3.1

$SR_{not}^{point}$ is the class $DTIME(polylog)$ of functions computable in poly-logarithmic time.

Proof. The proof is essentially the same as for the classical result by Bellantoni and Cook [3]. Here however, it is crucial to use the RATM as computation model. Simulating a polylogtime RATM with safe recursion on pointers is very similar to simulating a polytime TM with safe recursion - instead of explicitly using the machine input as recursion data, we use the size of the input as recursion data, and access the input values via the Read construct, exactly as is done by the RATM model. The other direction is also similar: the tiering discipline of the safe recursion on pointers enforces a polylog bound on the size of the strings (since the initial recursion data - the Offset - has size logarithmic in the size $n$ of the computation input), and thus a polylog bound on the computation time.

4 Tropical Tiering

We present here another, stricter tiering discipline, that we call tropical Tiering. The adjective ”tropical” refers to the fact that this tiering induces a polynomial interpretation in the tropical ring of polynomials. This tiering discipline takes some inspiration from Hofmann’s work on non-size increasing types [9], and pure pointer programs [10]. The idea however is to use here different tools than Hofmann’s to achieve a similar goal of bounding the size of the function outputs. We provide here a non-size increasing discipline via the use of tiering, and use it in the setting of pointer recursion to capture not only pure pointer programs (Hoffman’s class), but rather pointer programs with pointer arithmetics, which is in essence the whole class Logspace.

Basic Pointer Functions.

We add the following numerical successor basic function. Denote by $E:{\mathbb{N}}\rightarrow\{{\bf 0},{\bf 1}\}^{*}$ the usual binary encoding of integers, and $D:\{{\bf 0},{\bf 1}\}^{*}\rightarrow{\mathbb{N}}$ the decoding of binary strings to integers. Then,

[TABLE]

denotes the numerical successor on binary encodings, and, by convention, $\varepsilon$ is the binary encoding of the integer [math].

Primitive Recursion on Values.

Primitive recursion on values is the usual primitive recursion, encoded into binary strings:

[TABLE]

4.1 Tropical Tier

As usual, tiering consists in assigning function variables to different classes, called tiers. In our setting, these tiers are identified by a numerical value, called tropical tier, or, shortly, tropic. The purpose of our tropical tiers is to enforce a strict control on the increase of the size of the binary strings during computation. Tropics take values in ${\mathbb{Z}}\cup\{-\infty\}$ . The tropic of the $i^{th}$ variable of a function $f$ is denoted $T_{i}(f)$ . The intended meaning of the tropics is to provide an upper bound on the linear growth of the function output size with respect to the corresponding input size, as per Proposition 4.1. Tropics are inductively defined as follows.

Basic pointer functions:

[TABLE] 2. 2.

Composition:

[TABLE] 3. 3.

Primitive recursion on notations. Two cases arise:

•

$T_{2}(g_{0})\leq 0$ and $T_{2}(g_{1})\leq 0$ . In that case, we set

(a)

$T_{1}(f)=\max\{T_{1}(g_{0}),T_{1}(g_{1}),T_{2}(g_{0}),T_{2}(g_{1})\}$ , and, 2. (b)

for all $t\geq 1$ ,

$T_{t}(f)=\max\{T_{t+1}(g_{0}),T_{t+1}(g_{1}),T_{t-1}(h),T_{2}(g_{0}),T_{2}(g_{1})\}$ .

•

the previous case above does not hold, $T_{2}(g_{0})\leq 1$ , and $T_{2}(g_{1})\leq 1$ . In that case, we also require that $T_{1}(g_{0})\leq 0$ , $T_{1}(g_{1})\leq 0$ , and, for all $t\geq 2$ , $T_{t}(g_{0})=T_{t}(g_{1})=T_{t-2}(h)=-\infty$ . Then, we set $T_{1}(f)=\max\{T_{1}(g_{0}),T_{1}(g_{1}),T_{2}(g_{0})-1,T_{2}(g_{1})-1,c_{h}\}$ , where $c_{h}$ is a constant for $h$ given in Proposition 4.1 below, and, for $t\geq 1$ , $T_{t}(f)=-\infty$ .

Other cases than the two above do not enjoy tropical tiering. 4. 4.

Primitive recursion on values. Only one case arises:

•

$T_{2}(g)\leq 0$ . In that case, we set

(a)

$T_{1}(f)=\max\{T_{1}(g),T_{2}(g)\}$ , and, 2. (b)

for all $t\geq 1$ , $T_{t}(f)=\max\{T_{t+1}(g),T_{t-1}(h),T_{2}(g)\}$ .

Again, other cases than the one above do not enjoy tropical tiering.

Furthermore, when using tropical tiering, we use mutual recursion schemes. For ${\bf f}=(f_{1},\cdots,f_{n})$ , mutual primitive recursion (on values) is classically defined as follows,

[TABLE]

and similarly for mutual primitive recursion on notations. Tropical tiering is then extended to mutual primitive recursion in a straightforward manner.

We define the set of L-primitive pointer recursive functions as the closure of the basic pointer functions of Sections 2 and 4 under composition, (mutual) primitive recursion on notations and (mutual) primitive recursion on values, with tropical tiering.

4.2 Tropical Interpretation

Tropical tiering induces a non-size increasing discipline. More formally,

Proposition 4.1

The tropical tiering of a L-primitive recursive function $f$ induces a polynomial interpretation of $f$ on the tropical ring of polynomials, as follows.

For any L-primitve recursive function $f$ with $n$ arguments, there exists a constant $c_{f}\geq 0$ such that

[TABLE]

Proof. The proof is given for non-mutual recursion schemes, by induction on the definition tree. Mutual recursion schemes follow the same pattern.

For basic pointer functions, the result holds immediately. 2. 2.

Let $f$ be defined by composition, and assume that the result holds for the functions $g$ , $h_{1},\cdots,h_{n}$ . Then, for any $i=1,\cdots,n$ , $|h_{i}({\bf x})|\leq\max_{t}\{T_{t}(h_{i})+|\overline{x_{t}}|,c_{h_{i}}\}$ . Moreover, there exists by induction $c_{g}$ such that $|g(h_{1}({\bf x}),\cdots,h_{n}({\bf x}))|\leq\max_{i}\{T_{i}(g)+|h_{i}({\bf x})|,c_{g}\}$ . Composing the inequalities above yields $|g(h_{1}({\bf x}),\cdots,h_{n}({\bf x}))|\leq\max_{i}\{T_{i}(g)+\max_{t}\{T_{t}(h_{i})+|\overline{x_{i}}|,c_{h_{i}}\},c_{g}\}=\max_{t}\{T_{t}(f)+|\overline{x_{t}}|,\max_{i}\{c_{f_{i}},c_{g}\}\}$ . 3. 3.

Let $f$ be defined by primitive recursion on notations, and assume that the first case holds. Let $f(a.\overline{x},{\bf y})=g_{a}(\overline{x},f(\overline{x},{\bf y}),{\bf y})$ , for $a\in\{0,1\}$ , and assume $T_{2}(g_{0})\leq 0$ and $T_{2}(g_{1})\leq 0$ . We apply the tropical interpretation on $g$ , and we show by induction the result for $f$ on the length of $a.\overline{x}$ .

(a)

If $\max_{\overline{x},f(\overline{x},{\bf y}),t}\{|\overline{x}|+T_{1}(g_{a}),|f(\overline{x},{\bf y})|+T_{2}(g_{a}),|\overline{y_{t}}|+T_{t+2}(g_{a}),c_{g_{a}}\}=|\overline{x}|+T_{1}(g_{a})$ : $|f(a.\overline{x},{\bf y})|\leq|\overline{x}|+T_{1}(g_{a})\leq|\overline{x}|+T_{1}(f)$ , and the result holds. 2. (b)

If $\max_{\overline{x},f(\overline{x},{\bf y}),t}\{|\overline{x}|+T_{1}(g_{a}),|f(\overline{x},{\bf y})|+T_{2}(g_{a}),|\overline{y_{t}}|+T_{t+2}(g_{a}),c_{g_{a}}\}=|f(\overline{x},{\bf y})|+T_{2}(g_{a})$ : Since $T_{2}(g_{a})\leq 0$ , $|f(a.\overline{x},{\bf y})|\leq|f(\overline{x},{\bf y})|$ , and the induction hypothesis applies. 3. (c)

If $\max_{\overline{x},f(\overline{x},{\bf y}),t}\{|\overline{x}|+T_{1}(g_{a}),|f(\overline{x},{\bf y})|+T_{2}(g_{a}),|\overline{y_{t}}|+T_{t+2}(g_{a}),c_{g_{a}}\}=|\overline{y_{t}}|+T_{t+2}(g_{a})$ for some $t$ : the result applies immediately by structural induction on $g_{a}$ . 4. (d)

If $\max_{\overline{x},f(\overline{x},{\bf y}),t}\{|\overline{x}|+T_{1}(g_{a}),|f(\overline{x},{\bf y})|+T_{2}(g_{a}),|\overline{y_{t}}|+T_{t+2}(g_{a}),c_{g_{a}}\}=c_{g_{a}}$ , the result holds immediately. 5. (e)

The base case $f(\epsilon,{\bf y})$ is immediate. 4. 4.

Let $f$ be defined by primitive recursion on notations, and assume now that the second of the two corresponding cases holds. Let $f(a.\overline{x},{\bf y})=g_{a}(\overline{x},f(\overline{x},{\bf y}),{\bf y})$ , for $a\in\{0,1\}$ . Since the first case does not hold, $T_{2}(g_{0})=1$ or $T_{2}(g_{1})=1$ : assume that $T_{2}(g_{0})=1$ (the other case being symmetric). Assume also that, $T_{1}(g_{0})\leq 0$ and $T_{1}(g_{1})\leq 0$ , and for all $t\geq 2$ , $T_{t}(g_{0})=T_{t}(g_{1})=T_{t-2}(h)=-\infty$ . Then, we set $T_{1}(f)=\max\{0,c_{h}\}$ . We apply the tropical interpretation on $g$ , and prove by induction on the length of $a.\overline{x}$ that $|f(a.\overline{x},{\bf y})|\leq|a.\overline{x}|+\max\{c_{g_{1}},c_{g_{2}},c_{h}\}$ .

(a)

If $\max_{t\geq 2}\{|\overline{x}|+T_{1}(g_{a}),|f(\overline{x},{\bf y})|+T_{2}(g_{a}),|\overline{y_{t}}|+T_{t}(g_{a}),c_{g_{a}}\}=|\overline{x}|+T_{1}(g_{a})$ . Since $T_{1}(g_{a})\leq 0$ and $T_{1}(f)\geq 0$ , $|f(a.\overline{x},{\bf y})|\leq|\overline{x}|\leq T_{1}(f)+|\overline{x}|$ , and the result holds. 2. (b)

If $\max_{t\geq 2}\{|\overline{x}|+T_{1}(g_{a}),|f(\overline{x},{\bf y})|+T_{2}(g_{a}),|\overline{y_{t}}|+T_{t}(g_{a}),c_{g_{a}}\}=|f(\overline{x})|+T_{2}(g_{a})$ . Since $T_{2}(g_{a})\leq 1$ , $|f(a.\overline{x})|\leq 1+|f(\overline{x})|$ , and the induction hypothesis allows to conclude. 3. (c)

If $\max_{t\geq 2}\{|\overline{x}|+T_{1}(g_{a}),|f(\overline{x},{\bf y})|+T_{2}(g_{a}),|\overline{y_{t}}|+T_{t}(g_{a}),c_{g_{a}}\}=c_{g_{a}}$ , the result holds immediately. 4. (d)

The case $\max_{t\geq 2}\{|\overline{x}|+T_{1}(g_{a}),|f(\overline{x},{\bf y})|+T_{2}(g_{a}),|\overline{y_{t}}|+T_{t}(g_{a}),c_{g_{a}}\}=|\overline{y_{t}}|+T_{t}(g_{a})$ is impossible since $T_{t}(g_{a})=-\infty$ for $t\geq 2$ . 5. (e)

The base case $f(\epsilon,{\bf y})$ is immediate. 5. 5.

Let now assume $f$ is define by primitive recursion on values. Then, the only possible case is similar to the first case of primitive recursion on notation.

The proof by induction above emphasizes the critical difference between recursion on notation and recursion on values: the second case of the safe recursion on notations correspond to the linear, non-size increasing scanning of the input, as in, for instance,

[TABLE]

This, of course, is only possible in recursion on notation, where the height of the recursive calls stack is precisely the length of the scanned input. Recursion on values fails to perform this linear scanning, since, for a given recursive argument $\overline{x}$ , the number of recursive calls is then exponential in $|\overline{x}|$ .

Proposition 4.1 proves that the tropical tiering of a function yields actually a tropical polynomial interpretation for the function symbols: The right hand side of the Lemma inequality is indeed a tropical interpretation. Moreover, this interpretation is directly given by the syntax.

Furthermore, the proof also highlights why we use mutual recursion schemes instead of more simple, non-mutual ones: non-size increasing discipline forbids the use of multiplicative constants in the size of the strings. So, in order to capture a computational space of size $k.\log(n)$ , we need to use $k$ binary strings of length $\log(n)$ , defined by mutual recursion.

Corollary 4.2

L-primitive pointer recursive functions are computable in logarithmic space.

Proof.

Proposition 4.1 ensures that the size of all binary strings is logarithmically bounded. A structural induction on the definition of $f$ yields the result. The only critical case is that of a recursive construct. When evaluating a recursive construct, one needs simply to store all non-recursive arguments (the $\overline{y_{i}}$ ’s) in a shared memory, keep a shared counter for keeping track of the recursive argument $\overline{x}$ , and use a simple ${\tt while}$ loop to compute successively all intermediate recursive calls leading to $f(\overline{x},{\bf y})$ . All these shared values have logarithmic size. The induction hypothesis ensures then that, at each step in the ${\tt while}$ loop, all computations take logarithmic space. The two other cases, composition and basic functions, are straightforward.

In the following section, we prove the converse: logarithmic space functions can be computed by a sub-algebra of the L-primitive pointer recursive functions.

4.3 Tropical Recursion

In this section we restrict our tropical tiering approach to only four possible tier values: $1$ , [math], $-1$ and $-\infty$ . The rules for tiering are adapted accordingly. More importantly, the use of only four tier values allows us to denote these tropics directly in the syntax, in an approach similar to that of Bellantoni and Cook. Let us take as separator symbol the following ${\;\wr\;}$ symbol, with leftmost variables having the highest tier. As with safe recursive functions, we allow the use of a high tier variable in a low tier position, as in, for instance,

[TABLE]

Our tropical recursive functions are then as follows.

Basic tropical pointer functions.

Basic tropical pointer functions are the following.

[TABLE]

Tropical composition.

Define ${\bf t}={\bf t}_{1},{\bf t}_{2},{\bf t}_{3},{\bf t}_{4}$ . The tropical composition scheme is then

[TABLE]

Tropical Recursion on Notations - case 1.

[TABLE]

Tropical Recursion on Notations - case 2.

(Linear scanning)

[TABLE]

Tropical Recursion on Values.

[TABLE]

As above, we use the mutual version of these recursion schemes, with the same tiering discipline. Note that, unlike previous characterizations of sub-polynomial complexity classes [4, 5, 11], our tropical composition and recursion schemes are only syntactical refinements of the usual composition and primitive recursion schemes - removing the syntactical sugar yields indeed the classical schemes.

Definition 4.3

L-tropical functions

The class of L-tropical functions is the closure of our basic tropical pointer functions, under tropical composition, tropical mutual recursion on notations, and tropical mutual recursion on values.

The restriction of only four tier values suffices to capture the computational power of RATMs. More precisely,

Theorem 4.4

The class of L-tropical functions is the class of functions computable in logarithmic space, with logarithmic size output.

Proof. L-tropical functions are L- primitive pointer recursive functions with tropics $1$ , [math], $-1$ and $-\infty$ . Following Corollary 4.2, they are computable in logspace. The converse follows from the simulation of a logarithmic space RATM. The simulation works as follows.

Encoding the machine configurations.

Assume the machine $M$ works in space $k\lceil\log(n+1)\rceil$ . A configuration of $M$ is then encoded by $2k+3$ binary strings of length less than $\lceil\log(n+1)\rceil$ :

one string, of constant length, encodes the machine state, 2. 2.

one string, of length $\lceil\log(n+1)\rceil$ , encodes the pointer tape, 3. 3.

one string, of length $\lceil\log(n+1)\rceil$ , encodes the head of the pointer tape. It contains ${\bf 0}$ symbols everywhere, but on the position of the head (where it contains a ${\bf 1}$ ). 4. 4.

$k$ strings, of length $\lceil\log(n+1)\rceil$ , encode the content of the work tape, and 5. 5.

$k$ strings, of length $\lceil\log(n+1)\rceil$ , encode the position of the work tape head, with (as for the pointer tape) ${\bf 0}$ everywhere but on the position of the head.

Reading and Updating a configuration.

Linear scanning of the recursive argument in tropical recursion, corresponding to case 2 of the definition of tropical recursion on notations, is used to read and to update the encoding of the configuration. In order to do so, one defines L-tropical functions for

encoding boolean values true and false, boolean connectives, and if then else constructs, 2. 2.

scanning an input string until a 1 is found, and computing the corresponding prefix sequence, 3. 3.

computing left and right extractions of sub-strings of a string, for a given prefix, 4. 4.

replacing exactly one bit in a binary string, whose position is given by a prefix of the string.

With all these simple bricks, and especially with the in-place one-bit replacement, one is then able to read a configuration, and to update it, with L-tropical functions. None of these L-tropical functions uses recursion on values.

Computing the Transition map of the Machine.

Given the functions above, the transition map ${\bf Next}$ of the machine is then computed by a simple L-tropical function of width $(2k+3)$ : For a recursive argument $\overline{s}$ of size $\lceil\log(n+1)\rceil$ , ${\bf Next}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})$ computes the configuration reached from ${\bf c}$ in one transition step.

Simulating the RATM.

The simulation of the RATM is then obtained by iterating its transition map a suitable number of times. The time upper bound is here obtained by nesting $k$ tropical recursive functions on values: on an input of size $\lceil\log(n+1)\rceil$ , the unfolding of these recursive calls takes time $n^{k}$ . At each recursive step, this function needs to apply the transition map. The transition map having width $(2k+3)$ , we use here a mutual recursion scheme, of width $(2k+3)$ . Again, for a recursive argument $\overline{s}$ of size $\lceil\log(n+1)\rceil$ , we define

[TABLE]

Replacing $\overline{s}$ by the Offset in the above gives the correct bounds.

Finally, one simply needs to use simple L-tropical functions for computing the initial configuration, and reading the final configuration.

5 Logarithmic Space, Polylogarithmic Time

Definition 5.1

LP-tropical functions

The class of LP-tropical functions is the closure of our basic tropical pointer functions, under tropical composition and tropical mutual recursion on notations.

Theorem 5.2

The class of LP-tropical functions is the class of functions computable in logarithmic space, polylogarithmic time, with logarithmic size output.

Proof. Mutual recursion on notations, with recursive arguments of logarithmic size, are computable in polylogarithmic time, following similar arguments as in the proof of Theorem 4.4. The converse follows from the simulation in the proof of Theorem 4.4 above, where mutual recursion on values for the functions ${\tt Step}_{i}$ is replaced by mutual recursion on notations.

6 Alternation

In this section we extend the approach of Leivant and Marion [13] to our setting. Let us define a similar tropical recursion on notations with substitutions. Note that the tropical tiering discipline prevents using substitutions in case 2 of the tropical recursion on notations. Substitutions are therefore only defined for case 1 of this recursion scheme.

Tropical Recursion with substitutions on Notations.

Given functions $h$ , $g_{0}$ , $g_{1}$ , $k_{1}$ and $k_{2}$ ,

[TABLE]

Tropical Recursion with substitutions on Values.

Given functions $h$ , $g$ , $k_{1}$ and $k_{2}$ ,

[TABLE]

Again, as above, we assume these recursion schemes to be mutual.

Definition 6.1

P-tropical functions

The class of P-tropical functions is the closure of our basic tropical pointer functions, under tropical composition, tropical recursion on notations and on values, and tropical recursion with substitutions on notations and on values.

Theorem 6.2

The class of P-tropical functions with binary output is the class P.

Proof. The result follows from $Alogspace=P$ [6], and Theorem 4.4. Substitutions in the tropical recursion scheme on notations amounts to alternation. Restriction to decision classes instead of function classes comes from the use of alternating Turing machines, which compute only decision problems.

Let us first see how to simulate a logspace alternating machine with P-tropical functions. Recall the notations and functions of the proof of Theorem 4.4. Since we now need to simulate a non-deterministic, alternating machine, we assume without loss of generality that we now have two kinds of machine states:

•

non-deterministic universal

•

non-deterministic existential

and that non-deterministic transitions have at most two branches. Therefore, we also assume that we have one predicate that determines the kind of a state in a configuration ${\bf c}$ : ${\tt IsUniversal}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})$ . This predicate is assumed to output false or true.

We also assume that we have two transition maps, ${\tt Next}_{0}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})$ , and ${\tt Next}_{1}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})$ , for computing both branches of non-deterministic transitions. For deterministic transitions, we assume both branches are the same. Finally, we also assume we have a predicate ${\tt isPositive}({\;\wr\;}\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})$ , which returns ${\tt true}$ if the configuration ${\bf c}$ is final and accepting, and ${\tt false}$ otherwise.

We define now, with substitutions, the following:

[TABLE]

Then, for $\overline{t}$ and $\overline{s}$ large enough, and an initial configuration ${\bf c}$ , ${\tt Accept}({\;\wr\;}\overline{t},\overline{s},{\bf c}{\;\wr\;}{\;\wr\;})$ outputs the result of the computation of the machine. Finally, nesting up to $k$ layers of such recursion on values schemes allows, as in the proof of Theorem 4.4, to simulate a polynomial computation time.

The other direction is pretty straightforward: For any instance of a recursion scheme with substitutions, for any given values $\overline{r}$ , $\overline{u}$ , ${\bf x}$ , ${\bf y}$ and ${\bf z}$ , each bit of

$g_{a}({\bf x}{\;\wr\;}\overline{r},f({\bf x}{\;\wr\;}\overline{r},k_{1}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t}),f({\bf x}{\;\wr\;}\overline{r},k_{2}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})$ is a boolean function of the bits of $f({\bf x}{\;\wr\;}\overline{r},k_{1}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})$ and $f({\bf x}{\;\wr\;}\overline{r},k_{2}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})$ . Hence, it can be computed by an alternating procedure. The space bound follows from the bound on the size of the strings, provided by the tiering discipline.

Definition 6.3

NC-tropical functions

The class of NC-tropical functions is the closure of our basic pointer tropical functions, under tropical composition, tropical recursion on notations and tropical recursion with substitutions on notations.

Theorem 6.4

The class of NC-tropical functions with binary output is NC.

Proof. The result follows from $A(logspace,polylogtime)=NC$ [17], and Theorem 4.4. Substitutions in the tropical recursion scheme on notations amounts to alternation. The proof is similar to that of Theorem 6.2, where additionally,

•

The time bound on the computation of the machine needs only to be polylogarithmic, instead of polynomial. As in Theorem 5.2, tropical recursion on notations suffices to obtain this bound, and tropical recursion on values is no longer needed.

•

For the other direction, any bit of

$g_{a}({\bf x}{\;\wr\;}\overline{r},f({\bf x}{\;\wr\;}\overline{r},k_{1}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t}),$ $f({\bf x}{\;\wr\;}\overline{r},k_{2}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})$ is again a boolean function of the bits of $f({\bf x}{\;\wr\;}\overline{r},k_{1}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})$ and $f({\bf x}{\;\wr\;}\overline{r},k_{2}({\;\wr\;}\overline{u}{\;\wr\;}{\;\wr\;}),{\bf y}{\;\wr\;}{\bf z}{\;\wr\;}{\bf t})$ . Here, this boolean function can be computed by a boolean circuit of polylogarithmic depth, hence, by an alternating procedure in polylogarihtmic time. The arguments behind this remark are the same as the ones in the proof of $A(logspace,polylogtime)=NC$ .

7 Concluding Remarks

Theorems 4.4, 5.2, 6.2, and 6.4 rely on mutual recursive schemes. As stated above, we use these mutual schemes to express a space computation of size $k\log(n)$ for any constant $k$ , with binary strings of length at most $\log(n)+c$ . If we were to use only non-mutual recursion schemes, we would need to have longer binary strings. This can be achieved by taking as input to our functions, not simply the Offset, but some larger string $\#^{k}({\tt Offset})$ , where $\#^{k}$ is a function that appends $k$ copies of its argument.

It also remains to be checked wether one can refine Theorem 6.4 to provide characterizations of the classes NCi as in [14]. A first step in this direction is to define a recursion rank, accounting for the nesting of recursion schemes: then, check wether NC-tropical functions of rank $i$ are computable in NCi. Conversely, check also whether the simulation of Theorem 4.4 induces a fixed overhead, and wether NCi can be encoded by NC-tropical functions of rank $i+c$ for some constant $c$ small enough.

Finally, note that we characterize logarithmic space functions with logarithmically long output (Theorem 5.2), and NC functions with one-bit output (Theorem 6.4). As usual, polynomially long outputs for these classes can be retrieved via a pointer access: it suffices to parameterize these functions with an additional, logarithmically long input, denoting the output bit one wants to compute. In order to retrieve functions with polynomially long output, this approach could also be added to the syntax, with a Write construct similar to our Read construct, for writing the output.

Bibliography17

The reference list from the paper itself. Each links out to its DOI / PubMed record.

1[1]
2[2] Bill Allen (1991): Arithmetizing Uniform NC . Ann. Pure Appl. Logic 53(1), pp. 1–50, 10.1016/0168-0072(91)90057-S . · doi ↗
3[3] Stephen Bellantoni & Stephen A. Cook (1992): A New Recursion-Theoretic Characterization of the Polytime Functions . Computational Complexity 2, pp. 97–110, 10.1007/BF 01201998 . · doi ↗
4[4] Stephen A. Bloch (1994): Function-Algebraic Characterizations of Log and Polylog Parallel Time . Computational Complexity 4, pp. 175–205, 10.1007/BF 01202288 . · doi ↗
5[5] Guillaume Bonfante, Reinhard Kahle, Jean-Yves Marion & Isabel Oitavem (2016): Two function algebras defining functions in NC k k {}^{\mbox{k}} boolean circuits . Inf. Comput. 248, pp. 82–103, 10.1016/j.ic.2015.12.009 . · doi ↗
6[6] Ashok K. Chandra, Dexter Kozen & Larry J. Stockmeyer (1981): Alternation . J. ACM 28(1), pp. 114–133, 10.1145/322234.322243 . · doi ↗
7[7] P. Clote (1989): Sequential, machine-independent characterizations of the parallel complexity classes ALOGTIME , AC k , NC k and NC . Feasible Mathematics, Birkhaüser, 49-69 , 10.1007/978-1-4612-3466-1 _ _ \_ 4 . · doi ↗
8[8] A. Cobham (1962): The intrinsic computational difficulty of functions . In Y. Bar-Hillel, editor: Proceedings of the International Conference on Logic, Methodology, and Philosophy of Science , North-Holland, Amsterdam, pp. 24–30, 10.2307/2270886 . · doi ↗