2 Automata for the starting and ending positions of runs

We start with a basic result with a simple induction proof.

Next, we find automata for the starting and ending positions of the runs. Let us start with the starting positions.

The desired automaton $\texttt {sp}$ takes three inputs in parallel. The first input is a finite sequence $\textbf {f}$ of unfolding instructions, the second is the number n written in base $2$ and the third is some number x, also expressed in base $2$ . The automaton accepts if and only if $x = S_{\textbf {f}} [n]$ .

Normally, we think of the unfolding instructions as over the alphabet $\{ -1, 1 \}$ , but it is useful to be more flexible and also allow $0$ s, but only at the end; these $0$ s are essentially disregarded. We need this because the parallel reading of inputs requires that all three inputs be of the same length. Thus, for example, the sequences $-1, 1, 1, 0$ and $-1, 1, 1$ are considered to specify the same paperfolding sequence, while $-1, 0, 1, 1$ is not considered a valid specification.

Because we choose to let $f_0$ be the first symbol of the unfolding instructions, it is also useful to require that the inputs n and x mentioned above be represented with the least-significant digit first. In this representation, we allow an unlimited number of trailing zeros.

Finally, although we assume that $S_{\textbf {f}}$ is indexed starting at position $1$ , it is useful to define $S_{\textbf {f}}[0] = 0$ for all finite unfolding instruction sequences $\textbf {f}$ .

To find the automaton computing the starting positions of runs, we use a guessing procedure described in [Reference Shallit17], based on a variant of the Myhill–Nerode theorem. Once a candidate automaton is guessed, we can rigorously verify its correctness with Walnut.

We will need one Walnut automaton, FOLD, already introduced in [Reference Shallit17], and another one that we can define via a regular expression.

• • FOLD takes two inputs, $\textbf {f}$ and n. If n is in the range $1 \leq n < 2^{|{\textbf {f}}|}$ , then it returns the nth term of the paperfolding sequence specified by f.

• • lnk takes two inputs, f and x. It accepts if f is the valid code of a paperfolding sequence (that is, no $0$ s except at the end) and x is $2^t-1$ , where t is the length of f (not counting $0$ s at the end). It can be created using the Walnut command

  

Our guessed automaton sp has $17$ states. We must now verify that it is correct. To do so, we need to verify the following things.

1. (1) The candidate automaton sp computes a partial function. More precisely, for a given $\textbf {f}$ and n, at most one input of the form $({\textbf {f}},n,x)$ is accepted.

2. (2) sp accepts $({\textbf {f}},0,0)$ .

3. (3) sp accepts $({\textbf {f}},1,1)$ provided $|{\textbf {f}}| \geq 1$ .

4. (4) There is an x such that sp accepts $({\textbf {f}},2^{|{\textbf {f}}|-1},x)$ .

5. (5) sp accepts no input of the form $({\textbf {f}},n,x)$ if $n> 2^{|{\textbf {f}}|-1}$ .

6. (6) If sp accepts $({\textbf {f}},2^{|{\textbf {f}}|-1},x)$ , then the symbols $P_{\textbf {f}}[t]$ for $x \leq t < 2^{|{\textbf {f}}|}$ are all the same.

7. (7) Runs are nonempty: if sp accepts $({\textbf {f}},n-1,y)$ and $({\textbf {f}},n,z)$ , then $y<z$ .

8. (8) Finally, we check that if $\texttt {sp}$ accepts $({\textbf {f}},n,x)$ , then x is truly the starting position of the nth run. This means that all the symbols from the starting position of the $(n-1)$ th run to $x-1$ are the same, and different from $P_{\textbf {f}}[x]$ .

We use the following Walnut code to check each of these. A brief review of Walnut syntax may be useful:

• • ?lsd_2 specifies that all numbers are represented with the least-significant digit first and in base $2$ ;

• • A is the universal quantifier $\forall $ and E is the existential quantifier $\exists $ ;

• • & is logical AND, | is logical OR, W is logical NOT, => is logical implication, <=> is logical IFF, and != is inequality;

• • eval expects a quoted string representing a first-order assertion with no free (unbound) variables, and returns TRUE or FALSE;

• • def expects a quoted string representing a first-order assertion $\varphi $ that may have free (unbound) variables, and computes an automaton accepting the representations of those tuples of variables that make $\varphi $ true, which can be used later.

