Free Decompression (FD) Overview

• Free Decompression (FD) is a concept that avoids complete data reconstruction by using local context, partial decompression, or algebraic methods across various domains.
• In gzip/DEFLATE research, FD enables random access and parallel decoding by leveraging known block boundaries and exponential decay of uncertainty via literals.
• Across systems and spectral estimation, FD principles allow direct computation on compressed or partially reconstructed representations, improving efficiency and throughput.

Free Decompression (FD) is a context-dependent technical term used in several research literatures to denote methods that eliminate, localize, reverse, or bypass conventional decompression. In gzip/DEFLATE research, FD denotes decompression from an arbitrary compressed position once a block boundary and sufficient local context are available. In random matrix theory, FD is the inverse of free compression: a spectral extrapolation procedure that infers the empirical spectral density of a large Hermitian matrix from the spectrum of a smaller randomly sampled principal submatrix. In systems work, closely related ideas appear as compression without decompression for read-only arrays, decompression-free KV-cache compression, and analytics on partially decompressed scientific data. A further, explicitly FD-like systems principle appears in GPU decompression, where compute resources are freed for additional parallel decoding work instead of being spent on specialized latency-hiding roles (Kerbiriou et al., 2019, Ameli et al., 13 Jun 2025, Görzig, 2014, S et al., 24 Nov 2025, Wu et al., 26 Mar 2026, Park et al., 2023).

1. Terminological scope and domain-specific meanings

The term FD is not used uniformly across the cited literature. In the gzip work of Bonfield and Mahoney, FD is tied to random access and parallel decompression for DEFLATE streams, with the central question being whether one can decompress from a compressed suffix using only local information rather than a full prefix scan (Kerbiriou et al., 2019). In the spectral-estimation literature, FD denotes a free-probability operation that reverses free compression and thereby extrapolates spectral laws across matrix sizes (Ameli et al., 13 Jun 2025). In SWAN, the phrase “decompression-free (FD)” refers to KV-cache compression in which attention is computed directly on the compressed sparse representation rather than on a reconstructed dense cache (S et al., 24 Nov 2025).

A closely related but not formally identical usage appears in “Data Compaction - Compression without Decompression,” where the compressed representation is itself the usable data structure for read-only arrays, so no decompression routine is needed at runtime (Görzig, 2014). In CODAG, the paper does not define FD as a formal term, but the details explicitly characterize the design as embodying an “FD-like” principle: free compute resources for more parallel decoding work rather than for orchestration and prefetch specialization (Park et al., 2023). This suggests that, in systems contexts, FD often names an architectural objective—direct usability of compressed or partially decompressed state—rather than a single algorithmic template.

The term also has unrelated meanings outside computing. In the magma-vesiculation paper, “free decompression (FD)” means decompression at approximately constant temperature during pressure drop, and the scientific question concerns nucleation and growth versus spinodal decomposition under that thermodynamic regime (Nishiwaki, 2024). In logic programming, by contrast, clp(FD) means Constraint Logic Programming over Finite Domains; here FD stands for Finite Domains rather than Free Decompression (Arias et al., 2013). Any encyclopedia treatment therefore requires explicit disambiguation.

2. FD in DEFLATE and gzip: local context, random access, and exact parallelism

In the gzip/DEFLATE setting, FD is defined against the sequential dependence structure of DEFLATE. The relevant state is a 32 KiB sliding context, and Huffman coding is reset at every block boundary. Bonfield and Mahoney formalize decompression as $decompress(C,w)$, where $C$ is the compressed stream and $w$ is the circular buffer of prior output. To start decoding at an arbitrary point, one needs the start of the next DEFLATE block and the full 32 KiB context immediately preceding it. The associated random-access problem is: given a compressed suffix $C$, find the smallest position $i$ and a context $w$ such that $decompress(C[i\ldots], w)$ returns a suffix of the original string (Kerbiriou et al., 2019).

The paper’s key conceptual device is the use of undetermined symbols in the missing context. If a match copies a character that is still undetermined, the uncertainty propagates forward; if enough literals are emitted, dependence on the unknown initial context eventually disappears. The paper models this via the recurrence

$$L_{i+1}= \frac{E^\ell + (W-E^\ell)L_i}{W}=L_1+(1-L_1)L_i=1-(1-L_1)^{i+1},$$

so that the undetermined fraction decays exponentially as

$1-L_i=(1-L_1)^i.$

This provides the formal explanation for why FD can work on some files but not others: exact random access is feasible when literals appear often enough to wash out the unknown initial 32 KiB state.

