2 Preliminaries

We assume a basic familiarity with syntax and semantics of first-order functional programming languages, Turing machines, the Turing machine complexity classes P (polynomial time) and L (logarithmic space), and their functional variants FP and FL. Note that when defining a functional space class, the space bound only applies to the work tapes and not the output tape. Hence, the length of the output of function in FL may in general grow polynomially in the length of the input.

Following the set-theoretic convention, we identify any natural number n with its set of predecessors $\{0,1,\dots,n-1\}$ and we denote the set of all natural numbers by $\omega$ . Therefore, $1 = \{0\}$ , $2 = \{0,1\}$ , and $1^n$ and $2^n$ are the sets of unary and binary strings of length n, respectively. We also identify 0 and 1 with $\bot$ (false) and $\top$ (true), respectively, so 2 is also the set of boolean values.

We denote the set of all finite unary and binary strings by $1^\star$ and $2^\star,$ respectively, following the convention in computer science. ^{Footnote 3} The empty string is denoted $\varepsilon$ ; its underlying alphabet must be inferred from context. The head of a string is its first character, and its tail is the remainder. The head and tail of $\varepsilon$ are undefined. If x is a string, then $|x|$ is its length.

We typically use lowercase Latin letters such as m,n,u,v,w,x,y for variables that range over “type-0 objects” such as natural numbers and strings. By, e.g., a “n-ary relation on strings,” we mean a subset of $(2^\star)^n$ . We use capital Latin letters, e.g., P,Q,X,Y, for variable that range over relations, and f,g,h for variables that range over functions. We use lowercase Greek letters for variables that range over types. We use typewriter script for program syntax.

A partial function $f : X \rightharpoonup Y$ is a function $f : X' \to Y$ for some $X' \subseteq X$ ; X’ is the domain of convergence of f. If x is in the domain of convergence of f, we write $f(x) \downarrow$ , otherwise $f(x) \uparrow$ , and say that f “converges” or “diverges” on x, respectively. Partial functions converge strictly, meaning that $f(g(x)) \downarrow$ implies, in particular, that $g(x) \downarrow$ . For two partial functions $f,f':X \rightharpoonup Y$ , we say that $f' \sqsubseteq f$ in case $f'(x) = y \implies f(x) = y$ for all $(x,y) \in X \times Y$ . Finally, note that by “partial function” we do mean a possibly total function, otherwise we will say properly partial.

The semantics of a program p is the partial function denoted by $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}$ . A program p computes a partial function f in case $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}$ is identical to f as a partial function. A program p accepts a set X in case X is the domain of convergence of $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}$ . Finally, a boolean-valued program p decides a set X if it computes the characteristic function of X.

A partial function computed by a program may in general have a dependent type. Given a type $\alpha$ and family of types $\beta(x)$ indexed by $x : \alpha$ , we will refer to the dependent sum type $\sum_{x : \alpha} \beta(x)$ and the dependent product type $\prod_{x : \alpha} \beta(x)$ . (When $\beta$ does not depend on x, these reduce to $\alpha\times\beta$ and $\alpha \to \beta$ respectively.) The language of dependent types provides an elegant formulation for counting modules, but we do not use the machinery of dependent types in any essential way.

A note on functional complexity. Suppose that $f : 2^\star \to 2^\star$ is contained in the class FP of polynomial-time computable functions. Consider the function $f_\ell : 2^\star \to 1^\star$ defined by $f_\ell (x) = |f(x)|$ , i.e., the length of f(x). Then, $f_\ell$ is also in FP; take, for example, any Turing machine computing f in polynomial time and identify all the characters of its output alphabet. Similarly, consider the function $f_b : 2^\star \times 1^\star \to 2$ defined by $f_b(x,i) = \big( f(x) \big)_i$ , meaning the $i^{\mathrm{th}}$ -bit of f(x), for any $x \in 2^\star$ and $i < |f(x)|$ . This relation is computable in polynomial time as well: on input (x,i), write f(x) on a work tape and extract the $i{\mathrm{th}}$ -bit. ^{Footnote 4}

All this is to say, roughly speaking, that if a function of type $2^\star \to 2^\star$ is computable in polynomial time, then so is its length function and its bits relation. We note that the converse implication is valid too. In other words, if $f_\ell$ and $f_b$ are both computable in polynomial time, then we can compute f in polynomial time by concatenating the bits $f_b(x,i)$ for each $i < f_\ell(x)$ .

In other words, we have reduced the notion of polynomial-time computability of functions of type $2^\star \to 2^\star$ to polynomial-time computability of relations and of functions $2^\star \to 1^\star$ . What do we gain from this? We get some characterization of polynomial-time computability of functions $2^\star \to 2^\star$ in terms of cons-free programs. (Cons-free programs can handle data of type $1^\star$ with counting modules, a device for reckoning with natural number quantities bounded by a polynomial in the length of the input.) So the polynomial-time computability of $f : 2^\star \to 2^\star$ may be witnessed by two cons-free programs: one with string input and counting module output computing the length and another with string and counting module input and boolean outputs, computing the bits. We shall elaborate on this later.

The observations we have made about polynomial time apply respectively to logarithmic space and tail-recursive cons-free programs. The proof is slightly different: notice that if $f : 2^\star \to 2^\star$ is in FL, then we cannot compute $f_b(x,i)$ by writing f(x) on a work tape, because it will be too long, in general. However, there is a well-known trick in space complexity to circumvent this, viz., replacing the write-only output tape by a work tape that records only the position of the head. Similarly, when computing f(x) using $f_b$ and $f_\ell$ , we compute $f_\ell(x)$ in binary, which compresses it enough to stick it on a work tape.

We compile these observations into an official and easily referenced theorem.

3 RW-factorizable programs

Let us work over the set $2^\star$ of binary strings. Consider the following set of string primitives ^{Footnote 5}

• $\mathtt{hd}$ , denoting the head function, of type $2^\star \rightharpoonup 2$ ,

• $\mathtt{tl}$ , the tail function, of type $2^\star \rightharpoonup 2$

• $\mathtt{null}$ , the empty test, of type $2^\star \to 2$

• $\mathtt{nil}$ , a constant naming the empty string, of type $2^\star$ , and

• $\mathtt{cons}$ , a binary function prepending a given character onto a given string, of type $2 \times 2^\star \to 2$ .

Now, consider two separate copies of $2^\star$ , viz., R, whose strings are read-only, and W, whose strings are write-only. Then, we may retype these primitives, replacing each occurrence of $2^\star$ by either R or W as follows:

$$ \mathtt{hd} : R \rightharpoonup 2,\hspace{5pt} \mathtt{tl} : R \rightharpoonup R,\hspace{5pt}\mathtt{null} : R \to 2,\hspace{5pt} \mathtt{nil} : W,\hspace{5pt} \mathtt{cons}: 2 \times W \to W.$$

Note that this typing is consistent with strings in R being “read-only” and strings in W being “write-only.”

From these primitives, we construct a simple first-order programming language. First we define the types, then terms, of our programming language, then we define the programs themselves; finally, we equip these programs with an environment-based big-step semantics.

Definition 1. The three atomic types are 2, R, and W, denoting the type of booleans, read-only strings, and write-only strings, respectively. A product type is any expression of the form $\tau_0 \times \dots \times \tau_{n-1}$ , for $n \ge 0$ , where each $\tau_i$ is either 2 or R. (W is excluded from product formation.) When $n=0$ , the product is empty. We extend the type constructor $\times$ to apply to product types by

$$ (\tau_0 \times \dots \times \tau_{n-1}) \times (\tau_n \times \dots \times \tau_{m-1}) = \tau_0 \times \dots \times \tau_{m-1} . $$

A function type symbol is an expression of one of the following forms

$$ \beta \to \alpha,\hspace{5pt} \beta \to W,\hspace{5pt} \beta \times W \to W, $$

where $\beta$ and $\alpha$ are product types, and $\alpha$ is nonempty.

By a variable, we mean any member of any $\mathtt{Var}_\alpha$ , or the symbol $\mathtt{w}$ , which is the sole variable of type W. By a recursive function symbol, we mean any member of one of the sets $\mathtt{RFsymb}_{\beta \to W}$ or $\mathtt{RFsymb}_{\beta \times W \to W}$ , for any $\beta, W$ .

Definition 3. An RW term is any expression that can be derived according to the inference rules in Figure 1.

Fig 1. RW-terms. Letters $\alpha$ , $\beta$ , and each $\alpha_i$ range over product types and each $\tau_i$ ranges over the atomic types 2 and R.

It is straightforward to show that any RW term has a unique derivation from these inference rules, and that if an RW term contains any subterm of type W, it must itself have type W.

Notice that we restrict the way that W terms can occur: there is only one variable of type W and recursive function symbols of output type W have at most one W input. This restriction, which we may refer to as the W-thinness of RW terms, does not ultimately limit the expressive power of the resulting language. Roughly speaking, this is because a W datum is a sort of black box: no information can flow out of it and it cannot affect the shape of a computation. Think of it as a write-only output tape of a Turing machine: a single write-only output tape suffices.

Notice also that to be non-nested we only forbid nested recursive calls of output type W. (Surprisingly, we can always eliminate nested recursive calls in the purely cons-free part of a program, though we will not need this result in the present paper.)

However, consider a transformation $T \mapsto T^\diamond$ on terms that uses the recursive functions of a previously defined tail-recursive program $p^ \unicode{x2020}$ . In arguing that $T \mapsto T^\diamond$ preserves tail recursion, it suffices to treat calls to the recursive functions of $p^ \unicode{x2020}$ like calls to the primitives as opposed to other recursive calls. ^{Footnote 6}

Definition 5. An RW-factorizable program consists of a finite list of distinct recursive function symbols $(\mathtt{f}_0,\dots,\mathtt{f}_k)$ and a definition for each one, which takes one of the following two forms:

$$ \mathtt{f}_i(\mathtt{x}_i,\mathtt{w}) = T_i \ \text{ or }\ \mathtt{f}_i(\mathtt{x}_i) = T_i,$$

where $T_i$ is a RW-term, $\mathtt{x}_i$ is a variable, and every recursive function symbol that occurs in $T_i$ must be one of $(\mathtt{f}_0,\dots,\mathtt{f}_k)$ . Furthermore

• If the definition of $\mathtt{f}_i$ is of the form $\mathtt{f}_i(\mathtt{x}_i,\mathtt{w}) = T_i$ , then $\mathtt{f}_i(\mathtt{x}_i,\mathtt{w})$ must be a well-formed RW term of the same type as $T_i$ , and the only variables that may occur in $T_i$ are $\mathtt{x}_i$ and $\mathtt{w}$ .

• If the definition of $\mathtt{f}_i$ is of the form $\mathtt{f}_i(\mathtt{x}_i) = T_i$ , then $\mathtt{f}_i(\mathtt{x}_i)$ must be a well-formed RW term of the same type as $T_i$ , and the only variable that may occur in $T_i$ is $\mathtt{x}_i$ .

The head (term) of a program is the left-hand side of its first line, e.g., $\mathtt{f}_0(\mathtt{x}_0)$ or $\mathtt{f}_0(\mathtt{x}_0,\mathtt{w})$ . A program is cons-free in case all terms occurring within are cons-free.

We equip programs with a standard, call-by-value, environment-based big-step semantics. By a value, we mean an element of the domain of some type, and by an environment, we mean a finite function mapping variables to values.

Definition 6. For a program p, term T, value v of the same type as T, and environment $\rho$ , we define the relation $\rho \vdash_p T \to v$ according to the inference rules in Figure 2. We typically suppress the subscript p from $\vdash$ for legibility.

Fig. 2. Program Semantics. In the bottom two rules, $\mathtt{f}(\mathtt{x}) = T^\mathtt{f}$ or $\mathtt{f}(\mathtt{x},\mathtt{w}) = T^\mathtt{f}$ is the recursive definition of $\mathtt{f}$ in p. Also, w ranges over values of type W; r and r’ range over values of type R; b ranges over values of type 2; the $a_i$ range over values of type 2 and R; v, v’, $v_i$ range over values of any product type; and u ranges over values of any type. The value $v_0 \circ \dots \circ v_{n-1}$ denotes concatenation of the constituent tuples. For example if $v_0 = (a_0,a_1)$ and $v_1 = (a_2,a_3,a_4)$ then $v_0 \circ v_1 = (a_0, a_1, a_2, a_3, a_4)$ . In general we will not carefully maintain this correspondence between variable names and their types.

Note that the relation $\vdash_p$ is independent of the head of p; it is only when defining $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}$ that we care what the head is. ^{Footnote 7} Aside from specifying the head, neither $\vdash_p$ nor $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}$ is sensitive to the particular order of the recursive function symbols in a program; it is only because of overwhelming programming intuition that we say a list instead of a set of function symbols.