Walnut returns TRUE for all of these, which gives us a proof by induction on n that indeed $x_n = S_{\textbf {f}}[n]$ .

From the automaton for starting positions of runs, we can obtain the automaton for ending positions of runs, ep, using the following Walnut code:

Thus, we have proved the following result.

Using the automaton ep, we are now able to prove the following new theorem. Roughly speaking, it says that the ending position of the nth run for the unfolding instructions $\textbf {f}$ is $2n - \epsilon _n$ , where $\epsilon _n \in \{0, 1 \}$ , and we can compute $\epsilon _n$ by looking at a sequence of unfolding instructions closely related to $\textbf {f}$ .

Theorem 2.4. Let $\mathbf {f}$ be a finite sequence of unfolding instructions of length at least $2$ . Define a new sequence $\mathbf {g}$ of unfolding instructions as follows:

(2.1) $$ \begin{align} {\mathbf{g}} := \begin{cases} 1 \ (-x) & \text{if } \mathbf{f} = 11x, \\ (-1) \ (-x)& \text{if } \mathbf{f} = 1 (-1) x, \\ (-1) \ x & \text{if } \mathbf{f} = (-1) 1 x , \\ 1 \ x & \text{if } \mathbf{f} = (-1) (-1) x. \end{cases} \end{align} $$

Then,

(2.2) $$ \begin{align} E_{\mathbf{f}}[n] + \epsilon_n = 2n \end{align} $$

for $1 \leq n < 2^{n-1}$ , where

$$ \begin{align*}\epsilon_n = \begin{cases} 0 & \text{if } P_{\mathbf{g}}[n] = 1, \\ 1 & \text{if } P_{\mathbf{g}}[n]=-1. \end{cases} \end{align*} $$

Furthermore, if $\mathbf {f}$ is an infinite set of unfolding instructions, then (2.2) holds for all $n \geq 1$ .

Proof. We prove this using Walnut. First, we need an automaton assoc that takes two inputs $\textbf {f}$ and $\textbf {g}$ in parallel, and accepts if $\textbf {g}$ is defined as in (2.1). This automaton is depicted in Figure 1 and correctness is left to the reader. Now, we use the following Walnut code:

and Walnut returns TRUE.

3 Automaton for the sequence of run lengths

Next, we turn to the sequence of run lengths itself. We can compute these from the automata for ep and sp:

Figure 1

The automaton assoc.

Proof. It suffices to prove this for finite paperfolding sequences:

and Walnut returns TRUE.

We now use another feature of Walnut, which is that we can turn a synchronised automaton computing a function of finite range into an automaton returning the value of the function. The following code:

computes an automaton RL of two inputs $\textbf {f}$ and n, and returns the value of the run-length sequence at index n (either $1$ , $2$ or $3$ ) for the unfolding instructions $\textbf {f}$ . This automaton has $31$ states.

We now turn to examining the factors of the run-length sequences of paperfolding sequences. Recall that a factor is a contiguous block sitting inside a large sequence. We start with overlaps.

Recall that an overlap is a string of the form $axaxa$ , where a is a single letter and x is a possibly empty string. For example, the word entente is an overlap from French. We now prove that the sequence of run lengths in a paperfolding sequence contains no overlaps.

Proof. It suffices to prove the result for every finite paperfolding sequence. We can do this as follows:

and Walnut returns TRUE.

We now consider squares, that is, blocks of the form $zz$ , where z is a nonempty sequence.

Proof. We start by showing that the only squares are of order $1$ or $3$ :

Next, we check that the only square of order $1$ is $22$ :

Finally, we check that the only squares of order $3$ are $123123$ and $321321$ :

We now turn to palindromes.

Recall that the subword complexity of an infinite sequence is the function that counts, for each $n \geq 0$ , the number of distinct factors of length n appearing in it. The subword complexity of the paperfolding sequences was determined by Allouche [Reference Allouche2].

Proof. First we prove that if x is a factor of a run-length sequence and $|x| \geq 2$ , then $xa$ is a factor of the same sequence for at most two different a:

Next, we prove that if $|x| \geq 5$ , then exactly four factors of a run-length sequence are right-special (have a right extension by two different letters):

