Inapproximability of VC Dimension and Littlestone's Dimension
Pasin Manurangsi, Aviad Rubinstein

TL;DR
This paper investigates the computational complexity of determining VC and Littlestone's Dimensions, establishing quasi-polynomial algorithms and ETH-based lower bounds that highlight their inapproximability.
Contribution
It provides the first quasi-polynomial time algorithms and matching ETH-based lower bounds for approximating VC and Littlestone's Dimensions.
Findings
Exact computation is in quasi-polynomial time.
Under ETH, approximation is nearly as hard as exact computation.
The results establish fundamental inapproximability bounds.
Abstract
We study the complexity of computing the VC Dimension and Littlestone's Dimension. Given an explicit description of a finite universe and a concept class (a binary matrix whose -th entry is iff element belongs to concept ), both can be computed exactly in quasi-polynomial time (). Assuming the randomized Exponential Time Hypothesis (ETH), we prove nearly matching lower bounds on the running time, that hold even for approximation algorithms.
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Taxonomy
TopicsComplexity and Algorithms in Graphs · Machine Learning and Algorithms · Optimization and Search Problems
Inapproximability of VC Dimension and Littlestone’s Dimension
Pasin Manurangsi
UC Berkeley Email: [email protected].
Aviad Rubinstein
UC Berkeley Email: [email protected].
Abstract
We study the complexity of computing the VC Dimension and Littlestone’s Dimension. Given an explicit description of a finite universe and a concept class (a binary matrix whose -th entry is iff element belongs to concept ), both can be computed exactly in quasi-polynomial time (). Assuming the randomized Exponential Time Hypothesis (ETH), we prove nearly matching lower bounds on the running time, that hold even for approximation algorithms.
1 Introduction
A common and essential assumption in learning theory is that the concepts we want to learn come from a nice, simple concept class, or (in the agnostic case) they can at least be approximated by a concept from a simple class. When the concept class is sufficiently simple, there is hope for good (i.e. sample-efficient and low-error) learning algorithms.
There are many different ways to measure the simplicity of a concept class. The most influential measure of simplicity is the VC Dimension, which captures learning in the PAC model. We also consider Littlestone’s Dimension [Lit88], which corresponds to minimizing mistakes in online learning (see Section 2 for definitions). When either dimension is small, there are algorithms that exploit the simplicity of the class, to obtain good learning guarantees.
Two decades ago, it was shown (under appropriate computational complexity assumptions) that neither dimension can be computed in polynomial time [PY96, FL98]; and these impossibility results hold even in the most optimistic setting where the entire universe and concept class are given as explicit input (a binary matrix whose -th entry is iff element belongs to concept ). The computational intractability of computing the (VC, Littlestone’s) dimension of a concept class suggests that even in cases where a simple structure exists, it may be inaccessible to computationally bounded algorithms (see Discussion below).
In this work we extend the results of [PY96, FL98] to show that the VC and Littlestone’s Dimensions cannot even be approximately computed in polynomial time. We don’t quite prove that those problems are -hard: both dimensions can be computed (exactly) in quasi-polynomial () time, hence it is very unlikely that either problem is -hard. Nevertheless, assuming the randomized Exponential Time Hypothesis (ETH)111The randomized ETH (rETH) postulates that there is no -time Monte Carlo algorithms that solves on variables correctly with probability at least (i.e. ). [IPZ01, IP01], we prove essentially tight quasi-polynomial lower bounds on the running time - that hold even against approximation algorithms.
Theorem 1** (Hardness of Approximating VC Dimension)**
Assuming Randomized ETH, approximating VC Dimension to within a -factor requires time.
Theorem 2** (Hardness of Approximating Littlestone’s Dimension)**
There exists an absolute constant such that, assuming Randomized ETH, approximating Littlestone’s Dimension to within a -factor requires time.
1.1 Discussion
As we mentioned before, the computational intractability of computing the (VC, Littlestone’s) dimension of a concept class suggests that even in cases where a simple structure exists, it may be inaccessible to computationally bounded algorithms. We note however that it is not at all clear that any particular algorithmic applications are immediately intractable as a consequence of our results.
Consider for example the adversarial online learning zero-sum game corresponding to Littlestone’s Dimension: At each iteration, Nature presents the learner with an element from the universe; the learner attempts to classify the element, and loses a point for every wrong classification; at the end of the iteration, the correct (binary) classification is revealed. The Littlestone’s Dimension is equal to the worst case loss of the Learner before learning the exact concept. (see Section 2 for a more detailed definition.)
What can we learn from the fact that the Littlestone’s Dimension is hard to compute? The first observation is that there is no efficient learner that can commit to a concrete mistake bound. But this does not rule out a computationally-efficient learner that plays optimal strategy and makes at most as many mistakes as the unbounded learner. We can, however, conclude that Nature’s task is computationally intractable! Otherwise, we could efficiently construct an entire worst-case mistake tree (for a concept class , any mistake tree has at most leaves, requiring oracle calls to Nature).
On a philosophical level, we think it is interesting to understand the implications of an intractable, adversarial Nature. Perhaps this is another evidence that the mistake bound model is too pessimistic?
Also, the only algorithm we know for computing the optimal learner’s decision requires computing the Littlestone’s Dimension. We think that it is an interesting open question whether an approximately optimal computationally-efficient learner exists.
In addition, let us note that in the other direction, computing Littlestone’s Dimension exactly implies an exactly optimal learner. However, since the learner has to compute Littlestone’s Dimension many times, we have no evidence that an approximation algorithm for Littlestone’s Dimension would imply any guarantee for the learner.
Finally, we remark that for either problem (VC or Littlestone’s Dimension), we are not aware of any non-trivial approximation algorithms.
1.2 Techniques
The starting point of our reduction is the framework of “birthday repetition” [AIM14]. This framework has seen many variations in the last few years, but the high level approach is as follows: begin with a hard-to-approximate instance of a CSP (such as -Color), and partition the vertices into -tuples. On one hand, by the birthday paradox, even if the original graph is sparse, we expect each pair of random -tuples to share an edge; this is crucial for showing hardness of approximation in many applications. On the other hand our reduction size is now approximately (there are ways to color each -tuple), whereas by ETH solving -Color requires approximately time, so solving the larger problem also takes at least time.
VC Dimension
The first challenge we have to overcome in order to adapt this framework to hardness of approximation of VC Dimension is that the number of concepts involved in shattering a subset is . Therefore any inapproximability factor we prove on the size of the shattered set of elements, “goes in the exponent” of the size of the shattering set of concepts. Even a small constant factor gap in the VC Dimension requires proving a polynomial factor gap in the number of shattering concepts (obtaining polynomial gaps via “birthday repetition” for simpler problems is an interesting open problem [MR16, Man17]). Fortunately, having a large number of concepts is also an advantage: we use each concept to test a different set of -Color constraints chosen independently at random; if the original instance is far from satisfied, the probability of passing all tests should now be doubly-exponentially small ()! More concretely, we think of half of the elements in the shattered set as encoding an assignment, and the other half as encoding which tests to run on the assignments.
Littlestone’s Dimension
Our starting point is the reduction for VC Dimension outlined in the previous paragraph. While we haven’t yet formally introduced Littlestone’s Dimension, recall that it corresponds to an online learning model. If the test-selection elements arrive before the assignment-encoding elements, the adversary can adaptively tailor his assignment to pass the specific test selected in the previous steps. To overcome this obstacle, we introduce a special gadget that forces the assignment-encoding elements to arrive first; this makes the reduction to Littlestone’s Dimension somewhat more involved. Note that there is a reduction by [FL98] from VC Dimension to Littlestone’s Dimension. Unfortunately, their reduction is not (approximately) gap-preserving, so we cannot use it directly to obtain Theorem 2 from Theorem 1.
1.3 Related Work
The study of the computational complexity of the VC Dimension was initiated by Linial, Mansour, and Rivest [LMR91], who observed that it can be computed in quasi-polynomial time. [PY96] proved that it is complete for the class which they define in the same paper. [FL98] reduced the problem of computing the VC dimension to that of computing Littlestone’s Dimension, hence the latter is also -hard. (It follows as a corollary of our Theorem 1 that, assuming ETH, solving any -hard problem requires quasi-polynomial time.)
Both problems were also studied in an implicit model, where the concept class is given in the form of a Boolean circuit that takes as input an element and a concept and returns iff . Observe that in this model even computing whether either dimension is [math] or not is already -hard. Schafer proved that the VC Dimension is -complete [Sch99], while the Littlestone’s Dimension is -complete [Sch00]. [MU02] proved that VC Dimension is -hard to approximate to within a factor of almost ; can be approximated to within a factor slightly better than in ; and is -hard to approximate to within .
Another line of related work in the implicit model proves computational intractability of PAC learning (which corresponds to the VC Dimension). Such intractability has been proved either from cryptographic assumptions, e.g. [KV94, Kha93, Kha95, FGKP06, KKMS08, KS09, Kli16] or from average case assumptions, e.g. [DS16, Dan16]. [Blu94] showed a “computational” separation between PAC learning and online mistake bound (which correspond to the VC Dimension and Littlestone’s Dimension, respectively): if one-way function exist, then there is a concept class that can be learned by a computationally-bounded learner in the PAC model, but not in the mistake-bound model.
Recently, [BFS16] introduced a generalization of VC Dimension which they call Partial VC Dimension, and proved that it is -hard to approximate (even when given an explicit description of the universe and concept class).
Our work is also related to many other quasi-polynomial lower bounds from recent years, which were also inspired by “birthday repetition”; these include problems like Densest -Subgraph [BKRW17, Man17], Nash Equilibrium and related problems [BKW15, Rub15, BPR16, Rub16b, BCKS16, DFS16] and Community Detection [Rub16a]. It is interesting to note that so far “birthday repetition” has found very different applications, but they all share essentially the same quasi-polynomial algorithm: The bottleneck in those problem is a bilinear optimization problem , which we want to approximate to within a (small) constant additive factor. It suffices to find an -sparse sample of the optimal ; the algorithm enumerates over all sparse ’s [LMM03, AGSS12, Bar15, CCD*+*15]. In contrast, the problems we consider in this paper have completely different quasi-polynomial time algorithms: For VC Dimension, it suffices to simply enumerate over all -tuples of elements (where denotes the concept class and is the trivial upper bound on the VC dimension) [LMR91]. Littlestone’s Dimension can be computed in quasi-polynomial time via a recursive “divide and conquer” algorithm (See Appendix A).
2 Preliminaries
For a universe (or ground set) , a concept is simply a subset of and a concept class is a collection of concepts. For convenience, we sometimes relax the definition and allow the concepts to not be subsets of ; all definitions here extend naturally to this case.
The VC and Littlestone’s Dimensions can be defined as follows.
Definition 3** (VC Dimension [VC71])**
A subset is said to be shattered by a concept class if, for every , there exists a concept such that .
The VC Dimension of a concept class with respect to the universe is the largest such that there exists a subset of size that is shattered by .
Definition 4** (Mistake Tree and Littlestone’s Dimension [Lit88])**
A depth- instance-labeled tree of is a full binary tree of depth such that every internal node of the tree is assigned an element of . For convenience, we will identify each node in the tree canonically by a binary string of length at most .
A depth- mistake tree (aka shattered tree [BPS09]) for a universe and a concept class is a depth- instance-labeled tree of such that, if we let denote the element assigned to the vertex for every , then, for every leaf , there exists a concept that agrees with the path from root to it, i.e., that, for every , iff where denote the prefix of of length .
The Littlestone’s Dimension of a concept class with respect to the universe is defined as the maximum such that there exists a depth- mistake tree for .
An equivalent formulation of Littlestone’s Dimension is through mistakes made in online learning, as stated below. This interpretation will be useful in our proof.
Definition 5** (Mistake Bound)**
An online algorithm is an algorithm that, at time step , is given an element and the algorithm outputs a prediction whether is in the class. After the prediction, the algorithm is told the correct answer . For a sequence , prediction mistake of is defined as the number of incorect predictions, i.e., . The mistake bound of for a concept class is defined as the maximum prediction mistake of over all the sequences which corresponds to a concept (i.e. for all ).
Theorem 6** ([Lit88])**
For any universe and any concept class , is equal to the minimum mistake bound of over all online algorithms.
The following facts are well-know and follow easily from the above definitions.
Fact 7
For any universe and concept class , we have
[TABLE]
Fact 8
For any two universes and any concept class ,
[TABLE]
2.1 Label Cover and PCP
As is standard in hardness of approximation, the starting point for our reductions will be the following problem called Label Cover.
Definition 9** (Label Cover)**
A Label Cover instance consists of a bipartite graph , an alphabet , and, for every edge , a projection constraint .
An assignment (aka labeling) for is a function . The value of , is defined as the fraction of edges such that ; these edges are called satisfied edges. The value of the instance , , is defined as the maximum value among all assignments .
Throughout the paper, we often encounter an assignment that only labels a subset of but leaves the rest unlabeled. We refer to such assignment as a partial assignment to an instance; more specifically, for any , a -partial assignment (or partial assignment on ) is a function . For notational convenience, we sometimes write to denote the set of all functions from to .
We will use the following version of the PCP Theorem by Moshkovitz and Raz, which reduces 3SAT to the gap version of Label Cover while preserves the size to be almost linear.
Theorem 10** (Moshkovitz-Raz PCP [MR10])**
For every and every , solving 3SAT on variables can be reduced to distinguishing between the case that a bi-regular instance of Label Cover with and is satisfiable and the case that its value is at most .
2.2 Useful Lemmata
We end this section by listing a couple of lemmata that will be useful in our proofs.
Lemma 11** (Chernoff Bound)**
Let be i.i.d. random variables taking value from and let be the probability that , then, for any , we have
[TABLE]
Lemma 12** (Partitioning Lemma [Rub16a, Lemma 2.5])**
For any bi-regular bipartite graph , let and . When is sufficiently large, there exists a partition of into such that
[TABLE]
and
[TABLE]
Moreover, such partition can be found in randomized linear time (alternatively, deterministic time).
3 Inapproximability of VC Dimension
In this section, we present our reduction from Label Cover to VC Dimension, stated more formally below. We note that this reduction, together with Moshkovitz-Raz PCP (Theorem 10), with parameter gives a reduction from 3SAT on variables to VC Dimension of size with gap , which immediately implies Theorem 1.
Theorem 13
For every , there exists a randomized reduction from a bi-regular Label Cover instance such that to a ground set and a concept class such that, if and , then the following conditions hold for every sufficiently large .
- •
(Size) The reduction runs in time and .
- •
(Completeness) If is satisfiable, then .
- •
(Soundness) If , then with high probability.
In fact, the above properties hold with high probability even when and are not constants, as long as .
We remark here that when , Moshkovitz-Raz PCP produces a Label Cover instance with and . For such parameters, the condition holds for every sufficiently large .
3.1 A Candidate Reduction (and Why It Fails)
To best understand the intuition behind our reduction, we first describe a simpler candidate reduction and explain why it fails, which will lead us to the eventual construction. In this candidate reduction, we start by evoking Lemma 12 to partition the vertices of the Label Cover instance into where . We then create the universe and the concept class as follows:
- •
We make each element in correspond to a partial assignment to for some , i.e., we let . In the completeness case, we expect to shatter the set of size that corresponds to a satisfying assignment of the Label Cover instance , i.e., . As for the soundness, our hope is that, if a large set gets shattered, then we will be able to decode an assignment for that satisfies many constraints, which contradicts with our assumption that is small. Note that the number of elements of in this candidate reduction is at most as desired.
- •
As stated above, the intended solution for the completeness case is , meaning that we must have at least one concept corresponding to each subset . We will try to make our concepts “test” the assignment; for each , we will choose a set of vertices and “test” all the constraints within . Before we specify how is picked, let us elaborate what “test” means: for each -partial assignment that does not violate any constraints within , we create a concept . This concept contains if and only if and agrees with (i.e. ). Recall that, if a set is shattered, then each is an intersection between and for some . We hope that the ’s are different for different so that many different tests have been performed on .
Finally, let us specify how we pick . Assume without loss of generality that is even. We randomly pick a perfect matching between , i.e., we pick a random permutation and let \Big{(}\pi_{I}(1),\pi_{I}(2)\Big{)},\dots,\Big{(}\pi_{I}(r-1),\pi_{I}(r)\Big{)} be the chosen matching. We pick such that all the constraints in the matchings, i.e., constraints between and for every , are included. More specifically, for every , we include each vertex if at least one of its neighbors lie in and we include each vertex if at least one of its neighbors lie in . By Lemma 12, for every pair in the matching the size of the intersection is at most , so each concept contains assignments to at most variables; so the total size of the concept class is at most .
Even though the above reduction has the desired size and completeness, it unfortunately fails in the soundness. Let us now sketch a counterexample. For simplicity, let us assume that each vertex in has a unique neighbor in . Note that, since has quite small size (only ), almost all the vertices in satisfy this property w.h.p., but assuming that all of them satisfy this property makes our life easier.
Pick an assignment such that none of the constraints in is violated. From our unique neighbor assumption, there is always such an assignment. Now, we claim that the set gets shattered. This is because, for every subset , we can pick another assignment such that does not violate any constraint in and if and only if . This implies that as desired. Note here that such exists because, for every , if there is a constraint from a vertex to another vertex , then we can change the assignment to in such a way that the constraint is not violated222Here we assume that ; note that this always holds for Label Cover instances produced by Moshkovitz-Raz construction.; by doing this for every , we have created the desired . As a result, can still be as large as even when the value of is small.
3.2 The Final Reduction
In this subsection, we will describe the actual reduction. To do so, let us first take a closer look at the issue with the above candidate reduction. In the candidate reduction, we can view each as being a seed used to pick a matching. Our hope was that many seeds participate in shattering some set , and that this means that corresponds to an assignment of high value. However, the counterexample showed that in fact only one seed () is enough to shatter a set. To circumvent this issue, we will not use the subset as our seed anymore. Instead, we create new elements , which we will call test selection elements to act as seeds; namely, each subset will now be a seed. The benefit of this is that, if is shattered and contains test selection elements , then at least seeds must participate in the shattering of . This is because, for each , the intersection of with any concept corresponding to , when restricted to , is always . Hence, each subset of must come a from different seed.
The only other change from the candidate reduction is that each will test multiple matchings rather than one matching. This is due to a technical reason: we need the number of matchings, , to be large in order get the approximation ratio down to ; in our proof, if , then we can only achieve a factor of to some . The full details of the reduction are shown in Figure 1.
Before we proceed to the proof, let us define some additional notation that will be used throughout.
- •
Every assignment element of the form is called an -assignment element; we denote the set of all -assignment elements by , i.e., . Let denote all the assignment elements, i.e., .
- •
For every , let denote the set of all such that contains an -assignment element, i.e., .
- •
We call a set non-repetitive if, for each , contains at most one -assignment element, i.e., . Each non-repetitive set canonically induces a partial assignment . This is the unique partial assignment that satisfies for every
- •
Even though we define each concept as where is a partial assignment to a subset , it will be more convenient to view each concept as where is the assignment to the entire Label Cover instance. This is just a notational change: the actual definition of the concept does not depend on the assignment outside .
- •
For each , let denote . For each , we say that passes if does not violate any constraint within . Denote the collection of ’s that passes by .
- •
Finally, for any non-repetitive set and any , we say that passes if passes . We write as a shorthand for .
The output size of the reduction and the completeness follow almost immediately from definition.
Output Size of the Reduction. Clearly, the size of is . As for , note first that the number of choices for and are both . For fixed and , Lemma 12 implies that, for each matching , the number of vertices from each with at least one constraint to the matched partition in is at most . Since there are matchings, the number of vertices in is at most . Hence, the number of choices for the partial assignment is at most . In total, we can conclude that contains at most concepts.
Completeness. If has a satisfying assignment , then the set is shattered because, for any , we have . Hence, .
The rest of this section is devoted to the soundness analysis.
3.3 Soundness
In this subsection, we will prove the following lemma, which, combined with the completeness and output size arguments above, imply Theorem 13.
Lemma 14
Let be the output from the reduction in Figure 1 on input . If and , then w.h.p.
At a high level, the proof of Lemma 14 has two steps:
Given a shattered set , we extract a maximal non-repetitive set such that passes many () ’s. If is small, the trivial upper bound of on the number of different ’s implies that is also small. As a result, we are left to deal with the case that is large. 2. 2.
When is large, induces a partial assignment on a large fraction of vertices of . Since we assume that is small, this partial assignment must violate many constraints. We will use this fact to argue that, with high probability, only passes very few ’s, which implies that must be small.
The two parts of the proof are presented in Subsection 3.3.1 and 3.3.2 respectively. We then combine them in Subsection 3.3.3 to prove Lemma 14.
3.3.1 Part I: Finding a Non-Repetitive Set That Passes Many Tests
The goal of this subsection is to prove the following lemma, which allows us to, given a shattered set , find a non-repetitive set that passes many ’s.
Lemma 15
For any shattered , there is a non-repetitive set of size s.t. .
We will start by proving the following lemma, which will be a basis for the proof of Lemma 15.
Lemma 16
Let correspond to the same (i.e. and for some ).
For any subset and any maximal non-repetitive subset , if and , then .
The most intuitive interpretation of this lemma is as follows. Recall that if is shattered, then, for each , there must be a concept such that . The above lemma implies that, for each , must be different. This means that at least different ’s must be involved in shattering . Indeed, this will be the argument we use when we prove Lemma 15.
- Proof of Lemma 16.
Let be as in the lemma statement. Suppose for the sake of contradiction that there exists such that and .
First, note that . Since , we must have . Assume w.l.o.g. that there exists .
Note that (where the equality follows from maximality of ). Thus there exists such that . Since is in both and , we have and
[TABLE]
However, since , we have . This implies that
[TABLE]
which contradicts to (1).
In addition to the above lemma, we will also need the following observation, which states that, if a non-repetitive is contained in a concept , then must pass . This observation follows definitions.
Observation 17
If a non-repetitive set is a subset of some concept , then .
With Lemma 16 and Observation 17 ready, it is now easy to prove Lemma 15.
- Proof of Lemma 15.
Pick to be any maximal non-repetitive subset of . Clearly, . To see that , consider any such that . Since is shattered, there exists such that . Since , Observation 17 implies that . Moreover, from Lemma 16, is distinct for every . As a result, as desired.
3.3.2 Part II: No Large Non-Repetitive Set Passes Many Tests
The goal of this subsection is to show that, if is small, then w.h.p. (over the randomness in the construction) every large non-repetitive set passes only few ’s. This is formalized as Lemma 18 below.
Lemma 18
If and , then, with high probability, for every non-repetitive set of size at least , .
Note that the mapping is a bijection from the collection of all non-repetitive sets to . Hence, the above lemma is equivalent to the following.
Lemma 19
If and , then, with high probability, for every of size at least and every , .
Here we use the language in Lemma 19 instead of Lemma 18 as it will be easier for us to reuse this lemma later. To prove the lemma, we first need to bound the probability that each assignment does not violate any constraint induced by a random matching. More precisely, we will prove the following lemma.
Lemma 20
For any of size at least and any , if is a random permutation of , then the probability that does not violate any constraint in is at most where denote the index that is matched with in the matching \Big{(}\pi(1),\pi(2)\Big{)},\dots,\Big{(}\pi(r-1),\pi(r)\Big{)}.
- Proof.
Let be any positive odd integer such that and let be any distinct elements of . We will first show that conditioned on , the probability that violates a constraint induced by (i.e. in ) is at least .
To see that this is true, let . Since , we have . Consider the partial assignment . Since , can satisfy at most constraints. From Lemma 12, we have, for every , the number of constraints between and are at least . Hence, there are at most pairs of such that does not violate any constraint between and . In other words, there are at least pairs such that violates some constraints between and . Now, if and for some such pair , then violates a constraint induced by . Thus, we have
[TABLE]
Let denote the event that does not violate any constraints induced by and . We can now bound the desired probability as follows.
[TABLE]
which is at most since .
We can now prove our main lemma.
- Proof of Lemma 19.
For a fixed of size at least and a fixed , Lemma 20 tells us that the probability that does not violate any constraint induced by a single matching is at most . Since for each the construction picks matchings at random, the probability that passes each is at most . Recall that we pick ; this gives the following upper bound on the probability:
[TABLE]
where the last inequality comes from Bernoulli’s inequality.
Inequality (3) implies that the expected number of ’s that passes is less than . Since the matchings are independent for all ’s, we can apply Chernoff bound which implies that
[TABLE]
Finally, note that there are at most different ’s. By union bound, we have
[TABLE]
which concludes the proof.
3.3.3 Putting Things Together
- Proof of Lemma 14.
From Lemma 18, every non-repetitive set of size at least , . Conditioned on this event happening, we will show that .
Consider any shattered set . Lemma 15 implies that there is a non-repetitive set of size such that . Let us consider two cases:
. Since , we have . This implies that . 2. 2.
. From our assumption, . Thus, where the second inequality comes from our assumption that .
Hence, with high probability.
4 Inapproximability of Littlestone’s Dimension
We next proceed to Littlestone’s Dimension. The main theorem of this section is stated below. Again, note that this theorem and Theorem 10 implies Theorem 2.
Theorem 21
There exists such that there is a randomized reduction from any bi-regular Label Cover instance with to a ground set and a concept classes such that, if and , then the following conditions hold for every sufficiently large .
- •
(Size) The reduction runs in time and .
- •
(Completeness) If is satisfiable, then .
- •
(Soundness) If , then with high probability.
4.1 Why the VC Dimension Reduction Fails for Littlestone’s Dimension
It is tempting to think that, since our reduction from the previous section works for VC Dimension, it may also work for Littlestone’s Dimension. In fact, thanks to Fact 7, completeness for that reduction even translates for free to Littlestone’s Dimension. Alas, the soundness property does not hold. To see this, let us build a depth- mistake tree for , even when is small, as follows.
- •
We assign the test-selection elements to the first levels of the tree, one element per level. More specifically, for each , we assign to .
- •
For every string , the previous step of the construction gives us a subset of corresponding to the path from root to ; this subset is simply . Let denote the set of vertices tested by this seed . Let denote an assignment that satisfies all the constraints in . Note that, since is of small size (only ), even if is small, is still likely to exist (and we can decide whether it exists or not in time ).
We then construct the subtree rooted at that corresponds to by assigning each level of the subtree . Specifically, for each , we assign to node of the tree.
It is not hard to see that the constructed tree is indeed a valid mistake tree. This is because the path from root to each leaf agrees with (where ).
4.2 The Final Reduction
The above counterexample demonstrates the main difference between the two dimensions: order does not matter in VC Dimension, but it does in Littlestone’s Dimension. By moving the test-selection elements up the tree, the tests are chosen before the assignments, which allows an adversary to “cheat” by picking different assignments for different tests. We would like to prevent this, i.e., we would like to make sure that, in the mistake tree, the upper levels of the tree are occupied with the assignment elements whereas the lower levels are assigned test-selection elements. As in the VC Dimension argument, our hope here is that, given such a tree, we should be able to decode an assignment that passes tests on many different tests. Indeed we will tailor our construction to achieve such property.
Recall that, if we use the same reduction as VC Dimension, then, in the completeness case, we can construct a mistake tree in which the first layers consist solely of assignment elements and the rest of the layers consist of only test-selection elements. Observe that there is no need for different nodes on the -th layer to have subtrees composed of the same set of elements; the tree would still be valid if we make each test-selection element only work with a specific and create concepts accordingly. In other words, we can modify our construction so that our test-selection elements are and the concept class is where the condition that an assignment element lies in is the same as in the VC Dimension reduction, whereas for to be in , we require not only that but also that . Intuitively, this should help us, since each is now only in a small fraction () of concepts; hence, one would hope that any subtree rooted at any cannot be too deep, which would indeed implies that the test-selection elements cannot appear in the first few layers of the tree.
Alas, for this modified reduction, it is not true that a subtree rooted at any has small depth; specifically, we can bound the depth of a subtree by the log of the number of concepts containing plus one (for the first layer). Now, note that means that and , but there can be still as many as such concepts. This gives an upper bound of on the depth of the subtree rooted at . However, ; this bound is meaningless here since, even in the completeness case, the depth of the mistake tree is only .
Fortunately, this bound is not useless after all: if we can keep this bound but make the intended tree depth much larger than , then the bound will indeed imply that no -rooted tree is deep. To this end, our reduction will have one more parameter where hides a large constant and the intended tree will have depth in the completeness case; the top half of the tree (first layers) will again consist of assignment elements and the rest of the tree composes of the test-selection elements. The rough idea is to make “copies” of each element: the assignment elements will now be and the test-selection elements will be . The concept class can then be defined as naturally, i.e., is used as the seed to pick the test set , iff and whereas iff and . For this concept class, we can again bound the depth of -rooted tree to be ; this time, however, is much larger than , so this bound is no more than, say, . This is indeed the desired bound, since this means that, for any depth- mistake tree, the first layers must consist solely of assignment elements.
Unfortunately, the introduction of copies in turn introduces another technical challenge: it is not true any more that a partial assignment to a large set only passes a few tests w.h.p. (i.e. an analogue of Lemma 19 does not hold). By Inequality (3), each is passed with probability at most , but now we want to take a union bound there are different ’s. To circumvent this, we will define a map and use to select the test instead of itself. The map we use in the construction is the threshold projection where is included in if and only if, for at least half of , contains . To motivate our choice of , recall that our overall proof approach is to first find a node that corresponds to an assignment to a large subset of the Label Cover instance; then argue that it can pass only a few tests, which we hope would imply that the subtree rooted there cannot be too deep. For this implication to be true, we need the following to also hold: for any small subset of ’s, we have that is small. This property indeed holds for our choice of (see Lemma 29).
With all the moving parts explained, we state the full reduction formally in Figure 2.
Similar to our VC Dimension proof, we will use the following notation:
- •
For every , let ; we refer to these elements as the -assignment elements. Moreover, for every , let ; we refer to these elements as the -assignment elements.
- •
For every , let and .
- •
A set is non-repetitive if for all .
- •
We say that passes if the following two conditions hold:
- –
For every such that , all -assignment elements of are consistent on , i.e., for every , we have .
- –
The canonically induced assignment on does not violate any constraint (note that the previous condition implies that such assignment is unique).
We use to denote the collection of all seeds that passes.
We also use the following notation for mistake trees:
- •
For any subset and any function , let be the collections of all concept that agree with on . We sometimes abuse the notation and write to denote the collection of all the concepts that contain , i.e., .
- •
For any binary string , let denote the set of all proper prefixes of .
- •
For any depth- mistake tree , let denote the element assigned to the node , and let denote the set of all elements appearing from the path from root to (excluding itself). Moreover, let be the function corresponding to the path from root to , i.e., for every .
Output Size of the Reduction The output size of the reduction follows immediately from a similar argument as in the VC Dimension reduction. The only different here is that there are choices for and , instead of choices as in the previous construction.
Completeness. If has a satisfying assignment , we can construct a depth- mistake tree as follows. For , we assign to every node in the -th layer of . Note that we have so far assigned every node in the first layers. For the rest of the vertices ’s, if lies in layer , then we assign to it. It is clear that, for a leaf , the concept agrees with the path from root to where is defined as . Hence, .
4.3 Soundness
Next, we will prove the soundness of our reduction, stated more precisely below. For brevity, we will assume throughout this subsection that is sufficiently large, and leave it out of the lemmas’ statements. Note that this lemma, together with completeness and output size properties we argue above, implies Theorem 21 with .
Lemma 22
Let be the output from the reduction in Figure 2 on input . If , then with high probability.
Roughly speaking, the overall strategy of our proof of Lemma 22 is as follows:
First, we will argue that any subtree rooted at any test-selection element must be shallow (of depth ). This means that, if we have a depth- mistake tree, then the first levels must be assigned solely assignment elements. 2. 2.
We then argue that, in this -level mistake tree of assignment elements, we can always extract a leaf such that the path from root to indicates inclusion of a large non-repetitive set. In other words, the path to can be decoded into a (partial) assignment for the Label Cover instance . 3. 3.
Let the leaf from the previous step be and the non-repetitive set be . Our goal now is to show that the subtree rooted as must have small depth. We start working towards this by showing that, with high probability, there are few tests that agree with . This is analogous to Part II of the VC Dimension proof. 4. 4.
With the previous steps in mind, we only need to argue that, when is small, the Littlestone’s dimension of all the concepts that contains (i.e. ) is small. Thanks to Fact 8, it is enough for us to bound and separately. For the former, our technique from the second step also gives us the desired bound; for the latter, we prove that is small by designing an algorithm that provides correct predictions on a constant fraction of the elements in .
Let us now proceed to the details of the proofs.
4.3.1 Part I: Subtree of a Test-Selection Assignment is Shallow
Lemma 23
For any , .
Note that the above lemma implies that, in any mistake tree, the depth of the subtree rooted at any vertex assigned to some is at most . This is because every concept that agrees with the path from the root to must be in , which has depth at most .
- Proof of Lemma 23.
Consider any . Since , we have . Moreover, from Lemma 12, we know that , which implies that . This means that there are only at most choices of . Combined with the fact that there are only choices of , we have . Fact 7 then implies the lemma.
4.3.2 Part II: Deep Mistake Tree Contains a Large Non-Repetitive Set
The goal of this part of the proof is to show that, for mistake tree of of depth slightly less than , there exists a leaf such that the corresponding path from root to indicates an inclusion of a large non-repetitive set; in our notation, this means that we would like to identify a leaf such that is large. Since we will also need a similar bound later in the proof, we will prove the following lemma, which is a generalization of the stated goal that works even for the concept class for any non-repetitive . To get back the desired bound, we can simply set .
Lemma 24
For any non-repetitive set and any depth- mistake tree of , there exists a leaf such that .
The proof of this lemma is a double counting argument where we count a specific class of leaves in two ways, which ultimately leads to the above bound. The leaves that we focus on are the leaves such that, for every such that an -assignment element appears in the path from root to but not in , the first appearance of -assignment element in the path is included. In other words, for every , if we define , then must be equal to . We call these leaves the good leaves. Denote the set of good leaves of by .
Our first way of counting is the following lemma. Informally, it asserts that different good leaves agree with different sets . This can be thought of as an analogue of Lemma 16 in our proof for VC Dimension. Note that this lemma immediately gives an upper bound of on .
Lemma 25
For any depth- mistake tree of and any different good leaves , if agrees with and agrees with for some , then .
- Proof.
Suppose for the sake of contradiction that there exist , such that and agree with and respectively, and . Let be the common ancestor of , i.e., is the longest string in . Assume w.l.o.g. that and . Consider the node in tree where the paths to split; suppose that this is . Therefore .
We now argue that there is some (with the same but a different assignment ) that is in both concepts, i.e. . We do this by considering two cases:
- –
If , then there is for some .
- –
Suppose that . Since is a good leaf, there is some such that for some and is included by the path (i.e. ). This also implies that is in both and .
Now, since both and are in the concept , we have and
[TABLE]
On the other hand, since contains but not , we have and
[TABLE]
which contradicts (4) since .
Next, we will present another counting argument which gives a lower bound on the number of good leaves, which, together with Lemma 25, yields the desired bound.
- Proof of Lemma 24.
For any depth- mistake tree of , let us consider the following procedure which recursively assigns a weight to each node in the tree. At the end of the procedure, all the weight will be propagated from the root to good leaves.
For every non-root node , set . For root , let . 2. 2.
While there is an internal node such that , do the following:
- (a)
Suppose that for some and . 2. (b)
If so far no -element has appeared in the path or in , i.e., , then . Otherwise, set . 3. (c)
Set .
The following observations are immediate from the construction:
- –
The total of ’s over all the tree, always remain .
- –
At the end of the procedure, for every , if and only if .
- –
If , then at the end of the execution.
Note that the last observation comes from the fact that always get divides in half when moving down one level of the tree unless we encounter an -assignment element for some that never appears in the path or in before. For any good leaf , the set of such is exactly the set .
As a result, we have . Since Lemma 25 implies that , we can conclude that there exists such that as desired.
4.3.3 Part III: No Large Non-Repetitive Set Passes Many Test
The main lemma of this subsection is the following, which is analogous to Lemma 18
Lemma 26
If , then, with high probability, for every non-repetitive set of size at least , .
- Proof.
For every , let . For every and every , we say that passes if does not violate any constraint in . Note that this definition and the way the test is generated in the reduction is the same as that of the VC Dimension reduction. Hence, we can apply Lemma 19 with , which implies the following: with high probability, for every of size at least and every , where denote the set of all ’s passed by . Conditioned on this event happening, we will show that, for every non-repetitive set of size at least , .
Consider any non-repetitive set of size . Let be an assignment on such that, for each , we pick one (if there are more than one such ’s, pick one arbitrarily) and let . It is obvious that . Since is non-repetitive and of size at least , we have , which means that as desired.
4.3.4 Part IV: A Subtree Containing Must be Shallow
In this part, we will show that, if we restrict ourselves to only concepts that contain some non-repetitive set that passes few tests, then the Littlestone’s Dimension of this restrictied concept class is small. Therefore when we build a tree for the whole concept class , if a path from root to some node indicates an inclusion of a non-repetitive set that passes few tests, then the subtree rooted at this node must be shallow.
Lemma 27
For every non-repetitive set ,
[TABLE]
We prove the above lemma by bounding and separately, and combining them via Fact 8. First, we can bound easily by applying Lemma 24 coupled with the fact that for every non-repetitive . This immediately gives the following corollary.
Corollary 28
For every non-repetitive set ,
[TABLE]
We will next prove the following bound on . Note that Corollary 28, Lemma 29, and Fact 8 immediately imply Lemma 27.
Lemma 29
For every non-repetitive set ,
[TABLE]
The overall outline of the proof of Lemma 29 is that we will design a prediction algorithm whose mistake bound is at most . Once we design this algorithm, Lemma 6 immediately implies Lemma 29. To define our algorithm, we will need the following lemma, which is a general statement that says that, for a small collection of ’s, there is a some that agrees with almost half of every in the collection.
Lemma 30
Let be any collections of subsets of , there exists such that, for every , where denotes the symmetric difference between two sets.
- Proof.
We use a simple probabilistic method to prove this lemma. Let be a random subset of (i.e. each is included independently with probability 0.5). We will show that, with non-zero probability, for all , which immediately implies that a desired exists.
Fix . Observe that can be written as . For each , is a random variable with mean 0.5 independent of other . Applying Chernoff bound here yields
[TABLE]
Hence, by union bound, we have
[TABLE]
In other words, for all with non-zero probability as desired.
We also need the following observation, which is an analogue of Observation 17 in the VC Dimension proof; it follows immediately from definition of .
Observation 31
If a non-repetitive set is a subset of some concept , then .
With Lemma 30 and Observation 31 in place, we are now ready to prove Lemma 29.
- Proof of Lemma 29.
Let be the set guaranteed by applying Lemma 30 with . Let .
Our prediction algorithm will be very simple: it always predicts according to ; i.e., on an input333We assume w.l.o.g. that input elements are distinct; if an element appears multiple times, we know the correct answer from its first appearance and can always correctly predict it afterwards. , it outputs . Consider any sequence that agrees with a concept . Observe that the number of incorrect predictions of our algorithm is at most .
Since , Observation 31 implies that . This means that . Now, let us consider each . Suppose that . Since , at least elements of are in and, since , we have . This implies that . A similar bound can also be derived when . As a result, we have
[TABLE]
concluding our proof of Lemma 29.
4.3.5 Putting Things Together
- Proof of Lemma 22.
Assume that . From Lemma 26, we know that, with high probability, for every non-repetitive set of size at least . Conditioned on this event, we will show that .
Suppose for the sake of contradiction that . Consider any depth- mistake tree of . From Lemma 23, no test-selection element is assigned to any node in the first levels. In other words, the tree induced by the first levels is simply a mistake tree of . By Lemma 24 with , there exists such that .
Since , there exists a non-repetitive set of size . Consider the subtree rooted at . This is a mistake tree of of depth . Since , we have . However, this implies
[TABLE]
which is a contradiction when is sufficiently large.
5 Conclusion and Open Questions
In this work, we prove inapproximability results for VC Dimension and Littlestone’s Dimension based on the randomized exponential time hypothesis. Our results provide an almost matching running time lower bound of for both problems while ruling out approximation ratios of and for some for VC Dimension and Littlestone’s Dimension respectively. Even though our results help us gain more insights on approximability of both problems, it is not yet completely resolved. More specifically, we are not aware of any constant factor -time approximation algorithm for either problem; it is an intriguing open question whether such algorithm exists and, if not, whether our reduction can be extended to rule out such algorithm. Another potentially interesting research direction is to derandomize our construction; note that the only place in the proof in which the randomness is used is in Lemma 19.
A related question which remains open, originally posed by Ben-David and Eiron [BE98], is that of computing the self-directed learning444Roughly, self-directed learning is similar to the online learning model corresponding to Littlestone’s dimension, but where the learner chooses the order elements; see [BE98] for details. mistake bound. Similarly, it may be interesting to understand the complexity of computing (approximating) the recursive teaching dimension [DFSZ14, MSWY15].
Acknowledgement
We thank Shai Ben-David for suggesting the question of approximability of Littlestone’s dimension, and several other fascinating discussions. We also thank Yishay Mansour and COLT anonymous reviewers for their useful comments.
Pasin Manurangsi is supported by NSF Grants No. CCF 1540685 and CCF 1655215.
Aviad Rubinstein was supported by a Microsoft Research PhD Fellowship, as well as NSF grant CCF1408635 and Templeton Foundation grant 3966. This work was done in part at the Simons Institute for the Theory of Computing.
Appendix A Quasi-polynomial Algorithm for Littlestone’s Dimension
In this section, we provides the following algorithm which decides whether in time . Since we know that , we can run this algorithm for all and compute Littlestone’s Dimension of in quasi-polynomial time.
Theorem 32** (Quasi-polynomial Time Algorithm for Littlestone’s Dimension)**
There is an algorithm that, given a universe , a concept class and a non-negative integer , decides whether in time .
- Proof.
Our algorithm is based on a simple observation: if an element belongs to at least one concept and does not belong to at least one concept, the maximum depth of mistake trees rooted at is exactly . Recall from Section 4 that and denote the collection of concepts that exclude and the collection of concepts that include respectively.
This yields the following natural recursive algorithm. For each such that , recursively run the algorithm on and . If both executions return NO for some , then output NO. Otherwise, output YES. When , there is no need for recursion as we can just check whether .
Finally, we note that the running time can be easily proved by induction on .
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[AGSS 12] Sanjeev Arora, Rong Ge, Sushant Sachdeva, and Grant Schoenebeck. Finding overlapping communities in social networks: toward a rigorous approach. In ACM Conference on Electronic Commerce, EC ’12, Valencia, Spain, June 4-8, 2012 , pages 37–54, 2012.
- 2[AIM 14] Scott Aaronson, Russell Impagliazzo, and Dana Moshkovitz. AM with multiple Merlins. In IEEE 29th Conference on Computational Complexity, CCC 2014, Vancouver, BC, Canada, June 11-13, 2014 , pages 44–55, 2014.
- 3[Bar 15] Siddharth Barman. Approximating Nash equilibria and dense bipartite subgraphs via an approximate version of caratheodory’s theorem. In Proceedings of the Forty-Seventh Annual ACM on Symposium on Theory of Computing, STOC 2015, Portland, OR, USA, June 14-17, 2015 , pages 361–369, 2015.
- 4[BCKS 16] Umang Bhaskar, Yu Cheng, Young Kun Ko, and Chaitanya Swamy. Hardness results for signaling in Bayesian zero-sum and network routing games. In Proceedings of the 2016 ACM Conference on Economics and Computation, EC ’16, Maastricht, The Netherlands, July 24-28, 2016 , pages 479–496, 2016.
- 5[BE 98] Shai Ben-David and Nadav Eiron. Self-directed learning and its relation to the VC-dimension and to teacher-directed learning. Machine Learning , 33(1):87–104, 1998.
- 6[BFS 16] Cristina Bazgan, Florent Foucaud, and Florian Sikora. On the approximability of partial VC dimension. In Combinatorial Optimization and Applications - 10th International Conference, COCOA 2016, Hong Kong, China, December 16-18, 2016, Proceedings , pages 92–106, 2016.
- 7[BKRW 17] Mark Braverman, Young Kun-Ko, Aviad Rubinstein, and Omri Weinstein. ETH hardness for densest- k -subgraph with perfect completeness. In Proceedings of the Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2017, Barcelona, Spain, Hotel Porta Fira, January 16-19 , pages 1326–1341, 2017.
- 8[BKW 15] Mark Braverman, Young Kun-Ko, and Omri Weinstein. Approximating the best Nash equilibrium in n o o {}^{\mbox{o}} (log n ) (log n ) {}^{\mbox{(log \emph{n})}} -time breaks the exponential time hypothesis. In Proceedings of the Twenty-Sixth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2015, San Diego, CA, USA, January 4-6, 2015 , pages 970–982, 2015.