In subsequent sections, we will define programs by extending previously defined programs with additional recursive function symbols and their definitions. This simply means: take the old program, forget what its head is, add new lines to the program—we don’t care in what order—and pick a new head according to the definition at hand. If q is the old program and p the new one, notice that $\vdash_p$ extends $\vdash_q$ .

4 Bit-length programs

In this section, we construct a dialect of cons-free programs and use them to define function computability in the manner sketched in Section 2. In other words, two programs are needed to witness the computability of a function $f:2^\star \to 2^\star$ in polynomial time: one that computes the bits of f and the other that computes the length. Hence, we call these programs (rather unimaginatively) bit-length (or BL) programs.

The bit-length dialect differs from the standard cons-free language in two ways. The first difference is to replace R-data with string indices as follows. Imagine a cons-free program with a single string input. Then any string constructed during computation will be a suffix of that input. Instead, we might as well consider indices of the input string. Instead of querying the head of the various string suffixes, we query the bit of the input string at the given index.

The second difference is that counting modules—a type of natural numbers with magnitude bounded polynomially in the length of the input—are treated as a separate data type, a dependent type which varies with the length of the input string, as opposed to syntactic sugar.

Each of these modifications confers an advantage. Replacing R values by string indices lends a sort of extensional compositionality to bit-length programs that RW-factorizable programs lack. Meaning, the pair of programs computing a function transforms the same type of information about the input (its bits and length, given by the index primitives) into the same type of information about the output (its bits and length, given by the two programs). Moreover, a careful treatment of counting modules allows for cleaner representation strings in $1^\star$ . (The relevance of unary strings to computation of functions was discussed in Section 2.)

We note that the original paper (Jones, Reference Jones1999) contains a language called $\mathtt{CM}$ for counter machine, which was used as a technical tool in the proofs of the main results of that paper. A variant, $\mathtt{CM}^\mathit{rec-poly}$ , is basically identical to our bit-length language. However, our presentation is different enough to justify a separate treatment. For one, CM and its variants are imperative instead of functional. Secondly, indices and counting modules are conflated in CM, whereas we treat them as different types. A glossary between the present paper and (Jones, Reference Jones1999) can be found in Table 1. ^{Footnote 8}

Table 1. A correspondence between languages in the present paper on the left and Jones (Reference Jones1999) on the right. A bit-length program is C-free if it contains no counting modules

As for RW programs, we explain bit-length programs first by discussing types, then terms, then programs, and finally semantics.

Notice that C and I are dependent types; namely, they are families of types indexed by some other value (natural numbers or binary strings). Now we introduce program syntax.

Definition 12. Fix an infinite set $\mathtt{Var}_\alpha$ of variables of type $\alpha$ , for each BL-type $\alpha$ , and an infinite set $\mathtt{RFsymb}_{\beta \to \alpha}$ of BL-function symbols of type $\beta \to \alpha$ , for each function type $\beta \to \alpha$ . Then, a bit-length term is any expression which can be derived according to the inference rules in Figure 3.

Fig 3. Bit/length terms. Here $\alpha$ ranges over product types and $\tau$ over atomic types.

Definition 15. For any bit-length program p, input string $x \in 2^\star$ , seed $n \in \omega$ , term T of type $\alpha$ , environment $\rho$ binding the free variables of T, and value v of type $\alpha(x,n)$ , we define the relation

$$ x, n, \rho \vdash_p T \to v$$

according to the inference rules in Figure 4. Note that there is at most one v satisfying the above relation for each x, n, $\rho$ , p, and T, which means that p is deterministic.

Fig 4. Semantics for bit-length programs. Dependence of $\vdash$ on x, n, and $\rho$ is suppressed for legibility. $\mathtt{f}(\mathtt{x}^\mathtt{f}) = T^\mathtt{f}$ is the recursive definition of $\mathtt{f}$ in p and $x_i$ is the i-th bit of $x = x_{|x|} \dots x_1$ . Variables c and d range over C(n), i ranges over I(x), the $a_i$ range over values in any atomic type, and v, v’ and the $v_i$ range over values of any type. In general we will not carefully maintain this correspondence between variables and their types. As in RW-factorizable programs, note that while we can form larger tuples from smaller proper tuples, we can only decompose tuples into atomic types.

Definition 16. For any program p and function $\lambda : \omega \to \omega$ , we define the relation $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x,y) = w$ by

$$x,\lambda(|x|),[\mathtt{x}_0 = y] \vdash_p \mathtt{f}_0(\mathtt{x}_0) \to w,$$

where $\mathtt{f}_0(\mathtt{x}_0) = T_0$ is the head of p. By the determinism of p, $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda$ is a partial function.

Note that the string variable x becomes the first argument of $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda$ . Therefore, if we want to compute a function which has a single string input by a bit-length program, the head of that program must be nullary, i.e., have zero inputs.

Definition 17. Fix a string x, natural number n, and program p, and let $\rho \vdash T \to v$ mean $x,n,\rho \vdash_p T \to v$ . A collision is an occurrence of an inference rule of the form

such that $\min\{v+w,n\} = n$ , in a derivation formed from the inference rules in Figure 4. We say a derivation of $\rho \vdash T \to v$ is collision-free in case it contains no collisions.

Informally, a collision occurs when an addition operation attempts to overstep (or even meet) the maximum integer bound n in a derivation. The nice thing about collision-free derivations is that they are oblivious to this bound.

Proof. Notice that in the inference rules of Figure 4, a collision is the only instance in which the conclusion depends on n. Hence if we take a collision-free derivation and increase n, it is still a valid derivation.

Finally, let us discuss the type of the partial function computed $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda$ by a bit-length program p, which will in general be a dependent product type. Suppose the recursive function symbol $\mathtt{f}_0$ in the head of program p has type $\beta \to \alpha$ . Then, the type of $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda$ is

$$\prod_{x:2^\star} \big( \beta(x,\lambda(|x|)) \to \alpha(x,\lambda(|x|)) \big).$$

We identify two important special cases. When $\beta$ is the empty tuple and $\alpha = C$ , then

$$\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda : \prod_{x : 2^\star} C(\lambda(|x|)).$$

On the other hand, when $\alpha = 2$ and $\beta = C$ , then

$$ \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda : \sum_{x:2^\star} C(\lambda(|x|)) \to 2. $$

(Note that when both $\beta$ is empty and $\alpha =2$ , then $ \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda : 2^\star \to 2$ .)

5 Bit-length computability of functions

The following theorem is a restatement of the theorems $\mathtt{TM}^\mathit{ptime} \equiv \mathtt{CM}^\mathit{rec-poly}$ and $\mathtt{TM}^\mathit{logspace} \equiv \mathtt{CM}^\mathit{poly}$ from Jones (Reference Jones1999).

Theorem. Let f be any function of type $2^\star \to 2$ . Then, the following are equivalent:

• f is computable in polynomial time.

• There is a polynomially bounded function $\lambda : \omega \to \omega$ and bit-length program p such that $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x) = f(x)$ , without collisions, for any $x \in 2^\star$ .

We get an analogous result by replacing FP with FL and “bit-length program” with “tail-recursive bit-length program” throughout.

We use the following extension of this theorem. The basic observation is that the simulations of Turing machines by programs can be augmented by counting modules that keep track of the lengths of tapes or what comes to the same thing, unary strings. So the simulation extends to Turing machines which return unary strings as output. We sketch the proof in Appendix B.

For any function $f : 2^\star \times 1^\star \to 2$ and polynomially bounded function $\pi : \omega \to \omega$ , the following are equivalent:

• There is a polynomial-time computable function $g : 2^\star \times 1^\star \to 2$ such that $g(x,y) = f(x,y)$ for any string $x \in 2^\star$ and $y \le \pi(|x|)$ .

• There is a polynomially bounded function $\lambda : \omega \to \omega$ and a bit-length program p such that $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x,y) = f(x,y)$ , without collisions, for any $x \in 2^\star$ and $y \le \pi(|x|)$ .

Moreover, we get an analogous result by replacing FP with FL and “bit-length program” with “tail-recursive bit-length program” throughout.

Note that the recursive function symbol $\mathtt{f}_0$ in the head of the program p should have type C if $f : 2^\star \to 1^\star$ and type $C \to 2$ if $f : 2^\star \times 1^\star \to 2$ .

Combining Theorems 1 and 2, we are able to show the fundamental property of bit-length programs; namely that a function is computable in polynomial time iff there is a pair of bit-length programs computing the length and bits of f, respectively. Similarly, a function is computable in logarithmic space iff there is a pair of tail-recursive bit-length programs computing the length and bits of f respectively.

Theorem 3. For any function $f : 2^\star \to 2^\star$ , f is computable in polynomial time if and only if there is a polynomially bounded function $\lambda : \omega \to \omega$ such that $|f(x)| < \lambda(|x|)$ for all $x \in 2^\star$ and a pair of bit-length programs p and q such that

$$ |f(x)| = \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{q}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x) $$

without collisions, for all $x \in 2^\star$ , and additionally for any $i < |f(x)|$ ,

$$ \big( f(x) \big)_i = \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda (x,i) $$

without collisions, where $\big( f(x) \big)_i$ is the $i\mathrm{th}$ -bit of f(x).

Furthermore, we get the analogous result for logarithmic space by requiring that p and q be tail-recursive.

Proof We go through the proof in the polynomial-time case; the proof for the logarithmic-space case is verbatim, replacing “program” by “tail-recursive program” throughout.

Suppose $f : 2^\star \to 2^\star$ is computable in polynomial time. By Theorem 1, there exist polynomial-time computable functions $f_\ell: 2^\star \to 1^\star$ and $f_b:2^\star \times 1^\star \to 2$ such that, for all $x \in 2^\star$ $f_\ell(x) = |f(x)|$ , and additionally for each $i < |f(x)|$ , $f_b(x,i) = \big( f(x) \big)_i$ . Let $\pi$ be a polynomially bounded function such that $|f(x)|< \pi(|x|)$ .

By Theorem 2 applied to $f_\ell,$ there is a polynomially bounded function $\lambda_1$ and a bit-length program q such that $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{q}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_{\lambda_1}(x) = f_\ell(x)$ , without collisions, for any string x. By Theorem 2 applied to $f_b$ , there is a polynomially bounded function $\lambda_2$ and a bit-length program p such that $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_{\lambda_2}(x,i) = f_b(x,i)$ , without collisions, for any string x and $i < \pi(|x|)$ . Let $\lambda$ be a polynomially bounded function dominating both $\lambda_1$ and $\lambda_2$ . By Remark 7 concerning collision-free computation, we can replace $\lambda_1$ and $\lambda_2$ by $\lambda$ in the statements above. By definition of $f_\ell$ , $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{q}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x) = |f(x)|$ , for any string x. By definition of $f_b$ and since $\pi(|x|)$ dominates $|f(x)|$ , n the other direction, suppose we ha for any string x and $i < |f(x)|$ . This concludes the forward direction.

In the other direction, suppose we have a bound $\lambda$ and programs p and q satisfying the desired properties. Then by Theorem 2, the function $x \mapsto |f(x)| : 2^\star \to 1^\star$ is computable in polynomial time. Fix a polynomially bounded function $\pi$ such that $|f(x)| < \pi(|x|)$ . Then by Theorem 2 again, there is a function $g : 2^\star \times 1^\star \to 2$ , computable in polynomial time, such that $g(x,i) = \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x,i)$ for every string x and $i < \pi(|x|)$ . (In particular, $g(x,i) = \big( f(x) \big)_i $ for every string x and $i < |f(x)|$ .) Finally, by applying Theorem 1 to $x \mapsto |f(x)|$ and g, we conclude that f is computable in polynomial time.

Theorem 3 suggests the following definition.

Then we say $(\lambda,p,q)$ properly computes f in case $\lambda$ is increasing, $|f(x)| < \lambda(|x|)$ for all $x \in 2^\star$ , $ \big( f(x) \big)_i = \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda (x,i) $ without collisions.

Then, Theorem 3 can be succinctly restated as follows: membership in FP is equivalent to being properly computed by some triple $(\lambda,p,q)$ with polynomially bounded $\lambda$ , and membership in FL is equivalent to being properly computed by some triple $(\lambda,p,q)$ with polynomially bounded $\lambda$ and p and q tail-recursive.

6 Compiling RW-factorizable to bit-length programs

We now show how to compile an RW-factorizable program into a pair of bit-length programs that properly computes the same function. This consists of four program transformations:

1. 1. The “dagger” transformation $ \unicode{x2020}$ , that translates the RW-terms without W into the bit-length variant without counting modules. (So, substrings of the input string are reinterpreted as indices, $\mathtt{hd}$ is reinterpreted as $\mathtt{bit}$ , $\mathtt{tl}$ is reinterpreted as $\mathtt{P}$ , etc.)

2. 2. The “diamond” transformation $\diamond$ that takes an RW-term T of type W into a bit-length term $T^\diamond$ of type 2, which detects whether T denotes a string built up from $\mathtt{w}$ or built up from $\mathtt{nil}$ .

