
TL;DR
This paper investigates the computational power of resetting α-register machines, linking their capabilities to the structure of constructible universes and extending classical results in transfinite computability.
Contribution
It strengthens previous results by characterizing the computable subsets of α in terms of levels of the constructible hierarchy for exponentially closed ordinals.
Findings
For exponentially closed α, the computable subsets match those in L_{α+1}.
If L_{α} does not satisfy ZF^-, then the computable subsets are in L_{β(α)}.
Characterizes the bounds of clockable and computable ordinals for α-ITRM.
Abstract
We study the computational strength of resetting -register machines, a model of transfinite computability introduced by P. Koepke in \cite{K1}. Specifically, we prove the following strengthening of a result from \cite{C}: For an exponentially closed ordinal , we have ZF if and only if COMP, i.e. if and only if the set of -ITRM-computable subsets of coincides with the set of subsets of in . Moreover, we show that, if is exponentially closed and ZF, then COMP, where is the supremum of the -ITRM-clockable ordinals, which coincides with the supremum of the -ITRM-computable ordinals. We also determine the set of…
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Taming Koepke’s Zoo II: Register Machines
Merlin Carl
Institut für mathematische, naturwissenschaftliche und technische Bildung, Abteilung für Matheamtik und ihre Didaktik, Europa-Universität Flensburg
Abstract
We study the computational strength of resetting -register machines, a model of transfinite computability introduced by P. Koepke in [K1]. Specifically, we prove the following strengthening of a result from [C]: For an exponentially closed ordinal , we have ZF*-* if and only if COMP, i.e. if and only if the set of -ITRM-computable subsets of coincides with the set of subsets of in . Moreover, we show that, if is exponentially closed and ZF*-*, then COMP, where is the supremum of the -ITRM-clockable ordinals, which coincides with the supremum of the -ITRM-computable ordinals. We also determine the set of subsets of computable by an -ITRM with time bounded below when is an exponentially closed ordinal smaller than the supremum of the -ITRM-clockable ordinals.
1 Introduction
In [KM], Koepke and Miller introduced Infinite Time Register Machines (ITRMs) as a generalization of register machines to ordinal time, thus complementing the Infinite Time Turing Machines introduced in Hamkins and Lewis [HL]. An ITRM has finitely many registers, each of which can store a single natural number. Later on, Koepke also introduced Ordinal Turing Machines (ORMs) (see e.g. [ORM]), in which every register can contain an arbitrary ordinal. In [K1], he further mentions the possibility of defining register machines in which the register contents are bounded by an ordinal while the computation time is bounded by a possibly different ordinal , so-called -ITRMs. The computational objects for ITRMs were determined in [K1] to be those subsets of contained in , and for ORMs, it was shown in [ORM] that they can compute exactly the constructible sets of ordinals. Moreover, by arguments analogous to those given in Koepke and Seyfferth [KS] for tape models, one can see that for exponentially closed , an -ITRM computes exactly those subsets of that are -recursive, i.e. over .
We recall the definitions of -(w)ITRMs from [KM] and [K] very briefly. In the original definition of Koepke, programs for -(w)ITRMs are simply register machine programs as e.g. described in Cutland [Cu]. An -(w)ITRM has finitely many registers, each of which can store a single ordinal . Whe is a program that uses the register with indices , then a -computation is a sequence of -configuration, i.e., elements of , where denotes the active program line ad is the content of the -th register, for . These machines operate along an ordinal time axis. At successor stages, the register machine commands are carried out as usual. At limit stages, the active program line and the register contents are obtained as the inferior limits of the sequences of earlier program lines or the earlier contents of the register in question, respectively. If that limit is , an -wITRM-computation is undefined (it “crashes”), while in an -ITRM-computation, the content of such a register is simply reset to [math]. Of course, we can specify an initial configuration from which the machine will start; we write for the computation of the program starting in the initial configuration . When we work with a single ordinal as an input, we write and understand that is initially written to the first register, while all other registers contain [math]. When we do not specify an input configuration, it is meant that we start in the situation where all registers contain [math]. When we talk about “outputs” of a computation, we refer to the configuration in the halting state; often (when, e.g., talking about the computability of functions from the ordinals to the ordinals), it is only the content of the first register we care about, in which case we say that halts with output . For this paper, we modify the definition of a program slightly for the sake of a smoother development: Instead of only allowing jump conditions of the form , i.e. stating that the content of one register is equal to the content of another register, we allow arbitrary Boolean combinations of such statements as jumping conditions. This has the convenient effect that one can store a certain configuration of a program (i.e. the register contents and active program line) in some extra registers and then recognize in a single step whether or not is currently in this configuration. Clearly, this leaves the computational power of these machines untouched; one nice effect of this modification is that the proof of the speedup-theorem for -(w)ITRMs (see Lemma 33 below) avoids a lot of the trickery used in [CFKMNW] in the case of (-)ITRMs.
In this work, we investigate the computational strength of -ITRMs in the case that has sufficient closure properties. The lesson here is that, if has strong closure properties, then the computational strength of -(w)ITRMs goes little beyond . The results on -ITRMs in this paper are refinement of results that appeared in [C]; there, it was proved that, if is regular in , then COMP. Here, we exploit the proof to obtain the same result under a considerably weaker condition, thus obtaining an equivalence.
Although we will mostly be concerned with -ITRMs below, we point out the following result on the unresetting case, which is contained in [C] and will be improved below (Theorem 39):
Theorem 1**.**
If is -admissible, then COMP.
2 -ITRMs and ZFC*-*
For the definition of -ITRMs, we refer to [K1] or our sketch above. A set is -ITRM-decidable or -ITRM-computable if and only if there are an -ITRM-program and a parameter such that, for all , we have if and only if and otherwise, . We denote the set of ITRM-computable sets by COMP.
In [C], we showed that, if is an uncountable regular cardinal, then COMP. Here, we will explore the matter further to reach a much stronger result.
We will occasionally write liminf or min where is a set of tuples of ordinals of fixed finite length to denote the tuple consisting of the component-wise inferior limits, minima etc., i.e. and , respectively.
When talking about -ITRM-computations in this paper, we always mean that parameters are allowed, even though we will not mention it. Throughout the paper, will denote Cantor’s ordinal pairing function. If is an -structure and is surjective, we will call an -code for . When is clear from the context, the prefix will occasionally be dropped.
For this section, let be an exponentially closed ordinal.
We will be working with ZF*-, which is ZFC without choice and the power set axiom; to be more precise, we use the formulation of ZF-* established in [GJH] as the most natural one.
Our goal is to show the following result:
Theorem 2**.**
If is exponentially closed, then if and only if COMP.
Let us say that is a ZF*--ordinal if and only if . We will frequently and freely use the following folklore characterization of ZF-*-ordinals, the proof of which we recall for the convenience of the less set-theoretically minded reader:
Lemma 3**.**
is a ZF*-*-ordinal if and only if is regular in .
Proof.
Suppose that is singular in ; pick , such that and maps cofinally into . Towards a contradiction, assume that ZF*-*. By assumption, is definable over ; let be a formula, finite such that holds if and only if . Then is a functional class in and thus, by replacement in , is an element of . But then, by the axiom of union in , we also have , a contradiction.
Now assume that is regular in . The only axioms to check are comprehension and collection (all other axioms of ZF*-* hold in all limit levels of the -hierarchy that contain ). As comprehension is a consequence of collection, it suffices to deal with the latter. So let be a formula and such that . We need to show that there is such that . Let be minimal such that . Then (as is a limit ordinal) and moreover, by standard finestructure, there is a bijection in and thus also a surjection . Now, the function mapping each to the minimal such that contains some with is clearly definable over and thus contained in . By regularity of in , the image of must be bounded in , say be . Then is as desired. ∎
We now show the direction from left to right.
Proposition 4**.**
Let be an increasing sequence of ordinals, where is a limit ordinal, and let . Let be another sequence of ordinals (by definition, is a limit ordinal). Moreover, let for .
Then .
Proof.
We first show that .
Suppose for a contradiction that . Thus, for some , we have for all . But then, the same holds for as soon as , contradicting the definition of .
Now we show that .
Suppose for a contradiction that .
Thus, there is such that, for all , we have . But then, we have for all sufficiently large , contradicting the definition of . ∎
The next lemma is a strenghthening of a lemma that was proved in joint discussion with Philipp Schlicht and originally published in [C], namely that the definability of over holds when is an uncountable regular cardinal.
Lemma 5**.**
Let , let be an -ITRM-program using many registers, and let be an ordinal. Denote by the function that maps a -configuration to the -configuration arising by running for many steps with initial configuration .
Moreover, let be the function that maps a -configuration to the tuple , where is the minimal program line index in any -configuration occuring when one runs on for many steps; and similarly, are the minimal contents of the registers used by during this computation.
Finally, for , , let be the function that maps a -configuration to the binary sequence , where if and only if, for some configuration occuring during the -computation of length starting with , the th component of coincides with the th component of , and otherwise, .
Then , and are definable over , and in fact by -formulas for (and thus in particular contained in ).
Proof.
We will prove the definability of and by a simultaneous induction on ; the definability of will then be an easy consequence of this proof.
Let , and let .
As is a limit ordinal, any partial computation of of length for any starting configuration will be contained in .
Then, simply by expressing the liminf-rule, is definable over as follows:
if and only if all of the following hold:
For all , there is a -computation of length starting with with active program line in the final configuration. This is expressable by a -formula. 2. 2.
There is such that, for all , and all -computations of length starting with , the final configuration will have an active program line with index . This condition is expressable by a -formula. 3. 3.
For all (), there is such that, for all , all -computations of length starting with have an ordinal in their th register in their final configuration. This condition is expressable by a -formula. 4. 4.
For all , there is such that there is a -computation of length starting with such that, at time , the th register contains an ordinal for all . This condition is expressable by a -formula.
Thus, is -definable over .
Moreover, holds if and only if the following conditions hold:
There are and -computations starting with of length respectively, such that has active program line , has content in its first register, …, has content in its th register in its final configuration. This is expressable by a -formula. 2. 2.
For all and all -computations of length starting with , in the final configuration we have that the active program line index is and the content of the th register is , for all . This is expressable by a -formula.
Thus, is definable over by the conjunction of a -formula and a -formula.
Now assume that and have -definitions over . We show that and have -definitions over .
For a arbitrary -configuration and , let us define (the sequence of every th configuration in the -computation starting with up to time ) and (the sequence of component-wise minima of configurations occuring in the -computation starting with between times and up to time ) by a simultaneous recursion as follows:
- •
- •
- •
for a limit ordinal.
- •
- •
- •
for a limit ordinal.
By recursion (and the inductive assumption about the definability of and over ) in , we have and for all .
Now, we can define and over as follows:
For , we have by Proposition 4. It is not hard to see, using the inductive assumption, that this is over , as desired.
On the other hand, we have that : Clearly, the minimal value that the th component assumes until time is equal to the minimum of the minimal th components occuring in each subinterval of the form .)
In total, and are over , as desired.
Finally, we turn to .
For , we have if and only if, for any such that , there is such that, after running on for many steps, the th component of the last configuration is equal to the th component of and for any with , this is false.
The former condition is over , the latter is , so the whole definition is .
Now suppose that is defined. By recursion in , define, for all and all :
- •
- •
- •
for a limit ordinal.
The let (where the maximum is also to be taken in each component separately).
Clearly, this is definable over , as desired.
∎
Lemma 6**.**
Suppose that . If is computable by an -ITRM in time for some , then .
Proof.
Suppose that is decidable by an -ITRM-program and that, for each , halts in many steps, where .
Now, for all , we have if and only if in many steps if and only if, at time , the first register contains in the -computation starting in configuration 111After a halting configuration has been reached, the computation continues by repeating this configuration without changes. if and only if has in its second component. By Lemma 5, the last condition is over .
In particular, it follows that . ∎
The proof actually shows more:
Corollary 7**.**
If is -ITRM-decidable with time bound , then is over .
Moreover, if is -admissible, then any that is computable by an -ITRM with time bound is an element of .
Without any assumption on , we still obtain that, if is -ITRM-decidable with time bound , then .
Proof.
The first two claims are clear. For the third, note that, inductively, and will be contained in , so that and are definable over and thus contained in , so that now any that is -ITRM-computable with time bound is contained in . Thus, an induction on proves the desired result. ∎
Lemma 8**.**
[Koepke and Seyffert, see [KS]] Let be exponentially closed. Then is -ITRM-computable in many steps if and only if is over .
In particular, there is an -ITRM-computable code for in which each ordinal is coded by .
Moreover, the truth predicate for bounded formulas in with parameters is -ITRM-decidable.
Proof.
For the first and last claim, see Koepke and Seyfferth [KS].222Strictly speaking, [KS] proves this for -ITTMs, but the adaptation to -ITRMs is straightforward, see [C], Theorem 3.3.3. For the second claim, it is easy to see that such a code is over . ∎
Lemma 9**.**
Let be exponentially closed, . Then is -ITRM-computable.
Proof.
By Lemma 8, a subset coding is -ITRM-computable as it is easy to see that there is such a code which is over : More precisely, associate with every a triple , which is meant to represent . (In particular then, is represented by , where is an index for the formula “ is an ordinal”. Now define a code by saying that if and only if there are , in such that codes , codes and if and only if we have for all such , . This definition is clearly over .
Now suppose that is given as
[TABLE]
where is a finite sequence in . We show by induction on the complexity of that is -ITRM-decidable.
Suppose that is written in the form , where is quantifier-free.
To evaluate , one only needs to use the algorithm for evaluating the bounded truth predicate from Lemma 9.
Then, for each quantifier alternation, we perform an exhaustive search through . For quantifier alternations, extra registers are used for the nested searches.
More specifically, if decides for some formula , then is decided by running through in a new register and using on each content of that register to decide whether holds. If this terminates (i.e., if the new register contains [math], due to an overflow) without ever having returned the output , then is false, otherwise, it is true.
The set is just the relative complement of the set in and can thus be decided similarly. ∎
We now work towards a bound on the halting times on -ITRM-programs when is a ZF*-*-ordinal. Our approach is an adaptation of the proof by Koepke in [K1] that the halting times of -ITRMs are bounded by and strengthens our result from [C] that the halting times of -ITRMs are bounded by when is an uncountable regular cardinal.
The following lemma generalizes the looping criterion for ITRMs from [KM].
Lemma 10**.**
Let be an -ITRM-program. Suppose that, during the computation of , there are times such that the configurations at time and are equal and such that any configuration arising in between is in every component the configuration at time . Then is looping, repeating its behaviour between times and and in particular never halts.
Proof.
Let be such that . By the liminf-rule, the configuration at time reappears at any time of the form . ∎
Definition 11**.**
In the situation of Lemma 10, we say that witnesses the looping of .
A new phenomenon occuring for -ITRMs with , but not for ITRMs is the possibility that a register content occurs at a limit time without ever having been contained in that register before; for example, if one counts upwards in a register, starting with [math], then at time , this register will contain for the first time. This kind of limits complicates the control over the register contents that we need to ensure looping. Fortunately, for reasonable closed , we can show that it cannot occur at time .
Definition 12**.**
Let be an -(w)ITRM-program, , and a limit ordinal. We say that is a proper limit of at time if and only if some register contains at time in the computation of in the input , but that register had contents cofinally often before time .
Lemma 13**.**
Let be a ZF*-*-ordinal, let be an -ITRM-program, , and let be a register used by and let be its content at time . Then there is such that all contents of after time were and moreover, was cofinally often the content of before time .
Proof.
By the liminf rule, the second claim follows from the first. It thus suffices to show the first claim.
Suppose for a contradiction that the first claim fails. Note that, as a register content of an -ITRM, we have . Now we have that, for any , there is a minimal ordinal such that, from time on, all contents of were (but cofinally often, it was ). Consider the function , which maps cofinally into .
We claim that this function is definable over , hence contained in , contradicting the assumption that is regular in . To this end, we recall from the proof of Lemma 5 that is definable over for every .
Now holds if and only if, for all , we have that has an ordinal in its st component.
Clearly, this is expressable by some -formula over since is so expressable uniformly in , and (where is the initial configuration). Hence, the minimal such ordinal is also definable over and thus, so is the function . ∎
Theorem 14**.**
Let be a ZF*-*-ordinal. Then an -ITRM-program using registers halts in many steps or not at all.
Proof.
We follow the argument by Koepke from [K1].
We actually show that, if an -ITRM-computation with ZF*-* reaches time , then at least registers must contain [math] or there are witnessing the looping of . Since there cannot be more registers containing [math] than there are registers in total, this proves the claim.
By Lemma 13, we know that, if an -ITRM-computations reaches time for some , then there is (namely, the maximum of the values guaranteed to exist by that lemma for each of the finitely many registers) such that, from time on up to time , no register content dropped below its value at time (this holds trivially when that content is [math]). By increasing if necessary, we can assume without loss of generality that the same holds for the active program line. Let be the configuration of at time .
Now let and pick as just described. We build an increasing sequence of ordinals such that and, for all , is minimal such that the mod th component of the configuration at time agrees with that of . (Such a sequence exists since, by assumption, none of the register contents at time is due to an overflow.) Clearly, this sequence is definable over as a map from into and is thus not cofinal.
Let . Then and the -configurations at time is equal to by the liminf-rule.
But then, witnesses the looping of and thus, does not halt.333This argument actually shows that the halting times of -wITRMs are bounded by when is -admissible. See [C] and the remark in the introduction.
Let us now assume that the theorem holds for . Suppose the computation arrives at time and less than many registers contain [math] at that time. Again, pick as in the first case.
Suppose first that there is no register overflow at time .
Once more, we want to build the sequence as for . However, as it stands, this would be a sequence of ordinals and it would be defined over , not over , which would not help much to see that it is bounded.
We thus modify the definition a bit: will be the minimal such that . After that, will be the minimal ordinal such that and the mod st component will at some time between and agree with the corresponding component of .
This is again a sequence of elements of and, by Lemma 5, it is definable over and thus bounded in .
With , we thus have , hence and, by the liminf-rule, the configuration at time will be . Consequently, the looping criterion for is once again satisfied, and does not halt.
Thus, if there is no register overflow at time , then does not halt.
Now suppose that there is a register overflow at time . Pick one register of , say , that overflows at time . Thus, we can now chose the above additionally in such a way that, after time and up to time , never contains [math].
Consider the configuration at time , which we can regard as arising by running for many steps on the configuration it had at time .
In , no register contains [math] that does not contain [math] at time by assumption on , and by the same reason, does not contains [math]. Thus, at time , at most registers contain [math]. As we can regard this as step in a -computation starting in the configuration at time , it follows again that is looping.
Both cases are finished. Thus, if does not have at least many [math]s in its registers by time , it does not halt.
In particular, this holds if uses many registers. ∎
By exploiting the proof a bit further, we obtain the following refinement:
Corollary 15**.**
For any , there is with the following property: If -collection, then an -ITRM-program using many registers halts or loops in many steps. In fact, there is a natural constant such that for all .
Corollary 16**.**
An -ITRM-program with ZF*-* halts in many steps or does not halt at all.
Proof.
uses some natural number of registers. Thus, if it halts, it halts before time . ∎
Corollary 17**.**
If ZF*-*, then is the supremum of the -ITRM-halting times.
Proof.
That is an upper bound was just proved. On the other hand, it is easy to see that, for any , there is an -ITRM-program that halts at time :
To halt at time , just count upwards in some register, starting with and halt once that register overflows (i.e., contains [math]).
Now, if halts at time , take a program as above, but before incrementing its register, run once each time. Clearly, this halts at time . ∎
We are ready to prove the first direction of our main result.
Theorem 18**.**
Suppose that is a ZF*-*-ordinal. Then COMP.
Proof.
Let be -ITRM-computable by the -ITRM-program . Suppose that uses registers. Then runs for many steps on each input by Theorem 14. Hence is -ITRM-decidable with time bound . By Lemma 6, it follows that is definable over . Hence .
On the other hand, if , then, by Lemma 9, is -ITRM-decidable. ∎
Remark 19**.**
As a consequence of the last theorem, it follows that, for ZF*-, -ITRMs cannot evaluate truth predicates for (since such a truth predicate would allow us to compute sets outside of , see below.) In fact, together with the results below, this is possible if and only if ZF-*.
Remark 20**.**
We point out that, for a ZF*-*-ordinal, the realm of computable objects for -ITRMs is , which is only a very minor portion of , the first -level containing all halting -ITRM-computations. To our knowledge, this is the first time such a divergence between levels containing computations and levels containing the computable objects has occured in ordinal computability. (See, however, footnote below.)
We now work towards the reverse direction. To this end, we introduce some terminology from [C].
Definition 21**.**
An ordinal is (w)ITRM-singular if and only if there are , a cofinal function and an -(w)ITRM-program , such that for all .
We note that the singularising functions can be chosen to have a particularly nice form:
Proposition 22**.**
If is (w)ITRM-singular, then there is a function with such that is unbounded in and such that is -(w)ITRM-computable, continuous and increasing.
Proof.
Let with be such that is unbounded in and is -(w)ITRM-computable. Now pick minimal such that is unbounded in and define by for . This can be computed on an -(w)ITRM as follows: Given in the input register, successively compute the values of for all . At the start of this computation, store in some extra register . Whenever some is larger than the current content of that register, replace the content of that register with . When we reach , that register will contain . Then is as desired. ∎
Lemma 23**.**
Suppose that is exponentially closed. Then is ITRM-singular if and only if is singular in , i.e. if and only if .
Proof.
Suppose first that is singular in . Then there is such that maps some cofinally into . By a simple coding, we can regard as a subset of . By Lemma 9, is -ITRM-computable. Thus, is ITRM-singular.
Now suppose that is ITRM-singular. Suppose for a contradiction that ZF*-*. Let be an -ITRM-computable function that maps some cofinally into . By coding, we can regard as a subset of . By Theorem 18, we have . Thus is singular in , a contradiction. ∎
We will also use the following theorem from [C] (Theorem 3.3.28):
Lemma 24**.**
If is ITRM-singular, then there is an -ITRM-program such that, for all and all , we have if and only if and otherwise, we have .
Although we do not give a detailed proof of this result here and rather refer to [C], we offer a sketch for the interested reader to see how ITRM-singularity enters the picture. Let a code for be given, where the element coded by in is given by . Moreover, let us say that the statement to be evaluated is , where is quantifier-free. Thus, is a Boolean combination of statements that can be read off from for all assignments, which can easily be done by an -ITRM with access to .
Below, we will represent a sequence of ordinals using two stacks, one of which contains , while the other contains , which is defined thus: , is Cantors’s ordinal pairing function, and .
Now, what we would like to do - and what is done e.g. in the work of Koepke on ORMs - is the following: Store [math] on the bottom of a stack. We now want to test whether holds when one substitutes with in . To this end, we successively put all elements of on the stack, considering for all one after the other. For each such pair, we then want to evaluate whether holds when one substitutes for and for , which is now done by putting further elements on the stack. If the answer is “yes” for each , we finally halt and return ‘true’. If the answer is “no” for some , we replace [math] with and repeat the whole procedure, and so on, until we have either found a witness for the or have run through the whole of and thus know that none exists.
However, as it stands, this does not work (in fact, by our remark above on the inability of -ITRMs to evaluate truth predicates in when ZF*-*, it cannot). The reason is this: After, e.g., considering for all , the stack register will not contain , as it should, but simply , thus losing all information. The same happens frequently when the stack contents approach limits.
Fortunately, there is a way out: As is already observed and used in [K1], the following is true:
Lemma 25**.**
Let be a sequence of ordinals of limit length, , and let . Then .
Thus, sequence coding is compatible with limits, provided the limits are small enough. And if is ITRM-singular, this can be exploited: Suppose that with is cofinal, total and -ITRM-computable. Note that, by putting at the bottom of the stack, we can perform a depth-first-search through on an -ITRM. Take an auxiliar register in which this is done, called the “regulating register”. For the sake of simplicity, we will consider in detail only the case that the formula is ; the rest is then a matter of iteration. We proceed as follows: at each time, contains a sequence with . At the same time, the “main register” will contain a sequence with for . For any such sequence, it is tested whether holds for the elements coded by and using the code . If not, the current candidate for is not good and we change the contents of first to , then to and then to , so that the search in the second component can continue. If yes, we simply replace with . When , we have successfully checked up to ; in this case, we increase by and modify the contents of as follows: and continue. When , we have unsuccessfully searched for a witness below ; in that case, we modify the content of first to and then to and moreover, we modify the current content of as follows: . When , we have successfully checked all ordinals and holds, where is the element coded by the current value of ; thus, we output “true”. On the other hand, when , we have unsuccessfully searched through for a candidate for , in which case we output “false”.
The following picture illustrates the approach.
\delta^{2}$$\iota_{0}$$\iota_{1}…\iota_{n}$$f(\iota_{0})$$\xi_{0}<f(\iota_{0}+1)$$f(\iota_{1}+1)$$\xi_{1}<f(\iota_{1}+1)…f(\iota_{n})$$\xi_{n}<f(\iota_{n})+1
Given this lemma, the rest is a matter of a standard diagonalization:
Theorem 26**.**
Suppose that is exponentially closed and ZF*-*. Then COMP.
Proof.
Suppose that is not a ZF*-*-ordinal. By Lemma 3, it follows that is singular in . By Lemma 23, is ITRM-singular. By Lemma 24, there is a program that evaluates truth predicates in .
For , let us write for the unique natural number and for the unique ordinal such that can be written in the form .
Now let . Using , is clearly -ITRM-decidable.
Assume for a contradiction that . Thus, there are and such that . Let . Then , a contradiction. Thus .
Hence, we have , so COMP. ∎
This theorem is a bit of an understatement. Using the truth predicate for , one can compute a code for . From this in turn, one obtains a code for and so on. Thus, we actually get the following:
Corollary 27**.**
If is exponentially closed and ZF*-*, then COMP.
We will considerably extend this in the next section.
In any case, the proof of Theorem 2 is now finished: For exponentially closed , Theorem 18 shows that ZF*-* implies COMP and Theorem 26 shows that ZF*-* implies that COMP, which yields the desired equivalence.
3 Towards the general Case
We will now consider the case of ordinals such that ZF*-*. Although we are not able to determine the comptuational strength of -ITRMs in general, we give some information that should be helpful. The content of this section are generalizations of those obtained in [CFKMNW] for ITRMs (i.e., the case ).444We point out that our contribution to [CFKMNW] was the lost melody theorem for ITRMs. In particular, we had no part in the proof that clockability implies computability for ITRMs, which is generalized to -ITRMs in Theorem 32 below.
For the rest of the section, let be an ordinal that is exponentially closed and ITRM-singular.
We recall some standard terminology: For an ordinal , we say that is -ITRM-computable if and only if it has an -ITRM-computable -code (i.e. a subset of that codes it). We say that is -ITRM-clockable if and only if there are an -ITRM-program and an ordinal such that halts in exactly many steps.
Lemma 28**.**
[Cf. [CFKMNW], Theorem ] Let be an -ITRM-program, and let such that halts. Then no configuration appears more than many times in the computation of .
Proof.
This is proved by a generalization of the proof of Theorem of [CFKMNW]. The new feature that one needs to take into account is the possibility of proper limits, i.e., that inferior limits are reached not by appearing cofinally often before, but as limits of increasing sequences from below. Since the general case requires a bit more care in some places, we elaborate the proofs a bit further than it is done in [CFKMNW].
So suppose for a contradiction that halts, but some configuration appears many times during this computation. The possible configurations are partially ordered by the component-wise -relation. As configurations are finite tuples of ordinals, this ordering is well-founded. Let us assume without loss of generality that is minimal among the configurations appearing many times during the computation of . Also, for , let us denote by the th time at which appears in the computation of , and let .
Claim: Between times and , no component of any configuration occuring in the computation of was below the corresponing component in .
Proof.
Suppose otherwise. Thus, there is such that, at time , some component of the current configuration was smaller than the corresponding component in . Let be such that .
Now, clearly, the same will happen at time for any ; moreover, if at least many occurences of would happen between times and , then the same was true between times and , contradicting the assumption that .
Let us form a sequence of ordinals as follows: , is the smallest ordinal of the form greater than and .
It is not hard to see that the supremum of this sequence will be strictly below . Let be such that . Moreover, at time , the configuration will be an inferior limit of a sequence of configurations that contains cofinally often both times at which the configuration was and at which it was . Thus, at time , the configuration will be strictly smaller than in the component-wise ordering. As appears at any time of the form with , this happens many times, contradicting the minimality of . ∎
By the claim, the configuration at time is , and we have a strong loop between times and . But then, does not halt, a contradiction.
∎
Remark 29**.**
Note that the bound is optimal in the above result. To this end, recall (e.g., from [CFKMNW]) that a ’flag’ for an ITRM consists of two registers that initially contain [math] and and swap their contents in each step, so that the first time at which they will have equal contents will be . By nesting flags (which is used in [CFKMNW] to show that ordinals are ITRM-clockable), it is easy to obtain, for any and any , a halting -ITRM-program that repeats some configuration at least many times, and in fact with a program that only generates register contents [math] and .
From the proof of Theorem 28, we further obtain the following observation:
Corollary 30**.**
Let be a limit ordinal, and suppose that in the computation of , the configuration appears both at time and unboundedly often before . Then is looping.
From now on, the proofs from [CFKMNW] apply verbatim in the general context. We thus restrict ourselves to giving the results in their general form and sketching the proofs for the convenience of the reader.
The following lemma will be needed below for .
Lemma 31**.**
[Cf. [CFKMNW], Lemma ] Every ordinal is -ITRM-clockable. Moreover, there is a recursive function that sends (an encoding of the Cantor normal forms of) each ordinal in to an -ITRM-program such that clocks .
Proof.
Let . By the results of [CFKMNW] and [K1], is ITRM-clockable. Clearly, when , then an -ITRM can simulate an ITRM (using an extra register which initially contains ) without time lapse. Hence is -ITRM-clockable.
The second statement follows similarly from Proposition of [CFKMNW], the proof of which clearly yields such a recursive function. ∎
Theorem 32**.**
[Cf. [CFKMNW], Theorem ] If is -ITRM-clockable, then is -ITRM-computable. Moreover, the suprema of the -ITRM-clockable and the -ITRM-computable ordinals coincide.
Proof.
Let and be such that runs for exactly many steps. Suppose that uses many registers. Pick some effective bijection . An -code is obtained as follows: We let if and only if, with and , the -th occurence of the configuration preceeds the -th occurence of the configuration in the computation of (and both occurences exist in this computation).
This can be computed as follows: By Lemma 31, compute a program that clocks and a program that clocks . Then run . Whenever occurs, run one step of in some separate registers, and likewise for and . If halts before in this computation, return ‘yes’, otherwise (i.e., if the computation of halts and no such occurences were detected or if halts before ), return ‘no’.
Concerning the suprema, the above yields that the supremum of the -ITRM-computable ordinals is not smaller than that of the -ITRM-clockable ordinals. For the converse, just note that, if is ITRM-singular, then we can run a depth-first search on an -code for an ordinal to test it for well-foundedness, which takes at least many steps.
∎
Lemma 33**.**
[Cf. [CFKMNW], Lemma ] The set of -ITRM-clockable ordinals is downwards closed: That is, if is -ITRM-clockable and , then is also -ITRM-clockable.
Proof.
Let be an -ITRM-program and an ordinal such that clocks . At time in the computation of , some configuration appears for the -th time. By Theorem 28, we have . By Lemma 31, is -ITRM-clockable, say by the program . Now run with stored in some extra registers and run one step of whenever occurs in that computation. When halts, halt. This clocks . ∎
Let us from now on denote by the supremum of the -ITRM-clockable ordinals.
Corollary 34**.**
[Cf. [CFKMNW]] Let be an -ITRM-program, and let . Suppose that does not halt. Then there are ordinals such that witnesses the looping of . Moreover, is minimal with this property.
Proof.
Suppose that uses registers. Since does not halt and all configurations come from the set , some configuration must occur more than many times, so Lemma 28 implies that the computation will eventually enter a strong loop. Say that is lexically minimal such that witnesses the looping of . Let be the configuration at time .
We claim that is -ITRM-clockable, which implies , as desired.
To clock , let us run with stored in some extra registers. Moreover, we use a further ‘index’ register , which initially contains [math]. Whenever is assumed during the computation of , the content of is changed to . When a further configuration is in any component, the content of is changed back to [math]. On the other hand, if reoccurs with containing , we halt.
Minimality is clear, as we can simply run a non-halting computation after a halting computation. ∎
For the next result, it will be important that one can ‘read out’ ordinals from codes for ordinals. More specifically:
Lemma 35**.**
Let be an -code for an ordinal obtained from a program clocking (possibly with parameters) as described in the proof of Theorem 32. Then there are -ITRM-programs and such that:
For any , halts and outputs an ordinal such that represents in . 2. 2.
For any , halts and outputs an ordinal such that represents in .
Proof.
First, observe that, since , no configuration can occur in the computation of more than many times.
The program in question works as follows: Let be given in some input register. Run . Along with , count upwards in a separate register until is reached. At this point, we have determined the -th configuration in the computation of , say . Now run again for many steps in this way, this time counting upwards in some register whenever the configuration occurs during the computation. Let be the content of that register when reaches its th step. (In particular, we have and .) Now, knowing and , we can compute the ordinal representing in the sense of by simply computing the tuple code. 2. 2.
Let be given in an input register; we want to determine the ordinal represented by in . To this end, count upwards in some register up to . For every , uses the program from (1) to compute the ordinal represented by in . At some point, we will have ; when this happens, output .
∎
Theorem 36**.**
For every exponentially closed and ITRM-singular ordinal and every , is -ITRM-computable if and only if .
Proof.
Suppose that is -ITRM-computable. Thus, there are an -ITRM-program and an ordinal such that, for any , we have if and only if and otherwise . In particular, halts for every . Now consider the program that counts upwards in some register starting with [math] and runs for every appearing in that register until overflows. This program will terminate, say in many steps. In particular, we will have and will be larger than the halting time of for each . So is definable over , thus .
It remains to show that, if an ordinal is -ITRM-computable and , then is -ITRM-computable.
We sketch the construction, which is based on the way Koepke et al. used to show that Ordinal Register Machines (ORMs) compute all constructible sets of ordinals.
Elements of can be ‘named’ by triples of the form , where are ordinals and is an -formula. Here, will represent the set . Clearly (by exponential closure of ), names can be encoded as ordinals in in way that allows us to compute codes from their components and components from codes on an -ITRM. Let us fix such an encoding .
We can now use a recursive truth predicate algorithm in the spirit of Lemma 24 to determine, for codes and , whether or . We then obtain an -code for as the set of such that .
From this code, we can read out all elements of using Lemma 35.
∎
Thus, in contrast to Theorem 18, which spoils the general picture of ordinal computability that ‘computational strength corresponds to the -level indexed by the supremum of the clockable ordinals’ which holds for all models studied so far (including wITRMs ([K]), ITRMs (, [K1]), ITTMs ([HL]), -ITTMs ([K1], [C], [C1]), ORMs ([ORM]) and OTMs ([OTM]) with and without parameters, the ‘hypermachines’ of Friedman and Welch ([FW]) and infinite time Blum-Shub-Smale machines ([KS1],[KM]), for ITRM-singular , all is well again.555We note that this is not the only place in ordinal computability where this happens: In fact, for Ordinal Turing Machines (OTMs), let be the supremum of the ordinals with eventually OTM-writable real codes and let be the supremum of the stabilization times for real numbers. Since is a supremum of a constructibly countable set of constructibly countable ordinals, we have ; on the other hand, J. Hamkins observed (see [HMO]) that there are stabilization times way over , so that ; in particular, is way larger than .
3.1 -ITRMs
In [K1], Koepke defined -(w)ITRMs, which are -(w)ITRMs with time restricted to ordinals .
Definition 37**.**
A set is -(w)ITRM-computable if and only if there are an -(w)ITRM-program and some such that, for all , halts in many steps with output .
We denote the set of -ITRM-computable subsets of by COMP and the set of -wITRM-computable subsets of by COMP.
Combining the above proof with a more careful analysis of running times, we obtain the computational strength of -ITRMs, partially666Note that, as exponential closure is a rather weak requirement on running times, this can be regarded as the major part of the question, possibly covering all interesting cases. answering a question of Koepke, see [K1], p. 6.
Theorem 38**.**
Let be exponentially closed. Then COMP.
Proof.
Clearly, if is computable by an -ITRM with time bounded by , then .
On the other hand, suppose that . Thus, there is such that . As , is -ITRM-clockable. By the proof of Theorem 32, a code for is -ITRM-computable with time bound .
Now, is of the form for some , some ordinal parameter and some -formula . Thus, is ‘named’ by the tripel .
To determine whether for some , one now again uses the bounded truth predicate algorithm for evaluating whether . It is now easy to see (see, e.g., [KS1], p. 314) that the running time of this algorith will be bounded below the next exponentially closed ordinal after , and thus in particular below , as required. Thus COMP. ∎
3.2 Properties of
What remains to be done in order to determine the computational strength of -ITRMs when ZF*-* is to determine . In this section, we will give upper bounds and, in some special cases, lower bounds on the value of ; moreover, we will prove some properties of .
Our first observation is that Corollary 30 yields -reflecting ordinals as bounds on halting times (we denote by COMP the set of -wITRM-decidable subsets of ); we remark that -reflecting ordinals as bounds on halting times for a strengthened type of Infinite Time Blum-Shub-Smale-machines working on natural or rational numbers are mentioned by Welch in [W1]; the proof below probably bears some similarity to his (unpublished) argument, which is not known to us. We received a further hint at considering -reflecting ordinals from [M], according to which the first -reflecting ordinal is way smaller than the first -admissible ordinal. As every -admissible is -reflecting but not vice versa, part (1) of the following theorem improves Theorem 1 from the introduction.
Theorem 39**.**
We have the following statements:
If is -reflecting, then COMP. 2. 2.
If is the smallest -reflecting ordinal , then .
Proof.
(1) Suppose that is -reflecting, and let be an -wITRM-program, . Suppose that does not halt before time , and let be the configuration of at time . We will show that has appeared unboundedly often before time , from which it follows by Corollary 30 that does not halt at all.
That the th register contains at time means that (i) for every , there is such that, at time , the content of the th register was at most and (ii) that, for every , there is such that, for all , the -th register had a content at time . This is clearly a -statement that holds in . Since is -reflecting, it holds at some earlier ordinal . The same is true when one additionally demands in both clauses that is larger than some given bound . The active program line can be dealt with in the same way (it can be regarded as another register that only contains natural numbers below a given bound). Thus, for every , there is a time such that appeared at time , i.e. appeared unboundedly often before time .
However, by Lemma 8, one sees that register machines with time and and space bound compute exactly those subsets of contained in .
(2) The proof that works by a similar argument; the only modification is that, when some is equal to [math], one needs to distinguish whether or not this is due to an overflow when expressing this as a -formula. Now, the statement that, for all and all , there is either a halting computation of or a partial computation with a strong loop is and holds in , as it holds in and . Since is -reflecting, it follows that there is such that the same holds in . Thus . ∎
As a consequence of the last part of the proof of Theorem 39, we obtain:
Corollary 40**.**
is not -reflecting. In particular, is not admissible.
Proposition 41**.**
Let be an -ITRM-program, . Then, at time , no registers of the computation of overflows.
Proof.
If halts, it does so before time , so there is no overflow at time . Now suppose that does not halt. As is the supremum of the looping times for -ITRMs, we know that entered a strong loop before time , which, by additive indecomposability of , has been repeated unboundedly often below . In particular, there is a configuration that appeared unboundedly often before time . But then, by the liminf-rule, there cannot be an overflow at time . ∎
We mention some further properties of .
We also note the following rather straightforward generalization of the induction used in Koepke [K1] for ITRMs:
Definition 42**.**
Let us say that an ordinal is -safe if there is no -ITRM-program and no such that has a proper limit at time .
Let us denote the th ordinal which is both additively indecomposable and -safe by and let . Moreover, define in the analogous way for -wITRMs.
Lemma 43**.**
For all exponentially closed , we have . Moreover, the halting times of -wITRMs are bounded above by .
Proof.
Let use the registers . As in [K1], we really show the following statement:
Claim: If less than many registers contain [math] at time in the computation of , then loops.
To see this, first suppose that, at time , no register contains [math]. Let be the configuration of at time . By definition of , there is such that the content of the th register does not drop below between times and (and similarly for the active program line). Consequently, has occured as the content if the th register unboundedly often before time . If we can show that occured between times and , we have a strong loop for , as desired. We proceed as follows: As occurs below the looping or halting time of , is clockable. Thus, we can run for many steps. After that, we continue to run , but along with that, we have a new registers (initially containing [math]) and run a routine that works in phases and observes the computation of do detect the following: In phase , it waits for to contain . When this happens, it counts upwards in and switches to phase . In phase , it waits for to contain and, when that happens, counts upwards in and switches to phase [math]. In phase [math], it waits for the active program line to be and when that happens, it counts upwards in and switches to phase . Thus, when contains a limit ordinal, the configuration of is . If that happens at for the first time, the content of at time is , while it was at all earlier times, contradicting the definition of . Thus, occurs between times and , so is indeed looping.
The inductive step now works as in the proof of Theorem 14 above or as the proof of the main theorem in [K1]: Suppose that the statement is proved for and suppose that, at time , at most registers contain [math]. If none of these [math]s is due to an overflow, we are back in the situation of the base case. Otherwise, suppose that overflows at time . Again, there is such that, from time on, the content of is always ; in particular, no register that does not contain [math] at time contains [math] after time (up to time ). Now, as overflows, does not contain [math] from some time on; let . By additive indecomposability of , we have . But then, at time , less than registers contained [math]. As we can regard this as the th step of the computation of starting in the configuration that had at time , it follows by induction that is looping.
The argument for the second statement is basically the base case of the above induction. ∎
Remark 44**.**
It is easy to see that the supremum of the -wITRM-clockable ordinals is both additively indecomposable and -safe for weak machines. Thus, this supremum is in fact equal to .
We saw above that, for ITRM-singular (i.e., for ZF*-), the depth-first search algorithm testing subsets of for coding well-orderings can be performed on an -ITRM. This algorithm has the property that it produces an infinite descending sequence in the case of an ill-founded input. Consequently, denoting by WOα* the set of subsets of coding well-orderings, we have the following property of :
Corollary 45**.**
For all , we have that WOα if and only if WOα.
In particular, this means that is -true, i.e. for any -formula with parameters in , we have if and only if holds in .777We suspect that this can be generalized via generalized descriptive set theory to a more general version of -statements referring to elements and subsets of .
3.3 Special Cases
With further conditions on , we can obtain more precise estimates of .
Recall that an ordinal is an index if and only if . Moreover, for an ordinal and a natural number , denotes the next admissible ordinal after , denotes the th admissible ordinal after and denotes the next limit of admissible ordinals after . Note that, if is an index, then the comprehension axiom for subsets of does not hold in , so and thus is ITRM-singular.
Proposition 46**.**
is not admissible. If is an index, then is a limit of admissible ordinals.
Proof.
That is not admissible was seen in Corollary 40 above.888For a different way to see that is not admissible, note that and the function that maps to the halting- or looping time (the end of the first repetition of a strong loop) of the th program in the input is (in fact ) over .
Now suppose that is an index. Let . Thus, is clockable, so is an index. To see this, note that a real number in can be used in the definition of a real number over . Now suppose that runs for exactly many steps. There is a real in that codes by assumption. Now is minimal with the property that believes that there is an ordinal coded by such that halts. Hence, the -Skolem hull of in is , so is a index by standard finestructure.
Let be a code for . Then is -ITRM-computable. The same holds for all ordinals that are recursive in ; as -ITRMs can simulate ITRMs, we can check all of these for well-foundedness and compute a code for their sum, which will be . Thus, we obtain , so there is an admissible clockable ordinal above , as desired. ∎
Remark 47**.**
Note that this has the consequence that the computational strength of -ITRMs may make wild jumps as the number of used registers increases: In fact, if -collection (with and as in Corollary 15), an -ITRM with registers will halt or loop in many steps, while the halting times with any number of registers go at least up to . This condition is for example satisfied by the smallest that satisfies -collection.
Concerning lower bounds for the supremum of the clockable ordinals, this yields the following partial result.
Corollary 48**.**
Let be an index. Then .
Proof.
We have that and from Proposition 46 it follows that is a limit of admissible ordinals. As is by definition the smallest ordinal with those properties, we have .
∎
We recall from [AS] that an admissible ordinal is called Gandy if and only if the supremum of the -recursive ordinals equals . Gostanian [Go] obtained several sufficient criteria for a countable ordinal to be Gandy. Generalizations to the uncountable case were given by Abramson and Sacks [AS].
We start by connecting Gandyness to -ITRMs.
Lemma 49**.**
If is an admissible Gandy ordinal with , then .
Proof.
Suppose that is admissible. As we saw above, is not admissible. Thus, we actually have . It follows that is -ITRM-clockable. Consequently, every subset of contained in is -ITRM-computable, which includes every -recursive subset of . Thus, we have . By inadmissibility of again, we have . ∎
We recall the following special case of a statement from Gostanian [Go], Corollary :
Lemma 50**.**
[Cf. [Go], Corollary ]
Let be an admissible ordinal such that is countable in . Let be an -formula with parameters in and suppose that is minimal with . Then is Gandy.
This allows us to show for many special cases of that is either rather small or quite large:
Theorem 51**.**
Let be admissible and countable in . Then either or .
Proof.
Suppose that the first alternative fails, i.e. . We now show inductively that , for every , which implies that the second alternative holds. The base case has already been dealt with, so it remains to prove the induction step. Hence, let us assume that ; we will show that .
Since is not admissible, we have . Hence is -ITRM-clockable. Thus, there exists a program and some parameter such that runs for exactly many steps.
We will now express that fact that halts by a formula that holds in if and only if . (Note that “there is a halting computation by will not work, as will not contain a computation of length .) Let be the halting configuration of the computation of , where is the index of the active program line and are the register contents. Then . Now let be the maximal index of a register used by and let be the conjunction of the following statements:
- •
There is such that every partial computation of of length has the active program line index at all times .
- •
For every such that there is a partial computation of of length , there is and a partial computation of of length such that, at time , has the active program line index .
- •
(For every .) For every , there is such that there is a partial computation of of length and every partial computation of of length has the content of the th register from time on.
- •
(For every .) For every such that there is a partial computation of of length , there is and a partial computation of of length such that, at time , the content of the th register is .
These statements simply encode the liminf-rule. The first two statements imply that, at time , the active program line index is , while the last two imply that the register contents are . Taken together, they express that, at time , assumes the halting configuration .
Thus is minimal with the property that . Now, by Lemma 50, this implies that is Gandy. By Lemma 49, we have , as desired. ∎
We do not know whether the first alternative can occur for any countable unless ZF*-*.
The argument for Theorem 51 actually shows that, when , then cannot lie between two successive admissible ordinals. By iterating the same argument, we obtain:
Corollary 52**.**
Let be admissible and countable in . Suppose that . Then , where is a limit of admissible ordinals .
4 Weak ITRMs and -weakness
Concerning -ITRMs, one of our main results above is that their halting times are bounded by if and only if . Moreover, in Theorem 39 above, we saw that the halting times of -wITRMs are bounded by itself when is -reflecting. This motivates the following definition:
Definition 53**.**
An ordinal is -weak if and only if all -wITRM-clockable ordinals are smaller than .
Clearly, since we allow parameters, all ordinals are -wITRM-clockable, so that coincides with the supremum of the -wITRM-clockable ordinals when is -weak. Also note that, by the speedup-theorem, an ordinal is -weak if and only if is not -wITRM-clockable.
We currently have no full characterization for -weakness. By the proof of Theorem 39, all -reflecting ordinals are -weak. In this section, we will additionally prove the following:
- •
An admissible ordinal is -weak if and only if it is wITRM-regular (i.e. not wITRM-singular).
- •
Any -weak ordinal is admissible.
- •
There are -weak ordinals that are not -reflecting.
- •
There are admissible ordinals that are not -weak.
Thus, -weakness is strictly between -reflection and admissibility. We now prove the statements in the order of their appearence.
Theorem 54**.**
An admissible ordinal is -weak if and only if it is wITRM-regular.
Proof.
We will prove both implications by contraposition.
“”: Suppose that is not wITRM-regular. Thus, there is an -wITRM-computable, total and cofinal function with . Let be a program that computes , say in the parameter . If halts after many steps on some input , then we have found an -wITRM-program that halts in many steps, so is not -weak. On the other hand, suppose that takes many steps on any input . In this case, we add the parameter to our computation and use a separate register . In , we count upwards from [math] to and for every , we use to compute and then use another extra register to count from [math] to . When the content of reaches , we halt. Clearly, this program halts after at least many steps, so again, is not -weak.
“”: Now suppose that is not -weak. As we mentioned above, this implies that is -wITRM-clockable. In particular, there is a program that halts in many steps (we ignore parameters for the sake of simplicity). We distinguish two cases:
Case : For every register used by , there is a time such that, from time on, the content of never dropped below the content of at time .
By the liminf-rule, there must also be an ordinal such that the active program line index was never below the one at time after time . Let be the maximum of and the finitely many that exist by the case assumption. Again by the liminf-rule, the active program line and the register contents at time must have occured cofinally often before time . Thus, we can build an interleaving, strictly increasing sequence of length of times at which these values were the ‘right’ ones. By admissibility, the supremum of this sequence will be . But then, and witness that is looping, which is a contradiction.
Case : There is some register containing an ordinal at time such that the content of was cofinally often before time .
By the liminf-rule, this means that, for every , there must be some such that, from time on, the content of was . Let be the function that maps each to the minimal such . Clearly, maps cofinally into . (If was bounded in by , all contents of would be from time on, contradicting the case assumption.) We claim that is -wITRM-computable. To this end, we use the clockability of . Reserve two extra registers, say and . Now, given , we proceed as follows: In , we count upwards, starting with [math]. For every value , we run for many steps, using the clockability of and check whether, from time on, the content of drops below . If yes, we continue with the next value of . If not, we halt with output . Since we know that some exists for which the routine will halt, this computes without producing an overflow and thus on an -wITRM. Thus, is wITRM-singular, i.e. not wITRM-regular.
∎
Remark 55**.**
Note that only the reverse direction uses the admissibility of , which can in fact be weakened to the assumption that -definable total functions with domain are bounded.
Theorem 56**.**
Any -weak ordinal is admissible.
Proof.
Suppose for a contradiction that is -weak, but not admissible. Thus, there is and a cofinal function which is over . Let be the function that maps to the smallest such that believes that exists, according to the -definition of . Clearly, is also a cofinal map from to . Now, given , compute upwards in a separate register starting with and, for every content , use evaluation of bounded truth predicates to test whether . If not, continue with the next value of . Otherwise, halt with output . Since this will halt for some , this will compute without producing an overflow, and thus by an -wITRM-computation. Hence, is wITRM-singular and hence not -weak by the remark after Theorem 54, a contradiction. ∎
Theorem 57**.**
(1) There are -weak ordinals that are not -reflecting. In fact, there are unboundedly many such ordinals.
(2) There are admissible ordinals that are not -weak.
Proof.
(1) We claim that there is a -sentence such that if and only if is -weak. Once this is proved, consider some -weak ordinal and let be the first -reflecting ordinal . Then, by reflection, there is such that , and so is -weak and , but not -reflecting. Since all -reflecting ordinals are -weak, there are unboundedly many -weak ordinals, and the claim follows.
Now for the claim: is -weak if and only if, for all programs and all parameters , one of the following holds in :
- •
There is an overflow at time , i.e. (where denotes the register with index and is the content of at time in the computation of ) (this is a -condition) OR
- •
halts (this is a -condition) OR
- •
does not halt, i.e. there are such that is in a strong loop between times and (this is a -condition).
This is clearly necessary for being -weak. To see that it is sufficient, note that every program only uses finitely many registers; thus, if the first disjunct holds, one of them has contents that eventually surpass cofinally many ordinals below , which suffices for an overflow.
The disjunction can clearly be written as a -formula, and thus the same holds for the whole condition.
(2) Since -wITRMs (in fact, -wITRMs) can simulate (-)ITRMs whose running times are all ordinals below (see [K1]), it follows that is admissible, but not -weak. The same holds for for all .
∎
Proposition 58**.**
There is an -wITRM-program such that, for any , if and only if codes a well-ordering and otherwise, .
Proof.
Just perform the usual depth-first search used on ITRMs (see [KM]) with at the bottom of the stack. ∎
As we saw for , we can now see that -weak ordinals are WO-true.
Lemma 59**.**
If an ordinal is -weak, then is admissible and WO-true.
Proof.
Suppose that is -weak. By Theorem 56, is admissible. Let be a linear ordering and suppose that is not well-founded. Since , some -code for is -wITRM-computable for some . By -weakness, will terminate in many steps after finding an ill-founded sequence in . Now, the computation of is contained in and from , one can define an ill-founded sequence in by letting if and only if, for some , the th component of content of the stack register is always . But then, we have , as desired. ∎
4.1 Further Observations
We mention a bunch of related results, some of which are contained in [C] as exercises, in the hope that these may lead to more substantial generalizations or refinements.
Proposition 60**.**
The real numbers computable by an -wITRM for are a superset of .
Proof.
It is easy to simulate ITRMs on an -wITRM when . ∎
We also note the following humble simulation result:
Proposition 61**.**
For any and any ordinal , we have .
Proof.
It is clear that we have
On the other hand, an -ITRM-program can be simulated on an -ITRM in the following way: Replace any register used by with registers that can contain ordinals up to . Then represent , , by having in the first many of these registers and in the st. ∎
Finally, we observe that the lost melody theorem holds for -ITRMs whenever is exponentially closed. Let us say that is -ITRM-recognizable when there are an -ITRM-program and an ordinal such that, for any , we have if and only if and otherwise .999The term ‘recognizable’ was first used by Hamkins and Lewis in [HL] in the context of ITTMs. Following the terminology of [HL] (where it is shown that there are lost melodies for ITTMs), a subset of which is -ITRM-recognizable, but not -ITRM-computable is called an -ITRM lost melody, below simply called ‘lost melody’ for short. In the below proof, we will occasionally confuse a program with its index .
Theorem 62**.**
For any ITRM-singular and exponentially closed ordinal , there is a lost melody.
Proof.
Given , let be the halting set for -ITRMs. It is clear that is not -ITRM-computable.
We claim that is -ITRM-recognizable. We sketch the proof, which is a generalization of the one in [C2] showing that the halting set for ITRMs is ITRM-recognizable and thus a lost melody for ITRMs. We freely use the relativized versions of the previous results in this section: In particular, if is -ITRM-clockable in the oracle , then is -ITRM-computable in this oracle etc.
Note that it is easy to effectively assign to any -ITRM-program and any parameter another -ITRM-program such that halts if and only if halts with output [math] or for any . Moreover, we can effectively assign to all -ITRM-programs and all ordinals a program that halts if and only if .
Now, given in the oracle, we do the following: Run through and, for each , check whether . If not, continue. Otherwise, perform a well-foundedness check on the set . Doing this for any will clock some ordinal in the oracle ; thus, is -ITRM-computable. From a code for , we can then compute a code for . Evaluating truth in , we can then check whether it holds in that, for any -ITRM-program and any , either halts or runs into a strong loop. If this fails, then . If this holds, is definable over and thus -ITRM-computable from , and we can use this to compute and compare it to . ∎
5 Conclusion and Further Work
The above work settles the question of the computational strength of -ITRMs when ZF*-; in the other cases, the question for the -ITRM-computable subsets of an exponentially closed ordinal is reduced to the determination of , which is characterized as (i) the supremum of the -ITRM-clockable ordinals (ii) the -ITRM-computable ordinals and (iii) the supremum of the looping times for non-halting -ITRM-programs. Although we obtained some lower and upper bounds, these are still quite far apart, and we expect that considerably new ideas are needed to determine precisely for any which neither has ZF-* nor .
Similarly open is the analogous question for -wITRMs: Here, we are even missing a characterization of the -weak ordinals.
We mention the following specific questions:
Question 63**.**
Is for all exponentially closed ? Even more boldly, is for such unless ZF*-*?
Question 64**.**
An important feature of ITRMs is the solvability of the bounded halting problem, see Koepke and Miller [KM]: For any fixed number , the halting problem for ITRM-programs using registers is solvable by an ITRM-program (which, of course, will use more than registers). The proof in [KM] seems to depend on the fact that, for any possible register content of an ITRM, only finitely many configurations have all register contents , which clearly fails for -ITRMs as soon as . Hence, we ask: Does the solvability of the bounded halting problem work for any exponentially closed other than the ZF*--ordinals?101010For the ZF-*-ordinals, this is clearly true as we can clock the upper bound of the halting times of programs using registers, so it can be decided whether such a program halts by simply running it for that many steps and seeing whether it holds until then.
6 Acknowledgements
We thank Philipp Schlicht for a series of discussion in which the proof of a previous (weaker) version Lemma , was obtained and his kind permission to use this proof in our work.
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[AS] F. Abramson, G. Sacks. Uncountable Gandy Ordinals. Journal of the London Mathematical Society, vol. s 2-14(3) (1976)
- 2[C] M. Carl. Ordinal Computability. An Introduction to Infinitary Machines. De Gruyter (2019) (forthcoming)
- 3[CFKMNW] M. Carl, T. Fischbach, P, Koepke, R. Miller, M. Nasfi, G. Weckbecker. The basic theory of Infinite Time Register Machines. Archive for Mathematical Logic 49 (2010) 2, 249-273.
- 4[C 1] M. Carl. Resetting α 𝛼 \alpha -register machines and ZF - . Preprint, arxiv 1907.09513 (2019)
- 5[C 2] M. Carl. Optimal results on recognizability for infinite time register machines. ournal of Symbolic Logic 80 (4):1116-1130 (2015)
- 6[Cu] N. Cutland. Computability. An introduction to recursive function theory. Cambridge University Press (1980)
- 7[FW] S. Friedman, P. Welch. Hypermachine. J. Symb. Log., vol. 76(2), pp. 620-636 (2011)
- 8[GJH] V. Gitman, T. Johnstone, J. Hamkins. What is the theory ZFC without power set? Mathematical Logic Quarterly, vol. 62(4) (2011)
