Equivalence Between Coding and Complexity Lower Bounds
Abstract
The classical coding theorem in Kolmogorov complexity [27] states that if a string is sampled with probability by an algorithm with prefix-free domain, then . Motivated by applications in algorithms, average-case complexity, learning, and cryptography, computationally efficient variants of this result have been established for several recently introduced probabilistic measures of time-bounded Kolmogorov complexity, including [35] and [38]. However, establishing a coding theorem for classical (non-probabilistic) notions of time-bounded Kolmogorov complexity, such as complexity [28], remains a longstanding open problem despite its significance. In particular, the current status of coding results reveals a fundamental gap in our understanding of the role of randomness in data compression.
In this work, we make progress by establishing the first equivalence between coding for complexity and complexity lower bounds. Specifically, we show that weak coding for polynomial-time samplable distributions with bounds of the form
holds if and only if . Building on this equivalence, we show that similar characterizations hold for non-deterministic and zero-error variants of complexity, demonstrating that coding is equivalent to a corresponding complexity separation in each case. We complement these results by establishing additional equivalences involving the computational hardness of approximating time-bounded Kolmogorov complexity, along with an unconditional lower bound on the complexity of approximating zero-error time-bounded Kolmogorov complexity.
These results reveal novel connections between coding (the existence of succinct encodings), complexity separations (e.g., versus ), and meta-complexity (the complexity of deciding if a succinct encoding exists). In particular, our work provides a new perspective on frontier questions in complexity theory and explains why coding theorems exist for and but remain unknown for other measures of time-bounded Kolmogorov complexity. Finally, our results determine the minimal hardness assumptions sufficient for coding in different settings.
Keywords and phrases:
meta-complexity, lower bounds, Kolmogorov complexityCategory:
Track A: Algorithms, Complexity and GamesCopyright and License:
2012 ACM Subject Classification:
Theory of computation Computational complexity and cryptographyAcknowledgements:
We would like to thank Hanlin Ren for discussions related to the problem of showing that . We also thank the anonymous reviewers for their suggestions on improving the presentation and for their discussion of prior work.Funding:
This work received support from the UKRI Frontier Research Guarantee GrantEP/Y007999/1 and the Centre for Discrete Mathematics and its Applications (DIMAP) at the University of Warwick.
Editors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele PuppisSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl β Leibniz-Zentrum fΓΌr Informatik
1 Introduction
1.1 Context and Motivation
The investigation of data compression problems and their computational complexity has seen significant progress and impact in recent years. In particular, a sequence of works have established that different notions of compression and their associated computational problems can be used to capture major open problems from theoretical computer science. Some notable examples include the existence of one-way functions [30] and secure key-agreement protocols [6] in cryptography, and the efficient learnability of Boolean circuits [9] and the complexity of inductive inference [19] in computational learning theory. Strikingly, for several statements that do not refer to compression, the only known proof of the result seems to crucially rely on ideas and techniques from compression. Among them, we have the existence of learning speedups [41], a connection between worst-case and average-case complexity [13], and lower bounds on program size overhead in indistinguishability obfuscation [34].
A central tool in the study of compression is the coding theorem from Kolmogorov complexity [27]. It states that if a string is sampled with probability by an algorithm with prefix-free domain then . This general result connects randomized computations to compression and is widely considered to be one of the pillars of the theory of Kolmogorov complexity [26].
Due to the time-unbounded nature of Kolmogorov complexity, the coding theorem as stated above is typically not sufficient in algorithmic applications where the running time of algorithms is relevant. A few years ago, [35, 38] established a similar result for certain time-bounded variants of Kolmogorov complexity, namely, and complexities. Since then, these results have found several applications in cryptography [21, 31, 15, 18, 17, 33], algorithm design and hardness results [16, 37, 11], average-case complexity [38, 39], learning theory [12, 19, 10], and complexity lower bounds [14, 42, 32].
While unconditional, a drawback of these coding results is that and are probabilistic notions of time-bounded Kolmogorov complexity [36], meaning that randomness (and consequently uncertainty) is essential to the representation of the string . Establishing a coding theorem for classical (non-probabilistic) notions of time-bounded Kolmogorov complexity, such as Levinβs complexity [28], remains a longstanding open problem. It provides a natural computational setting where randomness offers a significant advantage over deterministic computations given our current knowledge of algorithms and complexity theory.
Let be a measure of (time-bounded) Kolmogorov complexity, such as , , etc. Let be a polynomial-time samplable distribution family. In order to put our results in perspective, we can informally classify coding theorems according to the amount of compression they achieve:
-
Weak Coding: , for a fixed but arbitrarily small .
-
Non-Trivial Coding: assuming, say, is generated with probability .
For non-probabilistic measures of time-bounded Kolmogorov complexity, conditional results are known:
There is a sharp contrast between the unconditional results established for probabilistic measures such as and , and the conditional results known for non-probabilistic measures such as , which require strong computational assumptions. Motivated by this discrepancy and with the goal of advancing our understanding of randomness in computation, we systematically investigate the prospects of achieving better coding results in time-bounded Kolmogorov complexity. From a technical perspective, we are interested in the following basic questions:
-
(1)
Is it possible to show non-trivial coding for without hardness assumptions?
-
(2)
If non-trivial coding for is difficult to achieve, can we at least improve the existing coding result for in order to achieve zero-error encodings?
-
(3)
Is there a connection between coding (i.e., the existence of succinct encodings) and the hardness of the corresponding meta-computational problem (i.e., the task of deciding if a succinct encoding exists)?
More broadly, we seek to deepen our knowledge of the role of randomness in data compression and identify when it can be eliminated without incurring significant overhead, under minimal hardness assumptions.
1.2 Results
Summary.
Our main contribution is to show that coding and complexity lower bounds are in fact equivalent. As a consequence of our results and techniques, we also establish a surprising equivalence between weak coding and non-trivial coding for different measures of time-bounded Kolmogorov complexity. Finally, we extend these equivalences by considering the computational complexity of estimating time-bounded Kolmogorov complexity. This extends our results and uncovers a novel connection between the existence of succinct encodings (coding) and the feasibility of deciding when a succinct encoding exists (meta-complexity).
Altogether, our results completely answer Questions 1-3 stated above. They also show that the validity of a key property (coding) of Kolmogorov complexity in the time-bounded setting captures several frontier questions in complexity theory. This exhibits another significant example of the relevance of compression to central questions in theoretical computer science.
Organization.
In Section 1.2.1, we establish the equivalence between coding and complexity lower bounds for complexity. Section 1.2.2 and Section 1.2.3 extend these results to the non-deterministic and zero-error variants, denoted by and , respectively. The computational complexity of estimating time-bounded Kolmogorov complexity is explored in Section 1.2.4.
1.2.1 Coding for Deterministic Time-Bounded Kolmogorov Complexity
Fix an efficient universal machine . Recall that for a string , we let
The notation denotes the output of on input string when it computes for at most steps. It is also possible to consider a relativized version of , namely , where we give the universal Turing machine oracle access to the set .
Recall that an ensemble of distributions supported over is polynomial-time samplable if there is a polynomial-time randomized algorithm whose output for is distributed according to . We denote the probability of an element over by .
Theorem 1.
The following statements are equivalent.
-
1.
.
-
2.
(Weak coding for .) For any and any polynomial-time samplable distribution family , there are infinitely many such that for all ,
-
3.
(Non-trivial coding for .) There exists a constant such that the following holds. Let be a polynomial-time samplable distribution family, where each is supported over , satisfying that there exists a sequence such that for every . Then for infinitely many , we have
As a consequence of this result, merely showing that admits non-trivial coding requires a hardness assumption. This addresses Question 1 from Section 1.1.
The equivalence stated in Theorem 1 significantly strengthens a result from [26, Chapter 5] showing that optimal coding for yields . In addition, our proof that Item 3 implies Item 1 is considerably simpler.
Theorem 1 also establishes an equivalence between weak coding and non-trivial coding for . On the other hand, we observe in Section 3.2 that near-optimal coding for implies the significantly stronger separation . Consequently, in contrast to the equivalence between non-trivial coding and weak coding, we are unlikely to obtain an equivalence between weak-coding and near-optimal coding given our current knowledge of complexity theory, unless we can show how to boost the separation to a much stronger result.111In fact, it seems plausible that near-optimal coding for is equivalent to lower bounds of the form . However, it is unclear to us how to establish this equivalence using our techniques, which are based on the theory of computational pseudorandomness.
We derive the following consequence from Theorem 1.
Corollary 2.
The following statements are equivalent:
-
1.
.
-
2.
For any sequence of strings where and for each , there exists infinitely many such that .
This corollary might be compared with [40, Theorem 5], which shows a partial equivalence between a strong derandomization assumption (roughly ) and a linear relationship between and (i.e. ). However, while [40, Theorem 5] has a gap between the two directions, our result establishes a full equivalence. Corollary 2 follows from Theorem 1 by noting that weak coding for Corollary 2 Item 2 non-trivial coding for ,222The only nontrivial (but standard) observation is that a universal time-bounded sampler can output any string of complexity with probability . This is used in the proof of the first implication. which implies that all statements are equivalent. It is unclear to us how to establish Corollary 2 using the techniques from [40, Theorem 5].
1.2.2 Coding for Non-Deterministic Time-Bounded Kolmogorov Complexity
Next, we establish an equivalence between coding with non-deterministic encodings and complexity lower bounds. We will need the following definition, which offers a natural extension of to the setting of non-deterministic computations. For a string , the non-deterministic time-bounded Kolmogorov complexity of is defined as
The above definition is equivalent to a βlocalβ notion of non-deterministic Kolmogorov complexity investigated in [2], which considers instead individual bits of (see [20, Appendix A]).
Theorem 3.
The following statements are equivalent.
-
1.
.
-
2.
(Weak coding for ) For any and any polynomial-time samplable distribution family , there are infinitely many such that for all ,
-
3.
(Non-trivial coding for .) There exists a constant such that the following holds. Let be a polynomial-time samplable distribution family, where each is supported over , satisfying that there exists a sequence such that for every . Then for infinitely many , we have
Moreover, the above holds if we replace with , and with .333Recall that denotes the extension of where the universal machine has access to a oracle.
As a consequence of this result, even if we could achieve non-trivial coding using non-deterministic encodings, a new complexity lower bound would follow. Indeed, Theorem 3 provides a new characterization of the versus problem as a statement about the existence of succinct encodings.
1.2.3 Coding for Zero-Error Time-Bounded Kolmogorov Complexity
Finally, we introduce a natural zero-error variant of complexity, which can also be seen as the restriction of [40] to errorless encodings. To the best of our knowledge, this definition has not been considered in previous work. For a string , we let
We observe that the existing near-optimal coding result for [35] yields zero-error encodings whenever the distribution is flat, i.e., when it is uniformly distributed over a set (see [20, Section 5.3]). In contrast, our next result indicates that it will be difficult to extend this zero-error coding theorem to all polynomial-time samplable distributions, even in the non-trivial coding regime.
Theorem 4.
The following statements are equivalent.
-
1.
.
-
2.
(Weak coding for ) For any and any polynomial-time samplable distribution family , there are infinitely many such that for all ,
-
3.
(Non-trivial coding for ) There exists a constant such that the following holds. Let be a polynomial-time samplable distribution family, where each is supported over , satisfying that there exists a sequence such that for every . Then for infinitely many , we have
Therefore, obtaining a zero-error version of existing coding results yields a new complexity separation. This addresses Question 2 from Section 1.1. Note that zero-error coding (Theorem 4) implies a stronger separation than non-deterministic coding (Theorem 3), which is expected since for every string (i.e., it is more challenging to achieve a zero-error encoding).
For the interested reader, in [20, Section 5.2] we investigate the possibility of achieving the stronger separation from coding for .
1.2.4 Complexity Separations and Meta-Complexity
Let be the following problem: Given , where and , decide whether . We also consider a parametrized βgapβ version of . Let be such that for every large . Define as the problem of deciding, given , whether or . When and , we might informally refer to the problem as -.
Similarly, we can define analogous problems for , , and , denoted as , , and , respectively.
We identify these problems with their corresponding (promise) languages in a natural way.
The problem - is complete for under non-uniform polynomial-time reductions [1]. A similar result also holds for -, i.e., - is complete for under non-uniform polynomial-time reductions [2]. These results imply that (resp. ) if and only if - (resp, -).
On the other hand, it was also established that - captures the hardness of with respect to uniform randomized algorithms. That is, if and only if - [1]. Here, we extend this result to the notion of .
Theorem 5.
The following are equivalent.
-
1.
.
-
2.
, for all .
Moreover, the above holds if we replace with , and with .444In fact, in all these results, the proof implicitly shows that the gap version of the problem is easy if and only if the non-gap version is easy. For instance, it is known that - if and only if . This will also be the case for the equivalences established in this paper.
For zero-error time bounded Kolmogorov complexity, we show that the problem of approximating is at least as hard as solving every problem in with respect to two-sided error randomized algorithms.
Theorem 6.
If for some , then .
Finally, we obtain an unconditional lower bound for approximating against zero-error randomized algorithms.
Theorem 7.
, for all .
1.3 Summary of Equivalences and Concluding Remarks
For convenience of the reader, we summarize the equivalences established in this paper in Table 1. Note that, from the perspective of derandomization, our results identify the minimal complexity-theoretic assumptions required to obtain coding for different measures of Kolmogorov complexity.
| Complexity Separation | Coding Theorem | Meta-Complexity |
|---|---|---|
| Weak/Non-Trivial Coding for | ||
| Weak/Non-Trivial Coding for | ||
| Weak/Non-Trivial Coding for | ||
| Weak/Non-Trivial Coding for |
As mentioned above, the equivalence between and - included in the first row of Table 1 was established in [1]. It is unclear to us how to prove that - from , which would provide the equivalence between all items in the last row of Table 1.
In contrast to the equivalences described in Table 1, for the two-sided error notion of time-bounded Kolmogorov complexity , we know unconditionally that:
Our work highlights that this is not a coincidence, i.e., these different statements are intimately related (see Figure 1). Moreover, our results provide an equivalence between coding (i.e., the existence of succinct encodings) and the hardness of the corresponding meta-computational problem (i.e., the task of deciding if a succinct encoding exists). In other words, they answer affirmatively Question 3 stated in Section 1.1.
Finally, our results show that any non-trivial compression (even with nondeterminism) would imply new separations in complexity theory and advance our understand of the power and limits of randomness in computation. It would be worthwhile to investigate whether this perspective can be combined with other techniques and employed as a concrete method for establishing new lower bounds.
1.4 Techniques
In this section, we explain the main ideas behind our proofs. We start off with our results for complexity. We then discuss the non-deterministic and zero-error settings, which require additional ideas and more elaborate proofs. In particular, the techniques we develop to establish our results in the context of zero-error Kolmogorov complexity might be of independent interest.
Equivalence Between Coding for and .
We first describe how to obtain from a non-trivial coding theorem for . Note that, by a standard padding argument, it suffices to show that , where and . Our goal is then to diagonalize against within . The first observation is that if we have a non-trivial coding theorem for , then the truth table of every language in on -bit inputs will have complexity strictly less than , for infinitely many . To see this, consider any language and a sampler that, on input , aims to output the -bit truth table of , where ,555For simplicity, letβs assume that is always a power of two. by running a probabilistic machine for computing on every input in . It is not hard to see that can be implemented to run in time and outputs with probability at least . Then, by invoking the non-trivial coding theorem for on this sampler, we get that for infinitely many , . Note that this holds for every . To diagonalize against all such , we define a language whose -bit truth table has complexity at least for all . Since one can compute an -bit string with complexity at least in time using exhaustive search, it follows that is computable in .
To derive a non-trivial coding theorem for from , the main idea is to use the hardness-vs-randomness framework to construct a pseudorandom generator (PRG). More specifically, by classical results in [23, 43], we obtain that if , then for every , there exists a PRG that takes a short seed of length , runs in time , and outputs a longer string of length that can fool any -time algorithm , for infinitely many . More formally:
Let be a polynomial-time samplable distribution family and be its sampler, i.e, is distributed according to for uniformly random , where is some constant. Let be the string for which we aim to find a short encoding. (For simplicity, letβs assume that each is supported on .) First observe that the weak coding theorem holds trivially on a given -bit string if , since in this case the desired encoding bound is larger than the length of the string. Therefore, we can assume without loss of generality that .
Consider the function , defined as if and only if . Note that . Using the pseudorandom property of (with chosen sufficiently large), it follows that:
This implies the existence of some such that . Given the descriptions of , , and the seed , can be recovered in time , yielding .
However, there is an issue in the above argument: the function depends on , making it non-uniform, while the PRG is designed to fool only uniform algorithms. The key observation is that the PRG obtained from [23, 43] possesses a slightly stronger property: it not only fools uniform algorithms but in our case also fools with probability at least over sampled from any -time samplable distribution (see Theorem 13). Since is assumed to be sampled from with probability at least , we conclude that can successfully fool in this case; otherwise, it would fail with probability at least , contradicting the pseudorandomness guarantee.
The above requires assuming that , while we only have . We address this with a standard win-win argument. If , then we are done. Otherwise, if , our assumption that implies . By the classical KarpβLipton result [25], which states that if , then , it follows that . Using a different hardness-vs-randomness framework [5] (see Theorem 12), which allows us to produce pseudorandomness using the hard truth table of a language in , this also yields an infinitely-often secure PRG with sub-polynomial seed length.666In fact, the PRG obtained in this case can even fool non-uniform algorithms. Such a PRG can be used to achieve weak coding for as described in previous paragraphs.
Equivalence Between Coding for and .
To obtain from a non-trivial coding theorem for , one might consider resembling the proof used in the previous case. However, for this approach to work, we would need to be able to construct an -bit string with high -complexity in time , which is not clear how to achieve (even non-deterministically).777Note that a naive algorithm for this task runs in time at least . In other words, we need to consider each candidate nondeterministic program running in time at most , and enumerating over all choices of the nondeterministic string to check that the program is suitable takes doubly exponential time. Here, we present a more sophisticated diagonalization argument that bypasses the need for this task. For simplicity, we describe how to obtain from a weak coding theorem for .
First of all, if we have a weak coding theorem for , by a similar argument as described in the previous case, we get that the truth table of every language in on -bit inputs will have -complexity less than , for infinitely many . This means one can non-deterministically generate these truth tables in time with at most -bits of advice. This allows us to conclude that .
Now suppose, for the sake of contradiction, . Note that by the existence of -complete problems under linear-time reductions, this implies for some fixed . Then we have
| (by padding and ) | ||||
| (by the previous paragraph) | ||||
| (by padding and ) | ||||
| (by choosing ) | ||||
| (by deterministic simulation) |
Note that we use the assumption twice in the above. Finally, one can show by diagonalization that , which gives a contradiction as desired.
The proof that weak coding for follows from is similar to the previous case. We use the hardness-vs-randomness framework (and a win-win argument) to construct a PRG that βhitsβ any string sampled with probability at least . However, there are a couple of differences in this setting. First, in the win-win argument, we use the KarpβLipton result for [22] instead of the one for . Second, to obtain weak coding for , we require our PRG to be computable non-deterministically in the sense that there exists some good guess that allows us to correctly compute the output of the PRG, while for all other bad guesses, we output . While we donβt know how to achieve this exactly, we can show that it is possible with access to a small advice string. This is because one can non-deterministically construct the truth table of a language in using a small amount of advice that indicates the number of positive instances, as observed for instance in [22]. Such a PRG is sufficient for our purposes.
Equivalence Between Coding for and .
The task of obtaining from a non-trivial coding theorem for faces the same challenge as in the case of showing from a coding theorem for , since it is unclear how to construct an -bit string with high -complexity in time . On the other hand, the alternative approach used to show the latter can also be applied in this context. However, when using this approach in the case of , it relied on the fact that is a syntactic class, whereas is not (i.e., it is semantic). To address this issue, we consider the weaker conclusion that instead of .
A bigger challenge arises in showing that weak coding for follows from . Recall that in previous cases, we needed to use a KarpβLipton result for either or . However, we do not have such a KarpβLipton result for zero-error probabilistic classes. In fact, obtaining KarpβLipton theorems for probabilistic classes is known to be a challenging task in complexity theory. While there are known results showing some weak versions of such a theorem for (see [41]), they are not sufficient for our purpose here.
Note that we only need the KarpβLipton result in one of the cases in our win-win argument. Specifically, we can consider two cases: , in which we have weak coding for and hence for , and . We show that in the latter case, we can indeed obtain a KarpβLipton theorem for zero-error probabilistic classes. More specifically, we show that assuming , if for some , then (see [20, Lemma 35]).
Now assume , and suppose we are in the remaining case (which is equivalent to ). We get that . By our aforementioned KarpβLipton theorem, we obtain that for all . Again, using the hardness-vs-randomness framework, this allows us to obtain an infinitely-often secure PRG with sub-polynomial seed length that is computable probabilistically with zero error using a small amount of advice. Proceeding similarly to previous proofs, this yields weak coding for , as desired.
Complexity Separations and Meta-Complexity.
We first describe the proof of Theorem 5. As mentioned in Section 1.2.4, it was shown in [1] that if and only if -. The original proof relied on the fact that admits instance checkers [4], which are not available for . Here, we provide an alternative proof that does not use instance checkers.
For the direction that implies -, it is not hard to see that , where the queries to the oracle are of polynomial size. It is then not difficult to show that the desired inclusion follows from . Indeed, we get the stronger conclusion that .
For the other direction, assume . Then, as shown in previous paragraphs, we obtain an infinitely-often secure PRG that is computable non-deterministically with a small amount of advice. Now suppose, for the sake of contradiction, that -. In that case, an efficient algorithm solving - could be used to break the security of the aforementioned PRG. This is because every output of such a PRG has small -complexity, while a uniformly random string has high -complexity.
The proof of Theorem 6 for - can be shown similarly, using a PRG that is computable probabilistically with zero error using a small advice. Such a PRG can be obtained under the assumption that , as described in previous paragraphs.
Finally, for our unconditional lower bound in Theorem 7, a natural approach is to try to adapt the lower bound for in the two-sided error setting from [40] to the zero-error setting. The proof makes crucial use of techniques from pseudorandomness and of the properties of the reconstruction procedure of different PRGs. In order to adapt the original argument to the zero-error setting, it is necessary to obtain zero-error reconstruction routines for the corresponding PRGs. This, however, seems to be out of reach using current techniques (see [29] for related results).
Instead, we show that if - can be solved by a zero-error randomized algorithm in quasi-polynomial time, then, using the easy witness method introduced by [24], one can approximately βcollapseβ and (see [20, Lemma 40]). This, in particular, implies that - can also be solved in quasi-polynomial time by a randomized algorithm. Using the known unconditional lower bound for - established in [40], this leads to a contradiction.
Remainder of the paper.
We provide the necessary background in Section 2. In Section 3, we establish the equivalence between complexity lower bounds and coding for complexity (Theorem 1), and in Section 4 we extend these results to (Theorem 3). Due to space limitations, we omit the proofs of the corresponding equivalence for (Theorem 4), as well as the results on meta-complexity (Theorems 5, 6, andΒ 7). Full details are available in the full version [20].
2 Preliminaries
2.1 Time-Bounded Kolmogorov Complexity
Fix a time-efficient universal Turing machine . For convenience of the reader, we collect below the main notions of time-bounded Kolmogorov complexity considered in this work.
Definition 8 ( [28]).
For a string and an oracle , we let
The notation denotes that computes for at most steps. In the absence of , we simply write .
Definition 9 ( [40]).
For a string , we let
Next, we define zero-error and nondeterministic analogues of these measures.
Definition 10 ().
For a string , we let
Definition 11 ().
For , we let
Note that, for every , we have and . The relation between and is unclear. For an overview of probabilistic notions of Kolmogorov complexity and their applications, we refer to [36].
2.2 Pseudorandomness
For a finite set , we write to denote that is uniformly distributed over .
Let be a distribution supported over . Let . Finally, let . We say that -fools if
For a function , we write to denote the distribution induced by for .
Theorem 12 ([5]).
For every and , there exist a polynomial time computable function , and such that the following holds.
and if is the truth table of a Boolean function on variables that has circuit complexity at least , then the generator -fool every circuit of size at most .
2.3 Complexity Theory and Diagonalization Against Advice
For the definition of standard notions, such as complexity classes with advice and promise classes, we refer to a textbook in complexity theory.
The following simple diagonalization lemma will be sufficient for our purposes.
Lemma 14.
Let be time-constructible functions satisfying the following properties:
-
1.
,
-
2.
,
-
3.
,
-
4.
.
Then we have .
Proof.
We define a language as follows. For input length , define . Item 2 guarantees that . We construct the length- prefix of truth tables of the first Turing machines with all possible length- advice strings running in time . There are at most such prefixes, and since , we can enumerate over all length- strings, and find the first string outside this list. We then define the truth table of this language on input length as .
The first enumeration and simulation step takes time . Using a naive search over all -bit strings, finding takes time at most . By Item 1 and Item 4, this language is decidable in time . However, by our construction and Item 3, any Turing machine running in time fails to decide this language with any length- advice string for all large enough .
Recall that denotes the class of languages that can be decided in double exponential time, denotes the class of languages that can be decided in single exponential time, and .
Corollary 15.
For any fixed and time-constructible , we have .
Corollary 16.
For any fixed , .
For a language , we let denote the string representing the truth table of on inputs of length .
3 Coding for Deterministic Time-Bounded Kolmogorov Complexity
3.1 Equivalence Between Coding for and
Theorem 1. [Restated, see original statement.]
The following statements are equivalent.
-
1.
.
-
2.
(Weak coding for .) For any and any polynomial-time samplable distribution family , there are infinitely many such that for all ,
-
3.
(Non-trivial coding for .) There exists a constant such that the following holds. Let be a polynomial-time samplable distribution family, where each is supported over , satisfying that there exists a sequence such that for every . Then for infinitely many , we have
Proof.
We show the following implications.
(Item 2 Item 3). This holds trivially.
(Item 3 Item 1). This is shown by Lemma 17, stated and proved in Section 3.1.1.
(Item 1 Item 2). This follows from Lemma 19, stated and proved in Section 3.1.2.
3.1.1 from Non-Trivial Coding for
Proof.
For the sake of contradiction, suppose . By a simple padding argument, this implies . Then it suffices to show the existence of a language such that .
We first show the following claim.
Claim 18.
If non-trivial coding for is true, then for every , there are infinitely many such that .
Proof of Claim 18.
Fix . Let be a -time probabilistic Turing machine that computes on each input of length with error . Such a machine can be obtained by using error reduction techniques.
Consider the distribution family where each is defined by the following sampling procedure:
On input , let . Let be the ordered set consisting of the lexicographically first elements of . For each compute . Finally, output , i.e., the concatenation of these bits.
Note that since has exponentially small error for each input, by a union bound, we get that for every , with probability at least , outputs the -bit prefix of the truth table given by , i.e., , where . Also note that is polynomial-time samplable.
By applying non-trivial coding for to , it follows that there are infinitely many such that, for ,
Fix any such that the above holds, and let be such that and outputs within steps. Consider the following procedure for generating .
Given , we first run to obtain and output .
It is easy to see that the above procedure runs in time . This implies that
This completes the proof of Claim 18.
We define the language as follows.
On input , we first compute a string such that , as follows. We enumerate all pairs such that and run for at most steps. This gives all the strings whose -complexity are at most . We then let be the lexicographically first -bit string that is not in the list. Finally, we output the -th bit of .
It is easy to see that . Also, by construction, we have that for all , . It follows from Claim 18 that .
3.1.2 Weak Coding for from
We first show the following technical lemma.
Lemma 20.
If , then for every and , there is a sequence , where is computable in time , such that the following holds. For every distribution family of Boolean circuits samplable in time , there are infinitely many such that with probability at least over sampled from , -fools .
Proof.
Assume . We consider two cases and show that the desired conclusion holds in each one of those cases.
Case 1: .
The desired pseudorandom generator follows directly from Theorem 13.
Case 2: .
Since we assume , we have in this case. Recall that if then [25]. Therefore, we have , which further implies . Let be a language that is not computable by any polynomial-size circuit.
Consider any and . Let , and be as provided by Theorem 12. By the property of and the hardness of the language , we have that, for infinitely many , the generator , defined as
-fools circuits of size at most . Note that since , can be obtained in time . Also, is polynomial-time computable. It follows that each can be computed in time . Finally, note that the above also yields the desired conclusion.
We are now ready to show Lemma 19.
Proof of Lemma 19.
Assume . The main idea is to use the pseudorandom generator in Lemma 20 to βhitβ any string that is sampled with probability at least . That is, there is a seed such that . Then can be encoded using the short seed . Details follow.
Let and be a distribution family that admits a sampler that, on input , runs in time at most , for some constant .
Let be the sequence of generators in Theorem 13, where is a constant specified later.
Consider the following distribution of circuits:
On input , we run to obtain a string . We then construct the circuit such that if and only if . Finally, we output .
First of all, note that by letting be a sufficiently large constant, we get that is samplable in time . Then by Theorem 13 and the security of , there are infinitely many such that
| (1) |
Now fix any large enough such that Equation 1 holds and consider any in the support of . Suppose . Then we have
as desired.
Suppose . Then by construction, we have that samples with probability at least . It follows from Equation 1 that -fools ; this is because otherwise the probability that fails to be pseudorandom would be greater than . In particular, this means
It follows that there exists some such that . From here, it is easy to show that , as desired.
3.2 Stronger Lower Bounds from Near-Optimal Coding for
We say that near-optimal coding for holds if for every polynomial-time sampler and for every string , if has probability under then .
Theorem 21.
Suppose that near-optimal coding for holds. Then, for every there is and a language such that .
Proof.
Fix a constant . We define a sampler with that randomly selects one of the first randomized Turing machines, runs it for steps on every string of length , and outputs the corresponding truth table. We also assume that boosts the success probability of the machine on a given input string by simulating it times and taking a majority vote, meaning that once a machine with bounded acceptance probabilities is selected, the corresponding truth table is produced with probability at least .
Note that for every language and for each large enough , the truth table of on inputs of length is output by with probability at least . Consequently, by the near-optimal coding assumption, every truth table in (a string of length ) has complexity at most , for a large enough constant .
Finally, we can define a hard language as follows. On an input string of length , we find by diagonalization a string of length of complexity , for , and compute according to the truth table encoded by this string. The latter can be done by exhaustive search in deterministic time , for a large enough positive integer . By the previous paragraph, we obtain that , which completes the proof.
We note that the elementary proof given above strengthens and simplifies [26, Theorem 5.3.4].
4 Coding for Non-Deterministic Time-Bounded Kolmogorov Complexity
4.1 Equivalence Between Coding for and
Theorem 22.
The following statements are equivalent.
-
1.
.
-
2.
(Weak coding for ) For any and any polynomial-time samplable distribution family , there are infinitely many such that for all ,
-
3.
(Non-trivial coding for .) There exists a constant such that the following holds. Let be a polynomial-time samplable distribution family, where each is supported over , satisfying that there exists a sequence such that for every . Then for infinitely many , we have
Proof.
We establish the following implications:
(Item 2 Item 3). This follows immediately.
(Item 3 Item 1). This is shown by Lemma 23, which is stated and proved in Section 4.1.1.
(Item 1 Item 2). This follows from Lemma 26, which is stated and proved in Section 4.1.2.
4.1.1 from Non-Trivial Coding for
Lemma 23.
(Item 3 Item 1 in Theorem 22). If non-trivial coding for is true, then .
Proof.
We first show the following two claims.
Claim 24.
If non-trivial coding for is true, then for every , there are infinitely many such that .
Proof Sketch of Claim 24.
The proof can be easily adapted from that of Claim 18, by replacing the use of non-trivial coding for with that for .
Claim 25.
If non-trivial coding for is true, then
Proof of Claim 25.
Fix . First of all, by Claim 24, we have that there are infinitely many such that . This means for infinitely many , there exist a program of size at most such that for ,
-
, outputs within steps, and
-
, outputs or within steps
It is easy to see that for any such that the above holds, given as an advice, on input length can be solved non-deterministically in time , by guessing and trying to use to generate . We are now ready to show the lemma. Suppose
| (2) |
Note that by the existence of languages that are -complete under linear-time reductions, the above implies that there exists some such that
| (3) |
Next, we aim to derive a contradiction. By Equation 2 and padding, we have
| (4) |
By Claim 25, we get
| (5) |
Now by using Equation 3 and a standard padding argument that incorporates the advice as an extra input string, we get that there exists some such that
| (6) |
Finally, by deterministic simulation of randomized algorithms, we get that there exists some such that
| (7) |
Equations 4, 5, 6, andΒ 7 yield the existence of some such that
However, the above contradicts Corollary 15.
4.1.2 Weak Coding for from
Lemma 26.
(Item 1 Item 2 in Theorem 22). If , then weak coding for is true.
We rely on the following result, which is analogous to Lemma 20 but for the case of .
Lemma 27.
If , then for every and , there is a sequence , where , such that the following holds. For every distribution family of Boolean circuits samplable in time , there are infinitely many such that with probability at least over sampled from , -fools . Moreover, each can be computed non-deterministically with advice in the following sense: There exists a deterministic Turing machine and a sequence of advice strings such that, given and , runs in time . Also, for every , the following hold:
-
There exists such that .
-
For all , .
Proof.
The proof is similar to that of Lemma 20 but requires some crucial observations on the efficiency of computing the pseudorandom generator in the non-deterministic setting.
Assume . We consider two cases below.
Case 1: .
The desired pseudorandom generator follows directly from Theorem 13.
Case 2: .
By the assumption that , we get that in this case. Then, by [22], implies . Therefore, we obtain in this case.
Analogous to the proof of Lemma 20, given that , we have a language that is not computable by any polynomial-size circuit. Then for every and , we get that the generator , defined as , where and are as provided by Theorem 12, fools circuits of size at most , for infinitely many .
To show that each can be computed non-deterministically with a small advice, it suffices to generate in non-deterministic time with bits of advice. This can be done, as observed in [22, Lemma 1].
We now show Lemma 26.
Proof Sketch of Lemma 26.
4.2 Equivalence Between Coding for and
Theorem 28.
The following statements are equivalent.
-
1.
.
-
2.
(Weak coding for ) For any and any polynomial-time samplable distribution family , there are infinitely many such that for all ,
-
3.
(Non-trivial coding for .) There exists a constant such that the following holds. Let be a polynomial-time samplable distribution family, where each is supported over , satisfying that there exists a sequence such that for every . Then for infinitely many , we have
Proof Sketch.
The proof can be easily adapted from that of Theorem 1.
One difference arises in showing that implies weak coding for . Analogously to Lemma 20, we can show that if , then for every and , there exists an infinitely-often secure pseudorandom generator , where each is computable in time with access to an oracle. Instead of using the KarpβLipton theorem for as in the proof of Lemma 20, we use the version for [8], which states that if , then .
References
- [1] Eric Allender, Harry Buhrman, Michal KouckΓ½, Dieter van Melkebeek, and Detlef Ronneburger. Power from random strings. SIAM J. Comput., 35(6):1467β1493, 2006. doi:10.1137/050628994.
- [2] Eric Allender, Michal KouckΓ½, Detlef Ronneburger, and Sambuddha Roy. The pervasive reach of resource-bounded Kolmogorov complexity in computational complexity theory. J. Comput. Syst. Sci., 77(1):14β40, 2011. doi:10.1016/j.jcss.2010.06.004.
- [3] Luis Filipe Coelho Antunes and Lance Fortnow. Worst-case running times for average-case algorithms. In Conference on Computational Complexity (CCC), pages 298β303, 2009. doi:10.1109/CCC.2009.12.
- [4] LΓ‘szlΓ³ Babai, Lance Fortnow, and Carsten Lund. Non-deterministic exponential time has two-prover interactive protocols. Comput. Complex., 1:3β40, 1991. doi:10.1007/BF01200056.
- [5] LΓ‘szlΓ³ Babai, Lance Fortnow, Noam Nisan, and Avi Wigderson. BPP has subexponential time simulations unless EXPTIME has publishable proofs. Computational Complexity, 3:307β318, 1993. doi:10.1007/BF01275486.
- [6] Marshall Ball, Yanyi Liu, Noam Mazor, and Rafael Pass. Kolmogorov comes to cryptomania: On interactive Kolmogorov complexity and key-agreement. In Symposium on Foundations of Computer Science (FOCS), pages 458β483, 2023. doi:10.1109/FOCS57990.2023.00034.
- [7] Harry Buhrman, Lance Fortnow, and Rahul Santhanam. Unconditional lower bounds against advice. In International Colloquium on Automata, Languages and Programming (ICALP), pages 195β209, 2009. doi:10.1007/978-3-642-02927-1_18.
- [8] Harry Buhrman and Steven Homer. Superpolynomial circuits, almost sparse oracles and the exponential hierarchy. In Foundations of Software Technology and Theoretical Computer Science (FSTTCS), pages 116β127, 1992. doi:10.1007/3-540-56287-7_99.
- [9] Marco L. Carmosino, Russell Impagliazzo, Valentine Kabanets, and Antonina Kolokolova. Learning algorithms from natural proofs. In Conference on Computational Complexity (CCC), pages 10:1β10:24, 2016. doi:10.4230/LIPIcs.CCC.2016.10.
- [10] Halley Goldberg and Valentine Kabanets. Improved learning from Kolmogorov complexity. In Computational Complexity Conference (CCC), pages 12:1β12:29, 2023. doi:10.4230/LIPIcs.CCC.2023.12.
- [11] Halley Goldberg and Valentine Kabanets. Consequences of randomized reductions from SAT to time-bounded Kolmogorov complexity. In Approximation, Randomization, and Combinatorial Optimization: Algorithms and Techniques (APPROX/RANDOM), pages 51:1β51:19, 2024. doi:10.4230/LIPIcs.APPROX/RANDOM.2024.51.
- [12] Halley Goldberg, Valentine Kabanets, Zhenjian Lu, and Igor C. Oliveira. Probabilistic Kolmogorov complexity with applications to average-case complexity. In Computational Complexity Conference (CCC), pages 16:1β16:60, 2022. doi:10.4230/LIPIcs.CCC.2022.16.
- [13] Shuichi Hirahara. Average-case hardness of NP from exponential worst-case hardness assumptions. In Symposium on Theory of Computing (STOC), pages 292β302, 2021. doi:10.1145/3406325.3451065.
- [14] Shuichi Hirahara. Symmetry of information from meta-complexity. In Computational Complexity Conference (CCC), pages 26:1β26:41, 2022. doi:10.4230/LIPIcs.CCC.2022.26.
- [15] Shuichi Hirahara, Rahul Ilango, Zhenjian Lu, Mikito Nanashima, and Igor C. Oliveira. A duality between one-way functions and average-case symmetry of information. In Symposium on Theory of Computing (STOC), pages 1039β1050, 2023. doi:10.1145/3564246.3585138.
- [16] Shuichi Hirahara, Valentine Kabanets, Zhenjian Lu, and Igor C. Oliveira. Exact search-to-decision reductions for time-bounded Kolmogorov complexity. In Computational Complexity Conference (CCC), pages 29:1β29:56, 2024. doi:10.4230/LIPIcs.CCC.2024.29.
- [17] Shuichi Hirahara, Zhenjian Lu, and Mikito Nanashima. Optimal coding for randomized kolmogorov complexity and its applications. In Symposium on Foundations of Computer Science (FOCS), pages 369β378, 2024. doi:10.1109/FOCS61266.2024.00030.
- [18] Shuichi Hirahara, Zhenjian Lu, and Igor C. Oliveira. One-way functions and pKt complexity. In Theory of Cryptography (TCC), pages 253β286, 2024. doi:10.1007/978-3-031-78011-0_9.
- [19] Shuichi Hirahara and Mikito Nanashima. Learning in Pessiland via inductive inference. In Symposium on Foundations of Computer Science (FOCS), pages 447β457, 2023. doi:10.1109/FOCS57990.2023.00033.
- [20] Jinqiao Hu, Zhenjian Lu, and Igor C. Oliveira. Equivalence between coding and complexity lower bounds. Electron. Colloquium Comput. Complex., TR25, 2025. URL: https://eccc.weizmann.ac.il/report/2025/211.
- [21] Rahul Ilango, Hanlin Ren, and Rahul Santhanam. Robustness of average-case meta-complexity via pseudorandomness. In Symposium on Theory of Computing (STOC), pages 1575β1583, 2022. doi:10.1145/3519935.3520051.
- [22] Russell Impagliazzo, Valentine Kabanets, and Avi Wigderson. In search of an easy witness: exponential time vs. probabilistic polynomial time. J. Comput. Syst. Sci., 65(4):672β694, 2002. doi:10.1016/S0022-0000(02)00024-7.
- [23] Russell Impagliazzo and Avi Wigderson. Randomness vs time: Derandomization under a uniform assumption. J. Comput. Syst. Sci., 63(4):672β688, 2001. doi:10.1006/jcss.2001.1780.
- [24] Valentine Kabanets. Easiness assumptions and hardness tests: Trading time for zero error. In Conference on Computational Complexity (CCC), pages 150β157, 2000. doi:10.1109/CCC.2000.856746.
- [25] Richard M. Karp and Richard J. Lipton. Some connections between nonuniform and uniform complexity classes. In Symposium on Theory of Computing (STOC), pages 302β309, 1980. doi:10.1145/800141.804678.
- [26] Troy Lee. Kolmogorov complexity and formula lower bounds. PhD thesis, University of Amsterdam, 2006.
- [27] Leonid A. Levin. Laws of information conservation (nongrowth) and aspects of the foundation of probability theory. Problemy Peredachi Informatsii, 10(3):30β35, 1974.
- [28] Leonid A. Levin. Randomness conservation inequalities; information and independence in mathematical theories. Information and Control, 61(1):15β37, 1984. doi:10.1016/S0019-9958(84)80060-1.
- [29] Jiatu Li, Edward Pyne, and Roei Tell. Distinguishing, predicting, and certifying: On the long reach of partial notions of pseudorandomness. In Symposium on Foundations of Computer Science (FOCS), pages 1β13, 2024. doi:10.1109/FOCS61266.2024.00095.
- [30] Yanyi Liu and Rafael Pass. On one-way functions and Kolmogorov complexity. In Symposium on Foundations of Computer Science (FOCS), pages 1243β1254, 2020. doi:10.1109/FOCS46700.2020.00118.
- [31] Yanyi Liu and Rafael Pass. One-way functions and the hardness of (probabilistic) time-bounded Kolmogorov complexity w.r.t. samplable distributions. In Annual Cryptology Conference (CRYPTO), pages 645β673, 2023. doi:10.1007/978-3-031-38545-2_21.
- [32] Yanyi Liu and Rafael Pass. On one-way functions, the worst-case hardness of time-bounded Kolmogorov complexity, and computational depth. In Theory of Cryptography (TCC), pages 222β252, 2024. doi:10.1007/978-3-031-78011-0_8.
- [33] Yanyi Liu and Rafael Pass. Hardness along the boundary towards one-way functions from the worst-case hardness of time-bounded Kolmogorov complexity. In Annual Cryptology Conference (CRYPTO), 2025. doi:10.1007/978-3-032-01855-7_20.
- [34] Zhenjian Lu, Noam Mazor, Igor C. Oliveira, and Rafael Pass. Lower bounds on the overhead of indistinguishability obfuscation. IACR Cryptol. ePrint Arch., page 1524, 2024. URL: https://eprint.iacr.org/2024/1524.
- [35] Zhenjian Lu and Igor C. Oliveira. An efficient coding theorem via probabilistic representations and its applications. In International Colloquium on Automata, Languages, and Programming (ICALP), pages 94:1β94:20, 2021. doi:10.4230/LIPIcs.ICALP.2021.94.
- [36] Zhenjian Lu and Igor C. Oliveira. Theory and applications of probabilistic Kolmogorov complexity. Bull. EATCS, 137, 2022. URL: http://bulletin.eatcs.org/index.php/beatcs/article/view/700.
- [37] Zhenjian Lu, Igor C. Oliveira, Hanlin Ren, and Rahul Santhanam. On the complexity of avoiding heavy elements. In Symposium on Foundations of Computer Science (FOCS), pages 2403β2412, 2024. doi:10.1109/FOCS61266.2024.00140.
- [38] Zhenjian Lu, Igor C. Oliveira, and Marius Zimand. Optimal coding theorems in time-bounded Kolmogorov complexity. In International Colloquium on Automata, Languages, and Programming (ICALP), pages 92:1β92:14, 2022. doi:10.4230/LIPIcs.ICALP.2022.92.
- [39] Zhenjian Lu and Rahul Santhanam. Impagliazzoβs worlds through the lens of conditional Kolmogorov complexity. In International Colloquium on Automata, Languages, and Programming (ICALP), pages 110:1β110:17, 2024. doi:10.4230/LIPIcs.ICALP.2024.110.
- [40] Igor C. Oliveira. Randomness and intractability in Kolmogorov complexity. In International Colloquium on Automata, Languages, and Programming (ICALP), pages 32:1β32:14, 2019. doi:10.4230/LIPIcs.ICALP.2019.32.
- [41] Igor C. Oliveira and Rahul Santhanam. Conspiracies between learning algorithms, circuit lower bounds, and pseudorandomness. In Computational Complexity Conference (CCC), pages 18:1β18:49, 2017. doi:10.4230/LIPIcs.CCC.2017.18.
- [42] Rahul Santhanam. An algorithmic approach to uniform lower bounds. In Computational Complexity Conference (CCC), pages 35:1β35:26, 2023. doi:10.4230/LIPIcs.CCC.2023.35.
- [43] Luca Trevisan and Salil P. Vadhan. Pseudorandomness and average-case complexity via uniform reductions. Computational Complexity, 16(4):331β364, 2007. doi:10.1007/s00037-007-0233-x.