3. 3. A “length” transformation $\ell$ that takes an RW-term T of type W into a bit-length term $T^\ell$ of type C computing the length of T.

4. 4. A “bit” transformation b that takes an RW-term T of type W into a bit-length term $T^b$ of type 2, which has an extra variable $\mathtt{c}$ and computes the bit of T at $\mathtt{c}$ .

Each of these transformations requires a translation of types, then terms and values, then programs, and finally a proof of correctness. ^{Footnote 9} Moreover, we need to observe that each transformation preserves tail recursion. For that reason, this section is long, even though the main idea of each translation is easy to intuit:

• The dagger transformation is straightforward, essentially amounting to a “renaming” of primitives.

• Operationally, when we evaluate a RW-term T of type W into a value v according to an environment $\rho$ , v is constructed by starting with either the empty string $\varepsilon$ or the string $w = \rho(\mathtt{w})$ and $\mathtt{cons}$ -ing various bits in front. The term $T^\diamond$ detects which of $\varepsilon$ or w v is “built up” from.

• Suppose p is an RW-factorizable program that contains a recursive function symbol $\mathtt{f}$ of type $\beta \times W \to W$ . Suppose that $\rho \vdash_p \mathtt{f}(T,S) \to v$ , $\rho \vdash_p \mathtt{f}(T,\mathtt{nil}) \to u$ and $\rho \vdash_p S \to w$ . Then, there are two possibilities. Either $v = uw$ , in which case

  • • $|v| = |u| + |w|$ , and

  • • $v_i = w_i$ (if $i \le |w|$ ), and otherwise is $u_{i - |w|}$ .

Otherwise $v = u$ , in which case $|v| = |u|$ and $v_i = u_i$ . Which case we are in is given to us by the diamond transformation.

The rest of the section essentially consists of making these intuitions formal.

6.1 The dagger transformation

The types in an RW-factorizable program are 2, R, and W. The types in a bit-length program are 2, I, and C. We first define a map from W-free types to bit-length types and then extend it to variables, recursive function symbols, terms, and programs.

Definition 19. Let $2^ \unicode{x2020} = 2$ and $R^ \unicode{x2020} = I$ , and extend this to product and function types coordinate-wise.

Definition 20. For RW variables $\mathtt{x}$ not of type W and function symbols $\mathtt{f}$ not containing any type W, let $\mathtt{x} \mapsto \mathtt{x}^ \unicode{x2020}$ and $\mathtt{f} \mapsto \mathtt{f}^ \unicode{x2020}$ be a map from RW-factorizable variables and function symbols into bit-length variables and function symbols, so that for example, if $\mathtt{x}$ is of type $\tau$ , then $\mathtt{x}^ \unicode{x2020}$ is of type $\tau^ \unicode{x2020}$ . (We may assume these maps are injective.)

Definition 21. Define a map $T \mapsto T^ \unicode{x2020}$ from W-free RW-factorizable terms to bit-length terms by:

• If $T \equiv \mathtt{true}$ or $T \equiv \mathtt{false,}$ , then $T^ \unicode{x2020} \equiv T$ .

• If $T \equiv \mathtt{x}$ , then $T^ \unicode{x2020} \equiv \mathtt{x}^ \unicode{x2020}$ .

• If $T \equiv \mathtt{hd}(S)$ then $T^ \unicode{x2020} \equiv \mathtt{bit}(S^ \unicode{x2020})$ .

• If $T \equiv \mathtt{tl}(S)$ then $T^ \unicode{x2020} \equiv \mathtt{P}(S^ \unicode{x2020})$ .

• If $T \equiv \mathtt{null}(S)$ then $T^ \unicode{x2020} \equiv \mathtt{null}(S^ \unicode{x2020})$ .

• If $T \equiv T_0 \oplus \dots \oplus T_{n-1}$ then $T^ \unicode{x2020} \equiv T^ \unicode{x2020}_0 \oplus \dots \oplus T^ \unicode{x2020}_{n-1}$ .

• If $T \equiv S[i]$ then $T^ \unicode{x2020} \equiv S^ \unicode{x2020} [i]$ .

• If $T \equiv \mathtt{if}\ T_0\ \mathtt{then}\ T_1\ \mathtt{else}\ T_2$ , then $T^ \unicode{x2020} \equiv \mathtt{if}\ T^ \unicode{x2020}_0\ \mathtt{then}\ T^ \unicode{x2020}_1\ \mathtt{else}\ T^ \unicode{x2020}_2$ .

• If $T \equiv \mathtt{f}(S)$ then $T^ \unicode{x2020} \equiv \mathtt{f}^ \unicode{x2020}(S^ \unicode{x2020})$ .

Notice that this transformation trivially preserves tail recursion.

Definition 22. For a cons-free program $p = (\mathtt{f}_i(\mathtt{x}_i) = T_i)_{0 \le i \le k}$ , let the bit-length program $p^ \unicode{x2020}$ be $ (\mathtt{f}^ \unicode{x2020}_i(\mathtt{x}_i^ \unicode{x2020}) = T^ \unicode{x2020}_i)_{0 \le i \le k}$ . Note that $p^ \unicode{x2020}$ is a well-formed program which is tail-recursive if p is.

Finally, we extend $ \unicode{x2020}$ to a map on values. Note that the type of the map $y \mapsto y^ \unicode{x2020} : R \to I(x)$ depends on an “ambient string” x of which y is a suffix.

Definition 23. For any $b \in 2$ , let $b^ \unicode{x2020} = b$ . For any string $x \in 2^\star$ and any nonempty suffix y of x, let $y^ \unicode{x2020} = |y|$ (as a member of I(x)). Furthermore,

• Extend the map to tuples of data coordinate-wise, i.e., if $v=(v_0,\dots,v_{n-1})$ is a decomposition of v into atomic types, then $v^ \unicode{x2020} = (v_0^ \unicode{x2020},\dots,v_{n-1}^ \unicode{x2020})$ . Note that $(u \circ v)^ \unicode{x2020} = u^ \unicode{x2020} \circ v^ \unicode{x2020}$ , where $\circ$ denotes concatenation.

• For an environment $\rho$ , define the environment $\rho^ \unicode{x2020}$ by $\rho(\mathtt{x}) = v \iff \rho^ \unicode{x2020}(\mathtt{x}^ \unicode{x2020}) = v^ \unicode{x2020}$ . (By this, we mean that the domain of $\rho^ \unicode{x2020}$ is the $ \unicode{x2020}$ -image of the domain of $\rho$ .)

Next, we prove correctness of the dagger translation.

Definition 24. Let $\rho$ be an RW environment, i.e., a partial, finite map from RW variables to RW data. For a string $x \in 2^\star$ , we say that $\rho$ is an x-environment in case for every variable $\mathtt{x}$ of type R, $\rho(\mathtt{x})$ is a suffix of x, and similarly, for every variable $\mathtt{x}$ of product type $\tau_0 \times \dots \tau_{n-1}$ , $\rho(\mathtt{x})[i]$ is a suffix of x whenever $\tau_i = R$ .

Remark 8. Suppose p is RW-factorizable program, $\rho$ is an x-environment, T is a cons-free term, and $\rho \vdash_p T \to v$ . Then, every R value that appears in the derivation of $\rho \vdash T \to v$ must also be a suffix of x.

The proof of the next lemma is postponed to Appendix A.

Lemma 2. Suppose p is a cons-free program, x is a string, $\rho$ is an x-environment. Then,

$$\rho \vdash_p T \to v \implies x, \rho^ \unicode{x2020} \vdash_{p^ \unicode{x2020}} T^ \unicode{x2020} \to v^ \unicode{x2020}.$$

Example Consider the program p defined by

\begin{align*} \mathtt{evt}(\mathtt{y}) &= \mathtt{if}\ \mathtt{null}(\mathtt{y})\ \mathtt{then}\ \mathtt{true}\ \mathtt{else}\ \mathtt{if}\ \mathtt{hd}(\mathtt{y})\ \mathtt{then}\ \mathtt{odt}(\mathtt{tl}\ \mathtt{y})\ \mathtt{else}\ \mathtt{evt}(\mathtt{tl}\ \mathtt{y}) \\ \mathtt{odt}(\mathtt{y}) &= \mathtt{if}\ \mathtt{null}(\mathtt{y})\ \mathtt{then}\ \mathtt{false,}\ \mathtt{else}\ \mathtt{if}\ \mathtt{hd}(\mathtt{y})\ \mathtt{then}\ \mathtt{evt}(\mathtt{tl}\ \mathtt{y})\ \mathtt{else}\ \mathtt{odt}(\mathtt{tl}\ \mathtt{y}).\end{align*}

Then, $\mathtt{evt}$ and $\mathtt{odt}$ compute whether the number of occurrences of the character $\mathtt{true}$ in the string $\mathtt{y}$ is even or odd, respectively. The program $p^ \unicode{x2020}$ is defined by

\begin{align*} \mathtt{evt}^ \unicode{x2020}(\mathtt{y}^ \unicode{x2020}) &= \mathtt{if}\ \mathtt{null}(\mathtt{y}^ \unicode{x2020})\ \mathtt{then}\ \mathtt{true}\ \mathtt{else}\ \mathtt{if}\ \mathtt{bit}(\mathtt{y}^ \unicode{x2020})\ \mathtt{then}\ \mathtt{odt}^ \unicode{x2020}(\mathtt{P} (\mathtt{y}^ \unicode{x2020}))\ \mathtt{else}\ \mathtt{evt}^ \unicode{x2020}(\mathtt{P} (\mathtt{y}^ \unicode{x2020})) \\ \mathtt{odt}^ \unicode{x2020}(\mathtt{y}^ \unicode{x2020}) &= \mathtt{if}\ \mathtt{null}(\mathtt{y}^ \unicode{x2020})\ \mathtt{then}\ \mathtt{false,}\ \mathtt{else}\ \mathtt{if}\ \mathtt{bit}(\mathtt{y}^ \unicode{x2020})\ \mathtt{then}\ \mathtt{evt}^ \unicode{x2020}(\mathtt{P} (\mathtt{y}^ \unicode{x2020}))\ \mathtt{else}\ \mathtt{odt}^ \unicode{x2020}(\mathtt{P} (\mathtt{y}^ \unicode{x2020})).\end{align*}

Notice that $\mathtt{evt}^ \unicode{x2020}$ and $\mathtt{odt}^ \unicode{x2020}$ compute whether the number of occurrences of $\mathtt{true}$ with index at most $ \mathtt{y}^ \unicode{x2020}$ in the input string is even or odd respectively. Thus, if $\mathtt{y}$ is bound to a suffix y of some string x, then $\mathtt{evt}$ and $\mathtt{odt}$ behave the same on input y as $\mathtt{evt}^ \unicode{x2020}$ and $\mathtt{odt}^ \unicode{x2020}$ behave on input $y^ \unicode{x2020}$ (the index $|y|$ ) with global input x.

6.2 The diamond transformation

These next three transformations each extend the dagger transformation from pure cons-free terms to terms of type W in different ways. In the diamond transformation, we will transform terms of type W into terms of type 2, the idea being that the transformed term will encode which of $\mathtt{nil}$ or $\mathtt{w}$ the original term is built up from.

Definition 25. . For each recursive function symbol $\mathtt{f} : \beta \times W \to W$ , let $\mathtt{f}^\diamond$ be a recursive function symbol of type $\beta^ \unicode{x2020} \to 2$ . (We may assume that the map $\mathtt{f} \mapsto \mathtt{f}^\diamond$ is injective.)

Definition 26. We define a transformation $T \mapsto T^\diamond$ from RW terms of type W to bit-length terms of type 2 as follows:

• If $T \equiv \mathtt{w}$ , then $T^\diamond \equiv \mathtt{false,}$ .

• If $T \equiv \mathtt{nil}$ , then $T^\diamond \equiv \mathtt{true}$ .

• If $T \equiv \mathtt{if}\ T_0\ \mathtt{then}\ T_1\ \mathtt{else}\ T_2$ then $T^\diamond \equiv \mathtt{if}\ T_0^ \unicode{x2020}\ \mathtt{then}\ T_1^\diamond\ \mathtt{else}\ T_2^\diamond$ .

• If $T \equiv \mathtt{f}(T')$ for some $\mathtt{f} : \beta \to W$ , then $T^\diamond \equiv \mathtt{true} $ .

• If $T \equiv \mathtt{f}(T',S)$ for some $\mathtt{f} : \beta \times W \to W$ , then $T^\diamond \equiv \mathtt{if}\ S^\diamond\ \mathtt{then}\ \mathtt{true} \ \mathtt{else}\ \mathtt{f}^\diamond((T')^ \unicode{x2020})$