The empirical results in the paper show strong dependence on compression level and file structure. For random DNA, at default and level $-4$, the unknown characters vanish after decompressing around $C$0 KB from block 2; at level $C$1, uncertainty also eventually vanishes, but only after much more decompression; at levels $C$2 to $C$3, the suffix may be encoded almost entirely using matches, with essentially no literals, so exact random access may fail. For FASTQ-like synthetic data, all DNA characters eventually become literals even at the lowest compression level, although the distance required may still be long. The practical implication is that FD is feasible mainly when compression behavior and file structure cause literals to appear sufficiently often.

The same paper contributes an exact whole-file parallel decompressor, pugz, which resolves the dependency problem by a two-pass scheme rather than by heuristic guessing. Block starts are found by searching from every bit position and enforcing strict validity checks, including valid block-type codes, valid dynamic Huffman-tree encodings, an ASCII output constraint, no back-reference offset beyond 32 KiB, and a decompressed block size between 1 KiB and 4 MiB; a block start is typically found in roughly 100–300 ms. In the first pass, the stream is split at block boundaries into $C$4, and each thread decompresses its chunk against a symbolic context $C$5, tracing dependencies back to unique symbols instead of unknown bytes. The last 32 KiB of $C$6 becomes $C$7 for the next chunk; the second pass then resolves remaining symbols in parallel, yielding exact output. On large FASTQ files, the reported throughputs are 37 MB/s for gunzip, 118 MB/s for libdeflate, and 611 MB/s for pugz with 32 threads, corresponding to about 16.5× speedup over gunzip and 5.2× over libdeflate (Kerbiriou et al., 2019).

3. Decompression-free representations and partial decompression in systems

One major systems interpretation of FD is that the compressed representation should itself be directly usable. In “Data Compaction - Compression without Decompression,” this is achieved for read-only array data by transforming arrays into one-dimensional byte sequences, compacting them into a single one-dimensional byte array using overlap-based heuristics related to the shortest superstring problem, and then replacing the original arrays with pointers into the compacted byte array (Görzig, 2014). The method explicitly claims that no decompression routine is needed at runtime, no source-code changes are required for data access, and the approach can be integrated into the compiler toolchain. Direct array-style access is preserved by pointer redirection and offsets rather than by reconstructing the original data into a separate buffer.

The same direct-use principle is carried into transformer inference by SWAN. SWAN rotates KV vectors into an orthogonal basis derived offline by SVD, prunes low-magnitude coordinates, stores the result in sparse form, and performs attention directly on the compressed sparse cache without explicit reconstruction. For query/key groups and value/output groups, the paper forms joint activation matrices, computes the SVD, and uses the right singular vectors as orthogonal projection matrices. Because orthogonal rotation preserves inner products, the attention scores are unchanged before pruning:

$C$8

Historical keys and values are then sparsified by retaining only the top-magnitude coordinates, while a small dense buffer stores recent tokens. Attention is computed directly as

$C$9

The paper reports that SWAN, with a small dense buffer, maintains performance close to the uncompressed baseline even at aggressive 50–60% per-token memory savings on KV-cache, that retaining 75% of dimensions gives negligible degradation, that retaining 50% still gives strong average performance, and that zero-buffer variants collapse on GSM8K and LongBench. For Llama-3.1-8B-Instruct, the reported average performance is 0.671 at baseline, 0.668 at retention ratio 0.75, and 0.625 at 0.5 (S et al., 24 Nov 2025).

A third systems realization appears in HSZ, a framework for error-controlled lossy scientific compression with multi-stage partial decompression. Instead of always decompressing compressed scientific data to floating-point values, HSZ exposes intermediate representations and pairs them with homomorphic analytical operators. The paper models latency as

$w$0

and replaces full decompression by

$w$1

The decompression ladder consists of metadata $w$2, decorrelated integers $w$3, quantized integers $w$4, and fully decompressed floating-point values $w$5. Mean and standard deviation, derivatives and Laplacians, and divergence and curl are all rewritten so that they can be evaluated on intermediate states. The reported results include over 2400 GB/s mean throughput for HSZx-m; on ND data, HSZx-nd-m improves mean throughput by up to 263×, 3079×, 7315×, and 1676× over SZOps on different datasets; for numerical differentiation, HSZp-q gets 1.89× over SZp and HSZx-q gets 1.71× over SZx on JHTDB; and for curl under error bound $w$6, HSZp-nd-p achieves around 2.68× over HSZp-nd-f in reported cases (Wu et al., 26 Mar 2026).

