cs.LGOct 27, 2026
SaveOn the VC Dimension of Autoregressive Linear Threshold Functions
Organizations: MIT · The Hebrew University
Abstract
Linear threshold functions (LTFs) are a canonical class of Boolean predictors. In the autoregressive setting, the same LTF reads the most recent bits, generates the next bit, and returns the bit produced after steps. While the one-step class has VC dimension , for general the counting upper bound is . We prove that the VC dimension is for every , resolving the quadratic gap for deterministic autoregressive LTFs. We then adapt the same technique to show an exponential separation between deterministic and stochastic autoregressive models: replacing the sign of LTFs by logistic sampling can increase the VC dimension of the final majority prediction class from quadratic to exponential in .
Figures & tables
Figure 1: One round of the recursion for , selected row , and encoding , from to . Within each region (Row, Test, Output, Pointer), coordinates are ordered by increasing . The row bits remain unchanged. The current output bits encode , and the pointer selects position , whose weight is . Since , the new test bit is , so the third output bit is set to , while all other output bits remain unchanged. Finally, the pointer shifts from position to position , selecting the next digit to test.
Figure 2: Transition from to for , , and . The black is the first bit of each block, fixed to by the definition of the encoding in ( 15 ). The same LTF generates all bits of from left to right. The row bits remain unchanged. The output bits initially represent , and the pointer selects , with weight . Since , the new test bit is . As the lower arrow indicates, this new test bit sets the third output bit to , so the output bits now represent . The pointer changes to . Test, output, and pointer bits are each stored twice in adjacent positions. Unmarked positions are zero; spacing is schematic.
Figure 3: Choosing inputs for a fixed row . The three rows correspond to columns ; each repeats the same string on the left. Each blue frame selects consecutive bits, forming . The short arrows show the shift from the start of the string to the start of each input. The long arrows represent generated bits. The blue cell is at position in the later block and equals . Since and are independent of the labels, so are the selected inputs. Shown for a multiple of ; spacing is schematic.
We prove that, in the realizable PAC setting, the sample complexity of exact-trace learning for full autoregressive Chain-of-Thought traces is upper bounded by the standard multiclass rate of the local next-token class, where this rate is governed by the Daniely--Shalev-Shwartz dimension. Under exact-trace loss, one wrong action makes the whole trace incorrect; nevertheless, for every stopping rule and every pointwise -halting local class , , with no dependence on rollout length. The dependence on is worst-case optimal, since one-step stopping recovers ordinary multiclass learning of . The proof introduces parity dimension, a rollout-stable refinement of DS dimension based on even pseudo-cubes. It controls one-inclusion density via a low-coordinate spanning theorem on finite restrictions and, unlike DS dimension itself, does not increase under autoregressive rollout. We also show why this detour is necessary: DS dimension can increase under rollout.
Contradiction Graphs Determine VC Dimension
We study the contradiction graphs associated with binary concept classes. For a class , the order- contradiction graph has as vertices the -realizable labeled sequences of length , with two vertices adjacent when the two sequences assign opposite labels to some common domain point. Our main result is that the single graph determines the threshold predicate . Consequently, the full sequence determines the exact VC dimension and, in particular, detects finite versus infinite VC dimension, answering a question posed by Alon et al. (2024).
Bagging Robustly Learns VC Classes with Linear Sample Complexity
We revisit the problem of learning predictors robust to adversarial examples at test-time. We prove that VC classes are adversarially robustly learnable with sample complexity linear in the VC dimension , providing an exponential improvement over the previous upper bound of Montasser, Hanneke, and Srebro (2019). Remarkably, this result is achieved with a simple improper algorithm that combines the classic heuristic bagging (bootstrap aggregation) of Breiman (1996) with robust empirical risk minimization (RERM). Our algorithm computes RERMs on independent bootstrap samples and outputs their majority vote, where denotes the dual VC dimension. We complement this result with a lower bound showing that this is unavoidable: in general, any learner in this oracle model requires calls to an RERM oracle, even when given arbitrarily many training examples.