• If $T \equiv \mathtt{cons}(T',S)$ then $T^\diamond \equiv S^\diamond$ .

Remark 9. This transformation transforms tail-recursive terms into tail-recursive terms. It never produces a primitive call, and the only things it puts inside recursive calls are outputs of the $ \unicode{x2020}$ transformation. The only way it possibly produces a non-tail-recursive term is in the case $T \equiv \mathtt{f}(T',S)$ , when $S^\diamond$ goes in an if clause. But if T is tail-recursive, S is explicit, so $S^\diamond$ is explicit, hence contains no recursive function calls.

Definition 27. Given an RW-factorizable program p of type $R \to W$ , we define the bit-length program $p^\diamond$ by extending $p^ \unicode{x2020}$ as follows. For every function symbol $\mathtt{f}_i$ of type $ \beta \times W \to W$ with definition $\mathtt{f}_i(\mathtt{x}_i,\mathtt{w}) = T_i$ , we add a new line $ \mathtt{f}_i^\diamond(\mathtt{x}_i^ \unicode{x2020}) = T_i^\diamond. $ Note that $p^\diamond$ is tail-recursive if p is.

We ignore function symbols of type $\beta \to W$ . Also, we do not bother to specify a head, because we will only need $\vdash_{p^\diamond}$ , not $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p^\diamond}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}$ .

Note that $p^\diamond$ is a well-formed program: its recursive function symbols consist exactly of $\mathtt{f}_i^ \unicode{x2020}$ for $\mathtt{f}_i$ of type non-W and $\mathtt{f}_i^\diamond$ for $\mathtt{f}_i$ of type $\beta \times W \to W$ . For the latter, the term $\mathtt{f}_i^\diamond(\mathtt{x}_i^ \unicode{x2020})$ is well-formed and of the same type as $T_i^\diamond$ . The only variable that may occur in $T_i^\diamond$ is $\mathtt{x}_i^ \unicode{x2020}$ . Notice as well that $p^\diamond$ contains no terms of type C. Hence, when specifying a semantics, we do not need to give a natural number bound n on the upper end of the counting module. Suppose that p is an RW-factorizable program, T is an RW term, $x, v, v',w \in 2^\star$ , $\rho$ is an x-environment, and $\mathtt{w}$ is not bound by $\rho$ .

Lemma 3. Suppose that $\rho,[\mathtt{w} = w] \vdash_p T \to v$ and $\rho,[\mathtt{w} = \varepsilon] \vdash_p T \to v'$ . ^{Footnote 10} Then either

• $x, \rho^ \unicode{x2020} \vdash_{p^\diamond} T^\diamond \to \top $ and $v = v'$ , or

• $x, \rho^ \unicode{x2020} \vdash_{p^\diamond} T^\diamond \to \bot $ and $v = v'w$ .

(The proof is postponed to Appendix A.)

In particular, Lemma 3 implies that for any x, x-environment $\rho$ , w, and term T, if there exists a v such that $\rho,[\mathtt{w} =w] \vdash T \to v$ , then there exists a boolean b such that $x,\rho^ \unicode{x2020} \vdash_{p^\diamond} T^\diamond \to b$ . We will silently use this fact in the remainder of this paper.

Example Consider the program $\mathit{id}$ defined by

\begin{align*} \mathtt{id}(\mathtt{x}) &= \mathtt{cat}(\mathtt{x},\mathtt{nil}) \\ \mathtt{cat}(\mathtt{x},\mathtt{w}) &= \mathtt{if}\ \mathtt{null}(\mathtt{x})\ \mathtt{then}\ \mathtt{w}\ \mathtt{else}\ \mathtt{cons}(\mathtt{hd}\ \mathtt{x},\mathtt{cat}(\mathtt{tl}\ \mathtt{x},\mathtt{w})),\end{align*}

which computes the identity function of type $R \to W$ . Both $\mathtt{id}$ and $\mathtt{cat}$ have output type W; note that $\mathtt{id}$ always builds its output from $\mathtt{nil}$ and $\mathtt{cat}$ always builds its output from the input $\mathtt{w}$ . Then,

\begin{align*} \mathtt{id}^\diamond(\mathtt{x}^ \unicode{x2020}) &= \mathtt{true} \\ \mathtt{cat}^\diamond(\mathtt{x}^ \unicode{x2020}) &= \mathtt{if}\ \mathtt{null}(\mathtt{x}^ \unicode{x2020})\ \mathtt{then}\ \mathtt{false,}\ \mathtt{else}\ \mathtt{if}\ \mathtt{false,}\ \mathtt{then}\ \mathtt{true}\ \mathtt{else}\ \mathtt{cat}^\diamond(\mathtt{P}(\mathtt{x}^ \unicode{x2020})).\end{align*}

We can see that $\mathtt{id}^\diamond$ and $\mathtt{cat}^\diamond$ compute the always-true and always-false functions, respectively, as they ought to. Note that the dagger and diamond transformations produce C-free BL-terms. By contrast, the subsequent two transformations make crucial use of counting modules.

6.3 The length transformation

In the length transformation, we will be transforming terms of type W into terms of type C. Since the length of any W output of an RW-factorizable program is bounded by a polynomial in the length of the inputs, it makes sense to try to capture the length within a counting module.

Definition 28. For each recursive function symbol $\mathtt{f}$ of type $\beta \times W \to W$ or $\beta \to W$ , let $\mathtt{f}^\ell$ be a recursive function symbol of type $\beta^ \unicode{x2020} \to C$ . (We may assume that the map $\mathtt{f} \mapsto \mathtt{f}^\ell$ is injective.)

Definition 29. We define a transformation $T \mapsto T^\ell$ from RW-terms of type W to bit-length terms of type C as follows:

• If $T \equiv \mathtt{w}$ or $T \equiv \mathtt{nil}$ , then $T^\ell \equiv 0$ .

• If $T \equiv \mathtt{if}\ T_0\ \mathtt{then}\ T_1\ \mathtt{else}\ T_2$ , then $T^\ell \equiv \mathtt{if}\ T^ \unicode{x2020}_0\ \mathtt{then}\ T_1^\ell\ \mathtt{else}\ T_2^\ell$ .

• If $T \equiv \mathtt{f}(T')$ , then $T^\ell \equiv \mathtt{f}^\ell((T')^ \unicode{x2020})$ .

