Introduction
Time-bounded Kolmogorov complexity measures a string by the length of its shortest program on which a fixed universal machine outputs the string within a given number of steps. Suppose that each of two efficient onto machines can run any machine M M M by reading a code of M M M followed by an unchanged program z z z of M M M , with polynomial overhead; we call this simulation by adjunction. Then their measures agree up to an additive constant in length and a polynomial change of the deadline (Fact 3.10). That comparison concerns only the shortest description. It says nothing about how the other descriptions of the same string are arranged, or whether one of them can be turned into another by small changes.
This paper studies that arrangement. Fix a machine, a target string, a program length and a deadline. The fiber of the target is the set of all programs of that length that halt with the target as output within the deadline, where two programs are joined when they differ in one bit. We ask whether the fiber is connected, how many components it has, and how hard it is to decide whether two given programs lie in the same component. In this decision problem the input is the target, the deadline in unary and two programs, and a pair that does not lie in the fiber is a no-instance.
Two features of the question shape the answers. First, the fiber contains every program of the given length, not only the programs that begin with one particular code. A path may pass through programs that begin differently, so an argument about the programs beginning with one code, which we call its cylinder , does not decide connectivity of the fiber. Second, connectivity of the fiber is not monotone in the deadline. A larger deadline keeps every old program and every old path, but newly admitted programs can form new components, so a connected fiber can become disconnected at a larger deadline (for the first machine of Theorem 1.2 , by Theorems 4.4 and 4.9 ). A larger program length gives a different cube altogether, rather than a larger subgraph of the old one, so the fragmentation results choose program lengths as functions of the target length.
Graphs of equal-output genotypes under local mutation are studied in the theory of neutral networks. Reidys, Stadler and Schuster study equal-image classes in genotype–phenotype maps [17 ] , and Hu, Banzhaf and Ochoa study finite systems whose genotypes are programs [11 ] . The questions here differ in their setting: they concern adjunction-universal machines, deadlines counted in the machine’s own transitions, and every description of the given length. Dependence on the choice of machine is also known for other structural properties of descriptions: for the number of descriptions of a string [22 ] , for reductions to the set of random strings [2 ] , and in the distinction between optimality and universality by adjunction [5 ] .
The results concern three conditions on an efficient machine V V V , stated precisely in § 2.2 . Besides its program, V V V may read an auxiliary input; the fibers above use the empty auxiliary input. The machine is onto : every string is the output of some program on the empty auxiliary input.
Next, the machine has the simulation property , the precise form of simulation by adjunction: every machine M M M has a code ⟨ M ⟩ V \langle M\rangle_V ⟨ M ⟩ V for V V V , computable from M M M in polynomial time. For every string z z z , the program ⟨ M ⟩ V z \langle M\rangle_V z ⟨ M ⟩ V z outputs M ( z ) M(z) M ( z ) , and it diverges when M M M diverges on z z z . The simulation takes time polynomial in the running time of M M M and the lengths of z z z and ⟨ M ⟩ V \langle M\rangle_V ⟨ M ⟩ V , with one polynomial for all M M M . Finally, the machine has the interpretation property : given an auxiliary input a a a second code ⟨ M ⟩ V ′ \langle M\rangle'_V ⟨ M ⟩ V ′ of M M M , also computable from M M M in polynomial time, it runs M M M on the program with the same kind of overhead.
We call a machine with the first two properties an adjunction-universal machine , and the three properties together the reference conditions . The name follows the term universal by adjunction, which Bauwens, Kozachinskiy and Shen record, quoting Downey and Hirschfeldt, for machines universal in their sense [5 Sections 2 and 4] . In their definition the string placed before the unchanged programs of a machine need only exist, and no time bound is imposed; here the code is computable from M M M in polynomial time and the simulation has polynomial overhead. The rigid reference U U U of Definition 3.5 , built on a parity-protected encoding of machines, satisfies all three. The programs ⟨ M ⟩ V z \langle M\rangle_V z ⟨ M ⟩ V z that an adjunction-universal machine must run are its mandatory descriptions . Deadlines always count transitions of V V V itself, which we call native transitions, and a subscript V V V , as in O V ( 1 ) O_V(1) O V ( 1 ) , marks a constant that may depend on V V V .
In short, adjunction forces the fibers of most targets to fragment permanently at suitable lengths. Yet it allows a machine whose fibers are all empty or connected, at every deadline, once the program length reaches a threshold depending on the target, and for most targets the length needed is necessarily exponential in the target length. The same machine shows that deciding connectivity can be hard when the target is part of the input and easy for every fixed target.
Our Results
Table 1 summarizes the results, the program lengths at which they hold, and the distinction between the shape of a fiber and the complexity of querying it. In the table, “one polynomial deadline” means a deadline polynomial in the target length that depends only on the machine, and the exceptional targets are the same at every later deadline. The informal statements after the table present the main results in words, each with a pointer to its precise counterpart in the body.
Table 1. Selected guarantees for full program fibers. Constants in statements about every adjunction-universal machine may depend on the machine.
Table 2.
Mandatory descriptions and persistent fragmentation. An adjunction-universal machine must run every program of every source machine, so a suitable source forces descriptions that the machine cannot avoid. We choose sources that give each target several mandatory descriptions far apart in Hamming distance, and we count how many other programs, anywhere in the cube, would be needed to connect them. Here and below, “almost all” refers to the fraction of the m m m -bit targets as m m m tends to infinity.
Theorem 1.1 (Informal; Theorems 4.1 and 4.9 and Corollary 4.11). Let V V V be an adjunction-universal machine. Each of the following holds at every deadline beyond a deadline polynomial in m m m , where the polynomial depends only on V V V , with the same exceptional targets at all those deadlines.
(1) At program length m + O V ( 1 ) m+O_V(1) m + O V ( 1 ) , every m m m -bit target has a nonempty fiber, since it has mandatory descriptions there, and all but an O V ( 1 / m ) O_V(1/m) O V ( 1/ m ) fraction of these fibers are disconnected.
(2) At program length exactly 2 m + 3 2m+3 2 m + 3 , for every sufficiently large m m m , all but an O V ( log ( m + 1 ) / m ) O_V(\log(m+1)/m) O V ( log ( m + 1 ) / m ) fraction of the m m m -bit targets have fibers with at least 2 m − O V ( 1 ) 2^{m-O_V(1)} 2 m − O V ( 1 ) components.
(3) When m ≥ 4 m \ge4 m ≥ 4 is a power of two, there is a program length below 2 m + O V ( 1 ) 2m+O_V(1) 2 m + O V ( 1 ) , depending only on V V V and m m m , that gives at least 2 m / 2 − 1 2^{m/2-1} 2 m /2 − 1 components for all but an O V ( m − 1 / 2 ) O_V(m^{-1/2}) O V ( m − 1/2 ) fraction of the m m m -bit targets.
The constants hidden in O V ( 1 ) O_V(1) O V ( 1 ) come from the length of the code of a fixed source machine, chosen separately for each part. The bounds therefore hold for every adjunction-universal machine, whatever its other programs do.
These bounds start only once the mandatory descriptions have halted. At an earlier deadline a fiber can look entirely different, and there the answer depends on the machine.
Theorem 1.2 (Informal; Theorems 4.4 and 4.9). There are two machines satisfying the three reference conditions that disagree about connectivity at program length 2 m + 3 2m+3 2 m + 3 and one common deadline linear in m m m . For every sufficiently large m m m , every m m m -bit target has a connected fiber with 2 m + 1 2^{m+1} 2 m + 1 vertices for the first machine and an edgeless fiber with 2 m 2^m 2 m vertices for the second. By contrast, for every adjunction-universal machine, almost all m m m -bit targets have disconnected fibers at length 2 m + 3 2m+3 2 m + 3 at every deadline beyond one polynomial deadline.
The two statements are compatible. A path present at the early deadline is still present later, but programs admitted afterwards form further components. The later statement concerns connectivity of the whole fiber, not the loss of a path that existed earlier.
Eventual connectivity. The fragmentation bounds hold at lengths chosen from the target length. The fibers of a target may be disconnected at those lengths and still be empty or connected at every length beyond a threshold that depends on the target. Our main construction provides this for all targets and all deadlines at once, and it remains hard to query.
Theorem 1.3 (Informal; Theorems 5.2 and 5.4 and Corollaries 5.3 and 5.6). There is a machine satisfying the three reference conditions with the following properties.
For every target x x x one can compute a threshold N x ≤ 2 ∣ x ∣ + 2 + 1 N_x \le2^{|x|+2}+1 N x ≤ 2 ∣ x ∣ + 2 + 1 such that, at every program length N ≥ N x N \ge N_x N ≥ N x and every deadline, the fiber of x x x is empty or connected, with diameter at most 2 N + 4 2N+4 2 N + 4 .
Deciding whether two programs lie in the same fiber component is PSPACE-complete, yet for each fixed target it is decidable in polynomial time.
Conversely, for every adjunction-universal machine with such thresholds and every sufficiently large m m m , more than three quarters of the m m m -bit targets x x x have N x ≥ 2 c V m − 2 N_x \ge2^{c_Vm-2} N x ≥ 2 c V m − 2 , for a constant c V > 0 c_V>0 c V > 0 .
The lower bound concerns program length, not decision time: it says how long programs must be before every fiber of the target is guaranteed to be empty or connected. It comes from the fragmentation argument run at an exponentially large program length, where a disconnected fiber persists at every later deadline.
Fixed and varying targets. The previous theorem separates the complexity of the whole problem from that of each fixed target. Measuring how the running time may depend on the target length gives a finer comparison, even between machines whose connectivity problems are complete for the same class.
Theorem 1.4 (Informal; Corollaries 3.24, 5.7 and 5.8). There are two machines satisfying the three reference conditions whose connectivity problems are both PSPACE-complete. For the first, the machine of Theorem 1.3, one algorithm runs in time 2 2 O ( k ) ℓ O ( 1 ) 2^{2^{O(k)}}\ell^{O(1)} 2 2 O ( k ) ℓ O ( 1 ) on queries of length ℓ \ell ℓ with targets of length k k k . If P differs from PSPACE, no algorithm for this machine runs in time 2 2 O ( k ) ℓ O ( 1 ) 2^{2^{O(k)}}\ell^{O(1)} 2 2 O ( k ) ℓ O ( 1 ) . For the second, the problem is already PSPACE-complete at the fixed target 00 00 00 , so if P differs from PSPACE it is not fixed-parameter tractable in the target length.
The single-exponential exclusion holds because the hardness reduction uses targets of logarithmic length (Corollary 5.8). No matching double-exponential lower bound on the running time is claimed.
Targets connected at every length and deadline. Write G ( V ) G(V) G ( V ) for the set of globally connected targets, those whose fibers are empty or connected at every program length and every deadline. This is much stronger than eventual connectivity: one disconnected fiber, at any length and any deadline, excludes a target from G ( V ) G(V) G ( V ) .
Theorem 1.5 (Informal; Theorems 6.2 to 6.4 and 6.6, Corollaries 6.5 and 6.8, and Proposition 6.9). For every adjunction-universal machine V V V , the set G ( V ) G(V) G ( V ) is co-c.e., its c.e. subsets obey a computable bound on their size, and hence it has no infinite c.e. subset, and it has intrinsic density zero. Conversely, for every finite set S S S of strings there is a machine V V V satisfying the three reference conditions with G ( V ) = S G(V)=S G ( V ) = S . For every such S S S there is also a machine satisfying the three reference conditions for which the fixed-target connectivity problem is polynomial-time decidable for every target in S S S and PSPACE-complete for every target outside S S S .
If P differs from PSPACE, the last machine has polynomial-time fixed-target problems exactly for the targets in S S S . Intrinsic density zero is the notion characterized by Astor through computable injective sampling [3 ] ; the contribution here is that G ( V ) G(V) G ( V ) has it for every adjunction-universal machine V V V , with an explicit rate (Theorem 6.6 and Corollary 6.8). Fix such a V V V and a total computable injective list of strings, and let k k k be the length of the one code, which depends on the list. Then for every q ≥ 2 q \ge2 q ≥ 2 , at most a fraction O ( 2 k / log q ) O(2^k/\log q) O ( 2 k / log q ) of the first q q q entries lies in G ( V ) G(V) G ( V ) . For an adjunction-universal machine V V V with G ( V ) G(V) G ( V ) infinite, the computable bound makes G ( V ) G(V) G ( V ) effectively immune, meaning that a computable function of the index of a c.e. set bounds the size of every c.e. subset of G ( V ) G(V) G ( V ) (Proposition 6.9). Whether G ( V ) G(V) G ( V ) can be infinite for some adjunction-universal machine V V V is open (Open Problem 2).
Our Techniques
The negative and positive results use the mandatory descriptions in opposite ways. The negative arguments count what every adjunction-universal machine must provide. The positive construction keeps those programs but controls when the other programs become available and how they attach.
Counting paths in the full cube. An adjunction-universal machine gives no control over programs outside the cylinder of a code, and any of them might help connect two descriptions. The negative arguments therefore count those programs instead of excluding them. A fixed linear-time source maps 0 x 0x 0 x and 1 x 1x 1 x to x x x , and its code has some length d d d . At program length m + d + 1 m+d+1 m + d + 1 , inside the cylinder of that code, its two mandatory descriptions of an m m m -bit target x x x are the only descriptions of x x x . A simple path joining them therefore leaves the cylinder and has at least m + 2 m+2 m + 2 vertices outside it.
Paths for different targets share no vertex, because one deterministic program has one output. There are only ( 2 d − 1 ) 2 m + 1 (2^d-1)2^{m+1} ( 2 d − 1 ) 2 m + 1 programs outside the cylinder of a code of length d d d , so only a fraction O ( 2 d / m ) O(2^d/m) O ( 2 d / m ) of the targets can have connected endpoints. The exceptional targets are defined through the untimed fiber, the graph with no deadline, so one exceptional set serves every later deadline.
To force many components rather than one disconnection, each target needs many mandatory descriptions that are pairwise far apart. A balanced linear map with well-separated preimage sets, built from finite-field parity checks adapted from the codes of Bose and Ray-Chaudhuri and of Hocquenghem [6 , 12 ] , supplies them. A traversal of a spanning tree shows that a connected subgraph of the cube containing k ≥ 2 k \ge2 k ≥ 2 terminals at pairwise distance at least D D D has at least k D / 2 kD/2 k D /2 vertices. Applied to each component in turn, this bound shows that most targets must have exponentially many components at length 2 m + 3 2m+3 2 m + 3 .
To reach exactly length 2 m + 3 2m+3 2 m + 3 , the source must know the length of its own code, which is chosen only after the source is fixed. The construction therefore supplies that length as a unary prefix of the raw input, so no source ever needs to compute its own code. Reed–Muller evaluation codes [4 Section 2.3] give a second family with an explicit tradeoff among program length, component count and the exceptional fraction.
The same balanced construction, tuned to a program length exponential in the target length, gives the threshold lower bound. The code of the source is still fixed across all those lengths, so most targets have a disconnected fiber at that length at every later deadline. Any threshold beyond which every fiber is empty or connected must therefore exceed that length.
Releasing a connected fiber at every deadline. The construction must make the fiber empty or connected at every deadline, not only when time is unlimited. A program needed on a connecting path might halt later than the descriptions it is meant to join, and at the intermediate deadlines the fiber could then be disconnected. The construction therefore admits a connected core first and lets simulated descriptions in only after the core is present.
The core rests on an explicit coloring of the cube of program bodies in which every color class is connected and every vertex has a neighbor of every color. It combines two syndrome registers with a selector bit; within each color class, paths to a fixed representative have linear length, and the coloring is computed on a schedule depending only on the body length. The syndrome part is the established coupon-coloring construction [8 ] ; the connectedness of the classes and the fixed schedule are proved here. Each color is printed as a short string, and the strings printable at a given body length form its palette .
Programs have two mode bits. Core programs print the color of their body. In the two helper modes, the parity of the body decides whether a program prints its color, as a router, or runs the simulation, as a source helper. Every core and router program of one body length halts at one common time. Base programs and their matching source helpers run the same native simulation of a fixed base machine after a common delay, so they halt together, after the core and the routers are present. Every admitted program whose output lies in the current palette of colors therefore attaches to the core in at most three steps, which gives empty or connected fibers at every deadline and the diameter bound. The palette grows with the body length, and every fixed target eventually enters it, which gives a computable threshold exponential in the target length.
Uniform hardness uses targets outside the palette. No core or router program prints such a target, so its fiber contains only base programs and their source helpers, and each helper is a leaf attached to its base. A rigid code of a formula verifier in the parity-protected encoding then makes the base components with that code, after deleting their helper leaves, correspond exactly to the components of the solution graph of a formula. The reduction starts from the PSPACE-complete problem of connecting two satisfying assignments by single-variable changes [10 ] .
The reduction picks the target before building the code, although the code length depends on the target. For a formula instance of encoding length L L L , a target of length a fixed multiple of ⌈ log 2 ( L + 2 ) ⌉ \lceil\log_2(L+2) \rceil ⌈ log 2 ( L + 2 )⌉ is long enough to lie outside the palette at the resulting body length, so only one verifier and one code are built. Membership in PSPACE uses Savitch’s recursive reachability method [18 ] , with the native graph tests proved explicitly here.
Effective restrictions and finite hubs. To restrict G ( V ) G(V) G ( V ) , the path count must be applied to many targets at once, although for general V V V the paper gives no membership test for G ( V ) G(V) G ( V ) , so the argument cannot rely on one. For a c.e. family of targets, one source machine waits for the indexed distinct elements of its enumeration and assigns each an antipodal pair of raw inputs. At each suffix length, the finitely many successful endpoints halt by a common deadline, whether or not that deadline can be computed. If all these targets lie in G ( V ) G(V) G ( V ) , the outside-path count applies to all of them together. Choosing the suffix length from the code turns this into a computable bound on the size of c.e. subsets, and running the same source on a total injective list gives the density rate.
A fixed finite set S S S reverses the order of quantifiers, since the machine may now depend on S S S . Each target of S S S gets a control header with a single one bit, which prints that target whatever suffix follows. The fiber of such a target therefore contains a whole cube of these hub programs before any base program halts, and every base program of the target differs from a hub program in one bit.
For targets outside S S S , the fiber is empty at short lengths and early deadlines, and otherwise deleting the common base prefix is an exact isomorphism of fibers. The fiber of the base machine at deadline t t t corresponds to the new fiber at deadline B + L t B + Lt B + L t , for constants B B B and L L L , so the fiber structure and the hardness of the base machine carry over. A sentinel keeps the shifted program’s left boundary during simulation, and all constants are computable from the base machine and S S S . Interpretation is added last, by a new first transition that dispatches on the auxiliary input; on the empty auxiliary input the machine performs the old computation step for step, so no fiber changes (Lemma 3.25).
Other Related Work
The relevant precedents concern local-move output fibers, structural properties of decompressors, and the graph constructions used in the proofs. This subsection says what each establishes and how its setting differs from the one here.
Neutrality and description sets. Reidys, Stadler and Schuster develop configuration graphs and equal-image neutral sets [17 Sections 2 and 4 of the author preprint] . Their RNA compatibility graph also permits changes in two paired positions, so it does not coincide with the one-bit program graph in every case. Hu, Banzhaf and Ochoa use literal programs in a finite register-based model and study neutrality, search and phenotype transitions [11 ] . Schaper, Johnston and Louis study disconnected neutral components in RNA sequence maps under single point mutations [21 Section 2] . Equal-output mutation graphs of programs are therefore not new objects. The results here instead quantify over all adjunction-universal machines, or construct specific ones, with guarantees for the full set of descriptions at stated native deadlines, most of them holding at every later deadline.
Tadaki proves that the entire prefix-complexity function can stay unchanged while output-description cardinalities change [22 Theorems 4 and 9 of the final manuscript] . That is a close structural precedent, in a prefix-free optimal-machine model. Allender, Buhrman and Koucký construct machines retaining a universal machine by adjunction behind a fixed prefix while varying efficient reducibility properties of random-string sets [2 Theorem 14 of the author draft] , so dependence on the machine under adjunction is also a precedent.
Bauwens, Kozachinskiy and Shen distinguish optimality from universality by adjunction and preserve plain complexity while installing the latter [5 Section 4, Proposition 1] ; their questions concern plain complexity, which has no deadline. In that universality the string placed before the programs of a machine need only exist, with no time bound, whereas for an adjunction-universal machine the code is computable in polynomial time and the simulation has polynomial overhead. Milovanov shows that, for a suitable optimal plain decompressor, an oracle for description-length thresholds does not give a polynomial-time decision of the halting problem [15 Theorem 1.1] . These works concern minima, cardinalities or reductions to complexity predicates, whereas the results here concern connectivity of full fibers.
Coding, domination, and reachability. The finite-field checks adapt those of Bose and Ray-Chaudhuri and of Hocquenghem [6 , 12 ] . The specific rank, balance and deterministic-construction properties needed in the packing proof are proved here. Reed–Muller evaluation codes provide the separated terminal family [4 Section 2.3] .
Coupon coloring asks that every open neighborhood contain every color; Chen, Kim, Tait and Verstraete give finite-field constructions for cube colorings [8 ] , and Goddard and Henning study the corresponding total-domatic and fractional formulations [GH18]. Connected domatic partitions are also established [23 ] , and Shaw constructs linearly many completely independent spanning trees of the cube with linear diameter [Sha24, Theorem 1.2]. These general partition notions are known; the selector construction here is used for its connected color classes, its representative paths and its fixed native schedule.
The hardness reductions begin with the satisfying-assignment st-connectivity theorem of Gopalan, Kolaitis, Maneva and Papadimitriou [10 Theorem 2.9 and Section 3.3 of the full version] . That theorem concerns two supplied satisfying assignments, which is distinct from asking whether the whole solution graph is connected. General reconfiguration and its implicit-graph perspective are discussed by Ito, Demaine, Harvey, Papadimitriou, Sideri, Uehara and Uno [13 ] and surveyed by Nishimura [16 ] .
Computability and parameterization. Astor characterizes intrinsic density through computable injective sampling [3 Corollary 4.3 of the accepted preprint] . Case discusses effective-immunity bounds and minimal-program sets in acceptable systems [7 ] . The statements about globally connected targets apply these established notions to a different set of outputs, with an explicit packing bound from one code. That G ( V ) G(V) G ( V ) is co-c.e. follows directly by enumerating finite witnesses of disconnected fibers.
Fixed-parameter tractability is standard, and so is the observation that a PSPACE-complete fixed-target connectivity problem at a constant parameter value rules it out unless P equals PSPACE. The content of the comparison here is the pair of machines satisfying the same reference conditions: one has a uniform target-parameter algorithm despite full PSPACE-completeness, while the rigid reference U U U has a PSPACE-complete fixed-target connectivity problem.
Discussion
The numerical invariance theorem and fiber connectivity concern different data. A code controls what each program beginning with it computes and bounds its running time. It says nothing about adjacency between programs beginning with different codes, and it does not guarantee any path between the programs for one output.
Persistent fragmentation and eventual connectivity concern different program lengths. The fragmentation bounds hold at lengths chosen from the target length, while eventual connectivity holds from a threshold that depends on the target. For a machine with such thresholds, every length at which a fiber of a target is disconnected lies below the threshold of that target. The exponential lower bound on that threshold follows from a single disconnected fiber at an exponentially large length, which persists at every later deadline.
The shape of a fiber and the complexity of querying it are also separate. A disconnected fiber can still have a simple component test: for the machine of Theorem 1.3 , most targets have disconnected fibers at some lengths (Theorem 5.5 ), yet every fixed target has a polynomial-time connectivity test (Corollary 5.3 ). Moreover, unless P equals PSPACE, polynomial-time connectivity for every fixed target need not give a uniform polynomial-time algorithm when the target varies. The construction of Theorem 1.3 exhibits both under adjunction and interpretation. It does not give a machine satisfying the reference conditions whose full connectivity language fails to be PSPACE-hard, and it does not classify such machines.
For globally connected targets, every finite set can be prescribed, with construction constants depending on that set. The packing obstruction instead uses one fixed code across unbounded suffix lengths. These quantifiers explain why finite prescriptions do not combine into an infinite computable family of globally connected targets for one adjunction-universal machine. The necessary conditions, co-c.e., computably bounded c.e. subsets and intrinsic density zero, are not known to suffice for an infinite realization.
Open Problems
We single out three questions. The first two stay within this native-fiber model and concern the full connectivity language under the reference conditions and the size of the set of globally connected targets. The third lets a path change the program length.
Complexity under the reference conditions. The fixed-target and parameterized separations do not decide whether the complexity of the full connectivity language is the same for every machine satisfying the reference conditions. reference conditions. The rigid reference and the machines of Theorems 5.4 and 6.2 have PSPACE-complete full connectivity languages.
Open Problem 1. Is Conn ( V ) \operatorname{Conn}(V) Conn ( V ) PSPACE-complete for every machine V V V satisfying all three reference conditions?
Here Conn ( V ) \operatorname{Conn}(V) Conn ( V ) is the language of Problem 3.21, which always lies in PSPACE (Proposition 3.22). A negative answer therefore requires a machine meeting all three conditions whose full connectivity language is not PSPACE-hard.
Infinite globally connected-target sets. For every adjunction-universal machine V V V , the packing bounds exclude every infinite c.e. subset of G ( V ) G(V) G ( V ) and force intrinsic density zero. Finite-hub completion realizes each finite set exactly, while later bridges cannot repair a disconnected fiber at an earlier deadline.
Open Problem 2. Does an adjunction-universal machine V V V exist for which G ( V ) G(V) G ( V ) is infinite?
By Proposition 6.9, such a set would be co-c.e. and effectively immune.
Programs of all lengths. Every fiber studied in this paper has the programs of one length as vertices and one-bit flips as edges. Definition 3.19 also defines the edit graph, whose vertices are the programs of length at most a budget ℓ \ell ℓ that print x x x within the deadline, and whose edges are flips, insertions and deletions of a single bit. Apart from its being an implicit graph (Lemma 3.20), so that its s t st s t -connectivity problem lies in PSPACE, no result of this paper concerns it. Every fiber at a length at most ℓ \ell ℓ is an induced subgraph of that edit graph, but a path in the edit graph may change length, so neither fragmentation nor connectivity of the fibers carries over by itself.
The packing argument of Theorem 4.1 bounds the length of a path below by the Hamming distance of its endpoints, and in the edit graph only the edit distance bounds it. The two mandatory descriptions h 0 x h0x h 0 x and h 1 x ‾ h1\overline{x} h 1 x of that proof are at Hamming distance ∣ x ∣ + 1 |x|+1 ∣ x ∣ + 1 , yet they can be at edit distance two as strings. For example, when x = ( 10 ) k x=(10)^k x = ( 10 ) k with k ≥ 1 k\ge1 k ≥ 1 , deleting the bit after h h h and then appending a 1 carries h 0 x h0x h 0 x to h 1 x ‾ h1\overline{x} h 1 x . This defeats only the lower bound used in that proof; it gives no path in the edit graph, since the intermediate string need not print x x x .
Open Problem 3. Do an adjunction-universal machine V V V and a computable function b b b exist such that, for every target x x x , every budget ℓ ≥ b ( x ) \ell\ge b(x) ℓ ≥ b ( x ) and every deadline t t t , the edit graph of the programs of length at most ℓ \ell ℓ that print x x x within t t t native steps of V V V is empty or connected?
A positive answer needs paths between programs of different lengths, and the proof of Theorem 5.2 does not address them, since it connects the programs of each length separately.
AI Disclosure
This work was developed with substantial assistance from Codex and Claude Code. These tools were used to discover almost all of the proofs in this work, find relevant literature, and write parts of the prose; the author wrote the rest. The author posed the problem, guided the development, and is responsible for any errors.
Paper Organization
Section 2 gives the preliminaries: strings, Hamming distance and the Boolean cube, native machines, adjunction, interpretation and full fibers. Section 3 supplies the explicit encoding and computational framework, including the numerical comparison of description lengths, defines the full connectivity language, and proves rigid-reference hardness and pointwise interpretation completion. Section 4 proves the first fragmentation bound for every adjunction-universal machine, the early separation between two machines satisfying the reference conditions, and sharper persistent fragmentation and component-multiplicity bounds. Section 5 constructs eventual connectivity, proves uniform hardness, establishes the exponential threshold obstruction, and derives the target-parameter consequences. Section 6 prescribes finite sets of easy targets and of globally connected targets, and proves effective restrictions on G ( V ) G(V) G ( V ) for every adjunction-universal machine.
Preliminaries
This section fixes the notation for strings, distances, graphs and the Boolean cube, the native machine model with adjunction and interpretation, and the full native fiber studied throughout.
Strings, Distances, and Cubes
Natural numbers include zero. Write { 0 , 1 } = { 0 , 1 } \{0,1\} = \{0,1\} { 0 , 1 } = { 0 , 1 } , ε \varepsilon ε for the empty string, ∣ z ∣ |z| ∣ z ∣ for a string’s length, and u v uv uv for concatenation. The sets { 0 , 1 } n \{0,1\}^{n} { 0 , 1 } n and { 0 , 1 } ≤ n \{0,1\}^{\leq n} { 0 , 1 } ≤ n contain strings of exactly and at most n n n bits, and { 0 , 1 } ∗ \{0,1\}^{*} { 0 , 1 } ∗ contains all finite binary strings. We also write { 0 , 1 } = n = { 0 , 1 } n \{0,1\}^{=n} = \{0,1\}^{n} { 0 , 1 } = n = { 0 , 1 } n . For a bit b b b , the string b n b^{n} b n consists of n n n copies of b b b , with b 0 = ε b^{0} = \varepsilon b 0 = ε . Complementing every bit of z z z gives z ‾ \overline{z} z . The binary value of z = z 1 ⋯ z n z = z_{1}\cdots z_{n} z = z 1 ⋯ z n is val ( z ) = ∑ i = 1 n z i 2 n − i \operatorname{val}(z) = \sum_{i=1}^{n} z_{i}2^{n-i} val ( z ) = ∑ i = 1 n z i 2 n − i , with value zero for the empty string. The canonical binary representation bin ( j ) \operatorname{bin}(j) bin ( j ) has no leading zeros, except bin ( 0 ) = 0 \operatorname{bin}(0) = 0 bin ( 0 ) = 0 . Exclusive-or of bits is addition modulo two, with empty sum zero.
Definition 2.1 (Hamming weight, Hamming distance, and codes). Let n ≥ 0 n \geq0 n ≥ 0 and let a , b ∈ { 0 , 1 } n a,b \in\{0,1\}^{n} a , b ∈ { 0 , 1 } n , the case n = 0 n = 0 n = 0 giving wt ( ε ) = Δ ( ε , ε ) = 0 \operatorname{wt}(\varepsilon) = \Delta(\varepsilon,\varepsilon) = 0 wt ( ε ) = Δ ( ε , ε ) = 0 . The Hamming weight of a a a is the number of its coordinates equal to one,
wt ( a ) = ∑ i = 1 n a i , \operatorname{wt}(a) = \sum_{i=1}^{n} a_i, wt ( a ) = i = 1 ∑ n a i , and the Hamming distance between a a a and b b b is Δ ( a , b ) = ∣ { i ∣ a i ≠ b i } ∣ \Delta(a,b) = |\{i \mid a_i \ne b_i\}| Δ ( a , b ) = ∣ { i ∣ a i = b i } ∣ , the number of coordinates on which they differ, so that wt ( a ) = Δ ( a , 0 n ) \operatorname{wt}(a) = \Delta(a,0^{n}) wt ( a ) = Δ ( a , 0 n ) .
The function Δ \Delta Δ is a metric on { 0 , 1 } n \{0,1\}^{n} { 0 , 1 } n : it is symmetric, it vanishes exactly on equal pairs, and it satisfies the triangle inequality Δ ( a , c ) ≤ Δ ( a , b ) + Δ ( b , c ) \Delta(a,c) \leq\Delta(a,b) + \Delta(b,c) Δ ( a , c ) ≤ Δ ( a , b ) + Δ ( b , c ) . For the last, any coordinate on which a a a and c c c differ is one on which a a a and b b b differ, or one on which b b b and c c c differ.
For δ 0 ∈ N \delta_{0} \in\mathbb{N} δ 0 ∈ N , a set C ⊆ { 0 , 1 } n C \subseteq\{0,1\}^{n} C ⊆ { 0 , 1 } n is a code of minimum distance δ 0 \delta_{0} δ 0 if Δ ( a , b ) ≥ δ 0 \Delta(a,b) \geq\delta_{0} Δ ( a , b ) ≥ δ 0 for all distinct a , b ∈ C a,b \in C a , b ∈ C . The lowercase δ 0 \delta_{0} δ 0 is used for the parameter so that it is not confused with the distance Δ \Delta Δ itself.
When C C C has at least two elements the admissible values of δ 0 \delta_{0} δ 0 are exactly 0 , 1 , … , min a ≠ b Δ ( a , b ) 0,1,\ldots,\min_{a\ne b}\Delta(a,b) 0 , 1 , … , min a = b Δ ( a , b ) , so the minimum distance of C C C , meaning the largest admissible δ 0 \delta_{0} δ 0 , exists and equals min a ≠ b Δ ( a , b ) \min_{a\ne b}\Delta(a,b) min a = b Δ ( a , b ) . A set with at most one element is a code of every minimum distance, since the condition Δ ( a , b ) ≥ δ 0 \Delta(a,b) \geq\delta_{0} Δ ( a , b ) ≥ δ 0 is quantified over pairs of distinct elements and there are none. The word code also names the ambient encoding ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ of a machine (Definition 3.2 ) and the code ⟨ M ⟩ V \langle M\rangle_{V} ⟨ M ⟩ V of a machine for a machine V V V (Definition 2.6), which for the reference machine is ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ itself; each use below says which meaning is intended.
A local transformation is a walk through feasible objects. We use simple undirected graphs and include the empty graph in our connectivity convention.
Definition 2.2 (Graphs, walks, components, and the Boolean cube). A graph G = ( V ( G ) , E ( G ) ) G = (V(G),E(G)) G = ( V ( G ) , E ( G )) consists of a set V ( G ) V(G) V ( G ) of vertices and a set E ( G ) E(G) E ( G ) of unordered pairs of distinct vertices, called edges . The letter V V V also names machines; as a vertex-set operator it is always applied to a graph, as in V ( G ) V(G) V ( G ) , so the two uses cannot be confused.
Two vertices u ≠ v u \ne v u = v are adjacent , written u ∼ G v u \sim_{G} v u ∼ G v , when { u , v } ∈ E ( G ) \{u,v\} \in E(G) { u , v } ∈ E ( G ) . We set u ∼ G u u \sim_{G} u u ∼ G u false for every u u u , and u ∼ G v u \sim_{G} v u ∼ G v false whenever u u u or v v v is not a vertex, so that ∼ G \sim_{G} ∼ G is defined on all of { 0 , 1 } ∗ × { 0 , 1 } ∗ \{0,1\}^{*} \times\{0,1\}^{*} { 0 , 1 } ∗ × { 0 , 1 } ∗ .
A walk of length k ≥ 0 k \geq0 k ≥ 0 from u u u to v v v is a sequence u = z 0 , z 1 , … , z k = v u = z_{0},z_{1},\ldots,z_{k} = v u = z 0 , z 1 , … , z k = v of vertices with z j − 1 ∼ G z j z_{j-1} \sim_{G} z_{j} z j − 1 ∼ G z j for every 1 ≤ j ≤ k 1 \leq j \leq k 1 ≤ j ≤ k , and a path is a walk whose vertices are pairwise distinct.
Two vertices are connected when some walk joins them. This is an equivalence relation on V ( G ) V(G) V ( G ) , and its classes are the connected components of G G G . The graph is connected when it has at most one component; a vertex v v v is isolated when its component is { v } \{v\} { v } ; and G G G is edgeless when E ( G ) = ∅ E(G) = \varnothing E ( G ) = ∅ , that is, when every vertex is isolated.
A walk of least length joining two connected vertices is a geodesic between them, and the distance d G ( u , v ) d_{G}(u,v) d G ( u , v ) is the length of one. The diameter of G G G is the supremum of d G ( u , v ) d_{G}(u,v) d G ( u , v ) over the pairs u , v u,v u , v that are connected in G G G . That supremum is 0 0 0 when V ( G ) = ∅ V(G) = \varnothing V ( G ) = ∅ . The diameter of a disconnected graph is therefore the supremum of the diameters of its components, and is not + ∞ +\infty + ∞ merely because two vertices lie in different components; every graph whose diameter is named below is finite.
For S ⊆ V ( G ) S \subseteq V(G) S ⊆ V ( G ) , the subgraph induced by S S S is G [ S ] G[S] G [ S ] with V ( G [ S ] ) = S V(G[S]) = S V ( G [ S ]) = S and E ( G [ S ] ) = { { u , v } ∈ E ( G ) ∣ u ∈ S and v ∈ S } E(G[S]) = \{\{u,v\} \in E(G) \mid u \in S \text{ and } v \in S\} E ( G [ S ]) = {{ u , v } ∈ E ( G ) ∣ u ∈ S and v ∈ S } .
The Boolean cube , or hypercube , Q n Q_{n} Q n is the graph with V ( Q n ) = { 0 , 1 } n V(Q_{n}) = \{0,1\}^{n} V ( Q n ) = { 0 , 1 } n in which a ∼ Q n b a \sim_{Q_{n}} b a ∼ Q n b exactly when Δ ( a , b ) = 1 \Delta(a,b) = 1 Δ ( a , b ) = 1 , for the Hamming distance Δ \Delta Δ of Definition 2.1 . It is connected, and d Q n ( a , b ) = Δ ( a , b ) d_{Q_{n}}(a,b) = \Delta(a,b) d Q n ( a , b ) = Δ ( a , b ) for all a , b ∈ { 0 , 1 } n a,b \in\{0,1\}^{n} a , b ∈ { 0 , 1 } n .
Flipping the coordinates on which a a a and b b b differ, one at a time and in any order, gives a walk of length Δ ( a , b ) \Delta(a,b) Δ ( a , b ) . No shorter walk exists: along a walk a = z 0 , … , z k = b a = z_{0},\ldots,z_{k} = b a = z 0 , … , z k = b each step satisfies $\Delta(z_{j-1},z_{j}) = 1, whence Δ ( a , b ) ≤ ∑ j = 1 k Δ ( z j − 1 , z j ) = k \Delta(a,b) \le\sum_{j=1}^{k}\Delta(z_{j-1},z_j)=k Δ ( a , b ) ≤ ∑ j = 1 k Δ ( z j − 1 , z j ) = k by the triangle inequality of Definition 2.1 . The diameter of Q n Q_n Q n is therefore n n n .
A graph isomorphism is a bijection between vertex sets that preserves and reflects adjacency.
Native Machines and Simulation by Adjunction
Fixed machine descriptions may include finite data. We distinguish their description length from the native time taken to execute them.
Definition 2.3 (The native machine model). Machines are deterministic multitape Turing machines. One transition is one native step , a step of the machine itself and not of any machine it simulates: a finite control reads the scanned symbols, changes state, writes on the writable tapes, and moves each head by at most one cell. Program and auxiliary strings occupy separate read-only tapes. Each tape head starts at its first cell, and a requested move left from that cell leaves the head there. A finite binary string occupies cells one through its length; every later cell contains the blank symbol ⊔ ∈ { 0 , 1 } \sqcup\in\{0,1\} ⊔ ∈ { 0 , 1 } .
The output tape starts blank and is never read by the machine. Its head may move in either direction, and a transition writes at most one output symbol. A normal halt delivers the final binary output string, including the empty string. Earlier transient output is not a halt: head movement, overwriting and erasure before the halt are part of the native computation. A computation delivering a string of length m m m takes at least m m m steps. A distinguished halting state delivers ⊥ \bot ⊥ , which is not a string and differs from ε \varepsilon ε .
The work tapes have fixed finite hardwired binary data, distributed in a layout declared with the machine; other work cells start blank. This initial data is present before the first transition and is not charged as runtime input or as time spent writing it. The encoding below records both the data and its layout. A program-only machine has no auxiliary input. A conditional machine also reads an auxiliary string; its unconditional reading is its run at the empty auxiliary string, and we write V ( p ) = V ( p , ε ) V(p)=V(p,\varepsilon) V ( p ) = V ( p , ε ) for it.
To read a machine description before an arbitrary appended program, the encoding of machines must identify where the description ends.
Definition 2.4 (Prefix-free sets and self-delimiting encodings). A set Π ⊆ { 0 , 1 } ∗ \Pi\subseteq\{0,1\}^{*} Π ⊆ { 0 , 1 } ∗ is prefix-free if no element of Π \Pi Π is a proper prefix of another. An encoding is self-delimiting if its range is prefix-free: a complete codeword cannot be the proper prefix of another. The explicit encoding used below also admits a computable left-to-right parse which identifies a codeword’s end.
We fix an injective self-delimiting binary encoding of finite machine descriptions, the ambient encoding , and write ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ for the code of M M M . It records the finite control, its initial work data and, for a clocked machine (Definition 3.6 ), its clock. The explicit representation is specified in Definition 3.2 , and its length and computational properties are proved in Proposition 3.3. The simulation and interpretation properties defined below measure uniformity in the length of this fixed code. The counting argument of § 4.1 uses only the code that Definition 2.6 assigns to a source machine, not the bit pattern of the ambient encoding.
Surjectivity, adjunction and interpretation are different requirements. The following definitions state exactly which of them each result assumes.
Definition 2.5 (Efficient machine, efficient universal machine). A Turing machine V V V , taking a program and, in the conditional setting, an auxiliary string as well, is efficient if, for every program p p p and auxiliary string y y y , the configuration of V ( p , y ) V(p,y) V ( p , y ) reached after t t t steps is computable from ( p , y , 1 t ) (p,y,1^t) ( p , y , 1 t ) in time polynomial in t + ∣ p ∣ + ∣ y ∣ t+|p|+|y| t + ∣ p ∣ + ∣ y ∣ , the polynomial depending only on V V V . A halting configuration is its own successor, so this is defined whether or not the computation has halted by step t t t . Under the model just fixed the efficiency clause is automatic by Fact 3.4. We retain the clause because it fixes the quantity against which the configuration computations of Lemma 3.20 are charged. It is also a genuine hypothesis on any model in which the configuration after t t t steps need not be computable in polynomial time.
An efficient universal machine is a machine that is efficient and in addition universal : for every x ∈ { 0 , 1 } ∗ x \in\{0,1\}^{*} x ∈ { 0 , 1 } ∗ there is a program p p p with V ( p , ε ) = x V(p,\varepsilon)=x V ( p , ε ) = x . For a machine taking a program alone the clause reads: for every x ∈ { 0 , 1 } ∗ x \in\{0,1\}^{*} x ∈ { 0 , 1 } ∗ there is a p p p with V ( p ) = x V(p)=x V ( p ) = x . Here the word universal means only onto at the empty condition; it does not assert either of the simulation and interpretation properties defined next. We
also call this an efficient onto machine. The words efficient and universal name separate requirements below, since efficiency is asked of some machines whose universality is not in question.
We write V ( p ) = x V(p)=x V ( p ) = x , or V ( p , y ) = x V(p,y)=x V ( p , y ) = x in the conditional setting, within t t t steps if the computation halts with output x x x after at most t t t steps. Machines are conditional except where stated, and we abbreviate V ( p ) = V ( p , ε ) V(p)=V(p,\varepsilon) V ( p ) = V ( p , ε ) throughout, so that the unconditional reading is the conditional one at the empty auxiliary string. Program-only and conditional machines are distinguished where each construction is given.
Universality asks that every string be the output of some program. Simulation by adjunction additionally requires that every program of a machine M M M be run unchanged after one fixed code that depends on M M M .
Definition 2.6 (Simulation property). An efficient universal machine V V V has the simulation property if there are a polynomial q q q and a map M ↦ ⟨ M ⟩ V M\mapsto\langle M\rangle_V M ↦ ⟨ M ⟩ V , computable in time polynomial in ∣ ⟨ M ⟩ ∣ \lvert\langle M\rangle\rvert ∣⟨ M ⟩∣ and of length polynomial in ∣ ⟨ M ⟩ ∣ \lvert\langle M\rangle\rvert ∣⟨ M ⟩∣ , such that for every Turing machine M M M and every string z z z : if M ( z ) M(z) M ( z ) halts in T T T steps then V ( ⟨ M ⟩ V z , ε ) V(\langle M\rangle_Vz,\varepsilon) V (⟨ M ⟩ V z , ε ) halts with output M ( z ) M(z) M ( z ) within q ( T , ∣ z ∣ , ∣ ⟨ M ⟩ V ∣ ) q(T,\lvert z\rvert,\lvert\langle M\rangle_V\rvert) q ( T , ∣ z ∣ , ∣⟨ M ⟩ V ∣) steps, and if M ( z ) M(z) M ( z ) diverges then so does V ( ⟨ M ⟩ V z , ε ) V(\langle M\rangle_Vz,\varepsilon) V (⟨ M ⟩ V z , ε ) . We call ⟨ M ⟩ V \langle M\rangle_V ⟨ M ⟩ V the code of M M M for V V V , and the map M ↦ ⟨ M ⟩ V M\mapsto\langle M\rangle_V M ↦ ⟨ M ⟩ V the code map of V V V ; the code is independent of the raw suffix z z z and of its length. In this setting M M M is the source machine and z z z the raw suffix . For the reference machine U U U of Definition 3.5, the code of M M M is the ambient encoding ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ itself; other machines use their own codes.
Running M M M on an unchanged program placed after a fixed code of M M M is simulation by adjunction , or adjunction for short. Simulation constrains the empty-condition branch; interpretation instead supplies the machine through the auxiliary string.
Definition 2.7 (Interpretation property). A conditional efficient universal machine V V V has the interpretation property if there are a polynomial q q q and a map M ↦ ⟨ M ⟩ V ′ M\mapsto\langle M\rangle'_V M ↦ ⟨ M ⟩ V ′ subject to the same computability and length bounds as in Definition 2.6, such that for every Turing machine M M M and every program p p p : if M ( p ) M(p) M ( p ) halts in T T T steps then V ( p , ⟨ M ⟩ V ′ ) V(p,\langle M\rangle'_V) V ( p , ⟨ M ⟩ V ′ ) halts with output M ( p ) M(p) M ( p ) within q ( T , ∣ p ∣ , ∣ ⟨ M ⟩ V ′ ∣ ) q(T,\lvert p\rvert,\lvert\langle M\rangle'_V\rvert) q ( T , ∣ p ∣ , ∣⟨ M ⟩ V ′ ∣) steps, and if M ( p ) M(p) M ( p ) diverges then so does V ( p , ⟨ M ⟩ V ′ ) V(p,\langle M\rangle'_V) V ( p , ⟨ M ⟩ V ′ ) .
The prime keeps this encoding apart from the simulation encoding of Definition 2.6. The simulation and interpretation encodings need not coincide. The polynomial q q q may be taken nondecreasing in each argument: replace it by the sum of the absolute values of its coefficients times the same monomials. We do so throughout.
The overhead is required to be uniform in ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ , and not merely polynomial for each fixed M M M , because every use below applies the property to a machine built from the input of a reduction. Definition 2.6 is stated with the same uniformity, and its polynomial is normalized in the same way. Fact 3.10 needs only the per-machine form, and uses that normalization.
Surjectivity is asked at the empty auxiliary string only. It could not be asked at every auxiliary string of a machine with the interpretation property of Definition 2.7. Let M c M_c M c ignore its input and print the string c c c . If V V V has the interpretation property of Definition 2.7, then V ( p , ⟨ M c ⟩ V ′ ) = M c ( p ) = c V(p,\langle M_c\rangle'_V)=M_c(p)=c V ( p , ⟨ M c ⟩ V ′ ) = M c ( p ) = c for every program p p p , so the range of V ( ⋅ , ⟨ M c ⟩ V ′ ) V(\mathord{\cdot},\langle M_c\rangle'_V) V ( ⋅ , ⟨ M c ⟩ V ′ ) is the single string c c c and is not all of { 0 , 1 } ∗ \{0,1\}^* { 0 , 1 } ∗ .
We call an efficient universal machine with the simulation property of Definition 2.6 an adjunction-universal machine . The name follows the term universal by adjunction, which Bauwens, Kozachinskiy and Shen record, quoting Downey and Hirschfeldt, for machines universal in their sense [5 Sections 2 and 4] . In their definition a machine is universal if, for every machine, some string placed before the unchanged programs of that machine makes it run them; that string need only exist, and no time bound is imposed. Here the code ⟨ M ⟩ V \langle M\rangle_V ⟨ M ⟩ V is computable from M M M in polynomial time and the simulation has polynomial overhead, so an adjunction-universal machine satisfies an effective, time-bounded form of their universality. Being onto, having the simulation property and having the interpretation property of Definition 2.7 are together the reference conditions .
Full Native Fibers
Fixing the output, program length and native deadline selects a set of feasible descriptions. Its geometry is the subgraph induced by those descriptions in the program cube.
Definition 2.8 (The full native fiber). For a machine V V V of the model of Definition 2.3, a target x ∈ { 0 , 1 } ∗ x \in\{0,1\}^{*} x ∈ { 0 , 1 } ∗ and integers N , t ≥ 0 N,t \ge0 N , t ≥ 0 , define
F V ( x , N , t ) = Q N [ { p ∈ { 0 , 1 } N : V ( p , ε ) normally halts with output x within t native steps } ] . \mathcal{F}_{V}(x,N,t)=Q_{N}\left[\left\{p\in\{0,1\}^{N}:V(p,\varepsilon)\text{ normally halts with output }x\text{ within }t\text{ native steps}\right\}\right]. F V ( x , N , t ) = Q N [ { p ∈ { 0 , 1 } N : V ( p , ε ) normally halts with output x within t native steps } ] . For a program-only machine the auxiliary string is omitted. We call F V ( x , N , t ) \mathcal{F}_{V}(x,N,t) F V ( x , N , t ) the fiber of x x x . A distinguished halt contributes no vertex, including when x = ε x=\varepsilon x = ε . Every length-N N N program is considered, however it begins. A path keeps V , x , N , t V,x,N,t V , x , N , t fixed and changes one program bit at each step. The untimed fiber of x x x at length N N N is the subgraph of Q N Q_{N} Q N induced by the length-N N N programs on which V V V eventually halts normally with output x x x ; it is the union of the fibers F V ( x , N , t ) \mathcal{F}_{V}(x,N,t) F V ( x , N , t ) over all t t t .
A prefix cylinder h { 0 , 1 } r h\{0,1\}^{r} h { 0 , 1 } r consists of every string obtained by appending an arbitrary r r r -bit suffix to the fixed string h h h . We call it the cylinder of h h h . The counting arguments for adjunction-universal machines in Section 4 count the vertices of connecting paths or subgraphs, including programs outside the cylinder of a code, so they never assume that this cylinder is separated from the rest of the fiber.
Encodings and Connectivity Complexity
The complexity results need, beyond the definitions of Section 2, a concrete encoding, uniform clocks and a precise endpoint query. This section provides that machinery with complete proofs, together with the numerical comparison of description lengths. It ends with two results used in Sections 5 and 6: every fixed-target connectivity language of the rigid reference U U U is PSPACE-complete (Corollary 3.24), and interpretation can be added to a machine without changing any fiber (Lemma 3.25).
Explicit Encodings
Our hardness results reduce from a problem about Boolean formulas, stated in Fact 3.17. We fix their syntax and truth-value conventions next.
Definition 3.1 (Conjunctive normal form). A literal is a variable v i v_i v i or its negation ¬ v i \neg v_i ¬ v i , a clause is a disjunction of literals, and a formula is in conjunctive normal form if it is a conjunction of clauses. The letter v v v is used for Boolean variables, and the letter x x x is reserved for the target string. A formula is in 3-conjunctive normal form if in addition every clause has at most three literals. For a formula on the variables v 1 , … , v n v_1,\ldots,v_n v 1 , … , v n , an assignment a ∈ { 0 , 1 } n a\in\{0,1\}^{n} a ∈ { 0 , 1 } n sends v i v_i v i to a i a_i a i and ¬ v i \neg v_i ¬ v i to 1 − a i 1-a_i 1 − a i , a clause to the maximum of the values of its literals, and the formula to the minimum of the values of its clauses. That last value is φ ( a ) \varphi(a) φ ( a ) . The empty clause takes the value 0 and the empty conjunction the value 1. An assignment a ∈ { 0 , 1 } n a\in\{0,1\}^{n} a ∈ { 0 , 1 } n satisfies φ \varphi φ if φ ( a ) = 1 \varphi(a)=1 φ ( a ) = 1 .
We fix an integer D ≥ 1 D\ge1 D ≥ 1 . A polynomial clock has the form c ( k ) = ∑ i = 0 D c i k i c(k)=\sum_{i=0}^{D}c_i k^i c ( k ) = ∑ i = 0 D c i k i , with nonnegative integer coefficients and c 0 ≥ 1 ; i t g r a n t s a t m o s t c_0\ge1; it grants at most c 0 ≥ 1 ; i t g r an t s a t m os t c(k)$ source transitions on an input of length k k k . Its coefficients are represented in unary. The complete clocked-machine convention is recorded below. We first make the binary representation of controls, machines, clocked machines, tuples and formulas explicit.
The ambient code uses a parity-protected length header so that a one-bit change cannot open a different valid parse.
Definition 3.2 (The ambient encoding). Call the three strings A 0 = 000 A_0=000 A 0 = 000 , A 1 = 011 A_1=011 A 1 = 011 and A e n d = 101 A_{\mathrm{end}}=101 A end = 101 the legal blocks ; in the notation of Definition 2.1 they satisfy wt ( A 0 ) ≡ wt ( A 1 ) ≡ wt ( A e n d ) ≡ 0 ( m o d 2 ) \operatorname{wt}(A_0)\equiv\operatorname{wt}(A_1)\equiv\operatorname{wt}(A_{\mathrm{end}})\equiv0\pmod2 wt ( A 0 ) ≡ wt ( A 1 ) ≡ wt ( A end ) ≡ 0 ( mod 2 ) and Δ ( A i , A j ) = 2 \Delta(A_i,A_j)=2 Δ ( A i , A j ) = 2 for i ≠ j i\ne j i = j . Write blk ( e ) \operatorname{blk}(e) blk ( e ) for the string obtained from e ∈ { 0 , 1 } ∗ e\in\{0,1\}^{*} e ∈ { 0 , 1 } ∗ by replacing each 0 by A 0 A_0 A 0 and each 1 by A 1 A_1 A 1 .
Let ρ \rho ρ be the concatenative raw encoding of finite objects, defined as follows. Every raw encoding begins with a tag σ \sigma σ of a fixed length λ 0 = O ( 1 ) \lambda_0=O(1) λ 0 = O ( 1 ) naming the type of the object encoded, which is one of control, machine, clocked machine, tuple, and formula. The tag makes ρ \rho ρ injective across types as well as within each, and is displayed in the identities below.
A finite control F F F is written as ρ ( F ) = σ c t r l T F \rho(F)=\sigma_{\mathrm{ctrl}}T_F ρ ( F ) = σ ctrl T F for its transition table T F T_F T F . The table uses a self-delimiting format of its own. In it, a transition mentions only the tapes it touches and the states it names, each by a self-delimiting numeral, and the states of a table are numbered 1 , … , S 1,\ldots,S 1 , … , S consecutively. The format is prefix-free, so the raw control encodings form a prefix-free set, and that makes the machine clause ρ ( F , d ) = σ m a c h ρ ( F ) d \rho(F,d)=\sigma_{\mathrm{mach}}\rho(F)d ρ ( F , d ) = σ mach ρ ( F ) d below injective and parsable in one left-to-right pass. In particular ⟨ F ⟩ \langle F\rangle ⟨ F ⟩ is defined.
The table carries an initial-state field, one self-delimiting numeral, ahead of the transitions, so that a wrapper redirects the entry point by rewriting a single field rather than by renumbering the inherited states. Tapes, states, and tape symbols are each numbered consecutively from 1. A table with k k k tapes, S S S states, and an alphabet of A A A symbols therefore has k + S + A = O ( ∣ T F ∣ ) k+S+A=O(|T_F|) k + S + A = O ( ∣ T F ∣ ) , which is the bound on the alphabet width that Fact 3.4 uses.
The two symbols 0 and 1 are numbered 1 and 2 and are written in a common fixed-width field, so that exchanging one for the other in a transition changes no field’s width. Declaring one further work tape, adding a bounded number of fresh states, rewriting the initial-state field, and adjoining a fixed gadget therefore enlarge the table by O ( log ( ∣ T F ∣ + 2 ) ) O(\log(|T_F|+2)) O ( log ( ∣ T F ∣ + 2 )) bits and no more. Rewriting an inherited bit-write in place changes no symbol field’s width.
A machine with control F F F and data string d d d is written as ρ ( F , d ) = σ m a c h ρ ( F ) d \rho(F,d)=\sigma_{\mathrm{mach}}\rho(F)d ρ ( F , d ) = σ mach ρ ( F ) d . A clocked machine with control F F F , data d d d , and clock coefficients c 0 , … , c D c_0,\ldots,c_D c 0 , … , c D as in Definition 3.6 is written as
ρ ( F , d , c 0 , … , c D ) = σ c l k ρ ( F ) 1 c 0 01 c 1 0 ⋯ 1 c D 0 d , (1) \rho(F,d,c_0,\ldots,c_D)=\sigma_{\mathrm{clk}}\rho(F)1^{c_0}01^{c_1}0\cdots1^{c_D}0d, \tag*{(1)} ρ ( F , d , c 0 , … , c D ) = σ clk ρ ( F ) 1 c 0 0 1 c 1 0 ⋯ 1 c D 0 d , (1)
where the coefficient block is self-delimiting because it contains exactly D + 1 D+1 D + 1 zeros and D D D is an absolute constant, so that the transition table, then the D + 1 D+1 D + 1 coefficients, then the data string are read off in one left-to-right pass. The data string comes last in both cases, since it is written raw and carries no delimiter of its own; its extent is fixed by the length that the length header of Eq. (2) announces. For a clocked machine M M M as in Eq. (1) , ρ ( M ) \rho(M) ρ ( M ) carries 1 c i 1^{c_i} 1 c i as a contiguous block for every i ≤ D i\le D i ≤ D . Lemma 3.7 reads these blocks. The D + 1 D+1 D + 1 blocks are disjoint substrings of ρ ( M ) \rho(M) ρ ( M ) , so that ∑ i ≤ D c i ≤ ∣ ρ ( M ) ∣ ≤ ∣ ⟨ M ⟩ ∣ \sum_{i\le D}c_i\le|\rho(M)|\le|\langle M\rangle| ∑ i ≤ D c i ≤ ∣ ρ ( M ) ∣ ≤ ∣ ⟨ M ⟩ ∣ , and ∣ ρ ( M ) ∣ = λ 0 + ∣ ρ ( F ) ∣ + ∣ d ∣ + ∑ i ≤ D c i + ( D + 1 ) |\rho(M)|=\lambda_0+|\rho(F)|+|d|+\sum_{i\le D}c_i+(D+1) ∣ ρ ( M ) ∣ = λ 0 + ∣ ρ ( F ) ∣ + ∣ d ∣ + ∑ i ≤ D c i + ( D + 1 ) . Emptying the data string of a clocked machine M M M with control F F F gives the clocked machine F ♭ = ( F , ε , c 0 , … , c D ) F^\flat=(F,\varepsilon,c_0,\ldots,c_D) F ♭ = ( F , ε , c 0 , … , c D ) , so ⟨ F ♭ ⟩ \langle F^\flat\rangle ⟨ F ♭ ⟩ is defined as well. Proposition 3.3 compares ∣ ⟨ M ⟩ ∣ |\langle M\rangle| ∣ ⟨ M ⟩ ∣ with ∣ ⟨ F ♭ ⟩ ∣ |\langle F^\flat\rangle| ∣ ⟨ F ♭ ⟩ ∣ . For an unclocked machine, F ♭ = F F^\flat=F F ♭ = F .
A tuple of k ≥ 2 k\ge2 k ≥ 2 strings u 1 , … , u k u_1,\ldots,u_k u 1 , … , u k is written as
ρ ( u 1 , … , u k ) = σ t u p sd ( k ) sd ( ∣ u 1 ∣ ) ⋯ sd ( ∣ u k − 1 ∣ ) u 1 ⋯ u k , \rho(u_1,\ldots,u_k)=\sigma_{\mathrm{tup}}\operatorname{sd}(k)\operatorname{sd}(|u_1|)\cdots\operatorname{sd}(|u_{k-1}|)u_1\cdots u_k, ρ ( u 1 , … , u k ) = σ tup sd ( k ) sd ( ∣ u 1 ∣ ) ⋯ sd ( ∣ u k − 1 ∣ ) u 1 ⋯ u k ,
where sd ( j ) = blk ( bin ( j ) ) A e n d \operatorname{sd}(j)=\operatorname{blk}(\operatorname{bin}(j))A_{\mathrm{end}} sd ( j ) = blk ( bin ( j )) A end is the self-delimiting numeral of length 3 ( ∣ bin ( j ) ∣ + 1 ) 3(|\operatorname{bin}(j)|+1) 3 ( ∣ bin ( j ) ∣ + 1 ) built from the legal blocks. The header records the arity, because the lengths alone would not tell a left-to-right parse where the header stops. With the arity in hand, the parse reads k k k , then the k − 1 k-1 k − 1 lengths, then the components.
For a pair this gives ∣ ρ ( a , b ) ∣ = ∣ a ∣ + ∣ b ∣ + O ( log ( ∣ a ∣ + ∣ b ∣ + 2 ) ) |\rho(a,b)|=|a|+|b|+O(\log(|a|+|b|+2)) ∣ ρ ( a , b ) ∣ = ∣ a ∣ + ∣ b ∣ + O ( log ( ∣ a ∣ + ∣ b ∣ + 2 )) . Arities are not assumed bounded, and none is needed: every numeral sd ( j ) \operatorname{sd}(j) sd ( j ) has length 3 ( ∣ bin ( j ) ∣ + 1 ) ≥ 6 3(|\operatorname{bin}(j)|+1)\ge6 3 ( ∣ bin ( j ) ∣ + 1 ) ≥ 6 , so the header of a k k k -tuple occupies at least 6 k 6k 6 k bits and k = O ( ∣ ρ ( u 1 , … , u k ) ∣ ) k=O(|\rho(u_1,\ldots,u_k)|) k = O ( ∣ ρ ( u 1 , … , u k ) ∣ ) . Appending one further component u k + 1 u_{k+1} u k + 1 therefore lengthens the header by ∣ sd ( k + 1 ) ∣ − ∣ sd ( k ) ∣ + ∣ sd ( ∣ u k ∣ ) ∣ = O ( log ( ∣ ρ ( u 1 , … , u k ) ∣ + 2 ) ) |\operatorname{sd}(k+1)|-|\operatorname{sd}(k)|+|\operatorname{sd}(|u_k|)|=O(\log(|\rho(u_1,\ldots,u_k)|+2)) ∣ sd ( k + 1 ) ∣ − ∣ sd ( k ) ∣ + ∣ sd ( ∣ u k ∣ ) ∣ = O ( log ( ∣ ρ ( u 1 , … , u k ) ∣ + 2 )) and the body by ∣ u k + 1 ∣ |u_{k+1}| ∣ u k + 1 ∣ , which is the estimate the wrappers below use.
The tuple rule is not applied to the pair ( F , d ) (F,d) ( F , d ) . The transition table is already self-delimiting, so no length header is needed to separate the control from the data, and the data string is charged ∣ d ∣ |d| ∣ d ∣ and no more, as the additive bounds below require.
A formula φ \varphi φ in conjunctive normal form on n n n variables with clauses C 1 , … , C m C_1,\ldots,C_m C 1 , … , C m is written as ρ ( φ ) = σ c n f sd ( n ) sd ( m ) ρ ( C 1 ) ⋯ ρ ( C m ) \rho(\varphi)=\sigma_{\mathrm{cnf}}\operatorname{sd}(n)\operatorname{sd}(m)\rho(C_1)\cdots\rho(C_m) ρ ( φ ) = σ cnf sd ( n ) sd ( m ) ρ ( C 1 ) ⋯ ρ ( C m ) . Each clause is written as its width in the numeral sd \operatorname{sd} sd followed by its literals, and each literal as a sign bit followed by sd of its index. The clause codes ρ ( C j ) \rho(C_j) ρ ( C j ) use a tagless local format. They have no type tag, since the tag rule of the opening paragraph applies to the five listed types only, and they are parsed positionally inside ρ ( φ ) \rho(\varphi) ρ ( φ ) , where the width numeral of each clause announces where the next begins. The parse is again left to right.
Finally, ∣ ρ ( o ) ∣ |\rho(o)| ∣ ρ ( o ) ∣ is linear in the size of o o o in every case, taking the size of a formula to be the length of that encoding. The map ρ \rho ρ is an injection. Both ρ \rho ρ and ρ − 1 \rho^{-1} ρ − 1 are computable in polynomial time, and the range of ρ \rho ρ is decidable in polynomial time by one left-to-right parse of the tag and of the self-delimiting fields that it announces. The ambient encoding of a finite object o o o is
⟨ o ⟩ = blk ( bin ( ∣ ρ ( o ) ∣ ) ) A e n d ρ ( o ) par ( o ) , par ( o ) = ⨁ i = 1 ∣ ρ ( o ) ∣ ρ ( o ) i , (2) \langle o\rangle=\operatorname{blk}(\operatorname{bin}(|\rho(o)|))A_{\mathrm{end}}\rho(o)\operatorname{par}(o),\qquad\operatorname{par}(o)=\bigoplus_{i=1}^{|\rho(o)|}\rho(o)_i, \tag*{(2)} ⟨ o ⟩ = blk ( bin ( ∣ ρ ( o ) ∣ )) A end ρ ( o ) par ( o ) , par ( o ) = i = 1 ⨁ ∣ ρ ( o ) ∣ ρ ( o ) i , (2)
a block-encoded length header, the raw encoding, and one parity bit, where the empty exclusive-or is 0, so that par ( o ) = 0 \operatorname{par}(o)=0 par ( o ) = 0 when ρ ( o ) = ε \rho(o)=\varepsilon ρ ( o ) = ε . A machine reading a codeword from the left reads the length header block by block until it meets A e n d A_{\mathrm{end}} A end , then reads the announced number of further bits together with the parity bit. It rejects the string outright in any of six cases: some block is not legal; the block-decoded header e e e is empty; e e e has ∣ e ∣ ≥ 2 |e| \ge2 ∣ e ∣ ≥ 2 and e 1 = 0 e_1 = 0 e 1 = 0 , so that e ≠ bin ( r ) e \ne\operatorname{bin}(r) e = bin ( r ) for the number r r r it names; the total length differs from 3 ( ∣ e ∣ + 1 ) + r + 1 3(|e|+1)+r+1 3 ( ∣ e ∣ + 1 ) + r + 1 ; the parity does not check; or ρ − 1 \rho^{-1} ρ − 1 is undefined on the announced span.
The leading-zero test is necessary. Without it the pass accepts blk ( e ) A e n d ρ ( o ) par ( o ) \operatorname{blk}(e)A_{\mathrm{end}}\rho(o)\operatorname{par}(o) blk ( e ) A end ρ ( o ) par ( o ) for every e e e whose value is r = ∣ ρ ( o ) ∣ r=|\rho(o)| r = ∣ ρ ( o ) ∣ , and so decides a strictly larger set than the range.
Take e = 0 bin ( r ) e=0\operatorname{bin}(r) e = 0 bin ( r ) . Every header block of the resulting string is legal, its decoded header is nonempty and names r r r , its total length is exactly 3 ( ∣ e ∣ + 1 ) + r + 1 3(|e|+1)+r+1 3 ( ∣ e ∣ + 1 ) + r + 1 , and its parity checks.
That string nonetheless lies outside the range. The block parse of any codeword stops at its first A e n d A_{\mathrm{end}} A end block, so a codeword beginning blk ( 0 bin ( r ) ) A e n d \operatorname{blk}(0\operatorname{bin}(r))A_{\mathrm{end}} blk ( 0 bin ( r )) A end would announce the header string 0 bin ( r ) 0\operatorname{bin}(r) 0 bin ( r ) . That string has a leading zero and length at least two, so it is bin ( r ′ ) \operatorname{bin}(r') bin ( r ′ ) for no r ′ r' r ′ . Only the clause forbidding a leading zero rejects it in the parse itself.
When the hardwired data string encodes a tuple, its components occupy separate declared work tapes. That layout is recorded in the finite control, so the ambient machine code determines the entire initial configuration. A wrapper may put an added component on a fresh tape after the inherited tapes, preserving every inherited tape index.
Proposition 3.3 (The ambient encoding is prefix-free, cheap, and rigid). The encoding of Definition 3.2 is injective, has a prefix-free range, decidable and decodable in polynomial time, is computable in polynomial time, has length bounded by a polynomial in the size of the object encoded, and satisfies
∣ ⟨ M ⟩ ∣ = ∣ ⟨ F ♭ ⟩ ∣ + ∣ d ∣ + O ( log ( ∣ d ∣ + 2 ) ) |\langle M\rangle|=|\langle F^{\flat}\rangle|+|d|+O(\log(|d|+2)) ∣ ⟨ M ⟩ ∣ = ∣ ⟨ F ♭ ⟩ ∣ + ∣ d ∣ + O ( log ( ∣ d ∣ + 2 )) for a machine M M M presented as a control F F F and a data string d d d , with an absolute implied constant, where F ♭ F^{\flat} F ♭ is the clocked machine ( F , ε , c 0 , … , c D ) (F,\varepsilon,c_0,\ldots,c_D) ( F , ε , c 0 , … , c D ) obtained by emptying the data string, and F ♭ = F F^{\flat}=F F ♭ = F for an unclocked machine; more generally ∣ ⟨ o ⟩ ∣ ≤ ∣ ρ ( o ) ∣ + 7 ⌈ log 2 ( ∣ ρ ( o ) ∣ + 2 ) ⌉ |\langle o\rangle|\le|\rho(o)|+7\lceil\log_2(|\rho(o)|+2)\rceil ∣ ⟨ o ⟩ ∣ ≤ ∣ ρ ( o ) ∣ + 7 ⌈ log 2 ( ∣ ρ ( o ) ∣ + 2 )⌉ . It is moreover rigid: for every codeword w w w , every w ′ ∈ { 0 , 1 } ∣ w ∣ w'\in\{0,1\}^{|w|} w ′ ∈ { 0 , 1 } ∣ w ∣ at Hamming distance one from w w w , and every z ∈ { 0 , 1 } ∗ z\in\{0,1\}^{*} z ∈ { 0 , 1 } ∗ , no codeword of the encoding is a prefix of w ′ z w'z w ′ z .
Proof. Prefix-freeness and the parse. The header is a sequence of legal blocks terminated by the single occurrence of A e n d A_{\mathrm{end}} A end , since no block of blk ( e ) \operatorname{blk}(e) blk ( e ) is A e n d A_{\mathrm{end}} A end , so it is self-delimiting and is read in one pass. It announces ∣ ρ ( o ) ∣ |\rho(o)| ∣ ρ ( o ) ∣ , which fixes the total length of the codeword. If one codeword is a prefix of another, the two are read by the same block parse, so they carry the same header, hence the same announced length, hence are equal. No codeword is therefore a proper prefix of another.
Membership is decided, and o o o recovered, by that one pass together with the parity check and the inversion of ρ \rho ρ , all in polynomial time. (2) is itself computed in polynomial time from o o o . The encoding is injective, because ρ \rho ρ is injective and because the header fixes the span of ⟨ o ⟩ \langle o\rangle ⟨ o ⟩ that ρ ( o ) \rho(o) ρ ( o ) occupies. Its length is linear in ∣ ρ ( o ) ∣ |\rho(o)| ∣ ρ ( o ) ∣ , hence polynomial in the size of o o o .
Length. Writing r = ∣ ρ ( o ) ∣ r=|\rho(o)| r = ∣ ρ ( o ) ∣ , the codeword has 3 ( ∣ bin ( r ) ∣ + 1 ) + r + 1 3(|\operatorname{bin}(r)|+1)+r+1 3 ( ∣ bin ( r ) ∣ + 1 ) + r + 1 bits, and ∣ bin ( r ) ∣ = ⌈ log 2 ( r + 1 ) ⌉ |\operatorname{bin}(r)|=\lceil\log_2(r+1)\rceil ∣ bin ( r ) ∣ = ⌈ log 2 ( r + 1 )⌉ for r ≥ 1 r\ge1 r ≥ 1 , while ∣ bin ( 0 ) ∣ = 1 |\operatorname{bin}(0)|=1 ∣ bin ( 0 ) ∣ = 1 . In either case ∣ bin ( r ) ∣ ≤ L |\operatorname{bin}(r)|\le L ∣ bin ( r ) ∣ ≤ L for L = ⌈ log 2 ( r + 2 ) ⌉ L=\lceil\log_2(r+2)\rceil L = ⌈ log 2 ( r + 2 )⌉ , so the excess of the codeword length over r r r is 3 ∣ bin ( r ) ∣ + 4 ≤ 3 L + 4 ≤ 7 L 3|\operatorname{bin}(r)|+4\le3L+4\le7L 3∣ bin ( r ) ∣ + 4 ≤ 3 L + 4 ≤ 7 L , the last step because L ≥ 1 L\ge1 L ≥ 1 . That is the general bound. For a machine the transition table is nonempty, so r = λ 0 + ∣ ρ ( F ) ∣ + ∣ d ∣ ≥ 1 r=\lambda_0+|\rho(F)|+|d|\ge1 r = λ 0 + ∣ ρ ( F ) ∣ + ∣ d ∣ ≥ 1 there, and ∣ ρ ( F ) ∣ ≥ λ 0 ≥ 1 |\rho(F)|\ge\lambda_0\ge1 ∣ ρ ( F ) ∣ ≥ λ 0 ≥ 1 as well. The exact formula ∣ bin ( r ) ∣ = ⌈ log 2 ( r + 1 ) ⌉ |\operatorname{bin}(r)|=\lceil\log_2(r+1)\rceil ∣ bin ( r ) ∣ = ⌈ log 2 ( r + 1 )⌉ for r ≥ 1 r\ge1 r ≥ 1 therefore applies to ⟨ F ⟩ \langle F\rangle ⟨ F ⟩ and to ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ alike, giving
∣ ⟨ M ⟩ ∣ − ∣ ⟨ F ⟩ ∣ − ∣ d ∣ = λ 0 + 3 ( ⌈ log 2 ( λ 0 + ∣ ρ ( F ) ∣ + ∣ d ∣ + 1 ) ⌉ − ⌈ log 2 ( ∣ ρ ( F ) ∣ + 1 ) ⌉ ) . |\langle M\rangle|-|\langle F\rangle|-|d|=\lambda_0+3\left(\left\lceil\log_2(\lambda_0+|\rho(F)|+|d|+1)\right\rceil-\left\lceil\log_2(|\rho(F)|+1)\right\rceil\right). ∣ ⟨ M ⟩ ∣ − ∣ ⟨ F ⟩ ∣ − ∣ d ∣ = λ 0 + 3 ( ⌈ log 2 ( λ 0 + ∣ ρ ( F ) ∣ + ∣ d ∣ + 1 ) ⌉ − ⌈ log 2 ( ∣ ρ ( F ) ∣ + 1 ) ⌉ ) .
This lies between λ 0 \lambda_0 λ 0 and λ 0 + 3 log 2 ( λ 0 + ∣ d ∣ + 1 ) + 3 \lambda_0+3\log_2(\lambda_0+|d|+1)+3 λ 0 + 3 log 2 ( λ 0 + ∣ d ∣ + 1 ) + 3 , by the inequality
λ 0 + ∣ ρ ( F ) ∣ + ∣ d ∣ + 1 ≤ ( ∣ ρ ( F ) ∣ + 1 ) ( λ 0 + ∣ d ∣ + 1 ) , \lambda_0+|\rho(F)|+|d|+1\le(|\rho(F)|+1)(\lambda_0+|d|+1), λ 0 + ∣ ρ ( F ) ∣ + ∣ d ∣ + 1 ≤ ( ∣ ρ ( F ) ∣ + 1 ) ( λ 0 + ∣ d ∣ + 1 ) ,
and is therefore O ( log ( ∣ d ∣ + 2 ) ) O(\log(|d|+2)) O ( log ( ∣ d ∣ + 2 )) with an absolute implied constant, since λ 0 \lambda_0 λ 0 is O ( 1 ) O(1) O ( 1 ) . For a clocked machine we absorb the clock into the control. Write
ρ ( F ♭ ) = σ c l k ρ ( F ) 1 c 0 0 ⋯ 1 c D 0 , s = ∣ ρ ( F ♭ ) ∣ , \rho(F^{\flat})=\sigma_{\mathrm{clk}}\rho(F)1^{c_0}0\cdots1^{c_D}0,\qquad s=|\rho(F^{\flat})|, ρ ( F ♭ ) = σ clk ρ ( F ) 1 c 0 0 ⋯ 1 c D 0 , s = ∣ ρ ( F ♭ ) ∣ ,
for the tag and the control together with the coefficient block of (1) , so that ρ ( M ) = ρ ( F ♭ ) d \rho(M)=\rho(F^{\flat})d ρ ( M ) = ρ ( F ♭ ) d exactly, with no further tag. By (1) the string just displayed is ρ \rho ρ of the clocked machine ( F , ε , c 0 , … , c D ) (F,\varepsilon,c_0,\ldots,c_D) ( F , ε , c 0 , … , c D ) , so ⟨ F b ⟩ \langle F^{b}\rangle ⟨ F b ⟩ is Eq. (2) applied to an object of a declared type. The derivation above then runs with λ 0 \lambda_{0} λ 0 replaced by 0 and gives
∣ ⟨ M ⟩ ∣ − ∣ ⟨ F b ⟩ ∣ − ∣ d ∣ = 3 ( ⌈ log 2 ( s + ∣ d ∣ + 1 ) ⌉ − ⌈ log 2 ( s + 1 ) ⌉ ) ∈ [ 0 , 3 ⌈ log 2 ( ∣ d ∣ + 1 ) ⌉ ] , |\langle M\rangle|-|\langle F^{b}\rangle|-|d|=3\left(\left\lceil\log_{2}(s+|d|+1)\right\rceil-\left\lceil\log_{2}(s+1)\right\rceil\right)\in\left[0,3\left\lceil\log_{2}(|d|+1)\right\rceil\right], ∣ ⟨ M ⟩ ∣ − ∣ ⟨ F b ⟩ ∣ − ∣ d ∣ = 3 ( ⌈ log 2 ( s + ∣ d ∣ + 1 ) ⌉ − ⌈ log 2 ( s + 1 ) ⌉ ) ∈ [ 0 , 3 ⌈ log 2 ( ∣ d ∣ + 1 ) ⌉ ] ,
the upper bound from s + ∣ d ∣ + 1 ≤ ( s + 1 ) ( ∣ d ∣ + 1 ) s+|d|+1\le(s+1)(|d|+1) s + ∣ d ∣ + 1 ≤ ( s + 1 ) ( ∣ d ∣ + 1 ) , so ∣ ⟨ M ⟩ ∣ = ∣ ⟨ F b ⟩ ∣ + ∣ d ∣ + O ( log ( ∣ d ∣ + 2 ) ) |\langle M\rangle|=|\langle F^{b}\rangle|+|d|+O(\log(|d|+2)) ∣ ⟨ M ⟩ ∣ = ∣ ⟨ F b ⟩ ∣ + ∣ d ∣ + O ( log ( ∣ d ∣ + 2 )) with an absolute implied constant. This is the form the constructions below use, since the clock coefficients are part of what the caller supplies and not of the data.
Rigidity. Let w w w be a codeword, let w ′ w' w ′ differ from w w w in the single position i i i , and let z z z be arbitrary. Write r = ∣ ρ ( o ) ∣ r=|\rho(o)| r = ∣ ρ ( o ) ∣ for the object o o o that w w w encodes and k = ∣ bin ( r ) ∣ + 1 k=|\operatorname{bin}(r)|+1 k = ∣ bin ( r ) ∣ + 1 for the number of header blocks. The codeword has 3 k + r + 1 3k+r+1 3 k + r + 1 bits, of which the first 3 k 3k 3 k form the header, the next r r r are ρ ( o ) \rho(o) ρ ( o ) , and the last is the parity bit. The position i i i therefore lies in exactly one of these three regions, and the two cases below are exhaustive.
Suppose some codeword u u u prefixes w ′ z w'z w ′ z . Every codeword begins with a header of legal blocks, and both parses start at the first bit. The blocks of u u u therefore occupy the same positions as those of w ′ w' w ′ , and the two parses read the same positions until one of them stops. Moreover, w ′ w' w ′ agrees with w w w off position i i i .
If i i i lies in the header of w w w , let B j B_j B j be the block containing it, so j ≤ k j\le k j ≤ k . Every legal block has even Hamming weight, so the corrupted block has odd weight and is not legal. The blocks before it are untouched, and none of them is A e n d A_{\mathrm{end}} A end : that block occurs in the header of w w w only as the last one, which is B j B_j B j or comes after it.
Concretely, the blocks 1 , … , j − 1 1,\ldots,j-1 1 , … , j − 1 of w w w lie inside blk ( bin ( r ) ) \operatorname{blk}(\operatorname{bin}(r)) blk ( bin ( r )) and are therefore each A 0 A_0 A 0 or A 1 A_1 A 1 . The flip does not touch them, so they are also the blocks 1 , … , j − 1 1,\ldots,j-1 1 , … , j − 1 of w ′ w' w ′ , hence of u u u . Since the header of a codeword terminates at its first A e n d A_{\mathrm{end}} A end block, the parse of u u u cannot stop before block j j j , and at block j j j it meets an illegal block. No such u u u exists.
If i i i lies in ρ ( o ) \rho(o) ρ ( o ) or in the parity bit, then w ′ w' w ′ has the same header as w w w : blocks 1 , … , k − 1 1,\ldots,k-1 1 , … , k − 1 are A 0 A_0 A 0 or A 1 A_1 A 1 , and block k k k is A e n d A_{\mathrm{end}} A end . The header of u u u therefore stops exactly at block k k k , and it is the header of w w w . Hence u u u announces the same length r r r as w w w and has the same total length 3 k + r + 1 3k+r+1 3 k + r + 1 . So u u u is the prefix of w ′ z w'z w ′ z of that length, which is w ′ w' w ′ itself. If i i i lies in ρ ( o ) \rho(o) ρ ( o ) , the announced bits of w ′ w' w ′ have the opposite parity to those of w w w while the parity bit is unchanged. If i i i is the parity bit, the announced bits are unchanged and the parity bit is flipped. Either way w ′ w' w ′ fails the parity check and is not a codeword. Therefore no codeword prefixes w ′ z w'z w ′ z .
Uniform Simulation and Native Clocks
Bounded native execution has a uniform interpreter. We give the configuration construction because the later clocks depend on uniformity in the supplied machine code.
Fact 3.4 (Uniform simulation of multitape machines; folklore strengthening of [1 Theorem 1.9 of the published edition] , see also [14 ] ). There are a multitape Turing machine Sim \operatorname{Sim} Sim and a polynomial q Sim q_{\operatorname{Sim}} q Sim such that, for every multitape Turing machine M M M , every input z z z , and every T T T , the machine Sim \operatorname{Sim} Sim on input ( ⟨ M ⟩ , z , 1 T ) (\langle M\rangle,z,1^{T}) (⟨ M ⟩ , z , 1 T ) outputs the configuration of M ( z ) M(z) M ( z ) after T T T steps, in time at most q Sim ( T , ∣ z ∣ , ∣ ⟨ M ⟩ ∣ ) q_{\operatorname{Sim}}(T,|z|,|\langle M\rangle|) q Sim ( T , ∣ z ∣ , ∣ ⟨ M ⟩ ∣ ) , the polynomial q Sim q_{\operatorname{Sim}} q Sim and its degree not depending on M M M . The same holds for a machine taking its two inputs p p p and y y y on separate read-only tapes.
Proof. The sources state the halting simulation with an overhead whose constant depends on M M M . The constructions below need two things those statements do not give: the configuration after a prescribed number of steps, whether or not the computation has halted, and an overhead uniform in ∣ ⟨ M ⟩ ∣ |\langle M\rangle| ∣ ⟨ M ⟩ ∣ . One construction supplies both, and we record it rather than cite it.
The simulator first lays out the initial configuration of M ( z ) M(z) M ( z ) , writing the hardwired data string d d d across the simulated work tapes in the layout that ρ ( F ) \rho(F) ρ ( F ) declares, as Definition 2.3 requires of that configuration. It then carries the k k k tapes of M M M interleaved on a single work tape, one track apiece, with a further track per tape marking that tape’s head, and it keeps the step count in unary on a second work tape. It reads the transition table off its own input rather than holding it in its control. That is what turns a dependence on M M M into a dependence on ∣ ⟨ M ⟩ ∣ |\langle M\rangle| ∣ ⟨ M ⟩ ∣ .
The number of tapes of M M M and the width of its alphabet are both bounded by ∣ ⟨ M ⟩ ∣ |\langle M\rangle| ∣ ⟨ M ⟩ ∣ , so one column of the interleaving, carrying one cell of each tape together with the head markers, occupies O ( ∣ ⟨ M ⟩ ∣ 2 ) O(|\langle M\rangle|^2) O ( ∣ ⟨ M ⟩ ∣ 2 ) cells of the simulator. The layout occupies ∣ d ∣ ≤ ∣ ⟨ M ⟩ ∣ |d| \leq|\langle M\rangle| ∣ d ∣ ≤ ∣ ⟨ M ⟩ ∣ columns before the first step, and the region in use after T T T steps therefore spans O ( ∣ ⟨ M ⟩ ∣ 2 ( T + ∣ z ∣ + ∣ ⟨ M ⟩ ∣ ) ) O(|\langle M\rangle|^2(T+|z|+|\langle M\rangle|)) O ( ∣ ⟨ M ⟩ ∣ 2 ( T + ∣ z ∣ + ∣ ⟨ M ⟩ ∣ )) cells.
One simulated step sweeps that region and makes one lookup in the table. The lookup costs O ( ∣ ⟨ M ⟩ ∣ ) O(|\langle M\rangle|) O ( ∣ ⟨ M ⟩ ∣ ) , so, including initialization and the final configuration output, the total is bounded by O ( ( T + 1 ) ( ∣ ⟨ M ⟩ ∣ + 1 ) 3 ( T + ∣ z ∣ + ∣ ⟨ M ⟩ ∣ + 1 ) ) O((T+1)(|\langle M\rangle|+1)^3(T+|z|+|\langle M\rangle|+1)) O (( T + 1 ) ( ∣ ⟨ M ⟩ ∣ + 1 ) 3 ( T + ∣ z ∣ + ∣ ⟨ M ⟩ ∣ + 1 )) . That is a polynomial in T T T , ∣ z ∣ |z| ∣ z ∣ and ∣ ⟨ M ⟩ ∣ |\langle M\rangle| ∣ ⟨ M ⟩ ∣ whose degree does not depend on M M M , which is what the fact asserts. The simulator halts after simulating exactly T T T steps, with the resulting configuration written out whether or not M M M has halted. □
We now fix one machine with both the simulation property of Definition 2.6 and the interpretation property of Definition 2.7.
Definition 3.5 (The reference machine). The reference machine U U U is defined as follows: if y = ε y=\varepsilon y = ε and p = ⟨ M ⟩ z p=\langle M\rangle z p = ⟨ M ⟩ z for the unique machine encoding ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ that prefixes p p p , then U ( p , y ) U(p,y) U ( p , y ) runs M ( z ) M(z) M ( z ) ; if y = ⟨ M ⟩ y=\langle M\rangle y = ⟨ M ⟩ , it runs M ( p ) M(p) M ( p ) ; and in every other case it diverges. We call the first the simulation branch and the second the interpretation branch . In both branches ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ ranges over the encodings of machines and of clocked machines alike, in the sense of Definition 3.6. A clocked M M M is run under its clock, so U ( p , ⟨ M ⟩ ) = ⊥ U(p,\langle M\rangle)=\bot U ( p , ⟨ M ⟩) = ⊥ when that clock expires. A prefixing codeword of any other type is not a machine encoding, and U U U diverges. Because its encoding is rigid (Proposition 3.3), we also call U U U the rigid reference .
Such a machine exists and meets both requirements. The parse is unique because ⟨ ⋅ ⟩ \langle\cdot\rangle ⟨ ⋅ ⟩ is prefix-free, and the two branches do not collide because ε \varepsilon ε is not a codeword of Definition 3.2: every codeword there has length at least seven. Universality holds directly, and not by way of either property, since the statements of both presuppose it. For x ∈ { 0 , 1 } x\in\{0,1\} x ∈ { 0 , 1 } , let M x M_x M x ignore its input and print x x x ; then U ( ⟨ M x ⟩ , ε ) = M x ( ε ) = x U(\langle M_x\rangle,\varepsilon)=M_x(\varepsilon)=x U (⟨ M x ⟩ , ε ) = M x ( ε ) = x . Efficiency is automatic under the model fixed above. Both properties hold with a single polynomial, by Fact 3.4, whose overhead is uniform in ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ . That is exactly the uniformity the two definitions ask for.
The clock presentation below makes every construction that wraps a supplied clocked machine uniform in that machine. It also specifies how a timeout differs from a normal empty output.
Definition 3.6 (Clocked machine). Use the fixed absolute degree bound D ≥ 1 D\geq1 D ≥ 1 introduced above. A clocked machine supplied as a decider (Definition 3.15) is written calligraphically as D \mathcal{D} D to distinguish it from this degree bound.
A clocked machine is a pair consisting of the code of a Turing machine and a clock c ( n ) = ∑ i ≤ D c i n i c(n)=\sum_{i\leq D}c_i n^i c ( n ) = ∑ i ≤ D c i n i of degree at most D D D , evaluated at the input length, so that a computation of the machine on an input a a a is granted c ( ∣ a ∣ ) c(|a|) c ( ∣ a ∣ ) steps.
The coefficients c i ∈ N c_i\in\mathbb{N} c i ∈ N are written in unary inside the code, so that the encoding length of a clocked machine may grow with the input length. They are natural numbers, which is what makes c c c non-decreasing on N \mathbb{N} N . We adopt the convention 0 0 = 1 0^0=1 0 0 = 1 , so that c ( 0 ) = c 0 c(0)=c_0 c ( 0 ) = c 0 , and require c 0 ≥ 1 c_0\geq1 c 0 ≥ 1 , so that a clocked machine is granted at least one step on every input, the empty one included.
It is run under its clock. If the clock expires it halts with a distinguished output ⊥ ∉ { 0 , 1 } ∗ \bot\notin\{0,1\}^* ⊥ ∈ / { 0 , 1 } ∗ . A timed-out computation is therefore a rejection when the machine is used as a decider, and it yields no string, hence no description, when the machine is used as a verifier. Here a verifier is a machine, clocked or not, whose normal outputs serve as targets, as opposed to a decider, whose outputs are the verdicts 0 0 0 and 1 1 1 . Since ⊥ \bot ⊥ is not a string, U ( p , y ) = ⊥ U(p,y)=\bot U ( p , y ) = ⊥ differs from every target, the empty target included.
Whenever a polynomial-time machine is supplied as input to one of the constructions below, it is presented in this form, and the relevant input length is given in unary as well. The degree bound and the unary coefficients together give what the constructions need, namely one polynomial serving for every clocked machine at once.
A construction that wraps a supplied clocked machine must present its clock by that machine’s own coefficients, and not by the value of its clock at a hardwired length. A unary constant coefficient costs as many bits as the running time it names, so the wrapper’s encoding would grow with that running time. The fixed degree bound and the unary representation of the coefficients are both needed for a uniform polynomial bound in input length and code size.
Multiplying the supplied clock by a fixed constant and adding a linear polynomial preserves degree at most D ≥ 1 D \ge1 D ≥ 1 . Scaling and adding the unary coefficients takes polynomial time. This is the closure used by the native wrappers below.
The fixed degree and explicit unary coefficients bound every supplied clock by one polynomial in input length and code size.
Lemma 3.7 (Uniform clock bound). Let M M M be a clocked machine with clock c c c in the sense of Definition 3.6. Then
c ( n ) ≤ ( n + ∣ ⟨ M ⟩ ∣ + D ) D + 2 (3) c(n) \le(n + \lvert\langle M\rangle\rvert+ D)^{D+2} \tag*{(3)} c ( n ) ≤ ( n + ∣⟨ M ⟩∣ + D ) D + 2 (3) for every n ≥ 0 n \ge0 n ≥ 0 , and 1 c ( n ) 1^{c(n)} 1 c ( n ) is computable from ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ and 1 n 1^n 1 n in time polynomial in n + ∣ ⟨ M ⟩ ∣ n + \lvert\langle M\rangle\rvert n + ∣⟨ M ⟩∣ .
Proof. The D + 1 D+1 D + 1 unary blocks 1 c 0 , … , 1 c D 1^{c_0},\ldots,1^{c_D} 1 c 0 , … , 1 c D are disjoint substrings of ρ ( M ) \rho(M) ρ ( M ) by Eq. (1) , so ∑ i ≤ D c i ≤ ∣ ρ ( M ) ∣ ≤ ∣ ⟨ M ⟩ ∣ \sum_{i\le D} c_i \le\lvert\rho(M)\rvert\le\lvert\langle M\rangle\rvert ∑ i ≤ D c i ≤ ∣ ρ ( M )∣ ≤ ∣⟨ M ⟩∣ . Also ∣ ⟨ M ⟩ ∣ ≥ 1 \lvert\langle M\rangle\rvert\ge1 ∣⟨ M ⟩∣ ≥ 1 , since a code is a nonempty string. For every n ≥ 0 n \ge0 n ≥ 0 and every i ≤ D i \le D i ≤ D we have n i ≤ ( n + 1 ) i ≤ ( n + 1 ) D n^i \le(n+1)^i \le(n+1)^D n i ≤ ( n + 1 ) i ≤ ( n + 1 ) D , so
c ( n ) = ∑ i ≤ D c i n i ≤ ( ∑ i ≤ D c i ) ( n + 1 ) D ≤ ∣ ⟨ M ⟩ ∣ ( n + 1 ) D . c(n) = \sum_{i\le D} c_i n^i \le\left(\sum_{i\le D} c_i\right)(n+1)^D \le\lvert\langle M\rangle\rvert(n+1)^D. c ( n ) = i ≤ D ∑ c i n i ≤ ( i ≤ D ∑ c i ) ( n + 1 ) D ≤ ∣⟨ M ⟩∣ ( n + 1 ) D . Write β 0 = n + ∣ ⟨ M ⟩ ∣ + D \beta_0=n+\lvert\langle M\rangle\rvert+D β 0 = n + ∣⟨ M ⟩∣ + D . Then ∣ ⟨ M ⟩ ∣ ≤ β 0 \lvert\langle M\rangle\rvert\le\beta_0 ∣⟨ M ⟩∣ ≤ β 0 and n + 1 ≤ β 0 n+1\le\beta_0 n + 1 ≤ β 0 , the latter because ∣ ⟨ M ⟩ ∣ + D ≥ 1 \lvert\langle M\rangle\rvert+D\ge1 ∣⟨ M ⟩∣ + D ≥ 1 . Multiplying gives
c ( n ) ≤ ∣ ⟨ M ⟩ ∣ ( n + 1 ) D ≤ β 0 ⋅ β 0 D ≤ β 0 D + 2 = ( n + ∣ ⟨ M ⟩ ∣ + D ) D + 2 , c(n) \le\lvert\langle M\rangle\rvert(n+1)^D \le\beta_0\cdot\beta_0^D \le\beta_0^{D+2}=(n+\lvert\langle M\rangle\rvert+D)^{D+2}, c ( n ) ≤ ∣⟨ M ⟩∣ ( n + 1 ) D ≤ β 0 ⋅ β 0 D ≤ β 0 D + 2 = ( n + ∣⟨ M ⟩∣ + D ) D + 2 , which is Eq. (3) . Since D D D is an absolute constant, the right-hand side is a fixed polynomial in n + ∣ ⟨ M ⟩ ∣ n+\lvert\langle M\rangle\rvert n + ∣⟨ M ⟩∣ . Parse the unary coefficients and the supplied string 1 n 1^n 1 n . For each i = 0 , … , D i=0,\ldots,D i = 0 , … , D , begin with 1 c i 1^{c_i} 1 c i and, i i i times, replace every symbol 1 1 1 by a copy of 1 n 1^n 1 n on a blank work tape. The intermediate strings have length at most ∣ ⟨ M ⟩ ∣ ( n + 1 ) D \lvert\langle M\rangle\rvert(n+1)^D ∣⟨ M ⟩∣ ( n + 1 ) D ; nested tape scans therefore implement each replacement in time polynomial in n + ∣ ⟨ M ⟩ ∣ n+\lvert\langle M\rangle\rvert n + ∣⟨ M ⟩∣ . Concatenating the resulting D + 1 D+1 D + 1 strings produces 1 c ( n ) 1^{c(n)} 1 c ( n ) within the same kind of polynomial bound. This includes n = 0 n=0 n = 0 and zero nonconstant coefficients; parsing and setup are charged independently of the output length. The additive D D D is a convenience rather than a necessity: the display above already gives c ( n ) ≤ ( n + ∣ ⟨ M ⟩ ∣ ) D + 2 c(n)\le(n+\lvert\langle M\rangle\rvert)^{D+2} c ( n ) ≤ ( n + ∣⟨ M ⟩∣ ) D + 2 , because n + ∣ ⟨ M ⟩ ∣ ≥ n + 1 n+\lvert\langle M\rangle\rvert\ge n+1 n + ∣⟨ M ⟩∣ ≥ n + 1 and n + ∣ ⟨ M ⟩ ∣ ≥ ∣ ⟨ M ⟩ ∣ ≥ 1 n+\lvert\langle M\rangle\rvert\ge\lvert\langle M\rangle\rvert\ge1 n + ∣⟨ M ⟩∣ ≥ ∣⟨ M ⟩∣ ≥ 1 . □ \square □
Numerical Description-Length Comparison
The numerical measure will be used only to compare machines; the connectivity questions retain every feasible description.
Definition 3.8 (Time-bounded conditional Kolmogorov complexity). For x , y ∈ { 0 , 1 } ∗ x,y\in\{0,1\}^* x , y ∈ { 0 , 1 } ∗ and a deadline t ∈ N t\in\mathbb{N} t ∈ N , the time-bounded conditional Kolmogorov complexity of x x x given y y y is
K M t ( x ∣ y ) = min { ∣ p ∣ ∣ p ∈ { 0 , 1 } ∗ and U ( p , y ) = x within t steps } , (4) K_M^t(x\mid y)=\min\{\lvert p\rvert\mid p\in\{0,1\}^* \text{ and } U(p,y)=x\text{ within }t\text{ steps}\}, \tag*{(4)} K M t ( x ∣ y ) = min {∣ p ∣ ∣ p ∈ { 0 , 1 } ∗ and U ( p , y ) = x within t steps } , (4) with the convention that the minimum of the empty set is + ∞ +\infty + ∞ .
A subscript V V V replaces the reference machine by V V V , and K V t ( x ) = K V t ( x ∣ ε ) K_V^t(x)=K_V^t(x\mid\varepsilon) K V t ( x ) = K V t ( x ∣ ε ) is the unconditional form. The value is infinite when no such program exists. In particular it is infinite whenever ∣ x ∣ > t \lvert x\rvert>t ∣ x ∣ > t , since a computation delivering x x x takes at least ∣ x ∣ \lvert x\rvert ∣ x ∣ steps (Definition 2.3 ). The following truncation bound also bounds the length of a shortest program.
Lemma 3.9 (Witness truncation). For every machine M M M , every x x x , and every t t t , if K M t ( x ) K_M^t(x) K M t ( x ) is finite then K M t ( x ) ≤ t + 1 K_M^t(x)\le t+1 K M t ( x ) ≤ t + 1 .
The bound is folklore for models of the kind fixed in [14 Section 7.1] , which states no such theorem. We verify it for the model of § 2.2 , since it depends on that model’s head discipline and read-only tape layout.
Proof. Suppose K M t ( x ) K_M^t(x) K M t ( x ) is finite and let p p p be a witness, so M ( p ) = x M(p)=x M ( p ) = x within t t t steps. By the model of § 2.2 the program tape is read-only, its head begins on cell 1 1 1 , and it moves by at most one cell per step. An induction on j j j then gives that after j j j steps the head is on a cell of index at most j + 1 j+1 j + 1 . The symbol read during step s s s is the one under the head after s − 1 s-1 s − 1 steps, hence lies at a cell of index at most s s s . As the computation halts after some j ≤ t j\le t j ≤ t steps, every program cell that it reads has index at most t t t , and a fortiori at most t + 1 t+1 t + 1 .
:::
Let p ′ p' p ′ be the first min ( ∣ p ∣ , t + 1 ) \min(|p|,t+1) min ( ∣ p ∣ , t + 1 ) bits of p p p , so p ′ = p p'=p p ′ = p when ∣ p ∣ ≤ t + 1 |p|\le t+1 ∣ p ∣ ≤ t + 1 and ∣ p ′ ∣ = t + 1 |p'|=t+1 ∣ p ′ ∣ = t + 1 otherwise. The two program tapes carrying p p p and p ′ p' p ′ agree on every cell of index at most t + 1 t+1 t + 1 . Beyond that index the first carries bits of p p p , and the second carries either bits of p p p or the blank symbol.
We show by simultaneous induction on s ≤ j s\le j s ≤ j that after s s s steps the two computations are in the same state, have all their heads on the same cells, carry the same contents on every tape other than the program tape, and have their program-tape heads on a cell of index at most s + 1 ≤ t + 1 s+1\le t+1 s + 1 ≤ t + 1 . The base case s = 0 s=0 s = 0 is the common initial configuration.
For the inductive step, the transition taken depends only on the current state and on the symbols under the heads. The symbols on the tapes other than the program tape agree by the inductive hypothesis. The program symbol is read at an index at most s + 1 ≤ j ≤ t s+1\le j\le t s + 1 ≤ j ≤ t , where the two program tapes agree, so the same transition is taken and all four clauses persist. Hence M ( p ′ ) = M ( p ) = x M(p')=M(p)=x M ( p ′ ) = M ( p ) = x within the same j ≤ t j\le t j ≤ t steps, so p ′ p' p ′ is a witness and K M t ( x ) ≤ ∣ p ′ ∣ ≤ t + 1 K_M^t(x)\le|p'|\le t+1 K M t ( x ) ≤ ∣ p ′ ∣ ≤ t + 1 . □
The usual resource-bounded invariance principle has the following form for adjunction. Its per-machine polynomial is proved explicitly here; compare the particular efficient reference in [14 Theorem 7.1.1] .
Fact 3.10 (Invariance from adjunction). Let V V V be an efficient universal machine with the simulation property of Definition 2.6 . For every machine M M M there are a constant c M c_M c M and a polynomial q q q such that, for every string x x x and every deadline t t t ,
K V q ( t ) ( x ) ≤ K M t ( x ) + c M , K_V^{q(t)}(x)\le K_M^t(x)+c_M, K V q ( t ) ( x ) ≤ K M t ( x ) + c M , where K M t K_M^t K M t is the time-t t t measure taken against M M M , in the notation just fixed.
Proof. That the polynomial q q q depends on t t t alone is not obvious, since Definition 2.6 grants an overhead polynomial in the running time of M M M and in the length of the simulated program.
Explicitly, let q 0 q_0 q 0 and M ↦ ⟨ M ⟩ V M\mapsto\langle M\rangle_V M ↦ ⟨ M ⟩ V witness the simulation property of V V V , and put c M = ∣ ⟨ M ⟩ V ∣ c_M=|\langle M\rangle_V| c M = ∣ ⟨ M ⟩ V ∣ and q ( t ) = q 0 ( t , t + 1 , c M ) q(t)=q_0(t,t+1,c_M) q ( t ) = q 0 ( t , t + 1 , c M ) , a polynomial in t t t for each fixed M M M .
If K M t ( x ) = + ∞ K_M^t(x)=+\infty K M t ( x ) = + ∞ the inequality is vacuous. Otherwise let p p p be a shortest witness, so that M ( p ) = x M(p)=x M ( p ) = x within some T ≤ t T\le t T ≤ t steps and ∣ p ∣ = K M t ( x ) |p|=K_M^t(x) ∣ p ∣ = K M t ( x ) , which is at most t + 1 t+1 t + 1 by Lemma 3.9. Then V ( ⟨ M ⟩ V p , ε ) = M ( p ) = x V(\langle M\rangle_Vp,\varepsilon)=M(p)=x V (⟨ M ⟩ V p , ε ) = M ( p ) = x within q 0 ( T , ∣ p ∣ , c M ) ≤ q ( t ) q_0(T,|p|,c_M)\le q(t) q 0 ( T , ∣ p ∣ , c M ) ≤ q ( t ) steps, since q 0 q_0 q 0 is nondecreasing in each argument. Hence K V q ( t ) ( x ) ≤ ∣ ⟨ M ⟩ V p ∣ = K M t ( x ) + c M K_V^{q(t)}(x)\le|\langle M\rangle_Vp|=K_M^t(x)+c_M K V q ( t ) ( x ) ≤ ∣ ⟨ M ⟩ V p ∣ = K M t ( x ) + c M .
Both c M c_M c M and q q q depend on M M M and on V V V and on nothing else. That q q q depends on t t t alone, and not on the complexity, is supplied by Lemma 3.9.
Apply this in both directions to a pair of machines with the simulation property. The measure K M t ( x ) K_M^t(x) K M t ( x ) is then determined by x x x and t t t up to an additive constant in the length budget and a polynomial change in the deadline, whichever of the two machines is used. □
Implicit Graphs and Space Bounds
For a general finite connected graph, the number of vertices gives a simple diameter bound.
Lemma 3.11 (Diameter of a finite connected graph). A connected graph with k ≥ 1 k\ge1 k ≥ 1 vertices has diameter at most k − 1 k-1 k − 1 .
Proof. A walk of least length between two vertices repeats no vertex, since deleting the portion between two occurrences of one leaves a shorter walk, so it visits at most k k k vertices and traverses at most k − 1 k-1 k − 1 edges. □
The computational input usually describes an exponentially larger graph through vertex and adjacency tests.
Definition 3.12 (Implicit presentation). Implicitness is a property not of a single finite graph, for which the conditions below hold by table lookup, but of a family presented by a string. A family { G w } w ∈ { 0 , 1 } ∗ \{G_w\}_{w\in\{0,1\}^*} { G w } w ∈ { 0 , 1 } ∗ of graphs is implicitly presented if there are a polynomial μ \mu μ , a set W ⊆ { 0 , 1 } ∗ \mathcal{W}\subseteq\{0,1\}^* W ⊆ { 0 , 1 } ∗ of well-formed presenting strings, and algorithms A W A_{\mathcal{W}} A W , A V A_V A V and A E A_E A E , each running in time polynomial in the total length of its arguments, such that
every vertex of G w G_w G w is a string of length at most μ ( ∣ w ∣ ) \mu(|w|) μ ( ∣ w ∣ ) ;
A V ( w , r ) A_V(w,r) A V ( w , r ) decides whether r ∈ V ( G w ) r \in V(G_w) r ∈ V ( G w ) ; and
A E ( w , r , r ′ ) A_E(w,r,r') A E ( w , r , r ′ ) decides whether r ∼ G w r ′ r \sim_{G_w} r' r ∼ G w r ′ .
The set W \mathcal{W} W is what makes the family total on { 0 , 1 } ∗ \{0,1\}^* { 0 , 1 } ∗ , and it is where each presentation below records the shape its tests assume. We say that G w G_w G w is implicit when the presenting family is clear from the context, as it is at every use below. The s t st s t -connectivity question for such a family asks, given w w w and two strings r r r and r ′ r' r ′ , whether both are vertices of G w G_w G w and are connected in G w G_w G w .
We use polynomial time and polynomial space with respect to the full binary input length, and polynomial-time many-one reductions.
Definition 3.13 (Complexity classes and many-one reductions). We write P for the class of decision problems solvable by a deterministic Turing machine in time polynomial in the input length, and NP for those whose yes-instances admit certificates of polynomial length checkable in polynomial time. Similarly, PSPACE denotes the class of decision problems solvable by a deterministic Turing machine in space polynomial in the input length, and NPSPACE the class of those solvable by a nondeterministic Turing machine in polynomial space.
For functions s s s we write DSPACE( s ) (s) ( s ) and NSPACE( s ) (s) ( s ) for the deterministic and nondeterministic classes at space bound s s s , so that PSPACE = ⋃ k ≥ 1 = \bigcup_{k\geq1} = ⋃ k ≥ 1 DSPACE( n k ) (n^k) ( n k ) and NPSPACE = ⋃ k ≥ 1 = \bigcup_{k\geq1} = ⋃ k ≥ 1 NSPACE( n k ) (n^k) ( n k ) .
A promise problem is a pair ( Π y e s , Π n o ) (\Pi_{\mathrm{yes}},\Pi_{\mathrm{no}}) ( Π yes , Π no ) of disjoint sets of strings, and an algorithm solves it if it accepts every element of Π y e s \Pi_{\mathrm{yes}} Π yes and rejects every element of Π n o \Pi_{\mathrm{no}} Π no , its behavior on every other input being unconstrained. A language L L L is identified with the promise problem ( L , { 0 , 1 } ∗ ∖ L ) (L,\{0,1\}^* \setminus L) ( L , { 0 , 1 } ∗ ∖ L ) , so that the two readings agree on decision problems and every notion below applies to languages as a special case. A promise problem lies in PSPACE if some deterministic algorithm running in space polynomial in the input length solves it, and lies in P if some deterministic algorithm running in time polynomial in the input length solves it.
A polynomial-time many-one reduction from ( Π y e s , Π n o ) (\Pi_{\mathrm{yes}},\Pi_{\mathrm{no}}) ( Π yes , Π no ) to ( Σ y e s , Σ n o ) (\Sigma_{\mathrm{yes}},\Sigma_{\mathrm{no}}) ( Σ yes , Σ no ) is a polynomial-time computable f f f with f ( Π y e s ) ⊆ Σ y e s f(\Pi_{\mathrm{yes}}) \subseteq\Sigma_{\mathrm{yes}} f ( Π yes ) ⊆ Σ yes and f ( Π n o ) ⊆ Σ n o f(\Pi_{\mathrm{no}}) \subseteq\Sigma_{\mathrm{no}} f ( Π no ) ⊆ Σ no , nothing being asked of f f f outside Π y e s ∪ Π n o \Pi_{\mathrm{yes}} \cup\Pi_{\mathrm{no}} Π yes ∪ Π no .
A promise problem is PSPACE-hard if every language in PSPACE, read as above, reduces to it in this sense, and PSPACE-complete if it is PSPACE-hard and lies in PSPACE.
If ( Π y e s , Π n o ) (\Pi_{\mathrm{yes}},\Pi_{\mathrm{no}}) ( Π yes , Π no ) reduces to ( Σ y e s , Σ n o ) (\Sigma_{\mathrm{yes}},\Sigma_{\mathrm{no}}) ( Σ yes , Σ no ) by f f f , and an algorithm A A A of one of the two resource bounds solves the latter, then A ∘ f A \circ f A ∘ f solves the former within the same bound, the output of f f f being polynomially bounded in length. Both classes are therefore closed downward under these reductions, promise problems included.
Reductions compose. If f f f reduces the first pair to the second and g g g reduces the second to ( Ξ y e s , Ξ n o ) (\Xi_{\mathrm{yes}},\Xi_{\mathrm{no}}) ( Ξ yes , Ξ no ) , then g ∘ f g \circ f g ∘ f is computable in polynomial time and carries Π y e s \Pi_{\mathrm{yes}} Π yes into Ξ y e s \Xi_{\mathrm{yes}} Ξ yes and Π n o \Pi_{\mathrm{no}} Π no into Ξ n o \Xi_{\mathrm{no}} Ξ no , so it reduces the first to the third. In particular, reducing a PSPACE-hard promise problem to a promise problem Ξ \Xi Ξ makes Ξ \Xi Ξ itself PSPACE-hard, which is the form every hardness argument below takes.
The next proof gives the finite-graph recursive argument in full. The midpoint recursion follows Savitch’s quadratic-space simulation method [18 ] ; [1 Theorem 4.14, Section 4.2.1] gives a textbook exposition. We need the stated endpoint tests and space bound for the graph presentation used here.
Lemma 3.14 (Reachability in an implicit graph). Let { G w } w ∈ { 0 , 1 } ∗ \{G_w\}_{w\in\{0,1\}^*} { G w } w ∈ { 0 , 1 } ∗ be implicitly presented in the sense of Definition 3.12 , with vertex length bound μ \mu μ and tests A V A_V A V and A E A_E A E . Deciding, given w w w and two strings r , r ′ r,r' r , r ′ , whether both are vertices of G w G_w G w and are connected in G w G_w G w is possible in space polynomial in ∣ w ∣ + log ( ∣ r ∣ + ∣ r ′ ∣ + 2 ) |w|+\log(|r|+|r'|+2) ∣ w ∣ + log ( ∣ r ∣ + ∣ r ′ ∣ + 2 ) , hence in space polynomial in ∣ w ∣ |w| ∣ w ∣ whenever ∣ r ∣ |r| ∣ r ∣ and ∣ r ′ ∣ |r'| ∣ r ′ ∣ are bounded by 2 poly ( ∣ w ∣ ) 2^{\operatorname{poly}(|w|)} 2 poly ( ∣ w ∣ ) , as they are at every use below.
Proof. Increase the polynomial bound μ \mu μ to a nonnegative integer-valued bound if necessary and put m = μ ( ∣ w ∣ ) m=\mu(|w|) m = μ ( ∣ w ∣ ) . First check that w w w is well formed, and reject otherwise. Count each endpoint’s length and reject it as soon as that count exceeds m m m . The fields of the input triple ( w , r , r ′ ) (w,r,r') ( w , r , r ′ ) and these counters can be read using space polynomial in ∣ w ∣ |w| ∣ w ∣ plus O ( log ( ∣ r ∣ + ∣ r ′ ∣ + 2 ) ) O(\log(|r|+|r'|+2)) O ( log ( ∣ r ∣ + ∣ r ′ ∣ + 2 )) ; the fixed arity of the triple and its binary length fields require only logarithmic counters. Once both endpoints pass, store them and run A V A_V A V on each. These tests have arguments of length polynomial in ∣ w ∣ |w| ∣ w ∣ . Reject unless both are vertices. For vertices u , v u,v u , v , define a recursive Boolean procedure R i ( u , v ) R_i(u,v) R i ( u , v ) . At i = 0 i=0 i = 0 , accept exactly when u = v u=v u = v or A E ( w , u , v ) = 1 A_E(w,u,v)=1 A E ( w , u , v ) = 1 . For i > 0 i>0 i > 0 , enumerate all strings z z z of length at most m m m . Discard z z z unless A V ( w , z ) = 1 A_V(w,z)=1 A V ( w , z ) = 1 . For each remaining z z z , evaluate R i − 1 ( u , z ) R_{i-1}(u,z) R i − 1 ( u , z ) and, if it accepts, evaluate R i − 1 ( z , v ) R_{i-1}(z,v) R i − 1 ( z , v ) . Accept if both evaluations accept for some z z z , and reject when enumeration finishes otherwise. The two recursive calls are performed sequentially, reusing their workspace.
Induction on i i i shows that R i ( u , v ) R_i(u,v) R i ( u , v ) accepts exactly when a walk of at most 2 i 2^i 2 i edges joins its endpoints. The base case includes the zero-edge walk. Two accepting recursive calls concatenate to a walk of at most 2 i 2^i 2 i edges. Conversely, split a walk of length at most 2 i 2^i 2 i after its first min ( 2 i − 1 , L ) \min(2^{i-1},L) min ( 2 i − 1 , L ) edges, where L L L is its length. The two resulting walks each have length at most 2 i − 1 2^{i-1} 2 i − 1 and meet at a vertex considered by the enumeration. This proves the induction.
There are at most 2 m + 1 − 1 2^{m+1}-1 2 m + 1 − 1 possible vertices. Every connecting walk can be shortened to a simple path, so R m + 1 ( r , r ′ ) R_{m+1}(r,r') R m + 1 ( r , r ′ ) decides connectivity. Each recursion frame stores a constant number of length-at-most-m m m strings, an enumeration counter and its depth, using O ( m + 1 ) O(m+1) O ( m + 1 ) cells. There are at most m + 2 m+2 m + 2 simultaneous frames. Let P ( ∣ w ∣ + m ) P(|w|+m) P ( ∣ w ∣ + m ) be a fixed polynomial bound for the shared workspace of the vertex and adjacency tests. These tests reuse that workspace. Thus total space is
O ( ( m + 1 ) 2 ) + P ( ∣ w ∣ + m ) + O ( log ( ∣ r ∣ + ∣ r ′ ∣ + 2 ) ) , O((m+1)^2)+P(|w|+m)+O(\log(|r|+|r'|+2)), O (( m + 1 ) 2 ) + P ( ∣ w ∣ + m ) + O ( log ( ∣ r ∣ + ∣ r ′ ∣ + 2 )) ,
which has the asserted form. Equal valid endpoints, m = 0 m=0 m = 0 , and empty graphs are included in the same procedure. If endpoint lengths are at most 2 poly ( ∣ w ∣ ) 2^{\operatorname{poly}(|w|)} 2 poly ( ∣ w ∣ ) , the logarithmic term is polynomial in ∣ w ∣ |w| ∣ w ∣ as well. □
Predicates and the Reconfiguration Problem for Formulas
Predicates may be supplied as clocked deciders. Our hardness reductions use formulas with explicit satisfying endpoints.
Definition 3.15 (Predicates and clocked deciders). A predicate at length n n n is a subset R ⊆ { 0 , 1 } n R\subseteq\{0,1\}^n R ⊆ { 0 , 1 } n , and a predicate is a subset R ⊆ { 0 , 1 } ∗ R\subseteq\{0,1\}^* R ⊆ { 0 , 1 } ∗ . A clocked machine M M M in the sense of Definition 3.6 decides R R R at length n n n if M ( a ) = 1 M(a)=1 M ( a ) = 1 for every a ∈ R ∩ { 0 , 1 } n a\in R\cap\{0,1\}^n a ∈ R ∩ { 0 , 1 } n and M ( a ) = 0 M(a)=0 M ( a ) = 0 for every a ∈ { 0 , 1 } n ∖ R a\in\{0,1\}^n\setminus R a ∈ { 0 , 1 } n ∖ R , the outputs being the one-bit strings 1 and 0.
A timed-out computation outputs ⊥ \bot ⊥ and therefore decides nothing, so a decider must finish within its clock at every input of that length.
It decides R R R , without qualification, if M ( a ) = 1 M(a)=1 M ( a ) = 1 for every a ∈ R a\in R a ∈ R and M ( a ) = 0 M(a)=0 M ( a ) = 0 for every a ∈ { 0 , 1 } ∗ ∖ R a\in\{0,1\}^*\setminus R a ∈ { 0 , 1 } ∗ ∖ R , that is, if it decides R R R at every length at once.
A clocked machine runs in time polynomial in its input length by Lemma 3.7 , so we use clocked machine and clocked polynomial-time machine interchangeably. We call R R R a clocked polynomial-time predicate at length n n n , and M M M a clocked polynomial-time decider for it, when such an M M M exists and is the object supplied.
The phrase presented by a clocked polynomial-time decider means that the input to the construction at hand is the pair ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ and 1 n 1^n 1 n , so that a deadline sufficient for running M M M on any a ∈ { 0 , 1 } n a\in\{0,1\}^n a ∈ { 0 , 1 } n may be written down in unary by Lemma 3.7 . Nothing is asked of M M M at lengths other than n n n , which is why the length is named in the phrase clocked polynomial-time predicate at length n n n .
Write ∣ φ ∣ = ∣ ρ ( φ ) ∣ |\varphi|=|\rho(\varphi)| ∣ φ ∣ = ∣ ρ ( φ ) ∣ for the size of a formula. Whether a given assignment satisfies a given formula is decidable in time O ( ( ∣ φ ∣ + n + 1 ) 3 ) O((|\varphi|+n+1)^3) O (( ∣ φ ∣ + n + 1 ) 3 ) on the multitape model of § 2.2 . Here is an explicit polynomial bound, including n = 0 n=0 n = 0 . Put S = ∣ φ ∣ + n + 1 S=|\varphi|+n+1 S = ∣ φ ∣ + n + 1 . Scan the encoded formula from left to right, keeping binary counters for clause widths and literal indices. All fields and counters needed for a valid formula have at most O ( S ) O(S) O ( S ) positions. Decoding each encoded bit, updating a counter and resetting its head can therefore be done with O ( S ) O(S) O ( S ) transitions, for O ( S 2 ) O(S^2) O ( S 2 ) total parsing time.
For each literal, first move the assignment head left n n n times, which leaves it at cell one under the left-end rule, and then move right to the indexed variable. There are at most n n n further head moves, each implementable with an O ( S ) O(S) O ( S ) -time counter operation, followed by a read of that variable. Thus the at most O ( ∣ φ ∣ ) O(|\varphi|) O ( ∣ φ ∣ ) literal tests cost O ( ∣ φ ∣ n S ) O(|\varphi|nS) O ( ∣ φ ∣ n S ) transitions in total. Clause truth flags and the remaining scan counters cost O ( S 2 ) O(S^2) O ( S 2 ) . Since O ( ∣ φ ∣ n S ) ≤ S 3 O(|\varphi|nS)\leq S^3 O ( ∣ φ ∣ n S ) ≤ S 3 , these operations give the asserted bound.
If n = 0 n=0 n = 0 , a valid formula has no literals; the same scan assigns value zero to an empty clause and value one to an empty conjunction, as required by Definition 3.1 . The positive term in S S S also covers the final verdict write.
The difficulty in everything that follows lies in moving between two assignments, not in testing one. The object that holds the reconfiguration structure is accordingly the set of satisfying assignments together with its adjacency, and not that set alone.
Definition 3.16 (Solution set and solution graph). For a Boolean formula ϕ \phi ϕ on n n n variables, in conjunctive normal form as in Definition 3.1 wherever a form is specified, the solution set is
R ϕ = { a ∈ { 0 , 1 } n ∣ ϕ ( a ) = 1 } , (5) R_{\phi} = \{a \in\{0,1\}^{n} \mid\phi(a) = 1\}, \tag*{(5)} R ϕ = { a ∈ { 0 , 1 } n ∣ ϕ ( a ) = 1 } , (5) and the solution graph of ϕ \phi ϕ is the graph with vertex set R ϕ R_{\phi} R ϕ in which two assignments are adjacent when they differ in exactly one variable. Equivalently, it is the subgraph of the n n n -dimensional hypercube induced by R ϕ R_{\phi} R ϕ . More generally, for any R ⊆ { 0 , 1 } n R \subseteq\{0,1\}^{n} R ⊆ { 0 , 1 } n the solution graph of R R R is the subgraph of the hypercube induced by R R R , so that the notion applies to an arbitrary predicate and not only to one presented by a formula.
The problem we reduce from asks about two designated vertices, rather than connectivity of the entire solution graph.
Fact 3.17 (Reconfiguration of satisfying assignments; [10 Theorem 2.9 and Section 3.3 of the full version] ). The following problem is PSPACE-complete. Given a Boolean formula ϕ \phi ϕ in conjunctive normal form on n ≥ 1 n \ge1 n ≥ 1 variables and two satisfying assignments s i n , s o u t ∈ { 0 , 1 } n s_{\mathrm{in}},s_{\mathrm{out}} \in\{0,1\}^{n} s in , s out ∈ { 0 , 1 } n of ϕ \phi ϕ , decide whether there is a sequence of satisfying assignments of ϕ \phi ϕ , beginning at s i n s_{\mathrm{in}} s in and ending at s o u t s_{\mathrm{out}} s out , in which every two consecutive assignments differ in exactly one variable. In the terminology of Definitions 2.2 and 3.16, the question is whether s i n s_{\mathrm{in}} s in and s o u t s_{\mathrm{out}} s out are connected in the solution graph of ϕ \phi ϕ . Hardness holds already when ϕ \phi ϕ is in 3-conjunctive normal form, and the general form stated here follows, every 3-conjunctive normal form being a conjunctive normal form.
The Full Fiber and Its Query Language
The next definitions allow programs of every length up to a budget and programs of one exact length; the results below concern exact lengths only.
Definition 3.18 (Adjacency models). Two strings p , q ∈ { 0 , 1 } ∗ p,q \in\{0,1\}^{*} p , q ∈ { 0 , 1 } ∗ are flip-adjacent if ∣ p ∣ = ∣ q ∣ |p| = |q| ∣ p ∣ = ∣ q ∣ and they differ in exactly one position. They are edit-adjacent if one is obtained from the other by flipping, inserting, or deleting a single bit. Flip-adjacency is the restriction of edit-adjacency to strings of equal length. Indeed, an insertion or a deletion changes the length by exactly one, so if ∣ p ∣ = ∣ q ∣ |p| = |q| ∣ p ∣ = ∣ q ∣ and p p p and q q q are edit-adjacent then the single edit is a flip and they differ in exactly one position. Conversely, a flip is one of the three permitted edits.
Both relations are symmetric, since insertion and deletion are mutually inverse and a flip is its own inverse. Both are irreflexive as well: a flip changes a position, and an insertion or a deletion changes the length. The edit distance between two strings is the least number of single-bit flips, insertions, and deletions carrying one to the other. Edit-adjacency is therefore edit distance one.
We apply these moves only to programs that meet the target and deadline constraints.
Definition 3.19 (Description landscape). For x , y ∈ { 0 , 1 } ∗ x,y \in\{0,1\}^{*} x , y ∈ { 0 , 1 } ∗ , a deadline t t t , a length budget ℓ \ell ℓ , and a length n n n , the description landscape is the set
L ℓ t ( x ∣ y ) = { p ∈ { 0 , 1 } ≤ ℓ ∣ U ( p , y ) = x within t steps } . (6) \mathcal{L}^{t}_{\ell}(x|y) = \{p \in\{0,1\}^{\le\ell} \mid U(p,y) = x \text{ within } t \text{ steps}\}. \tag*{(6)} L ℓ t ( x ∣ y ) = { p ∈ { 0 , 1 } ≤ ℓ ∣ U ( p , y ) = x within t steps } . (6) Its flip graph G ℓ t ( x ∣ y ) \mathcal{G}^{t}_{\ell}(x|y) G ℓ t ( x ∣ y ) has vertex set L ℓ t ( x ∣ y ) \mathcal{L}^{t}_{\ell}(x|y) L ℓ t ( x ∣ y ) and joins two descriptions when they are flip-adjacent; its edit graph E ℓ t ( x ∣ y ) \mathcal{E}^{t}_{\ell}(x|y) E ℓ t ( x ∣ y ) has the same vertex set and joins two descriptions when they are edit-adjacent. The fixed-length landscape is
L n t ( x ∣ y ) = { p ∈ { 0 , 1 } n ∣ U ( p , y ) = x within t steps } , \mathcal{L}^{t}_{n}(x|y) = \{p \in\{0,1\}^{n} \mid U(p,y) = x \text{ within } t \text{ steps}\}, L n t ( x ∣ y ) = { p ∈ { 0 , 1 } n ∣ U ( p , y ) = x within t steps } , whose flip graph is written G n t ( x ∣ y ) \mathcal{G}^{t}_{n}(x|y) G n t ( x ∣ y ) . By the clause of Definition 3.18 making flip-adjacency the restriction of edit-adjacency to equal lengths, its edit graph coincides with its flip graph, and so is not written separately. When the machine is an efficient machine V V V other than the reference machine we write L ℓ , V t ( x ∣ y ) \mathcal{L}^{t}_{\ell,V}(x|y) L ℓ , V t ( x ∣ y ) and L n , V t ( x ∣ y ) \mathcal{L}^{t}_{n,V}(x|y) L n , V t ( x ∣ y ) , and likewise for the graphs. The subscript is dropped only where the text names the machine, as “with respect to V V V ”; without a subscript or such a phrase the machine is U U U . Omitting the condition, as in L n , V t ( x ) \mathcal{L}^{t}_{n,V}(x) L n , V t ( x ) , means the auxiliary string ϵ \epsilon ϵ , or no auxiliary input for a program-only machine, by the convention of Definition 2.5.
The full native fiber F V ( x , N , t ) \mathcal{F}_V(x,N,t) F V ( x , N , t ) of Definition 2.8 is exactly the flip graph G = N , V t ( x ) \mathcal{G}^{t}_{=N,V}(x) G = N , V t ( x ) , and we call either one the fiber of x x x .
Lemma 3.20 (Landscapes are implicit). Let V V V be an efficient machine, let x , y ∈ { 0 , 1 } ∗ x,y \in\{0,1\}^{*} x , y ∈ { 0 , 1 } ∗ , and let the deadline t t t , the length budget ℓ \ell ℓ , and the length n n n be presented in unary. Then the flip graph and the edit graph of L ℓ , V t ( x ∣ y ) \mathcal{L}^{t}_{\ell,V}(x\mid y) L ℓ , V t ( x ∣ y ) are implicit, as is the flip graph of the fixed-length landscape L = n , V t ( x ∣ y ) \mathcal{L}^{t}_{=n,V}(x\mid y) L = n , V t ( x ∣ y ) , and likewise for the unconditional landscapes obtained by omitting the condition. The presenting strings are ( x , y , 1 t , 1 ℓ ) (x,y,1^{t},1^{\ell}) ( x , y , 1 t , 1 ℓ ) and ( x , y , 1 t , 1 n ) (x,y,1^{t},1^{n}) ( x , y , 1 t , 1 n ) in the conditional case and ( x , 1 t , 1 ℓ ) (x,1^{t},1^{\ell}) ( x , 1 t , 1 ℓ ) and ( x , 1 t , 1 n ) (x,1^{t},1^{n}) ( x , 1 t , 1 n ) in the unconditional one, with vertex length bound μ ( k ) = k \mu(k)=k μ ( k ) = k and with W \mathcal{W} W the set of tuples of the shape displayed, in which the last two fields are unary. Consequently the st-connectivity problem for any of these graphs lies in PSPACE.
Proof. We verify the four conditions of Definition 3.12. Proposition 3.3 decides well-formedness: it recovers the fields of a tuple in polynomial time, and so tests both the arity and the unarity of the last two fields. A string failing that test presents the empty graph.
A vertex is a string of length at most ℓ \ell ℓ , and ℓ \ell ℓ is bounded by the input size because it is presented in unary, so vertices have polynomial length.
Membership of a candidate string r r r in the vertex set is decided by testing ∣ r ∣ ≤ ℓ |r| \le\ell ∣ r ∣ ≤ ℓ and then computing, from ( r , y , 1 t ) (r,y,1^{t}) ( r , y , 1 t ) , the configuration of V ( r , y ) V(r,y) V ( r , y ) after t t t steps. That computation costs time polynomial in t + ∣ r ∣ + ∣ y ∣ t+|r|+|y| t + ∣ r ∣ + ∣ y ∣ , hence polynomial in the input length, because V V V is efficient and t t t is presented in unary.
The test accepts if and only if that configuration is halting, its state is not the distinguished one, and the contents of its output tape are exactly x x x . This is correct for two reasons. A halting configuration is its own successor by Definition 2.5, so the configuration after t t t steps records the output of any computation that halted at some step j ≤ t j \le t j ≤ t . And a halt in the distinguished halting state yields ⊥ \perp ⊥ , which differs from every string, the empty one included.
Adjacency of two candidate strings r r r and r ′ r' r ′ is decided as follows. First run the membership test above on r r r and on r ′ r' r ′ , rejecting unless both are vertices. This is needed because Definition 3.12 asks A E A_E A E to decide adjacency in G W G_{\mathcal{W}} G W , and a pair in which either member fails to be a vertex is not adjacent there.
For the flip graph, accept if and only if ∣ r ∣ = ∣ r ′ ∣ |r|=|r'| ∣ r ∣ = ∣ r ′ ∣ and ∣ { i : r i ≠ r i ′ } ∣ = 1 |\{i:r_i\ne r'_i\}|=1 ∣ { i : r i = r i ′ } ∣ = 1 , which is decided by one pass comparing the two strings position by position and counting the mismatches.
For the edit graph, accept if the flip test accepts, and otherwise test the two length cases. If ∣ r ′ ∣ = ∣ r ∣ + 1 |r'|=|r|+1 ∣ r ′ ∣ = ∣ r ∣ + 1 , accept if and only if there are an index j j j with 1 ≤ j ≤ ∣ r ′ ∣ 1\le j\le|r'| 1 ≤ j ≤ ∣ r ′ ∣ and a bit b b b with r ′ = r 1 ⋯ r j − 1 b r j ⋯ r ∣ r ∣ r'=r_1\cdots r_{j-1}br_j\cdots r_{|r|} r ′ = r 1 ⋯ r j − 1 b r j ⋯ r ∣ r ∣ . That is decided by trying each of the ∣ r ′ ∣ |r'| ∣ r ′ ∣ values of j j j and comparing the resulting string with r ′ r' r ′ . If ∣ r ∣ = ∣ r ′ ∣ + 1 |r|=|r'|+1 ∣ r ∣ = ∣ r ′ ∣ + 1 , run the same test with the roles of r r r and r ′ r' r ′ exchanged.
In every remaining case, that is when ∣ r ∣ = ∣ r ′ ∣ |r|=|r'| ∣ r ∣ = ∣ r ′ ∣ or ∣ ∣ r ∣ − ∣ r ′ ∣ ∣ ≥ 2 ||r|-|r'||\ge2 ∣∣ r ∣ − ∣ r ′ ∣∣ ≥ 2 , reject. No single edit changes a length by more than one, and by Definition 3.18 two strings of a common length are edit-adjacent only when they are flip-adjacent.
Each of these tests performs O ( ∣ r ∣ + ∣ r ′ ∣ ) O(|r|+|r'|) O ( ∣ r ∣ + ∣ r ′ ∣ ) comparisons of O ( ∣ r ∣ + ∣ r ′ ∣ ) O(|r|+|r'|) O ( ∣ r ∣ + ∣ r ′ ∣ ) symbols, so it runs in time polynomial in the total length of its arguments, as Definition 3.12 requires. The graphs are therefore implicit.
For the fixed-length landscape the only change is that the length test ∣ r ∣ ≤ ℓ |r|\le\ell ∣ r ∣ ≤ ℓ is replaced by ∣ r ∣ = n |r|=n ∣ r ∣ = n , and n n n is bounded by the input size because it too is presented in unary. For the unconditional landscapes the auxiliary string is omitted from the simulation. Neither change affects the remaining three conditions. The final claim now follows from Lemma 3.14.
To make connectivity a language, defined on every input string, we also say how inputs that are not well-formed queries are answered.
Problem 3.21 (Unconditional connectivity). Fix a machine V V V , read unconditionally, so that V ( p ) V(p) V ( p ) abbreviates V ( p , ϵ ) V(p,\epsilon) V ( p , ϵ ) for a machine that takes a condition, by the convention of Definition 2.5. The input is a tuple ( x , 1 t , p i n , p o u t ) (x,1^t,p_{\mathrm{in}},p_{\mathrm{out}}) ( x , 1 t , p in , p out ) in which x ∈ { 0 , 1 } ∗ x\in\{0,1\}^* x ∈ { 0 , 1 } ∗ , the deadline t t t is presented in unary, and p i n , p o u t p_{\mathrm{in}},p_{\mathrm{out}} p in , p out are two programs of a common length N N N lying in L = N , V t ( x ) \mathcal{L}^{t}_{=N,V}(x) L = N , V t ( x ) . The length N N N is read off the two programs and is therefore bounded by the input length. The question is whether p i n p_{\mathrm{in}} p in and p o u t p_{\mathrm{out}} p out are connected in the flip graph G = N , V t ( x ) \mathcal{G}^{t}_{=N,V}(x) G = N , V t ( x ) . We call this the unconditional reconfiguration connectivity problem with respect to V V V .
Write Conn ( V ) \operatorname{Conn}(V) Conn ( V ) for this language, rejecting malformed tuples, nonunary deadlines, unequal endpoint lengths, and nonvertices. We call Conn ( V ) \operatorname{Conn}(V) Conn ( V ) the full connectivity language of V V V , as opposed to its fixed-target restrictions Conn x ( V ) \operatorname{Conn}_{x}(V) Conn x ( V ) . For fixed x x x , the language Conn x ( V ) \operatorname{Conn}_{x}(V) Conn x ( V ) additionally rejects a tuple whose target field is not x x x . Query length always means the entire tuple length, including 1 t 1^{t} 1 t .
Proposition 3.22. For every efficient machine V V V in the sense of Definition 2.5, the unconditional reconfiguration connectivity problem with respect to V V V is in PSPACE.
Proof. A query of Problem 3.21 names the length N N N only through its two programs, whereas the presenting string of the fixed-length landscape in Lemma 3.20 carries 1 N 1^{N} 1 N , so the algorithm first forms that string. On an input ι \iota ι of length ℓ \ell ℓ it proceeds as follows.
First, it recovers the fields of ι \iota ι as in the proof of Lemma 3.20, by Proposition 3.3, and rejects unless ι \iota ι is a tuple ( x , τ , p i n , p o u t ) (x,\tau,p_{\mathrm{in}},p_{\mathrm{out}}) ( x , τ , p in , p out ) of four strings. It then rejects unless τ = 1 t \tau=1^{t} τ = 1 t for some t t t , and unless ∣ p i n ∣ = ∣ p o u t ∣ \lvert p_{\mathrm{in}}\rvert=\lvert p_{\mathrm{out}}\rvert ∣ p in ∣ = ∣ p out ∣ . These are exactly the malformed tuples, nonunary deadlines and unequal endpoint lengths that Conn ( V ) \operatorname{Conn}(V) Conn ( V ) rejects, and the tests take time polynomial in ℓ \ell ℓ .
Second, it puts N = ∣ p i n ∣ N=\lvert p_{\mathrm{in}}\rvert N = ∣ p in ∣ and writes the presenting string w = ( x , 1 t , 1 N ) w=(x,1^{t},1^{N}) w = ( x , 1 t , 1 N ) of the unconditional fixed-length landscape of Lemma 3.20. Since ∣ x ∣ \lvert x\rvert ∣ x ∣ , t t t and N N N are each at most ℓ \ell ℓ , the string w w w has length polynomial in ℓ \ell ℓ and is written in time polynomial in ℓ \ell ℓ , and it is well formed in the sense of that lemma. The graph it presents is G = N , V t ( x ) \mathcal{G}^{t}_{=N,V}(x) G = N , V t ( x ) .
Third, it runs the procedure of Lemma 3.14 for the family of Lemma 3.20 on ( w , p i n , p o u t ) (w,p_{\mathrm{in}},p_{\mathrm{out}}) ( w , p in , p out ) and returns its answer. That procedure accepts exactly when p i n p_{\mathrm{in}} p in and p o u t p_{\mathrm{out}} p out are both vertices of G = N , V t ( x ) \mathcal{G}^{t}_{=N,V}(x) G = N , V t ( x ) , that is, both lie in L = N , V t ( x ) \mathcal{L}^{t}_{=N,V}(x) L = N , V t ( x ) , and are connected in that graph. It runs in space polynomial in ∣ w ∣ + log ( ∣ p i n ∣ + ∣ p o u t ∣ + 2 ) \lvert w\rvert+\log(\lvert p_{\mathrm{in}}\rvert+\lvert p_{\mathrm{out}}\rvert+2) ∣ w ∣ + log (∣ p in ∣ + ∣ p out ∣ + 2 ) , hence in space polynomial in ℓ \ell ℓ .
An input passing the first step is therefore accepted if and only if both endpoints are vertices of the fiber at length N N N and deadline t t t and are connected in it, which is the definition of Conn ( V ) \operatorname{Conn}(V) Conn ( V ) . The first two steps run in polynomial time and hence in polynomial space, and storing w w w uses space polynomial in ℓ \ell ℓ , so the whole algorithm runs in polynomial space. The argument uses V V V only through Lemma 3.20, which needs only that V V V is efficient; whether V V V is onto plays no role. □
Local Isolation and a Rigid Reference
A hard solution graph can sit inside the fiber of one machine, as the programs beginning with one header, whatever the machine’s other programs do. It suffices that no one-bit change inside the header keeps a program in the fiber.
Proposition 3.23 (Local isolation suffices for hardness). *Let V V V be an efficient universal machine. Suppose there is a polynomial-time computable map sending the presentation, as in Definition 3.15, of every clocked polynomial-time predicate R ⊆ { 0 , 1 } n R\subseteq\{0,1\}^{n} R ⊆ { 0 , 1 } n , at every n ≥ 1 n\ge1 n ≥ 1 , to a witness length b ′ ≥ n b'\ge n b ′ ≥ n , a length N N N , a target x x x , a deadline 1 t 1^{t} 1 t , and a string h h h with ∣ h ∣ + b ′ = N \lvert h\rvert+b'=N ∣ h ∣ + b ′ = N , such that, writing R ′ = { w u ∣ w ∈ R , u ∈ { 0 , 1 } b ′ − n } R'=\{wu\mid w\in R,u\in\{0,1\}^{b'-n}\} R ′ = { w u ∣ w ∈ R , u ∈ { 0 , 1 } b ′ − n } for the padding of R R R to length b ′ b' b ′ ,
for every v ∈ { 0 , 1 } b ′ v\in\{0,1\}^{b'} v ∈ { 0 , 1 } b ′ , the program h v hv h v outputs x x x within t t t steps if and only if v ∈ R ′ v\in R' v ∈ R ′ ; and
for every v ∈ { 0 , 1 } b ′ v\in\{0,1\}^{b'} v ∈ { 0 , 1 } b ′ , every program at Hamming distance one from h v hv h v that differs from it within the first ∣ h ∣ \lvert h\rvert ∣ h ∣ bits fails to output x x x within t t t steps.
Then, at each such R R R , the map v ↦ h v v\mapsto hv v ↦ h v is an isomorphism from the solution graph of R ′ R' R ′ onto a union of connected components of the flip graph of L = N t ( x ) \mathcal{L}^{t}_{=N}(x) L = N t ( x ) with respect to V V V ; and consequently the unconditional reconfiguration connectivity problem with respect to V V V is PSPACE-complete. If moreover the map outputs one and the same target x 0 x_{0} x 0 for every such R R R , then the fixed-target language Conn x 0 ( V ) \operatorname{Conn}_{x_{0}}(V) Conn x 0 ( V ) is PSPACE-complete as well.*
Proof. Membership is Proposition 3.22. For hardness, take a valid instance ( φ , s , t 0 ) (\varphi,s,t_{0}) ( φ , s , t 0 ) of Fact 3.17, with n ≥ 1 n\ge1 n ≥ 1 variables. First present its solution predicate R = R φ R=R_{\varphi} R = R φ as a clocked decider at length n n n . Hardwire φ \varphi φ and unary n n n into a clocked decider which checks exact input length by reading at most n + 1 n+1 n + 1 cells and then uses the formula-evaluation procedure given after Definition 3.15. Wrong-length inputs are rejected at that length check, even if their actual length is much larger. Hence all its runs are bounded by one fixed polynomial in ∣ φ ∣ + n + 1 \lvert\varphi\rvert+n+1 ∣ φ ∣ + n + 1 .
Choose an integer constant coefficient exceeding that bound and set all other clock coefficients to zero. This is a permitted degree-zero clock, and its unary coefficient and complete decider code have polynomial length in the formula instance. This construction uses a new formula decider; it does not encode the runtime of an arbitrarily supplied clocked machine at a hardwired length. Apply the hypothesis to this presentation of R R R to obtain b ′ , N , x , 1 t , h b',N,x,1^t,h b ′ , N , x , 1 t , h in polynomial time.
The supplied integer b ′ b' b ′ need not itself be polynomially bounded. Put
b ′ ′ = min { b ′ , max ( n , t + 1 ) } , N ′ ′ = ∣ h ∣ + b ′ ′ . b''=\min\{b',\max(n,t+1)\},\qquad N''=|h|+b''. b ′′ = min { b ′ , max ( n , t + 1 )} , N ′′ = ∣ h ∣ + b ′′ .
Both integers are computable in polynomial time from the supplied data, and b ′ ′ ≤ max ( n , t + 1 ) b''\leq\max(n,t+1) b ′′ ≤ max ( n , t + 1 ) is polynomially bounded because 1 t 1^t 1 t is supplied explicitly.
If b ′ ′ = b ′ b''=b' b ′′ = b ′ , both hypotheses remain unchanged. Otherwise b ′ ′ ≥ t + 1 b''\geq t+1 b ′′ ≥ t + 1 . For every v ∈ { 0 , 1 } b ′ ′ v\in\{0,1\}^{b''} v ∈ { 0 , 1 } b ′′ , extend v v v to v ~ = v 0 b ′ − b ′ ′ \widetilde v=v0^{b'-b''} v = v 0 b ′ − b ′′ . A program head starting at cell one and moving by at most one cell per transition cannot inspect any cell beyond t + 1 t+1 t + 1 during its first t t t transitions.
The programs h v hv h v and h v ~ h\widetilde v h v agree on all these cells, since ∣ h v ∣ ≥ b ′ ′ ≥ t + 1 |hv|\geq b''\geq t+1 ∣ h v ∣ ≥ b ′′ ≥ t + 1 . Their other initial tapes and states are identical. Induction on the native transitions therefore gives identical configurations through time t t t , except for unread program cells. In particular, their normal halting outputs by t t t agree. The same argument applies to h ′ v h'v h ′ v and h ′ v ~ h'\widetilde v h ′ v for every header h ′ h' h ′ differing from h h h in one bit. Since b ′ ′ ≥ n b''\geq n b ′′ ≥ n , the first n n n bits of v v v and v ~ \widetilde v v also agree. Thus both hypotheses transfer to b ′ ′ b'' b ′′ and N ′ ′ N'' N ′′ ; no exponentially long extension is constructed by the reduction.
Write R ′ ′ = { w u : w ∈ R , u ∈ { 0 , 1 } b ′ ′ − n } R''=\{wu:w\in R,u\in\{0,1\}^{b''-n}\} R ′′ = { w u : w ∈ R , u ∈ { 0 , 1 } b ′′ − n } and put s ^ = s 0 b ′ ′ − n \widehat s=s0^{b''-n} s = s 0 b ′′ − n and t ^ 0 = t 0 0 b ′ ′ − n \widehat t_0=t_00^{b''-n} t 0 = t 0 0 b ′′ − n . The first transferred hypothesis says that the target-x x x vertices with prefix h h h are exactly h R ′ ′ hR'' h R ′′ . A feasible flip within the last b ′ ′ b'' b ′′ positions is precisely a solution-graph edge of R ′ ′ R'' R ′′ . A flip within h h h is infeasible by the second transferred hypothesis. Hence h R ′ ′ hR'' h R ′′ is a union of components of the entire length-N ′ ′ N'' N ′′ , deadline-t t t fiber, and prefixing by h h h is a graph isomorphism onto that union.
Padding preserves and reflects connectivity of the two zero-padded endpoints: a path in R R R lifts with padding fixed, while projecting a path in R ′ ′ R'' R ′′ onto its first n n n coordinates gives a walk in R R R after stationary steps are removed. Consequently s s s and t 0 t_0 t 0 are connected in the solution graph of φ \varphi φ if and only if h s ^ h\widehat s h s and h t ^ 0 h\widehat t_0 h t 0 are connected in the entire target-x x x fiber. The identical edge argument applied directly to the original suffix length b ′ b' b ′ proves the statement’s isomorphism onto a union of components at length N N N . The truncated map to ( x , 1 t , h s ^ , h t ^ 0 ) (x,1^t,h\widehat s,h\widehat t_0) ( x , 1 t , h s , h t 0 ) is polynomial-time, including writing its endpoints. Malformed formulas or nonsatisfying endpoints of the formula instance are recognized in polynomial time and sent to a fixed unequal-length no-query. This proves that Conn x ( V ) \operatorname{Conn}_x(V) Conn x ( V ) is PSPACE-hard.
For the fixed-target assertion, suppose that the map outputs the target x 0 x_0 x 0 for every R R R , and let f f f be the reduction just described. Every query that f f f outputs on a valid instance is ( x 0 , 1 t , h s ^ , h t ^ 0 ) (x_0,1^t,h\widehat s,h\widehat t_0) ( x 0 , 1 t , h s , h t 0 ) , whose target field is x 0 x_0 x 0 . By the definition of Conn x 0 ( V ) \operatorname{Conn}_{x_0}(V) Conn x 0 ( V ) after Problem 3.21 , a query with target field x 0 x_0 x 0 lies in Conn x 0 ( V ) \operatorname{Conn}_{x_0}(V) Conn x 0 ( V ) if and only if it lies in Conn ( V ) \operatorname{Conn}(V) Conn ( V ) , and every query outside Conn ( V ) \operatorname{Conn}(V) Conn ( V ) lies outside Conn x 0 ( V ) \operatorname{Conn}_{x_0}(V) Conn x 0 ( V ) .
Hence a valid yes-instance is sent into Conn x 0 ( V ) \operatorname{Conn}_{x_0}(V) Conn x 0 ( V ) , by the equivalence proved above. A valid no-instance is sent to a query with target field x 0 x_0 x 0 outside Conn ( V ) \operatorname{Conn}(V) Conn ( V ) , hence outside Conn x 0 ( V ) \operatorname{Conn}_{x_0}(V) Conn x 0 ( V ) . An invalid instance is sent to the fixed unequal-length no-query, which lies outside Conn ( V ) \operatorname{Conn}(V) Conn ( V ) and so outside Conn x 0 ( V ) \operatorname{Conn}_{x_0}(V) Conn x 0 ( V ) . Thus the same f f f reduces the problem of Fact 3.17 to Conn x 0 ( V ) \operatorname{Conn}_{x_0}(V) Conn x 0 ( V ) , which is therefore PSPACE-hard. For membership, a query is accepted exactly when its target field equals the fixed string x 0 x_0 x 0 , which is checked in polynomial time, and the algorithm of Proposition 3.22 accepts it; this uses polynomial space.
For the reference machine U U U , rigidity of the ambient encoding (Proposition 3.3) supplies the second hypothesis of Proposition 3.23 : no machine encoding is a prefix of a program obtained from ⟨ M ⟩ Z \langle M\rangle_Z ⟨ M ⟩ Z by changing one bit of its code ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ .
Corollary 3.24 (Every fixed target is hard for the rigid reference; previewed in Theorem 1.4 ). For the machine U U U of Definition 3.5 , the language Conn y ( U ) \operatorname{Conn}_y(U) Conn y ( U ) is PSPACE-complete for every fixed target y ∈ { 0 , 1 } ∗ y\in\{0,1\}^* y ∈ { 0 , 1 } ∗ , including ε \varepsilon ε . Consequently Conn ( U ) \operatorname{Conn}(U) Conn ( U ) is PSPACE-complete, in particular already at the fixed target 00 00 00 .
Proof. Fix y ∈ { 0 , 1 } ∗ y\in\{0,1\}^* y ∈ { 0 , 1 } ∗ and choose a fixed different string r y r_y r y : use r y = 0 r_y=0 r y = 0 if y = ε y=\varepsilon y = ε , and r y = ε r_y=\varepsilon r y = ε otherwise. Membership is Proposition 3.22 , with the target field checked against this fixed y y y . We verify Proposition 3.23 with output target y y y . Let a clocked decider D \mathcal{D} D decide R ⊆ { 0 , 1 } n R\subseteq\{0,1\}^n R ⊆ { 0 , 1 } n , with supplied clock q D q_{\mathcal{D}} q D . Construct M M M so that it normally outputs y y y on members of R R R and r y r_y r y on nonmembers at length n n n . So that D \mathcal{D} D may move its output head freely, M M M does not let it write on the real output tape. Instead, M M M redirects the output writes and head moves of D \mathcal{D} D to a fresh two-track work tape. The first track carries a permanent marker on the first cell, recording the original output origin, and the second track starts blank. The inherited program and work tapes, data and initial heads are unchanged. The new transition table preserves the marker when writing and enforces the original left-end rule at that cell. Since D \mathcal{D} D never reads its output tape, these changes reproduce every inherited state and all native head movements, with at most a fixed constant factor in time. In particular, overwrites and moves left before the first write are preserved.
On a normal halt, return the buffered-output head to its first-cell marker and inspect the symbol in its first cell. At length n n n it is the one-bit verdict guaranteed by Definition 3.15 . Only then write y y y or r y r_y r y , according as that verdict is 1 1 1 or 0 0 0 , on the untouched real output tape. Distinguished halts remain distinguished.
A head visits at most T + 1 T+1 T + 1 cells in T T T transitions, so returning to the marker costs at most T T T further transitions. Thus a fixed constant c y c_y c y , allowed to depend on the two fixed strings y y y and r y r_y r y , gives a clock c y q D ( k ) + c y k + c y c_yq_{\mathcal{D}}(k)+c_yk+c_y c y q D ( k ) + c y k + c y on inputs of length k k k , with degree at most D D D and unary coefficients polynomially constructible from those of D \mathcal{D} D . Off the promised length, any other normal output can be sent to a fixed default string after the same bounded return; no correctness is required there. The table and data construction are polynomial in the supplied decider code.
Set x = y x=y x = y , b ′ = n b'=n b ′ = n , h = ⟨ M ⟩ h=\langle M\rangle h = ⟨ M ⟩ , and N = ∣ h ∣ + n N=|h|+n N = ∣ h ∣ + n . The uniform clock bound and the fixed uniform native overhead of U U U supply a common deadline t t t , writable in unary in polynomial time, by which U ( h v ) = M ( v ) U(hv)=M(v) U ( h v ) = M ( v ) has halted for every v ∈ { 0 , 1 } n v\in\{0,1\}^n v ∈ { 0 , 1 } n . The first hypothesis of Proposition 3.23 now holds with R ′ = R R'=R R ′ = R . If h ′ h' h ′ differs from h h h in one bit, Proposition 3.3 says that no codeword of any length prefixes h ′ v h'v h ′ v . At the empty condition U U U therefore diverges on this program, proving the second hypothesis. The map D ↦ ( b ′ , N , x , 1 t , h ) \mathcal{D}\mapsto(b',N,x,1^t,h) D ↦ ( b ′ , N , x , 1 t , h ) just described is computable in polynomial time, is defined at every n ≥ 1 n\ge1 n ≥ 1 , and outputs the same target x = y x=y x = y for every R R R . The fixed-target clause of Proposition 3.23 therefore applies with x 0 = y x_0=y x 0 = y and shows that Conn y ( U ) \operatorname{Conn}_y(U) Conn y ( U ) is PSPACE-complete.
When y = ε y=\varepsilon y = ε , the untouched blank output is admitted only on a normal halt; rejection normally outputs r y = 0 r_y=0 r y = 0 , while distinguished halts and divergence remain infeasible. Thus the empty target is included. Since the hypotheses of Proposition 3.23 hold for U U U , its main conclusion gives that Conn ( U ) \operatorname{Conn}(U) Conn ( U ) is PSPACE-complete; the case y = 00 y=00 y = 00 of the argument above gives the completeness of Conn 00 ( U ) \operatorname{Conn}_{00}(U) Conn 00 ( U ) . □ \square □
Adding Interpretation Without Changing Native Fibers
The constructions may first be program-only. Interpretation can then be added without moving even the original deadlines.
Lemma 3.25 (Interpretation completion). For every efficient onto program-only machine W W W , there is an efficient conditional machine W ^ \widehat{W} W with the interpretation property such that, for every p , x , t p,x,t p , x , t , the computation W ^ ( p , ε ) \widehat{W}(p,\varepsilon) W ( p , ε ) normally halts with output x x x within t t t steps if and only if W ( p ) W(p) W ( p ) does. Thus every full native fiber, the full language Conn ( W ^ ) = Conn ( W ) \operatorname{Conn}(\widehat{W})=\operatorname{Conn}(W) Conn ( W ) = Conn ( W ) , and all unconditional measures K W ^ t = K W t K_{\widehat{W}}^t=K_W^t K W t = K W t are preserved at the original deadlines. If W W W has the simulation property, W ^ \widehat{W} W has it with the same codes and the same simulation polynomial. In particular, any additive-length, polynomial-deadline measure agreement with U U U is unchanged.
Proof. Let q 0 q_0 q 0 be the initial control state of W W W . It cannot be a normal halting state, since the initially blank output tape would give the same output ε \varepsilon ε for every program, contradicting onto-ness. The distinguished halting state would likewise preclude onto-ness. Retain a native copy of all of W W W ’s states, tapes, hardwired data, tape layout and transition rules. Add the auxiliary tape and a disjoint set of work tapes for a native copy of the fixed reference machine U U U , with its declared initial data already in place. The copies share the program and output tapes, and U U U uses the new auxiliary tape as its condition. Finite tape and state renamings do not change any transition count.
Give W ^ \widehat{W} W one fresh nonhalting entry state q ∗ q_* q ∗ . For every tuple of symbols under the inherited heads, define the transition from q ∗ q_* q ∗ as follows. If the auxiliary first cell is blank, perform exactly the transition that W W W performs from q 0 q_0 q 0 on those symbols, including its output action, head movements and next state in the inherited copy. All added heads remain stationary and added work cells unchanged. If that auxiliary cell is a bit, perform no inherited write or head movement and enter the native initial state of U U U . This conditional lookup is one ordinary multitape transition: it reads the additional tape at the same time as the inherited tapes and applies the corresponding finite-table rule. It does not combine two transitions of W W W .
On the empty condition, the first transition is therefore exactly W W W ’s first transition, and each later inherited transition is unchanged. If W W W returns to its old initial state, it enters that inherited state rather than the fresh q ∗ q_\ast q ∗ , so it does not branch again. This covers a first transition that writes output, normally halts, enters the distinguished halting state, or returns to q 0 q_0 q 0 . At time zero neither machine is normally halting. Thus their unconditional string halts agree at every number of native steps, including zero.
On a nonempty condition, the first transition leaves all heads and shared tapes unchanged, so the computation is the native U ( p , y ) U(p,y) U ( p , y ) computation after that one transition. Use the nonempty interpretation encoding ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ of Definition 3.5. The uniform polynomial interpretation overhead of U U U gains just one transition; divergence and distinguished outcomes are retained. Onto-ness follows from the unchanged empty branch, and efficiency follows from the fixed native model. If W W W has the simulation property, that entire empty branch and all its native deadlines are unchanged, proving the optional assertion. The pointwise equality of unconditional halting predicates gives identical fibers and identical full connectivity languages, including malformed-query rejection. Taking the same minimum over the same feasible programs gives K W ^ t ( x ) = K W t ( x ) K_{\widehat W}^{t}(x)=K_{W}^{t}(x) K W t ( x ) = K W t ( x ) for every x , t x,t x , t , and hence preserves the stated measure comparisons without changing any deadline or length constant.
Fragmentation Forced by Adjunction
An adjunction-universal machine must run every program of every source machine after that source’s code, so a fixed source prescribes the outputs of all programs in the cylinder of its code; we call these programs mandatory descriptions . This section first proves, by counting, that every adjunction-universal machine disconnects the fibers of almost all targets at linear overhead. It then shows that two machines satisfying the reference conditions can disagree about connectivity at one early linear deadline and program length 2 n + 3 2n+3 2 n + 3 , where n n n is the target length. Next it proves, for every adjunction-universal machine, that most fibers at that same length have exponentially many components at every deadline beyond one polynomial deadline. It closes with a second family of separated mandatory descriptions that trades program length against the number of components.
Persistent Fragmentation at Linear Overhead
A single code supplies two distant descriptions of every target. A path joining them may pass through programs outside the cylinder of that code. Counting the outside vertices needed to join these pairs gives a bound that is independent of all other programs of the machine. We call this counting the packing argument.
Theorem 4.1 (Persistent fragmentation at linear overhead; previewed in Theorem 1.1.) Let V V V have the simulation property. There are an integer d ≥ 0 d \ge0 d ≥ 0 and a nondecreasing polynomial Q V Q_V Q V such that, for every integer m ≥ 1 m \ge1 m ≥ 1 , putting N = m + d + 1 N=m+d+1 N = m + d + 1 gives the following conclusions. Every target in { 0 , 1 } m \{0,1\}^{m} { 0 , 1 } m has a nonempty fiber by deadline Q V ( N ) Q_V(N) Q V ( N ) . There is one set B m ⊆ { 0 , 1 } m B_m \subseteq\{0,1\}^{m} B m ⊆ { 0 , 1 } m with
∣ B m ∣ ≥ ( 1 − 2 ( 2 d − 1 ) m + 2 ) 2 m |B_m| \ge\left(1-\frac{2(2^d-1)}{m+2}\right)2^m ∣ B m ∣ ≥ ( 1 − m + 2 2 ( 2 d − 1 ) ) 2 m such that F V ( x , N , t ) \mathcal{F}_V(x,N,t) F V ( x , N , t ) is disconnected for every x ∈ B m x \in B_m x ∈ B m and every t ≥ Q V ( N ) t \ge Q_V(N) t ≥ Q V ( N ) .
Proof. Fix a native linear-time machine F F F which, on input b z bz b z with b ∈ { 0 , 1 } b \in\{0,1\} b ∈ { 0 , 1 } , prints z z z if b = 0 b=0 b = 0 and z ˉ \bar{z} z ˉ if b = 1 b=1 b = 1 , and enters the distinguished halting state on the empty input. A scan, repeat, and copy implementation F F F within a ( r + 1 ) a(r+1) a ( r + 1 ) transitions on every input of length r r r , for a fixed integer a a a . Let h = ⟨ F ⟩ V h=\langle F\rangle_V h = ⟨ F ⟩ V be its code for V V V , put d = ∣ h ∣ d=|h| d = ∣ h ∣ , and let q V q_V q V be the nondecreasing polynomial in its simulation property.
At suffix length m + 1 m+1 m + 1 , exactly two programs in the cylinder h { 0 , 1 } m + 1 h\{0,1\}^{m+1} h { 0 , 1 } m + 1 eventually print a given x ∈ { 0 , 1 } m x \in\{0,1\}^{m} x ∈ { 0 , 1 } m : they are h 0 x h0x h 0 x and h 1 x ˉ h1\bar{x} h 1 x ˉ . Adjunction applies to every raw suffix, so these are all the target-x x x programs in that cylinder, and both halt within
q V ( a ( m + 2 ) , m + 1 , d ) . q_V\bigl(a(m+2),m+1,d\bigr). q V ( a ( m + 2 ) , m + 1 , d ) .
One nondecreasing polynomial Q V ( N ) Q_V(N) Q V ( N ) majorizes this expression for every m m m , since N = m + d + 1 N=m+d+1 N = m + d + 1 and d , a d,a d , a are fixed. Hence every target fiber is nonempty by that common deadline.
Let C m C_m C m be the set of targets x x x whose two endpoints h 0 x h0x h 0 x and h 1 x h1x h 1 x are connected in the untimed fiber of x x x at length N N N . This does not assume that the whole untimed fiber is connected. For each x ∈ C m x\in C_m x ∈ C m , choose a simple connecting path. Its only vertices in h { 0 , 1 } m + 1 h\{0,1\}^{m+1} h { 0 , 1 } m + 1 are its endpoints, because those two are the only target-x x x programs in that cylinder. Since m + 1 ≥ 2 m+1\ge2 m + 1 ≥ 2 , the endpoints are not adjacent. If d = 0 d=0 d = 0 , there is no vertex outside the cylinder and no connecting path, so C m C_m C m is empty. Assume d ≥ 1 d\ge1 d ≥ 1 . The endpoints h 0 x h0x h 0 x and h 1 x h1x h 1 x differ in all m + 1 m+1 m + 1 suffix coordinates, so the path changes each of them at least once, and it must leave and return to the common code h h h , which needs at least two flips inside h h h . It has at least m + 3 m+3 m + 3 edges and therefore at least m + 2 m+2 m + 2 internal vertices, all outside the cylinder.
Different targets’ paths share no vertex, because a deterministic program has only one normal output. There are exactly ( 2 d − 1 ) 2 m + 1 (2^d-1)2^{m+1} ( 2 d − 1 ) 2 m + 1 vertices outside the cylinder. Thus
( m + 2 ) ∣ C m ∣ ≤ ( 2 d − 1 ) 2 m + 1 (m+2)|C_m|\le(2^d-1)2^{m+1} ( m + 2 ) ∣ C m ∣ ≤ ( 2 d − 1 ) 2 m + 1
The same inequality holds when d = 0 d=0 d = 0 . Take B m = { 0 , 1 } m ∖ C m B_m=\{0,1\}^m\setminus C_m B m = { 0 , 1 } m ∖ C m and divide by 2 m 2^m 2 m to obtain the stated cardinality bound. Both endpoints for every x ∈ B m x\in B_m x ∈ B m are present by Q V ( N ) Q_V(N) Q V ( N ) . A connecting path at any later finite deadline would be a path in the untimed fiber, contrary to the definition of B m B_m B m . Thus this one set works simultaneously for all later deadlines. For small m m m the right-hand side of the bound may be negative, and the statement is then vacuous. The case m = 0 m=0 m = 0 is excluded because h 0 h0 h 0 and h 1 h1 h 1 would be adjacent. □
The argument does not need the cylinder to be separated from the rest of the fiber; it counts the outside vertices instead. Sharper families of separated mandatory descriptions are developed in the rest of this section, and the contrasting eventual-connectivity construction in § 5 .
A Common Early Deadline
A machine that prints the first m m m bits of each program of odd length 2 m + 1 2m+1 2 m + 1 has large connected fibers, and adding a parity test makes every such fiber edgeless. Adding a delayed simulation branch to each gives two machines satisfying all three reference conditions, and none of that branch’s programs halts by the common early deadline.
Definition 4.2 (The prefix machines). For a string p p p of odd length 2 m + 1 2m+1 2 m + 1 write pre ( p ) \operatorname{pre}(p) pre ( p ) for the prefix of p p p of length m m m . Define
V 2 ( p ) = { pre ( p ) if ∣ p ∣ is odd , ⊥ otherwise , V 3 ( p ) = { pre ( p ) if ∣ p ∣ is odd and wt ( p ) is even , ⊥ otherwise . V_2(p)=
\begin{cases}
\operatorname{pre}(p) & \text{if } |p| \text{ is odd},\\
\perp& \text{otherwise},
\end{cases}
\qquad
V_3(p)=
\begin{cases}
\operatorname{pre}(p) & \text{if } |p| \text{ is odd and } \operatorname{wt}(p) \text{ is even},\\
\perp& \text{otherwise}.
\end{cases} V 2 ( p ) = { pre ( p ) ⊥ if ∣ p ∣ is odd , otherwise , V 3 ( p ) = { pre ( p ) ⊥ if ∣ p ∣ is odd and wt ( p ) is even , otherwise .
with ⊥ \perp ⊥ the output of the distinguished halting state of § 2.2 .
These two native routines have linear running time. Their universality below means surjectivity in the convention of Definition 2.5; adjunction and interpretation are established only for the machines W 2 W_2 W 2 and W 3 W_3 W 3 of Theorem 4.4, which are built from these two. At a fixed odd length, the fiber of V 2 V_2 V 2 is a subcube and that of V 3 V_3 V 3 is the even-weight half of the same subcube.
Theorem 4.3 (The prefix-machine separation). Put N ( n ) = 2 n + 1 N(n)=2n+1 N ( n ) = 2 n + 1 and let t ( n ) t(n) t ( n ) be a deadline large enough that V 2 V_2 V 2 and V 3 V_3 V 3 of Definition 4.2 halt on every program of length N ( n ) N(n) N ( n ) , which the proof shows is achieved by some t ( n ) = O ( n ) t(n)=O(n) t ( n ) = O ( n ) . The machines V 2 V_2 V 2 and V 3 V_3 V 3 of Definition 4.2 are efficient universal machines in the sense of Definition 2.5, and for every x x x with ∣ x ∣ ≥ 1 |x|\ge1 ∣ x ∣ ≥ 1 the fiber G N ( n ) ∣ x ∣ , V i t ( n ) ( x ) \mathcal{G}^{t(n)}_{N(n)|x|,V_i}(x) G N ( n ) ∣ x ∣ , V i t ( n ) ( x ) has at least two vertices for i = 2 , 3 i=2,3 i = 2 , 3 , is connected for V 2 V_2 V 2 , and is edgeless, hence disconnected, for V 3 V_3 V 3 .
Proof. Both machines are efficient and universal. Each scans its program, keeping its length parity and, for V 3 V_3 V 3 , its weight parity in the finite control. During that scan it writes a unary full-length counter and one marker on a second counter for every completed pair of input bits. For a program of odd length 2 m + 1 2m+1 2 m + 1 , the second counter consequently has exactly m m m markers. The full-length counter permits a return scan to the program’s first cell; after resetting the second counter’s head, the machine copies one input bit per marker and halts. At a rejected length or parity it returns ⊥ \perp ⊥ instead. All scans, resets and copying take at most c ( ∣ p ∣ + 1 ) c(|p|+1) c ( ∣ p ∣ + 1 ) steps for one constant c c c fixed by the two finite controls, including the empty program. The efficiency clause of Definition 2.5 holds by Fact 3.4. At length N ( n ) = 2 n + 1 N(n)=2n+1 N ( n ) = 2 n + 1 the bound is c ( 2 n + 2 ) = O ( n ) c(2n+2)=O(n) c ( 2 n + 2 ) = O ( n ) for n ≥ 1 n\ge1 n ≥ 1 , so this common bound and every larger one meet the theorem’s hypothesis.
For universality, let x ∈ { 0 , 1 } ∗ x\in\{0,1\}^* x ∈ { 0 , 1 } ∗ and put n = ∣ x ∣ n=|x| n = ∣ x ∣ . Every p = x z p=xz p = x z with ∣ z ∣ = n + 1 |z|=n+1 ∣ z ∣ = n + 1 has odd length 2 n + 1 2n+1 2 n + 1 and pre ( p ) = x \operatorname{pre}(p)=x pre ( p ) = x , so V 2 ( p ) = x V_2(p)=x V 2 ( p ) = x . Among those z z z there is one with wt ( x z ) \operatorname{wt}(xz) wt ( x z ) even, since flipping the last bit of z z z changes that parity, and for such a z z z also V 3 ( p ) = x V_3(p)=x V 3 ( p ) = x . At n = 0 n=0 n = 0 the program p = 0 p=0 p = 0 has length 1, prefix ε \varepsilon ε and even weight, so both machines print ε \varepsilon ε .
The fiber of V 2 V_2 V 2 . Fix x x x with n = ∣ x ∣ ≥ 1 n=|x|\ge1 n = ∣ x ∣ ≥ 1 and put N = 2 n + 1 N=2n+1 N = 2 n + 1 . A string p p p of length N N N satisfies V 2 ( p ) = x V_2(p)=x V 2 ( p ) = x exactly when pre ( p ) = x \operatorname{pre}(p)=x pre ( p ) = x , that is exactly when p = x z p=xz p = x z for some z ∈ { 0 , 1 } n + 1 z\in\{0,1\}^{n+1} z ∈ { 0 , 1 } n + 1 . The computation takes linear time, so L N t ( n ) ( x ) = x { 0 , 1 } n + 1 \mathcal{L}^{t(n)}_N(x)=x\{0,1\}^{n+1} L N t ( n ) ( x ) = x { 0 , 1 } n + 1 with respect to V 2 V_2 V 2 . That set has 2 n + 1 ≥ 2 2^{n+1}\ge2 2 n + 1 ≥ 2 elements.
Two of them, x z xz x z and x z ′ xz' x z ′ , are flip-adjacent exactly when Δ ( x z , x z ′ ) = 1 \Delta(xz,xz')=1 Δ ( x z , x z ′ ) = 1 , which since they share the prefix x x x holds exactly when Δ ( z , z ′ ) = 1 \Delta(z,z')=1 Δ ( z , z ′ ) = 1 . The fiber is therefore isomorphic to the Boolean cube Q n + 1 Q_{n+1} Q n + 1 of Definition 2.2 under z ↦ x z z\mapsto xz z ↦ x z , and is connected.
The fiber of V 3 V_3 V 3 . At the same x x x , N N N and deadline, V 3 ( p ) = x V_3(p)=x V 3 ( p ) = x holds exactly when p = x z p=xz p = x z with wt ( x z ) \operatorname{wt}(xz) wt ( x z ) even, that is exactly when wt ( z ) ≡ wt ( x ) ( m o d 2 ) \operatorname{wt}(z)\equiv\operatorname{wt}(x)\pmod{2} wt ( z ) ≡ wt ( x ) ( mod 2 ) . Exactly half of the strings z ∈ { 0 , 1 } n + 1 z\in\{0,1\}^{n+1} z ∈ { 0 , 1 } n + 1 have each weight parity, since flipping the last bit is an involution exchanging the two halves, so the fiber has 2 n ≥ 2 2^n\ge2 2 n ≥ 2 elements.
Every element has even weight, while a single flip changes the weight by exactly one and so makes it odd. Hence no two elements are flip-adjacent, the fiber is edgeless on at least two vertices, and it is disconnected. □
The additional simulation and interpretation properties can be imposed without losing a separation at one common linear deadline. A delay in the simulation branch leaves the programs that run the prefix machines as the only descriptions present at that deadline.
Theorem 4.4 (Uniform separation under the reference conditions; previewed in Theorem 1.2). There are conditional machines W 2 , W 3 W_2,W_3 W 2 , W 3 satisfying Definitions 2.5 to 2.7, an integer n 0 ≥ 1 n_0\ge1 n 0 ≥ 1 , and a common deadline t ( n ) = O ( n ) t(n)=O(n) t ( n ) = O ( n ) such that, for every x ∈ { 0 , 1 } n x\in\{0,1\}^n x ∈ { 0 , 1 } n with n ≥ n 0 n\ge n_0 n ≥ n 0 , at length N ( n ) = 2 n + 3 N(n)=2n+3 N ( n ) = 2 n + 3 the fiber G = N ( n ) , W 2 t ( n ) ( x ) \mathcal{G}^{t(n)}_{=N(n),W_2}(x) G = N ( n ) , W 2 t ( n ) ( x ) is connected on 2 n + 1 2^{n+1} 2 n + 1 vertices and the fiber G = N ( n ) , W 3 t ( n ) ( x ) \mathcal{G}^{t(n)}_{=N(n),W_3}(x) G = N ( n ) , W 3 t ( n ) ( x ) is edgeless on 2 n 2^n 2 n vertices. The deadline depends only on n n n , and the measures K W 2 t K^{t}_{W_2} K W 2 t and K W 3 t K^{t}_{W_3} K W 3 t agree up to additive constants and polynomial changes of the deadline.
Proof. Each W i W_i W i dispatches on its inputs. A nonempty auxiliary string is handed, with the program, to the reference machine U U U , which supplies interpretation. At the empty auxiliary string, a program 00 r 00r 00 r runs V i V_i V i on r r r , a program 11 r 11r 11 r runs U U U on r r r after a delay quadratic in the program length, and every other program yields ⊥ \perp ⊥ . At the chosen linear deadline only 00 00 00 programs can have halted with a string output, so the fibers are those of V i V_i V i with 00 00 00 prepended.
Native copies of the fixed machines. Fix the linear-time implementations of V 2 , V 3 V_2,V_3 V 2 , V 3 from Theorem 4.3 and the native reference U U U from Definition 3.5. Each W i W_i W i contains finite-control copies of these fixed machines, on disjoint work tapes carrying their declared initial data and layout. Its preparatory routines use additional tapes and leave those inherited work tapes and their heads unchanged. A native copy reproduces each inherited transition, including its output action and all head movements, in one transition after a finite tape and state renaming. Its states are disjoint from the preparatory states, so returning to an inherited initial state does not repeat the preparation.
First inspect the auxiliary first cell without moving any head or writing output. If it is a bit, enter a native conditional copy of U U U on the unchanged inputs p , y p,y p , y . That copy starts with its original initial configuration and therefore executes U ( p , y ) U(p,y) U ( p , y ) after the single dispatch transition. Every code ⟨ M ⟩ \langle M\rangle ⟨ M ⟩ , which serves below as the interpretation encoding, is nonempty, whereas the empty condition begins with a blank. Thus this branch implements interpretation and never applies at the empty condition.
At the empty condition, inspect the first two program bits. Programs shorter than two bits, and prefixes 01 or 10, enter the distinguished halting state. On 00r, copy r r r onto an initially blank private tape, without adding a delimiter, and return its head to cell one. The copied tape contains exactly r r r , followed by blanks. Run the native copy of V i V_i V i , using this tape as its program input and the real output tape as its output. The copied program tape is physically writable, but the inherited input rules never write it, so it has precisely the read-only behavior required by V i V_i V i . Its physical left end also gives the original left-end rule. Preparation and the native V i V_i V i routine take at most c ( ∣ p ∣ + 1 ) c(|p|+1) c ( ∣ p ∣ + 1 ) transitions, for one common fixed integer c ≥ 1 c \ge1 c ≥ 1 .
On 11r r r , put L = ∣ p ∣ L=|p| L = ∣ p ∣ and first execute an enforced delay of at least L 2 L^2 L 2 transitions, without output or halting. Scan the program to record L L L in unary on two fresh tapes, then make L L L traversals of a block of L L L marked cells, resetting its head between traversals. This takes O ( ( L + 1 ) 2 ) O((L+1)^2) O (( L + 1 ) 2 ) transitions and includes the required L 2 L^2 L 2 transitions. After the delay, copy r r r to an initially blank private tape and reset its head to cell one. Run a second native copy of U U U with this tape as its program input and with the unchanged empty auxiliary tape. Its work data, work heads and real output tape are still in their initial configurations. As above, its input rules leave the copied string unchanged, and its left boundary is the physical first cell.
The resulting computation is exactly the native U ( r , ε ) U(r,\varepsilon) U ( r , ε ) computation after preparation. Normal outputs, distinguished halts, divergence, overwrites and erasures are all preserved. In particular, no 11 program normally halts before its enforced delay finishes, even for target ε \varepsilon ε .
The reference conditions. Efficiency follows from the fixed native model and Fact 3.4. For every string x x x , choose r r r with U ( r , ε ) = x U(r,\varepsilon)=x U ( r , ε ) = x . Then W i ( 11 r , ε ) = x W_i(11r,\varepsilon)=x W i ( 11 r , ε ) = x after finite preparation, proving onto-ness, including at x = ε x=\varepsilon x = ε . For adjunction use
⟨ M ⟩ W i = 11 ⟨ M ⟩ \langle M\rangle_{W_i}=11\langle M\rangle ⟨ M ⟩ W i = 11 ⟨ M ⟩
This code is polynomial-time computable and has length ∣ ⟨ M ⟩ ∣ + 2 |\langle M\rangle|+2 ∣ ⟨ M ⟩ ∣ + 2 . On every raw suffix z z z , the copied input to U U U is exactly ⟨ M ⟩ z \langle M\rangle z ⟨ M ⟩ z . The delay and copying take polynomial time in ∣ ⟨ M ⟩ ∣ + ∣ z ∣ + 1 |\langle M\rangle|+|z|+1 ∣ ⟨ M ⟩ ∣ + ∣ z ∣ + 1 . If M ( z ) M(z) M ( z ) halts in T T T steps, the uniform simulation polynomial of U U U bounds the remaining native execution in T , ∣ z ∣ , ∣ ⟨ M ⟩ ∣ T,|z|,|\langle M\rangle| T , ∣ z ∣ , ∣ ⟨ M ⟩ ∣ . Adding the preparation gives one uniform polynomial in T , ∣ z ∣ , ∣ ⟨ M ⟩ W i ∣ T,|z|,|\langle M\rangle_{W_i}| T , ∣ z ∣ , ∣ ⟨ M ⟩ W i ∣ ; divergence is preserved by the native copy. For interpretation take ⟨ M ⟩ W i ′ = ⟨ M ⟩ \langle M\rangle'_{W_i}=\langle M\rangle ⟨ M ⟩ W i ′ = ⟨ M ⟩ . The nonempty-condition branch runs U ( p , ⟨ M ⟩ ) = M ( p ) U(p,\langle M\rangle)=M(p) U ( p , ⟨ M ⟩) = M ( p ) with one extra transition and hence has the required uniform polynomial overhead and divergence behavior. Fact 3.10, applied in both directions, now gives the numerical measure comparison.
The entire graphs at one deadline. Put N ( n ) = 2 n + 3 N(n)=2n+3 N ( n ) = 2 n + 3 and t ( n ) = c ( N ( n ) + 1 ) t(n)=c(N(n)+1) t ( n ) = c ( N ( n ) + 1 ) . Choose n 0 = c + 1 n_0=c+1 n 0 = c + 1 . For n ≥ n 0 n\ge n_0 n ≥ n 0 we have N = N ( n ) ≥ c + 1 N=N(n)\ge c+1 N = N ( n ) ≥ c + 1 , and
N 2 − c ( N + 1 ) = N ( N − c ) − c ≥ N − c > 0 N^2-c(N+1)=N(N-c)-c\ge N-c>0 N 2 − c ( N + 1 ) = N ( N − c ) − c ≥ N − c > 0
Thus every 00 computation at that length has halted by t ( n ) t(n) t ( n ) , whereas no 11 computation has halted by then. All other programs produce no string. For any x ∈ { 0 , 1 } n x\in\{0,1\}^n x ∈ { 0 , 1 } n , the vertex sets of the two fibers are therefore
L = N ( n ) , W 2 t ( n ) ( x ) = { 00 x z : z ∈ { 0 , 1 } n + 1 } , \mathcal{L}^{t(n)}_{=N(n),W_2}(x)=\{00xz:z\in\{0,1\}^{n+1}\}, L = N ( n ) , W 2 t ( n ) ( x ) = { 00 x z : z ∈ { 0 , 1 } n + 1 } ,
L = N ( n ) , W 3 t ( n ) ( x ) = { 00 x z : z ∈ { 0 , 1 } n + 1 and wt ( x z ) ≡ 0 ( m o d 2 ) } . \mathcal{L}^{t(n)}_{=N(n),W_3}(x)=\{00xz:z\in\{0,1\}^{n+1}\text{ and }\operatorname{wt}(xz)\equiv0\pmod2\}. L = N ( n ) , W 3 t ( n ) ( x ) = { 00 x z : z ∈ { 0 , 1 } n + 1 and wt ( x z ) ≡ 0 ( mod 2 )} .
In the first, z ↦ 00 x z z\mapsto00xz z ↦ 00 x z preserves and reflects one-bit adjacency, giving Q n + 1 Q_{n+1} Q n + 1 on 2 n + 1 2^{n+1} 2 n + 1 vertices. In the second, flipping the last bit of z z z exchanges the two parities, so exactly 2 n 2^n 2 n suffixes are feasible. Every feasible program has even weight, while a one-bit flip changes parity, so this graph is edgeless. Since n ≥ n 0 ≥ 1 n\ge n_0\ge1 n ≥ n 0 ≥ 1 , it has at least two vertices and is disconnected. The same length and deadline work for every target of length n n n . □ \square □
The deadline in Theorem 4.4 is part of the statement. At larger deadlines, programs in the delayed simulation branch may enter the fibers. The theorem consequently does not assert persistent disagreement at every larger deadline, and it gives no complexity separation between machines satisfying the reference conditions.
For every adjunction-universal machine, the two-endpoint bound of Theorem 4.1 already disconnects the fibers of almost all targets at its own length n + d + 1 n+d+1 n + d + 1 , where n n n is the target length, at every deadline beyond one polynomial deadline. We now prove such fragmentation at the length 2 n + 3 2n+3 2 n + 3 of the early separation, again for every adjunction-universal machine, and then force many components.
Fragmentation at the Exact Common Length
The next construction forces fragmentation at the same length 2 n + 3 2n+3 2 n + 3 as the early separation, where n n n is the target length. It uses many separated mandatory descriptions in each target fiber.
Write F 2 \mathbb{F}_2 F 2 for the field with elements zero and one, with addition and multiplication modulo two. A binary matrix acts on binary column vectors using these operations. Its rank is the largest number of linearly independent rows, its kernel is the set of vectors it maps to zero, and the preimage set of x x x is the set of vectors it maps to x x x . The construction uses one standard finite-field existence fact. A polynomial is monic when its leading coefficient is one, and is irreducible when it has no factorization into polynomials of smaller positive degree.
Fact 4.5 (Binary extension fields; [20 Section 19.2, Theorem 19.12] ). For every integer s ≥ 1 s \ge1 s ≥ 1 there is a monic irreducible polynomial f ∈ F 2 [ X ] f \in\mathbb{F}_2[X] f ∈ F 2 [ X ] of degree s s s . The polynomial residues modulo f f f form a field with 2 s 2^s 2 s elements, represented uniquely by binary polynomials of degree less than s s s .
Addition in this field is coefficientwise addition modulo two. Multiplication is polynomial multiplication followed by division by f f f and retention of the remainder. Both operations take polynomial time in s s s by the elementary algorithms. The parity-check idea below is classical; see the constructions of Bose and Ray-Chaudhuri and of Hocquenghem [6 , 12 ] . We prove the precise matrix and distance parameters used here.
Lemma 4.6 (Balanced maps with separated preimage sets). For integers r ≥ n ≥ 1 r \ge n \ge1 r ≥ n ≥ 1 , put
s = ⌈ log 2 ( r + 1 ) ⌉ , e = ⌊ n s ⌋ . s = \left\lceil\log_2(r+1) \right\rceil, \qquad e = \left\lfloor\frac{n}{s} \right\rfloor. s = ⌈ log 2 ( r + 1 ) ⌉ , e = ⌊ s n ⌋ . One can construct in deterministic time polynomial in r + n r+n r + n a binary matrix H n , r H_{n,r} H n , r of rank n n n , with n n n rows and r r r columns, such that every preimage set of w ↦ H n , r w w \mapsto H_{n,r}w w ↦ H n , r w has exactly 2 r − n 2^{r-n} 2 r − n elements and minimum Hamming distance at least e + 1 e+1 e + 1 . The distance assertion is vacuous for a singleton preimage set.
Proof. Constructing the field. Enumerate the 2 s 2^s 2 s monic binary polynomials of degree s s s . For each candidate test divisibility by every monic polynomial of degrees 1 , … , ⌊ s / 2 ⌋ 1,\ldots,\lfloor s/2\rfloor 1 , … , ⌊ s /2 ⌋ . A reducible degree-s s s polynomial has a factor in this range: in any factorization into two positive degrees, one degree is at most s / 2 s/2 s /2 . Thus the first candidate passing all tests is irreducible, and Fact 4.5 guarantees that one is found. For s = 1 s=1 s = 1 the test list is empty and every monic linear polynomial is irreducible. There are fewer than 2 s / 2 + 1 2^{s/2+1} 2 s /2 + 1 trial divisors, and each division takes polynomial time in s s s . The full search therefore takes O ( 2 3 s / 2 + 1 poly ( s ) ) O(2^{3s/2+1}\operatorname{poly}(s)) O ( 2 3 s /2 + 1 poly ( s )) time. Since 2 s < 2 ( r + 1 ) 2^s < 2(r+1) 2 s < 2 ( r + 1 ) , this is polynomial in r r r . Construct the field F = F 2 [ X ] / ( f ) \mathbb{F}=\mathbb{F}_2[X]/(f) F = F 2 [ X ] / ( f ) using the polynomial representations in the fact.*
The parity checks. Choose r r r distinct elements α 1 , … , α r \alpha_1,\ldots,\alpha_r α 1 , … , α r of F \mathbb{F} F by enumerating their binary representations. There are enough because 2 s ≥ r + 1 2^s \ge r+1 2 s ≥ r + 1 . Form the e e e -by-r r r field matrix with entry α i j \alpha_i^j α i j in column i i i and row j j j , for j = 0 , … , e − 1 j=0,\ldots,e-1 j = 0 , … , e − 1 ; when e ≥ 1 e \ge1 e ≥ 1 , its zeroth row consists of ones, including at α i = 0 \alpha_i=0 α i = 0 . Expand each field entry into its s s s binary coordinates. This gives at most e s ≤ n es \le n es ≤ n binary rows and a binary matrix B B B with r r r columns. For a binary vector w w w , the condition B w = 0 Bw=0 B w = 0 means exactly
∑ i = 1 r w i α i j = 0 in F , 0 ≤ j < e . \sum_{i=1}^{r} w_i\alpha_i^j = 0 \quad\text{in }\mathbb{F}, \qquad0 \le j < e. i = 1 ∑ r w i α i j = 0 in F , 0 ≤ j < e .
Suppose a nonzero such vector has weight q ≤ e q \le e q ≤ e . Let i 1 , … , i q i_1,\ldots,i_q i 1 , … , i q be its support. The first q q q field rows on these q q q columns form an invertible matrix. To see this, a dependence among its rows would give a nonzero polynomial of degree at most q − 1 q-1 q − 1 vanishing at the q q q distinct points α i 1 , … , α i q \alpha_{i_1},\ldots,\alpha_{i_q} α i 1 , … , α i q . A nonzero polynomial of degree at most q − 1 q-1 q − 1 has at most q − 1 q-1 q − 1 roots: division by X − a X-a X − a removes a root a a a and lowers the degree by one, and induction proves the bound. Thus its rows are independent, and a square matrix with independent rows is invertible by elimination over the field. The first q q q displayed equations say that this square matrix maps the all-ones vector ( w i 1 , … , w i q ) (w_{i_1},\ldots,w_{i_q}) ( w i 1 , … , w i q ) to zero, contradicting its invertibility. Every nonzero vector in the binary kernel of B B B therefore has weight at least e + 1 e+1 e + 1 . When e = 0 e=0 e = 0 , this conclusion is just the trivial positive-weight bound.
Full rank and balanced preimages. Use binary Gaussian elimination to take a basis of the rows of B B B . Append standard unit rows not yet in their span until there are exactly n n n independent rows, giving H n , r H_{n,r} H n , r . This succeeds because n ≤ r n \le r n ≤ r : if a proper row span contained every unit row it would already contain every binary row vector. Each appended row imposes another zero equation, so the new kernel is contained in the old one and retains its minimum-distance bound.
Rank n n n gives n n n pivot columns; setting the other r − n r-n r − n coordinates freely and solving for the pivots yields exactly 2 r − n 2^{r-n} 2 r − n preimages of each right-hand side x ∈ F 2 n x \in\mathbb{F}_2^n x ∈ F 2 n . Thus the map is onto and balanced. The difference of two vectors in one preimage set is a nonzero kernel vector, whose weight is their Hamming distance, proving the asserted separation. Field arithmetic, matrix formation, elimination and the unit-row extensions all take polynomial time in r + n r+n r + n . The search cost above shows that the same holds for the complete deterministic construction. □
The next elementary bound counts every vertex of a connecting subgraph, including vertices outside the cylinder of a code. It therefore needs no assumption, such as the rigid encoding of the reference machine U U U , about programs outside that cylinder. Its proof uses a spanning tree of a nonempty finite connected graph, which is a subgraph on all its vertices with a unique simple path between each pair of vertices. In this section D D D denotes a lower bound on Hamming distances, not the clock degree bound of Definition 3.6.
Lemma 4.7 (Connecting separated terminals). If a finite connected subgraph G G G of a Boolean cube contains k ≥ 2 k \ge2 k ≥ 2 specified vertices, called terminals, whose pairwise Hamming distances are at least D D D , then
2 ( ∣ V ( G ) ∣ − 1 ) ≥ k D . 2(|V(G)|-1) \ge kD. 2 ( ∣ V ( G ) ∣ − 1 ) ≥ k D . In particular, ∣ V ( G ) ∣ ≥ k D / 2 |V(G)| \ge kD/2 ∣ V ( G ) ∣ ≥ k D /2 .
Proof. Root a tree at one specified vertex, initially taking only that vertex and no edges. If some vertex of G G G has not been reached, a path from the root to it has a first edge leaving the reached set. Adjoin that edge and its previously unreached endpoint. The new vertex has only its one attaching edge in the constructed subgraph, so this operation preserves the unique-path property. After ∣ V ( G ) ∣ − 1 |V(G)|-1 ∣ V ( G ) ∣ − 1 additions the resulting tree spans G G G and has ∣ V ( G ) ∣ − 1 |V(G)|-1 ∣ V ( G ) ∣ − 1 edges.
A one-vertex tree has a closed walk of length zero; adjoining a leaf inserts a two-edge detour at its neighbor. Induction over these additions therefore gives a closed walk from the root using every tree edge twice, of length 2 ( ∣ V ( G ) ∣ − 1 ) 2(|V(G)|-1) 2 ( ∣ V ( G ) ∣ − 1 ) . List the k k k specified vertices in the order of their first appearances on that walk, the root first. Cut the walk at these k k k first appearances. The last of the resulting k k k portions runs from the first appearance of the last-listed specified vertex back to the root. Each of the resulting k k k portions joins two distinct specified vertices, so it has at least D D D edges: every cube edge changes just one coordinate. The portions together are the whole walk, proving the inequality. □
The connected-subgraph bound also limits how many of a family of vertex-disjoint graphs can have few components. Here a component counts when it meets the graph’s specified vertices, and few means fewer than half as many as there are specified vertices. We state this count separately because both constructions below, the balanced preimage sets and the Reed–Muller family, use it.
Lemma 4.8 (Counting components from separated vertices). Let X X X be a finite set, and let G x G_x G x , for x ∈ X x \in X x ∈ X , be subgraphs of the same Boolean cube Q N Q_N Q N whose vertex sets are pairwise disjoint. Let W ≥ 2 W \ge2 W ≥ 2 and D ≥ 1 D \ge1 D ≥ 1 be integers. Suppose each G x G_x G x contains a specified set P x P_x P x of W W W vertices whose pairwise Hamming distances are at least D D D . Write c x c_x c x for the number of connected components of G x G_x G x meeting P x P_x P x . Then
∣ { x ∈ X : c x < W / 2 } ∣ < 4 ⋅ 2 N D W . |\{x \in X : c_x < W/2\}| < \frac{4 \cdot2^N}{DW}. ∣ { x ∈ X : c x < W /2 } ∣ < D W 4 ⋅ 2 N . For every other x ∈ X x \in X x ∈ X , the graph G x G_x G x has at least W / 2 W/2 W /2 connected components.
Proof. Put Y = { x ∈ X : c x < W / 2 } Y=\{x \in X : c_x < W/2\} Y = { x ∈ X : c x < W /2 } . If Y Y Y is empty, the strict bound holds because 4 ⋅ 2 N / ( D W ) > 0 4 \cdot2^N/(DW)>0 4 ⋅ 2 N / ( D W ) > 0 . This also covers an empty index set X X X . Suppose therefore that Y Y Y is nonempty, and fix x ∈ Y x \in Y x ∈ Y .
At most c x c_x c x specified vertices lie in components containing just one specified vertex, since each such component accounts for one of the c x c_x c x components. Consequently the number a x a_x a x of specified vertices in components containing at least two satisfies
a x ≥ W − c x > W / 2. a_x \ge W-c_x > W/2. a x ≥ W − c x > W /2. For each such component C C C , let k C ≥ 2 k_C \ge2 k C ≥ 2 be its number of specified vertices. It is a finite connected subgraph of Q N Q_N Q N , and those vertices still have pairwise distances at least D D D . Thus Lemma 4.7 gives ∣ V ( C ) ∣ ≥ k C D / 2 |V(C)| \ge k_C D/2 ∣ V ( C ) ∣ ≥ k C D /2 . The components of G x G_x G x have disjoint vertex sets, so summing these bounds yields
∣ V ( G x ) ∣ ≥ D 2 ∑ C : k C ≥ 2 k C = D 2 a x > D W 4 . |V(G_x)| \ge\frac{D}{2}\sum_{C:k_C\ge2} k_C = \frac{D}{2}a_x > \frac{DW}{4}. ∣ V ( G x ) ∣ ≥ 2 D C : k C ≥ 2 ∑ k C = 2 D a x > 4 D W .
The graphs indexed by different x x x also have disjoint vertex sets, all inside the 2 N 2^N 2 N -vertex cube. Summing the strict inequality over the nonempty set Y Y Y gives
∣ Y ∣ D W 4 < ∑ x ∈ Y ∣ V ( G x ) ∣ ≤ 2 N . |Y|\frac{DW}{4}<\sum_{x\in Y}|V(G_x)|\le2^N. ∣ Y ∣ 4 D W < x ∈ Y ∑ ∣ V ( G x ) ∣ ≤ 2 N .
Division by the positive number D W / 4 DW/4 D W /4 proves the bound. For x ∉ Y x\notin Y x ∈ / Y , at least c x ≥ W / 2 c_x\ge W/2 c x ≥ W /2 components meet P x P_x P x ; these are components of the entire graph, proving the last assertion. □
We can now keep the program length of the earlier separation while allowing every later deadline. The balanced construction forces exponentially many components for most targets at every sufficiently large target length.
Theorem 4.9 (Exponential multiplicity at every large target length; previewed in Theorems 1.1 and 1.2). *Let V V V be an adjunction-universal machine. There are a constant a V > 0 a_V>0 a V > 0 , a nonnegative integer C V C_V C V , an integer n 0 ≥ C V + 1 n_0\ge C_V+1 n 0 ≥ C V + 1 and a nondecreasing polynomial P V P_V P V such that, for every n ≥ n 0 n\ge n_0 n ≥ n 0 , there is a set B n ⊆ { 0 , 1 } n \mathcal{B}_n\subseteq\{0,1\}^n B n ⊆ { 0 , 1 } n with
∣ B n ∣ ≥ ( 1 − a V log 2 ( n + 1 ) n ) 2 n |\mathcal{B}_n|\ge\left(1-a_V\frac{\log_2(n+1)}{n}\right)2^n ∣ B n ∣ ≥ ( 1 − a V n log 2 ( n + 1 ) ) 2 n for which the untimed fiber of x x x at length 2 n + 3 2n+3 2 n + 3 , induced by
{ p ∈ { 0 , 1 } 2 n + 3 : V ( p , ε ) = x } , \{p\in\{0,1\}^{2n+3}:V(p,\varepsilon)=x\}, { p ∈ { 0 , 1 } 2 n + 3 : V ( p , ε ) = x } , has at least 2 n − C V 2^{n-C_V} 2 n − C V connected components for every x ∈ B n x\in\mathcal{B}_n x ∈ B n . The fiber G = 2 n + 3 , V t ( x ) \mathcal{G}^{t}_{=2n+3,V}(x) G = 2 n + 3 , V t ( x ) has at least that many components for every such x x x and every t ≥ P V ( n ) t\ge P_V(n) t ≥ P V ( n ) . In particular, all these graphs are nonempty and disconnected. The same set B n \mathcal{B}_n B n works for all these later deadlines; no algorithm for recognizing it is asserted.*
Proof. One fixed polynomial-time machine. Define F F F independently of V V V . On input z z z , it first determines the full length L L L and parses z = 1 a 0 w z=1^a0w z = 1 a 0 w ; it rejects, meaning that it enters the distinguished halting state, if there is no zero. Write r = ∣ w ∣ r=|w| r = ∣ w ∣ and compute
n = L + a − 3 2 . n=\frac{L+a-3}{2}. n = 2 L + a − 3 .
On the programs built below, this value of n n n is the target length. If this is not an integer satisfying r ≥ n ≥ 1 r\ge n\ge1 r ≥ n ≥ 1 , return ⊥ \bot ⊥ . Otherwise construct the matrix of Lemma 4.6 and output H n , r w H_{n,rw} H n , r w . Every part of this algorithm, including its scans and the field search, takes polynomial time in L + 1 L+1 L + 1 , since r ≤ L r\le L r ≤ L and accepted parameters have n ≤ r n\le r n ≤ r . Implement it as a native multitape machine and fix a nondecreasing polynomial R ( L ) R(L) R ( L ) bounding its complete actual running time at every length, including rejected inputs. Its finite machine code is fixed.
Alignment without self-reference. Let u = ⟨ F ⟩ V u=\langle F\rangle_V u = ⟨ F ⟩ V be the code of F F F for V V V given by the simulation property, and put d = ∣ u ∣ d=|u| d = ∣ u ∣ . For sufficiently large n n n , set
N = 2 n + 3 , r = 2 n + 2 − 2 d , p ( w ) = u 1 d 0 w ( w ∈ { 0 , 1 } r ) . N=2n+3,\qquad r=2n+2-2d,\qquad p(w)=u1^d0w\quad(w\in\{0,1\}^r). N = 2 n + 3 , r = 2 n + 2 − 2 d , p ( w ) = u 1 d 0 w ( w ∈ { 0 , 1 } r ) .
These programs all have length d + ( d + 1 ) + r = N d+(d+1)+r=N d + ( d + 1 ) + r = N . The input seen by F F F has length L = N − d L=N-d L = N − d and unary prefix parameter a = d a=d a = d , so it computes exactly the intended n = ( L + d − 3 ) / 2 n=(L+d-3)/2 n = ( L + d − 3 ) /2 and r r r . The unary parameter supplies the code length as ordinary input, so the fixed machine F F F never computes its own code. Take n n n large enough that r ≥ n + 1 r\ge n+1 r ≥ n + 1 . Then every target x ∈ { 0 , 1 } n x\in\{0,1\}^n x ∈ { 0 , 1 } n has exactly
k = 2 r − n ≥ 2 k=2^{r-n}\ge2 k = 2 r − n ≥ 2
mandatory descriptions in the cylinder of u 1 d 0 u1^d0 u 1 d 0 , namely the p ( w ) p(w) p ( w ) with H n , r w = x H_{n,r}w=x H n , r w = x . Put
s = ⌈ log 2 ( r + 1 ) ⌉ , D = ⌊ n s ⌋ + 1. s=\lceil\log_2(r+1)\rceil,\qquad D=\left\lfloor\frac{n}{s}\right\rfloor+1. s = ⌈ log 2 ( r + 1 )⌉ , D = ⌊ s n ⌋ + 1.
For each fixed target x x x , the suffixes w w w of its mandatory programs form one preimage set of H n , r H_{n,r} H n , r , so by Lemma 4.6 any two distinct ones differ in at least D D D coordinates. The programs share the prefix u 1 d 0 u1^d0 u 1 d 0 , so any two distinct mandatory programs outputting x x x are at Hamming distance at least D D D . Let q V q_V q V be a nondecreasing polynomial majorant for the simulation overhead in Definition 2.6. Because L ≤ N L \le N L ≤ N , every mandatory program has finished by
P V ( n ) = q V ( R ( 2 n + 3 ) , 2 n + 3 , d ) , P_V(n) = q_V\left(R(2n+3),2n+3,d\right), P V ( n ) = q V ( R ( 2 n + 3 ) , 2 n + 3 , d ) ,
enlarging this expression to an integer-valued nondecreasing polynomial if necessary. This is a bound on the native transitions of V V V , and it does not assume that the source and the simulator take the same number of steps.
Counting in the untimed fiber. For x ∈ { 0 , 1 } n x \in\{0,1\}^n x ∈ { 0 , 1 } n , let
S x = { p ∈ { 0 , 1 } N : V ( p , ε ) = x eventually } , S_x = \{p \in\{0,1\}^N : V(p,\varepsilon) = x\ \text{eventually}\}, S x = { p ∈ { 0 , 1 } N : V ( p , ε ) = x eventually } ,
and let G x G_x G x be the subgraph of Q N Q_N Q N induced by S x S_x S x , which is the untimed fiber of x x x at length N N N . These untimed fibers have pairwise disjoint vertex sets, because a deterministic program has only one normal output. Apply Lemma 4.8 to them, their k k k mandatory programs per target, and the distance D D D above. Let C n \mathcal{C}_n C n be the targets for which fewer than k / 2 k/2 k /2 components meet those programs. The lemma gives
∣ C n ∣ < 4 ⋅ 2 N D k . |\mathcal{C}_n| < \frac{4 \cdot2^N}{Dk}. ∣ C n ∣ < D k 4 ⋅ 2 N .
Since k = 2 r − n k = 2^{r-n} k = 2 r − n and N − r = 2 d + 1 N-r = 2d+1 N − r = 2 d + 1 , division by 2 n 2^n 2 n yields
∣ C n ∣ 2 n < 4 ⋅ 2 N − r D = 2 2 d + 3 D < 2 2 d + 3 s n . \frac{|\mathcal{C}_n|}{2^n} < \frac{4 \cdot2^{N-r}}{D} = \frac{2^{2d+3}}{D} < 2^{2d+3}\frac{s}{n}. 2 n ∣ C n ∣ < D 4 ⋅ 2 N − r = D 2 2 d + 3 < 2 2 d + 3 n s .
Here D = ⌊ n / s ⌋ + 1 > n / s D = \lfloor n/s \rfloor+ 1 > n/s D = ⌊ n / s ⌋ + 1 > n / s and n , s n,s n , s are positive. As r ≤ 2 n + 2 r \le2n+2 r ≤ 2 n + 2 , we have
s ≤ log 2 ( 2 n + 3 ) + 1 ≤ log 2 ( n + 1 ) + log 2 3 + 1 ≤ 4 log 2 ( n + 1 ) , s \le\log_2(2n+3) + 1 \le\log_2(n+1) + \log_2 3 + 1 \le4\log_2(n+1), s ≤ log 2 ( 2 n + 3 ) + 1 ≤ log 2 ( n + 1 ) + log 2 3 + 1 ≤ 4 log 2 ( n + 1 ) ,
where the last inequality uses log 2 ( n + 1 ) ≥ 1 \log_2(n+1) \ge1 log 2 ( n + 1 ) ≥ 1 . Thus a V = 2 2 d + 5 a_V = 2^{2d+5} a V = 2 2 d + 5 gives the stated size bound for B n = { 0 , 1 } n ∖ C n \mathcal{B}_n = \{0,1\}^n \setminus\mathcal{C}_n B n = { 0 , 1 } n ∖ C n . Put C V = 2 d C_V = 2d C V = 2 d and choose n 0 ≥ max { 1 , 2 d + 1 } n_0 \ge\max\{1,2d+1\} n 0 ≥ max { 1 , 2 d + 1 } , so r ≥ n + 1 r \ge n+1 r ≥ n + 1 throughout. For every x ∈ B n x \in\mathcal{B}_n x ∈ B n , at least k / 2 k/2 k /2 untimed components meet its mandatory programs, and
k 2 = 2 n + 1 − 2 d ≥ 2 n − C V ≥ 2. \frac{k}{2} = 2^{n+1-2d} \ge2^{n-C_V} \ge2. 2 k = 2 n + 1 − 2 d ≥ 2 n − C V ≥ 2.
This proves the untimed assertion and its nonemptiness and disconnection consequences.
Every later deadline. Fix x ∈ B n x \in\mathcal{B}_n x ∈ B n and t ≥ P V ( n ) t \ge P_V(n) t ≥ P V ( n ) . Every untimed component just counted contains a mandatory program, which is already a vertex of the fiber at deadline P V ( n ) P_V(n) P V ( n ) . A path in the time-t t t fiber would also be a path in G x G_x G x , so it cannot join vertices from different such untimed components. The entire time-t t t fiber therefore has at least k / 2 ≥ 2 n − C V k/2 \ge2^{n-C_V} k /2 ≥ 2 n − C V components. The set B n \mathcal{B}_n B n was defined using the untimed fibers alone, so this holds simultaneously for every later deadline. The count includes paths that change bits of the code u u u , so it never assumes that the cylinder of u 1 d 0 u1^d0 u 1 d 0 is separated from the other programs of the fiber. □
The theorem does not force disagreement between two machines at later deadlines. Instead, it shows that the connectedness of the W 2 W_2 W 2 fibers in Theorem 4.4 , asserted at its specified early deadline, does not persist, for most targets, to every later deadline. For every adjunction-universal machine, and so for W 2 W_2 W 2 , most targets at the same program length have disconnected whole fibers once all the mandatory descriptions above have appeared. Adding feasible vertices can create new components, even though an existing path never disappears when the deadline increases. This distinguishes entire-fiber connectedness from connectivity of two fixed endpoints.
Counting the Forced Components. The next family of separated mandatory descriptions, built from Reed–Muller codes, gives an explicit tradeoff between program length, component multiplicity and the exceptional target fraction. We use classical Reed–Muller evaluation codes; see, for example, [4 Section 2.3 of the full version] . The needed distance bound and the complete machine construction are proved below.
A multilinear polynomial has exponent at most one for each variable in every monomial. For integers 0 ≤ j < k 0 \le j < k 0 ≤ j < k , the coefficient vector of a multilinear polynomial in k k k variables of degree at most j j j lists, in a fixed order, its coefficients on all monomials of degree at most j j j . Its evaluation vector lists its values at all binary inputs, in one fixed order. The Reed–Muller code of degree j j j consists of the evaluation vectors, of length 2 k 2^k 2 k , of all multilinear polynomials in k k k variables of degree at most j j j over F 2 \mathbb{F}_2 F 2 . There are ∑ i = 0 j ( k i ) \sum_{i=0}^{j} \binom{k}{i} ∑ i = 0 j ( i k ) monomials of degree at most j j j , which is the number b b b of coefficients below.
Theorem 4.10 (Many components under adjunction; previewed in Theorem 1.1 ). Let V V V be an adjunction-universal machine . There are a constant d ≥ 0 d \ge0 d ≥ 0 and a nondecreasing polynomial P V P_V P V with the following property. For any integers k ≥ 1 k \ge1 k ≥ 1 and 0 ≤ j < k 0 \le j < k 0 ≤ j < k , put
m = 2 k , b = ∑ i = 0 j ( k i ) , D = 2 k − j , N = m + b + d . m = 2^k,\qquad b = \sum_{i=0}^{j} \binom{k}{i},\qquad D = 2^{k-j},\qquad N = m+b+d. m = 2 k , b = i = 0 ∑ j ( i k ) , D = 2 k − j , N = m + b + d . Except for at most the fraction min { 1 , 4 ⋅ 2 d / D } \min\{1,4\cdot2^d/D\} min { 1 , 4 ⋅ 2 d / D } of the m m m -bit targets x x x , the untimed fiber of x x x at length N N N , induced by
S x , N = { p ∈ { 0 , 1 } N : V ( p , ε ) = x } , S_{x,N}=\{p\in\{0,1\}^N: V(p,\varepsilon)=x\}, S x , N = { p ∈ { 0 , 1 } N : V ( p , ε ) = x } , has at least 2 b − 1 2^{b-1} 2 b − 1 connected components. The same targets have at least that many components in G = N , V ( x ) \mathcal{G}_{=N,V}(x) G = N , V ( x ) for every t ≥ P V ( m ) t \ge P_V(m) t ≥ P V ( m ) . One constant d d d and one polynomial work for all the displayed pairs ( k , j ) (k,j) ( k , j ) .
Proof. For a coefficient vector w ∈ { 0 , 1 } b w\in\{0,1\}^b w ∈ { 0 , 1 } b , let E k , j ( w ) E_{k,j}(w) E k , j ( w ) be the length-m m m evaluation vector of its multilinear polynomial of degree at most j j j over F 2 \mathbb{F}_2 F 2 , in a fixed ordering of the monomials and of the k k k -bit evaluation points. Distinct coefficient vectors give evaluation vectors at distance at least D D D . Evaluation at a point is linear over F 2 \mathbb{F}_2 F 2 in the coefficients, so E k , j ( w ) ⊕ E k , j ( w ′ ) = E k , j ( w ⊕ w ′ ) E_{k,j}(w)\oplus E_{k,j}(w')=E_{k,j}(w\oplus w') E k , j ( w ) ⊕ E k , j ( w ′ ) = E k , j ( w ⊕ w ′ ) , and the distance between the evaluation vectors of w ≠ w ′ w\ne w' w = w ′ is the weight of E k , j ( g ) E_{k,j}(g) E k , j ( g ) for the nonzero coefficient vector g = w ⊕ w ′ g=w\oplus w' g = w ⊕ w ′ . Write the polynomial of g g g as ∑ B g B X B \sum_B g_BX_B ∑ B g B X B , the sum over the sets B B B of at most j j j variables, where X B X_B X B is the product of the variables in B B B , with X ∅ = 1 X_{\varnothing}=1 X ∅ = 1 . Choose a set A A A with g A = 1 g_A=1 g A = 1 and ∣ A ∣ = a |A|=a ∣ A ∣ = a maximal among the sets with nonzero coefficient, so a ≤ j a\le j a ≤ j .
Fix values c c c of the k − a k-a k − a variables outside A A A , and sum the polynomial over the 2 a 2^a 2 a evaluation points that agree with c c c outside A A A . Write y i y_i y i for the value such a point gives to a variable i ∈ A i\in A i ∈ A . For one monomial X B X_B X B , its value at such a point is the product of the fixed values c i c_i c i for i ∈ B ∖ A i\in B\setminus A i ∈ B ∖ A times the product of the y i y_i y i for i ∈ B ∩ A i\in B\cap A i ∈ B ∩ A . The second product is one at exactly 2 a − ∣ B ∩ A ∣ 2^{a-|B\cap A|} 2 a − ∣ B ∩ A ∣ of these points, namely those with y i = 1 y_i=1 y i = 1 for every i ∈ B ∩ A i\in B\cap A i ∈ B ∩ A , so the sum of X B X_B X B over the points is that first product times 2 a − ∣ B ∩ A ∣ 2^{a-|B\cap A|} 2 a − ∣ B ∩ A ∣ , reduced modulo two. If B B B does not contain A A A , then ∣ B ∩ A ∣ < a |B\cap A|<a ∣ B ∩ A ∣ < a , the count is even, and the sum is zero. If B B B contains A A A and has nonzero coefficient, then ∣ B ∣ ≤ a |B|\le a ∣ B ∣ ≤ a by the maximality of a a a , so B = A B=A B = A , and the sum is 2 0 = 1 2^0=1 2 0 = 1 times the empty product, which is one.
Summing over B B B gives that the sum of the polynomial over the 2 a 2^a 2 a points equals g A = 1 g_A=1 g A = 1 . Hence at least one of these points has evaluation one. The 2 k − a 2^{k-a} 2 k − a choices of c c c give disjoint sets of points, so the evaluation vector has weight at least 2 k − a ≥ 2 k − j = D 2^{k-a}\ge2^{k-j}=D 2 k − a ≥ 2 k − j = D . This also covers a nonzero constant polynomial, for which A A A is empty and the one point is c c c itself.
Define one fixed polynomial-time machine F F F . It first reads its entire input and obtains its length L L L . Reject if L < 3 L<3 L < 3 . If L = m + b L=m+b L = m + b for a pair ( k , j ) (k,j) ( k , j ) as displayed in the theorem, the inequalities 1 ≤ b < m 1\le b<m 1 ≤ b < m give
2 k < L < 2 k + 1 , 2^k<L<2^{k+1}, 2 k < L < 2 k + 1 ,
so k = ⌊ log 2 L ⌋ k=\lfloor\log_2 L\rfloor k = ⌊ log 2 L ⌋ is determined by L L L . Compute the binomial prefix sums and find the unique j < k j<k j < k for which b = L − 2 k b=L-2^k b = L − 2 k is the displayed sum; reject if none exists or k < 1 k<1 k < 1 . The sums strictly increase with j j j . Parse the input as w a wa w a , with ∣ w ∣ = b |w|=b ∣ w ∣ = b and ∣ a ∣ = m |a|=m ∣ a ∣ = m , and output
a ⊕ E k , j ( w ) , a\oplus E_{k,j}(w), a ⊕ E k , j ( w ) ,
where ⊕ \oplus ⊕ is coordinatewise addition modulo two. There are at most m m m monomials and m m m evaluation points. Enumerating the monomials as subsets of the k k k variables and evaluating each of them at every point takes O ( m b k ) O(mbk) O ( mbk ) elementary operations, hence polynomial time on a fixed multitape implementation. The binomial calculations use O ( k ) O(k) O ( k ) -bit integers. Consequently, for fixed constants A 0 , c 0 ≥ 1 A_0,c_0\ge1 A 0 , c 0 ≥ 1 , one bound A 0 ( L + 1 ) c 0 A_0(L+1)^{c_0} A 0 ( L + 1 ) c 0 covers the native running time of F F F at every input, including rejected lengths. The pair ( k , j ) (k,j) ( k , j ) is read off the input length, so the code of F F F is the same for every pair.
Let h = ⟨ F ⟩ V h=\langle F\rangle_V h = ⟨ F ⟩ V be the code of this one F F F for V V V , and put d = ∣ h ∣ d=|h| d = ∣ h ∣ . For a fixed pair ( k , j ) (k,j) ( k , j ) as displayed and each x ∈ { 0 , 1 } m x\in\{0,1\}^m x ∈ { 0 , 1 } m , all the programs
P x = { h w ( x ⊕ E k , j ( w ) ) : w ∈ { 0 , 1 } b } \mathcal{P}_x=\{hw(x\oplus E_{k,j}(w)):w\in\{0,1\}^b\} P x = { h w ( x ⊕ E k , j ( w )) : w ∈ { 0 , 1 } b }
print x x x . Each has length N N N , and there are W = 2 b W = 2^b W = 2 b of them, one for each w w w . Any two distinct programs in P x \mathcal{P}_x P x are at Hamming distance at least D D D , already in their last m m m positions. By the polynomial simulation bound and L < 2 m L < 2m L < 2 m , all these programs, for every degree and target, halt by one nondecreasing polynomial deadline P V ( m ) P_V(m) P V ( m ) .
Count components in the untimed fiber induced by S x , N S_{x,N} S x , N , including paths that change bits of the code h h h . For this fixed pair ( k , j ) (k,j) ( k , j ) , the graphs for distinct m m m -bit targets have disjoint vertex sets, because V V V is single-valued. Their respective sets P x \mathcal{P}_x P x each contain W = 2 b W = 2^b W = 2 b specified vertices, separated by at least D D D . Apply Lemma 4.8. Fewer than 4 ⋅ 2 N / ( D W ) 4 \cdot2^N/(DW) 4 ⋅ 2 N / ( D W ) targets have fewer than W / 2 W/2 W /2 components meeting their specified programs. Dividing by the 2 m 2^m 2 m possible targets gives
4 ⋅ 2 N D W 2 m = 4 ⋅ 2 d D , \frac{4 \cdot2^N}{DW2^m} = \frac{4 \cdot2^d}{D}, D W 2 m 4 ⋅ 2 N = D 4 ⋅ 2 d ,
since N = m + b + d N = m+b+d N = m + b + d and W = 2 b W = 2^b W = 2 b . The exceptional fraction is therefore at most min { 1 , 4 ⋅ 2 d / D } \min\{1,4 \cdot2^d/D\} min { 1 , 4 ⋅ 2 d / D } . Every remaining untimed fiber has at least W / 2 = 2 b − 1 W/2 = 2^{b-1} W /2 = 2 b − 1 components meeting P x \mathcal{P}_x P x .
All the specified programs have halted by P V ( m ) P_V(m) P V ( m ) . At every t ≥ P V ( m ) t \ge P_V(m) t ≥ P V ( m ) , each of those untimed components consequently has a vertex in the time-t t t fiber. A path in the time-t t t fiber is a path in the untimed fiber, so different counted components cannot be joined at that deadline. The same targets therefore have at least 2 b − 1 2^{b-1} 2 b − 1 components at every later deadline. The constant code and polynomial deadline still work for every displayed pair ( k , j ) (k,j) ( k , j ) , as established by the single source above. □
Taking the evaluation degree near half the number of variables turns the preceding component count into an exponential one.
Corollary 4.11 (Exponential component multiplicity; previewed in Theorem 1.1). For every adjunction-universal machine V V V , there are d d d and P V P_V P V such that for each m = 2 k m = 2^k m = 2 k with k ≥ 2 k \ge2 k ≥ 2 , some length N < 2 m + d N < 2m+d N < 2 m + d has the following property. Except for a fraction at most min { 1 , 4 ⋅ 2 d / m } \min\{1,4 \cdot2^d/\sqrt{m}\} min { 1 , 4 ⋅ 2 d / m } of the m m m -bit targets x x x , the untimed fiber induced by S x , N S_{x,N} S x , N has at least 2 m / 2 − 1 2^{m/2-1} 2 m /2 − 1 components, and so does the fiber G = N , V ( x ) \mathcal{G}_{=N,V}(x) G = N , V ( x ) for every t ≥ P V ( m ) t \ge P_V(m) t ≥ P V ( m ) .
Proof. Take j = ⌊ k / 2 ⌋ j = \lfloor k/2\rfloor j = ⌊ k /2 ⌋ in Theorem 4.10. By binomial symmetry, b = m / 2 b = m/2 b = m /2 for odd k k k , and b = ( m + ( k k / 2 ) ) / 2 b = (m + \binom{k}{k/2})/2 b = ( m + ( k /2 k ) ) /2 for even k k k . Thus b ≥ m / 2 b \ge m/2 b ≥ m /2 , b < m b < m b < m and D = 2 ⌈ k / 2 ⌉ ≥ m D = 2^{\lceil k/2\rceil} \ge\sqrt{m} D = 2 ⌈ k /2 ⌉ ≥ m , giving all the assertions. □
For comparison, take degree j = 2 j = 2 j = 2 with k > 3 k > 3 k > 3 . Then b = 1 + k + ( k 2 ) b = 1 + k + \binom{k}{2} b = 1 + k + ( 2 k ) and N = m + O V ( log 2 m ) N = m + O_V(\log^2 m) N = m + O V ( log 2 m ) , and all but O V ( 1 / m ) O_V(1/m) O V ( 1/ m ) of the targets have at least 2 b − 1 = m ( log 2 m + 1 ) / 2 2^{b-1} = m^{(\log_2 m+1)/2} 2 b − 1 = m ( l o g 2 m + 1 ) /2 components. In the exponential case, any labeling that gives distinct components distinct labels needs at least 2 m / 2 − 1 2^{m/2-1} 2 m /2 − 1 labels, hence at least m / 2 − 1 m/2 - 1 m /2 − 1 bits, which is linear in N N N ; a labeling with only polynomially many possible values in N N N is therefore impossible. This counting bound does not exclude a polynomial-time component test, since such a test may use polynomially many bits. Theorem 4.10 supplies no computational hardness reduction.
Eventual Connectivity and Uniform Hardness
The fragmentation bounds hold at program lengths chosen from the target length. We construct a machine satisfying the three reference conditions for which every fixed target has empty or connected fibers at every deadline once programs are sufficiently long. At shorter lengths, its fibers still make its full connectivity language PSPACE-complete.
Recall the full native fiber F V ( x , N , t ) \mathcal{F}_V(x,N,t) F V ( x , N , t ) of Definition 2.8. This graph includes every program of length N N N , however it begins. A program is admitted at deadline t t t when it is a vertex of this graph. The construction rests on a coloring of a cube. Here a coloring is any map from cube vertices to a set of colors; adjacent vertices may have the same color. The class of a color is its preimage, and it is connected when the subgraph induced by that class is connected. The construction needs a coloring of the cube in which every color class is connected and every vertex has a neighbor of every color. Lemma 5.1 gives one, by modifying the Hamming-syndrome coloring of [8 ] ; we prove it in full because both the connectedness of its classes and the neighbor of every color are used below.
Lemma 5.1 (A connected coloring with a neighbor of every color). *Let n ≥ 3 n \ge3 n ≥ 3 , let K = 2 a K = 2^a K = 2 a be the largest power of two with 2 K − 1 ≤ n 2K - 1 \le n 2 K − 1 ≤ n , and put k = K − 1 k = K - 1 k = K − 1 . Let H H H be the binary a × k a \times k a × k matrix whose columns are
the nonzero vectors of F 2 a \mathbb{F}_2^a F 2 a , in increasing numerical order. Write an n n n -bit string as p = ( u , v , b , w ) p=(u,v,b,w) p = ( u , v , b , w ) , with ∣ u ∣ = ∣ v ∣ = k |u|=|v|=k ∣ u ∣ = ∣ v ∣ = k and ∣ b ∣ = 1 |b|=1 ∣ b ∣ = 1 , and define
D n ( p ) = ( 1 − b ) H u + b H v . D_n(p)=(1-b)Hu+bHv. D n ( p ) = ( 1 − b ) H u + b H v .
The colors are the vectors of F 2 a \mathbb{F}_2^a F 2 a . Every color class is nonempty and connected. For every p p p and every color j j j , some one-bit neighbor q q q satisfies D n ( q ) = j D_n(q)=j D n ( q ) = j . Each vertex of color j j j is joined to a fixed representative of that color by a path of at most n + 1 n+1 n + 1 flips inside its color class. The color D n ( p ) D_n(p) D n ( p ) is computable in polynomial time by a routine whose head movements and number of transitions depend only on n n n .
Proof. Call H u Hu H u and H v Hv H v the syndromes of the registers u u u and v v v , and call b b b the selector. The color is the syndrome of the selected register (u u u if b = 0 b=0 b = 0 , v v v if b = 1 b=1 b = 1 ), and the other register is ignored. Vector addition is coordinatewise modulo two. The columns of H H H include all unit vectors. Choose r j r_j r j using those unit columns so that H r j = j Hr_j=j H r j = j . Start with selector zero and syndrome H u = j Hu=j H u = j . Change the ignored register v v v to r j r_j r j , then flip the selector to one. Change the now-ignored u u u to r j r_j r j , flip the selector back, and clear w w w . Every intermediate vertex has color j j j . This reaches ( r j , r j , 0 , 0 ∣ w ∣ ) (r_j,r_j,0,0^{|w|}) ( r j , r j , 0 , 0 ∣ w ∣ ) in at most
2 k + 2 + ∣ w ∣ = n + 1 2k+2+|w|=n+1 2 k + 2 + ∣ w ∣ = n + 1
flips. From selector one, first change u u u to r j r_j r j and flip the selector to zero. Then change v v v to r j r_j r j and clear w w w . At most n n n flips suffice. These paths prove connectedness and the representative bound. They also exhibit a vertex of every color.
For the neighbor property, let y y y be the currently selected syndrome. If y ≠ j y\ne j y = j , flip the coordinate of the selected register whose column is y + j y+j y + j . That column exists and the new syndrome is j j j . If y = j y=j y = j , flip a bit of the ignored register. Such a bit exists because k ≥ 1 k\ge1 k ≥ 1 . Thus the neighbor is distinct from p p p also in this case. Every chosen neighbor has the opposite parity to p p p .
For the computation, scan both registers and compute both syndromes with fixed-width a a a -bit loops. At position i i i , the column is the a a a -bit representation of i i i . Use fixed-duration bit operations, with dummy operations when an input bit is zero. The counters and scan lengths depend only on n n n and the current position. A fixed-width multiplexing loop reads both syndromes and the selector, following the same head schedule for either selector value. All these are ordinary polynomial-time multitape routines; their stored bits vary with p p p , but their durations and head movements do not. □
For each n ≥ 3 n\ge3 n ≥ 3 , take a a a and K ( n ) = 2 a K(n)=2^a K ( n ) = 2 a as in Lemma 5.1 for this n n n . In the machine below, n n n is the length of a program’s body, the part after its two leading mode bits. The machine prints each color as a binary string, its label , defined next. For a color vector j j j , let i i i be its integer value and let λ a ( j ) \lambda_a(j) λ a ( j ) be the binary representation of i + 1 i+1 i + 1 with its leading one removed. Thus increasing color integers give the strings ordered first by length and then lexicographically (shortlex order), beginning ε , 0 , 1 , 00 , … \varepsilon,0,1,00,\ldots ε , 0 , 1 , 00 , … . The palette P n \mathcal{P}_n P n consists of the first K ( n ) K(n) K ( n ) such strings. For n < 3 n<3 n < 3 put P n = ∅ \mathcal{P}_n=\varnothing P n = ∅ , since at such a body length the machine below prints no color. The label map is injective at fixed n n n , and its outputs have length at most a a a .
Theorem 5.2 (Whole fibers become connected at every deadline; previewed in Theorem 1.3). There is an efficient onto machine V V V with the simulation property such that, for every target x x x , one can compute a threshold
N x ≤ 2 ∣ x ∣ + 2 + 1 N_x\le2^{|x|+2}+1 N x ≤ 2 ∣ x ∣ + 2 + 1 for which F V ( x , N , t ) \mathcal{F}_V(x,N,t) F V ( x , N , t ) is empty or connected for every N ≥ N x N\ge N_x N ≥ N x and every native deadline. Every nonempty such graph has diameter at most 2 N + 4 2N+4 2 N + 4 . The interpretation property can be added to V V V without changing any fiber F V ( x , N , t ) \mathcal{F}_V(x,N,t) F V ( x , N , t ) or any halting time on the empty auxiliary input.
Proof. Fix an efficient onto program-only machine A A A with the simulation property, which we call the base machine. Any such machine will do; Theorem 5.4 takes the program-only realization of the reference machine U U U , which runs U U U with its auxiliary tape fixed empty. A program for V V V of length N ≥ 2 N\ge2 N ≥ 2 consists of two mode bits followed by a body p p p of length n = N − 2 n=N-2 n = N − 2 . Write π ( p ) \pi(p) π ( p ) for the parity of its Hamming weight, and call p p p even or odd accordingly. For n ≥ 3 n \ge3 n ≥ 3 , keep the following outputs:
Table 3.
Programs in mode 00 are base programs, and programs in mode 11 are core programs. Programs in modes 01 and 10 are helpers. A helper in mode 01 or 10 is a source when it runs A A A , and a router when it prints a color label. If n < 3 n < 3 n < 3 , only the base runs A A A and every other mode enters the distinguished halting state. Programs shorter than two bits also reject. These rules cover every program, including arbitrary bodies that are not valid reference codes.
One common color clock. For n ≥ 3 n \ge3 n ≥ 3 , the common front end reads the mode, scans the body, records n n n and its parity, and computes both syndromes and the selected color with the length-dependent schedule of Lemma 5.1. During these scans it also copies the body onto an initially blank private tape. It writes exactly the body bits, no delimiter or marker; all later cells remain blank. A length counter returns that tape’s head to cell one in n n n left moves.
All scans and finite branch tests have equal duration for the different bit values, padding a branch when necessary. The resulting front-end duration depends only on n n n . The work tapes and heads reserved for the native copy of A A A , with its fixed initial data and layout, have not been touched, and the real output tape is still blank.
To print a color of integer value i i i , first store i i i in exactly a + 1 a+1 a + 1 binary positions, with a leading zero. Compute i + 1 i+1 i + 1 by a full fixed-width increment scan, padding the steps after the carry disappears as well, and reset the head in a fixed a + 1 a+1 a + 1 moves. Thus this addition also has duration depending only on a a a .
Scan those positions from the most significant end, skipping leading zeros and the first one, and print each subsequent bit. A one-bit flag records whether the first one has been passed. Use the same fixed number of transitions at every position: before that first one, the output head stays still and no output is written; afterwards the bit is written and the output head moves right. The output tape is never read, so these different output actions do not alter the loop duration. Pad the finite flag cases to that common duration. There are exactly a + 1 a+1 a + 1 iterations, including when the resulting label is ε \varepsilon ε .
Thus every core and router program, which we together call the color programs , of every color at this body length, normally halts at one common time C ( n ) C(n) C ( n ) . That time has a fixed polynomial upper bound in n n n . Define these color routines first, and then choose a fixed nondecreasing integer polynomial B ( n ) B(n) B ( n ) with B ( n ) > C ( n ) B(n)>C(n) B ( n ) > C ( n ) for every n ≥ 3 n \ge3 n ≥ 3 . The color routines do not use B B B , so this choice is not circular.
One shared native simulation. Every program that runs A A A , whether a base program or a source helper, enters the same prelude, ignoring its old mode and parity flags. Compute J = B ( n ) J=B(n) J = B ( n ) in binary on a fresh tape and decrement the counter to zero. Fixed-width scans give exactly J J J iterations, each taking at least one and at most O ( log 2 ( J + 2 ) ) O(\log_2(J+2)) O ( log 2 ( J + 2 )) transitions, including its zero test and head reset. The delay is therefore at least B ( n ) B(n) B ( n ) and has polynomial upper cost in n n n . For the finitely many lengths n < 3 n<3 n < 3 , use the same body-copy preparation and any fixed additional delay on the base.
After preparation, enter a finite-control copy of the fixed native machine A A A . Its program input is the private tape containing exactly p p p , with its head at cell one; its work data, layout and work heads are the original initial ones, and its output is the untouched real output tape. Although the private input tape is writable in V V V , the copied input rules never write it. Its physical first cell implements the original left-end rule, including for an empty body.
Finite tape and state renamings reproduce every native transition of A A A in one transition, with the same writes, erasures and head movements. The copy’s states are disjoint from the front-end states, so a return to its old initial state does not repeat the preparation. No final output copy or test of transient writes is performed: a normal halt delivers precisely the final output configuration of A A A . Distinguished halts remain distinguished, and divergence remains divergence.
Write S ( n ) S(n) S ( n ) for the complete prelude duration before that native copy starts. It depends only on n n n and has one fixed nondecreasing integer-polynomial upper bound P ( n ) P(n) P ( n ) , including body copying, syndrome computation, counter evaluation and the delay. For n ≥ 3 n \ge3 n ≥ 3 it satisfies S ( n ) ≥ B ( n ) > C ( n ) S(n) \ge B(n) > C(n) S ( n ) ≥ B ( n ) > C ( n ) . If A ( p ) A(p) A ( p ) normally halts after u u u transitions, the base 00p p p and its matching source helper , which is 01p p p for even p p p and 10p p p for odd p p p , both halt at exactly
T b ( p ) = T s ( p ) = S ( n ) + u . T_{\mathrm{b}}(p)=T_{\mathrm{s}}(p)=S(n)+u. T b ( p ) = T s ( p ) = S ( n ) + u .
They start the same copy from identical relevant configurations at the same time; their original program tapes differ only in the ignored mode bits. This equality includes an initial normal halt, with u = 0 u=0 u = 0 and output ε \varepsilon ε , if such a halt occurs. No count of u u u is needed in the construction.
Every deadline. By the threshold computation below, N ≥ N x N\ge N_x N ≥ N x forces x ∈ P N − 2 x\in\mathcal{P}_{N-2} x ∈ P N − 2 , so palette targets are the only case. Fix n ≥ 3 n\ge3 n ≥ 3 and x ∈ P n x\in\mathcal{P}_n x ∈ P n . Before C ( n ) C(n) C ( n ) its whole fiber is empty: all color programs halt at C ( n ) C(n) C ( n ) , and every normal simulation halt occurs after C ( n ) C(n) C ( n ) . At and after C ( n ) C(n) C ( n ) , the fiber contains every core program 11q q q whose color has label x x x ; these form a copy of one color class of Lemma 5.1 and are therefore connected. Every router 01q q q or 10q q q in the fiber differs in one mode bit from the core program 11q q q , which prints the same label and is present from C ( n ) C(n) C ( n ) on.
An admitted source 01p p p has even p p p and A ( p ) = x A(p)=x A ( p ) = x . The coloring lemma supplies a one-bit neighbor q q q with label x x x ; its parity is odd, so 01q q q is a router. Hence
01 p → 01 q → 11 q 01p \to01q \to11q 01 p → 01 q → 11 q
is an admitted target-x x x path: its last two vertices already halted at C ( n ) C(n) C ( n ) . An admitted source 10p p p instead has odd p p p . Its color-x x x neighbor q q q has even parity, so 10q q q is a router, and the admitted path is
10 p → 10 q → 11 q . 10p \to10q \to11q. 10 p → 10 q → 11 q .
An admitted base 00p p p has its matching source helper admitted at exactly the same time: it is 01p p p for even p p p and 10p p p for odd p p p . That first mode flip followed by the relevant two-edge path attaches the base to the core. All cases preserve the original target, program length and deadline. They cover every noncore vertex, so the entire fiber is connected at every deadline from C ( n ) C(n) C ( n ) onward.
Each vertex attaches to the core in at most three flips. Every core vertex reaches its fixed representative in at most n + 1 n+1 n + 1 flips, all within the complete core already present at that deadline. Thus two admitted vertices have a connecting walk of length at most
3 + ( n + 1 ) + ( n + 1 ) + 3 = 2 n + 8 = 2 N + 4. 3+(n+1)+(n+1)+3=2n+8=2N+4. 3 + ( n + 1 ) + ( n + 1 ) + 3 = 2 n + 8 = 2 N + 4.
Removing repeated portions cannot increase that length, giving the diameter bound.
Threshold and reference properties. The shortlex rank of x x x , which is the integer value of the color labeled x x x , is i ( x ) = 2 ∣ x ∣ − 1 + val ( x ) i(x)=2^{|x|}-1+\operatorname{val}(x) i ( x ) = 2 ∣ x ∣ − 1 + val ( x ) . Let K x K_x K x be the least power of two at least max { 2 , i ( x ) + 1 } \max\{2,i(x)+1\} max { 2 , i ( x ) + 1 } . For ∣ x ∣ ≥ 1 |x|\ge1 ∣ x ∣ ≥ 1 ,
2 ∣ x ∣ ≤ i ( x ) + 1 = 2 ∣ x ∣ + val ( x ) ≤ 2 ∣ x ∣ + 1 − 1 , 2^{|x|}\le i(x)+1=2^{|x|}+\operatorname{val}(x)\le2^{|x|+1}-1, 2 ∣ x ∣ ≤ i ( x ) + 1 = 2 ∣ x ∣ + val ( x ) ≤ 2 ∣ x ∣ + 1 − 1 ,
so K x ≤ 2 ∣ x ∣ + 1 K_x\le2^{|x|+1} K x ≤ 2 ∣ x ∣ + 1 . For x = ε x=\varepsilon x = ε , i ( x ) = 0 i(x)=0 i ( x ) = 0 and K x = 2 K_x=2 K x = 2 , giving the same bound. Put N x = 2 K x + 1 ≤ 2 ∣ x ∣ + 2 + 1 N_x=2K_x+1\le2^{|x|+2}+1 N x = 2 K x + 1 ≤ 2 ∣ x ∣ + 2 + 1 ; in particular N ε = 5 N_\varepsilon=5 N ε = 5 . If N ≥ N x N\ge N_x N ≥ N x , then N − 2 ≥ 2 K x − 1 ≥ 3 N-2\ge2K_x-1\ge3 N − 2 ≥ 2 K x − 1 ≥ 3 , so K ( n ) ≥ K x > i ( x ) K(n)\ge K_x>i(x) K ( n ) ≥ K x > i ( x ) and hence the actual palette contains x x x . All these integer operations are computable from x x x .
For adjunction use ⟨ M ⟩ V = 00 ⟨ M ⟩ A \langle M\rangle_V=00\langle M\rangle_A ⟨ M ⟩ V = 00 ⟨ M ⟩ A . On every raw suffix z z z , the copied body is exactly ⟨ M ⟩ A z \langle M\rangle_Az ⟨ M ⟩ A z , with n = ∣ ⟨ M ⟩ A ∣ + ∣ z ∣ n=|\langle M\rangle_A|+|z| n = ∣ ⟨ M ⟩ A ∣ + ∣ z ∣ . If M ( z ) M(z) M ( z ) halts in T T T steps, let q A q_A q A be the nondecreasing uniform simulation polynomial of A A A and let h ′ = ∣ ⟨ M ⟩ V ∣ h' = |\langle M\rangle_V| h ′ = ∣ ⟨ M ⟩ V ∣ . The complete native runtime of V V V is at most
P ( h ′ + ∣ z ∣ ) + q A ( T , ∣ z ∣ , h ′ ) , P(h'+|z|)+q_A(T,|z|,h'), P ( h ′ + ∣ z ∣ ) + q A ( T , ∣ z ∣ , h ′ ) ,
because ∣ ⟨ M ⟩ A ∣ ≤ h ′ |\langle M\rangle_A|\le h' ∣ ⟨ M ⟩ A ∣ ≤ h ′ and the native copy adds no slowdown after preparation. This is one polynomial in the required three arguments, independent of M M M . Prepending 00 also preserves the polynomial computability and length bounds of the code map. The base gives onto-ness, and efficiency follows from the fixed native implementation. Finally Lemma 3.25 adds interpretation while preserving every unconditional output predicate at its original deadline and retaining this code map.
Figure 1 summarizes the attachment path and the native-time comparisons used in the proof. The threshold may depend on the target without preventing a polynomial algorithm for each fixed target. The explicit threshold also gives one uniform algorithm with a large target-dependent factor.
Figure 1. Attachment inside the palette. Arrows mark the order of attachment along undirected one-bit edges; each next vertex has halted no later than the preceding one. For odd p p p , exchange the helper modes 01 and 10. All color programs of this body length halt at the common time C ( n ) C(n) C ( n ) . The displayed base and its matching source helper appear together after that time. For a target outside the palette, every admitted source helper is a leaf adjacent to its simultaneously admitted base. This is the leaf structure used in Theorem 5.4 .
For n ≥ 3 n \ge3 n ≥ 3 , let p p p be even and A ( p ) = x ∈ P n A(p)=x\in\mathcal{P}_n A ( p ) = x ∈ P n . Choose a one-bit neighbor q q q with λ a ( D n ( q ) ) = x \lambda_a(D_n(q))=x λ a ( D n ( q )) = x . Write T s ( p ) T_s(p) T s ( p ) and T b ( p ) T_b(p) T b ( p ) for the normal halt times of the matching source helper and base.
00 p ⟶ 01 p ⟶ 01 q ⟶ 11 q base source helper router core T b ( p ) T s ( p ) C ( n ) C ( n ) \begin{array}{ccccc}
00p & \longrightarrow& 01p & \longrightarrow& 01q & \longrightarrow& 11q \\
\text{base} & & \text{source helper} & & \text{router} & & \text{core} \\
T_b(p) & & T_s(p) & & C(n) & & C(n)
\end{array} 00 p base T b ( p ) ⟶ 01 p source helper T s ( p ) ⟶ 01 q router C ( n ) ⟶ 11 q core C ( n )
C ( n ) < B ( n ) ≤ T s ( p ) = T b ( p ) . C(n)<B(n)\le T_s(p)=T_b(p). C ( n ) < B ( n ) ≤ T s ( p ) = T b ( p ) .
Corollary 5.3 (Every fixed target is polynomial-time decidable; previewed in Theorem 1.3 ). Let V V V be an efficient machine such that each target x x x has a length N x N_x N x for which F V ( x , N , t ) \mathcal{F}_V(x,N,t) F V ( x , N , t ) is empty or connected for every N ≥ N x N\ge N_x N ≥ N x and every deadline t t t . Then Conn x ( V ) ∈ P \operatorname{Conn}_x(V)\in\mathrm{P} Conn x ( V ) ∈ P for every x x x . For the machine of Theorem 5.2 , the full language has a uniform algorithm running in
2 2 O ( ∣ x ∣ ) poly ( query length ) . 2^{2^{O(|x|)}}\operatorname{poly}(\text{query length}). 2 2 O ( ∣ x ∣ ) poly ( query length ) .
Proof. Fix x x x and hardwire its finite threshold N x N_x N x . First check syntax, equal endpoint lengths and feasibility of both endpoints by bounded simulation at the supplied unary deadline. Reject infeasible queries. For a common length N ≥ N x N\ge N_x N ≥ N x , feasibility implies connectivity. For N < N x N<N_x N < N x , enumerate the finite cube of at most 2 N x 2^{N_x} 2 N x programs, simulate each at the given deadline, and search its induced graph. The number of vertices is a constant for this fixed target, while bounded simulation is polynomial in query length. No uniformly computable threshold is required for this fixed-target assertion.
For the explicit construction, compute N x N_x N x using integers with O ( ∣ x ∣ ) O(|x|) O ( ∣ x ∣ ) bits. A cube search below that threshold costs 2 O ( N x ) 2^{O(N_x)} 2 O ( N x ) times a polynomial in query length. The threshold bound in Theorem 5.2 gives the stated uniform running time. It does not give a polynomial bound independent of x x x . □
Uniform hardness survives when the base machine A A A is the reference machine U U U of Definition 3.5 . The reduction adapts the proof of Corollary 3.24, but the argument that the encoded solution graph is a union of fiber components must now account for the helper programs. For a target outside the palette, each source helper in the fiber is a leaf attached to its base program (Figure 1 ), so the helpers join no two components of the subgraph induced by the base programs. We call these components base components.
Theorem 5.4 (Uniform hardness with every fixed target easy; previewed in Theorem 1.3 ). The machine in Theorem 5.2 can be chosen so that its full connectivity language is PSPACE-complete while Conn x ( V ) ∈ P \operatorname{Conn}_x(V)\in\mathrm{P} Conn x ( V ) ∈ P for every fixed target x x x . It satisfies all three reference conditions and retains the length thresholds and diameter bounds of that theorem. The hardness reduction from an input of length L L L in Fact 3.17 uses a target of length O ( log ( L + 2 ) ) O(\log(L+2)) O ( log ( L + 2 )) , while its entire query, including the unary deadline, has polynomial length.
Proof. Take the base machine A A A to be the program-only realization of U U U , which runs U U U with its auxiliary tape fixed empty. Fix a body length m m m and a target y ∉ P m y\notin\mathcal{P}_m y ∈ / P m ; in this proof m m m denotes a body length, and n n n is reserved for the number of formula variables. Let Q y Q_y Q y be the length-m m m bodies for which U ( p ) U(p) U ( p ) eventually normally outputs y y y . Write α ( p ) = 01 \alpha(p)=01 α ( p ) = 01 for even p p p and 10 for odd p p p . For m ≥ 3 m\ge3 m ≥ 3 , the untimed fiber of y y y at program length m + 2 m+2 m + 2 has exactly the vertices
{ 00 p : p ∈ Q y } ∪ { α ( p ) p : p ∈ Q y } . \{00p:p\in Q_y\}\cup\{\alpha(p)p:p\in Q_y\}. { 00 p : p ∈ Q y } ∪ { α ( p ) p : p ∈ Q y } .
Every router and core prints a palette label and hence cannot print y y y . Two base vertices are adjacent exactly when their bodies are neighbors. Within this fiber, each helper is adjacent only to its base. Flipping a body bit of a helper reverses the parity, so the result is a router. The two helper modes differ in two bits, so no helper is adjacent to another helper with the same body. Flipping a mode bit of α ( p ) p \alpha(p)p α ( p ) p gives either the base 00 p 00p 00 p or the core program 11 p 11p 11 p .
The shared native simulation in Theorem 5.2 makes each base and its matching helper halt at exactly the same time. Thus at every finite deadline each admitted base has its helper admitted as a leaf attached to it, no other helper is admitted, and the helpers join no two base components. For m < 3 m < 3 m < 3 there are no helpers and the same assertion about base components is immediate.
Reduce from the explicit-endpoint solution-connectivity problem of Fact 3.17 . Let ( φ , s , t 0 ) (\varphi,s,t_0) ( φ , s , t 0 ) be a valid instance on n ≥ 1 n \ge1 n ≥ 1 variables, of encoding length L ≥ n + ∣ φ ∣ L \ge n+|\varphi| L ≥ n + ∣ φ ∣ and L ≥ 1 L \ge1 L ≥ 1 . For every integer b ≥ 1 b \ge1 b ≥ 1 , put y b = 1 b y_b = 1^b y b = 1 b . Construct a total native verifier M φ , b M_{\varphi,b} M φ , b which checks exact input length n n n , prints y b y_b y b on satisfying assignments, and prints ε \varepsilon ε otherwise. Its formula, unary length, target and initial layout are explicit data. The length check reads at most n + 1 n+1 n + 1 cells, and the formula-evaluation procedure of § 3.5 gives fixed polynomial bounds in L + b + 1 L+b+1 L + b + 1 for construction and all length-n n n runs. Put h b = ⟨ M φ , b ⟩ h_b = \langle M_{\varphi,b}\rangle h b = ⟨ M φ , b ⟩ and m b = ∣ h b ∣ + n m_b = |h_b|+n m b = ∣ h b ∣ + n . By Proposition 3.3, there are fixed constants C , e ≥ 1 C,e \ge1 C , e ≥ 1 such that
m b ≤ C ( L + b + 1 ) e m_b \le C(L+b+1)^e m b ≤ C ( L + b + 1 ) e
for every L , b L,b L , b in this construction. Choose one fixed integer κ > e \kappa> e κ > e with
3 κ − e > ( C + 1 ) ( 2 κ + 1 ) e . 3^{\kappa-e} > (C+1)(2\kappa+1)^e. 3 κ − e > ( C + 1 ) ( 2 κ + 1 ) e .
Such an integer exists because the exponential in κ \kappa κ eventually exceeds that fixed polynomial. Set u = L + 2 ≥ 3 u = L+2 \ge3 u = L + 2 ≥ 3 and choose directly
b = κ ⌈ log 2 u ⌉ . b = \kappa\lceil\log_2 u\rceil. b = κ ⌈ log 2 u ⌉ .
The ceiling is computable from the binary length of u u u and a power-of-two test. Since log 2 u > 1 \log_2 u > 1 log 2 u > 1 , this gives
κ log 2 u ≤ b ≤ κ ( log 2 u + 1 ) < 2 κ log 2 u , L + b + 1 ≤ ( 2 κ + 1 ) u . \kappa\log_2 u \le b \le\kappa(\log_2 u+1) < 2\kappa\log_2 u,\qquad L+b+1 \le(2\kappa+1)u. κ log 2 u ≤ b ≤ κ ( log 2 u + 1 ) < 2 κ log 2 u , L + b + 1 ≤ ( 2 κ + 1 ) u .
Consequently
m b + 1 ≤ ( C + 1 ) ( 2 κ + 1 ) e u e < u κ ≤ 2 b . m_b+1 \le(C+1)(2\kappa+1)^e u^e < u^\kappa\le2^b. m b + 1 ≤ ( C + 1 ) ( 2 κ + 1 ) e u e < u κ ≤ 2 b .
The strict inequality uses u κ − e ≥ 3 κ − e u^{\kappa-e} \ge3^{\kappa-e} u κ − e ≥ 3 κ − e and the choice of κ \kappa κ . This calculation accounts for the code’s dependence on the target before any code is built. Only one verifier and one code are constructed, with b = O ( log ( L + 2 ) ) b = O(\log(L+2)) b = O ( log ( L + 2 )) and all their lengths polynomial in L L L . For m b ≥ 3 m_b \ge3 m b ≥ 3 , every palette label has length at most log 2 K ( m b ) < b \log_2 K(m_b) < b log 2 K ( m b ) < b , because K ( m b ) ≤ ( m b + 1 ) / 2 < 2 b K(m_b) \le(m_b+1)/2 < 2^b K ( m b ) ≤ ( m b + 1 ) /2 < 2 b . Hence y b y_b y b lies outside the actual palette; for m b < 3 m_b < 3 m b < 3 that palette is empty.
Abbreviate the chosen code and body length by h , m h,m h , m . Let T M ( L + b + 1 ) T_M(L+b+1) T M ( L + b + 1 ) be a fixed polynomial bound for the verifier runs on length-n n n inputs. The uniform simulation polynomial of U U U , evaluated at T M ( L + b + 1 ) T_M(L+b+1) T M ( L + b + 1 ) , n n n and ∣ h ∣ |h| ∣ h ∣ , gives a polynomial upper bound u max u_{\max} u m a x on the running time of U ( h v ) U(hv) U ( h v ) for every v ∈ { 0 , 1 } n v \in\{0,1\}^n v ∈ { 0 , 1 } n . Let P ( m ) P(m) P ( m ) be the polynomial majorant for the complete shared prelude in Theorem 5.2 . Take
τ = P ( m ) + u max . \tau= P(m)+u_{\max}. τ = P ( m ) + u m a x .
The native copy adds exactly the underlying U U U transitions after this prelude. Thus every satisfying base and its source helper have halted by τ \tau τ . This deadline is polynomial in L L L , so 1 τ 1^\tau 1 τ is polynomial-time writable. Base programs 00 h v 00hv 00 h v with unsatisfying v v v output ε ≠ y b \varepsilon\ne y_b ε = y b and are infeasible at this target at every deadline.
Flipping one of the last n n n bits of 00 h v 00hv 00 h v keeps the program in the fiber exactly when the flipped assignment also satisfies φ \varphi φ . A flip inside the code gives 00 h ′ v 00h'v 00 h ′ v . By the full rigidity clause of Proposition 3.3, no codeword of any length prefixes h ′ v h'v h ′ v , so U U U diverges on that body. A mode flip can reach only the source-helper leaf α ( h v ) h v \alpha(hv)hv α ( h v ) h v ; the other neighbor is a router and cannot print y b y_b y b . That leaf has no other target-y b y_b y b neighbor by the parity argument above. The base programs 00 h v 00hv 00 h v with v v v satisfying, together with their helper leaves, therefore form a union of components of the entire deadline-τ \tau τ fiber. Deleting the leaves recovers exactly the solution graph of φ \varphi φ .
Thus s s s and t 0 t_0 t 0 are connected in the solution graph of φ \varphi φ if and only if 00 h s 00hs 00 h s and 00 h t 0 00ht_0 00 h t 0 are connected in F v ( y b , m + 2 , τ ) \mathcal{F}_v(y_b,m+2,\tau) F v ( y b , m + 2 , τ ) . The reduction outputs ( y b , 1 τ , 00 h s , 00 h t 0 ) (y_b,1^\tau,00hs,00ht_0) ( y b , 1 τ , 00 h s , 00 h t 0 ) . Malformed source instances or infeasible source endpoints map to a fixed malformed no-query.
We argue directly instead of applying Proposition 3.23 , whose second hypothesis fails here: a mode-bit flip of 00 h v 00hv 00 h v can give a feasible helper. Membership is Proposition 3.22 . Apply Lemma 3.25 to retain the full language, all unconditional deadline graphs and the code map while adding interpretation. The fixed-target conclusion follows from Corollary 5.3 . □
The hardness reduction varies its target and uses lengths below that target’s eventual threshold. The construction does not give a machine whose full connectivity language is not PSPACE-hard, and therefore does not settle Open Problem 1. Nor does it assert that every target has empty or connected fibers at every program length.
The exponential dependence of the threshold on target length cannot be replaced by a uniform subexponential bound. This follows by retuning the fixed source in the packing argument of Theorem 4.9 . The resulting obstruction occurs at an exponentially large program length for most targets of every sufficiently large length. It concerns connectivity of the whole fiber, rather than the complexity of testing its components.
Theorem 5.5 (Exponential lengths with permanent fragmentation; previewed in Theorem 1.3 ). Let V V V have the simulation property of Definition 2.6. There are constants c V > 0 c_V > 0 c V > 0 , h h h and m 0 m_0 m 0 , and a polynomial Q V Q_V Q V , with the following property. For every m ≥ m 0 m \ge m_0 m ≥ m 0 there are a length N m N_m N m and a set B m ⊆ { 0 , 1 } m \mathcal{B}_m \subseteq\{0,1\}^m B m ⊆ { 0 , 1 } m satisfying
2 c V m − 2 ≤ N m < 2 c V m + h , ∣ B m ∣ > 3 ⋅ 2 m 4 . 2^{c_V m-2} \le N_m < 2^{c_V m}+h,\qquad|\mathcal{B}_m| > \frac{3 \cdot2^m}{4}. 2 c V m − 2 ≤ N m < 2 c V m + h , ∣ B m ∣ > 4 3 ⋅ 2 m . For every x ∈ B m x \in\mathcal{B}_m x ∈ B m and every native deadline t ≥ Q V ( N m ) t \ge Q_V(N_m) t ≥ Q V ( N m ) , the entire graph F V ( x , N m , t ) \mathcal{F}_V(x,N_m,t) F V ( x , N m , t ) is nonempty and disconnected. The same set B m \mathcal{B}_m B m works for every such deadline.
Proof. We use Lemmas 4.6 and 4.7. For integers b ≥ m ≥ 1 b \ge m \ge1 b ≥ m ≥ 1 , the first lemma constructs a rank-m m m binary matrix H m , b H_{m,b} H m , b in polynomial time. Put s = ⌈ log 2 ( b + 1 ) ⌉ s = \lceil\log_2(b+1)\rceil s = ⌈ log 2 ( b + 1 )⌉ . Every output of the linear map w ↦ H m , b w w \mapsto H_{m,b}w w ↦ H m , b w from { 0 , 1 } b \{0,1\}^b { 0 , 1 } b to { 0 , 1 } m \{0,1\}^m { 0 , 1 } m has exactly 2 b − m 2^{b-m} 2 b − m preimages, and distinct preimages have Hamming distance at least
D = ⌊ m s ⌋ + 1. D = \left\lfloor\frac{m}{s}\right\rfloor+ 1. D = ⌊ s m ⌋ + 1.
The second lemma bounds the size of a connected cube subgraph containing separated specified vertices, even when their connecting paths leave the specified set.
One source before taking its code. Define a fixed native machine F F F as follows. It scans its entire raw input and parses it at the first zero as 1 a 0 w 1^a0w 1 a 0 w . Write b = ∣ w ∣ b = |w| b = ∣ w ∣ . If there is no zero, or if b = 0 b = 0 b = 0 , it enters the distinguished halting state. Otherwise it computes, in binary,
s = ⌈ log 2 ( b + 1 ) ⌉ , K a = 2 2 a + 4 , r = b mod K a , m = K a s + r . s = \lceil\log_2(b+1)\rceil,\qquad K_a = 2^{2a+4},\qquad r = b \mathbin{\operatorname{mod}} K_a,\qquad m = K_a s + r. s = ⌈ log 2 ( b + 1 )⌉ , K a = 2 2 a + 4 , r = b mod K a , m = K a s + r .
It rejects unless 1 ≤ m ≤ b − 1 1 \le m \le b-1 1 ≤ m ≤ b − 1 . After this guard, it constructs H m , b H_{m,b} H m , b , multiplies it by w w w over F 2 \mathbb{F}_2 F 2 , and writes exactly the resulting m m m bits, including leading zeros, before normally halting.
This is a polynomial-time machine on every raw input. The binary representation of K a K_a K a has 2 a + 5 2a+5 2 a + 5 bits; no unary block of that size is allocated. Computing the other integers and the guard takes polynomial time in the input length. The matrix is constructed only when m < b m < b m < b , so its construction, multiplication and fixed-width output also take polynomial time. Let R ( L ) R(L) R ( L ) be one nondecreasing integer polynomial bounding the complete native runtime on every input of length L L L , including rejected inputs. There is no hardwired variable data: the work tapes start blank, and the output tape remains blank until the final left-to-right write. Invalid cases enter the distinguished halting state rather than output ε \varepsilon ε .
Let u = ⟨ F ⟩ V u = \langle F\rangle_V u = ⟨ F ⟩ V be the code for V V V of this already defined source. Let d = ∣ u ∣ d = |u| d = ∣ u ∣ , put h = 2 d + 1 h = 2d+1 h = 2 d + 1 , and fix K = 2 2 d + 4 K = 2^{2d+4} K = 2 2 d + 4 . For each raw w w w consider the program
p ( w ) = u 1 d 0 w . p(w) = u1^d0w. p ( w ) = u 1 d 0 w .
The source receives precisely the raw suffix 1 d 0 w 1^d0w 1 d 0 w , and thus uses a = d a = d a = d and the fixed constant K K K . Its full program length is N = b + h N = b+h N = b + h . The order of these choices is essential: first define F F F , then obtain u u u , then supply d d d as an ordinary raw-input parameter. No parameter-dependent recomputation of the code or circular bound on a code is used. If d = 0 d = 0 d = 0 , the raw prefix is simply 0 0 0 , and h = 1 h = 1 h = 1 .
Take a nondecreasing polynomial majorant q V q_V q V for the simulation overhead in Definition 2.6. The source input length is b + d + 1 ≤ N b+d+1 \le N b + d + 1 ≤ N . Hence every successful mandatory program p ( w ) p(w) p ( w ) has normally halted by the common native deadline
Q V ( N ) = q V ( R ( N ) , N , d ) , Q_V(N) = q_V(R(N),N,d), Q V ( N ) = q V ( R ( N ) , N , d ) ,
after integer-polynomial majorization if needed. This includes all source scans, setup and emission. It bounds physical transitions of V V V and is polynomial in program length N N N ; it need not be polynomial in the much shorter target length.
Every sufficiently large target length. Given a sufficiently large m m m , write m = K s + r m=Ks+r m = K s + r with s = ⌊ m / K ⌋ s=\lfloor m/K\rfloor s = ⌊ m / K ⌋ and 0 ≤ r < K 0\le r<K 0 ≤ r < K . Let δ \delta δ be the least nonnegative residue of r − 2 s − 1 r-2^{s-1} r − 2 s − 1 modulo K K K , and choose
b = 2 s − 1 + δ . b=2^{s-1}+\delta. b = 2 s − 1 + δ .
Take m 0 = K ( K + 1 ) m_0=K(K+1) m 0 = K ( K + 1 ) , so m ≥ m 0 m\ge m_0 m ≥ m 0 gives s ≥ K + 1 ≥ 17 s\ge K+1\ge17 s ≥ K + 1 ≥ 17 , since K ≥ 16 K\ge16 K ≥ 16 . For every integer s ≥ 7 s\ge7 s ≥ 7 we have 2 s − 1 ≥ s 2 2^{s-1}\ge s^2 2 s − 1 ≥ s 2 . At s = 7 s=7 s = 7 this is 64 ≥ 49 64\ge49 64 ≥ 49 . If it holds at s s s , then 2 s ≥ 2 s 2 ≥ ( s + 1 ) 2 2^s\ge2s^2\ge(s+1)^2 2 s ≥ 2 s 2 ≥ ( s + 1 ) 2 , because 2 s 2 − ( s + 1 ) 2 = s 2 − 2 s − 1 ≥ 0 2s^2-(s+1)^2=s^2-2s-1\ge0 2 s 2 − ( s + 1 ) 2 = s 2 − 2 s − 1 ≥ 0 for s ≥ 7 s\ge7 s ≥ 7 . Consequently
2 s − 1 ≥ s 2 ≥ ( K + 1 ) s > K ( s + 1 ) , 2^{s-1}\ge s^2\ge(K+1)s>K(s+1), 2 s − 1 ≥ s 2 ≥ ( K + 1 ) s > K ( s + 1 ) ,
where the last inequality follows from ( K + 1 ) s − K ( s + 1 ) = s − K > 0 (K+1)s-K(s+1)=s-K>0 ( K + 1 ) s − K ( s + 1 ) = s − K > 0 . Then
2 s − 1 ≤ b ≤ 2 s − 1 + K − 1 ≤ 2 s − 1. 2^{s-1}\le b\le2^{s-1}+K-1\le2^s-1. 2 s − 1 ≤ b ≤ 2 s − 1 + K − 1 ≤ 2 s − 1.
Therefore ⌈ log 2 ( b + 1 ) ⌉ = s \lceil\log_2(b+1)\rceil=s ⌈ log 2 ( b + 1 )⌉ = s . Indeed, b + 1 > 2 s − 1 b+1>2^{s-1} b + 1 > 2 s − 1 gives ⌈ log 2 ( b + 1 ) ⌉ ≥ s \lceil\log_2(b+1)\rceil\ge s ⌈ log 2 ( b + 1 )⌉ ≥ s , and b + 1 ≤ 2 s b+1\le2^s b + 1 ≤ 2 s gives ⌈ log 2 ( b + 1 ) ⌉ ≤ s \lceil\log_2(b+1)\rceil\le s ⌈ log 2 ( b + 1 )⌉ ≤ s . Also b m o d K = r b\bmod K=r b mod K = r , so the source computes exactly the prescribed output length m m m . Its guard succeeds, since
m ≤ K ( s + 1 ) − 1 ≤ b − 1. m\le K(s+1)-1\le b-1. m ≤ K ( s + 1 ) − 1 ≤ b − 1.
Put N m = b + h N_m=b+h N m = b + h . For every m m m -bit target there are exactly k = 2 b − m ≥ 2 k=2^{b-m}\ge2 k = 2 b − m ≥ 2 mandatory programs outputting it. For each fixed m m m -bit target, all its mandatory programs are admitted by Q V ( N m ) Q_V(N_m) Q V ( N m ) and have pairwise distances at least
D = ⌊ K s + r s ⌋ + 1 = K + ⌊ r s ⌋ + 1 ≥ K + 1. D=\left\lfloor\frac{Ks+r}{s}\right\rfloor+1=K+\left\lfloor\frac{r}{s}\right\rfloor+1\ge K+1. D = ⌊ s K s + r ⌋ + 1 = K + ⌊ s r ⌋ + 1 ≥ K + 1.
The full untimed cube. For a target x x x , let S x , N m S_{x,N_m} S x , N m be the set of all length-N m N_m N m programs eventually normally outputting x x x . Let C m \mathcal{C}_m C m be the set of m m m -bit targets whose mandatory programs all lie in one component of the full induced graph Q N m [ S x , N m ] Q_{N_m}[S_{x,N_m}] Q N m [ S x , N m ] . For each such target, that component has at least k D / 2 kD/2 k D /2 vertices by Lemma 4.7 . The components chosen for different targets are disjoint, since a deterministic program has at most one normal output. They all lie in the same cube, so
∣ C m ∣ k D 2 ≤ 2 N m . |\mathcal{C}_m|\frac{kD}{2}\le2^{N_m}. ∣ C m ∣ 2 k D ≤ 2 N m .
Using the definitions of k , N m , h , K k,N_m,h,K k , N m , h , K gives
∣ C m ∣ 2 m ≤ 2 h + 1 D ≤ 2 2 d + 2 K + 1 = K 4 ( K + 1 ) < 1 4 . \frac{|\mathcal{C}_m|}{2^m}\le\frac{2^{h+1}}{D}\le\frac{2^{2d+2}}{K+1}=\frac{K}{4(K+1)}<\frac14. 2 m ∣ C m ∣ ≤ D 2 h + 1 ≤ K + 1 2 2 d + 2 = 4 ( K + 1 ) K < 4 1 .
Thus B m = { 0 , 1 } m ∖ C m \mathcal{B}_m=\{0,1\}^m\setminus\mathcal{C}_m B m = { 0 , 1 } m ∖ C m has the required strict three-quarter bound. This counts the entire untimed fiber. Its paths may change the code u u u , the unary parameter, the parse or any other coordinate; no isolation of a code cell is assumed.
Fix x ∈ B m x\in\mathcal{B}_m x ∈ B m and t ≥ Q V ( N m ) t\ge Q_V(N_m) t ≥ Q V ( N m ) . All its mandatory programs are feasible at this deadline, yet at least two lie in different components even in the untimed fiber. No deadline subgraph can connect them. The entire fiber is therefore nonempty and disconnected, with the same set B m \mathcal{B}_m B m at every later deadline. Finally, m / K = s + r / K < s + 1 m/K=s+r/K<s+1 m / K = s + r / K < s + 1 , so m / K − 2 < s − 1 m/K-2<s-1 m / K − 2 < s − 1 and
N m ≥ b ≥ 2 s − 1 > 2 m / K − 2 . N_m\ge b\ge2^{s-1}>2^{m/K-2}. N m ≥ b ≥ 2 s − 1 > 2 m / K − 2 .
The upper bound follows from b ≤ 2 s − 1 < 2 s ≤ 2 m / K b\le2^s-1<2^s\le2^{m/K} b ≤ 2 s − 1 < 2 s ≤ 2 m / K :
N m = b + h < 2 m / K + h . N_m=b+h<2^{m/K}+h. N m = b + h < 2 m / K + h .
Taking c V = 1 / K c_V=1/K c V = 1/ K proves the bounds. □
The set B m \mathcal{B}_m B m need not be recognizable. Its size nevertheless forces a lower bound on any assignment of eventual-connectivity thresholds.
Corollary 5.6 (The exponential order of eventual thresholds is necessary; previewed in Theorem 1.3 ). Suppose V V V has the simulation property and integer-valued thresholds N x N_x N x such that F V ( x , N , t ) \mathcal{F}_V(x,N,t) F V ( x , N , t ) is empty or connected for every N ≥ N x N \ge N_x N ≥ N x and every deadline t t t . For every sufficiently large m m m , more than three quarters of the targets x ∈ { 0 , 1 } m x \in\{0,1\}^m x ∈ { 0 , 1 } m satisfy
N x ≥ 2 c V m − 2 N_x \ge2^{c_Vm-2} N x ≥ 2 c V m − 2 for the constant c V > 0 c_V > 0 c V > 0 of Theorem 5.5 . In particular no uniform upper envelope N x ≤ 2 o ( ∣ x ∣ ) N_x \le2^{o(|x|)} N x ≤ 2 o ( ∣ x ∣ ) is possible. Together with Theorem 5.2 , exponential growth in target length is therefore necessary for every adjunction-universal machine with such thresholds and is achieved by one machine satisfying the reference conditions. The exponent constants are not asserted sharp.
Proof. For each target x ∈ B m x \in\mathcal{B}_m x ∈ B m in Theorem 5.5 , the nonempty disconnected fiber at length N m N_m N m forces N x > N m N_x > N_m N x > N m . Otherwise that length would be covered by the assumed eventual property at every deadline. Since the thresholds are integers, N x ≥ N m + 1 N_x \ge N_m + 1 N x ≥ N m + 1 , and the displayed lower bound follows. A uniform subexponential envelope would have base-two logarithm divided by m m m tending to zero, contradicting this bound for all sufficiently large m m m . The exponential upper envelope is supplied by Theorem 5.2 . □
Dependence of Target-Parameterized Complexity
For a query of full encoding length ℓ \ell ℓ , take k = ∣ x ∣ k = |x| k = ∣ x ∣ as the parameter. A language is fixed-parameter tractable in k k k if one algorithm decides it in time f ( k ) ℓ c f(k)\ell^c f ( k ) ℓ c , for a computable function f f f and a constant c c c independent of the query and parameter. The next corollary compares two machines whose full connectivity languages are both PSPACE-complete; they differ in how the running time can depend on this parameter.
Corollary 5.7 (Target-length complexity depends on the machine; previewed in Theorem 1.4 ). There are two machines satisfying all three reference conditions whose full connectivity languages are PSPACE-complete. For the machine of Theorem 5.4 , connectivity is fixed-parameter tractable in target length, with time 2 2 O ( k ) ℓ O ( 1 ) 2^{2^{O(k)}}\ell^{O(1)} 2 2 O ( k ) ℓ O ( 1 ) . The rigid reference machine U U U has a PSPACE-complete restriction at target 00 00 00 . Consequently, if P ≠ P S P A C E P \ne\mathrm{PSPACE} P = PSPACE , its connectivity language is not fixed-parameter tractable in target length.
Proof. The first machine has the uniform algorithm in Corollary 5.3 , whose polynomial exponent is independent of x x x , and PSPACE-completeness of the full language by Theorem 5.4 . The rigid reference satisfies all three properties by Definition 3.5 . Corollary 3.24, at the fixed two-bit target y = 00 y = 00 y = 00 , gives that Conn 00 ( U ) \operatorname{Conn}_{00}(U) Conn 00 ( U ) is PSPACE-complete, and Proposition 3.22 gives membership of the full language. If an algorithm for U U U had time f ( k ) ℓ c f(k)\ell^c f ( k ) ℓ c , its restriction to k = 2 k = 2 k = 2 would run in polynomial time, making a PSPACE-complete language polynomial-time decidable. This would imply P = P S P A C E P = \mathrm{PSPACE} P = PSPACE . □
For the first machine, any fixed-parameter algorithm must depend more than single-exponentially on the target length, unless P = P S P A C E P = \mathrm{PSPACE} P = PSPACE . This holds because the reduction of Theorem 5.4 uses targets of logarithmic length.
Corollary 5.8 (No single-exponential target dependence; previewed in Theorem 1.4 ). If P ≠ P S P A C E P \ne\mathrm{PSPACE} P = PSPACE , the machine of Theorem 5.4 admits no algorithm with running time 2 O ( ∣ x ∣ ) ℓ O ( 1 ) 2^{O(|x|)}\ell^{O(1)} 2 O ( ∣ x ∣ ) ℓ O ( 1 ) on its full connectivity language Conn ( V ) \operatorname{Conn}(V) Conn ( V ) .
Proof. For a source input of length L L L , the reduction in Theorem 5.4 produces a query of length polynomial in L + 2 L + 2 L + 2 and a target of length at most c 0 log 2 ( L + 2 ) c_0\log_2(L + 2) c 0 log 2 ( L + 2 ) , for one fixed constant c 0 c_0 c 0 . An algorithm with running time at most 2 a ∣ x ∣ + b ℓ c 2^{a|x|+b}\ell^c 2 a ∣ x ∣ + b ℓ c , for fixed constants a , b , c a,b,c a , b , c , would therefore decide the PSPACE-complete source in time polynomial in L + 2 L + 2 L + 2 . This implies P = P S P A C E P = \mathrm{PSPACE} P = PSPACE , proving the conditional exclusion. It is not a matching double-exponential running-time lower bound. □
Targets with Connected Fibers
The preceding results distinguish connectivity of a whole fiber from the complexity of deciding connectivity between two of its vertices. We now ask which targets have connected fibers at every length and every native deadline. The quantification over deadlines is essential: a disconnected fiber at one deadline is already a counterexample, even if later programs join its components.
For a machine V V V define
G ( V ) = { x ∈ { 0 , 1 } ∗ : F V ( x , N , t ) is empty or connected for every N , t ∈ N } . G(V)=\{x\in\{0,1\}^*: \mathcal{F}_V(x,N,t)\text{ is empty or connected for every }N,t\in\mathbb{N}\}. G ( V ) = { x ∈ { 0 , 1 } ∗ : F V ( x , N , t ) is empty or connected for every N , t ∈ N } .
Here F V \mathcal{F}_V F V includes every length-N N N program, and N \mathbb{N} N includes zero. We call the elements of G ( V ) G(V) G ( V ) the globally connected targets of V V V , shortened in this section to connected targets . We first prescribe finite sets and then prove effective restrictions on arbitrary G ( V ) G(V) G ( V ) .
Prescribing Finitely Many Easy Targets
We call a target x x x easy for V V V when its fixed-target connectivity problem Conn x ( V ) \operatorname{Conn}_x(V) Conn x ( V ) lies in P. For a fixed finite set S S S of targets, each target of S S S gets a block of programs, called hubs, that print it whatever their remaining bits are, and these hubs halt before any program that simulates a base machine A A A . For every other target, the fiber at long enough lengths and late enough deadlines is an exact copy of a fiber of A A A at a shorter length and a shifted deadline.
Lemma 6.1 (Completion on a finite set of targets). Let A A A be an efficient onto program-only machine with the simulation property, and let S = { x 1 , … , x K } S=\{x_1,\ldots,x_K\} S = { x 1 , … , x K } be a fixed finite set of distinct strings. There is an efficient onto program-only machine V S V_S V S with the simulation property and constants r ≥ 1 r\ge1 r ≥ 1 , B ≥ 0 B\ge0 B ≥ 0 , L ≥ 1 L\ge1 L ≥ 1 , having the following properties. For every x ∈ S x\in S x ∈ S , every fiber F V S ( x , N , t ) \mathcal{F}_{V_S}(x,N,t) F V S ( x , N , t ) is empty or connected, and Conn x ( V S ) ∈ P \operatorname{Conn}_x(V_S)\in\mathrm{P} Conn x ( V S ) ∈ P . For x ∉ S x\notin S x ∈ / S , the fiber is empty when N < r N<r N < r or t < B t<B t < B . At every other length and deadline, deleting the first r r r bits is an isomorphism from its entire fiber onto the fiber of A A A at length N − r N-r N − r and deadline
⌊ t − B L ⌋ . \left\lfloor\frac{t-B}{L}\right\rfloor. ⌊ L t − B ⌋ . All constants and the machine may depend on A , S A,S A , S . The finite description of V S V_S V S and the constants r , B , L r,B,L r , B , L are computable from the finite description of A A A and the list of the strings of S S S .
Proof. Put r = max ( 1 , K ) r=\max(1,K) r = max ( 1 , K ) , and let e i e_i e i be the length-r r r word with a single one in position i i i , for 1 ≤ i ≤ K 1\le i\le K 1 ≤ i ≤ K . Write every program of length at least r r r as a w aw a w with ∣ a ∣ = r |a|=r ∣ a ∣ = r , and call a a a its control header. The machine first reads exactly the r r r bits of the control header; if a blank is encountered earlier, it enters the distinguished halting state. At control 0 r 0^r 0 r , run A A A on the unchanged suffix w w w . The control e i e_i e i instead prints x i x_i x i independently of w w w . Every other control enters the distinguished halting state. For K = 0 K=0 K = 0 there are no e i e_i e i controls, and only control 0 r 0^r 0 r runs the base machine. We call the programs with control 0 r 0^r 0 r base programs, and the programs with control e i e_i e i the hubs of x i x_i x i .
We specify the exact halting times, since a hub must be present as soon as a base vertex is admitted; the hub halting time H H H chosen next is internal to this proof. Parsing the control header takes a fixed number of transitions on every program with at least r r r bits. A hub routine writes its fixed string, then waits until one common normal-halting time H H H . Choose H H H large enough for all these finite routines, including one that prints the empty string. If K = 0 K=0 K = 0 , choose any fixed parsing-compatible H H H . Choose the base setup and padding time B B B strictly larger than H H H .
When V S V_S V S runs A A A on the suffix w w w , its program head treats physical cell r + 1 r+1 r + 1 as the first cell of A A A ’s program. That simulated first cell needs its own left boundary. After the control parse, the physical program head is at cell r + 1 r+1 r + 1 , which represents cell one of A A A ’s program.
A new work tape has a sentinel at its first cell, and its head follows the simulated program head. At the sentinel, a requested left move keeps both heads fixed, exactly as Definition 2.3 requires at the virtual first cell. Away from it, both heads move together. The physical program head can therefore never enter the control prefix. Disjoint additional tapes handle the parse; the inherited tapes and hardwired data of A A A have their declared initial contents and head positions when simulation starts. The sentinel and this fixed setup are included in B B B . This also simulates the empty suffix at N = r N=r N = r , whose first virtual cell is blank.
Because A A A is fixed, compile its transition table into fixed-length blocks of L L L native transitions, padding every transition case to the same positive integer L L L . Perform its output write within the corresponding block and keep the output head stationary on the other transitions of that block. No final variable-length copy is used. A normal halt of A ( w ) A(w) A ( w ) after exactly T T T transitions thus becomes a normal halt of V S ( 0 r w ) V_S(0^r w) V S ( 0 r w ) after exactly B + L T B+LT B + L T transitions. An initially normal-halting machine is handled at B B B , covering T = 0 T=0 T = 0 . Distinguished halts remain distinguished, and divergence remains divergence. This fixes the entire deadline behavior, not merely an upper bound. If ⟨ M ⟩ A \langle M\rangle_A ⟨ M ⟩ A is the code of M M M for A A A , use 0 r ⟨ M ⟩ A 0^r\langle M\rangle_A 0 r ⟨ M ⟩ A for V S V_S V S . It runs every raw suffix z z z as A ( ⟨ M ⟩ A z ) A(\langle M\rangle_Az) A (⟨ M ⟩ A z ) , with no delimiter restriction. Its length and construction time are polynomial in the ambient code of M M M , since r r r is fixed with S S S . If q A q_A q A is the uniform simulation bound of A A A and q ^ A \widehat{q}_A q A is a nondecreasing polynomial majorant of it, then V S V_S V S halts within
B + L q ^ A ( T , ∣ z ∣ , ∣ 0 r ⟨ M ⟩ A ∣ ) , B+L\widehat{q}_A(T,|z|,|0^r\langle M\rangle_A|), B + L q A ( T , ∣ z ∣ , ∣ 0 r ⟨ M ⟩ A ∣ ) ,
since ∣ ⟨ M ⟩ A ∣ ≤ ∣ 0 r ⟨ M ⟩ A ∣ |\langle M\rangle_A|\leq|0^r\langle M\rangle_A| ∣ ⟨ M ⟩ A ∣ ≤ ∣ 0 r ⟨ M ⟩ A ∣ . Thus one polynomial works for every source machine and suffix. Onto-ness follows from the base branch, and efficiency from the fixed native model.
Fix x i ∈ S x_i\in S x i ∈ S and N ≥ r N\geq r N ≥ r . At deadlines below H H H the fiber is empty. At H ≤ t < B H\leq t<B H ≤ t < B it is exactly the cube { e i w : ∣ w ∣ = N − r } \{e_iw:|w|=N-r\} { e i w : ∣ w ∣ = N − r } . From deadline B B B onward it contains that cube and the base vertices 0 r w 0^rw 0 r w whose computations have already produced x i x_i x i and normally halted. Every such base vertex has the adjacent hub vertex e i w e_iw e i w , because the controls differ in one bit. The cube is connected by flipping its free suffix bits one at a time. Consequently the whole fiber is connected whenever nonempty, including its zero-dimensional cube when N = r N=r N = r . No hub of another target prints x i x_i x i , because the listed targets are distinct, and every control other than 0 r 0^r 0 r and the e j e_j e j rejects. For N < r N<r N < r every program rejects. An arbitrary query for this target is therefore decided by syntax, equal-length and endpoint-feasibility tests, which run in time polynomial in the query length, since the deadline is given in unary.
For a target outside S S S , no hub is feasible. At t ≥ B t\geq B t ≥ B and N ≥ r N\geq r N ≥ r , the exact clock gives the full vertex set
{ 0 r w : ∣ w ∣ = N − r , A ( w ) = x normally by ⌊ ( t − B ) / L ⌋ } . \{0^rw:|w|=N-r,A(w)=x\text{ normally by }\lfloor(t-B)/L\rfloor\}. { 0 r w : ∣ w ∣ = N − r , A ( w ) = x normally by ⌊( t − B ) / L ⌋} .
Every feasible program has that control, so no path can change it. Deleting it preserves and reflects every one-bit edge, giving the stated full-fiber isomorphism. The earlier deadlines and shorter lengths admit no vertex.
Computing the construction. These finite choices are computable from the given finite description of A A A and the explicit list of target strings. Supply that list by its cardinality K K K and the lengths and bits of its K K K strings, also allowing K = 0 K=0 K = 0 . Parse and copy A A A ’s finite control, declared work tapes, initial data and layout, and compute r = max ( 1 , K ) r=\max(1,K) r = max ( 1 , K ) . Give the inherited simulation states disjoint names from the control-parse and padding states, so returning to an old initial state cannot restart preparation. The control tests, suffix-origin sentinel and fixed setup use finitely many prescribed states and transitions.
Synthesize the fixed printers and count their finite execution lengths, including the control parse; padding their maximum gives a computable common H H H . For K = 0 K=0 K = 0 , choose a parsing-compatible H H H directly, since there are no printers. Enumerate the finitely many transition cases of A A A and synthesize the corresponding finite native blocks, including their boundary tests and output actions. Their maximum length gives a computable positive L L L , and padding makes all blocks have that length. A normal or distinguished halt is kept as an internal control flag during that padding; the actual halting state is entered only at the end of its block. The setup routine has a computable finite length as well. Choose an integer B B B exceeding both that length and H H H , and pad the setup to exactly B B B transitions.
These syntactic operations produce the finite description of V S V_S V S and the constants r , H , B , L r,H,B,L r , H , B , L , while retaining the exact clock B + L T B+LT B + L T . They do not require running A A A to discover whether it is onto or extracting its code map or global simulation polynomial. Those properties are used only as the stated promise when verifying the constructed machine’s properties. The conclusion is computability of this constructor; no polynomial bound on its running time is asserted.
The exceptional finite set may be prescribed while every other fixed target remains hard. Hardness outside S S S comes from the rigidity of the reference machine U U U through Corollary 3.24, not from the simulation property alone.
Theorem 6.2 (Prescribing finitely many easy targets; previewed in Theorem 1.5 ). For every fixed finite set S ⊆ { 0 , 1 } ∗ S\subseteq\{0,1\}^* S ⊆ { 0 , 1 } ∗ , there is a machine V V V satisfying the three reference conditions of Definitions 2.5 to 2.7 such that:
for every x ∈ S x\in S x ∈ S , every fiber F V ( x , N , t ) \mathcal{F}_V(x,N,t) F V ( x , N , t ) is empty or connected and Conn x ( V ) ∈ P \operatorname{Conn}_x(V)\in\mathrm{P} Conn x ( V ) ∈ P ;
for every fixed target y y y outside S S S , the language Conn y ( V ) \operatorname{Conn}_y(V) Conn y ( V ) is PSPACE-complete.
In particular, Conn ( V ) \operatorname{Conn}(V) Conn ( V ) is PSPACE-complete. If P ≠ P S P A C E \mathrm{P}\ne\mathrm{PSPACE} P = PSPACE , the set of targets whose restrictions are in P \mathrm{P} P is exactly S S S . The encodings witnessing the simulation and interpretation properties belong to the constructed machine and are not required to be the fixed ambient encoding.
Proof. By Corollary 3.24, Conn y ( U ) \operatorname{Conn}_y(U) Conn y ( U ) is PSPACE-complete for every fixed target y y y , including ε \varepsilon ε . Use the program-only realization of U U U , which runs U U U with its auxiliary tape fixed empty. Its rules always read blank on that tape, so they can be compiled without changing any transition count. Apply Lemma 6.1 with this base machine A = U A=U A = U and the prescribed S S S .
Fix y ∉ S y \notin S y ∈ / S . For a source query in Conn y ( U ) \operatorname{Conn}_y(U) Conn y ( U ) , first send malformed encodings or a target field different from y y y to a fixed unequal-length no-query at target y y y . Otherwise prefix both endpoints by 0 r 0^r 0 r and replace the deadline t t t by B + L t B+Lt B + L t . The lemma gives an exact full-fiber isomorphism at that deadline, so the reduction preserves both answers. Its output length is polynomial, including the unary deadline, because B , L , r B,L,r B , L , r are fixed. The corresponding restriction of V S V_S V S is therefore PSPACE-hard and belongs to PSPACE by Proposition 3.22 . The same lemma gives the connected fibers and polynomial-time restrictions for the targets in S S S .
Finally apply Lemma 3.25 to V S V_S V S . It is efficient and onto and has the code map just established, so every hypothesis of that lemma holds. Its completion retains that code map and every unconditional halting predicate at its original physical deadline, and adds interpretation with the required polynomial encoding and overhead. Hence all three reference conditions and all target conclusions hold for the same completed machine V V V . Some target lies outside the finite set S S S , and its PSPACE-complete restriction makes Conn ( V ) \operatorname{Conn}(V) Conn ( V ) PSPACE-hard; membership remains Proposition 3.22 . If P ≠ P S P A C E \mathrm{P} \ne\mathrm{PSPACE} P = PSPACE , none of the complete outside restrictions belongs to P, while all restrictions inside S S S do. This proves the final exact-set assertion.
The theorem has the quantifier order: for every fixed finite S S S there is a machine V V V . It does not give one machine with all target restrictions easy, nor a machine whose full connectivity language is not PSPACE-hard. Whether every machine satisfying the three reference conditions has a PSPACE-complete full connectivity language therefore remains open (Open Problem 1).
Exact Finite Sets of Connected Targets
The construction of Lemma 6.1 also controls G ( V ) G(V) G ( V ) exactly: every finite set of targets is the set of globally connected targets of some machine satisfying the three reference conditions. The finite-hub construction realizes each such set exactly, without assuming a separation between complexity classes.
Theorem 6.3 (Exact finite connected-target sets; previewed in Theorem 1.5 ). For every fixed finite S ⊆ { 0 , 1 } ∗ S \subseteq\{0,1\}^{*} S ⊆ { 0 , 1 } ∗ there is a machine V V V satisfying the three reference conditions of Definitions 2.5 to 2.7 with G ( V ) = S G(V)=S G ( V ) = S . The assertion includes S = ∅ S=\varnothing S = ∅ and sets containing ε \varepsilon ε .
Proof. First fix a target y y y and construct a native machine E y E_y E y which normally outputs y y y exactly on the inputs 00 00 00 and 11 11 11 , and diverges on every other input. An exact length test reads the blank after the second bit. Write h y = ⟨ E y ⟩ h_y=\langle E_y\rangle h y = ⟨ E y ⟩ and choose a finite native deadline D y D_y D y admitting both successful U U U -computations. The programs h y 00 , h y 11 h_y00,h_y11 h y 00 , h y 11 have equal length and Hamming distance two.
Each is isolated in the entire target-y y y fiber of U U U at length ∣ h y ∣ + 2 |h_y|+2 ∣ h y ∣ + 2 and deadline D y D_y D y . A suffix flip gives 01 01 01 or 10 10 10 , which diverges. A flip inside h y h_y h y gives a program with no codeword prefix of any length by Proposition 3.3, so the unconditional reference machine diverges on it. These exhaust every neighbor. Other programs elsewhere in the cube cannot connect either isolated vertex. This also holds for y = ε y=\varepsilon y = ε , since divergence produces no normal empty output.
Apply Lemma 6.1 to the program-only realization of U U U and to S S S , with constants r , B , L r,B,L r , B , L . Every target in S S S then belongs to G ( V S ) G(V_S) G ( V S ) .
For each y ∉ S y\notin S y ∈ / S , at length r + ∣ h y ∣ + 2 r+|h_y|+2 r + ∣ h y ∣ + 2 and deadline B + L D y B+LD_y B + L D y , the lemma identifies the entire target-y y y fiber with the disconnected reference fiber just constructed. Hence y ∉ G ( V S ) y\notin G(V_S) y ∈ / G ( V S ) , and G ( V S ) = S G(V_S)=S G ( V S ) = S .
Finally apply Lemma 3.25 . It preserves every unconditional fiber at its actual native deadline and retains adjunction, so the completed machine satisfies all three reference conditions and has the same set G G G .
Effective Restrictions on Connected Targets
A set is computably enumerable , abbreviated c.e., if an algorithm lists its elements, allowing repetitions; it is co-c.e. if its complement is c.e. Fix a standard effective indexing ( W e ) e ∈ N (W_e)_{e\in\mathbb{N}} ( W e ) e ∈ N of c.e. sets of binary strings. An infinite set A A A is effectively immune here if a total computable function b b b satisfies ∣ W e ∣ ≤ b ( e ) |W_e|\le b(e) ∣ W e ∣ ≤ b ( e ) whenever W e ⊆ A W_e\subseteq A W e ⊆ A . The finite-subset bound below holds whether or not G ( V ) G(V) G ( V ) is infinite.
Theorem 6.4 (Packing a c.e. family of connected targets; previewed in Theorem 1.5). Let V V V have the simulation property . There is a total computable map e ↦ h e e \mapsto h_e e ↦ h e to codes for V V V , with k e = ∣ h e ∣ k_e=|h_e| k e = ∣ h e ∣ , such that, if W e ⊆ G ( V ) W_e \subseteq G(V) W e ⊆ G ( V ) , then for every integer n ≥ 2 n \ge2 n ≥ 2 ,
( n + 1 ) min { ∣ W e ∣ , 2 n − 1 } ≤ ( 2 k e − 1 ) 2 n . (n+1)\min\{|W_e|,2^{n-1}\} \le(2^{k_e}-1)2^n. ( n + 1 ) min { ∣ W e ∣ , 2 n − 1 } ≤ ( 2 k e − 1 ) 2 n . The minimum is understood as 2 n − 1 2^{n-1} 2 n − 1 when W e W_e W e is infinite.
Proof. From e e e construct one machine M e M_e M e . On a nonempty input a b ab ab , with first bit a a a , let i i i be the binary value of b b b when a = 0 a=0 a = 0 , and of b ˉ \bar b b ˉ when a = 1 a=1 a = 1 . Suppress repeated outputs in the enumeration of W e W_e W e and wait for its ( i + 1 ) (i+1) ( i + 1 ) -st distinct element. Print that element and halt if it appears, and diverge otherwise. On the empty input diverge. This is one effectively constructible machine for all input lengths. The computable code map gives h e = ⟨ M e ⟩ V h_e=\langle M_e\rangle_V h e = ⟨ M e ⟩ V , independent of n n n .
Fix n ≥ 2 n \ge2 n ≥ 2 and write L = min { ∣ W e ∣ , 2 n − 1 } L=\min\{|W_e|,2^{n-1}\} L = min { ∣ W e ∣ , 2 n − 1 } . Call a rank i i i available if W e W_e W e has at least i + 1 i+1 i + 1 distinct elements. For each available rank i < 2 n − 1 i<2^{n-1} i < 2 n − 1 , let s i s_i s i be the ( i + 1 ) (i+1) ( i + 1 ) -st distinct element of W e W_e W e and b i b_i b i the ( n − 1 ) (n-1) ( n − 1 ) -bit representation of i i i . Exactly two eventual target-s i s_i s i programs lie in the cylinder h e { 0 , 1 } n h_e\{0,1\}^n h e { 0 , 1 } n : they are h e 0 b i h_e0b_i h e 0 b i and h e 1 b ˉ i h_e1\bar b_i h e 1 b ˉ i . A program of the cylinder whose suffix encodes an unavailable rank diverges. If L = 0 L=0 L = 0 , the asserted bound is immediate. Otherwise there are finitely many successful endpoint computations, so their actual native halting times have a finite maximum T T T . No algorithm for computing T T T , or deciding which ranks are available, is needed.
Assume W e ⊆ G ( V ) W_e \subseteq G(V) W e ⊆ G ( V ) . For each available rank i < 2 n − 1 i<2^{n-1} i < 2 n − 1 , the fiber F V ( s i , k e + n , T ) \mathcal{F}_V(s_i,k_e+n,T) F V ( s i , k e + n , T ) contains both endpoints and is connected, since s i ∈ G ( V ) s_i \in G(V) s i ∈ G ( V ) . Choose a simple path between its two endpoints. Since those endpoints are its only vertices in the cylinder, all internal vertices lie outside it. Their suffixes are complements, so at least n n n suffix flips occur. Leaving and returning to a nonempty code requires two more flips, hence at least n + 1 n+1 n + 1 internal outside vertices. If k e = 0 k_e=0 k e = 0 , no outside route exists and L > 0 L>0 L > 0 is impossible. Different outputs’ paths are disjoint. Counting the ( 2 k e − 1 ) 2 n (2^{k_e}-1)2^n ( 2 k e − 1 ) 2 n outside programs therefore gives the inequality in every case. □
The bound becomes finite and effective after choosing one suffix length as a function of the code. No efficiency bound is asserted for the resulting computation.
Corollary 6.5 (A computable bound on c.e. subsets; previewed in Theorem 1.5). Put
a ( k ) = max { 2 , 2 k + 1 − 2 } , B ( k ) = ⌊ ( 2 k − 1 ) 2 a ( k ) a ( k ) + 1 ⌋ . a(k)=\max\{2,2^{k+1}-2\}, \qquad B(k)=\left\lfloor\frac{(2^k-1)2^{a(k)}}{a(k)+1}\right\rfloor. a ( k ) = max { 2 , 2 k + 1 − 2 } , B ( k ) = ⌊ a ( k ) + 1 ( 2 k − 1 ) 2 a ( k ) ⌋ . For the codes in Theorem 6.4, the function e ↦ B ( k e ) e \mapsto B(k_e) e ↦ B ( k e ) is total computable, and W e ⊆ G ( V ) W_e \subseteq G(V) W e ⊆ G ( V ) implies ∣ W e ∣ ≤ B ( k e ) |W_e| \le B(k_e) ∣ W e ∣ ≤ B ( k e ) . In particular, G ( V ) G(V) G ( V ) contains no infinite c.e. subset.
Proof. For every k ≥ 0 k \ge0 k ≥ 0 we have a ( k ) + 1 > 2 ( 2 k − 1 ) a(k)+1>2(2^k-1) a ( k ) + 1 > 2 ( 2 k − 1 ) . Therefore
B ( k ) < 2 a ( k ) − 1 . B(k)<2^{a(k)-1}. B ( k ) < 2 a ( k ) − 1 . Apply Theorem 6.4 at n = a ( k e ) n=a(k_e) n = a ( k e ) . It yields
min { ∣ W e ∣ , 2 a ( k e ) − 1 } ≤ B ( k e ) < 2 a ( k e ) − 1 . \min\{|W_e|,2^{a(k_e)-1}\} \le B(k_e) < 2^{a(k_e)-1}. min { ∣ W e ∣ , 2 a ( k e ) − 1 } ≤ B ( k e ) < 2 a ( k e ) − 1 . Thus the minimum cannot be saturated; W e W_e W e is finite and its cardinality is at most B ( k e ) B(k_e) B ( k e ) . The conclusion includes k e = 0 k_e=0 k e = 0 , for which B ( k e ) = 0 B(k_e)=0 B ( k e ) = 0 . The machine constructor, code map, code length and displayed integer operations are all computable, proving total computability of the bound. □
Globally connected targets have zero density even when sampled in an arbitrary computable order, rather than by output length.
Theorem 6.6 (Zero density along computable lists; previewed in Theorem 1.5). Let V V V have the simulation property and let ( s i ) i ∈ N (s_i)_{i\in\mathbb{N}} ( s i ) i ∈ N be any total computable injective sequence of binary strings. Put C ( q ) = ∣ { i < q : s i ∈ G ( V ) } ∣ C(q)=|\{i<q:s_i\in G(V)\}| C ( q ) = ∣ { i < q : s i ∈ G ( V )} ∣ . There is a constant k k k , namely the length of the code for V V V of a machine built from the list, such that, whenever n ≥ 2 n \ge2 n ≥ 2 and 2 n − 2 < q ≤ 2 n − 1 2^{n-2}<q\le2^{n-1} 2 n − 2 < q ≤ 2 n − 1 ,
C ( q ) q ≤ 4 ( 2 k − 1 ) n + 1 . \frac{C(q)}{q}\le\frac{4(2^k-1)}{n+1}. q C ( q ) ≤ n + 1 4 ( 2 k − 1 ) .
Consequently C ( q ) / q → 0 C(q)/q \to0 C ( q ) / q → 0 as q → ∞ q \to\infty q → ∞ .
Proof. Use the machine of the proof of Theorem 6.4 , except that the program of rank i i i prints s i s_i s i , computed by the list algorithm, instead of the ( i + 1 ) (i+1) ( i + 1 ) -st distinct element of W e W_e W e . Its code has one fixed length k k k across all n n n . At suffix length n n n the cylinder holds the targets s i s_i s i with i < 2 n − 1 i < 2^{n-1} i < 2 n − 1 , and all their computations halt, since the list is total. Injectivity gives exactly two cylinder programs per such target. Choose paths only for those targets s i s_i s i that belong to G ( V ) G(V) G ( V ) , at a common finite deadline admitting all endpoints. The same outside-cylinder count gives
( n + 1 ) C ( 2 n − 1 ) ≤ ( 2 k − 1 ) 2 n (n+1)C(2^{n-1}) \le(2^k-1)2^n ( n + 1 ) C ( 2 n − 1 ) ≤ ( 2 k − 1 ) 2 n
For 2 n − 2 < q ≤ 2 n − 1 2^{n-2}<q\le2^{n-1} 2 n − 2 < q ≤ 2 n − 1 , monotonicity gives C ( q ) ≤ C ( 2 n − 1 ) C(q)\le C(2^{n-1}) C ( q ) ≤ C ( 2 n − 1 ) and 2 n < 4 q 2^n<4q 2 n < 4 q . Combining these inequalities proves the bound. Every integer q ≥ 2 q\ge2 q ≥ 2 belongs to one such interval, and its corresponding n n n tends to infinity with q q q . The right-hand side therefore tends to zero. □
For a set A ⊆ N A\subseteq\mathbb{N} A ⊆ N , asymptotic density zero means ∣ A ∩ { 0 , … , q − 1 } ∣ / q → 0 |A\cap\{0,\ldots,q-1\}|/q\to0 ∣ A ∩ { 0 , … , q − 1 } ∣/ q → 0 . A computable permutation of N \mathbb{N} N is a total computable bijection π : N → N \pi:\mathbb{N}\to\mathbb{N} π : N → N . The set A A A has intrinsic density zero if π ( A ) \pi(A) π ( A ) has asymptotic density zero for every such permutation.
We recall the injective-sampling characterization of intrinsic density zero.
Fact 6.7 (Computable injective sampling; [3 Corollary 4.3 of the accepted preprint] ). A set A ⊆ N A\subseteq\mathbb{N} A ⊆ N has intrinsic density zero if and only if, for every total computable injection f : N → N f:\mathbb{N}\to\mathbb{N} f : N → N ,
∣ { i < q : f ( i ) ∈ A } ∣ q → 0 ( q → ∞ ) . \frac{|\{i<q:f(i)\in A\}|}{q}\to0\qquad(q\to\infty). q ∣ { i < q : f ( i ) ∈ A } ∣ → 0 ( q → ∞ ) .
For a computable bijection β : N → { 0 , 1 } ∗ \beta:\mathbb{N}\to\{0,1\}^* β : N → { 0 , 1 } ∗ , we say that G ( V ) G(V) G ( V ) has intrinsic density zero under β \beta β when β − 1 ( G ( V ) ) \beta^{-1}(G(V)) β − 1 ( G ( V )) does.
Corollary 6.8 (Intrinsic density zero; previewed in Theorem 1.5 ). Let V V V have the simulation property. For every computable bijection β : N → { 0 , 1 } ∗ \beta:\mathbb{N}\to\{0,1\}^* β : N → { 0 , 1 } ∗ , the set β − 1 ( G ( V ) ) ⊆ N \beta^{-1}(G(V))\subseteq\mathbb{N} β − 1 ( G ( V )) ⊆ N has intrinsic density zero.
Proof. Fix β \beta β , put A = β − 1 ( G ( V ) ) A=\beta^{-1}(G(V)) A = β − 1 ( G ( V )) , and let π : N → N \pi:\mathbb{N}\to\mathbb{N} π : N → N be any computable permutation. Its inverse is computable: on input i i i , search j = 0 , 1 , … j=0,1,\ldots j = 0 , 1 , … until π ( j ) = i \pi(j)=i π ( j ) = i ; totality makes every test terminate, and bijectivity guarantees exactly one successful value. Thus s i = β ( π − 1 ( i ) ) s_i=\beta(\pi^{-1}(i)) s i = β ( π − 1 ( i )) defines a total computable sequence of binary strings, and it is injective because π − 1 \pi^{-1} π − 1 and β \beta β are injective. For every j ∈ N j\in\mathbb{N} j ∈ N we have j ∈ A j\in A j ∈ A exactly when β ( j ) ∈ G ( V ) \beta(j)\in G(V) β ( j ) ∈ G ( V ) . Hence, for every q ≥ 1 q\ge1 q ≥ 1 ,
∣ π ( A ) ∩ { 0 , … , q − 1 } ∣ = ∣ { i < q : π − 1 ( i ) ∈ A } ∣ = ∣ { i < q : s i ∈ G ( V ) } ∣ , |\pi(A)\cap\{0,\ldots,q-1\}|=|\{i<q:\pi^{-1}(i)\in A\}|=|\{i<q:s_i\in G(V)\}|, ∣ π ( A ) ∩ { 0 , … , q − 1 } ∣ = ∣ { i < q : π − 1 ( i ) ∈ A } ∣ = ∣ { i < q : s i ∈ G ( V )} ∣ ,
where the first equality holds because i ∈ π ( A ) i\in\pi(A) i ∈ π ( A ) exactly when π − 1 ( i ) ∈ A \pi^{-1}(i)\in A π − 1 ( i ) ∈ A . By Theorem 6.6 , applied to the sequence ( s i ) (s_i) ( s i ) , the right-hand side divided by q q q tends to zero as q → ∞ q\to\infty q → ∞ . So π ( A ) \pi(A) π ( A ) has asymptotic density zero. Since π \pi π was an arbitrary computable permutation, A A A has intrinsic density zero. □
The same conclusion follows from Fact 6.7: for a total computable injection f : N → N f:\mathbb{N}\to\mathbb{N} f : N → N , the sequence s i = β ( f ( i ) ) s_i=\beta(f(i)) s i = β ( f ( i )) is total computable and injective, and f ( i ) ∈ β − 1 ( G ( V ) ) f(i)\in\beta^{-1}(G(V)) f ( i ) ∈ β − 1 ( G ( V )) exactly when s i ∈ G ( V ) s_i\in G(V) s i ∈ G ( V ) , so Theorem 6.6 gives the limit that the fact requires.
The rate in Theorem 6.6 , which depends on the code length k k k , is the quantitative conclusion of our packing argument. Effective immunity, concerning c.e. subset cardinalities, is a separate restriction; see [7 Definitions 1.1–1.2] for that established terminology.
A nonempty disconnected fiber is a finite witness that its target lies outside G ( V ) G(V) G ( V ) , and enumerating such witnesses shows that G ( V ) G(V) G ( V ) is co-c.e. Neither this argument nor the preceding packing proves that G ( V ) G(V) G ( V ) is infinite.
Proposition 6.9 (Computability of the connected-target set; previewed in Theorem 1.5 ). For every native machine V V V , the set G ( V ) G(V) G ( V ) is co-c.e. If V V V has the simulation property and G ( V ) G(V) G ( V ) is infinite, then G ( V ) G(V) G ( V ) is effectively immune.
Proof. For any triple ( x , N , t ) (x,N,t) ( x , N , t ) , simulate all finitely many length-N N N programs for t t t native transitions. Test which have normally halted with output x x x , excluding distinguished halts, and decide connectivity of their finite induced graph. These calculations decide whether this triple witnesses a nonempty disconnected fiber. Enumerating all triples and listing their witnessing targets enumerates exactly the complement of G ( V ) G(V) G ( V ) . The effective-immunity assertion, conditional on infinitude, is Corollary 6.5 with the computable bound e ↦ B ( k e ) e \mapsto B(k_e) e ↦ B ( k e ) .
References