Across these systems papers, FD denotes a common structural move: the runtime consumer operates on compacted, sparse, quantized, or otherwise intermediate state rather than requiring a fully reconstructed dense representation first.

4. FD-like principles in GPU decompression

CODAG addresses GPU decompression from a different angle. Prior GPU designs assumed decompression was memory-bound and therefore assigned many threads to prefetching, buffering, broadcasting, and synchronized output writing in order to hide memory latency. CODAG’s profiling argues that this premise is mistaken for modern GPUs and practical decompression kernels: most threads end up waiting for a small number of leader decoding threads, so compute latency and synchronization latency are exposed instead of hidden (Park et al., 2023).

The paper’s baseline description is explicit. A compressed chunk is assigned to a thread block; one leader thread performs the serial decode; a prefetching warp moves compressed data into shared memory; and the remaining threads wait at block-wide barriers before collaboratively writing output. During SM stall cycles, up to 80% of threads can be waiting on a barrier. For Deflate, the baseline measures less than 25% memory bandwidth utilization and exhibits significant ALU, FMA, and load/store activity, indicating that compute latency and barrier stalls, rather than memory bandwidth, dominate execution.

CODAG’s response is “warp-level decompression.” Each warp, rather than each thread block, handles one compressed chunk, and all 32 threads in the warp execute the same serial decoding logic on that chunk. Specialized prefetch warps are removed, block-level broadcast and synchronization are eliminated, and the resulting freed execution resources are used to run more decompression streams concurrently. The decomposition kernel is expressed through three recurring operations—sequential decoding, coalesced on-demand reading, and coalesced on-demand writing—and the paper provides APIs such as input_stream::fetch_bits(int n), input_stream::peek_bits(int n), output_stream::write_byte(int8_t b), output_stream::write_run(T init, size_t len, T delta), and output_stream::memcpy(int off, int len).

A notable design point is CODAG’s “all-thread decoding” strategy. Every thread in the warp executes the same serial decoding logic on the same chunk rather than relying on a single leader and then broadcasting results. The paper reports that the compute throughput difference between single-thread decoding and all-thread decoding is at most 0.1%, so the arithmetic redundancy does not materially reduce performance. The throughput results on A100 are 38.07 GB/s for RLE v1, 26.87 GB/s for RLE v2, and 51.96 GB/s for Deflate, compared with RAPIDS baselines of 2.83 GB/s, 4.72 GB/s, and 44.18 GB/s, corresponding to speedups of 13.46×, 5.69×, and 1.18×, respectively. An ablation with a prefetch warp still improves over RAPIDS but remains worse than CODAG’s one-warp design, because manual prefetching consumes resources better used for decoding (Park et al., 2023).

CODAG does not formalize FD as a term of art, but the details explicitly identify its relevance to FD as a “free compute for more parallel work” principle. A plausible implication is that, in throughput-oriented decompression systems, FD can describe not only elimination of reconstruction but also the elimination of orchestration overhead that prevents the machine from exposing enough simultaneously running decoding threads.

5. FD as spectral extrapolation: from free compression to algebraic spectral curves

In spectral estimation, FD has a mathematically distinct meaning. The 2025 paper “Spectral Estimation with Free Decompression” defines FD for impalpable Hermitian matrices: matrices so large or inaccessible that one cannot form them, cannot multiply by them, and may observe only small randomly sampled principal submatrices (Ameli et al., 13 Jun 2025). The objective is to infer the full empirical spectral density of the large matrix from the spectrum of a much smaller observed submatrix. The core free-probability relation is the Nica–Speicher free-compression scaling of the $w$7-transform:

$w$8

The practical implementation works through the Stieltjes transform rather than explicit $w$9-transforms, using a PDE in decompression time and solving it by characteristics. Because naive empirical Stieltjes transforms have poles and cannot be analytically continued across the support in a straightforward way, the method constructs a secondary analytic branch via a gluing function approximated by a rational Padé ansatz. Density estimation uses Jacobi or Chebyshev expansions with Jackson damping, Tikhonov regularization, and positivity and unit-mass constraints.

The 2025 paper validates FD on the Wigner semicircle law, Marchenko–Pastur law, Kesten–McKay law, Wachter law, and the free Meixner family, and then on real datasets including the SNAP Facebook Page-Page network and an empirical NTK from a ResNet-50 trained on CIFAR-10. In one Marchenko–Pastur setting, starting from $C$0 and $C$1, FD extrapolates to $C$2 with average total variation distance around 0.2%, Jensen–Shannon divergence around 1.867%, and log-determinant relative error around 1.78%. For the NTK example, reported errors remain small, with total variation roughly 1%–3%, Jensen–Shannon roughly 3%–6%, and first/second moment errors below about 2.5% (Ameli et al., 13 Jun 2025).