• If $T \equiv \mathtt{f}(T',S)$ , where S has type W, then

  $$ T^\ell \equiv \mathtt{if}\ \mathtt{f}^\diamond((T')^ \unicode{x2020})\ \mathtt{then}\ \mathtt{f}^\ell((T')^ \unicode{x2020})\ \mathtt{else}\ \mathtt{f}^\ell((T')^ \unicode{x2020}) + S^\ell.$$

• If $T \equiv \mathtt{cons}(T',S)$ , then $T^\ell \equiv 1 + S^\ell$ .

Remark 10. This transformation does not preserve tail recursion, the problem being $\mathtt{f}^\ell((T')^ \unicode{x2020}) + S^\ell$ , where the recursive function symbol $\mathtt{f}^\ell$ occurs within the primitive $+$ . This can be fixed in a couple of ways. For one, we can observe that if T is tail-recursive then $T^\ell$ is linear recursive, which can always be transformed into an equivalent tail-recursive term (Greibach, 1975).

But there is an easier fix in this case: just give each $\mathtt{f}^\ell$ an extra input of type $\mathtt{c}$ , the idea being that the new $\mathtt{f}^\ell(T,\mathtt{c})$ is the old $\mathtt{f}^\ell(T) + \mathtt{c}$ . We have to change each recursive definition $\mathtt{f}^\ell(\mathtt{x}^ \unicode{x2020}) = T^\ell$ to $\mathtt{f}^\ell(\mathtt{x}^ \unicode{x2020},\mathtt{c}) = T^\ell + \mathtt{c}$ . Then $\mathtt{f}^\ell((T')^ \unicode{x2020}) + S^\ell$ becomes $\mathtt{f}^\ell((T')^ \unicode{x2020},S^\ell$ ), and this solves our problem.

Definition 30. Given an RW-factorizable program p of type $R \to W$ , we define the bit-length program $p^\ell$ by extending $p^\diamond$ by adding the following lines for each recursive function symbol of output type W:

Finally, add a new head $ \mathtt{h} = \mathtt{f}^\ell_0(\mathtt{max}) .$ The resulting program is $p^\ell$ ; it is tail-recursive if p is.

Let us check that $p^\ell$ is a well-defined bit-length program. In addition to $p^\diamond$ , it contains recursive function symbols $\mathtt{f}_i^\ell$ for $\mathtt{f}_i$ of output type W. If the only variables that may occur in $T_i$ are $\mathtt{x}_i$ and $\mathtt{w}$ , then the only variable that may occur in $T^\ell_i$ is $\mathtt{x}^ \unicode{x2020}_i$ , and the only recursive function symbols that may occur are the recursive function symbols listed above. Finally, the terms in each line are well-formed and the types of each recursive functions symbol and its definition agree. Finally, notice that since p has type $R \to W$ , $p^\ell$ has type C.

Definition 31. For a value v of type W, let $v^\ell = |v|$ .

Lemma 4. For every RW-program p of type $R \to W$ , RW term T from p of type W, strings x, v, and w, natural number $n > |v|$ , and x-environment $\rho$ binding $\mathtt{w}$ to w:

$$ \rho \vdash_p T \to v \implies x,n,\rho^ \unicode{x2020} \vdash_{p^\ell} T^\ell \to v^\ell - \delta ,$$

where $\delta = 0$ if $\rho^ \unicode{x2020} \vdash_\diamond T^\diamond \to \top $ or $\delta = |w|$ if $\rho^ \unicode{x2020} \vdash_\diamond T^\diamond \to \bot $ . Moreover, the derivation of the right-hand side is collision-free.

(The proof is postponed to Appendix A.)

Theorem 4. Suppose that p is an RW-factorizable program of type $ R \to W$ and suppose that $\lambda : \omega \to \omega$ satisfies

$$ (\forall x,w \in 2^\star)\, \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = w \implies | w | < \lambda(|x|) . $$

Then,

$$ (\forall x,w \in 2^\star)\, \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = w \implies \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p^\ell}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x) = |w|; $$

moreover, without collisions.

Proof Fix x and suppose that $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = w$ . Suppose $\mathtt{f}_0(\mathtt{x}_0)$ is the head of p. Then, $ [\mathtt{x}_0 = x] \vdash_p \mathtt{f}_0(\mathtt{x}_0) \to w, $ so by Lemma 4, since $\lambda(|x|) > w$ ,

$$ x, \lambda(|x|), [\mathtt{x}_0^ \unicode{x2020} = x^ \unicode{x2020}] \vdash_{p^\ell} \mathtt{f}_0^\ell(\mathtt{x}_0^ \unicode{x2020}) \to |w|$$

by a collision-free derivation. Therefore, since $x^ \unicode{x2020} = |x|$ (as a member of I(x)), and since $|x|$ is the denotation of $\mathtt{max}$ , we have

$$ x, \lambda(|x|) \vdash_{p^\ell} \mathtt{f}_0^\ell(\mathtt{max}) \to |w|. $$

Since $\mathtt{f}_0(\mathtt{max})$ is precisely the head of $p^\ell$ , we have $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p^\ell}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda (x) = |w|$ , which is what we wanted to prove.

Examples. Consider again the program $\mathit{id}$ given by

\begin{align*} \mathtt{id}(\mathtt{x}) &= \mathtt{cat}(\mathtt{x},\mathtt{nil}) \\ \mathtt{cat}(\mathtt{x},\mathtt{w}) &= \mathtt{if}\ \mathtt{null}(\mathtt{x})\ \mathtt{then}\ \mathtt{w}\ \mathtt{else}\ \mathtt{cons}(\mathtt{hd}\ \mathtt{x},\mathtt{cat}(\mathtt{tl}\ \mathtt{x},\mathtt{w})),\end{align*}

Then,

\begin{align*} \mathtt{id}^\ell(\mathtt{x}^ \unicode{x2020}) &= \mathtt{if}\ \mathtt{cat}^\diamond(\mathtt{x}^ \unicode{x2020})\ \mathtt{then}\ \mathtt{cat}^\ell(\mathtt{x}^ \unicode{x2020})\ \mathtt{else}\ \mathtt{cat}^\ell(\mathtt{x}^ \unicode{x2020})+0 \\ \mathtt{cat}^\ell(\mathtt{x}^ \unicode{x2020}) &= \mathtt{if}\ \mathtt{null}(\mathtt{x}^ \unicode{x2020})\ \mathtt{then}\ 0\ \mathtt{else}\ 1 + \big( \mathtt{if}\ \mathtt{cat}^\diamond(\mathtt{P}(\mathtt{x}^ \unicode{x2020}))\ \mathtt{then}\ \mathtt{cat}^\ell(\mathtt{P}(\mathtt{x}^ \unicode{x2020}))\ \mathtt{else}\\ &\mathtt{cat}^\ell(\mathtt{P}(\mathtt{x}^ \unicode{x2020})) + 0\big),\end{align*}

which is semantically equivalent to

\begin{align*} \mathtt{id}^\ell(\mathtt{x}^ \unicode{x2020}) &= \mathtt{cat}^\ell(\mathtt{x}^ \unicode{x2020}) \\ \mathtt{cat}^\ell(\mathtt{x}^ \unicode{x2020}) &= \mathtt{if}\ \mathtt{null}(\mathtt{x}^ \unicode{x2020})\ \mathtt{then}\ 0\ \mathtt{else}\ 1 + \mathtt{cat}^\ell(\mathtt{P}(\mathtt{x}^ \unicode{x2020})).\end{align*}

It’s now easy to see that for sufficiently large $\lambda$ , $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{\mathit{id}^\ell}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda (x) = |x|$ , as it ought to. (Recall that the head of $\mathit{id}^\ell$ is $\mathtt{id}^\ell(\mathtt{max})$ .)

Consider the following program $\mathit{leap}$ based off of modifying the program from line (1) in Section 1 to string data:

\begin{align*} \mathtt{leap}(\mathtt{x}) &= \mathtt{f}(\mathtt{x},\mathtt{nil}) \\ \mathtt{f}(\mathtt{x},\mathtt{w}) &= \mathtt{if}\ \mathtt{null}(\mathtt{x})\ \mathtt{then}\ \mathtt{cons}(\mathtt{true},\mathtt{w})\ \mathtt{else}\ \mathtt{f}(\mathtt{tl}\ \mathtt{x},\mathtt{f}(\mathtt{tl}\ \mathtt{x},\mathtt{w})).\end{align*}

Then for any string x, $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{\mathit{leap}}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x)$ is a $2^{|x|}$ -length string of only the character $\mathtt{true}$ . Now,

\begin{align*} \mathtt{leap}^\ell(\mathtt{x}^ \unicode{x2020}) =\ &\mathtt{if}\ \mathtt{f}^\diamond(\mathtt{x}^ \unicode{x2020})\ \mathtt{then}\ \mathtt{f}^\ell(\mathtt{x}^ \unicode{x2020})\ \mathtt{else}\ \mathtt{f}^\ell(\mathtt{x}^ \unicode{x2020}) + 0 \\ \mathtt{f}^\ell(\mathtt{x}^ \unicode{x2020}) =\ &\mathtt{if}\ \mathtt{null}(\mathtt{x}^ \unicode{x2020})\ \mathtt{then}\ 1 + 0\ \mathtt{else}\ \\ &\mathtt{if}\ \mathtt{f}^\diamond(\mathtt{P} \mathtt{x}^ \unicode{x2020})\ \mathtt{then}\ \mathtt{f}^\ell(\mathtt{P} \mathtt{x}^ \unicode{x2020})\ \mathtt{else}\ \mathtt{f}^\ell(\mathtt{P} \mathtt{x}^ \unicode{x2020}) + \\ &\big(\mathtt{if}\ \mathtt{f}^\diamond(\mathtt{P} \mathtt{x}^ \unicode{x2020})\ \mathtt{then}\ \mathtt{f}^\ell(\mathtt{P} \mathtt{x}^ \unicode{x2020})\ \mathtt{else}\ \mathtt{f}^\ell(\mathtt{P} \mathtt{x}^ \unicode{x2020}) + 0 \big).\end{align*}

This is semantically equivalent to

\begin{align*} \mathtt{leap}^\ell(\mathtt{x}^ \unicode{x2020}) &= \mathtt{f}^\ell(\mathtt{x}^ \unicode{x2020}) \\ \mathtt{f}^\ell(\mathtt{x}^ \unicode{x2020}) &= \mathtt{if}\ \mathtt{null}(\mathtt{x}^ \unicode{x2020})\ \mathtt{then}\ 1\ \mathtt{else}\ \mathtt{f}^\ell(\mathtt{P} \mathtt{x}^ \unicode{x2020}) + \mathtt{f}^\ell(\mathtt{P} \mathtt{x}^ \unicode{x2020}),\end{align*}

which we can see correctly computes the base-2 exponential of the length of the input string (given a sufficiently large counting module).

6.4 The bit transformation

In the bit transformation, we will transform terms of type W into terms of type 2, with an additional type-C input. The idea is that the transformed term encodes the bits of the original W-term.

Definition 32. For each function symbol $\mathtt{f}$ of type $\beta \times W \to W$ or $\beta \to W$ , let $\mathtt{f}^b$ be a recursive function symbol of type $\beta^ \unicode{x2020} \times C \to 2$ . (We may assume that the map $\mathtt{f} \mapsto \mathtt{f}^b$ is injective.)

Definition 33. We define a transformation $T \mapsto T^b$ from RW terms of type W to bit-length terms of type 2 as follows. Here $\mathtt{c}$ is a fixed variable of type C.

• If $T \equiv \mathtt{w}$ or $T \equiv \mathtt{nil}$ , then $T^b \equiv \mathtt{false,}$ . ^{Footnote 11}

• If $T \equiv \mathtt{if}\ T_0\ \mathtt{then}\ T_1\ \mathtt{else}\ T_2$ , then $T^b \equiv \mathtt{if}\ T_0^ \unicode{x2020}\ \mathtt{then}\ T_1^b\ \mathtt{else}\ T_2^b$ .

• If $T \equiv \mathtt{f}(T')$ , then $T^b \equiv \mathtt{f}^b((T')^ \unicode{x2020},\mathtt{c})$

• If $T \equiv \mathtt{f}(T',S)$ , where S has type W, then

  $$ T^b \equiv \mathtt{if}\ \mathtt{f}^\diamond((T')^ \unicode{x2020})\ \mathtt{then}\ \mathtt{f}^b((T')^ \unicode{x2020},\mathtt{c})\ \mathtt{else}\ \mathtt{if}\ \mathtt{c} \le S^\ell\ \mathtt{then}\ S^b\ \mathtt{else}\ \mathtt{f}^b((T')^ \unicode{x2020},\mathtt{c} - S^\ell) .$$

• If $T \equiv \mathtt{cons}(T',S)$ , then $T^b \equiv \mathtt{if}\ \mathtt{c} \le S^\ell\ \mathtt{then}\ S^b\ \mathtt{else}\ (T')^ \unicode{x2020}$ ,

Notice that the only variables that may occur in $T^b$ are $\mathtt{c}$ and $\mathtt{x}^ \unicode{x2020}$ for $\mathtt{x}$ which occur in T, and the only recursive function symbols that may occur are $\mathtt{f}^b$ for $\mathtt{f}$ of output type W, and $\mathtt{f}^ \unicode{x2020}$ for $\mathtt{f}$ of output type non-W, which occur in T.

Remark 11 Not only does this transformation preserve tail-recursive terms, but every term it produces is tail-recursive (as long as we regard previously defined subterms like $S^\ell$ and $\mathtt{f}^\diamond((T')^ \unicode{x2020})$ as explicit, as usual). No matter what T is, no $\mathtt{f}^b$ will occur inside anything other than a then- or else-clause in $T^b$ .

Definition 34. Given an RW-factorizable program p of type $R \to W$ , we define the bit-length program $p^b$ by extending $p^\ell$ as follows

Finally, add a new head $ \mathtt{h}(\mathtt{c}) = \mathtt{f}^b_0(\mathtt{max},\mathtt{c}) .$ The resulting program is $p^b$ . It is tail-recursive if p is.

Let us check that for any RW-factorizable program p of type $R \to W$ , $p^b$ is a well-defined bit-length program. It contains the recursive function symbols $\mathtt{f}^b$ for $\mathtt{f}$ in p of type W, and $\mathtt{f}^ \unicode{x2020}$ for $\mathtt{f}$ in p of type non-W. Since the only variable that appears in T is $\mathtt{x}_i$ , the only variables that may appear in $T^b$ are $\mathtt{x}_i^ \unicode{x2020}$ and $\mathtt{c}$ . Finally, the types of $\mathtt{f}^b_i(\mathtt{x}^ \unicode{x2020},\mathtt{c})$ and $T_i$ agree.

Notice that $p^b$ contains $p^\ell$ , and hence $p^\diamond$ and $p^ \unicode{x2020}$ , as “subprograms.” Hence, the semantics of $p^b$ extends the semantics of the previous programs. We now prove its correctness; the proof is postponed to Appendix A.

Lemma 5. For every RW program p of type $R \to W$ , RW term T from p of type W, strings x, w and v, natural numbers $n > |v|$ and $1 \le c \le |v| - \delta$ , and x-environment $\rho$ binding $\mathtt{w}$ to w,

$$ \rho \vdash_p T \to v \implies x,n, \rho^ \unicode{x2020} , [\mathtt{c} = c] \vdash_{p^b} T^b \to v_{c + \delta},$$

where $\delta = 0$ if $\rho^ \unicode{x2020} \vdash_\diamond T^\diamond \to \top $ or $\delta = |w|$ if $\rho^ \unicode{x2020} \vdash_\diamond T^\diamond \to \bot $ . ^{Footnote 12} Moreover, the computation on the right-hand side is without collisions.

Theorem 5. Suppose that p is an RW-factorizable program of type $ R \to W$ and suppose that $\lambda : \omega \to \omega$ satisfies

$$ (\forall x,w \in 2^\star)\, \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = w \implies |w| < \lambda(|x|) . $$

Then,

$$ (\forall x,w \in 2^\star)\, \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = w \implies (\forall c \le |w| ) \ \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p^b}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x,c) = w_c,$$

without collisions.

Proof Fix x, v, and c such that $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = v$ and $1 \le c \le |v |$ . Suppose that $\mathtt{f}_0(\mathtt{x}_0)$ is the head of p, so that $[\mathtt{x}_0 = x] \vdash_p \mathtt{f}_0(\mathtt{x}_0) \to v$ . Therefore, $[\mathtt{x}_0 = x,\mathtt{w} = \varepsilon] \vdash_p \mathtt{f}_0(\mathtt{x}_0) \to v$ . By Lemma 5, since $\lambda(|x|) > v$ ,

$$x,\lambda(|x|), [\mathtt{x}_0^ \unicode{x2020} = x^ \unicode{x2020}, \mathtt{c} = c] \vdash_{p^b} \mathtt{f}_0^b(\mathtt{x}_0^ \unicode{x2020},\mathtt{c}) \to v_c,$$

without collisions. (Notice that $\delta = 0$ as $\mathtt{w}$ is bound to $\varepsilon$ .)

Since $x , \lambda(|x|) \vdash_{p^b} \mathtt{max} \to |x|$ and $|x| = x^ \unicode{x2020}$ , we have

$$ x , \lambda(|x|) , [\mathtt{c} = c] \vdash_{p^b} \mathtt{f}_0^b(\mathtt{max},\mathtt{c}) \to v_c .$$

But since the head of $\mathtt{h}(\mathtt{c})$ is defined to be $\mathtt{f}_0^b(\mathtt{max},\mathtt{c})$ , this implies $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p^b}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x,c) = v_c$ , which is exactly what we wanted to show.

Theorems 4 and 5 immediately imply the following result, the statement of correctness for the translation from RW-factorizable to bit-length programs.

Theorem 6. Let $f:2^\star \to 2^\star$ be a function, $\lambda : \omega \to \omega$ satisfy $\lambda(|x|) > |f(x)|$ , and p be an RW-factorizable program of type $R \to W$ computing f. Then, $(\lambda,p^\ell,p^b)$ properly computes f.

Example Given the program $\mathit{id}$ defined by

\begin{align*} \mathtt{id}(\mathtt{x}) &= \mathtt{cat}(\mathtt{x},\mathtt{nil}) \\ \mathtt{cat}(\mathtt{x},\mathtt{w}) &= \mathtt{if}\ \mathtt{null}(\mathtt{x})\ \mathtt{then}\ \mathtt{w}\ \mathtt{else}\ \mathtt{cons}(\mathtt{hd}\ \mathtt{x},\mathtt{cat}(\mathtt{tl}\ \mathtt{x},\mathtt{w})),\end{align*}

$\mathit{id}^b$ is defined by

\begin{align*} \mathtt{id}^b(\mathtt{x}^ \unicode{x2020},\mathtt{c}) =\ &\mathtt{if}\ \mathtt{cat}^\diamond(\mathtt{x}^ \unicode{x2020})\ \mathtt{then}\ \mathtt{cat}^b(\mathtt{x}^ \unicode{x2020},\mathtt{c})\ \mathtt{else}\ \mathtt{if}\ \mathtt{c} \le 0\ \mathtt{then}\ \mathtt{false,}\\ & \mathtt{else}\ \mathtt{cat}^b(\mathtt{x}^ \unicode{x2020},\mathtt{c} - 0) \\ \mathtt{cat}^b(\mathtt{x}^ \unicode{x2020},\mathtt{c}) =\ &\mathtt{if}\ \mathtt{null}(\mathtt{x}^ \unicode{x2020})\ \mathtt{then}\ \mathtt{false,}\ \mathtt{else}\ \mathtt{if}\ \mathtt{c} \le S^\ell\ \mathtt{then}\ S^b\ \mathtt{else}\ \mathtt{bit}(\mathtt{x}^ \unicode{x2020}) ,\end{align*}

where $S \equiv \mathtt{cat}(\mathtt{tl}\ \mathtt{x},\mathtt{w})$ . We know that $S^\ell$ correctly computes the length of $\mathtt{tl}(\mathtt{x})$ , which is (abusing notation) $\mathtt{x}^ \unicode{x2020} - 1$ . Moreover,

$$ S^b \equiv \mathtt{if}\ \mathtt{cat}^\diamond(\mathtt{P} \mathtt{x}^ \unicode{x2020})\ \mathtt{then}\ \mathtt{cat}^b(\mathtt{P} \mathtt{x}^ \unicode{x2020},\mathtt{c})\ \mathtt{else}\ \mathtt{if}\ \mathtt{c} \le 0\ \mathtt{then}\ \mathtt{false,}\ \mathtt{else}\ \mathtt{cat}^b(\mathtt{P} \mathtt{x}^ \unicode{x2020},\mathtt{c}-0) .$$

Recall that $\mathtt{cat}^\diamond$ computes the always-false function. Combining this all into semantically equivalent and legible pseudocode, we get

\begin{align*} \mathtt{id}^b(\mathtt{x}^ \unicode{x2020},\mathtt{c}) = \ &\mathtt{if}\ \mathtt{c} \le 0\ \mathtt{then}\ \mathtt{false,}\ \mathtt{else}\ \mathtt{cat}^b(\mathtt{x}^ \unicode{x2020},\mathtt{c}) \\ \mathtt{cat}^b(\mathtt{x}^ \unicode{x2020},\mathtt{c}) =\ &\mathtt{if}\ \mathtt{null}(\mathtt{x}^ \unicode{x2020}) \vee \mathtt{c} \le 0\ \mathtt{then}\ \mathtt{false,}\ \mathtt{else}\ \\ &\mathtt{if}\ \mathtt{c} \le \mathtt{x}^ \unicode{x2020} - 1\ \mathtt{then}\ \mathtt{cat}(\mathtt{P} \mathtt{x}^ \unicode{x2020},\mathtt{c})\ \mathtt{else}\ \mathtt{bit}(\mathtt{x}^ \unicode{x2020}).\end{align*}

We can see that $\mathtt{cat}^b(\mathtt{x}^ \unicode{x2020},\mathtt{c})$ computes the bit indexed by $\mathtt{c}$ : operationally, it decrements the index $\mathtt{x}^ \unicode{x2020}$ until it is equal to the counting module $\mathtt{c}$ , then spits out the bit indexed by $\mathtt{x}^ \unicode{x2020}$ . Hence, $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{\mathit{id}^b}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x,c)$ computes the bit $x_c$ for sufficiently large $\lambda$ and appropriate values of c.

Observe that for sufficiently large $\lambda$ , $(\lambda,\mathit{id}^\ell,\mathit{id}^b)$ correctly bit-length computes the identity function, as $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{\mathit{id}^\ell}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x) = |x|$ and $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{\mathit{id}^b}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x,c) = x_c$ .

