{'fraction_non_alphanumeric': 0.05448717948717949, 'fraction_numerical': 0.008077497987811889, 'mean_word_length': 3.7055998917895305, 'pattern_counts': {'":': 0, '<': 101, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 19, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Realisability for Infinitary Intuitionistic Set Theory

We introduce a realisability semantics for infinitary intuitionistic set theory that is based on Ordinal Turing Machines (OTMs). We show that our notion of OTM-realisability is sound with respect to certain systems of infinitary intuitionistic logic, and that all axioms of infinitary Kripke-Platek set theory are realised. Finally, we use a variant of our notion of realisability to show that the propositional admissible rules of (finitary) intuitionistic Kripke-Platek set theory are exactly the admissible rules of intuitionistic propositional logic.


Introduction
Realisability formalises how a statement can be effectively or explicitly established. For example, in order to realise a statement of the form ∀x∃yϕ according to Kleene's realisability semantics for arithmetic [18], one needs to come up with a uniform method of obtaining a suitable y from any given x. Such a method is often taken to be a Turing program. Realisability originated as a formalisation of intuitionistic semantics. Indeed, it turned out to be well-chosen in this respect: the Curry-Howard-isomorphism shows that proofs in intuitionistic arithmetic correspond-in an effective way-to programs realising the statements they prove, see, e.g, van Oosten's survey [25] for a general introduction to realisability.
From a certain perspective, however, Turing programs are quite limited as a formalisation of the concept of effective method. Hodges [13] argued that mathematicians rely (at least implicitly) on a concept of effectivity that goes far beyond Turing computability, allowing effective procedures to apply to transfinite and uncountable objects. Koepke's [19] Ordinal Turing Machines (OTMs) provide a natural approach for modelling transfinite effectivity.
With such a transfinite generalisation of Turing computability, it becomes a natural application to obtain notions of realisability based on models of transfinite computability. Such a concept was first defined and briefly studied by the first author [6]. In contrast to Turing machines, for which input and output are finite strings and can thus be encoded as natural numbers, OTMs can operate on (codes for) arbitrary sets. The natural domain for the concept of transfinite realisability obtained from OTMs is thus set theory rather than (transfinite) arithmetic. Does OTM-realisability correspond to provability (iii) x i = x j is a formula for any variables x i and x j ; (iv) if ϕ and ψ are formulas, then ϕ → ψ is a formula; (v) if ϕ α is a formula for every α < β, then α<β ϕ α is a formula; (vi) if ϕ α is a formula for every α < β, then α<β ϕ α is a formula; (vii) if x is a context of length α, then ∃ α xϕ is a formula; and, (viii) if x is a context of length α, then ∀ α xϕ is a formula.
By this definition, our language allows set-sized disjunctions and conjunctions as well as quantification over set-many variables at once. However, infinite alternating sequences of existential and universal quantifiers are excluded from this definition.
Remark 1. While we only consider the logic L ∞,∞ in this paper, our results can be easily adapted to logics L κ,κ for regular cardinals κ. In particular, notions of realisability for these logics can be obtained through κ-Turing machines (κ-TMs; see [6]).
Whenever it is clear from the context, we will omit the superscripts from the quantifiers and write ∃ and ∀ instead of ∃ α and ∀ α , respectively. It will often be useful to identify a variable x with the context x = x whose unique element is x. In such situations, we will write "∃xϕ" for "∃xϕ" and "∀xϕ" for "∀xϕ". A variable x i is called a free variable of a formula ϕ whenever x i appears in ϕ but is not in the scope of a quantification over a context containing x i . As usual, a formula without free variables is called a sentence. We say that x is a context of the formula ϕ if all free variables of ϕ appear in x. As usual, we will write ϕ(x) if ϕ is a formula and x a context of ϕ. Similarly, given two contexts x and y with x j = y j ′ for all j < ℓ(x) and j ′ < ℓ(y), we will write ϕ(x, y) if the sequence obtained by concatenating x and y is a context for ϕ.
Let µ be an ordinal, x be a context of length µ, and y be a variable. Then "x ∈ y" is an abbreviation of the following infinitary formula: ∃f ∃d∃ µ z["f is a function whose domain is the ordinal d" ∧  Intuitively, "x ∈ y" expresses that there is a function f such that f = x and f is contained in the set y. We will later see in Lemma 23 that "x ∈ y" is interpreted with the intended set-theoretical meaning, namely that the set y contains the sequence x.
As in the case of finitary realisability, bounded quantification will play a crucial role for transfinite realisability. For this reason, we extend the classical abbreviations as follows: given a formula ϕ and an ordinal α ≥ ω we introduce the bounded quantifiers as abbreviations, namely, ∀ α x ∈ y ϕ for ∀ α x(x ∈ y → ϕ),
The bounded quantifiers for α < ω are defined as usual. The class of ∆ ω 0 -formulas consists of those formulas that have no infinitary quantifiers and whose quantifiers are bounded 2 . Similarly, a formula 2 We note that ∆ ω 0 = ∆ 0 and Σ ω 1 = Σ 1 where ∆ 0 and Σ 1 are the usual classes of formulas in the Levy hierarchy.
belongs to the class of Σ ω 1 -formulas if it is of the form ∃xψ for some ∆ ω 0 -formula ψ. We extend this definition to formulas with infinitary quantifiers as follows. An infinitary formula is a ∆ ∞ 0 -formula if all the quantifiers appearing in the formula are bounded. Furthermore, the class of Σ ∞ 1 -formulas consists of the formulas of the form ∃ α xψ for some ∆ ∞ 0 -formula ψ and an ordinal α.
Remark 2. Note that the previous definition of infinitary ∆ ∞ 0 -formulas requires the bounding set to contain the sequence x j | j < α rather than just each individual element of that sequence. This is necessary to lift the usual absoluteness results to the infinitary case. Indeed, the following alternative definition and straightforward generalisation of the standard definition of bounded formulas does not provide absoluteness. If we define ∀ α x ∈ yϕ as ∀ α x( j<α x j ∈ y → ϕ), and ∃ α x ∈ yϕ as ∃ α x( j<α x j ∈ y ∧ ϕ), then it the following formula ϕ(y) := ∃ ω x ∈ {0, 1} x / ∈ y is not absolute: it is easy to see that if ℘ V (ω) = ℘ L (ω), then L |= ¬ϕ(L ω L 1 ) but ϕ(L ω L 1 ) is true. 2.2. Ordinal Turing Machines. Ordinal Turing machines (OTMs, for short) were introduced by Koepke [19] as a transfinite generalisation of Turing machines and will be the main ingredient for our definition of infinitary realisability. We will only give a basic intuition for this model of transfinite computability and refer to the relevant literature (e.g. [19] or in [6, Section 2.5.6]) for a full introduction to OTMs.
An Ordinal Turing machine (OTM) has the following tapes of unrestricted transfinite length: finitely many tapes for the input, finitely many scratch tapes, and one tape for the output. Ordinal Turing machines run classical Turing machine programs and behave exactly like standard Turing machines at successor stages of a computation. At limit stages, the content of the tapes is computed by taking the point-wise inferior limit, the position of the head is set to the inferior limit of the head positions at previous stages, and the state of the machine is computed using the inferior limit of the states at previous stages (see [6,Section 2.5.6] for more details).
Ordinal Turing machines are a very well-behaved model of transfinite computability and many results from classical computability theory can be generalised to OTMs (e.g., [19,9,20,31,7,8,35]). For this reason, we will describe OTM-programs using high-level pseudo algorithms as usually done with Turing machines. We fix a computable coding of Turing machine programs as natural numbers. In the rest of the paper, we will identify a program with its natural number code.
In this paper, we consider machines that run programs with parameters. For this purpose, we fix one of the input tapes as the parameter tape. A parameter is a binary sequence of ordinal length, i.e., an element of 2 <On , which is written on the parameter tape before the execution of the program begins. Using classical techniques (see below), we can code sets of parameters in a single sequence p ∈ 2 <On . Therefore, we can say that an OTM executes a program c with parameter P ⊂ 2 <On if a code for P is written on the parameter tape before the program is executed. 3 Given a program c and a parameter P ⊂ 2 <On , and two sequences a and b in 2 <On we will write c P (a) = b if an OTM which executes c with parameter P and input a, outputs b.
Given a class function f : 2 <On → 2 <On we say that a program c computes f with parameter P ⊂ 2 <On if for every binary sequence b we have c P (b) = f (b).

2.3.
Coding. The objects of our notion of realisability will be arbitrary sets and not just ordinal numbers. Therefore, we need to be able to perform computations on sets. As OTMs work on ordinal length binary sequences, we have to code arbitrary sets as sequences in 2 <On . However, working directly on binary sequences of ordinal length is cumbersome. We therefore use a concatenation of two codings given by the following injective functions: allowing us to encode ordinals, sets of ordinals, pairs of sets of ordinals and ordinals, and sequences of such pairs as binary sequences of ordinal length.
(ii) A high-level coding C : (On × ℘(On)) → V encoding arbitrary sets as a pair of an ordinal and a set of ordinals.
By concatenating both injective functions, we obtain a coding of arbitrary sets as binary sequences of ordinal length. The reader familiar with OTMs and codings may wish to skip forward to Section 3 and refer back to this section if necessary.
2.3.1. Low-level coding. While not difficult, the technical details of the low-level coding are complicated and cumbersome (just like in the case of codings for ordinary Turing machines). We will now introduce a coding of sets of ordinals as binary sequences of ordinal length and prove a few basic properties of this coding.
Remark 3. Note that sets of ordinals can in principle also be coded using characteristic functions. Unfortunately, since the largest ordinal in the set is not computable from this coding, bounded searches are not computable with this simple coding and we would not be able to compute basic operations over sets, such as computing the image of a set under a computable function.
Given a binary sequence b ∈ 2 <On and a set X ∈ ℘(On) of ordinals we say that b codes X if for β = sup{2α + 2 | α ∈ X} we have b(β + 1) = b(β + 2) = 1, for every 2α ≤ β we have that b(2α) = 0, and for 2α + 1 < β we have α ∈ X if and only if b(2α + 1) = 1. Intuitively, a binary sequence encodes a set of ordinals X if it is of the form where i α = 1 if and only if α ∈ X. Note that the final sequence 11 marks the end of the code of the set, i.e, none of the further bits matter in determining the set encoded by the sequence. 4 In Section 2.3.2, we code sets as pairs α, X consisting of an ordinal α and a set X of ordinals including α. For this reason, we will now extend the previous coding to pairs in On × ℘(On). The idea is to start with a code of X as described before and encode α in the final part of the binary sequence. 4 For example, 0 is encoded by any sequence starting with 011, 1 = {0} is encoded by any sequence starting with 01011, and ω is encoded by any sequence starting with the sequence 0101010101 . . .
where as before i γ = 1 if and only if γ ∈ X.
We take χ to be the class function that associates to every sequence encoding a pair α, X the corresponding pair. It is easy to see that χ is bijective.
We will say that a program c computes a class function F : On×℘(On) → On×℘(On) with parameters P if an OTM executing c with parameter P , and a sequence encoding a pair α, X ∈ On × ℘(On) as input, returns a sequence that encodes F ( α, X ). Moreover, we will say that c computes the class function F : ℘(On) → ℘(On) with parameter P if for every set X ∈ ℘(On), an OTM executing c with parameter P , and a sequence that encodes 0, X as input, returns a sequence that encodes 0, F (X) .
The previous coding can be easily extended to sequences in (On × ℘(On)) <On . We encode a sequence α β , X β | β < η using the sequence obtained by concatenating the encodings χ −1 ( α β , X β ) in the order they appear in α β , X β | β < η followed by a sequence of four 1s to mark the end of the code of the sequence. Therefore, a sequence α β , X β | β < η is coded as follows: where, as before, i β γ = 1 if and only if γ ∈ X β for all β < η. As mentioned above, this coding induces a notion of computability over (On × ℘(On)) <On . Lemma 4. Let X be a set of ordinals. Then the following are OTM-computable: (i) the function that, given codes for an ordinal α and a sequence X, returns 1 if α ∈ X, and 0 otherwise, (ii) the function that, given codes for an OTM-computable function f : On → On and X, returns a code for the image {f (α) | α ∈ X} of X under f , (iii) the function that, givens codes for α γ , X γ | γ < η and an ordinal β < η, returns a code for α β , X β , (iv) the function that, given codes for α γ , X γ | γ < η and an ordinal β < η, returns a code for the list obtained by removing the β-th element from α γ , X γ | γ < η , (v) the function that, given codes for α γ , X γ | γ < η and α, X , returns a code of the list α γ , X γ | γ < η + 1 where α η , X η = α, X , (vi) bounded searches through sets of ordinals.
Proof. Given a code of a set of ordinals X as a binary sequence, and given some ordinal α such that α < sup{2β + 2 | β ∈ X}, an OTM can stop at the position of the tape which contains the i α bit of the code of X. In what follows, we will refer to this the cell of the tape as the position of i α on the tape. This can be computed by the program that moves the head of the tape left increasing a counter γ each time that the head is moved to a cell with an even index. Once γ reaches α, the machine moves to the next position of the tape and stops. For (i), consider the program that goes through the code of X until it reaches the cell containing i α , copies the content of that cell to the output tape and then stops.
For (ii), consider the program that runs through the representation of X and for each α ∈ X, first computes f (α), then writes a 1 in the position of i f (α) on the output tape, and saves the index of the first cell of the output tape after which the output tape was not modified in an auxiliary counter γ. Once the program sees the sequence 011 in the representation of X, it moves the head of the output tape to position γ, writes 011 and stops.
For (iii), the program goes trough the code of α γ , X γ | γ < η while increasing a counter α as follows: each time that the program sees the sequence 011, it looks for the first 1 after it and then increases α by 1. As soon as α = β, the program copies the input tape from the current position until the first occurence of the sequence 011, then it copies all 0s following this and stops as soon as it reaches a cell with a 1.
For (iv), the program goes trough the code of α γ , X γ | γ < η while increasing a counter α as for (iii) and copying the input tape on the output tape. Once β = α the program continues to go through the representation of X without copying it to the output tape the until it sees the first occurrence of the sequence 011 and the next 1 after that. Then the program continues copying the input tape to the output tape until it sees the sequence 1111.
Note that (v) can be trivially computed by an algorithm that copies the representation of α γ , X γ | γ < η on the output tape except for the sequence 1111. Then the program copies the representation of α, X on the output tape and writes the sequence 1111 when done.
Finally, (vi) can be computed by combining the previous items. Note, in particular, that our choice of coding allows us an OTM to recognise when it reaches the end of a code.
By Lemma 4 we are now justified in treating tapes as queues. We will make plenty of use of this convention. Moreover, we will use the expressions "bounded search", "bounded search through a set", and "search through a set" interchangeably. If c is a code for an OTM-program, P a parameter-set, and X and Y are sets of ordinals, we will write c P (X) = Y to mean that an OTM-computation of the program c with parameters P and input χ −1 (X) halts with χ −1 (Y ) on the output tape. We write c P (X)↑ if this computation does not halt.
By using the coding defined in the previous section we can extend the notion of computability to V. Given two sets X and Y , we write c P (X) = Y when, given a code a for X, c P (a) computes a code of Y . Note that the class relation c P on V is in general not a function but a multi-valued function-indeed, the set coded by the output of c P could depend on the specific code of X. Figure 1 shows how the codings interact with each other. Departing from this low-level coding, we need to encode arbitrary sets as pairs of an ordinal and a set of ordinals to use them as the objects of our investigation. Convention 5. We will follow the usual simplifying convention when working with OTMs (and, in fact, any other kind of machine), and confuse objects with their codes. For example, we might say that 'an OTM takes an ordinal α as input' when we mean, of course, that it 'takes a (low-level) code for an ordinal α as input,' and similar for sets of ordinals, sequences, etc. It will always be clear from the context when we mean low-level codes because OTMs operate directly only on binary sequences (and not on ordinals or arbitrary sets).

2.3.2.
High-level coding. We will now define a high-level coding for arbitrary sets. Recall that the Gödel class function g extends the usual Cantor pairing function on natural numbers and maps pairs of ordinals to ordinals, see, e.g., [17, p.31]. Given a set X we will denote its transitive closure by tc(X) (see, e.g., [17, p.64]). Definition 6. Let X be a set. A pre-code for X is a set C of ordinals such that there is a bijection d C : α → tc({X}) with the property that g(β, γ) ∈ C if and only if d C (β) ∈ d C (γ). We say that C is a pre-code if it is a pre-code for some set X.
Definition 7. The high-level coding C is the partial surjective class function On × ℘(On) → V given by C( ρ, C ) = d C (ρ). If C( ρ, C ) = x, we say that ρ, C is a code of x or that it encodes x. We will also say that ρ is the representative of x in C.
We say that a tuple β, C is a code if it is a code of some set x. We say that a code c is based on the pre-code C for y if c = β, C for some ordinal β. If c is a code for x based on a pre-code C for y, we will write ρ c for the representative of x in C, and d c for the bijection d C .
The pre-code on which a code is based may contain much more information than actually needed for the coding. For this reason, we introduce the following notion of essential domain containing only the information that is strictly needed to recover the set.
Intuitively speaking, the essential domain of a code c of a set x contains the transitive closure of x as coded by c but not more than that. There can be many codes for one set. For this reason, we introduce the following notion of isomorphism between codes. Crucially, these isomorphisms are only between the essential domains of a code.
As usual, we will say that two codes are isomorphic if there is an isomorphism of codes between them.
Lemma 10. Let X and Y be sets. If a is a code of X, b is a code of Y , and f a code-isomorphism between them, then X = Y .
We will now prove some helpful properties of (high-level) codes. In doing so, we will rely on Lemma 4 and Convention 5.
Lemma 11. Let a and b be codes of sets.
(i) The set essdom(a) is computable, i.e., given a code for a, we can compute a binary sequence b ∈ 2 <On such that b(α) is 1 if and only if α ∈ essdom(a).
(ii) The function that given (iv) There is a program that, given a code of a sequence a β | β < α of codes of sets, returns a code for the set {d a β (ρ a β ) | β < α}.
(v) Let ϕ be a computable property of sets, i.e., there is a program c, possibly with parameter P , such that c P (a) = 1 if and only if ϕ[Y /x] for every code a of a set Y . There is a program, possibly with parameters, that given a code of a set X as input computes a code for In particular, note that the relations X ∈ Y , X ⊆ Y , and X = Y are computable.
Proof. For (i), we make use of an auxiliary tape which we will use as a queue in virtue of Lemma 4. Given a code a = ρ a , C , the computation of essdom(a) is implemented via a breadth-first search as follows. Enqueue ρ a . Then run the following loop until there are no elements left in the queue: dequeue the first element of the queue, say ordinal β. Mark the βth position of the output tape with a 1. Then conduct a bounded search through C during which all α are enqueued whenever g(α, β) ∈ C, and jump to the beginning of the loop. This procedure must eventually stop because sets are well-founded so that only set-many steps will be required to walk through the transitive closure of the set represented by ρ a . For (ii) and (iii), we provide two procedures that recursively call each other: Decode(a, b, α) and Subset(a, b, α, β), where Decode(·, ·, ·) is the function required for (ii) and Subset(·, ·, ·, ·) for (iii). Let's begin with Decode(a, b, α), which takes codes a = (ρ a , A) and b = (ρ b , B) for sets as well as (a code for) an ordinal α ∈ dom(d a ) as input. First, the program checks whether d a (α) = ∅ by conducting a bounded search looking for a β ∈ dom(d a ) such that g(β, α) ∈ A. If such a β cannot be found, the program looks for the unique γ such that g(β, γ) / ∈ B for all β ∈ dom(d B ) which must exist as B is a pre-code. The program then returns this γ and stops. If it turns out that d a (α) is non-empty, then the program goes through all the ordinals β ∈ dom(d b ) and calls Subset(a, b, α, β) and Subset(b, a, β, α) to check whether d a (α) = d b (β). If that is the case, then the program returns β. If no such β is found, it writes dom(d b ) on the output tape.
Next, consider Subset(a, b, α, β), which takes as input two codes a = ρ a , A and b = ρ b , B . This procedure should return 1 in case d a (α) ⊆ d b (β) and 0 otherwise. To do so, conduct a bounded search on γ ∈ dom(d a ) and check whether g(γ, α) ∈ A. If so, let δ = Decode(a, b, γ) and check whether If this is the case, write 0 on the output tape and stop. If the bounded search is finished without interruption, write 1 on the output tape and stop.
To finish the proof of (ii) and (iii), note that the mutual recursive calls finish after set-many steps of computation because sets are well-founded so that, eventually, the case for ∅ will be reached.
For (iv), let a β | β < α be given with a β = ρ a β , A β . Set σ 0 = ρ a0 and recursively construct σ β for β ≤ α as follows. If β = γ + 1, then let σ β = sup({σ γ + δ | δ ∈ A γ }) + 1. If β is a limit, then let σ β = sup({σ γ | γ < β}). Note that all this can be straightforwardly computed by an OTM. Then define the set A as follows: Intuitively, the first half obtains a concatenation of all the sets coded by a β and the second half makes sure that all the sets coded by a β are members of the new set. Now, we might not yet have a code: if there are γ, δ < α such that the sets coded by a γ and a δ are not disjoint, then their common elements will appear twice. For this reason, we have to remove duplicates from A and obtain a pre-code A ′ . This can easily be done with a bounded search, using the Subset(·, ·, ·, ·) routine, replacing duplicate occurrences with the first occurrence and removing those that are not needed. Finally, return the code Finally, (v) is witnessed by the following algorithm: search through the code of X and check whether ϕ[Y /x] holds for each Y ∈ X. If so, then the machine adds a code of Y to an auxiliary queue. Once the program has checked all the elements of X, it uses the algorithm presented in the proof of (iv) to compute the desired code from the sequence saved in the queue.
Given that an OTM-program has access to the particular codes of a set, it can make use of, for example, the well-ordering that is implicit in the coding. To avoid any unwarranted side-effects of this, we introduce the notion of uniform OTM-programs. Intuitively, an OTM-program is uniform if running the program with codes for the same set(s) results in codes for the same set(s).
Convention 13. As with the low-level coding, we will follow the usual convention of (ordinal) computability theory and confuse objects and their codes. As in Convention 5, it will always be clear (or does not matter) which coding is applied when: for example, if we say that an OTM takes a set as input, then we mean that it takes as input the low-level code of a high-level code for a set.

A Notion of Transfinite Realisability
3.1. OTM-Realisability. In this section, we will define the realisability relation as a relation between potential realisers, viz., OTM programs with parameters, and formulas in the infinitary language of set theory L ∈ ∞,∞ .

Definition 14.
A potential realiser is a tuple c, P consisting of an OTM-program c and a set P of ordinals.
Remark 15. In Kleene's classical realisability with Turing Machines for arithmetic, every element of the universe, i.e., every natural number, is computable. To make sure that our notion has the same power, we use OTMs with set parameters as potential realisers. OTMs with a single ordinal parameter can only compute every element of the universe in case that V = L, and OTMs without parameters can only compute countably many elements. The seeming imbalance of finite programs with arbitrary parameters could be resolved by moving to the equivalent version of OTMs that can run programs of transfinite length studied by Lewis [21] under the supervision of Benedikt Löwe and the second author.
As potential realisers are just OTMs with parameters, we can keep our conventions and write r(x) = y in case that r = c, P is a potential realiser such that c P (x) = y. Similarly, we say that a potential realiser r = c, P computes a function if the OTM running program c on parameters P computes that function.
To define the realisability relation, we subtly extend the infinitary language of set theory with a constant symbol for every set in the universe V. To simplify notation, and without creating any confusion, we use the same letters to denote sets and their corresponding constant symbols.
Definition 16 (Substitution of Contexts). Let x be a context of length α,X = X i | i < α be a sequence of length α, and ϕ be a formula in context x. Then ϕ[X/x] is the formula obtained by replacing the free occurrences of the variable x i in ϕ with the (constant symbol for the) set X i .
. The OTM-realisability relation is recursively defined as a relation between the class of potential realisers and the class of formulas in the infinitary language of set theory L ∈ ∞,∞ as follows: (i) r ⊥ is never true, (ii) r X = Y if and only if r computes a code-isomorphism for every pair of codes for X and Y , A formula ϕ is realised if there is a potential realiser c, P ϕ. In this situation, we will call c, P a realiser of ϕ.
OTM-programs do not necessarily give rise to functions from sets to sets because the result of a computation may depend on specific features of the code of a set. Consider, for example, a realiser r ∀x∃y(x = ∅ → y ∈ x). Intuitively, the realiser r must do the following: given a code for a nonempty x, compute the code for a set y ∈ x. A simple implementation of this would be to search through the code of x until the first element of x is found (if there is any) and return the code for this element. However, there are obviously codes c 0 and c 1 of {0, 1} such that r(c i ) returns a code of i for i < 2. This shows that realisers may make use of specific features of our codes and give rise to multi-valued functions. In conclusion, it is natural to consider the following restricted notion of realisability in which realisers cannot make use of the features of specific codes.
Definition 18. We obtain uniform realisability by restricting the class of potential realisers to uniform OTMs.
As we will see in Theorem 21, if V = L, then the notions of uniform realisability and realisability coincide. On the other hand, if V = L then the two notions may differ. Indeed, by Theorem 51 there is a model of set theory in which the previous example provides a formula which is realised but not uniformly realised.

Basic Properties of OTM-Realisability.
We are now ready to establish some basic properties of OTM-realisability. First, we simplify the conditions for set-membership and equality in our definition of realisability.
Lemma 19. Let X and Y be sets.
Proof. For (i), the left-to-right direction follows from the definition of the realisability relation and Lemma 10. For the right-to-left direction assume that X = Y . Let a and b two codes for X based on the pre-codes A and B, respectively. Let c be a code for a program that returns the code of the algorithm Decode(·, ·, ·) from Lemma 11 and the ordinal Decode(a, b, ρ a ). We will show that c, ∅ X = Y . To this end, we define f (α) = Decode(a, b, α) for every α ∈ essdom(a). It suffices to show that f is a bijection from essdom(a) to essdom(b) to see that it is a code-isomorphism.
First, to see that f is an injection, let α ∈ essdom(a).
This concludes the proof of (i).
For (ii), first assume that there is a realiser c, P X ∈ Y . Let a and b be any two codes of X and Y , respectively. By definition of the realisability relation , the program c computes an ordinal α such that d b (α) = X and a realiser of X = d b (β) so the claim follows from the previous case. For the right-to-left direction it is enough to note that, using Decode(·, ·, ·), one can easily compute the ordinal α such that d b (α) ∈ d b (ρ b ) and the realiser of X = d b (α). This concludes the proof of (ii).

Lemma 20.
There is an OTM-program P min such that, for every constructible code a of a set X ∈ L, P min (c) computes the < L -minimal code of X, where < L is the canonical well-ordering of L.
Proof. P min works by successively writing codes for all constructible levels on the tape (see Koepke [19] for the details on how an OTM can write codes for levels of the constructible hierarchy). For each such level, it checks whether it contains a code for the set coded by a (i.e., X). As soon as such an L-level L α has been found, it searches through L α in the < L -ordering to determine the < L -minimal such code and write it to the output tape.
Theorem 21. If V = L then the following statements are equivalent: (i) ϕ is realised; (ii) ϕ is uniformly realised.
Proof. Clearly, if a statement ϕ is uniformly realised, then it is realised.
For the reverse direction, suppose that ϕ is realised, and that c, P realises ϕ. We may assume inductively that the statement holds for all subformulas of ϕ; we also note that the only point in which the definitions of realiser and uniform realiser differ is in the case of quantification, so that we can assume without loss of generality that ϕ is (i) ∀xψ or (ii) ∃xψ for some formula ψ.
In these cases, in order to obtain a uniform realiser from the plain realiser c, P , we simply start by applying P min to the given set before passing it over to c, P . In this way, all codes for sets will be replaced by the corresponding < L -minimal codes before further processing, so that the results of the computations will become independent of the choice of codes. Proof. The proof is an induction on the complexity of ϕ(x). The cases where ϕ is "X ∈ Y " or "X = Y " follow from Lemma 19. If ϕ = ⊥, then the claim is trivial because ⊥ is both never realised and false. The case for implication follows directly from the induction hypothesis and the definitions.
If ϕ(x) = β<γ ϕ β , assume that c, P uniformly realises β<γ ϕ β [X/x]. Then c is the code of a program that computes an ordinal β < γ and a realiser of ϕ β [X/x]. By the induction hypothesis, ϕ β [X/x] is true and, therefore, the disjunction ϕ is true as well. If β∈γ ϕ β [X/x] is true, then ϕ β [X/x] is true for some β < γ. By induction hypothesis, ϕ β [X/x] is realised by some potential realiser c ′ , P ′ . Let P be a code for the pair β, c ′ , P ′ , and c be a code for a program that given 0 as input just returns P . Then c, P uniformly realises ϕ[X/x].
If ϕ(x) = β<γ ϕ β , assume that c, P uniformly realises β<γ ϕ β . Then c codes a program that, given an ordinal β < γ, computes a realiser of ϕ β [X/x]. Hence, each formula ϕ β [X/x] is realised and, by induction hypothesis, true. In conclusion, the conjunction is also true. We prove the converse by contradiction. Suppose that β<γ ϕ β [X/x] is true but not realised. This means that there is a β < γ such that ϕ β [X/x] is not realised. By induction hypothesis, ϕ β [X/x] is false. A contradiction.
Assume that ϕ(x) = ∃ 1 yψ. If c, P uniformly realises ϕ[X/x], then c returns the code of a program with parameter that returns, on input 0, a code for a set Y and a realiser of ψ[Y /y][X/x]. By the induction hypothesis, ψ[Y /y][X/x] holds and, therefore, ϕ is true. On the other hand, if ϕ[X/x] is true, then there is a set Y such that ψ[Y /y][X/x] is true and, by induction hypothesis, there is a realiser c ′ , P ′ of ψ[Y /y][X/x]. Let P encode the realiser a, c ′ , P ′ , where a is a code for Y , and let c be the code of a program that copies the parameter to the output tape. It is not hard to see that c, P uniformly realises ϕ[X/x] as desired.
Finally, let ϕ(x) = ∀ 1 y ∈ x j ψ for some j < ℓ(x). Assume that c, P uniformly realises ϕ[X/x]. Then c is a program that, given P and a code for a set Y as input, returns a code for a realiser of Y ∈ X j → ψ[Y /y][X/x]. So, by induction hypothesis for every Y ∈ X j we have ψ[Y /y][X/x] as desired. For the right-to-left direction, assume that ϕ[X/x] is true. By induction hypothesis, for every Y ∈ X j there is a realiser c Y , PȲ of ψ[Y /y][X/x]. Let f : X j → N × On be the function that maps Y to the realiser c Y , P Y . Let P be a code for the function f (as a list of codes for the pairs a, c Y , P Y where a is a code of Y ), and let c be the code of a program that, given the code of Y ∈ X j , searches in P the pair a Y , c Y , P Y and copies c Y , P Y to the output tape. The pair c, P is a uniform realiser of ϕ. Indeed, given a code for Y ∈ X j the program coded by c with parameter P returns a code for a realiser of ψ[Y /y][X/x], moreover the output of the machine is independent from the specific coding ofX, so the realiser is uniform.
Lemma 22 can be extended to Σ ∞ 1 -formulas. To prove this, we need the following lemma. Recall that "x ∈ y", where x is a context-variable and y a set-variable, is an abbreviation as introduced in Section 2.1. The following lemma justifies this abbreviation semantically. Proof. For the right-to-left direction assume thatX ∈ Y . Let µ = ℓ(X) = ℓ(X). SinceX is a function with domain ℓ(X), Lemma 22 implies that the following sentence is realised by some s: Given a code of a sequenceX an OTM can easily compute a code for ℓ(X) because ℓ(X) = dom(X). Let r be a program that returns X , r ′ on input 0, where r ′ is a program that returns ℓ(X), r ′′ on input 0 with r ′′ a program such that r ′′ (0) = X , s . Then r realises ( For the left-to-right direction, assume that (x ∈ y)[X/x][Y /y] is realised by some program r. Then r is such that r(0) = F, r ′ , where r ′ is a program such that r ′ (0) = (D, r ′′ ), and r ′′ is a program such that r ′′ (0) = Z , s and s realises By Lemma 22, it follows that F =X and F ∈ Y . Therefore,X ∈ Y as desired. Proof. This result is a variation on a Lemma of Koepke [19,Lemma 4] for infinitary formulas. The proof is an induction on the complexity of the formula ϕ(x). We already provided the algorithms for atomic formulas in Lemma 11.
If ϕ(x) = ¬ψ(x), then the program computes the truth value of ψ(X) and flip the result. If ϕ(x) = β<α ψ β , then the program recursively computes the truth values ψ β for every β < α. The program outputs 1 if one of the recursive instances stops with 1; it outputs 0 if after the search is done none of the instances halted with 1. A similar procedure works for .
If ϕ(x) = ∃y ∈ x j ψ for some j < ℓ(x) and a ∆ ∞ 0 -formula ψ, then the program goes through the sequencesȲ in X j and for each of them recursively computes the truth value of ψ[Ȳ /y][X/x]. If the program finds aȲ on which the recursive call returns 1, then it returns 1, otherwise it returns 0. A similar proof works for ∀.

Lemma 26 (Universal Realisability Program).
There is an OTM-program Φ that takes codes of a sequenceX and an infinitary ∆ ∞ 0 -formula ϕ as input and returns the code of a realiser of ϕ[X/x] whenever ϕ[X/x] is realised. The same holds if we substitute realisability with uniform realisability. Moreover, if V = L then the statement is true for infinitary Σ ∞ 1 -formulas.
Proof. We give an informal description of the program Φ that computes the realisers. The program first checks the main operator of the input-formula and then proceeds as follows: If ϕ is "X ∈ Y " or "X = Y ", then the program just returns the codes of the algorithms described in Lemma 11 to compute a realiser of ϕ. If ϕ = ⊥ then the program can just return anything since ⊥ is never realised.
If ϕ = β∈γ ϕ β , then proceed as follows. By Theorem 25, the ∆ ∞ 0 -satisfaction relation is computable by an OTM. For every sentence ϕ β [X/x] the program Φ checks whether the sentence is true or not. When it finds a β such that ϕ β [X/x] holds, Φ stops the search and returns c, P where P is a code of X, and c is a code of a program that returns β and the output of a recursive call of Φ on ϕ β andX.
If ϕ = β∈γ ϕ β , then the program returns the pair c, P where c is a code for Φ and P is a code for X.
If ϕ(x) = ∃y ∈ x j ψ for some j < ℓ(x) and some ∆ ∞ 0 -formula ψ, then the program returns c, P , where P is a code ofX and c is a code of a program that does the following: for every sequenceȲ ∈ X of length y, it checks whether ψ[Ȳ /y][X/x] holds. As soon as such aȲ is found, the program recursively calls Φ on ψ[Ȳ /y][X/x] and outputs a code forȲ and the result of the recursive call of Φ.
If ϕ(x) = ∀y ∈ x j ψ, then the program returns c, P where P is a code ofX and c is a code for a program that takes a sequenceȲ as input and P as parameter and runs Φ on ψ[Ȳ /y][X/x].
The correctness of the algorithm follows by an easy induction on ϕ using Lemma 24. Finally, if V = L, then we can treat unbounded existential quantification as follows: suppose that ϕ(x) = ∃yψ for some ∆ ∞ 0 -formula ψ. By a result of Koepke (implicit in [19] and explained in detail in

4.1.
Logic. In this section, we will show that our notion of realisability is sound with respect to the infinitary sequent calculus that was introduced by Espíndola [10]. In fact, Espíndola defines a calculus for the language L κ + ,κ for every cardinal κ. As we admit formulas of all ordinal lengths, we will show that OTM-realisability is sound with respect to these systems for every κ. A sequent Γ ⊢ x ∆ is an ordered pair of sets of formulas in the infinitary language of set theory L ∈ ∞,∞ , where x is a common context for all formulas in Γ ∪ ∆. The rules checked in Propositions 28-37 are given exactly as in Espíndola [10], Def. 1.1.1.

Definition 27.
Let Γ ∪ ∆ be a set of formulas in the infinitary language of set theory L ∈ ∞,∞ . A sequent Γ ⊢ x ∆ is realised if the universal closure of Γ → ∆ is realised. If A and B are sets of sequents, then the rule A B is realised if whenever all sequents in A are realised, then there is some sequent in B that is realised.
Note that a formula ϕ is realised if and only if the sequent ∅ ⊢ ϕ is realised. To simplify notation, we will write A B to denote the conjunction of both rules A B and B A . In many of the following soundness proofs, we will need to show that certain sequents Γ ⊢ x ∆ are realised, i.e., we have to find a realiser of the corresponding formula ∀x( Γ → ∆). In many cases these realisers will be independent of x. In such cases, we will, for the sake of simplicity, directly describe a realiser r of Γ → ∆, when we really mean a realiser that, given anyX of length ℓ(x), outputs the realiser r.  1.1, 1(b)): where y is a string of variables including all variables occurring in the string of terms s.
Proof. The identity axiom is trivially realised by an OTM that implements the identity map. For the substitution rule, recall that by our definition, a realiser of ϕ ⊢ x ψ is in fact a realiser r ∀x(ϕ → ψ). We need to find a realiser t ∀y(ϕ[s/x] → ψ[s/x]), i.e., t takes as input some code for a sequence y of variables. To achieve this, find codes for the realiser r and the substitution s/x. Then let t be the OTM with parameters r and s/x that performs the following two steps: first, reorder the input y according to the substitution s/x, and then apply the parameter r to compute a realiser of For the cut rule, let r ∀x(ϕ → ψ) and s ∀x(ϕ → θ). For any given inputX, we have that r(X) ϕ(X) → ψ(X) and s(X) ψ(X) → θ(X), i.e., r(X) maps realisers of ϕ(X) to realisers of ψ(X), and s(X) maps realisers of ψ(X) to realisers of θ(X). Let t be the OTM that, given inputX, returns an OTM that given input u returns s(X)(r(X)(u)). Then t ∀x(ϕ(x) → ψ(x)). Proof. Finding a realiser of the first statement means finding a realiser of ∀x(⊤ → x = x), which is equivalent to finding a realiser of ∀x(x = x). This follows directly from the fact that the algorithm for equality presented in the proof of Lemma 19 is the same for any sets X and Y . The second statement follows in a similar way as the substitution rule of Proposition 28 using that, by the definition of realisability, realisers work on all codes of any given set.
Proof. The definition of realisability straightforwardly implies that both rules are realised: for the first rule observe that we can just extract a realiser of ϕ j from a realiser of i<κ ϕ i . For the second rule, combine the realisers r i ϕ → ψ i for i < κ into a parameter P and obtain a realiser of ϕ ⊢ x i<κ ϕ i by implementing an OTM program that returns the realiser of ϕ i on input i.
Proof. For the first statement, we need to realise the implication ϕ j → i<κ ϕ i . This can be done by an OTM that, given a realiser r j of ϕ j , returns an OTM that returns a tuple j, r j on input 0. For the second statement, code the realisers r j for ϕ i ⊢ x θ, i < κ, into a parameter P . Then, i<κ ϕ i ⊢ x θ is realised by the following algorithm implemented by an OTM: given a realiser s i<κ ϕ i , compute s(0) = i, t , such that t ϕ i and then return r i (t) by using the parameter.
Proof. We have to show two directions. For the first direction, top-to-bottom, let r ϕ ∧ ψ → η. Now, we construct a realiser of ϕ → (ψ → η) as follows: given a realiser r ϕ for ϕ, output the OTM that, given a realiser r ψ for ψ, combines it with r ϕ to obtain a realiser r ϕ∧ψ ϕ ∧ ψ. Then apply r(r ϕ∧ψ ) η.
For the other direction, assume that r ∀x(∃yϕ → ψ). We construct a realiser t ∀xy(ϕ → ψ). So let sequencesX,Ȳ be given, and assume that we have a realiser s ϕ(XȲ ). We can compute a realiser r ∃ for ∃yϕ(X) as the OTM that returnsX and s. We can then return (r(X))(r ∃ ), which is a realiser of ψ.
Proof. For the top-to-bottom-direction, assume that r ∀xy(ϕ → ψ). We have to find a realiser t ∀x(ϕ → (∀yψ)). IfX is a sequence and r ϕ a realiser of ϕ, then the OTM that takes someȲ as input and returns r(XȲ )(r ϕ ) is a realiser of ∀yψ. Call this realiser rX . Then, the OTM which takes someX as input and then returns rX is a realiser of ∀x(ϕ → ∀yψ).
Proof. It is enough to construct an OTM that transforms a realiser of i<κ (ϕ ∨ ψ i ) into a realiser of ϕ ∨ i<κ ψ i . So let r i<κ (ϕ ∨ ψ i ). The OTM proceeds as follows: first, search for a realiser of ϕ by going through all i < κ. As soon as a realiser of ϕ is found, we are done. If no realiser of ϕ is found, then we have, in fact, realisers for every ψ i for i < κ and can therefore construct a realiser of i<κ ψ i . Recall that a bar is an upwards-closed subset of a tree that intersects every branch of the tree.
holds whenever γ is a cardinal strictly below κ + , where B denotes the subset of γ <κ that contains the minimal elements of some bar of the tree γ κ and, for f ∈ B, δ f denotes the level of f .
Proof. Our goal is to construct a realiser of i.e., we have to construct an OTM that computes a realiser of ϕ ∅ from a realiser of f ∈B β<δ f ϕ f | β+1 .
In doing so, we can use realisers of the antecedents of the rule: we denote by r 1 a realiser of the first antecedent and by r ⊢ 2 a realiser of the forward direction of the second antecedent. We claim that Algorithm 1 describes a desired realiser, and we will now prove that it terminates with a realiser of ϕ ∅ when run on a realiser of f ∈B β<δ f ϕ f | β+1 . In fact, we will prove the contrapositive. So suppose that the OTM described by Algorithm 1 does not terminate, i.e., it either loops or crashes.
First, assume that the machine loops. As our algorithm constructs r (−) in a monotone way, the partial function r (−) must stabilise before the loop. Hence, the algorithm must loop through lines 15 and 16: otherwise we would (eventually) still alter r (−) (lines [11][12][13] or contradict the well-foundedness of the ordinal numbers (lines 5-9). However, looping through lines 15 and 16 means that we build up a sequence f that will eventually reach length κ. But then the operation of selecting a direct successor in line 15 will crash, a contradiction to the machine's looping.
Secondly, assume that the machine crashes. It is easy to see that this must happen in line 15 as all other operations are well-defined (using the case distinctions and assumptions on r, r 1 and r ⊢ 2 ). A crash in line 15, however, will only occur if f has reached length κ. This means that we have constructed a branch through γ <κ that does not intersect the bar B, a contradiction.
Algorithm 1: Walking(r), walking through the tree if f is of limit length β then 8 Calculate r ⊢ 2 (r f ) and extract from this r f |α for some α < β. 9 Set f := f | α . if g ∈ dom(r (−) ) for all direct successors g of f then 12 Combine the r g into a realiser r ′ g∈γ β+1 ,g| β =f ϕ g .
14 else 15 Select a direct successor g ∈ γ <κ of f such that r g is undefined. 16 Set f := g. 17 Return r ∅ .
Proposition 37. The transfinite transitivity rule (Espíndola, [10], Def. 1.1.1, 10) is realised: Here B ⊆ γ <κ consists of the minimal elements of a given bar over the tree γ κ , and the δ f are the levels of the corresponding f ∈ B.
Proof. The proof of this proposition is a simplification of the proof of Proposition 36: again, we need to search through the tree until we hit the bar. This time, however, we are starting from a realiser of ϕ ∅ . Then use the first assumption to compute realisers at successor levels and use the second assumption to compute realisers at limit levels. By the definition of the bar B, this procedure must at some point reach some node contained in B, and we have found the desired realiser. Note that this procedure does not require any backtracking as in the previous proposition and, therefore, the formalisation of the desired OTM is straightforward.
Espíndola's [10] system of κ-first-order logic is axiomatised in the sequent calculus by the rules mentioned in Propositions 29 to 37.
Corollary 38. OTM-realisability is sound with respect to κ-first-order logic for every cardinal κ. The same holds if we substitute realisability with uniform realisability.
Proof. This is just the combination of Propositions 29 to 37.
Before moving on to questions of which set theory is OTM-realised in the next section, we will take a brief moment to note a few logical properties of our notion of realisability.
Proposition 39 (Semantic Disjunction and Existence Properties). If ϕ∨ψ is realised, then ϕ is realised or ψ is realised. More generally, if i<κ ϕ i is realised, then there is some i < κ such that ϕ i is realised.
If ∃ α xϕ(x) is realised, then there is a sequenceX such that ϕ(X) is realised.
Proof. This follows from the definition of realisability for disjunctions and existential quantifiers.
We say that a formula of propositional logic is (uniformly) OTM-realisable if every substitution instance of the formula is (uniformly) OTM-realisable.
Theorem 40. There is a formula of propositional logic which is uniformly OTM-realisable but not a consequence of intuitionistic propositional logic.
Proof. Let ϕ be the formula ¬p ∨ ¬q. The Rose formula (due to Rose [32]) is the following sentence: The Rose formula is OTM-realisable but it is not a consequence of intuitionistic propositional logic. This is shown in just the same way as in the arithmetical case (see Plisko's survey [27, Section 6.1]).
A similar result holds with respect to first-order logic.
Theorem 41. Each substitution instance of the following Markov's principle, formulated in first-order logic, is uniformly OTM-realisable: However, this formula is not a theorem of intuitionistic first-order logic.
Proof. The realisability of every instance of Markov's principle follows by providing an OTM that executes a bounded search for a witness of P (x) within some big enough parameter V α . A standard argument using Kripke semantics shows that Markov's principle is not a theorem of intuitionistic firstorder logic. 5 These two results show that the propositional and first-order logics of OTM-realisability are stronger than intuitionistic propositional and intuitionistic first-order logic, respectively.

Set Theory.
In this section, we will study the realisability of various axioms of set theory. Some of these statements were already proved for uniform realisability of finitary logic by the first author [6]; we include their proofs here for the sake of completeness. We will begin by proving that our notion of uniform realisability realises the axioms of the infinitary version of Kripke-Platek set theory (for the finite version, see also [6,Proposition 9.4.7]).
The axiom schema of full collection is obtained from ∆ ∞ 0 -collection by allowing arbitrary infinitary formulas.
5 Take the Kripke model based on the frame K := {v, w} with v < w and domains Dv := {a}, Dw := {a, b}, and valuate the predicate P to be true only of the element b at node w. It is then straightforward to check that v ∀x(P (x) ∨ ¬P (x)), v ¬¬∃xP (x) but v ∃xP (x).
Theorem 43. The axioms of infinitary Kripke-Platek set theory are uniformly realised. Moreover, the axiom schema of full collection is uniformly realised.
Proof. It is straightforward to construct realisers for the axioms of empty set, pairing, extensionality and union. For each of the remaining axioms, we will now give an informal description of an algorithm that realises it.
First, consider the axiom schema of induction. For every infinitary formula ϕ(x, y) we have to show that the corresponding instance is realisable: It is sufficient to describe a program c that takes a code a for aȲ , a code b for X and a realiser r for ∀x(∀z ∈ xϕ[z/x]) → ϕ as input, and computes a realiser ϕ[X/x]. A realiser of the corresponding instance of the induction axiom is then obtained through currying: transform c(·, ·, ·) into λa.λb.λr.c(a, b, r).
We will describe a procedure to obtain a realiser of ϕ[X/x,Ȳ /y] by recursively building up realisers in the transitive closure of X. To do so, the program c uses two auxiliary tapes, Done and Realisers, to keep track of its progress. The tape Done is used to keep track of the sets Z in the transitive closure of X, for which a realiser of ϕ[Z/x,Ȳ /y] has already been computed. Meanwhile, Realisers is used as a queue on which the realisers for all sets in Done are saved. Now, until all members of the essential domain of b are in Done, the program keeps running through the elements of the essential domain of b. For each α in the essential domain of b, the program checks whether all its members are contained in Done. If so, the program uses the realisers contained in Realisers to compute a realiser of ∀z ∈ d b (α)ϕ[z/x,Ȳ ]. Note that this can easily be done by using the pair c ′ , {b, f } , where f is a code of the current content of Realisers and c ′ is the program that searches through f for a realiser of the set whose code is given as input. Then the program computes r(d) to obtain a realiser r ′ of ϕ[d b (α)/x,Ȳ /y] and saves this pair α, r ′ in Realisers. Once realisers for every element of the essential domain of b are computed, the program computes a realiser of ϕ[X/x,Ȳ /y] in the same way and returns it.
Second, consider the axiom schema of ∆ ∞ 0 -separation. By Lemma 24 and Lemma 26 it is enough to show that for every X andȲ , the set {Z ∈ X | ϕ[Z/x,Ȳ /y]} is computable. But this follows from Theorem 25 and Lemma 11.
LetZ be a sequence coded by some a. It suffices to show that there is a program that given realiser r of ∀x∃yϕ, and a code b for a set W , computes a code for a set W ′ such that ∀x ∈ W ∃y ∈ W ′ ϕ. Our program uses an auxiliary queue Codes. The program searches through b and for every α uses r to compute a code for a set Y such that ϕ[d b (α)/x, Y /y,Z/z] is realised and saves the computed code in Codes. The claim follows by Lemma 11.
The proof of the following lemma is analogous to a proof by the first author ([6, Lemma 8.6.3]), which, in turn, followed the "cardinality method" of Hodges, see Hodges [13], Lemma 3.2.
Proof. Assume κ ≥ ω and that Φ(s) halts. Note that Φ(s) cannot be longer than the halting time λ of Φ on input s. Indeed, Φ will need at least one step in order to compute each bit of the output.
Let ϕ(x, y, z) be the ∆ ω 0 -formula expressing that x is the computation of the program y on input z. Consider the Σ ∞ 1 -sentence ∃xϕ(x, Φ, s) expressing the fact that there is a computation of Φ on s. Let δ = max{ℵ 0 , κ, λ}. Note that L δ + [s] |= ∃xϕ(x, Φ, s). Indeed, L δ + [s] contains the computation σ of Φ over s, and ϕ is absolute between transitive models. Now, let H be the Skolem hull of κ ∪ {s} in L δ + [s]. Then, H has size κ and so does the transitive collapse M of H. But then M is a transitive model of ∃xϕ(x, Φ, s). Therefore, there is σ ′ ∈ M such that M |= ϕ(σ ′ , Φ, s), and since ϕ is a ∆ ∞ 0 -formula it is absolute between transitive models of set theory. Therefore, σ ′ is the computation of Φ with input s of size at most κ. Finally, λ ≥ κ and by the Condensation Lemma, Lemma 45 ( [6,Proposition 9.4.3] ). The axiom of power set is not realised.
Proof. A realiser of the power set axiom is a pair c, P where c is the code of a program with parameter P that takes a code of a set X as input and returns a code for ℘(X). Now let a be any code for the set P . By Lemma 44, the output of program c with input a and parameter P has size <|P | + . Therefore, the result of the computation cannot be a code of ℘(P ).
Corollary 46. There are sentences ϕ and χ in the language of set theory such that ϕ → χ is uniformly realised but ϕ → χ is false.
Proof. Let ϕ be the power set axiom and χ be the sentence ∃x x = x. It is then trivial that ϕ → χ is uniformly realised by the previous Lemma 45. However, ϕ → χ is false since the power set axiom holds and ∃x x = x is false.
Proposition 47. The infinity axiom is uniformly realised.
Proof. The infinity axiom is a Σ ∞ 1 -formula and, therefore, uniformly realised by Lemma 24.
The following theorem is a variant of a result of the first author ([5, Proposition 3]).
Proof. Let ϕ be the Π 2 -statement ∀x∃yψ(x, y), where ψ is a ∆ 0 -formula. A realiser of ϕ must consist in an OTM that, given a constructible set X, computes some constructible set Y and a realiser r for ψ(x, y)[X/x, Y /y]. Therefore, it is enough to show that there is a program that for every X computes a set Y such that ψ(x, y)[X/x, Y /y]. Split the tape into ω × On many disjoint portions. Let (P i ) i ∈ ω be a computable enumeration of Turing machine programs. On the i, α -th portion of the tape, run P i on input α. In this way, every OTM-computable set will eventually be computed on one of the portions. As the OTM-computable sets coincide with the constructible sets (cf. Koepke [19]), all constructible sets will eventually be on a portion of the tape. While producing all the constructible sets, our program uses Theorem 25 to look for a Y such that ψ(x, y)[X/x, Y /y] and stops when it finds one. We note that the realiser is uniform since the code of Y only depends on the OTM enumeration of L.
Proof. Let χ(y, y ′ ) be the formula stating that y ′ is the power set of y. Let ϕ(x, y) = ∃y ′ χ be the formula that ignores x and expresses the fact that the power set of y exists. Further assume that r = c, P realises the corresponding instance of separation: Let Y be an arbitrary set, let a be a code for Y , b be a code for ∅ and c a code for {∅}. Then r(a)(c) is a realiser of: i.e. r(a)(c)(0) = d, s , where d is a code for a set and s a realiser. Since the formula ∃y ′ χ[Y /y] is trivially realised by taking the power set of Y as a parameter, it follows that the set Z coded by d is non-empty and, in fact, Z = {∅}. Let t ∅ ∈ {∅}. It follows that s(b)(0)(t)(1) ϕ[Y /y], i.e. s(b)(0)(t)(1) computes a code for the power set of X. This is in contradiction to Lemma 45.
Recall that a choice function f on X satisfies f (Y ) ∈ Y for all Y ∈ X. The axiom of choice is the principle that there is a choice function on every set X if X does not contain the empty set. The well-ordering principle states that every set is in bijection with an ordinal. We call weak axiom of choice the sentence ∀X(∀Y ∈ X(∃Z(Z ∈ Y )) → ∃f (f (Y ) ∈ Y )).
Theorem 50. The weak axiom of choice is uniformly realised.
Proof. For each non-empty Y ∈ X, let r Y be a uniform realiser of ∃Z(Z ∈ Y ). Then r Y = a Y , s Y , where a Y is the code of an element Z Y of Y . These realisers can be combined into a function f with f (Y ) = Z Y to obtain a realiser of the weak axiom of choice.
Despite the fact that the axiom of choice and the weak axiom of choice are classically equivalent, the first one is considerably stronger from the point of view of realisability.
Theorem 51. The axiom of regularity, the axiom of choice, and the well-ordering principle are realisable. Moreover, it is consistent that these principles are not uniformly realisable.
Proof. Note that the ∈-minimal elements of a set are computable. For this reason, the axiom of regularity can be realised by returning a code for the first ∈-minimal element that the machine finds. Similarly, for the axiom of choice, the machine just searches through the code of the input family and for each set in the family output the first element it finds. Finally, the well-ordering principle is realisable because every code of a set induces a well-ordering on the set which can be computed and returned by an OTM. Note that all these algorithms are not uniform because their output crucially depends on the specific codes of the input sets.
To prove the second part, note that a uniform realiser of the axiom of regularity can easily be used to uniformly realise the axiom of choice by picking out an (∈-minimal) element of each set in the given collection. Similarly, a uniform realiser of the well-ordering principle can be used to uniformly realise the axiom of choice (see [6, Section 8.6.1]).
Finally, note that a uniform realiser of the axiom of choice would provide a class function F such that F (X) ∈ X for every set X. By Rubin [33, p.201] this statement is equivalent to the axiom of global choice in Von Neumann-Bernays-Gödel set theory. Therefore the consistency of the non-uniformly realisability of the axiom of choice follows by the fact that there are models of ZFC where the axiom of global choice fails, see, e.g., [1].
Note that by Theorem 21 if V = L then the axiom of regularity, the axiom of choice, and the well-ordering principle are all uniformly realisable.
We end this section with a few comments on the realisability of intuitionistic and constructive set theories. Friedman's and Myhill's IZF has the axioms of ZF but replacing foundation with ∈-induction and replacement with collection; we saw that not all of the axioms of IZF are OTM-realisable. Aczel's CZF has the axioms of extensionality, pairing, union, empty set, infinity, bounded separation, strong collection, the subset collection scheme and the axiom of set induction. Of these, only the subset collection scheme is not OTM-realised. As we have seen, all axioms of Kripke-Platek set theory are OTM-realisable.

Proof-Theoretic Application: The Admissible Rules of IKP
In this section, we will apply our realisability techniques to answer a recent proof-theoretic question of Iemhoff and the third author concerning finitary intuitionistic Kripke-Platek set theory IKP (see [16, Question 66]). The theory IKP was introduced by Lubarsky [22] to study admissible sets in the context of intuitionistic set theory. In our context, IKP is obtained by restricting infinitary Kripke-Platek set theory to the standard finitary language of set theory, and then adding the infinity axiom (see Proposition 47).
For the rest of this section, we restrict our attention to the finitary language of set theory. If T is a theory, then a map σ from the set of propositional variables to the set of sentences in the language of T is called a T -substitution. Given a propositional formula A, we write A σ for the formula obtained from A by replacing each propositional letter p with the formula σ(p).
Definition 52. A propositional rule is an ordered pair (A, B) of formulas in propositional logic, usually written A B . A propositional rule A B is called admissible for a theory T if for all substitutions σ of propositional letters for sentences in the language of T , we have that T ⊢ A σ implies that T ⊢ B σ . A propositional rule A B is called derivable for a theory T if T ⊢ A σ → B σ for all substitutions σ of propositional letters for sentences in the language of T .
In contrast to the case of classical propositional logic, it is possible for intuitionistic and intermediate logics to have admissible rules that are not derivable. The structure of the admissible rules of intuitionistic propositional logic has been investigated since the 1970s. Rybakov [34] proved that the set of admissible rules of IPC is decidable, answering a question of Friedman [11,Question 40]. Visser [36] later showed that the propositional admissible rules of Heyting Arithmetic are exactly the admissible rules of intuitionistic propositional logic, and Iemhoff [15] provided an explicit description of the set of admissible rules (a so-called basis).
Recently, Iemhoff and the third author [16] analysed the structure of propositional and first-order logics of intuitionistic Kripke-Platek set theory IKP, and showed, in particular, that the propositional logic of IKP is IPC. 6 It follows that the set of propositional admissible rules of IKP is included in the set of propositional admissible rules of IPC. This suggests the question of whether the converse inclusion holds as well ([16, Question 66]). We will now show that this is indeed the case, and hence, that the propositional admissible rules of IKP are exactly the admissible rules of IPC.
For technical purposes, we first need to consider a certain conservative extension of IKP (and show, of course, that it is indeed conservative). To keep all languages set-sized, we will from now on work with realisability over V κ for some inaccessible cardinal κ. Hence, all notions of realisability are restricted to V κ , and all realisers must be elements of V κ as well. Recall that the elementary diagram of V κ contains the statements c a ∈ c b whenever a ∈ b, and c a = c b whenever a = b.
Definition 53. Let T be an extension of IKP in the language of set theory. The theory T * is obtained from T by extending the language of IKP with constant symbols for every element of V κ and adding the elementary diagram of V κ to IKP.
Lemma 54. Let the theory T be an extension of IKP. Then T * is conservative (in the constant-free language of set theory) over T .
Proof. Suppose that T * ⊢ ϕ, where ϕ is a sentence in the language of IKP. By compactness we can assume that j<m ψ j ∧ i<n χ i ⊢ ϕ for ψ j ∈ IKP and χ i statements of the form c a ∈ c b or c a = c b . By the implication rule (see Proposition 32), we obtain that i<n χ i ⊢ j<m ψ j → ϕ. Now the formula in the consequent of the sequent is in the language without constants, and the left side contains a finite set of constants c i . We are therefore justified in (repeatedly) applying the existential rule (see Proposition 33) to get ∃c a0 ∃c a1 . . . ∃c a k i<n χ i ⊢ j<m ψ j → ϕ. Now the whole sequent is in the usual language of set theory, without constants. Applying the converse implication rule (see Proposition 32), we get j<m ψ j ∧ ∃c a0 ∃c a1 . . . ∃c a k i<n χ i ⊢ ϕ.
In this situation it suffices to show that X := ∃c a0 ∃c a1 . . . ∃c a k i<n χ i is a consequence of IKP, and thus a consequence of T , to conclude that IKP ⊢ ϕ.
To this end, first observe that X describes a finite cycle-free directed graph because X encodes the ∈-relation between finitely many sets in some V κ (which is, of course, well-founded by the foundation axiom). Hence, to see that X is a theorem of IKP it suffices to see that every such finite graph can be modelled by using the axioms of empty set, pairing and union. Our next step is to adapt the technique of glued realisability to our situation (see van Oosten's survey [25] for the arithmetical version).
Definition 55. Let T be an OTM-realised theory. We then define the T -realisability relation, T by replacing conditions (iv) and (viii) of Definition 17 with the following clauses: (iv') r T ϕ → ψ if and only if T * ⊢ ϕ → ψ and for every s T ϕ we have that r(s) T ψ, and, (viii') r T ∀xϕ if and only if T * ⊢ ∀xϕ and r(X) T ϕ[X/x] for every set X.
Note that we do not need to redefine condition (viii) in full generality for transfinite quantifiers as we are restricting to the finitary language in this section.
Lemma 56. Let T be an OTM-realised theory extending IKP, and ϕ be a formula in the language of T * . Then, T * ⊢ ϕ if and only if there is a realiser r T ϕ.
Proof. The forward direction is essentially proved in the same way as the fact that realisability is sound with respect to intuitionistic logic (see Corollary 38) and that all axioms of T are realised, paying attention to the fact that the new clauses (iv') and (viii') do not cause any problems. The backward direction is proved with a straightforward induction on the complexity of the formula ϕ (in the extended language of T * ), using the definition of T * and Lemma 19 for the atomic cases.
Proposition 57. Let T be an OTM-realised theory extending IKP, and ϕ be a formula in the language of T . Then, T ⊢ ϕ if and only if there is a realiser r T ϕ.
Proof. This is a direct consequence of the previous Lemmas 54 and 56.
This concludes our preparations and we are now ready to apply this to some proof-theoretic properties.
The restricted Visser's rules {V n } n<ω are defined as follows: Denote by V a n the antecedent and by V c n the consequent of the rule. We will make use of the following theorem, which is a direct corollary of Iemhoff's results [14].
Theorem 59 (Iemhoff, [14, Theorem 3.9, Corollary 3.10]). If the restricted Visser's rules are propositional admissible for a theory T with the disjunction property, then the propositional admissible rules of T are exactly the propositional admissible rules of intuitionistic propositional logic.
Theorem 60. The propositional admissible rules of IKP are exactly the admissible rules of IPC.
Proof. By Theorem 59 and the fact that IKP has the disjunction property (see Theorem 58) it suffices to show that the restricted Visser's rules are propositional admissible. To this end, let σ be a substitution. We will write ϕ i for σ(p i ), and ψ j for σ(q j ). Now, assume that IKP ⊢ (V a n ) σ , i.e., spelling this out, Denote the antecedent of (V a n ) σ by δ. We will now consider the theory IKP + δ. There are two cases. In the first case, suppose that there is a realiser r IKP+δ δ. By assumption, IKP ⊢ (V a n ) σ , and hence, with Proposition 57.(i), it follows that there is a realiser s IKP (V a n ) σ , and thus s IKP+δ (V a n ) σ . Hence, s(r) IKP+δ ϕ n+1 ∨ϕ n+2 . It follows that ϕ n+k is IKP+D σ -realised for some k < 2. By Proposition 57.(ii), we have IKP+ δ ⊢ ϕ n+k , and with the deduction theorem and some propositional reasoning, we conclude that IKP ⊢ (V c n ) σ . In the second case, suppose that δ is not IKP + δ-realisable. By the definition of IKP + δ-realisability, this means that there is some i, 1 ≤ i ≤ n, such that ϕ i → ψ i is not IKP + δ-realised. This means that IKP + δ ⊢ ϕ i → ψ i , or that for every potential realiser r, there is a realiser s ϕ i such that r(s) ψ i . As ϕ i → ψ i is a consequence of δ, it follows, in particular, that there is a realiser r IKP+δ ϕ i . By Proposition 57.(ii), we have that IKP + δ ⊢ ϕ σ i . An application of the deduction theorem yields IKP ⊢ δ → ϕ i . In this situation, it is immediate that IKP ⊢ (V c n ) σ . In conclusion, we have shown that IKP ⊢ (V a n ) σ implies that IKP ⊢ (V c n ) σ for every substitution σ. This shows that Visser's rule V n is admissible for IKP for every n < ω.