A Turing degree d is said to be low for isomorphism if whenever two computable structures are d-computably isomorphic, then they are actually computably isomorphic. We construct a real that is 1-generic and low for isomorphism but not computable from a 2-generic and thus provide a counterexample to Franklin and Solomon’s conjecture that the properly 1-generic degrees are neither low for isomorphism nor degrees of categoricity.
A set A is low for a relativizable class if using it as an oracle does not reduce the class at all, that is, if . This term was first introduced in pure computability theory in 1972 with respect to Turing functionals [12]. Since then, lowness has been studied in “applied” subfields of computability theory such as algorithmic randomness [7] and computational learning theory [11], and it was studied for the first time in the context of computable structure theory by Franklin and Solomon [8]. Here, Franklin and Solomon defined the notion of lowness for isomorphism. We write that is d-computably isomorphic to () if there is an isomorphism from to that is computable from d.
[8] A degree d is low for isomorphism if for every pair of computable structures and , if , then .
Informally, d is low for isomorphism if, whenever it can compute an isomorphism between two computable structures, no oracle is actually necessary to do so because they are already computably isomorphic.
While Franklin and Solomon did not develop a full characterization of this notion, they obtained both positive and negative partial characterizations, mainly in terms of category and measure. We recall that a real A is n-generic if it either meets or strongly avoids every subset of ; that is, if for every such S, there is some such that either or no extension of σ is in S. A real is weakly n-generic if it meets every dense subset of ; that is, if for every such S, some initial segment of the real is in S [10]. If a real is n-generic (or weakly n-generic), we may say it is large with respect to category. If a real is random, on the other hand, it is large with respect to measure. For any reasonably defined randomness notion , the class of -random reals is conull; we refer the interested reader to [5,9] for definitions.
Franklin and Solomon proved that every Cohen 2-generic degree is low for isomorphism but that no Martin-Löf random degree is [8]. Therefore, this class of degrees is large with respect to category but small with respect to measure. Both of these bounds were found to be optimal: Franklin and Solomon showed that there was a weakly 2-generic degree that is not low for isomorphism and a computably random degree that is. However, the question remained as to whether any degree that was generic and low for isomorphism must necessarily be at least 2-generic.
We may also consider the degrees of categoricity, which form an interesting contrast with the degrees that are low for isomorphism. A Turing degree d is a degree of categoricity if some computable structure is c-computably categorical if and only if [6]. We can thus see that the degrees of categoricity form something of a dual to those that are low for isomorphism. Furthermore, very little is known about the degrees of categoricity: the only known examples are d.c.e. in and above for some α [3,4,6], and no hyperimmune-free degree but is a degree of categoricity [1]. However, every degree of categoricity is known to be hyperarithmetic [3]. Therefore, the class of degrees of categoricity is conull as well.
Franklin and Solomon suggested that an attempt at understanding these notions could be made by studying the gap between them: the degrees that are neither degrees of categoricity nor low for isomorphism. They proposed the properly 1-generic degrees as a possible such class [8].
In this paper, we show that this conjecture is false: that there is a properly 1-generic degree d that is low for isomorphism. In fact, we must prove something stronger: since the degrees that are low for isomorphism are downwards closed, to prove a novel result, we must show that there is a 1-generic degree that is both not computable from any 2-generic degree and low for isomorphism.
The result
There is a 1-generic real that is low for isomorphism that is not computable from any 2-generic.
We begin with a general discussion of the requirements we will have to satisfy and the ways in which we will do this. First, let be an effective listing of all partial computable structures. We must ensure that the real G we build is 1-generic, that it is not computed by a 2-generic, and that it is low for isomorphism. We denote these requirements as follows:
:
G either meets or avoids the set .
:
There is a set such that if , then Y neither meets nor avoids .
:
If is an isomorphism between and , then .
The first kind of requirement is finitary and the easiest one to satisfy: we can ensure that G is 1-generic through a standard finite injury approach. If we find at some stage that we can extend our finite approximation to G in such a way that we meet , we do so, injuring later requirements; otherwise, we satisfy it automatically.
We will satisfy the second requirement by breaking it up into subrequirements:
:
If there is a with , then Y does not meet and there is a string with .
By working to meet each subrequirement, we will construct the set . Our action to meet a subrequirement is also finitary but somewhat complicated to describe.
Suppose that we have a finite approximation g to our real and that we now wish to act to satisfy . We attempt to locate a string ρ extending τ with the property that there is no Y extending ρ with . We reserve the next bit b (at position ) for our use. At first we require that . If at some stage we see a ρ extending τ with , this is our desired ρ. We ensure that there is no Y extending ρ with by requiring that . Thus, our action for this subrequirement is finitary.
Our construction will take place on a priority tree, and there will be various strategies on the tree. We will define to be made up of the ρ which are selected by a strategy that is not later injured during the construction. As we are performing a -construction, this will be a set.
If there is a Y extending τ with , we will argue that the -strategy along the true path will see the desired extension ρ of τ, and this ρ will be in , so Y cannot avoid .
Alternately, if Y meets , then we can find an initial segment ρ at which this happens and consider the -strategy that put ρ into . If the strategy is not on the true path, we will show that this Y cannot compute our real G; if the strategy is on the true path, we will use the bit b as a witness to show that, once again, cannot compute G.
The third kind of requirement allows us to ensure that G is actually low for isomorphism. This requirement must be treated in an infinitary way. To do this, we will take our finite approximation to G and look for longer and longer extensions of it that would produce a partial isomorphism via . While we are looking for such an extension, we restrain G to pass through the previously located extension. If we find such an extension, we move to the infinite outcome as we temporarily drop the restraint. Then we return to the finite outcome and begin searching for a longer extension.
If, for the -strategy along the true path, we are infinitely often able to find a longer extension which extends the isomorphism via , then this is a computable sequence, so the resulting isomorphism is computable. If we eventually stop finding such extensions, then our restraint on G ensures that G cannot compute an isomorphism via .
Construction
We define our priority tree T recursively:
;
If with , then σ is a -node, and both and are in T with ;
If with , then σ is a -node, and both and are in T with ;
If with , then σ is a -node, and for , with .
For every node σ in the priority tree which is visited at any point in the construction, we will define a string . This is the finite initial segment of G that σ must work beyond – it is the restraint that σ inherits from its parent. We begin with .
At every stage s we will visit an increasing sequence of nodes on the tree, beginning with . When we visit a node σ, we will act according to its strategy for that stage. If , this action will include choosing some m such that is the next node to visit at stage s. At this or a previous stage, the action for σ will have defined with . Once we have visited a node σ with , the stage will end and we will proceed to stage .
Now we give the details of each node’s strategy.
Strategy for -nodes
Suppose σ is a -node which is visited at stage s. We can immediately define . If we have defined at a previous stage, then there is no action to take for σ, and is the next node to be visited.
If we have not yet defined , we look for a with . If there is such a ρ, we define , and is the next node to be visited. If there is no such ρ, then is the next node to be visited.
Strategy for -nodes
Suppose σ is a -node which is visited at stage s, where . We can immediately define and .
We then look for a with and . If there is such a ρ, then is the next node to be visited. If there is no such ρ, then is the next node to be visited.
Strategy for -nodes
Suppose σ is an -node which is visited at stage s, where . We can immediately define and .
We define a length-of-agreement function to be the greatest such that:
The atomic diagrams of and have converged up to n by stage s;
;
; and
is a partial isomorphism from to .
Let be greatest with defined, and let be the stage at which was defined. We look for a with and . If there is such a ρ, then we define , and is the next node to be visited. If there is no such ρ, then is the next node to be visited.
The true path
Define the true path by setting to be the lexicographically leftmost node with and σ is visited infinitely often during the construction. It is straightforward to see that this is a path through T. We write to indicate that ν is on or to the left of the true path. Note that is a set; indeed,
For every i, define the set as:
Note that is a set.
Define
Verification
Ifbut(so ν is strictly to the left of the true path), thenis either not defined or.
Assume is defined. Let σ be the meet of ν and TP. So there are some with , and . Since is defined, it follows that is defined.
Suppose σ is a -node. Then requires and . Since is defined, our action for σ ensures that is on the true path, contrary to our choice of σ. Thus σ cannot be a -node.
Suppose σ is a -node. Then requires and . By our action for σ, and . Since and , the lemma follows.
Finally, suppose σ is an -node. Then requires , in the usual ordering of . If , then by our action for σ, after the stage at which becomes defined, will never again be visited. This contradicts our assumption that . So it must be that . Again by our action for σ, . Also, observe that for all k and . So , and . The lemma follows. □
G cannot be computed from a 2-generic.
To prove this lemma, it is sufficient to show that for any i and Y such that , Y cannot be 2-generic. In fact, we will show that such a Y can neither meet nor avoid .
Suppose that Y avoids . We fix a at which this happens, let , and let . Then by definition of , there is no with . In particular, it must be that . But if there is no such ρ, then will always be the next node visited after σ is visited, meaning is on the true path. So . Thus , and .
Now we suppose that Y does meet . We fix an initial segment ρ at which Y meets and consider the -node ν that witnesses . By definition, , is defined and . But if ν is strictly to the left of the true path, then by Lemma 2.2, is not an initial segment of G, so .
Now suppose ν is on the true path. Then ρ is precisely the sort of string we are searching for in the strategy for ν. So at any stage at which ν is visited, will be the next node visited. So , and so . But then . □
Each requirement of the formis met.
Fix e, and let . If is ever defined, then and by construction, so G meets at .
So suppose now that is never defined, and that does not avoid . Then there is a with , and so at some sufficiently late stage s we will see while acting for the strategy for σ. At this stage, we will define , contrary to our assumption. □
Each requirement of the formis met.
Fix and let , and suppose and are total structures and is an isomorphism from to .
First suppose there were some with , and let t be the stage at which is defined. Since is visited infinitely often, by construction must never be defined. But for some sufficiently large n and s, and . So our action for σ will define , contrary to our previous statement.
So it must be that . But in that case the sequence is a total computable increasing sequence, and is a computable isomorphism between and . □
These lemmas suffice to prove Theorem 2.1: Lemma 2.4 shows that G must be 1-generic, Lemma 2.5 shows that G must be low for isomorphism, and Lemma 2.3 shows that G must not be computable from a 2-generic and thus that it is not only properly 1-generic but that its lowness for isomorphism is not due to being in the downwards closure of a 2-generic.
Parting thoughts
Franklin and Solomon’s results indicated that the degrees that are low for isomorphism are resistant to a straightforward characterization. For instance, they showed that there are degrees that are low for isomorphism and degrees that are not in each of the following classes: minimal degrees, hyperimmune degrees, and hyperimmune-free degrees [8]. However, as mentioned in the introduction of this paper, they also showed that some classes of degrees, including the 2-generic degrees, contain only degrees that are low for isomorphism and that some other classes, including the Martin-Löf random degrees, contain only degrees that are not. While it was already known that there are properly 1-generic degrees that are low for isomorphism since every 2-generic degree computes a properly 1-generic degree and the degrees that are low for isomorphism are closed downward, we have constructed a properly 1-generic degree that is nontrivially low for isomorphism. We have therefore shown that there is no level of Cohen genericity at which lowness for genericity only holds when it is required to by higher levels and thus that lowness for isomorphism is not a straightforward notion with respect to genericity, either.
We should note that the situation is more complicated when one considers weak genericity as well. We have not addressed the question of whether a degree that is low for isomorphism and properly 1-generic must be computable from a weakly 2-generic. While we see no reasonable way to adapt our construction and replace “2-genericity” with “weak 2-genericity” in Theorem 2.1, we cannot rule it out as a possibility.
We may also consider notions similar to lowness for isomorphism. Csima defined a degree d to be low for categoricity if every computable d-computably categorical structure is computably categorical [2]. Lowness for isomorphism is immediately seen to imply lowness for categoricity; it remains an open problem whether the converse holds. Thus our 1-generic G is low for categoricity, and it demonstrates that attempting to separate the two notions at the level of Cohen 1-generics would be extremely difficult.
One could also consider the question of separating notions for lowness for isomorphism for classes of structures. A degree d is low for isomorphism for a class if for every pair of structures and in , if is d-computably isomorphic to , then and are already computably isomorphic. This notion was defined in [8] and investigated further in [13] for classes such as linear orders and equivalence structures. The results for these classes often mirror those for the general case or are somehow trivial, and it would be interesting to know whether this trend continues when 1-genericity is considered.
Footnotes
Acknowledgements
The authors would like to thank the Institute for Mathematical Sciences of the National University of Singapore for supporting their stay there during the Algorithmic Randomness program in June 2014.
References
1.
B.A.Anderson and B.F.Csima, Degrees that are not degrees of categoricity, Notre Dame J. Formal Logic57(3) (2016), 389–398.
2.
B.Csima, Degrees of categoricity and related notions, BIRS Computable Model Theory Workshop (2013).
3.
B.F.Csima, J.N.Y.Franklin and R.A.Shore, Degrees of categoricity and the hyperarithmetic hierarchy, Notre Dame J. Formal Logic54(2) (2013), 215–231. doi:10.1215/00294527-1960479.
4.
B.F.Csima and M.Harrison-Trainor, Degrees of categoricity on a cone via η-systems, J. Symbolic Logic82(1) (2017), 325–346. doi:10.1017/jsl.2016.43.
5.
R.G.Downey and D.R.Hirschfeldt, Algorithmic Randomness and Complexity, Springer, Berlin2010.
6.
E.B.Fokina, I.Kalimullin and R.Miller, Degrees of categoricity of computable structures, Arch. Math. Logic49(1) (2010), 51–67. doi:10.1007/s00153-009-0160-4.
7.
J.N.Y.Franklin, Lowness and highness properties for randomness notions, in: Proceedings of the 10th Asian Logic Conference, T.Araiet al., eds, World Scientific, Singapore2010, pp. 124–151.
8.
J.N.Y.Franklin and R.Solomon, Degrees that are low for isomorphism, Computability3(2) (2014), 73–89.
9.
A.Nies, Computability and Randomness, Clarendon Press, Oxford, 2009.
10.
P.Odifreddi, Classical Recursion Theory. Number 125 in Studies in Logic and the Foundations of Mathematics, North-Holland, Amsterdam1989.
11.
T.A.Slaman and R.M.Solovay, When oracles do not help, in: Fourth Annual Workshop on Computational Learning Theory, Morgan Kaufman., Los Altos, CA, 1991, pp. 379–383.
12.
R.Soare, The Friedberg–Muchnik theorem re-examined, Canadian J. of Math.24 (1972), 1070–1078. doi:10.4153/CJM-1972-110-4.
13.
J.D.Suggs, On Lowness for Isomorphism as Restricted to Classes of Structures, PhD thesis, University of Connecticut, 2015.