7 Compiling BL- to RW-factorizable programs

In this section, we show how to compile a pair of bit-length programs into a single RW-factorizable program, thus establishing extensional equivalence for these two notions of computability, at least for total functions. The core of this section consists of two transformations:

• The more significant of these is a transformation $\unicode{x2021}$ , which acts as a sort of inverse to $ \unicode{x2020}$ : it eliminates indices in favor of string suffixes, i.e., R-data, and counting modules in favor of tuples of R-data. (More precisely, this is a family of transformations parameterized by how many R values we need to encode a single counting module.) This process transforms every bit-length program into a cons-free program with a “global input variable.”

• The simpler transformation takes a cons-free program with a global input variable into one without. We do this in most naive way possible, simply by passing the global input as an additional parameter to every recursive call.

The former transformation uses a well-known trick of cons-free programming, namely that we can simulate a counting module of size polynomial in the input length by a tuple of suffixes of the input. If we just think of a suffix of the input as encoding its length (i.e., forgetting about its bits), then we can identify it with some single digit $\{0,1,\dots,n\}$ , where n is the length of the input. Therefore, we can identify a k-tuple of suffixes with some k-digit number in base $n+1$ , which we can identify in turn with some number less than $(n+1)^k$ . To implement the full data type of a counting module, it simply suffices to implement the fixed-width arithmetic and comparison operations using cons-free programs. In this way, we can replace polynomially bounded counting modules with fixed-width tuples of R values.

A complication is the fact that our language does not accommodate nested tuples. For example, suppose that we had to replace every counting module of type C by three R values of type $R \times R \times R$ . Then if we had a tuple of type $I \times C \times 2$ , it should be replaced by a tuple of type $(R,R^3,2)$ , but since we don’t have nested tuples, we are required to “flatten it out” into a tuple of type (R,R,R,R,2). This makes indexing harder: to get the element of $R^3$ encoding the counting module, we have to extract the middle three coordinates.

7.1 Programs with global input

Bit-length programs have a global input value, which is the x in the judgment $x , n, \rho \vdash_p T \to v$ . RW-factorizable programs, and cons-free programs in particular, do not. It will be convenient to first transform bit-length programs into cons-free programs with some global input variable $\mathtt{in}$ , and then eliminate it, instead of trying to cram both in one transformation.

Definition 35. A RW term term with global input is obtained by extending the formation rules of Figure 1 by the additional axiom $\mathtt{in} : R$ . A RW-factorizable program with global input is defined like an ordinary RW-factorizable program, except that the terms $T_i$ are RW-terms with global input.

The semantics relation $\vdash$ has the form $x , \rho \vdash T \to v$ (note the additional x argument on the left-hand side) and is defined by extending the rules of Figure 2 by the axiom $x,\rho \vdash \mathtt{in} \to x$ . If $\mathtt{f}_0(\mathtt{x}_0)$ is the head of a program p, then we define

$$ \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x,y) = v \iff x,[\mathtt{x}_0 = y] \vdash_p \mathtt{f}_0(\mathtt{x}_0) \to v . $$

An RW-factorizable program with global input is cons-free if it contains no term of type W.

We can easily transform a RW program with global input into one without. The basic idea is to pass the global input explicitly into each recursive function symbol as an extra argument which never gets modified. The remainder of this subsection consists of making this intuition formal. Moreover, we will restrict our attention to cons-free programs, because that is the only case we need.

Definition 36. For any RW product term $\alpha$ , let $\alpha_R$ be $\alpha \times R$ . For any RW function term $\rho = \beta \to \alpha$ , let $\rho_R$ be $\beta_R \to \alpha$ . Define an injection $\mathtt{x} \mapsto \mathtt{x}_R$ , $\mathtt{f} \mapsto \mathtt{f}_R$ from variables and recursive function symbols of type $\alpha$ and $\rho$ to type $\alpha_R$ and $\rho_R,$ respectively.

The idea of the next transformation is we replace the variable $\mathtt{x}$ with the variable $\mathtt{x}_R$ . The last coordinate of $\mathtt{x}_R$ stores the “global input” which gets passed around to all the recursive functions in the program, and the rest of the variable stores the “original variable” $\mathtt{x}$ .

Suppose T is a term in which only the variable $\mathtt{x}$ may occur. (Call this an $\mathtt{x}$ -term for brevity.) Let n be the length of the type of $\mathtt{x}$ . Define the map $T \mapsto T^\mathtt{x}_R$ from cons-free terms with global input to cons-free terms as follows (for brevity, we omit the superscript $\mathtt{x}$ ):

• If $T \equiv \mathtt{x}$ , then $T_R \equiv \mathtt{x}_R [0,n-1]$ .

• If $T \equiv \mathtt{in}$ , then $T_R \equiv \mathtt{x}_R [n]$ .

• If $T \equiv \mathtt{if}\ T_0\ \mathtt{then}\ T_1\ \mathtt{else}\ T_2$ then $T_R \equiv \mathtt{if}\ (T_0)_R\ \mathtt{then}\ (T_1)_R\ \mathtt{else}\ (T_2)_R$ .

• If $T \equiv \mathtt{hd}(S)$ , $\mathtt{tl}(S)$ , or $\mathtt{null}(S)$ , then $T_R \equiv \mathtt{hd}(S_R)$ , $\mathtt{tl}(S_R)$ , or $\mathtt{null}(S_R)$ respectively.

• If $T \equiv T_0 \oplus \dots \oplus T_{n-1}$ , then $T_R \equiv (T_0)_R \oplus \dots \oplus (T_{n-1})_R$ .

• If $T \equiv S[i,j]$ , then $T_R \equiv S_R[i,j]$ .

• If $T \equiv \mathtt{f}(S)$ , then $T_R \equiv \mathtt{f}_R(S_R \oplus \mathtt{x}_R[n])$ .

Notice that for any RW-term with global input T containing only $\mathtt{x}$ , then $T_R^\mathtt{x}$ is a well-formed RW-term of the same type of T. Moreover, $\mathtt{x}_R$ is the only variable which may occur in $T^\mathtt{x}_R$ . This transformation is easily seen to preserve tail recursion.

Definition 38. Suppose the cons-free program with global input p consists of the lines $\mathtt{f}_i(\mathtt{x}_i) = T_i$ for $0 \le i \le k$ . Then define the program $p_R$ to consist of lines $(\mathtt{f}_i)_R((\mathtt{x}_i)_R) = (T_i)^{\mathtt{x}_i}_R$ for $0 \le i \le k$ .

Note that $p_R$ is a well-defined program. It contains the recursive function symbols $(\mathtt{f}_i)_R$ for each $\mathtt{f}_i$ from p. The type of $(\mathtt{x}_i)_R$ is the input type of $(\mathtt{f}_i)_R$ . The type of $(T_i)^{\mathtt{x}_i}_R$ is the type of $T_i$ , which is the output type of $\mathtt{f}_i$ , which is the output type of $(\mathtt{f}_i)_R$ . The only variable that may occur in $(T_i)_R$ is $(\mathtt{x}_i)_R$ , and the only recursive function symbols that may occur are among $((\mathtt{f}_0)_R,\dots,(\mathtt{f}_k)_R)$ .

In the next lemma, recall that if $(u_0,\dots,u_{n-1})$ is a decomposition of the value u into atomic values, then by $u \circ x$ we mean $(u_0,\dots,u_{n-1},x)$ . Its proof is postponed to Appendix A.

Lemma 6. For any cons-free program with global input p, values x u, and v, variable $\mathtt{x}$ , and $\mathtt{x}$ -term T,

$$ x,[\mathtt{x} = u] \vdash T \to v \implies [\mathtt{x}_R = u \circ x] \vdash T^\mathtt{x}_R \to v .$$

Hence,

Theorem 7. For any cons-free program with global input p with nullary input, string x and value v, if $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = v$, then $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p_R}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = v$ .

Proof Let $\mathtt{f}_0(\mathtt{x})$ be the head of p. Since p has nullary input, $\mathtt{x}$ is a variable of type the empty product, and $\mathtt{x}_R$ is a variable of type R. If $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = v$, then $x \vdash \mathtt{f}_0 \to v$ . By Lemma 6, $[\mathtt{x}_R = x] \vdash (\mathtt{f}_0)_R((\mathtt{x}_0)_R) \to v$ . But since $(\mathtt{f}_0)_R((\mathtt{x}_0)_R)$ is the head of $p_R$ , $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p_R}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = v$ .

7.2 Eliminating indices and counting modules

In this subsection, we show how to compile any bit-length program into a cons-free program with global input. We fix a natural number $k \ge 1$ which is the number of copies of R we want to replace every copy of C by. The transformation $\unicode{x2021}$ defined in this section should be understood as parameterized by this number k. First we will define a map on types, variables, and terms, then values, then programs, and we conclude with a proof of correctness.

The main idea: Bit-length programs contain two types of data that RW-factorizable programs do not: indices and counting modules. We replace indices by single R values and counting modules by k-tuples of R values.

The former correspondence is straightforward: if the input string x has length n, then its bits are $x_n \dots x_2 x_1$ . R values range over suffixes of x. We encode the index i by the R value $x_i \dots x_2 x_1$ . The “dummy index” 0 is encoded by the empty string. With respect to this encoding, the index primitives $\mathtt{bit}$ , $\mathtt{P}$ , $\mathtt{null}$ , and $\mathtt{max}$ correspond to $\mathtt{hd}$ , $\mathtt{tl}$ , $\mathtt{null}$ , and $\mathtt{in}$ (the global input variable) respectively. The only index primitive that needs to be programmed is $\mathtt{min}$ , which can be replaced by $\mathtt{f}(\mathtt{in})$ , where