Here, nofive shows that no length 5 or larger has five or more right-special factors of that length, and every length $6$ or larger has exactly four such right-special factors. Here, we have used [Reference Shallit17, Theorem 12.2.2], which guarantees that every factor of length n of a paperfolding sequence can be found in a prefix of length $13n$ . Thus, we see that if there are t factors of length $n \geq 6$ , then there are $t+4$ factors of length $n+1$ : the t arising from those that can be extended in exactly one way to the right, and the $4$ additional from those that have two extensions.

Since there are $28$ factors of every run-length sequence of length $6$ (which we can check just by enumerating them, again using [Reference Shallit17, Theorem 12.2.2]), the result now follows by a trivial induction.

4 The regular paperfolding sequence

In this section, we specialise everything we have done so far to the case of a single infinite paperfolding sequence, the so-called regular paperfolding sequence, where the folding instructions are $1^{\omega } = 111\cdots $ . In [Reference Bunder, Bates and Arnold6], the sequence $2122321231232212\cdots $ of run lengths for the regular paperfolding sequence was called $g(n)$ , and the sequence $2, 3, 5, 7, 10, 12, 13, 15, 18, 19, 21,\ldots $ of ending positions of runs was called $h(n)$ . We adopt their notation. Note that $g(n)$ forms sequence A088431 in the OEIS, while the sequence of starting positions of runs $1, 3, 4, 6, 8, 11, 13, 14, 16,\ldots $ is A371594 . The sequence $h(n)$ of ending positions of runs is A381929 .

In this case, we can construct an automaton computing the nth term of the run length sequence $g(n)$ as follows:

The resulting automaton is depicted in Figure 2.

Figure 2

The lsd-first automaton RLR.

Casual inspection of this automaton immediately proves many of the results of [Reference Bunder, Bates and Arnold6], such as the multi-part Theorems 2.1 and 2.2. To name just one example, the sequence $g(n)$ takes the value $1$ if and only if $n \equiv 2, 7$ (mod $8$ ). We can also use Walnut to prove the other results from [Reference Bunder, Bates and Arnold6].

We can also specialise sp and ep to the case of the regular paperfolding sequence, as follows:

These automata are depicted in Figures 3 and 4.

Figure 3

Synchronised automaton sp_reg for starting positions of runs of the regular paperfolding sequence.

Figure 4

Synchronised automaton ep_reg for ending positions of runs of the regular paperfolding sequence.

Once we have these automata, we can easily recover many of the results of [Reference Bunder, Bates and Arnold6], such as Theorem 3.2. For example, if $n \equiv 1$ (mod $4$ ), then $h(n) = 2n$ . We can prove this as follows with Walnut:

The reader may enjoy constructing Walnut expressions to check the other results of [Reference Bunder, Bates and Arnold6].

Slightly more challenging to prove is the sum property, conjectured by Hendriks, and given in [Reference Bunder, Bates and Arnold6, Theorem 4.1]. We state it as follows.

Proof. The first step is to create an automaton tt computing $t(n)$ . Once again, we guess the automaton from data and then verify its correctness. It is depicted in Figure 5.

Figure 5

The automaton tt computing $t(n)$ .

To verify its correctness, we need to verify that tt indeed computes an increasing function $t(n)$ and further that the set $\{ t(n) \, : \, n \geq 1 \} = \{ 1,2, \ldots , \} \setminus H$ . We can do this as follows:

Now, we can verify parts (a)–(c) of Theorem 4.1 as follows:

and Walnut returns TRUE for all of these. This completes the proof.

5 Connection with continued fractions

Dimitri Hendriks observed, and Bunder et al. [Reference Bunder, Bates and Arnold6] proved, a relationship between the sequence of runs for the regular paperfolding sequence and the continued fraction for the real number $\sum _{i \geq 0} 2^{-2^i}$ .

As it turns out, however, a much more general result holds; it links the continued fractions for uncountably many irrational numbers to runs in the paperfolding sequences.

Theorem 5.1. Let $n\geq 2$ and $\epsilon _i \in \{ -1, 1\}$ for $2 \leq i \leq n$ . Define

$$ \begin{align*}\alpha(\epsilon_2, \epsilon_3, \ldots, \epsilon_n) := {1\over 2} + {1 \over 4} + \sum_{2\leq i\leq n} {\epsilon_i}2^{-2^i} .\end{align*} $$

