The previous lesson reduced the minimal pair theorem to requirements , and , and showed that the strategy for below depends on the outcome of , which the construction cannot compute. The tree method assigns to each requirement one strategy for each possible guess about the outcomes of the strategies above it. At every stage, the construction computes a current guess, a finite path through the tree, and only runs the strategies along it. The true path, the leftmost path visited infinitely often, consists of the strategies whose guesses are correct; the verification shows that they meet their requirements.
2.1 The tree and the priority order
Let , ordered by . We list the requirements as , so that the requirement of index is , that of index is , and that of index is .
- The tree of strategies is the set of finite strings such that whenever is not a multiple of . A string is a node, and the node works for the requirement of index : it is an -node if , and so on.
- For nodes and , is to the left of , written , if there is with , and .
- has higher priority than if or .
The -nodes have two outcomes, the other nodes only the outcome . A node with guesses that the -node has infinitely many expansionary stages, and a node with that it has finitely many. For any two distinct nodes, either one is a prefix of the other, or one is to the left of the other; the priority order is a linear order on . Unlike the priority orders of finite injury arguments, it gives most nodes infinitely many nodes of higher priority: a node with the value at some -level has to its left every extension of .
2.2 The construction
Each node carries some data, which initializing the node resets.
- An -node has a record , a number or undefined. Initialization makes it undefined.
- An -node or -node may have a follower , and may be marked satisfied. Initialization cancels the follower and the mark.
A number is fresh at a stage if it is larger than the stage and than every number mentioned so far in the construction. Initially every node is initialized, and .
Stage . We define the current path , of length at most , by visiting nodes one after the other, starting with the root; when a node is visited with outcome , the next node to visit is . A node of length is not visited, and the stage also ends when a node acts. Let be the node visited.
- If is an -node, compute the length of agreement of and (Definition 1.4). The stage is -expansionary if is undefined or . In that case, set , and the outcome is ; otherwise the outcome is .
- If is an -node without a follower, it receives a fresh follower; the outcome is . If it has a follower , is not marked satisfied, and , then acts: is enumerated into , is marked satisfied, the stage ends, and . Otherwise the outcome is .
- -nodes are treated in the same way, with in place of .
At the end of the stage, initialize every node with . Then and are and with the element enumerated at stage , if any.
A node is visited at stage , and is an -stage, if , strictly. At each stage, at most one number is enumerated, at the very end, after all the computations of the stage have been examined. The construction is computable, so and are c.e. Followers are fresh, so distinct followers are distinct numbers, and a follower enters or only through the action of its own node. In particular .
The initialization rule replaces the explicit restraints of finite injury arguments. A node to the right of the current path has made a guess that the current stage refutes, at least for now: it loses its follower, and the next follower it receives is fresh, hence larger than every use of a computation examined so far.
2.3 The true path
The true path is the infinite sequence defined by induction: is the least such that is visited at infinitely many stages.
For every , the true path is defined at , and the node satisfies:
- is visited at infinitely many stages;
- holds for only finitely many ; in particular is initialized only finitely often;
- if is an - or -node, it acts only finitely often.
By induction on . The root is visited at every stage , and no path is to its left.
Suppose that satisfies items 1 and 2. The node is initialized only at the end of a stage with , so it is initialized finitely often. If is an - or -node, then between two initializations it acts at most once, since it is then marked satisfied; this gives item 3. Let be a stage after which never acts, nor is initialized, nor satisfies .
Case 1: is an - or -node. At every -stage , does not act and has length less than , so is visited. So , and satisfies item 1. A node to the left of is to the left of , since no node has the value at position ; this gives item 2.
Case 2: is an -node. At every -stage , is visited, where is the outcome of at . If the outcome occurs at infinitely many stages, , and a path to the left of is to the left of . Otherwise, , the node is visited at all -stages after the last -expansionary stage, and a path to the left of is either to the left of or extends ; both happen only finitely often.
Item 2 is the reason why the priority order puts every node to the left of above it. A node to the right of the true path may be initialized infinitely often, and act infinitely often, each time with a new follower: if extends while the true outcome of is , is initialized at every -expansionary stage. This is the infinite injury. It is harmless, because the requirement of is met by the node of the same level on the true path, and because the actions of only enumerate fresh numbers.
2.4 Verification
Every requirement and is met.
Let , the -node on the true path. By Lemma 2.3, is initialized finitely often and visited infinitely often. At its first visit after its last initialization, it receives a follower , which it keeps forever. If , at the first -stage with , is not yet marked satisfied, so it acts, and . If , then never enumerates , no other node does, and . In both cases . The argument for is the same.
The main lemma checks condition 2 of Lemma 1.6 for the -nodes of the true path.
Let , and let be a stage larger than such that, for , and no proper prefix of acts at stage . If are consecutive -expansionary stages, then or .
Let be a stage with at which some node acts, so that . We consider the position of relative to .
- is a proper prefix of , or : excluded by the choice of , since then in the second case.
- : impossible, since -nodes do not act.
- : then is visited at with outcome , so is -expansionary, and .
- or : since is -expansionary, , so , and is initialized at the end of stage . In particular , and the follower enumerated by was received after stage ; it is fresh, hence larger than .
So the only number below that may be enumerated during the stages is the follower of the node acting at stage , if any. It enters or , not both, and the other side does not change below .
Every requirement is met.
Let . By Lemma 2.3, the prefixes of act finitely often, and for finitely many ; so a stage as in Lemma 2.5 exists, and is not initialized after . Suppose that is total. By Proposition 1.5, applied to the infinite set of -stages after the last initialization of , there are infinitely many -expansionary stages. List those larger than as . The sequence is computable: run the construction and list the -expansionary stages after . Condition 1 of Lemma 1.6 holds since the record increases, and condition 2 by Lemma 2.5. By Corollary 1.7, is computable.
The sets and are c.e. By Lemma 2.4, they are not computable, and is non-empty: for an index with , the requirement puts a number into . Since , we have . By Lemma 2.6 and Lemma 1.3, every set computable in both and is computable.
2.5 Exercises
Show that the true path is computable in .
Solution
Given , if it is an -node, then if and only if is visited at infinitely many stages. The set of stages at which a node is visited is computable, uniformly in , so it is for a computable function . Hence is visited at infinitely many stages if and only if , which decides (Proposition 3.5 of “The Turing jump”). If is another node, . By induction on , computes .
Modify the construction so that and are, in addition, simple sets.
Solution
Put into at stage , and replace by the requirement “if is infinite, then ”. An -node , visited at stage , acts if and there is with and larger than the last stage at which was initialized: it enumerates the least such into , and the stage ends. Treat in the same way for , with numbers and , so that and .
A node initialized at the end of stage only enumerates numbers larger than at its later actions, so Lemma 2.5 still holds, with the same proof; Lemma 2.6 and Lemma 1.3 then give the minimal pair property. If is infinite, the -node on the true path, after its last initialization at stage , eventually sees an element of larger than and , and acts at the next -stage unless already. Finally, once some element of is in , no -node acts again, so each contributes at most one element to , and that element is larger than . Hence has at most elements, and is infinite. The same holds for .
2.6 Notes and references
The tree method was made explicit by Lachlan in the 1970s, and became the standard presentation of infinite injury arguments with Soare’s book; earlier proofs organized the same guesses implicitly, through the stages at which restraints are recomputed. Lempp’s lecture notes describe the hierarchy of priority arguments: finite injury arguments are -arguments, since can follow them, the tree arguments of this course are -arguments, since the true path is computable in , and -arguments use trees of strategies with more complex interactions.
- R. I. Soare, Recursively Enumerable Sets and Degrees, Springer, 1987, Chapters IX and XIV.
- S. Lempp, Priority arguments in computability theory, model theory, and complexity theory, lecture notes, University of Wisconsin, 2012.