$$ \mathtt{f}(\mathtt{x}) \equiv \mathtt{if}\ \mathtt{null}(\mathtt{x})\ \mathtt{then}\ \mathtt{x}\ \mathtt{else}\ \mathtt{f}(\mathtt{tl}(\mathtt{x})). $$

Let $\mathtt{zero}_I$ be the term $\mathtt{f}(\mathtt{in})$ .

If we ignore the characters in an R-string, it simply encodes a length ranging from 0 to $n+1$ ; i.e., a single digit base $n+1$ . Hence, a k-tuple of R-data encodes a k-digit number base $n+1$ , or alternatively, as a natural number less than $(n+1)^k$ . Therefore, k-tuples of R data can be used to simulate counting modules which are polynomially bounded in the length of the input. ^{Footnote 13} The counting modules primitives $+$ , $-$ , and $\le$ can be replaced by cons-free programs $\mathtt{add}$ , $\mathtt{minus}$ , and $\mathtt{less}$ , which simulate the corresponding primitives on k-tuples of R values by mimicking any common algorithm for fixed-width arithmetic. ^{Footnote 14} The cons-free constants 0 and 1 can similarly be replaced with programs $\mathtt{zero}$ and $\mathtt{one}$ , which compute the constant- $(0,\dots,0,0)$ and constant- $(0,\dots,0,1)$ functions, respectively. ^{Footnote 15}

We assume the existence of these five programs without constructing them and note that they can always be made tail-recursive. In fact, all the recursion we need can be collected into a few important subroutines. Thinking of R values as single digits, we can name the largest digit (by the global input variable $\mathtt{in}$ ) and we can decrement digits (by $\mathtt{tl}$ ). Using these primitives, we can define simple tail-recursive subroutines incrementing a digit, comparing two digits, and naming the digit 0. Then, the programs $\mathtt{add}$ , $\mathtt{minus}$ , $\mathtt{less}$ , $\mathtt{zero}$ , and $\mathtt{one}$ are explicit in these subroutines; i.e., can be defined in terms of them using no additional recursion.

Definition 39. Let $2^\unicode{x2021} = 2$ , $I^\unicode{x2021} = R$ , and $C^\unicode{x2021} = R^k$ . For every bit-length product type $\alpha$ , define the RW product type $\alpha^\unicode{x2021}$ by replacing every copy of I by R, replacing every copy of C by $R^k$ , and flattening. For example:

\begin{align*} C^\unicode{x2021} &= R^k \\ (2 \times I \times C)^\unicode{x2021} &= 2 \times R^{k+1} \\ (2 \times C \times I \times 2 \times C \times C)^\unicode{x2021} &= 2 \times R^{k+1} \times 2 \times R^{2k}. \end{align*}

Extend this to a map on function types by $(\beta \to \alpha)^\unicode{x2021} = \beta^\unicode{x2021} \to \alpha^\unicode{x2021}$ .

Finally, for each product type $\alpha$ , define the map $s_\alpha : |\alpha^\unicode{x2021}| \to |\alpha|$ by mapping each coordinate of $\alpha^\unicode{x2021}$ to the coordinate “which it comes from” in $\alpha$ . For example, $s_C : k \to 1$ is defined by $s_C(i) = 0$ for all $i \in k$ ; $s_{2 \times I \times C}:k+2 \to 3$ and $s_{2 \times I \times C}(i)$ is 0 if $i=0$ , 1 if $i = 1$ , and 2 otherwise; and

$$ s_{2 \times C \times I \times 2 \times C \times C} : 3k + 2 \to 6 $$

is defined by

$$ s_{2 \times C \times I \times 2 \times C \times C}(i) = \begin{cases} 0 & \text{if } i = 0 \\1 & \text{if } 1 \le i \le k \\2 & \text{if } i = k+1 \\3 & \text{if } i = k+2 \\4 & \text{if } k+3 \le i \le 2k+2 \\5 & \text{otherwise}\end{cases}$$

Notice that each such map $s_\alpha$ is a monotone (non-decreasing) surjection.

Definition 40. Fix an injection $\mathtt{x} \mapsto \mathtt{x}^\unicode{x2021}$ from bit-length variables to RW variables such that if $\mathtt{x}$ has type $\alpha$ , $\mathtt{x}^\unicode{x2021}$ has type $\alpha^\unicode{x2021}$ . Fix an injection $\mathtt{f} \mapsto \mathtt{f}^\unicode{x2021}$ from bit-length recursive function symbols of type $\rho$ to RW function symbols of type $\rho^\unicode{x2021}$ , for every bit-length function type $\rho$ .

In the next definition, $\mathtt{in}$ is a fixed variable of type R naming the global input, $\mathtt{zero}$ and $\mathtt{one}$ are fixed function symbols of type $ C^ \unicode{x2020}$ , $\mathtt{add}$ and $\mathtt{minus}$ are fixed function symbols of type $(C \times C \to C)^\unicode{x2021}$ , and $\mathtt{less}$ is a fixed function symbol of type $(C \times C \to 2)^\unicode{x2021}$ .

Definition 41. Define a map $T \mapsto T^ \unicode{x2020}$ from bit-length terms to cons-free terms with global input by:

• If $T \equiv \mathtt{true} $ or $T \equiv \mathtt{false,}$ then $T^\unicode{x2021} \equiv T$ .

• If $T \equiv \mathtt{x}$ , a variable of type $\alpha$ , then $T^\unicode{x2021} \equiv \mathtt{x}^\unicode{x2021}$ .

• If $T \equiv \mathtt{0}$ then $T^\unicode{x2021} \equiv \mathtt{zero}$ .

• If $T \equiv \mathtt{1}$ then $T^\unicode{x2021} \equiv \mathtt{one}$ .

• If $T \equiv T_0 + T_1$ then $T^\unicode{x2021} \equiv \mathtt{add}(T_0^\unicode{x2021},T_1^\unicode{x2021})$ .

• If $T \equiv T_0 - T_1$ then $T^\unicode{x2021} \equiv \mathtt{minus}(T_0^\unicode{x2021},T_1^\unicode{x2021})$ .

• If $T \equiv T_0 \le T_1$ , then $T^\unicode{x2021} \equiv \mathtt{less}(T_0^\unicode{x2021},T_1^\unicode{x2021})$ .

• If $T \equiv \mathtt{min}$ then $T^\unicode{x2021} \equiv \mathtt{zero}_I$ .

• If $T \equiv \mathtt{max}$ then $T^\unicode{x2021} \equiv \mathtt{in}$ .

• If $T \equiv \mathtt{P}(S)$ then $T^\unicode{x2021} \equiv \mathtt{tl}(S^\unicode{x2021})$ .

• If $T \equiv \mathtt{null}(S)$ then $T^\unicode{x2021} \equiv \mathtt{null}(S^\unicode{x2021})$ .

• If $T \equiv \mathtt{bit}(S)$ then $T^\unicode{x2021} \equiv \mathtt{hd}(S^\unicode{x2021})$ .

• If $T \equiv T_0 \oplus \dots \oplus T_{n-1}$ then $T^\unicode{x2021} \equiv T_0^\unicode{x2021} \oplus \dots \oplus T_{n-1}^\unicode{x2021}$ .

• If $T \equiv S[i,j]$ , let m be the length of S and n the length of $S^\unicode{x2021}$ . Then, $T^\unicode{x2021} \equiv S^\unicode{x2021}[\imath,\jmath]$ , where the interval $[\imath,\jmath] \subseteq m$ is the $s_\alpha$ -pre-image of $[i,j] \subseteq n$ .

• If $T \equiv \mathtt{if}\ T_0\ \mathtt{then}\ T_1\ \mathtt{else}\ T_2$ then $T^\unicode{x2021} \equiv \mathtt{if}\ T_0^\unicode{x2021}\ \mathtt{then}\ T_1^\unicode{x2021}\ \mathtt{else}\ T_2^\unicode{x2021}$ .

• If $T \equiv \mathtt{f}(S)$ , then $T \equiv \mathtt{f}^\unicode{x2021}( S^\unicode{x2021} )$ .

Now we define a map on values. For this definition, recall the bijection

$$ f : \underbrace{n \times \dots \times n}_{\boldsymbol{k}}{\text{copies}} \to n^k $$

defined by $(d_0,\dots,d_{k-1}) \mapsto \sum_{i < k} d_i n^i.$ Intuitively, this identifies k-digit numerals base n with the numbers they denote.

Remark 12. As long as $\mathtt{zero}$ , $\mathtt{one}$ , $\mathtt{add}$ , $\mathtt{minus}$ , and $\mathtt{less}$ are implemented by tail-recursive programs, this transformation is easily seen to preserve tail recursion.

Definition 42. For any string $x \in 2^\star$ , define the map $v \mapsto v^\unicode{x2021}$ as follows. If $v \in 2$ , then $v_x^\unicode{x2021} = v$ . If $v \in I(x)$ , then $v_x^\unicode{x2021}$ is the suffix of x of length $|v|$ . If $v \in C((|x|+1)^k)$ , then $v_x^\unicode{x2021}$ is the unique k-tuple of suffixes $(s_0,\dots,s_{k-1})$ of x such that

$$ v = \sum_{i < k} |s_i| (|x| + 1)^i .$$

If $(v_0,\dots,v_{n-1})$ is a decomposition of v into atomic types, then $v^\unicode{x2021} = v_0^\unicode{x2021} \circ \dots \circ v_{n-1}^\unicode{x2021}$ . Notice that for any values u and v, $(u \circ v)^\unicode{x2021} = u^\unicode{x2021} \circ v^\unicode{x2021}$ .

Definition 43. Given a bit-length program $p = (\mathtt{f}_i(\mathtt{x}_i) = T_i)$ , the cons-free program with global input $p^\unicode{x2021}$ is defined to be $(\mathtt{f}_i^\unicode{x2021}(\mathtt{x}^\unicode{x2021}_i) = T_i^\unicode{x2021}) $ .

This program is well-defined: if $T_i$ is an $\mathtt{x}_i$ -term, then $T_i^\unicode{x2021}$ is an $\mathtt{x}_i^\unicode{x2021}$ -term. The only recursive function symbols that may occur in $T_i^\unicode{x2021}$ , besides the previously defined $\mathtt{zero}_I$ , $\mathtt{zero}$ , $\mathtt{one}$ , $\mathtt{add}$ , $\mathtt{minus}$ and $\mathtt{less}$ , are the $\mathtt{f}_j^\unicode{x2021}$ . Moreover, it is tail-recursive if p is.

The proof of the next result is postponed to Appendix A.

Lemma 7. For every bit-length program p, bit-length term T from p, string x, x-environment $\rho$ , and value v,

$$ x, (|x|+1)^k, \rho \vdash_p T \to v \implies x, \rho^\unicode{x2021} \vdash_{p^\unicode{x2021}} T^\unicode{x2021} \to v^\unicode{x2021}.$$

Lemma 7 and Theorem 7 have the following corollary. Let $p^\unicode{x2021}_R$ be $(p^\unicode{x2021})_R$ .

Theorem 8. For any bit-length program p and polynomially bounded $\lambda : \omega \to \omega$ , string x and value v, if $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x) = v$ without collisions, then $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p^\unicode{x2021}_R}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = v^\unicode{x2021}$ .

Proof Choose k such that $\lambda(n) < (n+1)^k$ for all n and define $\mu:\omega \to \omega$ by $\mu(n) = (n+1)^k$ . Suppose that $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\lambda(x) = v$ without collisions. Then, $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}_\mu(x) = v$ by monotonicity of collision-free computation. By Lemma 7 and the definition of $p^\unicode{x2021}$ , $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p^\unicode{x2021}}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = v^\unicode{x2021}$ . By Theorem 7, $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p^\unicode{x2021}_R}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = v^\unicode{x2021}$ .

Example. The following program of type $C \times C \to C$ multiplies its two inputs. (Or rather, the two coordinates of its single input—recall these are $\mathtt{c}[0]$ and $\mathtt{c}[1]$ .)

\begin{align*} \mathtt{f}(\mathtt{c}) = \mathtt{if}\ \mathtt{c}[0] \le 0\ \mathtt{then}\ 0\ \mathtt{else}\ \mathtt{c}[1] + \mathtt{f}(\mathtt{c}[0] - 1, \mathtt{c}[1]).\end{align*}

Suppose that $k=2$ , so we replace each occurrence of C by two copies of R. Then, the type of $\mathtt{c}^\unicode{x2021}$ is $R^4$ , where the former and latter two copies of R correspond to $\mathtt{c}[0]$ and $\mathtt{c}[1],$ respectively. Hence,