Then, the continued fraction for $\alpha (\epsilon _2, \epsilon _3, \ldots , \epsilon _n)$ is given by $[0, 1, (2R_{1, \epsilon _2, \epsilon _3, \ldots , \epsilon _n})']$ , where the prime indicates that the last term is increased by $1$ .

As a consequence, the numbers $\alpha (\epsilon _2, \epsilon _3,\ldots )$ have continued fraction given by $[0, 1, 2R_{1, \epsilon _2, \epsilon _3, \ldots }]$ .

As an example, suppose $(\epsilon _2,\epsilon _3,\epsilon _4,\epsilon _5) = (1,-1,-1,1)$ . Then,

$$ \begin{align*}x(1,-1,-1,1) = 3472818177/2^{32} = [0, 1, 4, 4, 2, 6, 4, 2, 4, 4, 6, 4, 2, 4, 6, 2, 4, 5],\end{align*} $$

while $R_{1,1,-1,-1, 1} = 2213212232123122$ .

To prove Theorem 5.1, we need the ‘folding lemma’.

Lemma 5.3. Suppose $p/q = [0, a_1, a_2,\ldots , a_t]$ , t is odd and $\epsilon \in \{-1, 1\}$ . Then,

$$ \begin{align*}p/q + \epsilon/q^2 = [0, a_1, a_2, \ldots, a_{t-1}, a_t - \epsilon, a_t + \epsilon, a_{t-1}, \ldots, a_2, a_1].\end{align*} $$

We can now prove Theorem 5.1 by induction.

Proof of Theorem 5.1.

From Lemma 5.3, we see that if $\alpha (\epsilon _2, \epsilon _3, \ldots , \epsilon _n) = [0, 1, a_2, \ldots , a_t]$ , then

$$ \begin{align*}\alpha(\epsilon_2, \epsilon_3, \ldots, \epsilon_n, \epsilon_{n+1}) = [0, 1, a_2, \ldots, a_{t-1}, a_t - \epsilon_{n+1}, a_t + \epsilon_{n+1}, a_{t-1}, a_{t-2}, \ldots, a_3, a_2+1] .\end{align*} $$

Now, for the paperfolding sequence, $P_{1, \epsilon _2, \epsilon _3, \ldots , \epsilon _n}$ always ends in $-1$ . Write $R_{1, \epsilon _2, \epsilon _3, \ldots , \epsilon _n} = b_1 b_2 \cdots b_t$ . Then,

$$ \begin{align*}R_{1, \epsilon_2, \ldots, \epsilon_n, \epsilon_{n+1}} = b_1 \cdots b_{t-1}, b_t +1, b_{t-1}, \ldots, b_1\end{align*} $$

if $\epsilon _{n+1} = -1$ (because we extend the last run with one more $-1$ ), and

$$ \begin{align*}R_{1, \epsilon_2, \ldots, \epsilon_n, \epsilon_{n+1}} = b_1 \cdots b_{t-1}, b_t, b_t+1, b_{t-1}, \ldots, b_1\end{align*} $$

if $\epsilon _{n+1} =1$ .

Suppose

$$ \begin{align*} \alpha(\epsilon_2, \epsilon_3, \ldots, \epsilon_n) = [0, 1, (2R_{1, \epsilon_2, \epsilon_3, \ldots, \epsilon_n})'] = [0, 1, a_2, \ldots, a_t ] \end{align*} $$

and let $R_{1, \epsilon _2, \ldots , \epsilon _n} = b_1 b_2 \cdots b_{t-1}$ . Then,

$$ \begin{align*} &\alpha(\epsilon_2, \epsilon_3, \ldots, \epsilon_n, \epsilon_{n+1} ) = [0, 1, a_2, \ldots, a_{t-1}, a_t - \epsilon_{n+1}, a_t + \epsilon_{n+1}, a_{t-1}, \ldots, a_3, a_2+1] \\ &\quad= [0, 1, 2b_1, \ldots, 2b_{t-2}, 2b_{t-1} + 1 - \epsilon_{n+1}, 2b_{t-1} + 1 + \epsilon_{n+1}, 2b_{t-2}, \ldots, 2b_2, 2b_1,1] \\ &\quad= [0, 1, 2b_1, \ldots, 2b_{t-2}, 2b_{t-1} + 1 - \epsilon_{n+1}, 2b_{t-1} + 1 + \epsilon_{n+1}, 2b_{t-2}, \ldots, 2b_2, 2b_1 + 1] \\ &\quad= [0, 1, 2R_{1, \epsilon_2, \ldots, \epsilon_{n+1}}'] , \end{align*} $$

as desired.