The 2026 paper “Free Decompression with Algebraic Spectral Curves” generalizes this framework beyond the earlier single-bulk setting (Ameli et al., 5 May 2026). Its central assumption is that the Stieltjes transform is algebraic:

$C$3

for a nonzero bivariate polynomial $C$4. The spectrum is then represented by the algebraic spectral curve

$C$5

Under free decompression by factor $C$6, the decompressed Stieltjes transform $C$7 satisfies

$C$8

This reparameterizes FD as evolution on a spectral curve rather than as direct PDE evolution of a single branch. The method uses predictor-corrector continuation on the curve for physical-branch selection, exploiting the Herglotz property and the normalization $C$9 at infinity.

The algebraic-curve framework is designed for spectra with multiple disconnected bulks, multiple scales, and atoms. Real branch points determine spectral edges; cusp conditions characterize bulk merging and splitting; and atoms correspond to simple poles of $i$0, with fixed location under decompression and mass evolving as

$i$1

The paper demonstrates these mechanisms on compound free Poisson models, the Pennington–Bahri Hessian model, a two-layer network Hessian on CIFAR-10-like data, and activation matrices from a large-scale diffusion model. It reports accurate predictions for matrices as large as 32,768 or 64,000, starting from 4,000-size samples, and describes successful tracking of multi-bulk, multi-scale structure, atom-like bulks, cusp events, and spectral edges over many decades (Ameli et al., 5 May 2026).

6. Limits, misconceptions, and adjacent debates

A recurrent misconception is that FD means universal decompression without prerequisites. The gzip literature explicitly rejects that view. Exact FD from a random location is feasible only when the stream sheds dependence on unknown prior context quickly enough; at random-DNA compression levels $i$2 to $i$3, exact random access may fail because the suffix can be encoded almost entirely using matches. Exact whole-file parallel decompression remains possible, but only through block-boundary identification and explicit dependency propagation and resolution (Kerbiriou et al., 2019).

A second misconception is that decompression-free operation implies zero approximation cost or zero auxiliary structure. SWAN requires runtime query/key rotation because RoPE does not commute with arbitrary rotation, and its quality depends critically on the small dense buffer; the paper reports severe or catastrophic degradation when the buffer is zero. HSZ likewise does not eliminate full decompression universally: some operations require $i$4 or $i$5, the best stage depends on the compressor and operation, and the framework is compressor-dependent because homomorphic operators must be derived for specific decorrelation models (S et al., 24 Nov 2025, Wu et al., 26 Mar 2026).

A third misconception is that any high-throughput decompressor embodies FD in the strict sense. CODAG is better described as FD-like. The paper’s own synthesis is that it “operationalizes a ‘free compute for more parallel work’ principle,” not that it removes reconstruction entirely. Its contribution is to reallocate execution resources from prefetching and synchronization into additional concurrently active decoding warps, thereby shifting decompression from a latency-bound regime toward a compute-bound one (Park et al., 2023).

The magma literature provides an instructive non-computing contrast. There, FD means decompression-induced vesiculation at approximately constant temperature, and the controversy concerns whether phase separation proceeds by nucleation and growth or by spinodal decomposition. Nishiwaki’s thermodynamic analysis treats hydrous magma as a two-component symmetric regular solution and concludes that the spinodal curve lies far below the binodal curve in the relevant pressure range. At $i$6, the representative values are $i$7 MPa and $i$8 MPa for phonolitic melt, $i$9 MPa and $w$0 MPa for basaltic melt, and $w$1 MPa and $w$2 MPa for albite melt. The final pressures of prior decompression experiments fall between the binodal and spinodal curves, leading to the conclusion that decompression-induced vesiculation in the continental crust is better understood as nucleation followed by growth rather than spinodal decomposition (Nishiwaki, 2024). This use of FD is unrelated to computational decompression, but it illustrates the importance of domain-specific interpretation.

Finally, clp(FD) in Prolog is a separate terminological lineage altogether. In the Ciao library paper, FD denotes Finite Domains, with FD variables represented by ranges, propagation chains, and higher-level constraints built from indexicals. The shared acronym does not indicate any conceptual connection to free decompression in compression, storage, or spectral estimation (Arias et al., 2013).

Across these literatures, FD is best understood not as a single method but as a recurring research motif: avoid reconstructing what need not be reconstructed, expose only the local or algebraically sufficient state, and push useful computation as close as possible to the compressed, partial, or reduced representation.