\begin{align*} \mathtt{f}^\unicode{x2021}(\mathtt{c}^\unicode{x2021}) & = \mathtt{if}\ \mathtt{less}(\mathtt{c}^\unicode{x2021}[0,1],\mathtt{zero})\ \mathtt{then}\ \mathtt{zero}\ \mathtt{else}\ \mathtt{add}(\mathtt{c}^\unicode{x2021}[2,3],\mathtt{f}^\unicode{x2021}(\mathtt{minus}(\mathtt{c}^\unicode{x2021}[0,1],\mathtt{one}),\\ & \qquad \mathtt{c}^\unicode{x2021}[2,3])).\end{align*}

7.3 Building type-W output

So far we have shown that we can convert any bit-length program p into an equivalent cons-free RW-factorizable program $p^\unicode{x2021}_R$ . Given a polynomially bounded function $\lambda$ and bit-length programs p and q such that $(\lambda,p,q)$ properly computes a function f, how do we use the cons-free programs $q^\unicode{x2021}_R$ and $p^\unicode{x2021}_R$ to form an RW-factorizable program computing f? (As above, $\unicode{x2021}$ is dependent on a parameter k, which we choose large enough so that $(n+1)^k$ dominates $\lambda$ .)

As usual, the basic idea is straightforward. We compute the length of the output string using $q^\unicode{x2021}_R$ . We iterate through indices of the output string less than $q^\unicode{x2021}_R$ and compute the corresponding bit of the output string using $p^\unicode{x2021}_R$ . For each of these computed bits, we $\mathtt{cons}$ -them on to a variable $\mathtt{w}$ , which “accumulates” the eventual output.

If we were to write this in a legible but informal imperative pseudocode, it would look like this:

\begin{align*} &\mathtt{w} = \mathtt{nil} \\ &\mathtt{for}\ \texttt{1} \le \mathtt{c} \le \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{q^\unicode{x2021}_R}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(\mathtt{x}) \\ &\ \ \ \ \mathtt{w} = \mathtt{cons}(\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p^\unicode{x2021}_R}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(\mathtt{x},\mathtt{c}),\mathtt{w}) \\ &\mathtt{return} \ \mathtt{w}\end{align*}

It is easy to see that this program computes f(x) on input x, as it outputs a string of length $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{q^\unicode{x2021}_R}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x)$ (x) whose i-th bit is $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p^\unicode{x2021}_R}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x,i)$ . Written slightly more carefully, we get this:

\begin{align*} \mathtt{out}(\mathtt{x}) &= \mathtt{f}(\mathtt{x} , \mathtt{one},\mathtt{nil}) \\ \mathtt{f}(\mathtt{x},\mathtt{c},\mathtt{w}) &= \mathtt{if}\ \mathtt{c}=\mathtt{h}_q(\mathtt{x})\ \mathtt{then}\ \mathtt{w}\ \mathtt{else}\ \mathtt{f}(\mathtt{x},\mathtt{add}(\mathtt{c},\mathtt{one}),\mathtt{cons}(\mathtt{h}_p(\mathtt{x},\mathtt{c}),\mathtt{w})),\end{align*}

where $\mathtt{h}_p$ and $\mathtt{h}_q$ denote the heads of the programs $p^\unicode{x2021}_R$ and $q^\unicode{x2021}_R,$ respectively. But even here, we have sacrificed some precision for legibility: for example, we must replace $=$ by two occurrences of $\mathtt{less}$ , and a term like $\mathtt{f}(\mathtt{x},\mathtt{0},\mathtt{nil})$ must be understood as $\mathtt{f}(\mathtt{x} \oplus \mathtt{0},\mathtt{nil})$ .

Thus, we have transformed $(\lambda,p,q)$ into an RW-factorizable program computing the same function. Moreover, note that it is non-nested, and tail-recursive if p and q are. ^{Footnote 16} Combined with Theorem 6, we get the following translation result:

Theorem 9. For every function $f : 2^\star \to 2^\star$ whose length is polynomially bounded, there is a non-nested RW-factorizable program of type $R \to W$ computing f iff there is a polynomially bounded function $\lambda$ and bit-length programs p and q such that $(\lambda,p,q)$ properly computes f.

Similarly, there is a tail-recursive RW-factorizable program of type $R \to W$ computing f iff there is a polynomially bounded function $\lambda$ and tail-recursive bit-length programs p and q such that $(\lambda,p,q)$ properly computes f.

Theorems 9 and 2 have the following immediate consequence, which is the central result of this paper:

Theorem 10. For any function $f:2^\star \to 2^\star$ , $f \in \mathrm{FP}$ iff f is computed by a non-nested RW-factorizable program of type $R \to W$ , and $f \in \mathrm{FL}$ iff f is computed by a tail-recursive RW-factorizable program of type $R \to W$ .

A few comments are in order. The proof of this theorem gives us a rather strong normal form for non-nested RW-factorizable programs. Namely, each such program can be written with a single for loop on top of purely cons-free subroutines. We know that those cons-free subroutines can be made non-nested in general, and can furthermore be made tail-recursive if the original program was tail-recursive.

It remains an open question which complexity class general (i.e., possibly nested) RW-factorizable programs capture, but it seems to be intermediate between the class of polynomial time and polynomial space functions. (Recall that the length of the output of the latter functions can grow exponentially in the length of the input.) A plausible candidate is functions whose length is computable in polynomial space, but whose bits are computable in polynomial time.

8 Composing bit-length programs

Finally, we turn to the problem of syntactic composition: producing a program r such that $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{r}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$} = \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{p}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$} \circ \mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{q}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}$ given p and q. In most programming languages this is trivial: we combine programs p and q and add a new head $\mathtt{h}_p(\mathtt{h}_q(\mathtt{x}))$ , where $\mathtt{h}_p$ and $\mathtt{h}_q$ are the recursive function symbols in the heads of p and q respectively. However, this does not work for RW-factorizable programs of type $R \to W$ , as the term $\mathtt{h}_p(\mathtt{h}_q(\mathtt{x}))$ would be ill-typed.

However, since we can transform RW-factorizable programs to and from equivalent pairs of bit-length programs, it suffices to syntactically compose these. ^{Footnote 17} As we have remarked above, pairs of bit-length programs are compositional in a rough extensional sense: we are given bit- and length-access to the input, and we compute bit- and length-access to the output.

More precisely, suppose we have a triple $(\lambda_f,p_f,q_f)$ that properly computes a function f and a triple $(\lambda_g,p_g,q_g)$ that properly computes g. We want to transform $p_f$ and $q_f$ so that they output the bits and length of f(g(x)), as opposed to f(x). Namely, we must “re-interpret” the primitives in $p_f$ and $q_f$ so that it returns the bits of g(x) instead of bits of x, and the constant $\mathtt{max}$ so that it returns the maximum index of g(x) instead of the maximum index of x. Luckily this is exactly what we have in $p_g$ and $q_g$ .

Finally, we have to find a suitable bound for the size of the counting module in the composed program. We assume $\lambda_f$ and $\lambda_g$ are increasing and dominate the identity function. Note that if $|f(x)| \le \lambda_f(|x|)$ and $|g(x)| \le \lambda_g(|x|)$ , then $|f(g(x))| \le (\lambda_f \circ \lambda_g)(|x|)$ . Hence, we may take $\lambda_f \circ \lambda_g$ .

We now present the formal development, which follows a familiar rhythm: a map on types, on values, terms, and programs, followed by a proof of that the program transformation behaves how we want it to. In this section, let us fix:

• functions $f,g: 2^\star \rightharpoonup 2^\star$ ,

• increasing functions $\lambda_f,\lambda_g : \omega \to \omega$ , each dominating the identity function, such that $\lambda_f(|x|) > |f(x)|$ and $\lambda_g(|x|) > |g(x)|$ for all x,

• a function $\mu : \omega \to \omega$ satisfying $\mu \ge \lambda_f \circ \lambda_g$ ,

• a triple $(\lambda_f,p_f,q_f)$ properly computing f, and

• a triple $(\lambda_g,p_g,q_g)$ properly computing g.

Note that the map defined in this section will be denoted by a g in the subscript, e.g., $T \mapsto T_g$ . For types, terms, and programs, this g is purely formal; not so for values, where it actually depends on the partial function g.

For the next definition, notice that $|g(x)| \le \lambda_g(|x|) \le \lambda_f(\lambda_g(|x|)) \le \mu(|x|)$ and $\lambda_f(|g(x)|) \le \lambda_f(\lambda_g(|x|)) \le \mu(|x|)$ , by the assumption that $\lambda_f$ is increasing and dominates the identity.

For the next definition and henceforth, let $\mathtt{h}_p(\mathtt{c})$ and $\mathtt{h}_q$ be the heads of $p_g$ and $q_g$ . Notice that these are terms of type 2 and C respectively, and that $\mathtt{c}$ is a variable of type C.

Lemma 8. For any program p, environment $\rho$ , string x, term T, and value v,

$$ g(x), \lambda_f(|g(x)|) , \rho \vdash_p T \to v \implies x, \mu(|x|) , \rho_g \vdash_{p_{(g)}} T_g \to v_g,$$

without collisions, if the derivation of the left-hand side has no collisions.

(The proof is in Appendix A.)

Proof. Let $\mathtt{h}'_p(\mathtt{c})$ and $\mathtt{h}'_q$ be the left-hand-sides of the heads of $p_f$ and $q_f$ respectively. Fix a string x. By definition of $q_f$ ,

$$ g(x), \lambda_f(|g(x)|) \vdash_{q_f} \mathtt{h}'_q \to |f(g(x))| $$

without collisions. Hence by Lemma 8,

$$ x,\mu(|x|) \vdash_{(q_f)_{(g)}} (\mathtt{h}'_q)_g \to |f(g(x))|,$$

i.e., $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{(q_f)_{(g)}}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x) = |f(g(x))|$ , without collisions.

By definition of $p_f$ , for each $i < |f(g(x))|$ ,

$$ g(x), \lambda_f(|g(x)|), [\mathtt{c} = i] \vdash_{p_f} \mathtt{h}'_p(\mathtt{c}) \to (f(g(x)))_i$$

without collisions. Hence, by Lemma 8,

$$ x,\mu(|x|), [\mathtt{c}_g = i] \vdash_{(p_f)_g} (p^0_f)_g(\mathtt{c}_g) \to (f(g(x)))_i,$$

i.e., $\mbox{$\lbrack\hspace{-0.3ex}\lbrack$}{(p_f)_{(g)}}\mbox{$\rbrack\hspace{-0.3ex}\rbrack$}(x,i) = (f(g(x)))_i$ , without collisions.

Example. Let $q_g$ be the program

\begin{align*} \mathtt{h}_q &= \mathtt{q}(\mathtt{max}) \\ \mathtt{q}(\mathtt{x}) &= \mathtt{if}\ \mathtt{null}(\mathtt{x})\ \mathtt{then}\ 0\ \mathtt{else}\ 1 + \mathtt{q}(\mathtt{P}(\mathtt{x})),\end{align*}

and let $p_g$ be the program

\begin{align*} \mathtt{h}_p(\mathtt{x}) = \mathtt{if}\ \mathtt{bit}(\mathtt{x})\ \mathtt{then}\ \mathtt{false,}\ \mathtt{else}\ \mathtt{true}.\end{align*}

In other words, for sufficiently large $\lambda$ , $(\lambda,p_g,q_g)$ computes the function which flips the bits of the input string. Let us square this function, i.e., create an identical pair of programs $(p_f,q_f)$ , distinguishing the function symbols of the latter by replacing, e.g., $\mathtt{q}$ by $\mathtt{q}'$ , and then composing $(p_f,q_f)$ with $(p_g,q_g)$ . We get for the length component:

\begin{align*} \mathtt{h}'_q &= \mathtt{q}'(\mathtt{h}_q) \\ \mathtt{q}'(\mathtt{x}_g) &= \mathtt{if}\ \mathtt{x}_g \le 0\ \mathtt{then}\ 0\ \mathtt{else}\ 1 + \mathtt{q}'(\mathtt{x}_g - 1) \\ \mathtt{h}_q &= \mathtt{q}(\mathtt{max}) \\ \mathtt{q}(\mathtt{x}) &= \mathtt{if}\ \mathtt{null}(\mathtt{x})\ \mathtt{then}\ 0\ \mathtt{else}\ 1 + \mathtt{q}(\mathtt{P}(\mathtt{x})),\end{align*}

and for the bits component,

\begin{align*} \mathtt{h}'_p(\mathtt{x}_g) &= \mathtt{if}\ \mathtt{h}_p(\mathtt{x}_g)\ \mathtt{then}\ \mathtt{false,}\ \mathtt{else}\ \mathtt{true} \\ \mathtt{h}_p(\mathtt{x}) &= \mathtt{if}\ \mathtt{bit}(\mathtt{x})\ \mathtt{then}\ \mathtt{false,}\ \mathtt{else}\ \mathtt{true}.\end{align*}

By inspection, we can see that this pair of programs computes the identity function, as it should.