Toward higher-order infinite time Turing machines: simulational $\Gamma$-machines

TL;DR

This paper explores new limit rules for infinite time Turing machines, aiming to develop models with properties similar to standard ITTMs, including the existence of a universal machine and matching writable and clockable ordinals.

Contribution

It introduces a set of constraints for limit rules that produce well-behaved infinite Turing machine models, extending the classical ITTM framework.

Findings

A set of four constraints ensures models have a universal machine.

Adding a fifth constraint guarantees the equality of writable and clockable ordinals.

Counter-example shows four constraints alone are insufficient.

Abstract

Infinite time Turing machines (ITTMs) have been introduced by Hamkins and Lewis in their seminal article arXiv:math/9808093. The strength of the model comes from a limit rule which allows the ITTM to compute through ordinal stages. This rule is simple to describe and another rule would lead to a different model of ordinal computation. The aim of this article is to define a collection of limit rules for which the models of infinite Turing machine they induce have nice properties, akin to that of the ITTM. Through the analysis of the universal ITTM and of its preponderant role in the study of the ITTM, we devise a set of four constraints. A limit rule satisfying those constraints yields a model of infinite machine for which we can define a universal machine. Adding a fifth constraint, we show that any limit rule definable in set theory which meets those constraints produces a model of infinite machine with the desired properties. Among those, the fact that the supremum of the writable ordinal matches that of the clockable ordinal. That is, with the usual notations, the equality $\lambda = \gamma$ holds for any of those limit rules. Eventually, we provide a counter-example to show that the four first constraints alone are not sufficient.

Equations

