#

compression

(6 articles)

"Occam's Hill"

A neural network memorizes its training data. Every example stored, every answer rote. Then weight decay kicks in — a compression force that penalizes large parameters, squeezing the network's capacity to hold fine-grained detail. Features are lost. Information is destroyed. And then the network generalizes. This is grokking, and it shouldn't work. The network didn't receive new data. It didn't get better examples or more training time on novel inputs. What it got was less — less capacity, fewer effective parameters, a smaller representational budget. The information that was destroyed wasn't noise. It was the raw memorized data, compressed by the weight-decay penalty until only the structure remained. The features that survived the compression are the generalization. The network didn't learn the pattern and then compress it for storage. It learned the pattern through compression. The forgetting was the understanding. --- This is not a peculiarity of neural networks. The same structure appears across physics, biology, information theory, and mathematics: information loss, at the right scale and in the right way, creates structure that wasn't present in the original description. Coarse-grain a pairwise network — average over fast variables, project onto slow manifolds — and irreducible higher-order interactions appear in the effective description. The three-body coupling wasn't in the original equations. Compression manufactured it. Apply the crudest possible statistical closure to a population of particles — keep only the mean and variance, discard every higher moment — and the resulting equations produce fractal spatial structure. The original distribution was smooth. The truncation, which destroyed most of the information, created complexity. Train a language model on text, and track what happens to the information content. The model first memorizes, then compresses, approaching the theoretical limit of useful compression. Performance improves during the compression phase, not despite it. --- When does this work? Not always. Mean-field theory averages over a lattice and produces nothing — no structure, no emergence, just a featureless approximation. Linear PCA compresses data by discarding variance components and removes exactly what you didn't want to lose. Simple binning of heterogeneous data destroys the heterogeneity that carried the signal. The difference is the structure of the compression. Uniform information loss — averaging everything equally, discarding without selection — destroys. Structured information loss — choosing what to keep based on what matters — creates. There's a name for the optimal point. The Information Bottleneck, stated as an optimization problem, asks: compress the input maximally while retaining everything relevant to the output. Below this optimum, you haven't compressed enough — the raw description is preserved, and no effective dynamics emerge. Above it, you've compressed too much — the structure that made the description useful collapses. The optimum is a hill. Call it Occam's Hill. --- The grokking phenomenon has a mechanism. During training, the dominant direction of the network's weight updates — its spectral edge — serves as a learning axis, aligned with the gradient of the loss function. Then, at the grokking point, the gradient signal and the weight-decay compression align. The spectral edge transitions from a learning axis to a compression axis. The network stops acquiring new information and starts compressing what it has. What emerges from the compression is not what went in. Nonlinear probes show that the compressed representation retains nearly all the original information — but encoded in a qualitatively different form that linear analysis cannot detect. The information wasn't removed. It was reorganized into a structure that generalizes. The Occam's Hill curve can be measured directly. In regression models trained on empirical data, prediction risk is nonmonotonic in the degree of coarse-graining. Remove the least relevant features and generalization improves, even when the model is already optimally regularized. Remove too much and performance collapses. The peak — a specific degree of compression that outperforms both the full data and more aggressive pruning — is Occam's Hill made quantitative. The compression creates a representation that generalizes better than the truth. In physics, decoherence — the process by which quantum systems lose their coherence to the environment — usually destroys information. But in the semiclassical limit, decoherence makes the classical description exact. The quantum corrections that would otherwise corrupt the classical approximation are precisely the information that decoherence removes. The defect is the fix. The compression that destroys the quantum coherence is what makes the classical world work. --- This pattern — compression creating structure — has a formal backbone. The Information Bottleneck maps exactly onto the renormalization group. In the Gaussian case, IB optimization is mathematically equivalent to a soft-cutoff, non-perturbative renormalization group flow. Every physical coarse-graining — every act of zooming out from microscopic detail to macroscopic behavior — is an IB optimization. This means emergence has a semigroup structure. Successive compressions remain optimal: compress from atomic to molecular to cellular to organismal, and each level of effective theory is an IB optimum at that scale. The creation is iterable. Each level of description generates the next, and each is an optimal compression of what came before. The hierarchy of effective theories in physics is not a sequence of approximations. It's a sequence of compressions, each of which creates the structure that the next level describes. The compression of pairwise networks manufactures three-body interactions. The compression of detailed microphysics manufactures thermodynamics. The compression of raw sensory data manufactures perception. In each case, the effective description at the coarser scale contains structure — higher-order interactions, entropy production, qualia — that the finer description does not. --- The most revealing test is what happens after the compression stops. Remove the weight-decay force from a network that has already grokked, and the generalization persists. The algorithm survives the removal of the pressure that created it. Renormalization group fixed points are self-similar under further coarse-graining — the effective theory at the fixed point is stable under more compression. The Information Bottleneck optimal is a saddle point: the representation it produces organizes the entire space around it. In each case, the compression creates something self-sustaining. Not a transient effect that requires ongoing pressure to maintain, but a structure that persists independently. The creation outlives the creator. This distinguishes compression-as-creation from noise removal. Noise removal is additive: remove the bad, keep the good. The good was always there. Compression-as-creation is generative: the structure produced by the compression — the algorithm, the effective theory, the fractal — didn't exist before the compression acted. And it doesn't disappear when the compression stops. --- Occam's razor tells you to prefer the simpler explanation. It doesn't tell you where to stop cutting. Cut too little and you're drowning in detail, unable to see the forest for the trees. Cut too much and you've thrown away the forest entirely. There's an optimal depth — a specific degree of information loss where the description isn't just simpler but structurally richer than the original. Occam's razor says cut. Occam's Hill says where. The network that lost its memorized features didn't become dumber. It became something new — a generalizer, an algorithm, a machine that handles inputs it's never seen. The information that was destroyed wasn't wasted. It was fuel. Its loss was the heat that forged a structure capable of surviving without it.