$$C_i(\alpha )=0⟷\exists \beta <\alpha \forall \delta \in [\beta ,\alpha [C_i(\delta )=0$$

$$n{\prec }_{\alpha }m⟷x[⟨n,m⟩]=1$$

$$C_i^m(\alpha +\beta )=C_i^{m,s_{\alpha }}(\beta )$$

$${}^{<On}\mathrm{A}=\bigcup _{\alpha \in On}{}^{\alpha }\mathrm{A}$$

$$i\prec j⟷x[⟨i,j⟩]=1$$

$$\Gamma (H_{\nu })[i]=k⟺L_{\nu }[y]\models \phi (i,m,y,k)$$

$$\Gamma (H_{\nu })[i]=0⟺L_{\nu }[y]\models \phi (i,m,y)$$

$$\Gamma (x^{\alpha })=x$$

$$\gamma (H{|}_i)=\Gamma (H){|}_i$$

$$\exists a\in A\forall \iota \in \left[{\nu }_{\mu },{\nu }_{\mu +1}\right[w[\iota ]=a\wedge w[{\nu }_{\mu +1}]\ne a$$

$$\mathrm{ctr}(w)(\iota )=w({\nu }_{\iota })$$

$$\gamma (h)=\gamma (H{|}_i)=\Gamma (H){|}_i=\Gamma (H^{\prime }){|}_i=\gamma (H^{\prime }{|}_i)=\gamma (h^{\prime })$$

$$\Gamma (H^{\alpha })=\Gamma (H^{{\alpha }^{\prime }})$$

$$\Gamma (H^{\alpha })=\Gamma (H^{\omega })$$

$$\sum _{i<\omega }\alpha \cdot {\omega }^{i+1}=\alpha \cdot {\omega }^{\omega }$$

$$L_{{\omega }_2}\models \exists {\alpha }_1<{\alpha }_2<{\alpha }_3$$

$$\wedge \mathrm{Lim}({\alpha }_1)\wedge \mathrm{Lim}({\alpha }_2)\wedge \mathrm{Lim}({\alpha }_3)$$

$$\wedge {\alpha }_2\cdot \omega <{\alpha }_3$$

$$\wedge \text{no new real number appear after construction stage }{\alpha }_1$$

$$L_{{\beta }_3}\models \exists {\beta }_2<{\beta }_2^{\prime }\mathrm{Lim}({\beta }_2)\wedge \mathrm{Lim}({\beta }_2^{\prime })\wedge C^m({\beta }_2)=x_2\wedge C^m({\beta }_2^{\prime })=x^{\prime }$$

$${\Gamma }_k(H)={\Gamma }_n(H)$$

$$\Gamma ((ij{)}^{\omega })=k$$

$$F_0=\left\{x\in {}^{\omega }2\mid x\in L_{{\lambda }_{{\Gamma }_{\sup }}^x}\right\}$$

$$Q=\left\{x\in {}^{\omega }2\mid x\in L_{{\omega }_1^{\mathrm{CK},x}}\right\}$$

$$x⪯y⟺{\lambda }^x⩽{\lambda }^y$$

$$\text{macc@depth}\text{@ne}\text{macc@set@skewchar}\text{macc@nested@a}111x:=⟨\top ,x,0,\beta ⟩$$

$$\text{macc@depth}\text{@ne}\text{macc@set@skewchar}\text{macc@nested@a}111x:=⟨\phi ,\text{macc@depth}\text{@ne}\text{macc@set@skewchar}\text{macc@nested@a}111p_1,\dots ,\text{macc@depth}\text{@ne}\text{macc@set@skewchar}\text{macc@nested@a}111p_n,\alpha ,\beta ⟩$$

$$\hat{a}:=x$$

$$\hat{a}:=\left\{y\in L_{\zeta \cdot \alpha +\beta }\mid L_{\zeta \cdot \alpha +\beta }\models \phi (y,\widehat{b_1},\dots ,\widehat{b_n})\right\}$$

$$L_{\zeta \cdot \alpha +\beta }\models \phi (\widehat{p_1},\dots ,\widehat{p_n})$$

$$L_{{\zeta }_{\Gamma }\cdot {\alpha }_j+{\beta }_j}\models \psi (x_i,\widehat{c_1},\dots ,\widehat{c_m})$$

$$\{\begin{array}{l}\widehat{p_i}\in L_{\zeta \cdot {\alpha }_j+{\beta }_j}\\ L_{\zeta \cdot {\alpha }_j+{\beta }_j}\models {\psi }_j(\widehat{p_i},\widehat{c_1},\dots ,\widehat{c_k})\end{array}$$

Full text

This article is extracted from the fifth chapter of the thesis [10] of Johan Girardot. It constitutes the first main contribution of this thesis and it aims to lay the groundwork for a generalized study of infinite Turing machines.

1 Introduction

Infinite time Turing machines (ITTMs) have been first introduced by Hamkins and Lewis in [12]. Since then it has been thoroughly studied. Recent surveys can be found, such as [1, 3], while new studies like [6, 5] continue to appear. Generalizations can also be found in [1, 9, 13]. We reintroduce briefly the model of the ITTM to explain the nature of those different generalizations.

The ITTM is a model of computation that computes through the hierarchy of the ordinals. It is built on the same structure as the classical finite Turing machine. Imagine a finite Turing machine $m$ that somehow managed to compute up to some limit ordinal stage $\alpha$. At this stage, it is in some state $q$, has some real number $x$ (an element of $\left\{0,1\right\}^{\mathbb{N}}$, which we more conveniently write ${}^{\omega}2$) written on its tape and its head is on some cell $i\in\mathbb{N}$. Following [12], we call the tuple of those data the snapshot of the machine at this computation stage. Given this snapshot, the computation step from stage $\alpha$ to $\alpha+1$, that is to say the snaphot at stage $\alpha+1$, is simply determined by the program (or the code) of $m$ using the classical rules of finite Turing machines. And so is the computation up to stage $\alpha+k$ for any finite $k$.

We see that the question left out in this description is: how does the machine “somehow computes” up to a limit stage? And what is interesting is that it is enough to answer this in order to have an effective infinite model of computation. As described, once a limit stage is reached by the computation, it carries on through the next successor stages as a classical finite Turing machine, until the next limit stage. The next definition is Hamkins and Lewis’ proposition to answer this question. This defines the model of the ITTM.

Definition 1.1** ([12]).**

An infinite time Turing machine (ITTM) $M$ is a machine which has the same structure as a three-tape finite Turing machine, those three tapes being called input, output and a working tape and such that:

• •

At any stage $\alpha+1$, the snapshot of the machine $M$ is determined by the snapshot of $M$ at stage $\alpha$ and by the program of the machine $m$ as done with classical finite Turing machines.

• •

At any limit stage $\alpha$, the head of $M$ is on the first cell, its state is some distinguished state $q_{limit}$ and for all cell $i$, writing $C_{i}$ for the (class) function that maps an ordinal stage to the value of the cell $i$ at this stage:

[TABLE]

That is the value of the cell $i$ at limit stage $\alpha$ is set to [math] if and only if there is some stage $\beta<\alpha$ at which the value of cell $i$ stabilized on [math] up to stage $\alpha$.

The important part of this definition is the limit rule (1) which uses the history of the machine to set the value of all cells at a limit stage. This limit rule is usually called the $\limsup$ rule: given some limit stage $\alpha$, the value of $C_{i}(\alpha)$ is simply defined as the $\limsup$ of the $C_{i}(\delta)$ for $\delta<\alpha$. Again, it is important to observe that, up to this point, this rule could be any kind of rule that unambiguously sets the value of any cell and at any limit stage as a function of this stage history. Changing this rule would simply yield a different model of ordinal computation.

1.1 Generalizations, state-of-the-art and the place of this work among those

From there, we can already distinguish two kind of generalizations: generalizations can be either rule-wise if they try to produce new limit rules, either machine-wise if they try to enhance the structure of the machine.

For some machine-wise generalizations, the reader can refer to [13] in which Koepke investigates on enhancements of the basic machine structure: what can be said if the tape is not $\omega$ long but $\alpha$ long for some limit ordinal $\alpha$? This yields $\alpha-$ITTMs and very interestingly provides the missing “mechanical” equivalent of $\alpha$-recursion. Further, it is possible to enhance the size of the tapes to $On$ itself (the class of all ordinals) as done in [4] to define “ordinal Turing machines” (OTM). In this case, this yields a model of computations whose behavior and power are closely related to $L$ the Gödel’s constructible universe. For example, Koepke shows how in $L$ every set of ordinals is computable with an OTM from a finite set of ordinal parameters.

The structure of the machine may also be more deeply modified to define infinite time register machine (ITRM). This is done in [14]: an ITRM has the structure of a register machine and at a limit stage its current line and its registers values are set to the $\liminf$ of their respective previous values. The register may be of ordinal size or again of size $On$ as described in [15]. The monograph [1] widely discusses those generalizations.

Even further, the work of Fischbach and Seyfferth in [8] could be seen as a radical machine-wise generalization. In this article, they develop an ordinal extension of lambda calculus in which a term can be the $\alpha$-fold composition of another term for $\alpha\in On$. Then, as in previous models of computation, the normal form procedure is an extension of the usual procedure for finite terms and again it relies, at limit stages, on an inferior limit.

As for “rule-wise” generalization, to this date and to the best of our knowledge, the only work published is that of Friedman and Welch in [9]. In this article, the authors devise a new limit rule, based on a $\liminf$ working with a dynamically restricted history. More precisely, there is a fourth tape called the “rule tape” and at any limit stage, the value of a cell is set as the inferior limit of a subset of its previous values, which subset is determined by the history of the rule tape. The authors show how this yields a model of computation strictly more powerful than ITTMs but which is equally “well-behaved” and which also exhibits strong links with the constructible hierarchy. We discuss this generalization further in the light of our study of the universal machine in Remark 3.35.

So, machine-wise generalizations provide new and interesting models of computation. They do so, for example, by filling the gaps left in the Church-Turing equivalence generalized to ordinal computation, as done by Koepke’s OTM or by Fischbach and Seyfferth’s ordinal lambda calculus. On the other hand, the concept of rule-wise generalization has it own interesting features and for the moment has been way less studied. One of those features is the scope and the easiness with which such generalizations can be devised: as seen, any limit rule plugged in the structure of the infinite time Turing machine yield a new model of ordinal computation. And as a limit rule is ultimately a formula in the language of set theory, this yields a rich parallel with logic and set theory. Understanding which formulas induce well-behaved and interesting models of infinite machines may gives us new pieces of information regarding those.

It is clear that not any formula which can be seen as limit rule will give rise to as a well-behaved and interesting model as that of ITTMs. One way to measure the interest of such models is to compare them to the classical ITTM. In the case of ITTM, its power can easily be equated with the largeness of its writable and clockable ordinals and one very good representative of its theorical interest is the equality $\lambda=\gamma$. This equality, whose truth was left open in [12] and established in [17], links two constants of very different nature. Here $\lambda$ is the supremum of the writable ordinals, that is ordinals appearing on the output of some halting ITTM, while $\gamma$ is the supremum of the clockable ordinals, that is ordinals corresponding to the halting time of an ITTM. This equality is fruitful as it provides a link between ITTMs and the constructible hierarchy. For example, with it, we know that all writable sets are written before stage $\gamma=\lambda$ and so are in $L_{\lambda}$ while the fact that all ordinals below $\lambda$ are writable implies that any set in $L_{\lambda}$ is writable.

This equality was proven using the universal ITTM and we will see how, more generally, the successes of the model of the ITTM are themselves rooted in the existence of a universal machine. So naturally, in this article, we will be interested in limit rules which yield a model of infinite machines for which there exists a universal machine. In particular, the main result of this paper is Theorem 4.14. It proves a structural property which generalizes the equality $\lambda=\gamma$ for such models of infinite machines, which also are definable in set theory while satisfying a safeguard condition. This safeguard condition is moreover shown to be required in Theorem 5.1.

Hence, in this paper, working our way through the possibility of devising interesting and well-behaved rule-wise generalizations, our first leading question will be: how and why does the universal ITTM work?

1.2 Results and organization of the paper

To begin answering this question, “how and why does the universal ITTM work?”, we start in Section 2 with a brief overview of the ITTM and of common state-of-the-art proof techniques. This will put into light the importante role of simulations and, in particular, of the universal ITTM and provide the main intuitions behind this work. More precisely, we begin this section by proving a slightly new structural equality (which generalizes the equality $\lambda=\gamma$ proved in [17]) for the usual ITTMs. This proof shows how the universal machine is canonically used in this kind of advanced proofs developed by Welch in [17]. We then try to understand what is implicitly needed in this proof regarding the universal machine and more generally regarding the possibility of simulating other machines. At the end of this discussion, we exhibit five critical characteristics satisfied by the usual $\limsup$ limit rule. The first four of those form a sufficient condition for a given limit rule to yield a model of ITTM in which a universal machine exists. Again, this section serves as an extended introduction presenting the motivations and intuitions for this article.

In Section 3 starts, strictly speaking, the formal work. We provide general definitions for the article as well as a general definition of what we call a limit rule. It can indeed be seen as an operator that maps ordinal words, representing the history of the computation, to collection of symbols in the alphabet of the machine, representing the tapes. With this formal definition we then formalize the five conditions found in the previous section.

In Section 4, we start by showing in Theorem 4.1 that the $\limsup$ and the $\liminf$ operators are, surprisingly, the only two-symbol limit operators satisfying this set of five conditions. This steers the search for higher order machines toward a yet unexplored direction: $n$-symbol infinite Turing machine. We then show that for any $n$-symbol Turing machine that satisfies those five conditions and definable by a set-theoretic formula, we can establish many of the results established for the classical ITTMs. The most important one, Theorem 4.14, whose proof takes the larger part of the section, is a strong constant equality relating the clockable ordinals and the writable ordinals (For the general case, those constants are introduced in Section 3). A corollary of this equality is that for those models, the generalization of the equality $\lambda=\gamma$ also holds.

In Section 5 we eventually show in Theorem 5.1 that the fifth condition, acting as a safeguard and not needed for an operator to yield a model of machine with a universal machine, is however needed for the main theorem, i.e. Theorem 4.14. It is needed in the sense that, without it, we can devise a limit rule for which the equality of the main theorem does not hold.

2 Eventually clocking and accidentally clocking

As mentioned, this section is meant to contextualize this work and its seminal observations within the study of the ITTMs and the techniques commonly used. To this extent we briefly reintroduce some key concepts of Hamkins ITTMs as well as the proofs of some main results. This will also highlight the importance of some of the implicit properties of the $\limsup$ rules. Everything we define or redefine, in a more or less formal way, will be formally defined in Section 3 in a more general setting.

In the model of the ITTM, as in the finite model of Turing machines, the machine can produce an output: when a machine halts, whatever is written on its output tape is understood as its output. While in the finite Turing machines case the output can be seen as an integer, in the infinite case, it will be seen as a real number. Hence a real number can be written as output and we say that the real number was written and so that it is writable.

But more interestingly, as done in [12], in the infinite setting of ITTMs we can define different degrees of writability for the real numbers. As said, a real number $x$ can be writable if there is a machine that halts (by reaching its distinguished state $q_{halt}$) and, upon halting, which has $x$ written on its output tape. But it can also be eventually writable (sometimes abbreviated e.w.) if there is a machine that never stops and that, at some point, has $x$ written on its output tape and never modifies it afterward. It can be accidentally writable (sometimes abbreviated a.w.) if there is a machine in which $x$ is written on any of its tapes at any stage of its computation, even if it is modified or erased just after. It is easy to see that being writable implies being eventually writable implies being accidentally writable.

Then, an ITTM can also “write” ordinals. It writes an ordinal when it writes a real number that encodes this ordinal: we say that $x$ encodes $\alpha$ when $x$ describes some well-order $\prec_{\alpha}$ on $\omega$ in the following way:

[TABLE]

and such that the order-type of $\prec_{\alpha}$ is $\alpha$. What motivates this definition is a fundamental result of Hamkins and Lewis, Theorem 2.2 of [12], which states that, with this encoding, an ITTM can decide whether a real number encodes a well-order.

So, as ordinals can be written, we may wonder what kind of ordinals can be written, or at least accidentally written. First, given the simple fact that ITTMs have $\omega$ cells, they can only write countable ordinals. Moreover, as there are countably many ITTMs, the writable and the eventually writable ordinals are bounded in $\omega_{1}$; that is their union is countable as well. However, it may not seem so clear whether this fact holds for the accidentally writable ordinals, since a single machine will accidentally write many different ordinals through its computation. Still it happens that those are bounded as well. Hence, as introduced in [12] there exists three supremum ordinals, $\Sigma$, the supremum of the accidentally writable ordinals, $\zeta$, the supremum of the eventually writable ordinals and $\lambda$, the supremum of the writable ordinals.

Additionnaly Hamkins and Lewis define the clockable ordinals. An ordinal $\alpha$ is clockable when there is some machine which halts just after carrying out its $\alpha^{th}$ step of computation. That is, through this $\alpha^{th}$ step, it transitions from stage $\alpha$ to stage $\alpha+1$ and, in this latter stage, the machine reached the state $q_{halt}$. Then as previously, there is $\gamma$ the supremum of the clockable ordinals. One important question left open in [12] was: does $\lambda=\gamma$? This was answered positively in Theorem 1.1 of [17] using a universal machine; which now brings us to this machine and its importance.

A universal machine $\mathcal{U}$ is a machine that simulates simultaneously all ITTMs. It was already used by Hamkins and Lewis in Theorem 3.4 of [12] and its importance appears even more clearly in [17]. To illustrate this, we give a proof of a slightly more general equality than that established by Welch, but which relies on the same ideas. As there are three different ways for an ordinal to be written (writable, eventually writable and accidentally writable), we would also can devise three ways for an ordinal to be clockable: and this can be done by saying that: $\alpha$ is eventually clockable (e.c.) when the output of some converging machine $m$ stabilizes at stage $\alpha$, and $\alpha$ is accidentally clockable (a.c.) when there is a computation in which at stage $\alpha$ some real number $x$ appears for the first time in the computation. Then we can write $\eta$ the supremum of the eventually clockable ordinals and $\mathrm{T}$ (capital $\tau$) the supremum of the accidentally clockable ordinals. And with the latter, we can show the following result, with $\Sigma$ being the supremum of the accidentally writable ordinals.

Proposition 2.1** ([17]).**

$\Sigma=\mathrm{T}$. That is the supremum of the accidentally writable ordinals is equal to that of the accidentally clockable ordinals.

This proposition, while stated here in a new way, is very close to Corollary 3.5 of [17] which states that the collection of sets encoded by accidentally writable real numbers is actually $L_{\Sigma}$. In this article from Welch, it was a corollary of the fact that $\lambda=\gamma$ and this fact is itself a corollary of Theorem 2.1 here, as will be proved in a more general setting in Corollary 4.31. Another corollary is the fact that, with previous notations, $\zeta=\eta$. So this downward chain of consequences likely justify this new phrasing. Moreover, as said, the proof of this slightly more general result uses the same technique as that of the main proposition of [17]. Finally, we take for granted in this proof that there exists a universal ITTM $\mathcal{U}$ and that we can design, in a natural way, machines which simulate other machines. Those fact are actually true and we will come back to those.

Proof.

First, suppose that $\Sigma>\mathrm{T}$. This implies that $\mathrm{T}$ is accidentally writable by some machine $m_{\mathrm{T}}$. So we consider the following machine $\mathcal{M}$. It will use the code of $\mathrm{T}$ that appears at some point in $m_{\mathrm{T}}$ to write something for the first time after stage $\mathrm{T}$, hence reaching a contradiction. To do this, first, it keeps the first cell of its working tape always set to [math] and the first cell of its output tape always set to $1$. So when using its working tape, it uses cells $i>0$. Then, it simulates $m_{\mathrm{T}}$ on some part of its working tape (again, without using cell $i=0$) and each time an ordinal $\alpha$ is written in the simulation of $m_{\mathrm{T}}$, it counts for at least $\alpha$ steps. Remember that by [12, Theorem 2.2] it can recognize real numbers describing well-orders. This is done by trying to count through it, so it takes at least $\alpha$ steps to recognize that a real number encodes a well-order of order type $\alpha$. Then, it copies $\alpha$ on its output tape, without using the first cell that it keeps to $1$. Now, when $\mathrm{T}$ appears for the first time at stage $\alpha_{\mathrm{T}}$: as $\mathrm{T}$ appears for the first time in $m_{\mathrm{T}}$ and $\mathrm{T}$ is the supremum of the a.c., that is of the stages of first appearance in a given machine, we have $\alpha_{\mathrm{T}}<\mathrm{T}$. Then, $\mathcal{M}$ counts for at least $\mathrm{T}$ steps and after those writes $\mathrm{T}$ on its output tape. This is the first time that $\mathrm{T}$ appears on this tape. Also, the whole content of this tape, with the first cell set to $1$ cannot have appeared earlier in the working tape whose first cell is left on [math]. Hence the real number it writes was not written before and it is written for the first time at least at stage $\alpha_{\mathrm{T}}+\mathrm{T}\geqslant\mathrm{T}$. And $\alpha_{\mathrm{T}}+\mathrm{T}$ is consequently a.c. which is a contradiction. So $\Sigma\leqslant\mathrm{T}$.

For the other direction, to show that $\Sigma\geqslant\mathrm{T}$, we will show that in any computation that does not halt, for any cell on any tape, the values of this cell at stages $\zeta$ and $\Sigma$ match and moreover that a cell set to [math] at stage $\zeta$ stays forever so. This will prove that nothing new is ever written after stage $\Sigma$, as the machine will be repeating indefinitely the segment of computation $\left[\zeta,\Sigma\right[$ and so that $\Sigma\geqslant\mathrm{T}$. Let $m$ be a machine and $i\in\omega$ be some cell on one of its tape.

• •

Suppose $C_{i}(\Sigma)=0$. Then, by the limsup rule, the cell must have converged to [math] at some least ordinal stage $\alpha<\Sigma$. That is $C_{i}(\alpha)=0$ and stays so up to $\Sigma$. We show that $\alpha<\zeta$ (this is actually Main Proposition of [17]). We design a machine $\mathcal{M}$ that does the following: it launches a copy $\mathcal{U}_{1}$ of the universal machine and for each ordinal $\beta$ appearing in the computation of $\mathcal{U}_{1}$, that is accidentally written in a machine simulated by $\mathcal{U}_{1}$, $\mathcal{M}$ writes this ordinal on its output tape and simulates $m$ up to this ordinal $\beta$. If $C_{i}^{m}(\beta)=0$, it launches a new copy $\mathcal{U}_{2}$ of the universal machine and each time some ordinal $\beta^{\prime}>\beta$ is appears in $\mathcal{U}_{2}$, it simulates a fresh copy of $m$ up to stage $\beta^{\prime}$ and looks whether the cell $i$ was set back to $1$ between $\beta$ and $\beta^{\prime}$. If it was, $\mathcal{M}$ goes back to its simulation of the universal machine $\mathcal{U}_{1}$ and looks for the next such ordinal $\beta$, that is such that $C_{i}^{m}(\beta)=0$. When $\beta>\alpha$, the machine never find $1$’s anymore in the history of cell $i$ after this $\beta$, as all $\beta^{\prime}>\beta$ generated are strictly between $\alpha$ and $\Sigma$. Hence, $\beta$ is written on the output and $\mathcal{M}$ looks indefinitely for $\beta^{\prime}>\beta$ at which a $1$ appear on cell $i$. And so $\mathcal{M}$ actually eventually writes some $\beta>\alpha$. As such, $\beta$ is eventually writable and we have $\alpha<\beta<\zeta<\Sigma$ and $C_{i}(\zeta)=0$ as well.

• •

Suppose now that $C_{i}(\zeta)=0$. Then, the value of the cell converged at some $\alpha<\zeta$ and there exists a machine $m_{\alpha}$ that eventually writes $\alpha$. We consider the following computation from a machine that we call $\mathcal{W}$: It simulates $m_{\alpha}$ on some part of its working tape, which will eventually write $\alpha$. Each time an ordinal $\beta$ is written on the simulated output tape of $m_{\alpha}$, it does the following: while $\beta$ does not change (that is the simulation of $m_{\alpha}$ is intertwined by dovetailing with the rest of the computation) it simulates $\mathcal{U}$ and, each time $\mathcal{U}$ (accidentally) writes an ordinal $\beta^{\prime}>\beta$, $\mathcal{W}$ starts by simulating $m$ up to $\beta$ and then up to $\beta^{\prime}$. If it finds a $1$ in the cell $i$ between stages $\beta$ and $\beta^{\prime}$, it writes $\beta^{\prime}$ on the output tape and stops this part of the computation. Note that as the simulation of $m_{\alpha}$ is still going on, it might start again from the beginning later, if its output value changes. However, at some point $\alpha$ is written in $m_{\alpha}$ and does not change anymore. At this point, if $\mathcal{W}$ finds a $1$ between stages $\beta=\alpha$ and some $\beta^{\prime}>\alpha$, this $1$ must appear after $\zeta$ (as the value of the cell converges to [math] at stage $\alpha$ and up to stage $\zeta$) and then $\beta^{\prime}$, which it has consequently eventually written is greater that $\zeta$, which is a contradiction. Hence, the value of $C_{i}$ never changes after stage $\zeta$ and $C_{i}(\Sigma)=0$ and this concludes the proof.

∎

The proof of Proposition 2.1 is somewhat of a classical proof in the theory of ITTMs, at least in its usage of simulations and in particular in that of the simulation of the universal machine $\mathcal{U}$. Hence, the question that we postponed: how does the universal ITTM work? Does it actually exist and how can we describe it?

To answer this, observe that $u$, the classical three-tape finite universal machine, gives almost immediately rise to an infinite time universal machine that simulates a single other ITTM. Indeed, in the finite setting, $u$ is such that given the code of some finite machine $m$, it simulates $n$ steps of $m$ in less than $Cn^{2}$ steps for some constant $C$, supposing that $u$ works in a straightforward fashion. How does it work? Without going into the finicky details, each cell $i$ of $m$ is simulated by some cell $I$ of $u$. That is, for any finite stage $k$, the value of $I$ in $u$ at stage $Ck^{2}$ is the value of $i$ in $m$ at stage $k$, and the next value to be written in $I$, after some steps, is that of the cell $i$ at stage $k+1$. Outside of those cells $I$, the other cells of $u$ are used to keep track of the simulation, in particular of the position of the head and of the state of the simulated machine $m$.

Now consider the ITTM $\mathcal{U}_{0}$ whose code is the same as $u$. Remember indeed that the structure of an ITTM is exactly that of a three-tape classical Turing machine. Similarly, we can see $m$ as an ITTM, which we denote by $M$. What happens when $\mathcal{U}_{0}$ computes with the code of $M$ as input (which we write $\langle M\rangle$)? By construction, for any finite stage $k$, the snapshot of $\mathcal{U}_{0}[\langle M\rangle]$ at stage $k$ will be the same as that of $u[\langle M\rangle]$. But $M$ and $m$ share the same code, so this is the same thing as $u[\langle m\rangle]$. Hence, for the first $\omega$ steps, the computation of $\mathcal{U}_{0}[\langle M\rangle]$ is the same as that of $u[\langle m\rangle]$. In other words, the ITTM $\mathcal{U}_{0}$ with the code of $M$ as input simulates the ITTM $M$ through all the finite stages.

But what happens a stage $\omega$? That is, what is the snapshot of $\mathcal{U}_{0}[\langle M\rangle]$ at stage $\omega$? Take some cell $i$ of $M$. It is simulated by some cell $I$ of $\mathcal{U}_{0}$. Hence, suppose $i$ in $M$ stabilizes on [math] before stage $\omega$. That is, with the $\limsup$ rule, $C^{M}_{i}(\omega)=0$. Then, so does $I$ in $\mathcal{U}_{0}[\langle M\rangle]$ and $C^{\mathcal{U}_{0}}_{I}(\omega)=0$ and same goes for the cells $i^{\prime}$ such that $C^{M}_{i^{\prime}}(\omega)=1$. Hence, the simulation of the limit rule for the simulated cell $i$ in $M$ comes directly from the limit rule itself applied to the simulating cell $I$ in $\mathcal{U}_{0}$. This means that at stage $\omega$ in the computation $\mathcal{U}_{0}[\langle M\rangle]$, the content of the different cells $I$ describes exactly that of the cells $i$ in $M$ at stage $\omega$. From there, to simulate the ITTM $M$ further through the ordinals, only a few things are missing at limit stages: $(1)$ the auxiliary cells used for the simulation will likely all be set to $1$ and those need to be tidied up, $(2)$ the simulated head of $M$ should be back on the first simulated cell and $(3)$ the simulated state of $M$ should be set to $q_{limit}$. But since at any limit stage $\mathcal{U}_{0}$ reaches its own distinguished state $q_{limit}$, it is easy from there to modify the machine $\mathcal{U}_{0}$ in order to have it tidy up its auxiliary cells and to set the correct head position and state for the simulated machine. This takes a finite number of steps and after those the simulation goes on, in time for the next limit ordinal stage.

This previous description yields a universal infinite time machine $\mathcal{U}^{\prime}_{0}$, slightly adapted from $\mathcal{U}^{\prime}_{0}$, which simulates a single ITTM. From it we can simply enough describe the universal machine $\mathcal{U}$ that simulates all ITTMs at once. $\mathcal{U}$ works with its working tape as if it were $\omega$ different tapes in which it simulates in parallel all computations $\mathcal{U}^{\prime}_{0}[m]$ for all machines $m\in\omega$. For $\mathcal{U}$ to split its working tape, this can be done as follows: first, all even cells (that is cells on the workings tape whose index $i$ is even) are kept aside (metaphorically) and they will constitute a virtual working tape of its own that the machine uses to keep track of its simulations of all the $\mathcal{U}_{0}[m]$’s. The idea being that its easy for it to “stay” on this virtual tape while it reads it as it just needs to shift its head twice to the left or to the right of the real tape to move on this virtual tape. And using this first virtual tape it can split the odd cells into $\omega$ tapes, e.g. the virtual tapes of some machine $m$ will be constituted of the cells $(f(m,i))_{i}$ for any computable function (in the finite sense) $f$ that partitions the odd integers into $\omega$ unbounded sets. Then, when $\mathcal{U}$ begins, it initializes all its virtual tapes $m$ as would $\mathcal{U}^{\prime}_{0}[m]$ initializes its working tape, which takes $\omega$ steps. Then begins the simulation itself. By dovetailing, that is simulating the machines $m$ in cascade, $k$ steps of the first $k$ machines, $k+1$ steps of the first $k+1$ machines, etc. it simulates $\omega$ steps of all of those machines in $\omega$ steps of itself; which should be enough for the description of $\mathcal{U}$.

Now, why does the universal machine works? That is, what is implicitly used in this explanation? First, as a cell $i$ of some machine $m$ (we now drop the capital $m$ and only consider ITTMs) will likely be simulated by a cell $I\neq i$ in $\mathcal{U}$, it uses the fact that all cells are governed by the same limit rule. Also, it uses the fact that the limit value of the cell $I$ only depends of the history of this very cell. The context of those cells (e.g. the neighboring cells) may greatly vary. So we rely on the fact that the limit rule only looks at the histories $h_{i}$ and $h_{I}$, the histories of respectively the cell $i$ in $m$ and the cell $I$ in $\mathcal{U}$. When a rule only looks at the history of a given cell to define the limit value of this cell, we will say that the rule is cell-by-cell. Further, for a limit ordinal $\alpha$, in order to say that $C_{i}^{m}(\alpha)=C_{I}^{\mathcal{U}}(\alpha)$, where $C_{i}^{m}(\alpha)$ denotes the value of cell $i$ in $m$ at stage $\alpha$, we use the fact that $h_{i}$ and $h_{I}$ are somewhat the same.

But what is meant by this ? Are the histories $h_{i}$ and $h_{I}$ not actually equal? Suppose that $m$ is a very simple machine that continuously blinks its cell $i$. To do so, first, the head of $m$ needs $i$ steps to reach the cell $i$. As the cell $i$ is initially set to [math], its history begins with $0^{i}$, that is the word made from the letter [math] repeated $i$ times. At stage $i+1$, the cell $i$ in $m$ is set to $1$. Its history is now $0^{i}1$. And then back to [math], then again to $1$ and so on. Hence, at some limit stage $\alpha$, its history reads $0^{i}(10)^{\alpha}$. Now what does the history of cell $I$ in $\mathcal{U}$ read? We can merge in $\mathcal{U}$ the $\omega$ steps of initialization with the actual simulation, but in any case, the machine will begin the actual simulation of $m$ after some $k$ strictly greater than $i$. Hence, $h_{I}$ begins with $0^{k}$. At stage $k+1$, $\mathcal{U}$ writes a $1$ in cell $I$ and the history of $H_{i}$ reads $0^{k}1$. But, and this is one of important point, after having simulated this step from $k$ to $k+1$ in $m$, $\mathcal{U}$ will then be simulating at least the machine $m+1$ for a certain number of steps and. And it won’t be coming back to $m$ before some finite number of steps $k_{2}$. In the meantime, during those $k_{2}$ steps, the cell $I$ stays set to $1$. So, after those $k_{2}$ steps, $H_{i}$ reads $0^{k}1^{k_{2}}$. And so, as the computation goes on, $H_{i}$ will look like: $0^{k}1^{k_{2}}0^{k_{3}}\ldots 1^{k_{\alpha}}0^{k_{\alpha+1}}\ldots$ where each $k_{\nu}$ are finite and strictly greater than $1$. So, to some extent, $h_{i}$ and $H_{i}$ are not quite the same. Still we could say that $h_{i}$ is the contraction of $H_{i}$, that is the word obtained by contracting any $1^{k}$ or $0^{k^{\prime}}$ respectively to a $1$ or a [math]. And $\mathcal{U}$ operates as it should because, as we will say, the $\limsup$ rule is contraction-proof. The limit value of a cell does not change if we contract (or conversely dilate) its history. And here, we could say that the dilatation from $h_{i}$ to $H_{i}$ is only finite as all $k_{\nu}$ are finite, but in practice, when we use $\mathcal{U}$ or when we simulate any other machine, it is very common to keep it “on hold” for extensive periods of computation, as in the first part of the proof of Proposition 2.1. In such a case the $k_{\nu}$’s may be infinite ordinals and a priori unboundedly big.

Other than that, keeping a simulated machine “on hold” for some infinite ordinal amount of steps $\alpha$, implicitly makes use of the fact that the cells that aren’t written on (i.e. whose content is not modified) won’t change their content at limit stages. We can say that the $\limsup$ rule is stable as the content of a cells which stabilized up to a limit stage does not change at said limit stage.

Eventually, there is a last feature of the Hamkins and Lewis ITTMs that is used implicitly. Take the computation of some machine $m$ up to some limit stage $\alpha$. Then consider a fresh computation of $m$ in which the initial snapshot (that is the content of the tapes, the state and the head position) is set to match that of $m$ after those $\alpha$ steps. In this second computation, stage [math] corresponds to stage $\alpha$ in the first computation. Still in both cases, observe that it leads to the same subsequent computation. Hence, for any stage $\beta$ we would like, for all cell $i$, writing $s_{\alpha}$ for the snapshot of $m$ at stage $\alpha$ and $C^{m,s}_{i}$ for the function that maps an ordinal to the content of the cell $i$ at this ordinal stage in the computation of $m$ that starts with $s$ as its snapshot, that

[TABLE]

This clearly holds in the classical model of ITTM for finite $\alpha$ and $\beta$. For $\alpha$ and $\beta$ limits, it means that even if the history $h_{i}$ of length $\alpha+\beta$ is truncated to the final segment $h^{\prime}_{i}$ of length $\beta$, it still yields the same limit value with respect to the $\limsup$ rule. This means more generally that for any histories $h$ and $h^{\prime}$ such that $h^{\prime}$ is a final segment (or suffix) of $h$, then $h$ and $h^{\prime}$ yield the same limit value. This easily seen to be true for the $\limsup$ limit rule and we will say that it is asymptotical.

This quick glance into the characteristics usual limit rule and which are implicitly used in the universal machine leads us to distinguish four characteristics (formalized in the next section): those $\limsup$ and $\liminf$ limit rules are cell-by-cell, contraction-proof, asymptotic and stable. And, as we will see, those conditions are sufficient for the universal machine to be easily described and may likely be necessary for it to exist in a satisfying form. To those, we can add the looping stability which somehow equates to the fact that a machine can be seen to be looping without looking at its entire computation through $On$. For example, a $\limsup$ ITTM is seen to be looping if there are two stages sharing the same snapshot such that cells that are set to [math] at both of those stages are also set to [math] for the whole segment of computation that spans between those two stages. Without it, we could easily conceive a pathological machine that repeats for some gigantic ordinal amount of time and after which, thanks to its rule, that escapes the repeating pattern.

As stated, the interesting result, which we show at the beginning of Section 4 is that the $\limsup$ and $\liminf$ rules are the only $2$-symbol rules that satisfy this set of five conditions. In other words, they likely are the only $2$-symbol rules allowing for natural simulations and having an easy-to-describe universal machine while also satisfying the condition of looping stability. Further, as mentioned, the main theorem of this paper shows the following strong result: for a $n$-symbol rule definable by a set-theoretic formula and that satisfies those five conditions, the supremum of the accidentally writable ordinals matches with that of the a.c. ordinals, that is $\Sigma=\mathrm{T}$ for all those rules. In the last section, we provide a counter-example to show that this theorem is tight. Namely, we show that there exists a limit rule that satisfies all those conditions but that of looping stability and such that, for the machines ruled by it, the equality $\Sigma=\mathrm{T}$ does not hold.

3 General definitions and conditions on operators

In order to formaly study limit rules, we need first to define what a limit rule is. In [16], Welch introduces the concept of operator. A $n$-symbol limit rule can be seen as an operator $\Gamma:{}^{<On}(^{\omega}n)\rightarrow{}^{\omega}n$, that is a function that given any computation history seen as an ordinal-indexed limit sequence of $n$-symbol real numbers (corresponding to tape contents) yields a $n$-symbol real number that will represent the tape content at the next limit stage. As noted, the data of an operator $\Gamma$ is enough to produce a model of infinite time Turing machine whose limit stage behavior is ruled by this operator. Such machines will be called $n$-symbol $\Gamma$-machines. We start by introducing some general concepts.

3.1 General definitions on ordinal words

Definition 3.1** (Additively closed ordinals).**

An ordinal $\alpha$ is additively closed when, for all $\beta,\delta<\alpha$, $\beta+\delta<\alpha$. The additively closed ordinals are known to be the ordinals of the forms $\omega^{\beta}$ for some ordinal $\beta$.

Definition 3.2** (Multiplicatively closed ordinals).**

An ordinal $\alpha$ is multiplicatively closed when, for all $\beta,\delta<\alpha$, $\beta\cdot\delta<\alpha$. The multiplicatively closed ordinals are known to be the ordinals of the forms $\omega^{\omega^{\beta}}$ for some ordinal $\beta$.

Definition 3.3** (Ordinal word).**

An ordinal word $w$ of length $\lambda$ on some alphabet $\mathrm{A}$ is a function from $\lambda$ to $\mathrm{A}$ that maps every ordinal $\iota<\lambda$, seen as a position or index in the word, to a letter in $\mathrm{A}$. We write $w[\iota]$ for the letter at position $\iota$ in $w$ and $w[\iota,\kappa[$ the subword of $w$ staring at position $\iota<\kappa$ up to position $\kappa$ non included. We write $|w|$ for the length of the word $w$ and when $|w|$ is finite, this coincides with the definition of words in the ordinary theory of formal languages. When $|w|$ is a limit ordinal, we say that $w$ is a limit word. Eventually, we write ${}^{\alpha}\mathrm{A}$ for the set of ordinals words of length $\alpha$ on the alphabet $\mathrm{A}$ and we write ${}^{<On}\mathrm{A}$ for the class of ordinal words of any length on the alphabet $\mathrm{A}$. That is:

[TABLE]

Example 3.4**.**

Consider an infinite Turing machine $m$ with two symbols, [math] and $1$, that computes with any limit rule and whose computation reaches some stage $\alpha$. For any cell $i$, this induces a function $C_{i}$ that maps $\beta\leqslant\alpha$ to the value of the cell $i$ at stage $\beta$. This also induces an ordinal word $h_{i}$ of length $\alpha+1$ on the alphabet $2=\left\{0,1\right\}$ such that for any $\beta\leqslant\alpha$, $h_{i}[\beta]=C_{i}(\beta)$. Also, the content of the three tapes at any stage $\beta$ can be described, as an ordinal word $w_{\beta}\in{}^{\omega}2$, that is a word of length $\omega$ on the alphabet $2$. This can simply be done using an usual encoding to describe the three tapes of length $\omega$ in a single word of length $\omega$. Combining both those points of view, this computation induces an ordinal word $W\in{}^{\alpha+1}(^{\omega}2)$, that is a word of length $\alpha+1$ on the alphabet ${}^{\omega}2$ such that for any stage $\beta\leqslant\alpha$, $W[\beta]=w_{\beta}$.

Definition 3.5** (Stutter-free).**

Let $h$ be an ordinal word on some alphabet $\mathrm{A}$. We say that $h$ is stutter-free when for all $\alpha+1$ index of $h$, $h[\alpha]\neq h[\alpha+1]$; that is the $\alpha^{th}$ letter of $h$ is different from the $\alpha+1^{th}$.

Definition 3.6** (Suffixes and prefixes).**

Given $u$ and $v$ two ordinal words, we say that $u$ is a prefix or an initial segment of $v$, written $u\sqsubseteq v$ when $|u|\leqslant|v|$ and for all $\iota<|u|$, $u[\iota]=v[\iota]$. We say that $u$ is a suffix or a final segment of $v$, written $v\sqsupseteq u$ when $|u|\leqslant|v|$ and there exists $\alpha$ such that $\alpha+|u|=|v|$ and for all $\iota\in\left[\alpha,|v|\right[$, that is for all $\iota=\alpha+\iota^{\prime}<|v|$, we have $u[\iota^{\prime}]=v[\iota]$.

Definition 3.7** (Operations on words).**

Given two words $u$ and $v$ and $\alpha$ an ordinal, we write $uv$ for the concatenation of $u$ and $v$ of ordinal length $|u|+|v|$ and $u^{\alpha}$ for the word made from $u$ concatenated $\alpha$ times to itself, of length $|u|\cdot\alpha$.

3.2 General definitions on machines

Definition 3.8** (Operators and $\Gamma$-machines, [16]).**

For a natural number $n$, an $n$-symbol limit rule operator $\Gamma$ is a (class) function $\Gamma:{}^{<On}(^{\omega}n)\rightarrow{}^{\omega}n$ that maps ordinal words on the alphabet ${}^{\omega}n$, seen as computation histories of $n$-symbol machines, to element of ${}^{\omega}n$, seen as tape contents. A $\Gamma$-machine is an infinite Turing machine whose limit rule is that induced by the operator $\Gamma$.

We now introduce basic definitions regarding $\Gamma$-machines. Naturally, as $\Gamma$-machines and Hamkins’ ITTM have the same structure, most of those definitions are identical to the definition given in the specific context of Hamkins’ ITTM.

Definition 3.9**.**

We write $\Gamma_{\sup}$ and $\Gamma_{\inf}$ the operators associated respectively to the $\limsup$ and the $\liminf$ rule.

Definition 3.10** (Looping, [12]).**

For $\Gamma$ a limit operator and $m$ a $\Gamma$-machine, we say that $m$ is looping when the machine never halts and some interval of computation $\left[\alpha,\alpha+\beta\right[$ repeats itself through the whole computation of $m$ after stage $\alpha$. That is for any stage $\nu\geqslant\alpha$, writing $\nu=\alpha+\beta\cdot\delta+\nu^{\prime}$ with $\delta$ maximal, the snapshot of $m$ at stage $\nu$ is the same as that of $m$ at stage $\alpha+\nu^{\prime}$.

Definition 3.11** (Writable real numbers, [12]).**

For $\Gamma$ a limit operator, a real number $x$ is $\Gamma$-writable if there is a $\Gamma$-machine which, when computing from the empty input, halts with $x$ written on its output.

Definition 3.12** (Converging, [12]).**

For $\Gamma$ a limit operator and $m$ a machine computing on some input $y$ we say that $m$ converges or converges definitively when it never halts and when after some stage its output tape is never modified again. We say that $m$ converges up to some ordinal $\alpha$ when it does not halt before stage $\alpha$ and after some stage $\beta<\alpha$ its output tape is never modified before stage $\alpha$. Observe that the definition of converging involves only the output tape: often, converging machines will continue to modify their working tape through the whole computation.

Definition 3.13** (Eventually writable real numbers, [12]).**

For $\Gamma$ a limit operator, a real number $x$ is $\Gamma$-eventually writable if there is a $\Gamma$-machine which converges when computing from the empty input and has $x$ written on its output tape when the content of its output tape stabilized.

Definition 3.14** (Accidentally writable real numbers, [12]).**

For $\Gamma$ a limit operator, a real number $x$ is $\Gamma$-accidentally writable if there is a $\Gamma$-machine which, when computing from the empty input, at some stage has $x$ written on any of its tapes

Then to capture ordinals using real numbers, we need some kind of encoding.

Definition 3.15**.**

We say that a real number $x$ encodes some ordinal $\alpha$ when the real number encodes a relation $\prec$ on $\omega$ of order type $\alpha$ in the the following fashion.

[TABLE]

Definition 3.16** (Writable ordinals, [12]).**

For $\Gamma$ a limit operator, an ordinal $\alpha$ is $\Gamma$-writable (resp. $\Gamma$-eventually writable and $\Gamma$-accidentally writable) if some $x$ that encodes $\alpha$ is $\Gamma$-writable (resp. $\Gamma$-eventually writable and $\Gamma$-accidentally writable.) We write $\lambda_{\Gamma}$, $\zeta_{\Gamma}$ and $\Sigma_{\Gamma}$ respectively for the supremum of the $\Gamma$-writable, $\Gamma$-e.w. and $\Gamma$-a.w. ordinals.

Definition 3.17** (Clockable ordinals, [12]).**

An ordinal $\alpha$ is $\Gamma$-clockable if there is a $\Gamma$ machine computing from the empty input that halts a stage $\alpha$. That is, it computes for $\alpha$ steps and then, on its next transition, it reaches the state $q_{halt}$. We write $\gamma_{\Gamma}$ for the supremum of the $\Gamma$-clockable ordinals.

With those definitions, what Hamkins and Lewis asked in [12] is whether $\lambda_{\Gamma_{\sup}}=\gamma_{\Gamma_{\sup}}$. As noted, Welch answered this question positively in [17]. More generally, we may wonder under which conditions on $\Gamma$ does the equality $\lambda_{\Gamma}=\gamma_{\Gamma}$ holds. As done in the discussion of Section 2, we can get a better insight on the question by introducing the following extensions of the concept of clockable, akin to that of the concept of writable.

Definition 3.18** (Eventually clockable ordinals).**

An ordinal $\alpha$ is $\Gamma$-eventually clockable ($\Gamma$-e.c. or simply e.c. when the context is clear) if there is a $\Gamma$-machine which, computing from the empty intput, never halts and whose output tape stabilizes at stage $\alpha$; that is, it changes its content upon reaching this stage and it never subsequently changes it. We write $\eta_{\Gamma}$ for the supremum of the $\Gamma$-eventually clockable ordinals.

Definition 3.19** (Accidentally clockable ordinals).**

An ordinal $\alpha$ is $\Gamma$-accidentally clockable ($\Gamma$-a.c. or simply a.c. when the context is clear) if there is a $\Gamma$-machine which, when computing from the empty input, writes at stage $\alpha$ on one of its tapes a real number that wasn’t written at any previous stage of this computation on any tape. We write $\mathrm{T}_{\Gamma}$, capital $\tau$, for the supremum of $\Gamma$-accidentaly clockable ordinals.

We sum those constants up in Figure 1.

Now, as before, given some limit operator $\Gamma$, the question becomes: does $\Sigma_{\Gamma}=\mathrm{T}_{\Gamma}$? This is answered positively in Theorem 4.14 for a wide range of operators. And we show in Corollary 4.30 and Corollary 4.31 that $\Sigma_{\Gamma}=\mathrm{T}_{\Gamma}$ implies both the equalities $\zeta_{\Gamma}=\eta_{\Gamma}$ and $\lambda_{\Gamma}=\gamma_{\Gamma}$.

3.3 Conditions on operators

3.3.1 Simulational operators

Definition 3.20** (History of computation).**

Given an $n$-symbol operator $\Gamma$ and a $\Gamma$-machine $m$ that does not halt before stage $\alpha$, the history $H$ of the computation of $m$ up to $\alpha$ is an element of ${}^{\alpha}({}^{\omega}n)$, that is, it is an ordinal word of length $\alpha$ on the alphabet made from $n$-symbol real numbers, and such that for all $\beta<\alpha$, $H[\beta]=C^{m}(\beta)$, meaning that the $\beta^{th}$ letter of $H$ is the content of the tapes of $m$ at stage $\beta$ (representing the three tapes with a single real). For a given cell $i$, the cell history $h_{i}$ of the computation of $m$ up to $\alpha$ is an element of ${}^{\alpha}n$ such that for all $\beta<\alpha$, $h_{i}[\beta]=C_{i}^{m}(\beta)$. Further, $h_{i}=H|_{i}$, the restriction of $H$ to the cell $i$. When $\alpha$ is a limit ordinal, we say that $H$ (resp. $h_{i}$) is a limit history (resp. a limit cell history).

Definition 3.21** (Suitable operator, [16]).**

An operator $\Gamma$ is a suitable $n$-symbol operator if there is a set-theoretic first-order formula $\varphi(x_{1},x_{2},x_{3},x_{4})$ such that for any machine $m$, input $y$, cell $i$, symbol $k$ and stage $\nu$, writing $H_{\nu}$ the history of $m$ up to stage $\nu$ and $L_{\nu}$ the $\nu^{th}$ level of the constructible hierarchy, we have

[TABLE]

When $\varphi$ is a $\Sigma_{n}$ formula, it is a $\Sigma_{n}$ operator and it produces $\Sigma_{n}$ machines.

Remark 3.22**.**

We may want to restrict the symbols produced at limit stages to [math] and $1$, that is $\Gamma$ would be an operator which acts from ${}^{<On}(^{\omega}n)$ to ${}^{\omega}2$. In this case, it is enough to provide a first-order formula $\varphi(x_{1},x_{2},x_{3})$ such that, with the same notations,

[TABLE]

From there, we can formalize the different conditions exhibited and informally defined in the previous section.

Definition 3.23** (Stable).**

An operator $\Gamma$ is stable when for any real number $x$ and limit ordinal $\alpha$, we have

[TABLE]

Definition 3.24** (Cell-by-cell).**

An operator $\Gamma$ is cell-by-cell when there exists $\gamma:{}^{<On}n\rightarrow n$ such that, given any limit history $H$ and for all cell $i$, we have

[TABLE]

where $|_{i}$ denotes the restriction of the tape history $H$, possibly made of a single tape content, to a single cell; hence yielding a single cell history, that is an element of ${}^{<On}n$. We say that $\gamma$ is the cell restriction of $\Gamma$.

Definition 3.25** (Asymptotic).**

A limit rule operator $\Gamma$ is asymptotic when for any limit history $H$ of length $\alpha$ and any non-empty final segment $H^{\prime}$ (with previously introduced notation, $H\sqsupseteq H^{\prime}$), we have $\Gamma(H)=\Gamma(H^{\prime})$

Example 3.26**.**

Let us see how a $\Gamma$-machine $m$ behaves when $\Gamma$ is asymptotic. For the sake of simplicity, we suppose that $m$ only has a working tape. We write $H(\alpha)$ for the history word of length $\alpha$ of the working tape up to some stage $\alpha$. Again to make thing simpler, suppose that at stage [math] some real number $x$ can be found on the working tape and the machine is in the state $q_{\lim}$. Suppose further that there is a limit stage $\alpha>0$ such that $\Gamma(H(\alpha))=x$. Then, we look at the computation of $m$ after this stage $\alpha$ and we show how this gives rise to a repetition in the computation; but a repetition that may not be a loop.

By definition of the model of the ITTM, at any stage $\beta+k$ for a finite $k$, the snapshot of $m$ depends only of its code and of its snapshot at stage $\beta$. In this case, as only the working tape is used, in the computation of $m$ stages [math] and $\alpha$ share the same snapshot. This means that, for any finite $k$, the snapshots at stage $k$ and $\alpha+k$ match. That is, $H(\alpha+\omega)\sqsupseteq H(\omega)$. Then, what happens at limit stage $\alpha+\omega$? By asymptoticity, $\Gamma(H(\alpha+\omega))=\Gamma(H(\omega))$. And so, snapshots at stages $\omega$ and $\alpha+\omega$ also match. Further, inductively, we can show that $\Gamma(H(\alpha\cdot 2))=\Gamma(H(\alpha))=x$. And further that $\Gamma(H(\alpha\cdot k))=\Gamma(H(\alpha))=x$ for any finite $k$. Is then $m$ actually looping? Consider stage $\alpha\cdot\omega$. This stage is the first stage after $\alpha$ whose ordinal number is additively closed. Consequently, by additive closeness, any non-empty final segment of $H(\alpha\cdot\omega)$ has itself $H(\alpha\cdot\omega)$ as final segment. Hence applying asymptoticity in this case only yields that $\Gamma(H(\alpha\cdot\omega))=\Gamma(H(\alpha\cdot\omega))$ and without more assumptions, the limit rule may very well make $m$ exit the repeating pattern at stage $\alpha\cdot\omega$.

For the next condition, we need a prior definition. We will define the contraction of a word $w$, that is the stutter-free word which is made by squeezing any segment in $w$ in which a symbol is repeated into a single symbol, until no more repetition can be found. For example, the contraction of the word $aabc^{\omega}$ would be $abc$. We define the operator $\operatorname{ctr}$, which maps a word to its contraction.

Definition 3.27** (Contraction).**

We define $\operatorname{ctr}$ for ordinal words as follows. Let $w$ be a word on some alphabet $A$ of length $\alpha$. Then, there exists an ordinal sequence $(\nu_{\mu})\subset\alpha$ of length at most $\alpha$, unbounded in $\alpha$ and starting at [math], which describes the blocks of equal symbols in $w$. That is, for $\nu_{\mu}$ and $\nu_{\mu+1}$ in this sequence,

[TABLE]

With this sequence, $\operatorname{ctr}(w)$, the contraction of the word $w$ is the word of length $|(\nu_{\mu})|$ (or of length $|(\nu_{\mu})|-1$ if the length of the sequence is not a limit ordinal) in which each individual block is replaced by a single letter, that is such that for $\iota<|(\nu_{\mu})|$,

[TABLE]

Definition 3.28**.**

We say that two words $u$ and $v$ are equal after contraction, written $u\simeq_{ctr}v$, whenever $\operatorname{ctr}(u)=\operatorname{ctr}(v)$

Below are a few examples of contraction of words and words equal up to contraction. This wholly coincides with the intuitive idea of contracting every sequence of a symbol which repeats itself into a single symbol.

Example 3.29**.**

• –

$aaabcccc\simeq_{ctr}abbbc$.

• –

The contraction of the limit word $b^{\omega}$, that is of the limit word in which the letter $b$ is repeated $\omega$ times, is the single-letter word $b$, made from the letter $b$.

• –

For $\alpha,\beta>0$ and any $\delta$, $(b^{\beta}a^{\alpha})^{\delta}\simeq_{ctr}(ba)^{\delta}$.

Definition 3.30** (Contraction-proof).**

A operator $\Gamma$ is contraction-proof when for any limit histories $H$ and $H^{\prime}$ such that $H\simeq_{ctr}H^{\prime}$, we have $\Gamma(H)=\Gamma(H^{\prime})$.

Remark 3.31**.**

As the contraction of a limit word may be a non limit word (take for example $b$, the contraction of $b^{\omega}$), general operators should not only be defined on limit words. However, any non limit word $w$ finishing with some letter $a$ is equal up to contraction to $wa^{\omega}$. So, when considering contraction-proof operators, as we will do, it is enough for those to be defined only on limit words.

Remark 3.32**.**

Observe that for a cell-by-cell operator, those three characteristics, namely being stable, asymptotic or contraction-proof, are naturally refined to cell-wise properties. For example, if we take the case of the property of a cell-by-cell operator $\Gamma$ being contraction-proof and write $\gamma$ its associated cell restriction. Take $h$ and $h^{\prime}$ two limit cell histories such that $h\simeq_{ctr}h^{\prime}$. Then we can consider $H$ and $H^{\prime}$ such that for all $i$, $H|_{i}=h$ and $H^{\prime}|_{i}=h^{\prime}$. By the properties of being cell-by-cell and contraction-proof, we have:

[TABLE]

which is simply the fact that $\gamma$ is contraction-proof as well, in a cell-by-cell fashion. Conversely, if $\gamma$ satisfy this cell-by-cell contraction-proof property, it is clearly carried over to $\Gamma$.

Definition 3.33** (Simulational operator).**

We say that a limit rule operator $\Gamma$ is a simulational limit rule operator when it is stable, cell-by-cell, asymptotic and contraction proof.

Proposition 3.34**.**

Let $\Gamma$ be a simulational limit rule operator. Then there exists a universal machine $U_{\Gamma}$ and more generally, a $\Gamma$-machine can be designed to compute using the simulation of any other $\Gamma$-machine.

Proof.

We use the same reasoning as in the description of the $\limsup$ universal machine. It is easy, in virtue of the fact that $\Gamma$ is cell-by-cell and given the code of the finite universal machine $u$, to describe a universal $\Gamma$-machine $\mathcal{U}_{0}$ that simulates a single other $\Gamma$-machine. From there the description of $U_{\Gamma}$ from $\mathcal{U}_{0}$ is as previously: we can arrange to virtually split the working tape into $\omega$ virtual workings tapes in each of which, for $m\in\omega$, we run $\mathcal{U}_{0}$ that simulates $m$. We can also run those machines in cascade (that is $n$ steps of the $n^{th}$ first machine, $n+1$ steps of the $(n+1)^{th}$ first machine and so on) so that in $\omega$ steps, we run $\omega$ steps of each of those machines, and more generally at any $\alpha$ limit the machine simulated $\alpha$ steps of each simulated machine. And this produces the desired computation, that is at limit stages, the tapes of the simulated machine have the same content as the machines would have because $\Gamma$ is contraction-proof.

Now for the second part. What is a natural way for a machine to use the simulation of another? As briefly sketched, it should first be able to run the simulation of any machine from any snapshot and for as long it wants. And second, it should be able to put this simulation on hold also for as long as it wants. As $\Gamma$ is cell-by-cell, asymptotical and contraction-proof, a machine can run simulations of other machine from any snapshot. As it is stable and contraction-proof, it can put the simulation on hold for as long as it wants. ∎

Remark 3.35**.**

Let us now look at the hypermachines developed by Welch and Friedman in [9], under the scrutiny of those new notions. Briefly, the structure of the hypermachine is akin to that of a $2$-symbol ITTM with the difference that it has a new tape called a rule tape. At a limit stage, the values of the cells are computed by a discretionary $\liminf$ operator, that is a $\liminf$ operator that considers only a precise subset of the previous stages over which it takes the $\liminf$. And it is the rule tape which dictates, at a given limit stage, which subset of previous stages should be considered in the $\liminf$.

Now, as this operator needs to look at the whole rule tape, it is not cell-by-cell. However, it is easily seen to be stable. Then, if it was asymptotic, at some limit stage $\alpha\cdot 2$, the limit rule would not depend on the first half of the history. However, the notions of $1$-stability and $1$-correctness, used to define the operator of the hypermachine, are themselves not asymptotic. With those, it is possible to devise an history of computation for the hypermachine which would contradict asymptoticity. Similarly, those definitions are not contraction-proof. Hence, the behavior of the limit rule may change after a contraction or a dilation of the history. A more detail analysis of the hypermachine under those four definitions can be found in [10, Remark 5.3.34].

In the end, this shows that is not possible to define a universal machine for the hypermachines with the technique used in the previous proposition. It may still exist but the presence of the rule tape makes a constructive approach seem difficult.

The following proposition can be seen as a closure property. It is of the utmost importance and is ubitquitous in what follows, often under the guise of the formulation given in Remark 3.37.

Proposition 3.36**.**

Let $\Gamma$ be a simulational limit rule operator. If a real number $x$ is $\Gamma$-e.w. and $y$ is $x$-$\Gamma$-writable, then $y$ is $\Gamma$-e.w.

Proof.

This is proved as with classical ITTMs. Let $m_{x}$ be a machine which eventually writes $x$ and $m_{y}$ a machine which $x$-writes $y$. With those, we can design a computation which, in parallel, using a classical dovetailing technique, simulates $m_{x}$ and tries to writes $y$ using $m_{y}$ and, as input for $m_{y}$, whatever is written on the output of $m_{x}$. It restarts the simulation of $m_{y}$ each time the output of $m_{x}$ changes. At some point, $m_{x}$ eventually wrote $x$ on its output and this output won’t be modified again. From this point onward, the computation of $m_{y}$ will be conducted using $x$, which will eventually yield $y$. See [1, Theorem 3.5.10] and [18, Proposition 6.3] for more details. ∎

Remark 3.37**.**

Proposition 3.36 justifies the following formulation widely used in the following proofs:

To show that $y$ is eventually writable, we consider the following machine: first it simulates $m_{x}$ to eventually write $x$ on some part of its working tape. Then using $x$ it conducts the following computation to write $y$ on its output…

What is hidden behind this slightly abusive de-interlacing or sequencing of the different writing operations is the more complex but sound dovetailing technique refered to in the previous proof.

Proposition 3.38**.**

The operator $\Gamma_{\sup}$ is a suitable and simulational $\Sigma_{2}$ operator.

Proof.

To show that $\Gamma_{\sup}$ is a suitable $\Sigma_{2}$ operator, it is enough to provide a $\Sigma_{2}$ formula defining the $\limsup$ operator in the sense of Definition 3.21. The only technical part is the fact that this formula does not directly take as argument the history of the machine and that the history is itself defined by this same formula. This can be done in a rather straightforward fashion akin to $\Sigma$-recursion. A more detailed construction of this $\Sigma_{2}$ formula can be found in the proof of Proposition 5.3.37 in [10].

As for the fact that it is a simulational operator: it is stable, asymptotical and cell-by-cell by definition and it is clearly enough contraction-proof.

∎

3.3.2 Looping stability

The possibility for an infinite machine to exit a repeating pattern, as presented in Example 3.26, is in a way what enables those machines to compute for so long and to give rise to intricate computations. At the same time it may lead to pathological patterns from the point of view of those being computation models. As presented in Remark 3.40, this could result in a $\Gamma$-machine which repeats for a very long time (very long when compared to the time it took to enter this repeating pattern) and then suddenly exits this pattern. To avoid those cases, we introduce in Definition 3.39 the notion of looping stability. It is a simple assumption that let us develop a rather general and sound subclass of the simulational operators for which we can prove strong results like Theorem 4.14. Observe that it thus excludes some more exotic models of ITTM, for example cardinal-recognizing ITTMs as introduced in [11].

Definition 3.39** (Looping stability).**

A limit rule operator $\Gamma$ satisfies the looping stability condition when for any limit history $H$ and limit ordinals $\alpha$ and $\alpha^{\prime}$, writing $H^{\alpha}$ for the word in which $H$ is repeated $\alpha$ times, we have:

[TABLE]

Equivalently, in a formulation that will be used more often, for any limit history $H$ and limit ordinal $\alpha$:

[TABLE]

Remark 3.40**.**

Why do we need looping stability? Without it, it seems impossible to establish a general looping condition as was established in the $\Sigma_{2}$ case and as we’ll do in Proposition 3.41, for the operators satisfying the condition of looping stability. By “looping condition”, we mean a criterion that lets us decide, by looking at at some point the history of a machine (so looking at a given and fixed past of the computation), whether the machine is at this point seen to be looping (and so producing a statement about the future of the computation). In other word, it is a criterion that allows us to decide whether a machine is looping without having to look at its whole computation through $On$. To give an idea of what would be possible without this hypothesis and the difficulty it poses, imagine $\gamma$ a cell-by-cell operator acting as the $\limsup$ operator with the only difference being that for some gigantic additively closed $\tau$, $\gamma((01)^{\tau})=0$. This operator would be stable and asymptotic. We could also arrange for it to be contraction proof. And with $\tau>\Sigma_{\sup}$, it would be repeating from stage $\mathrm{T}_{\sup}=\Sigma_{\sup}$ onward and up to stage $\tau$ where it would magically exit this loop.

In particular, refining this idea, Theorem 5.1 shows that the main theorem of this section, that is that under some conditions on $\Gamma$, $\Sigma_{\Gamma}=\mathrm{T}_{\Gamma}$, does not hold without the hypothesis of looping stability.

As suggested, the first benefit of the condition of looping stability is that it gives a general looping condition for the operators of the class.

Proposition 3.41**.**

Let $\Gamma$ be an operator which is looping stable and asymptotic. Then the following looping condition holds: a $\Gamma$-machine is looping if and only if there are two ordinals $\alpha$, $\beta$ such that stages $\alpha$, $\alpha+\beta$ and $\alpha+\beta\cdot\omega$ share the same snapshot.

Proof.

This is a direct application of looping stability. ∎

The following corollary will offer a bit more flexibility when using Proposition 3.41.

Corollary 3.42**.**

Let $\Gamma$ be an operator which is looping stable and asymptotic. Then the following looping condition holds: a $\Gamma$-machine is looping if and only if there are two ordinals $\alpha$, $\beta$ such that $\alpha$ and $\alpha+\beta$ share the same snapshot and such that the snapshot $\alpha+\beta\cdot\omega$ also appears between stages $\alpha$ and $\alpha+\beta$.

Proof.

Let $\alpha^{\prime}$ be the least stage between stages $\alpha$ and $\alpha+\beta$ at which the snapshot of stage $\alpha+\beta\cdot\omega$ also appears. As $\alpha$ and $\alpha+\beta$ share the same snapshot, by asymptoticity, the computation segment $[\alpha,\alpha+\beta[$ is the same as the computation segment $[\alpha+\beta,\alpha+\beta\cdot 2[$. In particular, the snapshot of stage $\alpha+\beta\cdot\omega$ also appears at some stage $\alpha^{\prime}+\beta^{\prime}$ between stages $\alpha+\beta$ and stages $\alpha+\beta\cdot 2$ and such that $\alpha^{\prime}+\beta^{\prime}\cdot\omega=\alpha+\beta\cdot\omega$. And so, $\alpha^{\prime}$ and $\beta^{\prime}$ satisfy the looping condition of Proposition 3.41. ∎

Further, Proposition 3.41 justifies the following definition.

Definition 3.43**.**

Let $\Gamma$ be an asymptotic operator that satisfies the looping stability and $m$ a $\Gamma$-machine. We say that $m$ is seen to be looping at some stage $\delta$ if there are two ordinals $\alpha$ and $\beta$ such that stages $\alpha$, $\alpha+\beta$ and $\alpha+\beta\cdot\omega$ share the same snapshot and such that $\alpha+\beta\cdot\omega=\delta$.

Proposition 3.44**.**

Let $\Gamma$ be an operator that satisfies the looping stability as well as being asymptotic and let $m$ be a $\Gamma$-machine that does not halt. Then at any stage $\alpha$, if the machine is not seen to be looping before stage $\alpha\cdot\omega^{\omega}$, there is a snapshot that did not appear strictly before stage $\alpha$ that appears strictly before stage $\alpha\cdot\omega^{\omega}$.

Proof.

Let $m$ be some machine and $\alpha$ an ordinal such that the machine is not seen to be looping before stage $\alpha\cdot\omega^{\omega}$. We look at its computation starting from stage $\alpha$ onwards. We consider the snapshot $s_{0}$ that appears in $m$ at stage $\alpha$. Either this snapshot appears for the first time, and we’re done. Or this snapshot appears at some earlier stage $\alpha_{0}<\alpha$. This means that the snapshot $s_{0}$ (at stage $\alpha_{0}$) leads to another occurrence of the snapshot $s_{0}$ (at stage $\alpha$). By asymptoticity of $\Gamma$, the snapshot $s_{0}$ (at stage $\alpha$) must also lead to an ulterior occurrence of $s_{0}$ and so on, for at least $\omega$ repetitions. After those $\omega$ repetitions, we write $s_{1}$ for the snapshot of $m$. Observe first that $s_{1}\neq s_{0}$ as otherwise $m$ would be seen to be looping by Proposition 3.41. And even stronger: by Corollary 3.42, $s_{1}$ does not appear in the whole segment that spans between the two occurrences of $s_{0}$ and that repeats itself. Hence, again, if $s_{1}$ does not appear for the first time, there is some least stage $\alpha_{1}<\alpha_{0}$ at which the snapshot $s_{1}$ occurs.

With the same reasoning, as long as the repetition of the segments between the occurrences of $s_{i}$ does not yield a new snapshot, it yields a snapshot $s_{i+1}$ that appeared earlier, at some least ordinal stage $\alpha_{i+1}<\alpha_{i}$ (as, by hypothesis, the machine isn’t seen to be looping yet). This yields a decreasing sequence of ordinals $(\alpha_{i})$. Consequently, by well-orderdness, there must be some snapshot $s_{k}$ that appears for the first time at some stage $\alpha_{k}$ for a finite $k$.

And how late can this snapshot occur? At worst, the first repeating segment between the occurrences of $s_{0}$ has length $\alpha$. Then the second repeating segment, between the occurrences of $s_{1}$ would have length $\alpha\cdot\omega$. And, more generally, the repeating segment between the occurrences of $s_{i}$ would have length $\alpha\cdot\omega^{i}$. This yields the bound

[TABLE]

for the appearance of a new snapshot. ∎

Proposition 3.45**.**

Let $\Gamma$ be a suitable operator that satisfy the looping stability as well as being asymptotic. Then there is some countable stage $\alpha$ such that any $\Gamma$-machine either stopped or is seen to be looping before stage $\alpha$.

Proof.

Consider ordinal $\omega_{2}$. By the downward Löwenheim-skolem theorem, we can find limit ordinals $\alpha_{1}<\alpha_{2}<\alpha_{3}$ of cardinality $\aleph_{1}$ and such that the $L_{\alpha_{i}}$ are elementary substructures of $L_{\omega_{2}}$. Moreover we can arrange for $\alpha_{3}$ to be strictly greater than $\alpha_{2}\cdot\omega$. Further, by a result of Devlin [7, II. 5.5], we can show in $L$ that no new real numbers appear in the constructible universe after construction stage $\omega_{1}$. Hence, we have:

[TABLE]

Again by the downward Löwenheim-Skolem theorem there exists some countable ordinal $\beta$ such that $L_{\beta}\prec L_{\omega_{2}}$. This yields three limit countable ordinals $\beta_{1}<\beta_{2}<\beta_{3}$ that satisfy the previous formula in $L_{\beta}$. We show that any $\Gamma$-machine $m$ is seen to be looping before stage $\beta_{3}$.

Let $m$ be a $\Gamma$-machine computing from the empty input. First, as $\Gamma$ is a suitable operator there is some predicate $\varphi(i,m,0,k)$ that defines in $L_{\alpha}$, for any limit $\alpha$, the value of any cell $i$ of $m$ at limit stage $\alpha$ (the [math] in $\varphi$ stands for the empty input). As $L_{\beta_{1}}\prec L_{\beta_{2}}$ (and as those are limit stages), whether in $L_{\beta_{1}}$ or $L_{\beta_{2}}$, the computation of the limit rule for some cell $i$ using $\varphi$ yields the same value. Hence, the snapshots of $m$ at stages $\beta_{1}$ and $\beta_{2}$ match. For convenience, we let $\beta_{0}<\beta_{2}$ be the least ordinal stage that share the same snapshot as $\beta_{2}$ and we write $x_{2}$ the real number appearing at those two stages. As seen in Example 3.26, by asymptoticity of $\Gamma$ this gives rise to a repeating pattern where the segment between stages $\beta_{0}$ and $\beta_{2}$ repeats at least $\omega$ stages. Let $\beta^{\prime}_{2}$ be the limit stage directly after those $\omega$ repetitions of the segment of computation $[\beta_{0},\beta_{2}[$ and $x^{\prime}$ be the real number appearing at this stage. As $\beta^{\prime}_{2}\leqslant\beta_{2}\cdot\omega$, we also have that $\beta^{\prime}_{2}<\beta_{3}$. This state of affairs is represented in Figure 3.

By Corollary 3.42, $m$ is seen to be looping if $x^{\prime}$ appears at a limit stage in the segment of computation $[\beta_{1},\beta_{2}[$ (as it would then produce the same snapshot as the one appearing at stage $\beta^{\prime}_{2}$.) As $x^{\prime}$ appears as a snapshot in $m$ at stage $\beta^{\prime}_{2}$, it can be defined in $L_{\beta^{\prime}_{2}}$. Hence $x^{\prime}\in L_{\beta^{\prime}_{2}+1}$. As $\beta^{\prime}_{2}<\beta_{3}$, $x^{\prime}$ is also in $L_{\beta_{3}}$. So, with $x_{2}$ being the snapshot that appeared at stage $\beta_{2}$ and with $C^{m}(\alpha)$ the function that maps some ordinal stage $\alpha$ to the real number that describes the snapshot at stage $\alpha$ in the computation of $m$:

[TABLE]

Now, and that is the corner stone of this proof, $L_{\beta_{3}}$ sees that no new real numbers appeared in the constructible universe after stage $\beta_{1}$. This means that $x^{\prime}$ (as well as $x_{2}$) are in $L_{\beta_{1}}$ and in $L_{\beta_{2}}$ and that, by elementarity, we can reflect the previous sentence down to $L_{\beta_{2}}$. This means that, as depicted in Figure 4, in the computation of $m$ up to stage $\alpha_{2}$, the real number $x^{\prime}$ appeared at some limit stage $\delta^{\prime}_{2}$ such that there is an earlier limit stage $\delta_{2}<\delta^{\prime}_{2}$ at which the real number $x_{2}$ appeared. By definition of $\beta_{0}$, it must be less than $\delta_{2}$ and $x^{\prime}$ appeared at a limit stage in the segment of computation $[\beta_{0},\beta_{2}[$. Hence, by Corollary 3.42, $m$ is seen to be looping before stage $\beta_{3}$.

∎

4 Toward higher-order and many-symbol ITTMs

Theorem 4.1**.**

$\Gamma_{\sup}$* and $\Gamma_{\inf}$ are the only simulational operators with two symbols that satisfy the looping stability condition.*

Proof.

First, as seen, $\Gamma_{\sup}$ is a suitable and simulational operator. With the same reasoning, so is its symmetric, $\Gamma_{\inf}$. Then, let $\Gamma$ be a two-symbol suitable and simulational operator. As $\Gamma$ is cell-by-cell we can write $\gamma$ the cell restriction of $\Gamma$. We now want to show that $\gamma$ is either $\gamma_{\sup}$ or $\gamma_{\inf}$. So let $h\in{}^{<On}2$ a limit cell history on two symbols. We distinguish two cases

• –

If there is $s=0$ or $s=1$ and some $\alpha$ such that the word $s^{\alpha}$ is a final segment of $h$ then by asymptoticy $\gamma(h)=\gamma(s^{\alpha})$ and by stability $\gamma(h)=s$.

• –

Otherwise, this means that both [math] and $1$ are cofinal in the word $h$. We show that all such $h$ are mapped to the same symbol. Take $h_{1}$ and $h_{2}$ two such history who have cofinally [math]’s and $1$’s. From $h_{1}$ and $h_{2}$ we can construct by transfinite induction $h^{\prime}_{1}$ and $h^{\prime}_{2}$ such that $h^{\prime}_{1}$ and $h^{\prime}_{2}$ are stutter-free and $h^{\prime}_{1}\simeq_{ctr}h_{1}$ and $h^{\prime}_{2}\simeq_{ctr}h_{2}$. As $\gamma$ is contraction-proof, $\gamma(h^{\prime}_{1})=\gamma(h_{1})$ and $\gamma(h^{\prime}_{2})=\gamma(h_{2})$. As $h^{\prime}_{1}$ and $h^{\prime}_{2}$ are stutter-free, they are simply the regular alternation of [math] and $1$ : $010101\ldots$ or $101010\ldots$ Hence, there are two ordinals $\alpha$ and $\beta$ such that $h^{\prime}_{1}=(01)^{\alpha}$ (or $h^{\prime}_{1}=(10)^{\alpha}$) and $h^{\prime}_{2}=(01)^{\beta}$ (or $h^{\prime}_{2}=(10)^{\beta}$). In any case, by asymptoticity and looping stability (which can be applied cell-by-cell as $\Gamma$ is cell-by-cell; see Remark 3.32.), $\gamma(h^{\prime}_{1})=\gamma((01)^{\omega})=\gamma(h^{\prime}_{2})$ and from there $\gamma(h_{1})=\gamma(h_{2})$. Hence those histories form a single equivalence class w.r.t. $\gamma$: either they are all mapped to $1$ and $\gamma=\gamma_{\sup}$. Either they are all mapped to [math] and $\gamma=\gamma_{\inf}$.

∎

First, observe that this result is really proper to $2$-symbol $\Gamma$-machines. With $3$ symbols or more, there are many intricate ordinal words that can’t be simplified by contraction. Hence this theorem shows how, on the contrary to what we are used to in computability, working with only two symbols is actually a real constraint here. This shows the necessity to consider $n$-symbol machines. This will let us consider more complex rules that will still satisfy basic operator constraints, like being simulational. Still, we will want to build on the previous result established for the $2$-symbol operators $\limsup$ and $\liminf$. To this extent, we will be interested in operators enhancing other operators.

Definition 4.2**.**

Let $\Gamma_{n}$ be an $n$-symbol operator and $\Gamma_{k}$ be a $k$-symbol operator with $k<n$. We say that $\Gamma_{n}$ enhances $\Gamma_{k}$ when for any $H\in{}^{<On}({}^{\omega}k)$ :

[TABLE]

Remark 4.3**.**

Enhancement is a powerful feature as it allows an operator to behave like another operator it enhances by simply sticking to a subset of symbols. In the case of enhancement of the operators $\Gamma_{\sup}$ or $\Gamma_{\inf}$ is it moreover relatively easy to obtain in the setting of well behaved operators.

Indeed, take $\Gamma$ an $n$-symbol simulational and looping stable operator with $n>2$. If we suppose that at limit stages $\Gamma$ does not produce symbols for a cell that were not cofinal in the history of the cell (which is a relatively mild assumption that we refer to as “strong stability”), then $\Gamma$ enhances either the operator $\Gamma_{\sup}$ or $\Gamma_{\inf}$. To see this, just consider the restriction of $\Gamma$ to [math] and $1$: it yields a simulational and looping stable $2$-symbol operator and, by Theorem 4.1, it must be either $\Gamma_{\sup}$ or $\Gamma_{\inf}$

Still, as much as such enhancement is convenient we may not want to impose this hypothesis of strong stability on our operators. One main reason being that, even without this hypothesis, a simulational and looping stable operator can still emulate a classical ITTM in a fairly straightforward and faithful way. We will call this behavior emulation.

Definition 4.4**.**

Let $\Gamma_{n}$ and $\Gamma_{k}$ be respectively an $n$-symbol operator and a $k$-symbol operator with $k<n$. We say that $\Gamma_{n}$ emulates $\Gamma_{k}$ when for each $\Gamma_{k}$-machine $m_{k}$ there exists a $\Gamma_{n}$-machine $m_{n}$ such that:

• •

at any limit stage the snapshots of $m_{k}$ and $m_{n}$ match.

• •

all snapshots of $m_{k}$ appearing between two limit stages also appear between the same two limit stages and in the same order in $m_{n}$ but they may be separated by a finite amount of other snapshots.

• •

all snapshot of $m_{n}$ that are not from $m_{k}$ have a symbol $s\not\in k$ written in one of their cell.

With this definition, it is clear that any emulation of a machine will produce a very similar computation. In particular, with the notations of Definition 4.4, $m_{k}$ writes (or eventually writes) $x$ if and only if $m_{n}$ does. While $m_{n}$ may accidentally write more real numbers, this will be enough for our purpose as we will mostly want to harvest the deciding and writing power of $\limsup$ machines (deciding whether a real number is a code for an ordinal, writing a code for $L_{\alpha}$ given a code for $\alpha$, $\dots$) Proposition 4.6 motivates this definition and Proposition 4.5 links it with previous definition of enhancement.

Proposition 4.5**.**

If $\Gamma_{n}$ enhances $\Gamma_{k}$ then it also emulates it.

Proof.

With the notations of Definition 4.4, it is enough for $m_{n}$ to take $m_{k}$ seen as a $\Gamma_{n}$-machine. ∎

Proposition 4.6**.**

Let $\Gamma$ be an $n$-symbol simulational and looping stable operator. Then $\Gamma$ emulates the operator $\Gamma_{\sup}$.

Proof.

Let $\Gamma$ be an $n$-symbol simulational and looping stable operator. By Theorem 4.1, we can suppose w.l.o.g. that $n>2$. For this proposition, the difficulty lies in the fact that there may not be two symbols in $n$ with respect to which $\Gamma$ acts like $\Gamma_{\sup}$. That is, it may be the case that for all $i,j\in n$, there is $k\in n-\left\{i,j\right\}$ such that

[TABLE]

To circumvent this issue, we use a simple enough trick. Consider the word $w=123\dots(n-1)0$ made from all letters in $n$ starting from $1$. Let $k\in n$ such that $\Gamma(w^{\omega})=k$. With $w^{\prime}=k(k+1)\ldots(n-1)01\ldots k-1$, all the letters in $n$ starting from $k$, observe that, by asymptoticty, $\Gamma(w^{\omega})=\Gamma((w^{\prime})^{\omega})=k$. Hence, by renaming the symbols and arranging $w$, we can suppose that $\Gamma(w^{\omega})=1$.

With this, given a classical ITTM $m$, we describe the emulating machine $m_{\Gamma}$ of Definition 4.4. It behaves like $m$ with the only difference that when $m$ writes a [math] over a $1$, $m_{\Gamma}$ writes, one after the other in the same cell: $2$, $3$, $\dots$, $n-2$, $n-1$ and finally [math]. When $m$ writes a $1$ over a [math], $m_{\Gamma}$ simply does so.

This way, when the history of some cell in the classical ITTM $m$ reads $(10)^{\omega}$, it will read $(w)^{\omega}$ in the history of this cell in $m_{\Gamma}$. And by construction, the operator $\Gamma$ maps this history to $1$. That is, after the limit stage $\omega$, the history of this cell in the $\Gamma$-machine reads $(w)^{\omega}1$ and the computation goes on. From there, by an induction relying on this reasoning and on the property of looping stability, we can show that the simulation carries on in a faithful way, respecting the conditions of Definition 4.4.

∎

We will see that a large part of the results for the $\limsup$ machines involving either only writable or only clockable ordinals are true and proved with the exact same proof for $n$-symbol machines able to emulate the classical $2$-symbol machine. The following few results illustrate this.

The first two results also ensure that the writing and clocking constants are well-behaved and meaningful, as they are in the ITTM setting. Note that when possible we include the hypothesis that $\Gamma$ emulates $\Gamma_{\sup}$ (or indifferently $\Gamma_{\inf}$) rather than the stronger hypothesis of looping stability.

Proposition 4.7**.**

Let $\Gamma$ be a simulational $n$-symbol operator that emulates the operator $\Gamma_{\sup}$. Then the constants related to the three different kinds of $\Gamma$-writable ordinals are distinct. That is: $\lambda_{\Gamma}<\zeta_{\Gamma}<\Sigma_{\Gamma}$

Proof.

$\lambda_{\Gamma}<\zeta_{\Gamma}$ : At some point, all machines that write an ordinal have written their ordinal. So we consider the following machine: it simulates $\mathcal{U}_{\Gamma}$ (which exists as $\Gamma$ is simulational) and at each step it writes the sum of all ordinals that have been written by any of the machines that halted. Observe that summing ordinals is possible by emulation of a $\Gamma_{\sup}$-machine. When all writable ordinals have be written, i.e. when their respective machine stopped, the machine we are describing has eventually written their sum (ordered by the code of the machine) which is by definition greater or equal to $\lambda_{\Gamma}$.

$\zeta_{\Gamma}<\Sigma_{\Gamma}$ : With the same reasoning, at some point all eventually writable ordinal appeared in $\mathcal{U}_{\Gamma}$. Computing the sum of all ordinals appearing in $\mathcal{U}_{\Gamma}$ at the same time (we can’t distinguish between those which are eventually writable and accidentally writable) will at some point accidentally write an ordinal greater or equal to $\zeta_{\Gamma}$. ∎

Proposition 4.8**.**

Let $\Gamma$ be a simulational $n$-symbol operator that emulates the operator $\Gamma_{\sup}$. Then the supremum of any kind of writable is smaller than or equal to its respective kind of clockable. That is, $\lambda_{\Gamma}\leqslant\gamma_{\Gamma}$, $\zeta_{\Gamma}\leqslant\eta_{\Gamma}$, $\Sigma_{\Gamma}\leqslant\mathrm{T}_{\Gamma}$.

Proof.

Suppose that $\lambda_{\Gamma}>\gamma_{\Gamma}$, that is that $\gamma_{\Gamma}$ is writable and consider the following machine toward a contradiction: it writes a code for $\gamma_{\Gamma}$, then it emulates the $\Gamma_{\sup}$-machine that counts through an ordinal with this code to count for $\gamma_{\Gamma}$ steps after which is stops. The emulations takes at least $\gamma_{\Gamma}$ steps. So this machine effectively clocks some ordinal greater or equal to $\gamma_{\Gamma}$, which is a contradiction.

Suppose that $\zeta_{\Gamma}>\eta_{\Gamma}$, that is that $\eta_{\Gamma}$ is eventually writable and consider the following machine toward a contradiction: it simulates the machine that eventually writes a code for $\eta_{\Gamma}$ and, again using the emulation of a $\limsup$ machine, each time a code for an ordinal is written on its output, it counts through this ordinal and then copies the output of this machine to its own output. When the simulated machine stabilizes on a code for $\eta_{\Gamma}$, the main machine copies it on its output after at least $\eta_{\Gamma}$ steps, hence eventually clocks an ordinal greater or equal to $\eta_{\Gamma}$, which is again a contradiction.

As for the last inequality, it is proved exactly as in the first part of the proof of Proposition 2.1, replacing $\Sigma$ and $\mathrm{T}$ respectively by $\Sigma_{\Gamma}$ and $\mathrm{T}_{\Gamma}$. Moreover, albeit slightly trickier, it is the same technique as used with the two previous inequalities. ∎

Proposition 4.9**.**

Let $\Gamma$ be a simulational $n$-symbol operator that emulates the operator $\Gamma_{\sup}$. Then $\lambda_{\Gamma}$, $\zeta_{\Gamma}$ and $\Sigma_{\Gamma}$ are multiplicatively closed.

Proof.

We show this for $\Sigma_{\Gamma}$. Let $\alpha$ and $\beta$ two accidentally writable ordinals. We want to show that $\alpha\cdot\beta$ is accidentally writable as well. Observe first that the product of two ordinals is computable with a $\Gamma$-machine. This comes from the fact that $\Gamma$ emulates the $\limsup$ operator: there is a $\limsup$ machine that computes this function, and this machine can be emulated by a $\Gamma$-machine. Now suppose w.l.o.g. that (a code for) $\alpha$ appears earlier than (a code for) $\beta$ on one of the tapes of the machines simulated in $\mathcal{U}_{\Gamma}$ (and $\mathcal{U}_{\Gamma}$ exists as $\Gamma$ is simulational.) We consider the following computation: the machine simulate $\mathcal{U}_{\Gamma}^{1}$, a copy of $\mathcal{U}_{\Gamma}$, and at each step of $\mathcal{U}_{\Gamma}^{1}$, writing $s^{1}$ for its snapshot, it launches $\mathcal{U}_{\Gamma}^{2}$ a fresh copy of $\mathcal{U}_{\Gamma}^{2}$ and it simulates this copy until it reaches the snapshot $s^{1}$. Meanwhile, it computes the product of any two ordinals appearing in $s^{1}$ and in $\mathcal{U}_{\Gamma}^{2}$. When $\mathcal{U}_{\Gamma}^{1}$ computed far enough so that $\beta$ appears in $s^{1}$, $\alpha$ appeared earlier and it will appear again in the computation of $\mathcal{U}_{\Gamma}^{2}$ until it reaches snapshot $s^{1}$; hence the ordinal $\alpha\cdot\beta$ will be accidentally writable by this machine before $\mathcal{U}_{\Gamma}^{2}$ reaches the snapshot $s^{1}$.

For $\lambda_{\Gamma}$ and $\zeta_{\Gamma}$, it relies in the same way on the fact that the product of two ordinals is computable, and it is easier as $\alpha$ and $\beta$ can be multiplied once eventually written (resp. written.) ∎

Remark 4.10**.**

While, as illustrated above, many results on ITTMs are readily generalized to $\Gamma$-machines (provided basic hypothesis on $\Gamma$, e.g. being simulational), there is one interesting result which does not easily lend itself to generalization. As kindly pointed out by Bruno Durand, this is the case of the Speed-up Lemma of [12]. This lemma reads: “if $\alpha+k$ is clockable for $k\in\omega$, then so is $\alpha$” and its proof is a clever argument which relies on combinatorial aspects of the $\limsup$ rule. It is clear that this argument can’t be ported as is to $\Gamma$-machines and unclear whether it can be proved differently for those.

Thankfully, the consequences of this fact are limited. One reason is that when it comes to the behavior of infinite machines from a macro perspective (as mostly done here, where the ordinals we consider are limit ordinals closed under many different kind of operations), this lemma is not needed. It is however useful when conducting a finer analysis of gaps and particularly of their beginning and ends. While I reckon most of the analysis regarding the beginning of gaps (see e.g. [5] and [3]) and their links to admissible ordinals may be extended to $\Gamma$-machines, the absence of the Speed-up Lemma makes it less clear when it comes to the end of gaps. In particular, this leads to the following question: does there exist a simulational operator $\Gamma$ for which a gap ends at a non-limit ordinal stage?

To specify the relationship between writable real numbers and the level of the constructible hierarchy, we can encode sets with real numbers. This is done in a similar fashion as with ordinals. Observe however that, without consequences, it does not yield the exact same encoding for ordinals seen as well-orders and ordinals seen as sets.

Definition 4.11** (Encoding of sets).**

We say that a real number $x$ encodes a set $a$ when $x$ describes a transitive relation $E$ on $\omega$ such that $(\omega,E)\simeq(TC(\left\{a\right\}),\in)$. As with ordinals, a set $a$ is writable (resp. eventually writable and accidentally writable) by a $\Gamma$-machine when a code for $a$ is writable (resp. eventually writable and accidentally writable) by a $\Gamma$-machine.

Proposition 4.12**.**

Let $\Gamma$ be a simulational $n$-symbol operator that emulates the operator $\Gamma_{\sup}$. If a set $a$ is in $L_{\lambda_{\Gamma}}$ (resp. in $L_{\zeta_{\Gamma}}$ and in $L_{\Sigma_{\Gamma}}$) then it is writable (resp. eventually writable and accidentally writable) by a $\Gamma$-machine.

Proof.

If $a\in L_{\Sigma_{\Gamma}}$, there is an accidentally writable ordinal $\alpha$ such that $a\in L_{\alpha}$. Hence, a code for $a$ is computable from a code for $L_{\alpha}$. Now consider the following computation that will accidentally write $a$ under the assumption that $a$ is in $L_{\Sigma_{\Gamma}}$: as $\Gamma$ is simulational, the machine can enumerate all ordinals below $\Sigma_{\Gamma}$. For each of those ordinals $\nu$, as $\Gamma$ emulates the $\limsup$ operator, the machine can write a code for $L_{\nu}$ on its working tape and try to extract the subcode that would be a code for $a$. Before $\alpha$ appears, what it thus produces is likely gibberish. When $\alpha$ appears, a code for $a$ is accidentally written. This works similarly if $a$ is in $L_{\zeta_{\Gamma}}$ or $L_{\lambda_{\Gamma}}$: the machine simply eventually writes or writes the right $L_{\alpha}$ and computes a code for $a$ from it. ∎

Remark 4.13**.**

We may be tempted, under the hypothesis that $\Gamma$ emulates the operator $\Gamma_{\sup}$, to try and immediatly establish the converse implication of Proposition 4.12 (which will be a corollary of Theorem 4.14). That is to show, for the first case, that if $x$ is accidentally writable then $x\in L_{\Sigma_{\Gamma}}$. It would simply build on the work which was already done for the operator $\Gamma_{\sup}$. Suppose that $x$ is accidentally writable by $\Gamma$, then as $\Gamma$ emulates $\Gamma_{\sup}$ a $\Gamma$-machine could use this $x$ to accidentally write greater and greater ordinals in $\Sigma^{x}_{\Gamma_{\sup}}$ (which is $\Sigma_{\Gamma_{\sup}}$ relativised to computations with $x$ as input). And as we might think that $x\in L_{\Sigma^{x}_{\Gamma_{\sup}}}$ (after all, $x$ is $x$-writable), this would mean, a fortiori, that $x\in L_{\Sigma_{\Gamma}}$. But it happens that $x\in L_{\Sigma^{x}_{\Gamma_{\sup}}}$ simply does not hold in the general case (the fact that $x$ is $x$-writable simply says that $x\in L_{\Sigma^{x}_{\Gamma_{\sup}}}[x]$). Welch first considered in [16] the (analogous) set

[TABLE]

which he explains is akin to the set

[TABLE]

Both of those sets are thin (i.e. they do not admit non-empty and non-unit closed subsets) which implies that uncountably many real numbers $x$’s are not in $F_{0}$ or $Q$. A proof of which we give the idea can be found in [2]. Consider $F_{0}$ and suppose that it is not thin. That is, it contains a perfect subset $P$ (i.e. closed subset with not isolated points). $P$ is continuously isomorphic to ${}^{\omega}2$, so for our purpose we can assume that $P={}^{\omega}2$. We then consider the application $f:x\mapsto\lambda^{x}$. It induces a pre-well-ordering $\preceq$ on ${}^{\omega}2$:

[TABLE]

This pre-well-order has order type $\omega_{1}$ (the $\lambda^{x}$ are unbounded in $\omega_{1}$) and is $\Sigma_{1}^{1}$ (under our the assumption that $P\subset F_{0}$ and modulo the isomorphism, which implies that $x\in\lambda^{x}$, we have that $\lambda^{x}\leqslant\lambda^{y}$ is equivalent to $x$ being $y$-computable.) Hence, this yields a Lebesgue measurable (as a subset of ${}^{\omega}2\times{}^{\omega}2$) pre-well-order of the real numbers which can be shown with Fubini’s theorem to yield a contradiction.

We now state the main theorem of this article.

Theorem 4.14**.**

Let $\Gamma$ be an $n$-symbol suitable, looping stable and simulational operator. Then ${\Sigma_{\Gamma}=\mathrm{T}_{\Gamma}}$.

We will prove this result step by step. For all that follows in this subsection, we let $\Gamma$ be an $n$-symbol suitable, looping stable and simulational operator. By Theorem 4.6, we can suppose w.l.o.g. that it emulates the $2$-symbol operator $\Gamma_{\sup}$.

Proposition 4.15**.**

The supremum of the $\Gamma$-e.c. ordinals is strictly less than that of the $\Gamma$-a.c. ordinals. That is, $\eta_{\Gamma}<\mathrm{T}_{\Gamma}$.

Proof.

We show that in $\mathcal{U}_{\Gamma}$ a new real number appears at stage $\eta_{\Gamma}$, that is that $\mathcal{U}_{\Gamma}$ a.c. stage $\eta_{\Gamma}$.

For this, observe that once a machine converges, that is once its output stabilizes definitely, it computes through a set of snapshot that never occurred in the computation of this machine before it converged. Indeed, suppose it did earlier, then by asymptoticity the machine would already have converged at this earlier stage. Hence this defines two disjoint sets of snapshot: those before the machine converged and those after, that we can call the converging snapshots. Moreover, as a machine e.c. the stage at which it converges, $\eta_{\Gamma}$ is the first stage at which all converging machines actually converged. Hence it is the first stage at which all the snapshots of those machine belong to their respective set of converging snapshots. This naturally stays true in their simulation done by the universal machine. Hence the real number on the working tape of the universal machine at stage $\eta_{\Gamma}$ appeared for the first time. ∎

Proposition 4.16**.**

If the supremum of the eventually clockable ordinals is smaller than or equal to that of the accidentally writable ordinals, then the supremum of the accidentally writable ordinals is equal to that of the accidentally clockable ordinals. That is, if $\eta_{\Gamma}\leqslant\Sigma_{\Gamma}$ then $\Sigma_{\Gamma}=\mathrm{T}_{\Gamma}$.

Proof.

We suppose that $\eta_{\Gamma}\leqslant\Sigma_{\Gamma}$. We show that, in this case, in any $\Gamma$-machine $m$, nothing new appears after stage $\Sigma_{\Gamma}$. This will show that $\Sigma_{\Gamma}\geqslant\mathrm{T}_{\Gamma}$ and, by Proposition 4.8, that $\Sigma_{\Gamma}=\mathrm{T}_{\Gamma}$.

Suppose that there is some $\Gamma$-machine $m$, a real number $x_{m}$ and a least ordinal stage $\alpha_{m}\geqslant\Sigma_{\Gamma}$ such that $x_{m}$ appears for the first time on a tape of $m$ at stage $\alpha_{m}$. We consider the following computation: it simulates $m$ and at each step of $m$, writing $x$ the real number written on the relevant tape, it simulates a fresh instance of $\mathcal{U}_{\Gamma}$. For each ordinal $\alpha$ accidentally written by $\mathcal{U}_{\Gamma}$, its simulate a fresh copy of $m$ for $\alpha$ steps and looks whether $x$ appears in $m$ during those $\alpha$ steps. If $x$ appeared for the first time in $m$ before stage $\Sigma_{\Gamma}$, this subcomputation will eventullay find an ordinal below $\Sigma_{\Gamma}$ great enough so that $x$ is found in the simulation of $m$. Actually, $x_{m}$ is the first real number accidentally writable by $m$ that can’t be found by this subcomputation. Effectively, the computation we designed eventually writes $x_{m}$ and eventually clocks some ordinal greater or equal to $\alpha_{m}$. By our assumptions, $\alpha_{m}$ is itself greater than $\Sigma_{\Gamma}$ and so greater than $\eta_{\Gamma}$. Hence the machine e.c. an ordinal greater than $\eta_{\Gamma}$ which is a contradiction. ∎

Now, in virtue of Proposition 4.16, to prove Theorem 4.14, it suffices to prove that the case $\zeta_{\Gamma}<\Sigma_{\Gamma}<\eta_{\Gamma}<\mathrm{T}_{\Gamma}$ leads to a contradiction. This case is represented in Figure 5. In the rest of the proof, spanning almost until the end of the section, we suppose toward a contradiction that the constants of $\Gamma$ give rise to this situation.

Proposition 4.17**.**

In the computation of $\mathcal{U}_{\Gamma}$, there are $\Sigma_{\Gamma}$ distinct snapshots appearing before stage $\Sigma_{\Gamma}$.

Proof.

As $\Sigma_{\Gamma}\leqslant\mathrm{T}_{\Gamma}$ by Proposition 4.8, $\mathcal{U}_{\Gamma}$ is not seen to be looping before stage $\Sigma_{\Gamma}$. Then for any $\alpha<\Sigma_{\Gamma}$, a code for $\alpha\cdot\omega^{\omega}$ is writable from a code for $\alpha$. Hence $\alpha\cdot\omega^{\omega}<\Sigma_{\Gamma}$ and by Proposition 3.44 for any $\alpha<\Sigma_{\Gamma}$ there is a new snapshot (that is distinct from all previous snapshots) that appears after stage $\alpha$ and before stage $\alpha\cdot\omega^{\omega}$. As $\Sigma_{\Gamma}$ is multiplicatively closed, we can repeat this reasoning with $\alpha\cdot\omega^{\omega}$ and so on; which yields $\Sigma_{\Gamma}$ distinct snapshots. ∎

Proposition 4.18**.**

Let $x_{\alpha}$ be a code for some ordinal $\alpha<\Sigma_{\Gamma}$. Then the $\alpha^{th}$ distinct snapshot appearing in the computation of $\mathcal{U}_{\Gamma}$ is $x_{\alpha}$-$\Gamma$-writable.

Proof.

We show that there is a machine that, given (the code of) some ordinal $\alpha$ as input, can write the $\alpha^{th}$ distinct snapshot appearing in $\mathcal{U}_{\Gamma}$ if it exists and that never halts if it does not. More precisely it will use $\alpha$ to write down the $\alpha+1$ first distinct snapshots of $\mathcal{U}_{\Gamma}$. The machine works as follows: using $\alpha$ given as input to arrange the information (that is it splits the working tape or some part of it into $\alpha$ virtual tape, each of those being able to store a real number describing a snapshot), it will inductively look for the $\beta$ first distinct snapshots for all $\beta<\alpha$. For $\beta=0$, the first distinct snapshot of $\mathcal{U}_{\Gamma}$ is its initial snapshot. Then, for any $\beta<\alpha$ such that the machine saved the $\beta$ first distinct snapshots, that is such that every $\delta<\beta$ correspond to a distinct saved snapshot, the machine simulates $\mathcal{U}_{\Gamma}$ and, at each stage of this simulation, checks whether this snapshot is one of the snapshots saved as the $\delta^{th}$ distinct snapshot for some $\delta<\beta$. If the machine finds one that isn’t part of those and consequently is a new snapshot, it saves it as the $\beta^{th}$ distinct snapshot. If the machine eventually finds $\alpha$ distinct snapshots, then the next distinct snapshot it finds (if it finds it) with the same procedure is the $\alpha^{th}$ snapshot it was looking for and it can stop. If at any point the machine does not find the wanted next distinct snapshots, it never halts. ∎

Proposition 4.19**.**

In the computation of $\mathcal{U}_{\Gamma}$, the order-type of the distinct snapshots is greater than or equal to $\Sigma_{\Gamma}+1$ and the $\Sigma_{\Gamma}^{th}$ distinct snapshot (that is the last of the $\Sigma_{\Gamma}+1$ first snapshots) is eventually writable.

Proof.

As, by Proposition 4.16, the working hypothesis $\Sigma_{\Gamma}<\eta_{\Gamma}$ implies that $\Sigma_{\Gamma}<\mathrm{T}_{\Gamma}$, there is some machine computation in which a real number appears for the first time after stage $\Sigma_{\Gamma}$. As this machine is simulated by the universal machine $\mathcal{U}_{\Gamma}$, there is a least stage $\alpha\geqslant\Sigma_{\Gamma}$ such that a snapshot $s$ appears for the first time at this stage on the working tape of $\mathcal{U}_{\Gamma}$. By Proposition 4.17 this snapshot is the $\Sigma_{\Gamma}^{th}$ distinct snapshot (that is the last of the $\Sigma_{\Gamma}+1$ first snapshots) appearing in the computation of $\mathcal{U}_{\Gamma}$.

We show that this snapshot $s$ is eventually writable. Consider this machine: it simulates $\mathcal{U}_{\Gamma}$ in a simulation that we call $\mathcal{U}_{\Gamma}^{1}$. For each snapshot $s^{1}$ of $\mathcal{U}_{\Gamma}^{1}$, it first copies it on its output and launches a new simulation $\mathcal{U}_{\Gamma}^{2}$ to enumerate the ordinals $\alpha\in\Sigma_{\Gamma}$. More precisely, using $\mathcal{U}_{\Gamma}^{2}$, the main machine looks for an ordinal $\alpha$ such that $s^{1}$ is the $\alpha^{th}$ distinct snapshot of $\mathcal{U}_{\Gamma}$. This can be done using the machine described in the proof of Proposition 4.18. If such an $\alpha$ is found, the computation goes on with the simulation of $\mathcal{U}_{\Gamma}^{1}$. Now, when $s^{1}$, the snapshot of $\mathcal{U}_{\Gamma}^{1}$, is the $\beta^{th}$ distinct snapshot of $\mathcal{U}_{\Gamma}^{1}$ for $\beta\in\Sigma_{\Gamma}$, the simulation $\mathcal{U}_{\Gamma}^{2}$ obviously yields at some point the correct $\alpha$, that is such that $\alpha=\beta$. On the other hand, when $\beta\geqslant\Sigma_{\Gamma}$ the simulation of $\mathcal{U}_{\Gamma}^{2}$ never finds an $\alpha$ big enough and the machine never halts. This happens for the first time with the $\Sigma_{\Gamma}^{th}$ snapshot of $\mathcal{U}_{\Gamma}^{1}$ and this snapshot is actually eventually writable, as wanted. ∎

Proposition 4.20**.**

For the operator $\Gamma$, there exists some stage $\mathrm{A}<\eta_{\Gamma}$ such that for each accidentally writable ordinals, there is a machine in which this ordinal appears before stage $\mathrm{A}$.

Proof.

We use the previously proven fact that there is some eventually writable snapshot that appears after $\Sigma_{\Gamma}$ distinct snapshots appeared in $\mathcal{U}_{\Gamma}$ to study the time of first appearance of ordinals in any computation. Let $s_{\alpha}$ be this eventually writable snapshot, as defined in the proof of Proposition 4.19, and $\alpha\geqslant\Sigma_{\Gamma}$ that stage at which it appears.

We show using this snapshot $s_{\alpha}$ that there exists some stage $\mathrm{A}<\eta_{\Gamma}$ such that all accidentally writable ordinals appear in $\mathcal{U}_{\Gamma}$ before this stage $\mathrm{A}$. While this is slightly different than the statement of the proposition, remember that at any limit stage $\nu$, inside of the computation of the universal machine $\mathcal{U}_{\Gamma}$, all machine also reached stage $\nu$ of their simulation. In other words, in its simulations of other machines, the universal machine is never delayed by more than $\omega$ steps. Hence, as $\eta_{\Gamma}$ is additively closed, it is equivalent to prove this result for $\mathcal{U}_{\Gamma}$ or, as initially stated, for all machines individually.

So we consider the following computation of a machine that we call $\mathcal{M}$. It simulates $\mathcal{U}_{\Gamma}^{1}$ a copy of $\mathcal{U}_{\Gamma}$, and at each step of $\mathcal{U}_{\Gamma}^{1}$, writing $s$ for its snapshot, $\mathcal{M}$ writes $s$ on its own output tape and launches $\mathcal{U}_{\Gamma}^{2}$, a fresh copy of $\mathcal{U}_{\Gamma}$, in order to enumerate the ordinals below $\Sigma_{\Gamma}$. For each ordinal $\beta$ appearing in this fresh copy of $\mathcal{U}_{\Gamma}$, the main machine launches $\mathcal{U}_{\Gamma}^{3}$, a third fresh copy of $\mathcal{U}_{\Gamma}$ and checks whether the snapshot $s$ of the simulation of $\mathcal{U}_{\Gamma}^{1}$ appears in the $\beta$ first steps of $\mathcal{U}_{\Gamma}^{3}$. If it does, the simulation of $\mathcal{U}_{\Gamma}^{1}$ carries on and this procedure is repeated with the next snapshots appearing in $\mathcal{U}_{\Gamma}^{1}$. If it does not, the simulation of $\mathcal{U}_{\Gamma}^{2}$ continues with its enumeration of the accidentally writable ordinals. Hence, when the simulation of $\mathcal{U}_{\Gamma}^{1}$ reaches stage $\alpha$, the snapshot $s_{\alpha}$ is written on the output tape of the main machine. As this snapshot does not appear before stage $\Sigma_{\Gamma}$, it will never be found by the simulation of $\mathcal{U}_{\Gamma}^{3}$ that is only conducted through accidentally writable stages and $\mathcal{M}$ effectively eventually writes $s_{\alpha}$. Now the interesting part is: which ordinal is then e.c. by this computation?

Let $\mathrm{A}\leqslant\mathrm{T}_{\Gamma}$ be the least ordinal stage such that for each accidentally writable ordinal, there is a machine in which it appears before stage $\mathrm{A}$. We claim that if $\mathrm{A}>\eta_{\Gamma}$, that is if there is some accidentally writable ordinal $\sigma$ that does not appear before stage $\eta_{\Gamma}$ in any machine, then the previous computation e.c. some ordinal greater than $\eta_{\Gamma}$. First, if such an ordinal $\sigma$ exists, all ordinals greater than $\sigma$ also appears after stage $\eta_{\Gamma}$. Then, as $\sigma$ is accidentally writable, $\sigma<\Sigma_{\Gamma}$ and by Proposition 4.17 there is some snapshot $t$ that appears for the first time in $\mathcal{U}_{\Gamma}$ after stage $\sigma$. Consequently, when $t$ appears in the first simulation of $\mathcal{U}_{\Gamma}$ in $\mathcal{M}$, $\mathcal{U}_{\Gamma}^{2}$, the second simulation of $\mathcal{U}_{\Gamma}$, won’t stop until it finds some ordinal greater than $\sigma$. And to do this it will compute for at least $\eta_{\Gamma}$ steps. Consequently, in such a case, when $\mathcal{M}$ converges, it has computed for more than $\eta_{\Gamma}$ steps and it e.c. an ordinal greater than $\eta_{\Gamma}$; which is a contradiction. Hence $\mathrm{A}\leqslant\eta_{\Gamma}$. What is left to show is that $\mathrm{A}$ can’t be equal to $\eta_{\Gamma}$.

Suppose now that $\mathrm{A}=\eta_{\Gamma}$: by minimality of $\mathrm{A}$, for any $\alpha<\eta_{\Gamma}$, there is some accidentally writable ordinal $\sigma$ that does not appear in $\mathcal{U}_{\Gamma}$ before stage $\alpha$. Moreover, by the definition of $\eta_{\Gamma}$, for any $\alpha<\eta_{\Gamma}$, there are machines that converge after stage $\alpha$. In particular there is some stage $\alpha_{\zeta}<\eta_{\Gamma}$ such that $\zeta_{\Gamma}$ appears for the first time at stage $\alpha_{\zeta}$ and some machine $m$ that converges at stage $\alpha_{m}>\alpha_{\zeta}+\omega$, as depicted in figure 6. With it, we design the following computation $\mathcal{N}$: using a first simulation of $\mathcal{U}_{\Gamma}$, that we call $\mathcal{U}_{\Gamma}^{1}$, $\mathcal{N}$ enumerates the accidentally writable ordinals and for every ordinal $\alpha$ it finds, it does the following: it simulates in parallel a copy of $m$ and $\mathcal{U}_{\Gamma}^{2}$, a new copy of $\mathcal{U}_{\Gamma}$, until ordinal $\alpha$ or greater appears in $\mathcal{U}_{\Gamma}^{2}$. As $\alpha$ appeared in the simulation $\mathcal{U}_{\Gamma}^{1}$, it must appear at some point in $\mathcal{U}_{\Gamma}^{2}$. When $\alpha$ has been found in $\mathcal{U}_{\Gamma}^{2}$, it is written on the output of $\mathcal{N}$ and then the simulation of $m$ is carried on until there is a proof that $m$ had not yet converged. That is until the output of $m$ is modified for the first time after $\alpha$ has been found. When and if this happens, the main computation carries on with simulation of $\mathcal{U}_{\Gamma}^{1}$ and starts this procedure again with the next $\alpha^{\prime}$ it produces.

Now, as $m$ is a converging machine, it will have converged (that is reached the stage after which its output won’t be modified anymore) after some $\alpha$ has been found when, before reaching the point at which this $\alpha$ is found, the parallel computation of $m$ and $\mathcal{U}_{\Gamma}^{2}$ was carried for at least $\alpha_{m}$ steps. For this parallel simulation of $\mathcal{U}_{\Gamma}^{2}$ and $m$ to be carried for at least $\alpha_{m}$ steps, it must have been looking for an ordinal greater than $\zeta_{\Gamma}$; as $\zeta_{\Gamma}$ appeared before, at stage $\alpha_{\zeta}$. Observe also that $\zeta_{\Gamma}$ appears at stage $\alpha_{\zeta}$ implies that any ordinal $\beta<\zeta_{\Gamma}$ appears before stage $\alpha_{\zeta}+\omega$. Moreover, by the assumption that $\mathrm{A}=\eta_{\Gamma}$, ordinals great enough (that is greater than $\zeta_{\Gamma}$ and further, great enough to appear for the first time after stage $\alpha_{m}$) are indeed found after stage $\alpha_{m}$. Consequently, at this point, $m$ is definitely converging and so is $\mathcal{N}$. And this is only possible because such an ordinal greater than $\zeta_{\Gamma}$ has been encountered in $\mathcal{U}_{\Gamma}^{1}$, that $\mathcal{U}_{\Gamma}^{2}$ then found at some computation stage greater than $\alpha_{m}$. So $\mathcal{N}$ has eventually written this ordinal greater than $\zeta_{\Gamma}$, which is a contradiction.

∎

Now, by Proposition 4.20, we obtain the state of affairs described in figure 7 for the $\Gamma$-machines.

Proposition 4.21**.**

In the situation described in Figure 7 there is an eventually writable snapshot $s_{\Sigma}$ and a machine $m_{\Sigma}$ such that given as input $s_{\Sigma}$, any set theoretic formula $\varphi$ and any parameter $p\in L_{\Sigma_{\Gamma}}$, this machine decides whether $L_{\Sigma_{\Gamma}}\models\varphi(p)$.

Proof.

Let $m$ be a machine that converges after all accidentally writable ordinal appeared in $\mathcal{U}_{\Gamma}$. Such a machine exists as, by Proposition 4.20, $A<\eta_{\Gamma}$.

First we show that we can eventually write the snapshot at which $m$ converges (while the output of $m$ stabilizes at some point, its whole snapshot may not stabilize.) Consider the following computation: it simulates $m$ and at each stage where the output appears to have stabilized (that is the output did not change for at least one step), the main machine saves the snapshot of $m$. When $m$ starts to converge definitely, its output is never modified anymore and consequently neither does its saved snapshot. We call $s_{\Sigma}$ this particular snapshot. What is now interesting is that when this snapshot appears in $m$, itself simulated in $\mathcal{U}_{\Gamma}$, all ordinals appeared in $\mathcal{U}_{\Gamma}$. Indeed, it does not appear earlier as otherwise, by asymptoticity of $\Gamma$, the machine would also be converging earlier.

Now we describe the machine $m_{\Sigma}$ that decides whether $L_{\Sigma}\models\varphi(p)$ with $\varphi$, $p$ and $s_{\Sigma}$ given as input. As $s_{\Sigma}$ is given as input, by looking at the simulation of $m$ inside $U_{\Gamma}$, $m_{\Sigma}$ knows when $m$ reaches snapshot $s_{\Sigma}$ and so, it knows when all ordinal below $\Sigma_{\Gamma}$ appeared. Moreover, as the operator $\Gamma$ emulates the usual $\Sigma_{2}$-rule, given a code for any ordinal $\alpha$, a code for $L_{\alpha}$ is computable from it. With this in mind, $m_{\Sigma}$ can use $\mathcal{U}_{\Gamma}$ to enumerate $L_{\Sigma_{\Gamma}}$ and it will know when all elements of $L_{\Sigma_{\Gamma}}$ appeared in the iteration. Using this, it works inductively as follows: If $\varphi(p)$ is $\Delta_{0}$, it is absolute and the machine can directly evaluate it. Then, when $\varphi(p)=\exists x\psi(x,p)$ is a $\Sigma_{n}$ formula: it starts by simulating $\mathcal{U}_{\Gamma}$ and it looks at the ordinals that appear in it until the simulation of $m$ inside $\mathcal{U}_{\Gamma}$ reaches snapshot $s_{\Sigma}$. When this occurs, all ordinals below $\Sigma_{\Gamma}$ appeared and the machine effectively enumerated all accidentally writable ordinals. Meanwhile, before $s_{\Sigma}$ appears in $m$, for all ordinal $\alpha<\Sigma_{\Gamma}$ appearing in $\mathcal{U}_{\Gamma}$, it enumerates $L_{\alpha}$. For each $x$ coding an element of $L_{\alpha}$ it inductively (on $\psi$) decides whether $L_{\Sigma_{\Gamma}}\models\psi(x,p)$. If it does, that is if $L_{\Sigma_{\Gamma}}\models\psi(x,p)$, then $L_{\Sigma_{\Gamma}}\models\varphi(p)$ and $m_{\Sigma}$ halts and outputs true. If it doesn’t, the iteration of $L_{\Sigma}$ goes on. If at the end of the iteration, no $x$ such that $L_{\sigma}\models\psi(x,p)$ has been found, then it outputs false. And the case where $\varphi$ is $\Pi_{n}$ is dealt with by considering $\neg\varphi$. Observe also, as the induction is finite, that there is no difficulties organizing the information from the different recursive calls.

∎

Proposition 4.22**.**

$L_{\Sigma_{\Gamma}}$* is an end-elementary extension (e.e.e) of $L_{\zeta_{\Gamma}}$. That is, $L_{\zeta_{\Gamma}}\prec L_{\Sigma_{\Gamma}}$.*

Proof.

We show this by induction. By absoluteness $L_{\zeta_{\Gamma}}\prec_{\Sigma_{0}}L_{\Sigma_{\Gamma}}$. Then let $\varphi$ be a $\Sigma_{n}$ formula such that for some $p\in L_{\zeta_{\Gamma}}$, $L_{\Sigma_{\Gamma}}\models\varphi(p)$. We show that $L_{\zeta_{\Gamma}}\models\varphi(p)$. By Proposition 4.12, $p$ is eventually writable. Writing $\varphi(p)=\exists x\psi(x,p)$ with $\psi$ a $\Delta_{0}$ formula, by Proposition 4.21, given $p$, some $x$ and $s_{\Sigma}$, $m_{\Sigma}$ can decide whether $L_{\Sigma_{\Gamma}}\models\psi(x,p)$. As $p$ and $s_{\Sigma}$ are eventually writable, $\widetilde{x}$, the first $x$ appearing in $\mathcal{U}_{\Gamma}$ such that $L_{\Sigma_{\Gamma}}\models\psi(x,p)$ is eventually writable as well. So we consider $\psi(\widetilde{x},p)$, true in $L_{\Sigma_{\Gamma}}$. As both $\widetilde{x}$ and $p$ are eventually writable, they are in $L_{\zeta_{\Gamma}}$ and we can apply the induction hypothesis: $L_{\zeta_{\Gamma}}\models\psi(\widetilde{x},p)$. And so, $L_{\zeta_{\Gamma}}\models\varphi(p)$.

Conversely, if $L_{\Sigma_{\Gamma}}\not\models\varphi(p)$, then $L_{\Sigma_{\Gamma}}\models\forall x\,\neg\psi(x,p)$. Hence for all $\widetilde{x}\in L_{\zeta_{\Gamma}}$, $L_{\Sigma_{\Gamma}}\models\neg\psi(\widetilde{x},p)$ with $\neg\psi(\widetilde{x},p)$ $\Sigma_{n-1}$. So by the previous implication, $L_{\zeta_{\Gamma}}\models\neg\psi(\widetilde{x},p)$. That is, $L_{\zeta_{\Gamma}}\models\forall x\,\neg\psi(x,p)$, i.e. $L_{\zeta_{\Gamma}}\not\models\varphi(p)$. ∎

Corollary 4.23**.**

Given as input $s_{\Sigma}$, any set theoretic formula $\varphi$ and any parameter $p\in L_{\zeta_{\Gamma}}$, the machine $m_{\Sigma}$ decides whether $L_{\zeta_{\Gamma}}\models\varphi(p)$.

Proof.

By elementarity it is enough to decide whether $L_{\Sigma_{\Gamma}}\models\varphi(p)$. ∎

In this proof toward a contradiction we now have obtained fairly strong results. The fact that $L_{\zeta_{\Gamma}}\prec L_{\Sigma_{\Gamma}}$ is clearly way too powerful to be established for any $\Sigma_{n}$ operator $\Gamma$ and the fact that we can decide whether $L_{\Sigma_{\Gamma}}\models\varphi(p)$ seems a direct contradiction of the intuition that $L_{\Sigma_{\Gamma}}$ is a bound on what the $\Gamma$-machines may apprehend. Still, reaching a conclusion from there is still somewhat involved. To harvest the previous result, Corollary 4.23, we show how we can use a system of notations to virtually work with $L_{\zeta_{\Gamma}\cdot 2}$ in $L_{\zeta_{\Gamma}}$.

Definition 4.24** (Notation).**

We define a system of notation in $L_{\zeta_{\Gamma}}$. We write $\top$ for some distinguished tautological sentence. A set $a$ is a notation if and only if:

• •

Either $a=\langle\top,x,0,\beta\rangle$ for $x\in L_{\beta}$ and $\beta\in\zeta_{\Gamma}$.

• •

Or $a=\langle\varphi,b_{1},\dots,b_{n},\alpha,\beta\rangle$ where $\varphi$ is a set-theoretic formula (encoded by a set) without the symbol of equality, $\alpha>0$ and $\beta$ are ordinals in $\zeta_{\Gamma}$ and the ordered pair $(\alpha,\beta)$ is called the rank of $a$, written $\operatorname{rk}(a)$, and $b_{1},\dots,b_{n}$ are notations of rank strictly less (w.r.t. lexicographical order) than $(\alpha,\beta)$.

We now use those notations to encode sets in $L_{\zeta_{\Gamma}^{2}}$, the level $(\zeta_{\Gamma})^{2}$ of the constructible universe.

Definition 4.25** (Notation of a set).**

For $x\in L_{\zeta_{\Gamma}^{2}}$, the least notation of the set $x$, $\macc@depth\@ne\macc@set@skewchar\macc@nested@a 111{x}$, is a notation inductively defined as follows.

• •

If $x\in L_{\beta}$ for some least $\beta\in\zeta_{\Gamma}$:

[TABLE]

• •

If $x\in L_{\zeta_{\Gamma}\cdot\alpha+\beta+1}-L_{\zeta_{\Gamma}\cdot\alpha+\beta}$, with $\alpha>0$, then $x$ was defined over $L_{\zeta_{\Gamma}\cdot\alpha+\beta}$ by some least formula $\varphi$ (w.r.t. some fixed order on formulas) and least parameters $p_{1},\dots,p_{n}\in L_{\zeta_{\Gamma}\cdot\alpha+\beta}$ (w.r.t. $<_{L}$). And by extensionality we can w.l.o.g. suppose that the symbol of equality is not used in $\varphi$. So we define:

[TABLE]

Definition 4.26** (Set of a notation).**

For a notation $a\in L_{\zeta_{\Gamma}}$, the set of the notation $a$, $\widehat{a}$, is inductively defined as follows:

• •

If $a=\langle\top,x,0,\beta\rangle$:

[TABLE]

• •

If $a=\langle\varphi,b_{1},\dots,b_{n},\alpha,\beta\rangle$ with $\alpha>0$:

[TABLE]

We draw the attention of the reader to some clear but important features of this system of notations.

Proposition 4.27**.**

• –

The operator $x\mapsto\macc@depth\@ne\macc@set@skewchar\macc@nested@a 111{x}$ defined on $L_{\zeta_{\Gamma}^{2}}$ is injective, $\widehat{\macc@depth\@ne\macc@set@skewchar\macc@nested@a 111{x}}=x$ and the operator $a\mapsto\widehat{a}$ is surjective onto $L_{\zeta_{\Gamma}^{2}}$. That is, every set in $L_{\zeta_{\Gamma}^{2}}$ has a notation.

• –

A notation only uses finitely many notations in its definition.

• –

For a notation $a$ of rank $(\alpha,\beta)$, $\widehat{a}\in L_{\zeta_{\Gamma}\cdot\alpha+\beta+1}$.

• –

For $x\in L_{\zeta_{\Gamma}\cdot\alpha+\beta+1}$ with $\alpha,\beta<\zeta_{\Gamma}$, $x$ has a notation of rank less than $(\alpha,\beta)$.

Proof.

• –

By definition, it is clear that $x\mapsto\macc@depth\@ne\macc@set@skewchar\macc@nested@a 111{x}$ is injective and that $\widehat{\macc@depth\@ne\macc@set@skewchar\macc@nested@a 111{x}}=x$. Hence $a\mapsto\widehat{a}$ is surjective onto $L_{\zeta_{\Gamma}^{2}}$.

• –

Observe that the inductive definition of a notation induces a tree in which each node is a notation. In this tree, every node has finitely many children and by well-orderdness every path is finite. Hence the tree itself is finite.

• –

By induction: notations of rank $(0,\beta)$ clearly yield elements of $L_{\zeta_{\Gamma}}$. For a notation $a=\langle\varphi,b_{1},\dots,b_{n},\alpha,\beta\rangle$ with $\alpha>0$, by induction $b_{1},\dots,b_{n}$ are notations for some sets $p_{1},\dots,p_{n}$ (i.e. $\widehat{b_{i}}=p_{i}$) of rank strictly less than $(\alpha,\beta)$ and so they are in $L_{\zeta\cdot\alpha+\beta}$. Hence, as a set defined over $L_{\zeta\cdot\alpha+\beta}$, $\widehat{a}$ is in $L_{\zeta\cdot\alpha+\beta+1}$.

• –

Simply consider $\macc@depth\@ne\macc@set@skewchar\macc@nested@a 111{x}$, the least notation of $x$.

∎

Proposition 4.28**.**

There exists a $\Gamma$-machine such that: given as input $s_{\Sigma}$, a formula $\varphi$, two ordinals $\alpha,\beta\in\zeta_{\Gamma}$ with $\alpha>0$ and notations $p_{1},\dots,p_{n}$ of rank strictly less than $(\alpha,\beta)$, it decides whether

[TABLE]

Proof.

We show this by induction on $(\alpha,\beta)$. We provide a description of a machine $\mathcal{M}$ that uses the inductive definition of the notations to inductively decide whether $L_{\zeta\cdot\alpha+\beta}\models\varphi(\widehat{p_{1}},\dots,\widehat{p_{n}})$. Through this description we will actually describe two recursive subroutines relying on each other. Namely:

• •

A subroutine that given $\varphi$, two ordinals $\alpha,\beta\in\zeta_{\Gamma}$ with $\alpha>0$ and notations $p_{1},\dots,p_{n}$, decides whether $L_{\zeta\cdot\alpha+\beta}\models\varphi(\widehat{p_{1}},\dots,\widehat{p_{n}})$.

• •

A subroutine that given notations $a$ and $b$, decides whether $\widehat{a}\in\widehat{b}$.

The main difficulty will be the fact that we can’t decide whether some set $a$ is a notation. Deciding whether $a$ is of the form $\langle\varphi,b_{1},\dots,b_{n},\alpha,\beta\rangle$ for some sets $b_{1},\dots,b_{n}$ is fairly straightforward if we forget the condition on $\alpha$ and $\beta$ being in $L_{\zeta_{\Gamma}}$. However deciding this, that is whether $\alpha,\beta\in\zeta_{\Gamma}$, is clearly not doable with what we have established so far. And even if $\alpha$ and $\beta$ are known to be in $\zeta_{\Gamma}$, taking a set that looks like a notation of lower rank, that is of rank $(\alpha^{\prime},\beta^{\prime})<_{lex}(\alpha,\beta)$, clearly does not guarantee with the lexicographical order that $\beta^{\prime}$ is in $\zeta_{\Gamma}$.

Still, despite this difficulty, let us first suppose that there is some machine $m_{\langle\rangle}$ that, given the code of some set $a\in L_{\Sigma_{\Gamma}}$, decides whether $a$ is a notation. We now describe $\mathcal{M}$ using $m_{\langle\rangle}$. It works as a triple imbricated induction on $(\alpha,\beta)$ for the outermost one, the rank of $\varphi$ for the next one and the rank of its parameters for the innermost one. We begin with the induction on $(\alpha,\beta)$.

• $\bullet$

Base case is $(\alpha,\beta)=(1,0)$. In this case, by hypothesis, the rank of any $p_{i}$ is $(0,\beta_{i})$ with $\beta_{i}\in\zeta_{\Gamma}$. Hence, for any of those, $p_{i}=\langle\top,x_{i},0,\beta_{i}\rangle$ with $\widehat{p_{i}}=x_{i}$ and $\mathcal{M}$ can extract a code for $x_{i}$ given a code for $p_{i}$. And by Corollary 4.23, using $s_{\Sigma}$ which is given as input, it can decide whether $L_{\zeta}\models\varphi(x_{1},\ldots,x_{n})$.

• $\bullet$

Then, when $(\alpha,\beta)>_{lex}(1,0)$, we proceed by induction on $\varphi$.

• $\rhd$

Suppose that $\varphi$ is $\Delta_{0}$. Then there is not quantifiers and any atomic formula is of the form $\widehat{p_{i}}\in\widehat{p_{j}}$. We show by induction on $\operatorname{rk}(p_{i})$ that $\mathcal{M}$ can decide such atomic formulas using the notations $p_{i}$ and $p_{j}$.

Suppose first that we can write $p_{i}=\langle\top,x_{i},0,\beta_{i}\rangle$. This means that $x_{i}\in L_{\zeta_{\Gamma}}$. Then, either $p_{j}=\langle\top,x_{j},0,\beta_{j}\rangle$ and $\mathcal{M}$ can extract codes for $x_{i}$ and $x_{j}$ and use them to decide whether $\widehat{p_{i}}\in\widehat{p_{j}}$, as it simply means $x_{i}\in x_{j}$. Or $p_{j}=\langle\psi,c_{1},\ldots,c_{m},\alpha_{j},\beta_{j}\rangle$ and $\widehat{p_{i}}\in\widehat{p_{j}}$ if and only if:

[TABLE]

As $(\alpha_{j},\beta_{j})<_{lex}(\alpha,\beta)$, taking $p_{i}$ for a notation of $x_{i}$, $\mathcal{M}$ can inductively (by to the induction hypothesis on $(\alpha,\beta)$) decide this.

• *

Now, if $p_{i}=\langle\psi_{i},b_{1},\ldots,b_{m},\alpha_{i},\beta_{i}\rangle$ and $p_{j}=\langle\psi_{j},c_{1},\ldots,c_{k},\alpha_{j},\beta_{j}\rangle$. By definition, $\widehat{p_{i}}\in\widehat{p_{j}}$ if and only if $\widehat{p_{i}}$ is in $L_{\zeta\cdot\alpha_{j}+\beta_{j}}$ and satisfies $\psi_{j}$, the formula that defines $\widehat{p_{j}}$ over $L_{\zeta}\cdot\alpha_{j}+\beta_{j}$. That is, if and only if:

[TABLE]

First $\widehat{p_{i}}\in L_{\zeta\cdot\alpha_{j}+\beta_{j}}$ if and only if there exists a notation $q_{i}$ such that $\operatorname{rk}(q_{i})<_{lex}(\alpha_{j},\beta_{j})$ and with $\widehat{q_{i}}=\widehat{p_{i}}$. We can w.l.o.g. suppose that $\operatorname{rk}(p_{i})\geqslant_{lex}(\alpha_{j},\beta_{j})$ as otherwise $p_{i}$ satisfies the requirement. And under this assumption, given some notation $q_{i}$ such that $\operatorname{rk}(q_{i})<_{lex}(\alpha_{j},\beta_{j})$, $\widehat{q_{i}}=\widehat{p_{i}}$ if and only if for all notation $r_{i}$ such that $\operatorname{rk}(r_{i})<\operatorname{rk}(p_{i})$ we have

[TABLE]

Hence using $m_{\Sigma}$ (to enumerate codes for sets in $L_{\Sigma}$) and $m_{\langle\rangle}$ (to decide which real numbers encode a notation), $\mathcal{M}$ can enumerate the notations $q_{i}$ such that $\operatorname{rk}(q_{i})<_{lex}(\alpha_{j},\beta_{j})$ and for each of those $q_{i}$ enumerate all the $r_{i}$ such that $\operatorname{rk}(r_{i})<_{lex}\operatorname{rk}(p_{i})$ and for each of those $r_{i}$ inductively decide (as $\operatorname{rk}(r_{i})<_{lex}\operatorname{rk}(p_{i})$) whether the equivalence (2) holds; which in turn enables $\mathcal{M}$ to decide whether $\widehat{q_{i}}=\widehat{p_{i}}$ for all the $q_{i}$ it encounters; which finally lets it decide whether $\widehat{p_{i}}\in L_{\zeta\cdot\alpha_{j}+\beta_{j}}$.

As for the second part, deciding whether $L_{\zeta\cdot\alpha_{j}+\beta_{j}}\models\psi_{j}(\widehat{p_{i}},\widehat{c_{1}},\dots,\widehat{c_{k}})$ can inductively be done since $(\alpha_{j},\beta_{j})<_{lex}(\alpha,\beta)$.

• *

Last case, if $p_{i}=\langle\psi,b_{1},\ldots,b_{m},\alpha_{i},\beta_{i}\rangle$ and $p_{j}=\langle\top,y,0,\beta_{j}\rangle$, then $\widehat{p_{i}}\in\widehat{p_{j}}$ if and only if there is a notation $q_{i}=\langle\top,x,0,\beta_{i}^{\prime}\rangle$ with $\widehat{q_{i}}=\widehat{p_{i}}$ and $x\in y$. And this is decidable with the same reasoning as in the previous case, still under the assumption that notations are decidable using $m_{\langle\rangle}$.

Hence, as $\mathcal{M}$ can decide all the atomic formulas in the $\Delta_{0}$ formula $\varphi$, it can decide $\varphi$.

• $\rhd$

Now, suppose that $\varphi$ is $\Sigma_{n}$. We write $\varphi=\exists x\,\psi(x,\widehat{p_{1}},\dots,\widehat{p_{n}})$. By the results of Proposition 4.27, $x\in L_{\zeta\cdot\alpha+\beta}$ if and only if $x$ has a notation of rank strictly less than $(\alpha,\beta)$. So, $\mathcal{M}$ does the following: it uses again the fact that given the snapshot $s_{\Sigma}$ and the machine $m_{\langle\rangle}$ it can enumerate $L_{\Sigma}$ (and know when it has exhausted it). $\mathcal{M}$ enumerates $L_{\Sigma_{\Gamma}}$ and for each notation $a\in L_{\Sigma}$ such that $\operatorname{rk}(a)<(\alpha,\beta)$ it tests whether $L_{\zeta_{\Gamma}\cdot\alpha+\beta}\models\psi(\widehat{a},\widehat{p_{1}},\dots,\widehat{p_{n}})$, which it can do by the inductive hypothesis of the induction on the rank of $\varphi$. And ${L_{\zeta\cdot\alpha+\beta}\models\varphi(\widehat{p_{1}},\dots,\widehat{p_{n}})}$ if and only this is true for some notation $a$ with $\operatorname{rk}(a)<(\alpha,\beta)$.

• $\rhd$

When $\varphi$ is $\Pi_{n}$, we write $\varphi=\forall x\psi$. As in the previous case, $\mathcal{M}$ enumerates the notation $a$ in $L_{\Sigma_{\Gamma}}$ and inductively decides whether $L_{\zeta_{\Gamma}\cdot\alpha+\beta}\models\psi(\widehat{a},\widehat{p_{1}},\dots,\widehat{p_{n}})$. If it fails for some $a$, $\mathcal{M}$ outputs false. If not (and, using $s_{\Sigma}$, $\mathcal{M}$ knows when it went through all notations in $L_{\Sigma_{\Gamma}}$), it outputs true. This conclude the description of $\mathcal{M}$ under the assumption that $m_{\langle\rangle}$ was given.

Now, we need to provide a description of $m_{\langle\rangle}$. As we cannot decide whether some set is a notation because it involves deciding whether an ordinal is less than $\zeta_{\Gamma}$, we introduce the slightly more general concept of quasi-notation. Quasi-notations are defined inductively, as notations, with the only difference that for the case $a=\langle\varphi,b_{1},\dots,b_{n},\alpha,\beta\rangle$ or for the base case $a=\langle\top,x,0,\beta^{\prime}\rangle$ we only require $\alpha,\beta$ and $\beta^{\prime}$ to be in $\Sigma_{\Gamma}$ (instead of $\zeta_{\Gamma}$). The main interest of quasi-notations is that it will be fairly easy to decide whether a set is a quasi-notation: in our case, the conditions, as stated in the proposition, regarding the inputs that are given to $\mathcal{M}$ implies that they are all eventually writable. Consequently, every set that appears in a computation using them is at least accidentally writable. In particular any ordinal appearing is in $\Sigma_{\Gamma}$. In such a context, deciding whether a set is a quasi-notation is easy enough given the inductive definition of quasi-notations. So, we can consider the machine $m^{q}_{\langle\rangle}$ that, given some set $a\in L_{\Sigma_{\Gamma}}$, decides whether $a$ is a quasi-notation. And with it, we can finish the description of $\mathcal{M}$: it simply uses $m^{q}_{\langle\rangle}$ as if it was the fictitious $m_{\langle\rangle}$. Obviously, for the moment, we don’t have any guarantees regarding the behavior of $\mathcal{M}$ computing with $m^{q}_{\langle\rangle}$ instead of $m_{\langle\rangle}$. We will work our way toward this.

First, another important fact regarding quasi-notations is the following: if $a$ is a quasi-notation and $a$ is eventually writable, then $a$ is a notation. To see this, it is enough to observe that, by finite induction, all ordinals appearing in the inductive definition of $a$ will be eventually writable as well and so in $\zeta_{\Gamma}$. From there the idea is the following: if we manage to prove that the quasi-notations used in the computation of $\mathcal{M}$ (which uses $m^{q}_{\langle\rangle}$) are eventually writable, then it means that they are actually all notations! And so, despite $\mathcal{M}$ working with $m^{q}_{\langle\rangle}$ which simply recognizes quasi-notation, it would actually behave as if it was working with $m_{\langle\rangle}$, which recognizes notations.

So we consider the computation of $\mathcal{M}$ using $m^{q}_{\langle\rangle}$, with input $s_{\Sigma}$, a formula $\varphi$, two ordinals $\alpha,\beta\in\zeta_{\Gamma}$ with $\alpha>0$ and notations $p_{1},\dots,p_{n}$ of rank strictly less than $(\alpha,\beta)$, as stated above. As noted, all those inputs are eventually writable. Further, by well-orderdness of the lexicographical order on $\Sigma_{\Gamma}\times\Sigma_{\Gamma}$, the machine also terminates when working with quasi-notation. So, suppose that $\mathcal{M}$ answers positively, that is, it thinks that $L_{\zeta\cdot\alpha+\beta}\models\varphi(\widehat{p_{1}},\dots,\widehat{p_{n}})$ (but this may not be what it actually computed, working with quasi-notations). Suppose also that $\varphi$ is $\Sigma_{n}$: $\varphi(\widehat{p_{1}},\dots,\widehat{p_{n}})=\exists x\psi(x,\widehat{p_{1}},\dots,\widehat{p_{n}})$. As $\mathcal{M}$ answered positively, this means that it found a quasi-notation $a_{x}$ of rank strictly less than $(\alpha,\beta)$ for which it thinks that “$L_{\zeta_{\Gamma}\cdot\alpha+\beta}\models\varphi(\widehat{a_{x}},\dots,\widehat{p_{n}})$”. As noted earlier, working with the lexicographical order, the rank of $a_{x}$ being strictly less than $(\alpha,\beta)$ does not imply that it is in $\zeta_{\Gamma}\times\zeta_{\Gamma}$. But the inputs are all eventually writable. Consequently so is $a_{x}$, as it would be easy to ask $\mathcal{M}$ to write this $a_{x}$ on its output. This, combined with the previous fact, shows that $a_{x}$ is actually a notation of rank strictly less than $(\alpha,\beta)$. That is, $\widehat{a_{x}}\in L_{\zeta\cdot\alpha+\beta}$ and $\mathcal{M}$ was correct in taking $\widehat{a_{x}}$ as a potential witness for $\varphi$. This gives the main ingredient to show by induction, again on $\varphi$, that $\mathcal{M}$, despite working with quasi-notations, yields the desired result.

• •

If $\varphi$ is $\Delta_{0}$: the only quasi-notations involved are the notations $p_{1},\dots,p_{n}$. However when deciding whether $\widehat{p_{i}}\in\widehat{p_{j}}$, the machine will use quasi-notations and may be wrong. That is, it may wrongfully think that $\widehat{p_{i}}\in\widehat{p_{j}}$ because it used a quasi-notation $q_{i}$ that isn’t a notation. But if it is the case, as the inputs involved are eventually writable, we can eventually write the first quasi-notation $q_{i}$ that $\mathcal{M}$ uses to decide that $\widehat{p_{i}}\in\widehat{p_{j}}$, thinking for example that “$\widehat{q_{i}}=\widehat{p_{i}}$”. But this implies that $q_{i}$ is a notation. And so that $\mathcal{M}$ was correct in picking this $q_{i}$. Then if it thinks that $\widehat{q_{i}}=\widehat{p_{i}}$ working with quasi-notations, this is a fortiori true with notations.

And so, inductively, we could reproduce the induction scheme used to define the machine to show that $\mathcal{M}$ is correct for each of this decisions, because (a) when something holds for all quasi-notations, it a fortiori does for all notations and (b) when something does not hold for a quasi-notation, we can arrange so that $\mathcal{M}$ eventually writes the first quasi-notation appearing in its computation for which the statement does not hold, hence showing that it is actually a notation (the important point in this previous assertion being that, by well-orderdness, at any step of the induction scheme there are only finitely many sets involved–namely the parameters that get created and carried along the inductive way–and that, by induction, all of them are eventually writable.)

This shows that $\mathcal{M}$ is correct in every of its subchoices done to decide whether the formula $\varphi$ is true and consequently that it is correct when deciding whether $\varphi$ is true.

• •

If $\varphi$ is $\Sigma_{n}$: we write $\varphi(\widehat{p_{1}},\dots,\widehat{p_{n}})=\exists x\psi(x,\widehat{p_{1}},\dots,\widehat{p_{n}})$. Suppose that $\mathcal{M}$ answers positively. That is, it found a quasi-notation $a_{x}$ such that it answers positively with $\psi$, $a_{x}$ and $p_{1},\dots,p_{n}$ as inputs. As seen, this implies that $a_{x}$ is eventually writable, so that it is actually a notation and that $\widehat{a_{x}}\in L_{\zeta_{\Gamma}\cdot\alpha+\beta}$. By induction, this means that $L_{\zeta_{\Gamma}\cdot\alpha+\beta}\models\psi(\widehat{a_{x}},\widehat{p_{1}},\dots,\widehat{p_{n}})$ and so that $L_{\zeta_{\Gamma}\cdot\alpha+\beta}\models\varphi(\widehat{p_{1}},\dots,\widehat{p_{n}})$. If it answered negatively, this is done as in the next case, replacing “positively” by “negatively”.

• •

If $\varphi$ is $\Pi_{n}$, writing $\varphi=\forall x\psi$, the machine answering positively means that for all quasi-notation $a_{x}$ of rank strictly less than $(\alpha,\beta)$, it answered positively with inputs $\psi$, $a_{x}$ and $\widehat{p_{1}},\dots,\widehat{p_{n}}$. In particular, this means that it answers positively with those inputs for all notation $a_{x}$ of rank strictly less than $(\alpha,\beta)$ (as notations are also quasi-notations). By induction, it means that for all notation $a_{x}$ of rank strictly less than $(\alpha,\beta)$, $L_{\zeta_{\Gamma}\cdot\alpha+\beta}\models\psi(\widehat{a_{x}},\widehat{p_{1}},\dots,\widehat{p_{n}})$. And by Proposition 4.27, this implies that $L_{\zeta_{\Gamma}\cdot\alpha+\beta}\models\forall x\,\psi(x,\widehat{p_{1}},\dots,\widehat{p_{n}})$. Again, the negative case is done like the $\Sigma_{n}$ positive case, replacing “positively” by “negatively”.

∎

Proposition 4.29**.**

The ordinal $\zeta_{\Gamma}$ is a gap of real numbers in the constructible universe of length $\zeta_{\Gamma}^{2}$. That is:

[TABLE]

Proof.

Suppose that some new real number $x$ is defined at some stage $\gamma\in[\zeta_{\Gamma},\zeta_{\Gamma}^{2}[$. That is, there is a formula $\varphi$ and parameters $p_{1},\dots,p_{n}\in L_{\gamma}$ such that:

[TABLE]

and $x\not\in L_{\gamma}$. As $\gamma<\zeta_{\Gamma}^{2}$ it can be written $\zeta_{\Gamma}\cdot\alpha+\beta$ with both $\alpha$ and $\beta$ in $L_{\zeta_{\Gamma}}$. By Proposition 4.27, all $p_{i}$ have a notation in $L_{\zeta_{\Gamma}}$, that is an eventually writable notation. Further, for any $n\in\omega$, a code for $\macc@depth\@ne\macc@set@skewchar\macc@nested@a 111{n}$ is easily computable. So we can consider the following machine: it starts by eventually writing $\varphi$, $\alpha$, $\beta$, $\macc@depth\@ne\macc@set@skewchar\macc@nested@a 111{p_{1}}\dots,\macc@depth\@ne\macc@set@skewchar\macc@nested@a 111{p_{n}}$ and $s_{\Sigma}$ on some part of its working tape. Once they are written (that is with the usual dovetailling technique of Proposition 3.36), for each $n\in\omega$, it computes $\macc@depth\@ne\macc@set@skewchar\macc@nested@a 111{n}$ and uses the parameters it eventually wrote to simulate the machine $\mathcal{M}$ described in Proposition 4.28. With it, it decides (and save the result on another part of its working tape) whether $L_{\zeta_{\Gamma}\cdot\alpha+\beta}\models\varphi(n,p_{1},\dots,p_{n})$ for all $n\in\omega$. Once done for all $n$, it can eventually write $x$ on its output, contradicting the fact that $x$ was a new real number appearing at stage $\gamma+1>\zeta_{\Gamma}$. ∎

We can now finish the proof of the main theorem.

Proof of Theorem 4.14.

We use the fact that $\zeta_{\Gamma}$ starts a big gap in the constructible universe to show that it is seen to be looping at stage $\zeta_{\Gamma}\cdot\omega$. It relies on Corollary 3.42, in the same way as the proof of Proposition 3.45 does.

We show first that given some accidentally writable ordinal $\alpha$, it is possible for a machine to eventually decide (that is to eventually write $1$ if it is true and [math] otherwise) whether $L_{\alpha}\prec L_{\Sigma_{\Gamma}}$. In Proposition 4.21 we showed that there is a real number $s_{\Sigma}$ and a machine $m_{\Sigma}$ such that, given $s_{\Sigma}$ and some $\varphi$ and $p$ as input, $m_{\Sigma}$ decides whether $L_{\Sigma_{\Gamma}}\models\varphi(p)$. Hence, consider the following machine $\mathcal{N}$: it eventually writes $s_{\Sigma}$, the snapshot of Proposition 4.21, and for all $\varphi(p)$ with $p\in L_{\alpha}$ and such that $L_{\alpha}\models\varphi(p)$, it uses this snapshot (that is with the usual dovetailing construction presented in proof of Proposition 3.36), to eventually decide (once $s_{\Sigma}$ has been eventually writable, $m_{\Sigma}$, as simulated in the computation we are describing, always halt!) whether $L_{\Sigma_{\Gamma}}\models\varphi(p)$. Once $\mathcal{N}$ iterated through all formulas $\varphi$ and parameters $p\in L_{\alpha}$, it eventually decides whether $L_{\alpha}\prec L_{\Sigma_{\Gamma}}$.

Now, using $\mathcal{N}$, it is possible to eventually write, if there is one, the first ordinal $\alpha$ such that $L_{\alpha}\prec L_{\Sigma_{\Gamma}}$. Indeed, as once $s_{\Sigma}$ has been eventually written, the simulation of $m_{\Sigma}$ inside some machine with $s_{\Sigma}$ as input always halts, we can design a machine that looks for $\alpha$ such that $L_{\alpha}\prec L_{\Sigma_{\Gamma}}$ and with the usual dovetailling technique, that restarts each time the machine that eventually writes $s_{\Sigma}$ changes its output. And there is one such $\alpha$ by Proposition 4.22. So there is $\alpha<\zeta_{\Gamma}$ such that $L_{\alpha}$ is an end-elementary substructure of $L_{\Sigma_{\Gamma}}$, as otherwise this computation would eventually write $\zeta_{\Gamma}$ itself. On the other side of $\zeta_{\Gamma}$, if there was a bound on those $\alpha$’s, this bound would be eventually writable and greater than $\zeta_{\Gamma}$. Hence such $\alpha$’s are cofinal in $\Sigma_{\Gamma}$. This yields, among many others, two ordinals $\alpha$ and $\alpha^{\prime}$ such that:

[TABLE]

As the operator $\Gamma$ is suitable, it is defined by some formula $\varphi_{\Gamma}$ at the different levels of the constructible universe. So, in particular, this chain of e.e.e. means, looking at the computation of $\mathcal{U}_{\Gamma}$, that stages $\alpha$, $\alpha^{\prime}$ and $\zeta_{\Gamma}$ all share the same snapshot. Hence, for any $\nu,\nu^{\prime}$ in $\left\{\alpha,\alpha^{\prime},\zeta_{\Gamma}\right\}$ with $\nu<\nu^{\prime}$ and by asymptoticity, the machine will repeat itself $\omega$ times between stages $\nu^{\prime}$ and $\nu^{\prime}\cdot\omega$. However, it does not yet imply that the machine is looping. More precisely, it does not escape this repetition of the segment $[\nu,\nu^{\prime}[$ and is actually looping if and only if, by Corollary 3.42, the snapshot occurring after this repetition is the same as a snapshot occuring between $\nu$ and $\nu^{\prime}$. So we will show that the snapshot appearing at stage $\zeta_{\Gamma}\cdot\omega$ in the computation of $\mathcal{U}_{\Gamma}$, that is after some final segment of the computation below $\zeta_{\Gamma}$ is repeated $\omega$ times, was actually part of said segment of computation.

To do this, we consider first $s_{\zeta_{\Gamma}}$, the snapshot of the computation of $\mathcal{U}_{\Gamma}$ at stage $\zeta_{\Gamma}$. As $L_{\alpha}\prec L_{\zeta_{\Gamma}}$, this snapshot also occurs at stage $\alpha$ and $s_{\zeta_{\Gamma}}$ is definable (as a real) over $L_{\alpha}$. Hence, $s_{\zeta_{\Gamma}}\in L_{\zeta_{\Gamma}}$. We let $\alpha_{0}\leqslant\alpha$ be the least stage at which this snapshot occurs. Then, we let $s_{\zeta_{\Gamma}\cdot\omega}$ be the snapshot (again seen as a real) of $\mathcal{U}_{\Gamma}$ occurring at stage $\zeta_{\Gamma}\cdot\omega$. At this stage, by asymptoticity, the segment of computation between stages $\alpha_{0}$ and $\zeta_{\Gamma}$ has been repeated $\omega$ times. Moreover, $s_{\zeta_{\Gamma}\cdot\omega}$ is definable over $L_{\zeta_{\Gamma}\cdot\omega}$ and so it is in $L_{\zeta_{\Gamma}\cdot\omega+1}$. But the gap of real numbers starting at $\zeta_{\Gamma}$ and of length $\zeta_{\Gamma}^{2}$ spans over $\zeta_{\Gamma}\cdot\omega+1$. So $s_{\zeta_{\Gamma}\cdot\omega}$ is also in $L_{\zeta_{\Gamma}}$. Now we consider the following sentence, writing $S(\nu)$ for the snapshot of $\mathcal{U}_{\Gamma}$ at some stage $\nu$:

[TABLE]

It is naturally true in $L_{\alpha^{\prime}}$ as it witnesses stages $\alpha_{0}$ and $\zeta_{\Gamma}\cdot\omega$ (As $\zeta_{\Gamma}$, the ordinal $\alpha^{\prime}$ is multiplicatively closed). Moreover, this sentence is actually expressible in the language of $L_{\zeta_{\Gamma}}$ as both $s_{\zeta_{\Gamma}}$ and $s_{\zeta_{\Gamma}\cdot\omega}$ are in $L_{\zeta_{\Gamma}}$. As such, by elementarity, it can be reflected down to $L_{\zeta_{\Gamma}}$. This implies that there is some stage $\nu^{\prime}<\zeta_{\Gamma}$ such that its snapshot is $s_{\zeta_{\Gamma}\cdot\omega}$ and such that it appears after an occurrence of the snapshot $s_{\zeta_{\Gamma}}$. As $\alpha_{0}$ is the least stage whose snapshot is $s_{\zeta_{\Gamma}}$, $\alpha_{0}<\nu^{\prime}$. As wanted, the repeating segment $[\alpha_{0},\zeta_{\Gamma}[$ in the computation of $\mathcal{U}_{\Gamma}$ yields at stage $\zeta_{\Gamma}\cdot\omega$ a snapshot that is part of it, namely that appeared at stage $\nu^{\prime}$. Hence $\mathcal{U}_{\Gamma}$ is seen to be looping at stage $\zeta_{\Gamma}\cdot\omega<\Sigma_{\Gamma}<\mathrm{T}_{\Gamma}$, which is a contradiction. ∎

The two other structural equalities are now corollaries of the main theorem.

Corollary 4.30**.**

Let $\Gamma$ be an $n$-symbol suitable, looping stable and simulational operator. Then $\zeta_{\Gamma}=\eta_{\Gamma}$.

Proof.

By Proposition 4.6, $\Gamma$ emulates, w.l.o.g., the operator $\Gamma_{\sup}$. So we can apply Proposition 4.8 which yields $\zeta_{\Gamma}\leqslant\eta_{\Gamma}$. Now, suppose that $\zeta_{\Gamma}<\eta_{\Gamma}$. This means that there is some machine $m$ and ordinal $\alpha$ such that $m$ converges at stage $\alpha$ with $\zeta_{\Gamma}<\alpha<\eta_{\Gamma}$. As $\Sigma_{\Gamma}=\mathrm{T}_{\Gamma}$ by Theorem 4.14, $\alpha<\Sigma_{\Gamma}$. Then we can consider the following machine: using $\mathcal{U}_{\Gamma}$, it enumerates ordinals below $\Sigma_{\Gamma}$. For each ordinal $\nu$ produced by $\mathcal{U}_{\Gamma}$, the main machine copies it to its output and then simulates $\nu$ steps of a fresh simulation of $m$ and, after those $\nu$ steps, goes on with the simulation of $m$ until its output changes. If it does, the computation goes on with the simulation of $\mathcal{U}_{\Gamma}$ and the enumeration of accidentally writable ordinals. If it doesn’t, it actually eventually writes the ordinal $\nu$. And the output of the simulation of $m$ does not change if and only if $\nu\geqslant\alpha$. Hence this computation eventually writes the first ordinal greater than $\alpha$ to appear, which contradicts the fact that $\zeta_{\Gamma}<\alpha$. ∎

Corollary 4.31**.**

Let $\Gamma$ be an $n$-symbol suitable, looping stable and simulational operator. Then $\lambda_{\Gamma}=\gamma_{\Gamma}$.

Proof.

Again by Proposition 4.6 and Proposition 4.8, $\lambda_{\Gamma}\leqslant\gamma_{\Gamma}$. Then, if a machine halts after stage $\lambda_{\Gamma}$, it must still do so before stage $\Sigma_{\Gamma}$ in virtue of Theorem 4.14. But then, it is easy to simulate this machine along the accidentally writable ordinals to look for and write the accidentally writable ordinal stage at which this machine halts, which proves that every halting stage is actually also writable. ∎

Corollary 4.32**.**

Let $\Gamma$ be an $n$-symbol suitable, looping stable and simulational operator. A set $a$ is in $L_{\lambda_{\Gamma}}$ (resp. in $L_{\zeta_{\Gamma}}$ and in $L_{\Sigma_{\Gamma}}$) if and only if it is writable (resp. eventually writable and accidentally writable) by a $\Gamma$-machine.

Proof.

The first implication is simply Proposition 4.12. We show the converse implication for accidentally writable real numbers, the two other cases are similar.

Suppose that the set $a$ is accidentally writable. That is a code for $a$, which we write $\hat{a}$, appears in the computation of some $\Gamma$-machine. As, by Theorem 4.14, $\Sigma_{\Gamma}=\mathrm{T}_{\Gamma}$, this codes appears in this computation before stage $\Sigma_{\Gamma}$ and so is itself (as a real) in $L_{\Sigma_{\Gamma}}$.

Then, as with the operator $\Gamma_{sup}$, $\zeta_{\Gamma}$ is an admissible ordinal and so $\Sigma_{\Gamma}$ is a limit of admissible ordinals–as otherwise the last admissible ordinal below $\Sigma_{\Gamma}$ would be eventually writable. So there is $\alpha$ admissible and smaller than $\Sigma_{\Gamma}$ such that $\hat{a}\in L_{\alpha}$. As a code for $a$, $\hat{a}$ describes a transitive relation $E$ on $\omega$ such that $(\omega,E)\simeq(TC(\left\{a\right\}),\in)$. The isomorphism described by it yields an application $f$ on $\omega$ inductively defined as, using $E$ in infix notation:

[TABLE]

As $L_{\alpha}$ is admissible, this function is definable in it by $\Sigma$-recursion and for some $i_{a}$, $f(i_{a})=a$. Also, for some $E$-least $i_{0}$, $i_{0}$, $f(i_{0})=\emptyset\in L_{\alpha}$. Hence, by external induction resting on the use of $\Sigma$-collection, for all $i$, $f(i)\in L_{\alpha}$. In particular, $a\in L_{\alpha}\subset L_{\Sigma_{\Gamma}}$, as wanted. ∎

Corollary 4.33** ($\lambda$-$\zeta$-$\Sigma$ theorem).**

Let $\Gamma$ be an $n$-symbol suitable, looping stable and simulational operator. Then the following chain of elementary end-extension holds.

[TABLE]

Proof.

This theorem was first established in [17] for the ITTM and, using Theorem 4.14, the proof is the same in the general case. We give one direction of the $\Sigma_{2}$ end-extension.

Suppose that some $\Sigma_{2}$ formula $\varphi(p)=\exists x\forall y\,\psi(x,y,p)$ is true in $L_{\zeta_{\Gamma}}$, for some $p\in L_{\zeta_{\Gamma}}$. Then, since $p\in L_{\zeta_{\Gamma}}$, by previous corollary, it is eventually writable. Using it, a $\Gamma$-machine can look for $\widetilde{x}$, a witness of $\varphi(p)$, and it can eventually write it as well. Then, using now this $\widetilde{x}$ (that is using the previous machine which eventually writes $x$), another machine can eventually write, if it exists, the first $y$ it finds such that $L_{\Sigma_{\Gamma}}\models\neg\psi(\widetilde{x},y,p)$. But such a $y$ can’t be found in $L_{\zeta_{\Gamma}}$, since $\varphi(p)$ is true in it. And it can’t be found in $L_{\Sigma_{\Gamma}}-L_{\zeta_{\Gamma}}$ either, since it would be eventually writable. So, in the end, $\varphi(p)$ is also true in $L_{\Sigma_{\Gamma}}$. ∎

Remark 4.34**.**

A question remains: for an operator $\Gamma$ that satisfies the condition of Theorem 4.14, is a $\Gamma$-machine that does not halt seen to be looping at stage $\Sigma_{\Gamma}$? In virtue of this theorem, we know that no new snapshot appears after stage $\Sigma_{\Gamma}$. It is however not yet enough to apply Corollary 3.42. As it stands, using this corollary, it can be shown that, for such an operator, $\Gamma$-machines will be seen to be looping before stage $\Sigma_{\Gamma}\cdot\omega^{\omega}$. Still, it may be possible to show that, in fact and as in the classical case, those machines are seen to be looping as soon as they reach stage $\Sigma_{\Gamma}$.

5 A counter-example without the looping condition

By Theorem 4.14, for an operator satisfying the looping condition (as well as being suitable and simulational and enhancing the $\limsup$ machine), we have $\Sigma_{\Gamma}=\mathrm{T}_{\Gamma}$. In this section, to show that the looping condition is a necessary condition, we construct a suitable and simulational operator that does not satisfy the looping condition and for which $\Sigma_{\Gamma}<\mathrm{T}_{\Gamma}$. The definition of this operator, the tick operator, is done in Definition 5.12 and is fairly straightforward. However, to prove that it indeed forms a counter-example, one convincing way to do it is to introduce another operator, the escaping operator whose behavior is easier to study and to show that both those operators behave in a similar way.

The intuition behind this counter-example, mentioned in Remark 3.40, is fairly simple as well: the machines ruled by the tick operator will be repeating for most of their computation and they will only exit those repetitions every tick, that is every $\tau$ steps for a very big $\tau$. After they exit their repetition, they compute a bit and “quickly” start to repeat again until the next tick. Hence with a well chosen $\tau$, we will be able to obtain great length of computation, that is greater than $\tau$, with only few different real numbers written in the computations, and so with small accidentally writable ordinals, that is smaller than $\tau$.

Theorem 5.1**.**

There exists a suitable and simulational operator $\Gamma$ that enhances the operator $\Gamma_{sup}$ and such that $\Sigma_{\Gamma}<\mathrm{T}_{\Gamma}$.

Before defining the escaping operator that will help us prove this result for the tick operator we need some preliminary results.

Definition 5.2**.**

For $n\in\omega$, the $n$-symbol $\limsup$ operator is the cell-by-cell operator $\Gamma_{\sup}^{n}$ defined by the single cell operator $\gamma_{\sup}^{n}$ itself defined as follows. For $h\in{}^{<On}n$,

[TABLE]

with the convention that if $h$ is not a limit word, its last letter is considered cofinal in it.

Proposition 5.3** (Looping condition for $\Gamma_{\sup}^{n}$-machine).**

A $\Gamma_{\sup}^{n}$-machine is looping if and only if there are two limit stages $\mu<\nu$ sharing the same snapshot and such that for each cell $i$, writing $s_{\nu}$ for the snapshot at stage $\nu$ and $s_{\nu}[i]$ for the value of cell $i$ in $s_{\nu}$:

[TABLE]

Proof.

The condition $\max_{\nu^{\prime}\in\left[\mu,\nu\right[}(C_{i}(\nu^{\prime}))=s_{\nu}[i]$ simply comes from the fact that once the segment of computation $[\mu,\nu[$ is repeating, the $\limsup$ of the value of some cell $i$ after it repeated some limit ordinal amount of time is equal to the maximum value of the cell $i$ in this segment of computation $[\mu,\nu[$. This ensures that the snapshot $s_{\nu}$ also appears after the segment $[\mu,\nu[$ has been repeated a limit ordinal amount of time. ∎

Proposition 5.4**.**

For $n\in\omega$, the $n$-symbol $\limsup$ operator $\Gamma_{\sup}^{n}$ is a suitable and simulational operator.

Proof.

This is the same proof as done for the usual $2$-symbol $\limsup$ operator. ∎

Proposition 5.5**.**

For $n>1$, the $n$-symbol $\limsup$ operator $\Gamma_{\sup}^{n}$ is as powerful as the usual $\limsup$ operator $\Gamma_{\sup}$. That is $\Sigma_{\Gamma_{\sup}^{n}}=\Sigma_{\Gamma_{\sup}}$ and $\mathrm{T}_{\Gamma_{\sup}^{n}}=\mathrm{T}_{\Gamma_{\sup}}$

Proof.

For $n>1$, $\Gamma_{\sup}^{n}$ enhances $\Gamma_{\sup}$, so we naturally have that $\Sigma_{\Gamma_{\sup}^{n}}\geqslant\Sigma_{\Gamma_{\sup}}$ and $\mathrm{T}_{\Gamma_{\sup}^{n}}\geqslant\mathrm{T}_{\Gamma_{\sup}}$. In the other direction, we show that a $\Gamma_{\sup}$-machine can simulate a $\Gamma_{\sup}^{n}$-machine.

For finite machines, an $n$-symbol machine can be easily simulated by a $2$-symbol machine by representing a cell of the $n$-symbol machine by $n-1$ cells of the $2$-symbol machines. We choose the following encoding: the $n$-symbol cell that reads $k\in n$ is represented by $n-1$ cells (namely, $2$-symbol cells) that read, once aggregated, $1^{k}0^{n-k-1}$. Observe that at a limit stage, those are equivalent:

• –

The $n$-symbol operator yields $k$ for cell $i$.

• –

$k$ is the greatest cofinal value of $i$ in the $n$-symbol cell up to this limit stage.

• –

$1^{k}0^{n-k-1}$ is the aggregated value of the $n-1$ $2$-symbol cell simulating $i$ with the longest $1$-prefix and which is cofinal in this limit stage.

• –

the $\limsup$ operator yields $1^{k}0^{n-k-1}$ for the cells simulating $i$.

Hence, at any limit stage, the $n$-symbol $\limsup$ operator is correctly simulated by the usual $2$-symbol $\limsup$ operator and with it the simulation is faithfully carried out through all the ordinals. ∎

Definition 5.6**.**

For $\Gamma$ an asymptotic operator and $H$ a limit segment of history, we say that $H$ is a looping pattern w.r.t. $\Gamma$ or a $\Gamma$-looping pattern when a machine with a history of the form $H_{0}H^{\omega}$ is looping and, more precisely, looping over the segment of history $H$.

In the previous definition, we ask $\Gamma$ to be asymptotic in order to ensure that different initial segments $H_{0}$ won’t lead to different behaviors after $H$ repeated $\omega$ times. So it is equivalent to ask that one machine with this history loops or to ask that any machine with this history loops.

Example 5.7**.**

Take $\Gamma^{n}_{\sup}$, the $n$-symbol $\limsup$ operator. Then, with Proposition 5.3 in mind, $H$ is a looping pattern w.r.t. $\Gamma^{n}_{\sup}$ if and only if for all cell $i$:

[TABLE]

Hence, if for some $\Gamma^{n}_{sup}$-machine the history reads at some point $H_{0}H^{\omega}$, we know that the machine is looping and that the segment of history $H$ will repeat indefinitely.

Definition 5.8** (the $3$-symbol escaping machine).**

The $3$-symbol escaping operator $\Gamma_{esc}$ is a $3$-symbol $\limsup$ operator with the only difference that its behavior changes after the machine has been repeating itself for some limit ordinal amount of times (or when such repeating stages are cofinal). It is called a "escaping" operator as this change of behavior can be seen as a Turing jump escaping the loop.

It can be defined using the $\limsup$ operators $\Gamma_{102}$ and $\Gamma_{210}$. Those are defined using cell-by-cell $\limsup$ operators $\gamma_{102}$ and $\gamma_{210}$. Both are usual $3$-symbol $\limsup$ operators working on the alphabet $3$ with the only difference being the order of priority of the letters in $3$. That is for a limit cell history $h\in{}^{<On}3$,

[TABLE]

and

[TABLE]

From there, $\Gamma_{esc}$ is defined as follow. For a limit history $H\in{}^{<On}({}^{\omega}3)$:

[TABLE]

Proposition 5.9**.**

The escaping operator $\Gamma_{esc}$ is a $\Delta_{4}$-suitable operator. It is moreover stable, asymptotical and contraction-proof but not cell-by-cell.

We give this proof of this first fact for the sake of completeness, but it is actually enough to be convinced that $\Gamma$ is a $\Sigma_{n}$-suitable operator for any $n$.

Proof.

As it is built from two $\limsup$ operators, the escaping operator is easily seen to be stable and contraction-proof. It is also asymptotical as when the history $H$ can be written $H=H_{0}(H_{1})^{\omega}$ (with $H_{0}$ possibly empty), any final segment of $H$ can be written in the same way (possibly with a different $H_{0}$). Same goes when $H$ is a limit of such terms. And it is not cell-by-cell as for a given cell $i$, the operator needs to consider the whole machine history $H$ rather than only the cell history $h_{i}$.

As for it being $\Delta_{4}$-suitable, the definition provides the skeleton that we can use to define a formula $\varphi_{esc}$ which suits Definition 3.21. The details rest on a recursive definition, as in the proof of Proposition 3.38. A detailed proof with the definition of $\varphi_{esc}$ can be found in [10, Proposition 5.5.9].

∎

Proposition 5.10**.**

A $\Gamma_{esc}$-machine is looping if and only if there are two limit stages $\mu<\nu$, both ruled by the operator $\Gamma_{210}$, that is both following the repetition of a $\Gamma_{102}$-looping pattern or a limit of thereof, sharing the same snapshot and such that writing $s_{\nu}$ for the snapshot at stage $\nu$ and writing $\max^{210}$ for the $\max$ operator with the order $2\succ 1\succ 0$, we have:

[TABLE]

In this case, the machine is seen to be looping at stage $\nu$.

Proof.

Suppose that a $\Gamma_{esc}$-machine is looping and let $H$ be the shortest repeating pattern and $\alpha$ be the stage at which it starts looping. Let $H_{0}$ be the history up to stage $\alpha$. Then the history reads: $H_{0}HHH\ldots$. In particular, when $H$ has repeated $\omega$ times, it reads $H_{0}H^{\omega}$. As it is looping, $\Gamma_{esc}(H_{0}H^{\omega})=H[0]$. Let $\mu$ be the stage below which the history $H_{0}H^{\omega}$ spans. We show that stage $\mu$ is ruled by the operator $\Gamma_{210}$, that is that $H^{\omega}$ is a $\Gamma_{102}$-looping pattern or limit of such looping patterns. Suppose that $H^{\omega}$ isn’t. Then it is easy to see that for any limit $\alpha$, $H^{\alpha}$ is neither a $\Gamma_{102}$-looping pattern nor a limit of looping patterns. Bu then it means that after this point, $\Gamma_{esc}$ always acts as the operator $\Gamma_{102}$. But then $H^{\omega}$ satisfies Proposition 5.3 and $H^{\omega}$ is a $\Gamma_{102}$-looping pattern, which contradict our first assumption. Hence, and by definition of the escaping operator, $\Gamma_{esc}(H_{0}H^{\omega})=\Gamma_{210}(H_{0}H^{\omega})$, i.e. the stage $\mu$ below which the history$H_{0}H^{\omega}$ spans is ruled by the $\Gamma_{210}$-operator. Then, let $\nu$ be the stage corresponding to the history $H_{0}H^{\omega}H^{\omega}$. So the segment of history delimited by $\mu$ and $\nu$ is $H^{\omega}$ itself. With the same reasoning, stage $\nu$ is also ruled by the $\Gamma_{210}$-operator and $\Gamma_{esc}(H_{0}H^{\omega}H^{\omega})=H[0]=\Gamma_{esc}(H_{0}H^{\omega})$, which means that the snapshot at stage $\mu$ and $\nu$ match. Eventually, the fact that the machine is repeating implies that $\Gamma_{esc}((H^{\omega})^{\omega})=H[0]$. But also $\Gamma_{esc}((H^{\omega})^{\omega})=\Gamma_{210}((H^{\omega})^{\omega})$ and this ensures that condition (3) on the repeating segment (here $H^{\omega}$), is satisfied as well.

Conversely, suppose that some $\mu$ and $\nu$ satisfying the hypothesis are given. Let $H_{0}$ be the segment of history that spans between stages [math] and $\mu$ and $H$ the segment that spans between stages $\mu$ and $\nu$. As the snapshots at stages $\mu$ and $\nu$ match and $\Gamma_{esc}$ is asymptotical, the history reads $H$ again after $H_{0}H$ appeared. And this goes on for at least $\omega$ repetitions of $H$. As $\nu$ is ruled by the operator $\Gamma_{210}$, so are all stages below which $H_{0}H^{k}$ spans for a natural number $k$. Hence, as a limit of stage limit of stages ruled by $\Gamma_{210}$, the stage below which spans $H_{0}H^{\omega}$ is also ruled by $\Gamma_{210}$. Hence $\Gamma_{esc}(H_{0}H^{\omega})=\Gamma_{210}(H_{0}H^{\omega})$. And $\Gamma_{210}(H_{0}H^{\omega})=\Gamma_{210}(H_{0}H)$ by hypothesis (3). And $\Gamma_{210}(H_{0}H)=\Gamma_{210}(H_{0})=H[0]$ by the fact that $\mu$ and $\nu$ share the same snapshot and are both ruled by $\Gamma_{210}$. Hence the stage corresponding to $H_{0}H^{\omega}$ also shares the same snapshot and is ruled by $\Gamma_{210}$. Further, carrying this reasoning on by transfinite induction, shows that the machine is looping.

∎

Proposition 5.11**.**

Let $m$ be a $\Gamma_{esc}$-machine that does not halt and let $(\alpha,\beta,\delta)$ the lexicographicaly least triple of additively closed ordinals such that $\alpha<\beta<\delta$ and

[TABLE]

Then $m$ is seen to be looping at the latest at stage $\delta\cdot\omega$.

Proof.

By the e.e.e. hypothesis, the snapshots at stage $\alpha$, $\beta$ and $\delta$ match. Hence, by asymptoticty, the segment of history $[\alpha,\beta[$ repeats $\omega$ times up to stage $\beta\cdot\omega$. If at stage $\beta$ the operator $\Gamma_{esc}$ acts as $\Gamma_{210}$ then it does so at any stage $\beta\cdot k$ and also at stage $\beta\cdot\omega$, as a limit of stages ruled by $\Gamma_{210}$. Else, suppose that at stage $\beta$ the operator $\Gamma_{esc}$ acts as $\Gamma_{102}$. In this case, we can show that $H_{\beta}$, the segment of history that spans between stages $\alpha$ and $\beta$ is a $\Gamma_{102}$-looping pattern, which contradicts this supposition. This comes from the fact that by elementarity, for any cell $i$, any symbol appearing in $i$ between stages $\alpha$ and $\beta$ also appears in $i$ cofinally in stage $\alpha$, and so that the value of cell $i$ at stages $\alpha$ and $\beta$ is at least greater (w.r.t. $\preceq_{210}$) that the maximum of the values appearing in cell $i$ between those stages. In definitive, $\beta\cdot\omega$ must be ruled by the operator $\Gamma_{210}$

We write $s_{\beta\cdot\omega}$ for the snapshot that appears at this stage. It may be different from $s_{\beta}$. However, $s_{\delta}=s_{\beta}$ and, again by asymptoticity, the segment of history $[\beta,\delta[$ starts repeating from stage $\delta$ and at least up to stage $\delta\cdot\omega$. This is depicted in Figure 8. With the same justification, stage $\delta\cdot\omega$ is ruled by the operator $\Gamma_{210}$.

We claim that stages $\beta\cdot\omega$ and $\delta\cdot\omega$ satisfy the looping condition of Proposition 5.10. First, as shown, at both those stages, operator $\Gamma_{esc}$ acts like $\Gamma_{210}$. Then, writing $H_{\delta}$ for the history that spans between stages $\beta$ and $\delta$, observe that $H_{\beta}\sqsubset H_{\delta}$. Hence, the repetition of $H_{\delta}$ encloses that of $H_{\beta}$. This implies that for any cell $i$:

[TABLE]

The inequality may be strict for some cell $i$ if and only if a symbol greater (w.r.t. $\preceq_{210}$) than $\Gamma(H_{\beta}\cdot\omega)[i]$ appears between stages $\beta\cdot\omega$ and $\delta$ in the cell $i$. We show that this is not possible. To do this, we show that:

[TABLE]

Suppose that this is not the case. This means that there is some symbol $s\in 3$ appearing in cell $i$ between stages $\beta\cdot\omega$ and $\delta$ and greater than any symbol appearing in $i$ between stages $\alpha$ and $\beta$. The second half of the affirmation translates to:

[TABLE]

But reflecting this affirmation up to $L_{\delta}$ contradicts the fact that $s$ appeared between stages $\beta\cdot\omega$ and $\delta$. This shows that stages $\beta\cdot\omega$ and $\delta\cdot\omega$ share the same snapshot and moreover that the condition (3) of Proposition 5.10 holds, which ends the proof.

∎

We now define the $\tau$-ticking operator which will be, in definitive, the operator that interests us to prove Theorem 5.1. However, the operator $\Gamma_{esc}$ will help us define the right $\tau$-tick operator (which depends of an ordinal $\tau$) as well as help us study its behavior. It is worth noting that the idea behind the ticking operator is similar to Habic’s cardinal recognizing ITTMs, which we mentioned earlier as a model that does not satisfy the condition of looping stability.

Definition 5.12** (the $3$-symbol tick machine).**

For $\tau$ a limit ordinal, the $\tau$-ticking operator $\Gamma_{\tau}$ is a $3$-symbol $\limsup$ operator with the only particularity that its behavior is altered at limit stages that are multiple of $\tau$. It is called a "ticking" operator as this change of behavior can be seen as a regular tick. $\Gamma_{\tau}$-machines will naturally be able to harvest this tick and, at least, to know when their current stage is a multiple of $\tau$.

$\Gamma_{\tau}$ can be defined as a cell-by-cell operator $\gamma_{\tau}$ defined using $\gamma_{102}$ and $\gamma_{210}$; themselves defined as in Definition 5.8. For a limit history $h\in{}^{<On}3$:

[TABLE]

That is before stage $\tau$ and more generally at any stage that is not a multiple of $\tau$, a $\Gamma_{\tau}$-machine behaves like a $\Gamma_{\sup}^{3}$ machine with the order $1\succ 0\succ 2$ on its alphabet. And at stages $\tau\cdot\alpha$, a $\Gamma_{\tau}$-machine behaves like a $\Gamma_{\sup}^{3}$ machine with the order $2\succ 1\succ 0$ on its alphabet.

Definition 5.13** (uniformly characterizable ordinals).**

An ordinal $\alpha$ is uniformly characterizable with respect to the constructible hierarchy if there is a sentence $\psi_{\alpha}$ such that for all real number $y$:

[TABLE]

It is $\Sigma_{n}$-uniformly characterizable when $\psi_{\alpha}$ is $\Sigma_{n}$.

Proposition 5.14**.**

There exists an additively closed $\Pi_{2}$-uniformly characterizable ordinal $\chi$ strictly greater than $\Sigma_{esc}$ and $\mathrm{T}_{esc}$, which are respectively the supremum of the ordinals accidentally written by a $\Gamma_{esc}$-machine and the supremum of the ordinals a.c. by a $\Gamma_{esc}$-machine.

Proof.

As $\Gamma_{esc}$ is not cell-by-cell, it is not simulational and we can’t apply Proposition 4.8. However, we know that every accidentally writable real number is accidentally writable before stage $\mathrm{T}_{esc}$ and that $\mathrm{T}_{esc}<\delta$ with $\delta$ defined in Proposition 5.11. So, for any $\Gamma_{esc}$-a.w. ordinal $\alpha$, a code for $\alpha$ is in $L_{\delta}$ and $\alpha$ is in $L_{\delta^{+}}$ where $\delta^{+}$ is the least admissible ordinal greater than $\delta$. Hence, we also know that $\Sigma_{esc}\leqslant\delta^{+}$.

Now let $\chi$ be the least ordinal that witnesses the existence of $\alpha$, $\beta$, $\delta$ and $\delta^{+}$ such that the following is true in $L_{\chi}$:

[TABLE]

This description yields a uniform (as it only quantifies over ordinals or set of the form $L_{\alpha}$) characterization of $\chi$ strictly greater than $\Sigma_{esc}$ and $\mathrm{T}_{esc}$. (And note that because of Induction, $\mathrm{KP}$ is not finitely axiomatizable but this is not an issue when dealing with structures that already satisfy Foundation.) ∎

Proposition 5.15**.**

Given a $\Sigma_{n}$-uniformly characterizable ordinal $\alpha$, there exists a $\Sigma_{m}$ sentence $M_{\alpha}$ with $m=\max(n,3)$ and such that for all ordinal $\nu$:

[TABLE]

Proof.

Let $\psi_{\alpha}$ as defined in Definition 5.13 and consider the following formula.

[TABLE]

Then $L_{\nu}\models M_{\alpha}$ if and only if: either $\nu=\alpha$, in which case $L_{\nu}\models\psi_{\alpha}$ and $\nu$ is the least such, or $\nu>\alpha$ and for all $\alpha\cdot\mu<\nu$, we also have $\alpha\cdot\mu+\delta<\nu$ for any $\delta<\alpha$. Which is equivalent to saying that $\nu$ is a multiple of $\alpha$. Having in mind that, given $\beta$, the predicate $L_{\beta}\models\psi_{\alpha}$ is $\Sigma_{1}$, it is clear that $M_{\alpha}$ is $\Sigma_{m}$ with $m=\max(n,3)$. ∎

Proposition 5.16**.**

For $\tau$ an additively closed and $\Sigma_{3}$-characterizable limit ordinal, the $\tau$-tick operator $\Gamma^{\tau}_{tick}$ is a $\Delta_{4}$-suitable and simulational operator. If $\tau$ is greater than $\Sigma_{\sup}$ this operator does not satisfy the looping stability condition.

Proof.

As it is built from two $\limsup$ operators, the $\tau$-tick operator is easily seen to be stable, cell-by-cell and contraction-proof for any limit ordinal $\tau$. It is only asymptotical when $\tau$ is additively closed as otherwise, taking a final segment of an history could displace the position of the next tick, that is of the next stage multiple of $\tau$.

Then, observe that it is easy for a machine to detect the "ticking" stages (i.e. stages multiple of $\tau$): it can simply have a cell whose value regularly alternates between $1$ and $2$ and it will read $2$ at a limit stage if and only if this stage is a ticking stage. From there, if $\tau>\Sigma_{\sup}$, we can design a machine that waits for stage $\tau$ to exit a repetition that repeated for more than $\omega$ times, which falsifies the looping stability condition.

As for it being $\Delta_{4}$-suitable, the definition again provides the skeleton to define a formula and Proposition 5.15 ensures that with can distinguish with a formula of bounded complexity whether the limit stage is a multiple of $\nu$. For a complete proof, the reader is referred to [10, Proposition 5.5.16].

∎

Proof of Theorem 5.1.

We claim that for a great enough $\tau$, any $\tau$-tick machine will behave like the escaping machine having the same code with the only difference that it will be considerably “slower” as it will often be repeating for considerable amount of time (namely $\tau$ steps) before exiting the repetition and acting again like its escaping counterpart. Hence, it will still produce the same accidentally writable ordinals. More precisely, for $\tau=\chi$, the admissible characterizable ordinal defined in Proposition 5.14 such that both $\tau>\Sigma_{esc}$ and $\tau>\mathrm{T}_{esc}$, we will show that we have $\mathrm{T}_{\tau}>\tau$ and $\Sigma_{esc}=\Sigma_{\tau}$. This implies that:

[TABLE]

which proves the theorem. We now need to show that both $\Sigma_{esc}=\Sigma_{\tau}$ and $\mathrm{T}_{\tau}>\tau$ hold. Observe that the second equality is immediate as $\tau$ is clearly clockable by a $\tau$-tick machine. For the first one, we make the following claim.

Claim 5.16.1**.**

Let $m$ be a machine code, $m_{esc}$ the $\Gamma_{esc}$-machine with the code $m$ and ruled by the escaping operator and $m_{\tau}$ the $\Gamma_{\tau}$-machine with the code $m$ and ruled by the the $\tau$-tick operator. We write $(\alpha_{\nu})$ for the limit stages of $m_{esc}$ that are ruled by $\Gamma_{210}$ (that is stages where some looping pattern $H_{1}$ has been repeating for $\omega$ limit times, or limit of those) and $(\beta_{\nu})$ the limit stages of $m_{\tau}$ that also are ruled by $\Gamma_{210}$ (that is stages multiple of $\tau$). Then, we claim that:

• •

For any ordinal $\nu$, the snapshots at stage $\alpha_{\nu}$ in $m_{esc}$ and $\beta_{\nu}$ in $m_{\tau}$ match.

• •

For any ordinal $\nu$, we can write $H_{0}\cdot H_{1}^{\omega}$ for the history of $m_{esc}$ up to stage $\alpha_{\nu+1}$ and the history of $m_{\tau}$ up to stage $\beta_{\nu+1}$ reads $H_{0}\cdot H_{1}^{\tau}$.

Proof.

We show this by induction. Consider stages $\alpha_{0}$ and $\beta_{0}$. By definition, before those stages, respectively in machines $m_{esc}$ and $m_{\tau}$, the limit operators behaved simply as $\Gamma_{102}$. Hence, both those machines started repeating at the latest from stage $\Sigma_{\sup}$ onward. That is, the history of $m_{esc}$ below $\alpha_{0}$ reads $H_{0}H_{1}^{\omega}$ where $H_{1}$ is some history of the machine below $\Sigma_{\sup}$ and at most the history between stages $\zeta_{\sup}$ and $\Sigma_{\sup}$ while the history of $m_{\tau}$ below $\beta_{0}$ reads (by closedness of $\tau$ and as $\tau>\Sigma_{\sup}$) $H_{0}H_{1}^{\tau}$. Hence, as stages $\alpha_{0}$ and $\beta_{0}$ are both ruled by the operator $\Gamma_{210}$ and as this operator is asymptotic and satisfies the looping stability, both stages share the same snapshot.

Then, we consider successor stages $\alpha_{\nu+1}$ and $\beta_{\nu+1}$ for some successor ordinal $\nu+1$. By induction hypothesis, $\alpha_{\nu}$ and $\beta_{\nu}$ share the same snapshot. By asymptoticity, the computation of both machines match while they are both ruled by the operator $\Gamma_{102}$, that is, respectively, until stages $\alpha_{\nu+1}$ and $\beta_{\nu+1}$. And, for the first time after stage $\alpha_{\nu}$, the machine $m_{esc}$ produces an history of the form $H_{0}H_{1}^{\omega}$ for $H_{1}$ a looping pattern at stage $\alpha_{\nu+1}$. Hence the history below stage $\alpha_{\nu+1}$ can be written $H_{0}H_{1}^{\omega}$. As $\tau>\mathrm{T}_{esc}$, $\tau$ is also greater than the length of the history $H_{0}\cdot H_{1}^{\omega}$ and the machine $m_{\tau}$ is repeating $H_{1}$ up to stage $\beta_{\nu+1}$, the history before this stage reads $H_{0}\cdot H_{1}^{\tau}$. Again, by the $\limsup$ definition of operator $\Gamma_{210}$, this implies that $m_{esc}$ and $m_{\tau}$ share the same snapshot at respectively stages $\alpha_{\nu+1}$ and $\beta_{\nu+1}$.

Eventually, for some limit $\nu$: Consider the sequence $(\alpha_{\nu^{\prime}})_{\nu^{\prime}<\nu}$ and the ordinal $\bigcup_{\nu^{\prime}<\nu}\alpha_{\nu^{\prime}}$. First, as the escaping operator also acts like the $\Gamma_{210}$ operator at stages that are limit of repeating histories (i.e. limit of histories of the form $H_{0}\cdot H_{1}^{\alpha}$), we have:

[TABLE]

On the other hand, this naturally holds for $\beta_{\nu}$, as a limit of multiple of $\tau$:

[TABLE]

Moreover, by induction hypothesis, we can control the history before stages $\alpha_{\nu}$ and $\beta_{\nu}$. Namely, the history before stage $\beta_{\nu}$ is the same as that before $\alpha_{\nu}$ with the only difference that between some stages $\beta_{\nu^{\prime}}$ and $\beta_{\nu^{\prime}+1}$, it reads $H^{\nu^{\prime}}_{0}\cdot(H^{\nu^{\prime}}_{1})^{\tau}$ instead of $H^{\nu^{\prime}}_{0}\cdot(H^{\nu^{\prime}}_{1})^{\omega}$ for some specific $H^{\nu^{\prime}}_{0}$ and $H^{\nu^{\prime}}_{1}$. Hence, by the definition of the $\limsup$ rule, stages $\alpha_{\nu}$ and $\beta_{\nu}$ share the same snapshot and this proves the claim. ∎

Finally, from the previous claim, it is clear that the machines $m_{esc}$ and $m_{\tau}$ sharing the same machine code accidentally write the same ordinals. And with it, more generally, that as wanted $\Sigma_{esc}=\Sigma_{\tau}$; which ends the proof. ∎

6 Conclusion

Simply put, the aim of this paper was to try and answer the following question: “Why did we choose the $\limsup$ rule for the definition of the ITTM and not another rule? And what makes the ITTM with this limit rule work so well?” Clearly this question, as is, does not have a satisfying answer. This is surely why it is bugging and, at the same time, a great kick start for an inquiry. So we started by investigating into some compelling results of the ITTM. What came into light, as presented in Section 2, is the key role of the universal ITTM in the study of the model of Hamkins and Lewis. Then, in the same section, upon looking more closely at the universal ITTM and at its construction, we saw how said construction is actually grounded on a set of four implicit properties, which the $\limsup$ rule satisfies. And what makes this observation potent is that, once formalized, those four properties actually are sufficient for a limit rule to yield a model of infinite Turing machine in which a universal machine exists. So working backward from there, we defined the concept of simulational operator, which is a limit operator (that is the (class) function behind a limit rule) which satisfies this set of four properties. Those operators, as said, yield a model of infinite Turing machine for which there exists a universal machine.

Then, unstacking further, our aim was to establish for this class of operators (i.e. for the models of machine they yield) the same high-level results as were established for the classical ITTM. However, the concept of simulational operator alone falls a bit short of this goal. But when we add another constraint, which we called looping stability, we take a more than significant step in this direction. First, as shown in Proposition 4.6, the operators from this new class (that is, the simulational and looping stable operators) can emulate the computation of a classical ITTM. But further, among other similarities, they can be said to be as “well-behaved”, and that in virtue of the main theorem, Theorem 4.14, which states that for such an operator $\Gamma$ definable in set theory, $\Sigma_{\Gamma}$ equals $\mathrm{T}_{\Gamma}$. This equality, which holds for the classical ITTM, is one of the most compelling results in the study of ITTMs and it draws fruitful links between it and the fine structure theory. Finally, in Section 5, we prove that the constraint of looping stability is indeed needed, in the sense that there exists a simulational operator definable in set theory for which the previous equality does not hold.

Another significant result is the $\lambda$-$\zeta$-$\Sigma$ theorem of [17]. As done in Corollary 4.33 It can be established in the setting of simulational and looping stable operators using Theorem 4.14. However, this theorem deals with operators definable in set theory with formulas of any complexity. That is, while the $\limsup$ operator is defined by a $\Sigma_{2}$ formula, other operators may be defined by higher-order formulas. And a question is whether, for those operators, we can establish a higher-order equivalent of the $\lambda$-$\zeta$-$\Sigma$ theorem. This was partially answered in the Chapter 6 of the thesis of Johan Girardot. In this chapter, a higher-order operator is designed. It satisfies the constraints which we established here and, for the model of infinite machine it yields, we can generalize the $\lambda$-$\zeta$-$\Sigma$ theorem up to a $\Sigma_{3}$ elementary end-extension.