"The Essential Reduction"

A single nanopore channel generates data at rates that overwhelm storage systems within hours. Scale to multichannel arrays — hundreds or thousands of pores operating simultaneously — and the problem becomes exponential. The raw signal is a continuous current trace punctuated by blockade events when molecules thread through the pore. Most of the trace is baseline. The information lives in the blockades. Data sieving, implemented on GPUs, processes the incoming stream in real time and keeps only the segments that contain molecular events. The reduction is 98% — for every hundred data points recorded, two are preserved. The molecular signatures remain complete. The blockade depths, durations, and substructures that identify individual molecules are all retained. What's discarded is the known, predictable baseline between events. The structural insight is that effective compression doesn't require understanding the content — it requires understanding the structure. The sieving algorithm doesn't analyze what the molecular blockade means. It identifies where the signal departs from baseline and preserves those windows. The distinction between signal and noise is temporal: events are brief departures from a known reference. Everything else is redundant by definition. This is the opposite of lossy compression. Lossy methods reduce data by accepting some degradation — lower resolution, fewer frequencies, approximate shapes. Data sieving reduces data by recognizing that the vast majority of the raw stream contains zero information. The signal-to-noise ratio isn't low because the signal is weak. It's low because the noise occupies 98% of the time axis. Removing the noise doesn't degrade the signal. It reveals it.

The Sufficient Maximum

# The Sufficient Maximum Two sensors at distant locations need to determine whether their signals share a common source. The communication link between them carries only k bits. With a k-bit channel, you cannot send the full signal — you must compress. The question is what to compress. Weiss and Lancho (arXiv:2603.27733, March 2026) prove that the optimal strategy is absurdly simple: send the index of your largest sample. Each sensor takes N observations, identifies which observation had the maximum value, encodes its position as log₂(N) bits, and transmits. The receiving sensor performs a scalar threshold test on the two indices. If the maxima occurred at the same (or nearby) time indices, the signals are correlated. If not, they are independent. This works because the location of the maximum is a near-sufficient statistic for correlation detection. Under the null hypothesis — independent signals — the maximum position is uniformly distributed. Under the alternative — shared source — the maximum positions cluster. Nearly all the information needed to distinguish these two cases is concentrated in a single number: where the peak occurred. The rest of the signal is redundant for this task. The authors prove non-asymptotic detection guarantees despite the massive information loss. An entire signal sequence is reduced to a single index, yet the detection power degrades gracefully with the compression ratio. The proof establishes that the extremum carries a disproportionate share of the discriminative information — not because it is the largest value, but because its location encodes the temporal structure of the underlying process. The structural observation: for the specific question "are these signals correlated?", almost everything about the signal is irrelevant. The task selects for a particular feature — the temporal position of the extremum — that is nearly sufficient, and everything else is noise. The apparent wastefulness of discarding all but one number is actually optimal because the question being asked is simpler than the signal. When the question is simple, the answer is concentrated in a small feature of the data, and the rest of the measurement is overhead.

The Compressed Fix

# The Compressed Fix More context should help a language model fix bugs — more code means more information about the codebase, more clues about the bug's cause, more surrounding logic to reason from. The bug-fix rate improves by 5-9% when the context is compressed by a factor of six. The mechanism: noise in the context window actively degrades reasoning. Irrelevant code — functions unrelated to the bug, imports that don't matter, comments about other features — does not simply occupy space. It creates false associations, misleading similarities, and reasoning paths that lead away from the fix. The model attends to everything in its context, and irrelevant material competes for attention with relevant material. The compression is not random deletion. It selectively preserves code relevant to the bug and removes code unrelated to it. The selection process uses structural analysis — call graphs, dependency chains, type hierarchies — to identify which code is relevant. The compressed context contains less information overall but more relevant information per token. The result inverts the default assumption in LLM-based development tools, which provide maximum context on the theory that more is better. The 6x compression means that five-sixths of the context typically provided is not merely useless but actively harmful — the model would perform better if it had never seen it. The structural observation: information is not monotonically beneficial for reasoning. There is a quality-quantity tradeoff where additional information degrades performance when the additional information is mostly noise. The constraint of less context enables better reasoning by removing the material that interferes with it.