Lossless Tensor Compression as Program Synthesis

Lossless Tensor Compression as Program Synthesis Jieke Shi1 , Junda He1 , Wenjia Jiang1 , Weifeng Sun1 , Shidong Pan2 , Zhensu Sun1 , Chengran Yang1 , Peixin Zhang3 , Yifan Jia3 , Zhou Yang4 , Thong Hoang (James)2 , Xiwei (Sherry) Xu2 , Zhenchang Xing2 , David Lo1 1 Singapore Management University, Singapore

3 AIDX TECH PTE LTD, Singapore

2 CSIRO, Australia

4 University of Alberta & Alberta Machine Intelligence Institute, Canada

arXiv:2608.02162v1 [cs.SE] 3 Aug 2026

Model checkpoints are growing in both number and size, which makes archival, transfer, and deployment increasingly costly. General-purpose compressors can reduce storage requirements but ignore tensor structure, whereas existing tensor-specific compressors rely on fixed and format-specific pipelines. We present Brevis, which formulates lossless tensor compression as program synthesis. We design a typed domain-specific language (DSL) that captures recurring tensor structures, such as repeated regions and floating-point fields, through a set of reversible operators. Given a tensor, Brevis synthesizes a self-contained DSL program that reconstructs it bit-exactly. A checkpoint-specific production prior, learned from a small representative sample of tensors, guides a bounded A* search to synthesize compact programs, which can later be executed directly for bit-exact decompression. On 10 public checkpoints spanning language, audio, and image generation models, Brevis reduces 2.13 TB of checkpoint data to 1.41 TB, a 33.93% storage reduction. It produces archives up to 30.87% smaller than those of four general-purpose compressors, including zstd and gzip, and smaller archives than the tensor-specific compressors ZipNN and DFloat11. Under a practical concurrency configuration, Brevis achieves 3.60 GB/s compression and 6.61 GB/s decompression while preserving every source byte.

1

Introduction

As large language models (LLMs) become increasingly capable and widely used, the number of publicly-available model repositories continues to grow rapidly. As shown in Figure 1(a), Hugging Face has grown from 425 publicly listed model repositories in April 2020 to 2.95 million today, hosting more than 15 petabytes (PB) of data [Fahlgren 2026; Wang et al. 2026]. Each repository may contain multiple large tensor checkpoints or revisions that are replicated across model hubs, storage systems, and deployment clusters. As model repositories continue to proliferate, the cost of archival, transfer, and deployment grows accordingly, making efficient compression increasingly important. Model compression can be broadly divided into lossy and lossless approaches. Lossy methods, such as quantization and pruning, reduce model size by modifying or discarding weight information [Frantar et al. 2023; Lin et al. 2024; Xu

1M

2.95M

100K 10K 1K

425

2020

2022

Year

2024

(a) Repository growth

2026

Compression (GB/s)

Abstract

Model Repositories

{jiekeshi,jundahe.2022,wjjiang,wfsun,zssun,cryang.2021,pxzhang,davidlo}@smu.edu.sg shidong.pan@anu.edu.au; {James.Hoang,Xiwei.Xu,Zhenchang.Xing}@csiro.au yifan.jia@aidxtech.com; zy25@ualberta.ca Snappy

6

ter

bet

4 2 0

Brevis

gzip

ZipNN

LZ4 zstd

0

10

20

30

Storage Reduction (%)

(b) Compression tradeoff

Figure 1. Growth in public model repositories and the compression tradeoff. (a) Hugging Face repositories (log scale). (b) Storage reduction versus compression throughput. et al. 2025]. They are designed for efficient inference and often require specific numerical formats (e.g., GGUF [Gerganov 2026]) or execution environments, making them unsuitable for archival or exact checkpoint transfer because the original weights cannot be recovered bit exactly. In contrast, lossless compression preserves every source bit while reducing checkpoint size. General-purpose compressors, such as gzip and Zstandard (zstd), are widely used for storage and transmission but treat tensor weights as generic byte sequences, ignoring tensor-specific information such as dtypes, shapes, floating-point layouts, and relationships among elements. Model-specific compressors exploit common properties of floating-point tensors, such as redundancy in exponent fields [Hershcovitch et al. 2025; Zhang et al. 2025], while scientific-data compressors combine predefined transformations and codecs for floating-point arrays [Burtscher et al. 2016; Claggett et al. 2018; Rodriguez et al. 2024]. Although effective, these methods rely on fixed compression schemes or predefined pipelines, which may fail to capture tensor-specific patterns such as repeated values, recurring subsequences, and simple relationships among elements. This limitation raises a natural question: rather than selecting a fixed compression scheme or predefined pipeline, can we synthesize a compact program that directly represents a tensor? Such a program serves as the compressed representation and can be executed to reconstruct the original tensor bit exactly. Since each tensor can use a different program, this formulation can capture tensor-specific structures. Realizing this idea introduces three challenges. First, the language must express diverse tensor structures while guaranteeing bit-exact reconstruction. Second, the program space is large,

Jieke Shi et al.

so the search must efficiently discover compact programs within a practical budget. Third, self-contained programs must remain compact despite the overhead of storing instructions, parameters, and literals required for reconstruction. We present Brevis, which addresses these challenges with a typed domain-specific language (DSL) whose reversible operators capture recurring tensor structures, including repeated values, subsequences, element relations, and floatingpoint fields, while exact literals provide a fallback for values that cannot be represented more compactly. During compression, Brevis learns a checkpoint-specific production prior, i.e., a probability distribution over DSL productions, from a small representative sample of tensors. This prior guides a novel bounded A* search that prioritizes promising program expansions and explores the search space within a search budget. Each complete candidate is evaluated by its exact serialized size, and the smallest synthesized program is selected for storage. During decompression, the synthesized program is executed directly for high-throughput bit-exact reconstruction, without requiring search or the learned prior. We evaluate Brevis on 10 public checkpoints spanning language, audio, and image generation models, three floatingpoint formats, 420 shards, and 2.13 TB of checkpoint data. Brevis produces the smallest archive on all 10 checkpoints against six baselines, reducing archive size by 12.94%-30.87% on average relative to four general-purpose compressors. Compared with the tensor-specific baselines ZipNN and DFloat11, Brevis produces archives up to 2.90% smaller and saves 10.53 GB in total. The improvements over all paired baselines remain statistically significant after Holm correction (𝑝 H = 0.0098, 𝑟 rb = 1.0). Figure 1(b) shows the storagethroughput tradeoff, where Brevis reaches 3.60 GB/s compression and 6.61 GB/s decompression while lying on the Pareto frontier. This paper makes the following contributions:

• We formulate bit-exact checkpoint compression as program synthesis, where each tensor is represented by a compact, self-contained DSL program that reconstructs the original tensor exactly. • We design a typed domain-specific language (DSL) with reversible operators that capture recurring tensor structures and element relationships. • We develop a bounded A* synthesis algorithm guided by a checkpoint-specific production prior learned from a small representative sample of tensors. • We evaluate Brevis on 10 public checkpoints totaling 2.13 TB of checkpoint data. Brevis significantly outperforms six baselines, producing the smallest archive on every checkpoint and reducing archive size by up to 30.87% over existing compressors.

2

Background and Related Work

2.1

Lossless Compression

Given a tensor 𝑋 and archive 𝑐, lossless compression requires Decompress(𝑐) =bit 𝑋,

Reduction(𝑋, 𝑐) = 1 −

|𝑐 | , (1) |𝑋 |

where =bit denotes bitwise equality and |𝑐 | includes all data and metadata required for reconstruction. General-purpose codecs, such as gzip and Zstandard, combine dictionary matching, reversible transforms, and entropy coding but treat tensors as generic byte streams [Collet and Kucherawy 2021; Deutsch 1996]. Float-aware preprocessing further exploits numerical structure through Bitshuffle, Typed Data Transformation (TDT), and ALP [Afroozeh et al. 2023; Jamalidinan and Cheshmi 2025; Masui et al. 2015]. These methods improve compression through fixed transformations or predefined codec families. Model-specific compressors exploit statistical properties of learned weights. ZipNN rearranges floating-point fields before lossless coding [Hershcovitch et al. 2025]; DFloat11, ECF8, and ZipMoE target exponent distributions or modelspecific layouts [Wang et al. 2026; Yang et al. 2026c,b; Zhang et al. 2025]; Huff-LLM and tile-aligned ANS integrate entropy coding with efficient inference [Tan et al. 2026; Yubeaton et al. 2025]; ZipServ, DFloat11, and ENEC further co-design representations with hardware decoders [Fan et al. 2026; Yang et al. 2026a; Zhang et al. 2025]. In contrast, Brevis targets bit-exact archival by synthesizing a self-contained tensor program rather than selecting a predefined codec or hardware-specific representation. 2.2

Lossy Tensor and Model Compression

Lossy compression trades information for storage or execution efficiency. Quantization and pruning reduce model size by modifying weights [Frantar et al. 2023; Lin et al. 2024]; LLM.265 repurposes video codecs for tensors [Xu et al. 2025]; and NeuZip studies lossless training with near-lossless inference [Hao et al. 2024]. These methods target inference efficiency rather than exact reconstruction, whereas Brevis focuses on bit-exact checkpoint archival. 2.3

Program Synthesis

Program synthesis searches a program space P for a program that satisfies a specification 𝜙 while minimizing a cost function Cost: 𝑃 ∗ ∈ arg min Cost(𝑃) 𝑃∈P

s.t. 𝜙 (𝑃, 𝑋 ).

(2)

Syntax-guided synthesis restricts the search space with a grammar, while probability-guided methods prioritize likely productions [Alur et al. 2013]. PHOG, Euphony, and TFCoder learn production probabilities or operation priors to accelerate search [Bielik et al. 2016; Lee et al. 2018; Shi et al.

Lossless Tensor Compression as Program Synthesis synthesise

Bits(𝑋 )

the tensor as it sits on disk

1

Where the redundancy is values

+1

−1

+1

−1

+1

2

Lit

1

Repeat

exponent 8b

127 127 127 127 127 127

Const

fraction 23b

0

Const

0

1

0

1

0

Bits(𝑋 ′ ) = Bits(𝑋 ) every bit, not a tolerance

A program is synthesised, not chosen

3

Decoding is execution

Target-directed 𝐴∗ : a production is admitted only when its decomposition recomposes the hole’s exact target.

−1

the same bits, read as ieee 754 fields

sign 1b

execute

𝑃 a short reversible program

Const

Concat

Repeat

Map

Scan

Exec(𝑃 )

Merge

+1

𝑃 = Mergefp32 Repeat3 (Lit1 (0, 1) ),
Const8 (127), Const23 (0)

0

0

0

0

Each field is regular in its own way, so no single codec catches all three.

structure

parameters

literals

+1

−1

+1

−1

BIT-EXACT

signed zeros and nan payloads survive too

Ranked by the complete serialized size 𝐿 (𝑃 ), not by structure alone: 0

−1

tables

Lit alone offers four physical encodings, picked by measured bytes.

No search at decode: the decoder validates 𝑃 against the stored shape, then runs it.

Figure 2. Compression as program synthesis in Brevis. Each tensor is represented by a short reversible program whose execution regenerates its bits exactly. (1) Read as IEEE 754 fields, 6 FP32 words expose 3 different regularities, and no single codec captures all of them. (2) Target-guided 𝐴∗ searches the typed grammar and ranks candidates by the complete serialized size 𝐿(𝑃), which includes the literal payload and codec tables rather than the program structure. (3) Decoding validates 𝑃 and executes it without search and without the learned prior; a universal Lit fallback keeps every supported tensor representable. 2022], and the KoLMogorov Test studies exact sequence generation through synthesized programs [Yoran et al. 2025]. Compression systems have also synthesized floating-point algorithms or searched transformation pipelines, including OpenZL’s graph-based framework [Burtscher et al. 2016; Claggett et al. 2018; Collet et al. 2025; Rodriguez et al. 2024]. Unlike these approaches, Brevis formulates tensor compression itself as program synthesis: the DSL defines the search space, exact reconstruction defines correctness, serialized program size defines the objective, and a checkpoint-specific prior guides bounded A* search.

3

Method

3.1

Overview and Problem Formulation

Brevis represents each tensor as a typed, self-contained program whose execution reconstructs the original bits. Figure 2 summarizes the workflow. During compression, Brevis learns a checkpoint-specific production prior, i.e., a probability distribution over DSL productions, from a small deterministic sample of tensors. This prior guides bounded A* synthesis over a tensor-oriented grammar, while exact serialized size determines the selected program. Reversible operators expose repeated regions, element relationships, and low-entropy floating-point fields, while literal codecs encode the remaining streams. During decompression, the synthesized program is validated and executed directly without search or the learned prior. Let tensor 𝑋 have dtype 𝑑, shape s, and 𝑛 elements. If 𝑏 (𝑑) is the physical width of 𝑑, Brevis flattens 𝑋 in checkpoint

order into W𝑏 = {0, . . . , 2𝑏 − 1}.

x = Bits(𝑋 ) ∈ W𝑏𝑛 (𝑑 ) ,

(3)

This representation preserves signed zeros, NaN payloads, and every other bit pattern. We write 𝑃 : 𝑏 [𝑛] when program 𝑃 produces 𝑛 words of width 𝑏, and Exec(𝑃) for its output. Program 𝑃 represents 𝑋 exactly when (4)

Exec(𝑃) = Bits(𝑋 ).

The type 𝑏 [𝑛] allows both the synthesizer and decoder to reject incompatible widths and lengths. The canonical encoding of 𝑃 contains its operation tags, parameters, literal coding tables, lengths, and payloads. Let 𝐿(𝑃) denote the byte length of this complete representation. Given expansion budget 𝐵, Brevis selects 𝑃bx = arg min 𝐿(𝑃) 𝑃 ∈ C𝐵 (x)

subject to

Exec(𝑃) = x,

(5)

where C𝐵 (x) contains the initial literal program and all complete candidates found within the budget. The literal fallback makes C𝐵 (x) nonempty, while the equality constraint excludes inexact programs. Thus, Brevis minimizes exact serialized size within the configured finite search space without claiming global optimality. 3.2

Typed Tensor Language

Figure 3 presents the seven DSL operators and their wellformedness rules. Each synthesis hole carries both a type 𝑏 [𝑛] and the exact stream that its completed subprogram must generate. Grammar rules may therefore introduce only type-compatible children, and the decoder independently validates the same widths, lengths, arities, and parameters.

Jieke Shi et al.

(a) Abstract Syntax Types and records 𝜏 ::= 𝑏 [𝑛],

Programs 𝑃 ::= lit𝑏 (v) | const𝑏,𝑛 (𝑣) | concat(𝑃1, . . . , 𝑃𝑘 )

𝐴 ::= ⟨𝑑, s, 𝑃⟩.

| repeat𝑘 (𝑃) | map𝑢,𝜃 (𝑃) | scan𝑞,𝜃 (𝑣 0, 𝑃) | merge 𝑓 ,𝜃 (𝑃1, . . . , 𝑃𝑘 ). (b) Well-Formedness

v ∈ W𝑏𝑛 𝑛 ≥ 0 ⊢ lit𝑏 (v) : 𝑏 [𝑛]

T-Lit

𝑣 ∈ W𝑏 𝑛 ≥ 1 ⊢ const𝑏,𝑛 (𝑣) : 𝑏 [𝑛]

⊢ 𝑃𝑖 : 𝑏 [𝑛𝑖 ] T-Const

⊢ 𝑃 : 𝑏 [𝑚] 𝑘 ≥ 2 𝑚 ≥ 1 𝑛 = 𝑘𝑚 ⊢ repeat𝑘 (𝑃 ) : 𝑏 [𝑛]

(1 ≤ 𝑖 ≤ 𝑘 ) 𝑘 ≥ 2 𝑛𝑖 ≥ 1

⊢ 𝑃 : 𝑏 [𝑛] 𝑛 ≥ 1 𝑢𝜃 : W𝑏 ↔ W𝑏

T-Repeat

𝑘 ∑︁

𝑏𝑖

𝑛𝑖

⊢ concat(𝑃1 , . . . , 𝑃𝑘 ) : 𝑏 [𝑛]

⊢ map𝑢,𝜃 (𝑃 ) : 𝑏 [𝑛] ∀𝑎 ∈ W𝑏 . 𝑞𝜃 (𝑎, ·) : W𝑏 ↔ W𝑏

⊢ scan𝑞,𝜃 (𝑣0 , 𝑃 ) : 𝑏 [𝑛] (1 ≤ 𝑖 ≤ 𝑘 ) 𝑘 ≥ 2 𝑛 ≥ 1 𝑏 =

𝑘 ∑︁ 𝑖=1

⊢ 𝑃 : 𝑏 [𝑛 − 1] 𝑛 ≥ 2 𝑣0 ∈ W𝑏

⊢ 𝑃𝑖 : 𝑏𝑖 [𝑛]

(1 ≤ 𝑖 ≤ 𝑘 ) 𝑛 =

𝑓𝜃 :

𝑖=1

𝑘 Ö

T-Merge

𝑖=1

⊢ merge 𝑓 ,𝜃 (𝑃 1 , . . . , 𝑃𝑘 ) : 𝑏 [𝑛]

T-Map

T-Scan

⊢ 𝑃 : 𝑏 (𝑑 ) [𝑛] 𝑛 =

W𝑏𝑖 ↔ W𝑏

T-Concat

Ö 𝑗

⊢ ⟨𝑑, s, 𝑃 ⟩ : Tensor

𝑠𝑗 T-Tensor

Notation. W𝑏 = {0, . . . , 2𝑏 − 1}; ↔ marks a bijection; 𝜃 denotes stored operator parameters; 𝑢 ∗ applies 𝑢 to every word; 𝑃 represents 𝑋 when ⊢ ⟨𝑑, s, 𝑃 ⟩ : Tensor and Exec(𝑃 ) = Bits(𝑋 ).

Figure 3. Typed operators in the Brevis language. Lit is the universal fallback; all internal operators are reversible for their stored parameters. Lit stores an arbitrary word stream and provides a universal fallback, whereas Const stores one word and its repetition count. Concat joins programs for adjacent regions, and Repeat expands one nonempty child multiple times. Together, these operators capture arbitrary values, constants, piecewise regions, and recurring subsequences. Map, Scan, and Merge expose relationships that are not visible as repeated strings. Map applies a width-preserving bijection, including XOR or modular addition with a constant, ZigZag coding [Google 2026], Gray coding [Doran 2007], bit reversal, and rotation. Scan stores an initial word followed by XOR or modular-addition updates, exposing adjacent correlations. Merge combines equal-length children whose widths sum to the parent width, using contiguous floatingpoint fields, or bit and byte planes. The basic execution rules are Exec(lit𝑏 (v)) = v, Exec(const𝑏,𝑛 (𝑣)) = (𝑣, . . . , 𝑣), Exec(concat(𝑃1, . . . , 𝑃𝑘 )) = Exec(𝑃1 ) · · · Exec(𝑃𝑘 ), Exec(repeat𝑘 (𝑃)) = Exec(𝑃)𝑘 , Exec(map𝑢,𝜃 (𝑃)) = 𝑢𝜃∗ (Exec(𝑃)).

(6)

For scan𝑞,𝜃 (𝑣 0, 𝑃), execution starts with 𝑣 0 and applies 𝑞𝜃 to the previous output and each update generated by 𝑃. A Merge applies its stored composition pointwise. Every parameter is serialized, every child has a fixed type, and the

root must produce exactly the words required by the tensor record. Physical literal coding. Lit is a semantic leaf rather than necessarily a raw byte copy. The encoder tries raw words, fixed-width bit packing, canonical Huffman coding, and rANS, then selects the smallest complete encoding, including codec tags, tables, lengths, and payloads. The decoder first restores the literal words and then executes the surrounding program. Raw words remain available when codec metadata would outweigh the compression benefit. Running example. Consider the FP32 sequence (+1.0, −1.0, +1.0, −1.0, +1.0, −1.0). One synthesized program is 𝑃 = mergeFP32 repeat3 (lit1 (0, 1)),
const8,6 (127), const23,6 (0) .

(7)

Its three children represent the sign, exponent, and fraction fields. The sign child stores (0, 1) once and repeats it three times, while the other two generate the shared exponent and fraction. Merge reconstructs all six FP32 words. A direct literal remains valid, and Brevis selects the synthesized program only if its serialized form is smaller. 3.3

Target-Directed Synthesis

Target-directed expansion. A naive synthesizer would enumerate programs and execute each one against the target tensor, although most candidates would fail to reproduce

Lossless Tensor Compression as Program Synthesis

it. Brevis instead searches backward from the target. Every hole is paired with the exact stream that its completed subprogram must generate, and applying an operator decomposes that stream into the required outputs of its children. For operator 𝑟 with parameters 𝜃 , let 𝐺𝑟,𝜃 compose child streams and 𝐷𝑟,𝜃 decompose a target stream. Brevis accepts only decompositions satisfying 𝐷𝑟,𝜃 (x) = (x1, . . . , x𝑘 ) =⇒ 𝐺𝑟,𝜃 (x1, . . . , x𝑘 ) = x.

(8)

Thus, if each child program generates its assigned stream, the parent is guaranteed to generate x. Correctness is preserved by construction rather than checked by repeatedly executing complete candidates. Each operator provides a target-specific inverse expansion. Repeat applies only when the target consists of exact copies, Map inverts its bijection, Scan derives updates from adjacent words, and Merge splits each word into fields or planes. Concat proposes boundaries derived from the target, while Const applies only to constant streams. Each rule considers finitely many target-derived parameters. Node, depth, arity, and memory limits keep the search finite, while canonical forms remove identity and equivalent programs. The search budget is therefore spent comparing exact representations rather than testing arbitrary programs for correctness. Checkpoint-specific production prior. The useful DSL productions vary across checkpoints. Brevis therefore selects a small deterministic sample stratified by dtype and tensor size, searches these tensors with uniform production costs, and counts the productions used by the smallest programs found. For each production, the context 𝜅 records the hole type, parent operator, child position, depth, dtype, size bucket, zero fraction, distinct-value ratio, repetition ratio, and entropy of adjacent differences. With rule counts 𝑁 (𝑟, 𝜅), admissible production set R (𝜅), and additive smoothing 𝛽 > 0, we follow PHOG and Euphony [Bielik et al. 2016; Lee et al. 2018] to estimate the production prior: 𝑁 (𝑟, 𝜅) + 𝛽 . ′ 𝑟 ′ ∈ R (𝜅 ) 𝑁 (𝑟 , 𝜅) + 𝛽 |R (𝜅)|

𝑞b(𝑟 | 𝜅) = Í

(9)

Unseen detailed contexts back off to coarser ones. Every valid production retains nonzero probability, so the prior changes only the exploration order and never makes a valid program unreachable. The prior is deterministic for a fixed checkpoint and is not stored with the compressed representation. Bounded A* search. A search state 𝑠 contains a partial typed program whose holes are paired with their required output streams; 𝐻 (𝜏, v) is a hole of type 𝜏 targeting v. Applying production 𝑟 under context 𝜅 incurs cost 𝑤 (𝑟, 𝜅) = − log2 𝑞b(𝑟 | 𝜅).

(10)

States are prioritized by 𝑔(𝑠)+ℎ(𝑠), where 𝑔(𝑠) is the accumulated production cost and ℎ(𝑠) is an admissible completion

Algorithm 1 Bounded A* synthesis for one tensor. Require: Target x : 𝑏 [𝑛], prior 𝑞b, expansion budget 𝐵 1: 𝑃 best ← lit𝑏 (x) 2: 𝑄 ← {𝐻 (𝑏 [𝑛], x) }; 𝑒 ← 0 3: 𝑠 cut ← ⊥ 4: while 𝑄 is not empty do 5: 𝑠 ← PopMin(𝑄 ) by A* cost and byte bound 6: if LB𝐿 (𝑠 ) ≥ 𝐿 (𝑃best ) then 7: continue 8: end if 9: if 𝑠 is complete then 10: 𝑃 best ← arg min𝑃 ∈{𝑃best ,𝑠 } 𝐿 (𝑃 ) 11: continue 12: end if 13: if 𝑒 = 𝐵 then 14: 𝑠 cut ← Prefer(𝑠 cut , 𝑠 ) 15: continue 16: end if 17: 𝑒 ←𝑒 +1 18: 𝐻 (𝜏, v) ← LeftmostHole(𝑠 ) 19: for each valid target-directed expansion of 𝐻 (𝜏, v) do 20: push the resulting typed state into 𝑄 21: end for 22: end while 23: if 𝑠 cut ≠ ⊥ then 24: 𝑃roll ← CompleteWithLiterals(𝑠 cut ) 25: 𝑃best ← arg min𝑃 ∈{𝑃best ,𝑃roll } 𝐿 (𝑃 ) 26: end if 27: return 𝑃 best

cost computed from a relaxed grammar. The relaxation preserves width and coarse length constraints while omitting target guards and concrete parameters, ensuring that ℎ(𝑠) remains optimistic. Consequently, the learned prior affects only the exploration order, whereas candidate quality is determined independently by their serialized size. A separate byte lower bound LB𝐿 (𝑠) accounts for fixed operation tags, parameters, and a minimum closing cost for each remaining hole. States whose lower bound cannot improve upon the current best program are pruned, while complete candidates are evaluated using their exact serialized size 𝐿(𝑃). Algorithm 1 summarizes the procedure. The initial incumbent is a literal program for the complete target, and search continues after the first complete candidate because the most probable program need not be the smallest. When the expansion budget is exhausted, Prefer retains the open state the queue orders first, and Brevis completes its remaining holes with literals and evaluates the rollout, allowing structures discovered near the search boundary to remain competitive. If the frontier is exhausted or safely pruned, the result is optimal within the configured finite search space. If the expansion budget is reached, Brevis returns the smallest exact candidate encountered, including the literal-completed rollout. The procedure does not claim global optimality over unbounded programs, but every returned program reconstructs the target exactly.

Jieke Shi et al.

3.4

Archive Format and Bit-Exact Reconstruction

The archive preserves the original safetensors header and layout. Each tensor record stores its name, dtype, shape, and synthesized program. Tensor records can be compressed and decoded independently by a bounded worker pool, while source-order emission keeps the archive deterministic. Before execution, the decoder parses the complete program and validates the type rules in Figure 3. It rejects invalid widths, lengths, parameters, or literal payloads, executes the program, and restores the bytes at their original offsets. Proposition 1 (Compositional bit-exact reconstruction). Let 𝑃 be a complete, well-formed program whose root is assigned xroot = Bits(𝑋 ). Assume that (i) serialization and parsing preserve the typed tree and all stored parameters, (ii) every physical literal codec 𝑐 satisfies Dec𝑐 (Enc𝑐 (v)) = v, and (iii) every internal node uses child targets returned by a decomposition satisfying Equation 8. Then executing the parsed program yields Bits(𝑋 ). Proof. Let x𝑡 be the target assigned to node 𝑡. We prove by induction on subtree height that Exec(𝑃𝑡 ) = x𝑡

(11)

for every parsed subtree 𝑃𝑡 . For a Lit leaf, assumption (ii) restores its stored stream exactly. For a Const leaf, wellformedness requires the assigned target to equal the stored value repeated to the specified length. Now consider an internal node using production 𝑟 , parameters 𝜃 , and children 𝑡 1, . . . , 𝑡𝑘 . By induction, Exec(𝑃𝑡𝑖 ) = x𝑡𝑖 for every child. The decoder applies the stored composition function 𝐺𝑟,𝜃 , and Equation 8 gives
Exec(𝑃𝑡 ) = 𝐺𝑟,𝜃 Exec(𝑃𝑡1 ), . . . , Exec(𝑃𝑡𝑘 ) = 𝐺𝑟,𝜃 (x𝑡1 , . . . , x𝑡𝑘 ) = x𝑡 .

(12)

The invariant thus holds at the root, where xroot = Bits(𝑋 ). □ The root type agrees with the stored dtype, shape, and layout, so placing the generated words at their recorded offsets reconstructs 𝑋 bit for bit. The guarantee assumes correct operator implementations and does not imply global search optimality.

4

Evaluation

4.1

Experimental Setup

Corpus and baselines. Our corpus contains 10 public checkpoints from Hugging Face, including eight language models [Devlin et al. 2019; GLM-5 Team 2026; Grattafiori et al. 2024; Jiang et al. 2024; Qwen Team 2025], one audio model, and one image generation model. It spans eight BF16, one FP32, and one FP8 checkpoint, comprising 420 canonical shards and 2,130,256,127,862 source bytes (2.130 TB). We compare Brevis against zstd 1.5.7 (level 9), ZipNN 0.5.4, LZ4 1.9.4 (HC level 9), gzip, and Snappy 0.7.3. We additionally

compare with DFloat11 on Llama-3.1-8B, the only model for which a validated native result is available. TDT, ZipServ, and ENEC require different software or hardware backends, LLM.265 is lossy, and ECF8 [Yang et al. 2026b] is excluded because its official CUDA validator rejected the decoded output in our experiment. These methods are therefore not directly comparable. Configuration. The main Brevis configuration uses one A* expansion per tensor and 32 workers. To learn the checkpoint-specific production prior, calibration samples at most four tensors, performs six expansions per tensor, and examines at most 1,048,576 elements from each tensor. Programs are limited to 64 nodes and depth 4, with at most 512 MiB for open decompositions. All experiments use warm file caches on one AMD EPYC 9654 server with 192 physical cores, 724 GiB RAM. Measurement. For each checkpoint, we aggregate source and archive bytes over canonical shards and compute Í 𝑆𝑖 𝐶𝑚 − 𝐶 Brevis CR = Í 𝑖 , Saving𝑚 = , 𝐶𝑚 𝑖 𝐶𝑖 where 𝑆𝑖 and 𝐶𝑖 denote the source and archive sizes of shard 𝑖, and 𝐶𝑚 is the total archive size produced by baseline 𝑚. All 60 archives in the complete comparison matrix were decoded and retained only after exact reconstruction. Brevis, zstd, LZ4, gzip, and Snappy reconstruct the original files byte for byte; ZipNN preserves tensor names, metadata, dtypes, shapes, and payload bits but may alter the safetensors layout. We compute 95% percentile bootstrap intervals by resampling checkpoints 10,000 times with seed 20260729. For the five complete-corpus baselines, we use two-sided exact Wilcoxon signed-rank tests and report Holm-adjusted 𝑝-values 𝑝 H with matched-pairs rank-biserial correlation 𝑟 rb . 4.2

Compression Effectiveness

Across the complete corpus, Brevis reduces 2.130 TB to 1.407 TB, yielding a compression ratio of 1.5135 and a 33.93% storage reduction, or 722.79 GB saved. As shown in Table 1, Brevis produces the smallest archive for every checkpoint and available comparison. Against the four general-purpose compressors, it is smaller on all 10 checkpoints, with mean per-checkpoint savings ranging from 12.94% over zstd to 30.87% over Snappy (Figure 4). All five complete-corpus comparisons, including ZipNN, remain significant after Holm correction (𝑝 H = 0.0098), with the maximum matched-pairs effect size (𝑟 rb = 1.0). ZipNN is the closest complete-corpus baseline. Brevis is smaller on all 10 checkpoints and saves 10.21 GB in aggregate. Its pooled saving is 0.72% [0.70%, 0.81%], and its mean per-checkpoint saving is 0.71% [0.61%, 0.78%]. The mean saving across the eight BF16 checkpoints is 0.75% [0.71%, 0.79%], while the FP32 and FP8 savings are 0.32% and 0.81%, respectively, indicating that the aggregate result is not driven solely

Lossless Tensor Compression as Program Synthesis

Table 1. Complete archive results across 10 checkpoints. Each method cell reports archive size in decimal GB/storage reduction. Bold cells and underlined reductions mark the best and second-best comparable results. Domain

Checkpoint

Data type

Source

Archive size (GB)/storage reduction

(GB)

zstd

LZ4

gzip†

Snappy

ZipNN

DFloat11‡

Brevis

Language

BERT Base Llama-3.1-8B Ministral-3-8B Qwen3-32B Qwen3-32B Llama-3.1-70B Mixtral-8 × 22B GLM-5.2

FP32 BF16 BF16 FP8 BF16 BF16 BF16 BF16

0.440 16.061 17.836 34.323 65.524 141.107 281.241 1,506.667

0.407/7.59% 12.38/22.91% 13.79/22.67% 28.41/17.21% 50.84/22.41% 108.58/23.05% 217.40/22.70% 1,159.70/23.03%

0.440/0.00% 15.94/0.77% 17.70/0.79% 34.30/0.07% 65.05/0.72% 140.00/0.79% 279.15/0.74% 1,494.27/0.82%

0.407/7.56% 12.50/22.17% 13.94/21.85% 28.29/17.57% 51.36/21.62% 109.67/22.28% 219.97/21.79% 1,171.85/22.22%

0.440/ − 0.01% 16.06/0.00% 17.84/0.01% 34.33/ − 0.01% 65.53/ − 0.01% 141.12/ − 0.01% 281.28/ − 0.01% 1,506.85/ − 0.01%

0.366/16.84% 10.66/33.63% 11.83/33.68% 28.08/18.18% 43.65/33.38% 93.50/33.74% 186.23/33.78% 998.71/33.71%

– 10.90/32.16% – – – – – –

0.365/17.11% 10.58/34.13% 11.74/34.18% 27.85/18.85% 43.28/33.94% 92.73/34.28% 184.85/34.27% 991.73/34.18%

Audio

Voxtral-Mini-3B

BF16

9.356

7.215/22.89%

9.269/0.93%

7.297/22.01%

9.355/0.02%

6.226/33.46%

–

6.186/33.89%

Image

Qwen-Image

BF16

57.699

44.64/22.63%

57.25/0.79%

45.07/21.89%

57.70/0.00%

38.42/33.42%

–

38.14/33.89%

† gzip uses libdeflate 1.19 in gzip mode at DEFLATE level 1.

‡ DFloat11 reconstructs BF16 tensor bits in its native directory format; its Llama-3.1-8B result was independently validated at the bit level. Dashes indicate unsupported or unevaluated

combinations. DFloat11 is excluded from the paired statistical analysis.

ZipNN

Brevis vs. ZipNN: +0.54 pp storage reduction +7.2% compression speed, +8.9% decompression speed

0.71% 12.94%

gzip

13.61%

LZ4

30.44%

Snappy

30.87%

0

10

20

Throughput (GB/s)

(a) Compression

zstd

30

Mean per-checkpoint archive saving (%)

Figure 4. Mean archive saving of Brevis over the five complete-corpus baselines. Lines show 95% bootstrap intervals over checkpoints. by the largest checkpoint. We additionally compare with DFloat11 using its only publicly available and independently validated native result on Llama-3.1-8B. DFloat11 occupies 10.896 GB, compared with 10.579 GB for Brevis, making Brevis 316.27 MB, or 2.90%, smaller. Because DFloat11 does not provide comparable results for the remaining checkpoints and uses a different container format, we do not generalize this comparison beyond Llama-3.1-8B. 4.3

Throughput

Figure 5 compares storage reduction and throughput on Llama-3.1-70B. Brevis reaches 3.60 GB/s compression and 6.61 GB/s decompression with a compression ratio of 1.522. Compared with ZipNN, it compresses 7.2% faster while producing a 0.82% smaller archive, placing it on both Pareto frontiers. zstd and LZ4 decompress faster, and Snappy compresses faster, but all achieve lower storage reduction. Throughput uses the 141.11-GB source size and full-checkpoint elapsed time, including process launch and output fsync, but excluding cache conditioning and verification. Because methods use practical rather than identical resource configurations, these comparisons are descriptive.

10

Snappy

6

Pareto front

Brevis

4 gzip

2

10

20

Brevis Snappy

4

zstd

0

zstd LZ4Pareto front

8 6

ZipNN

LZ4

0

(b) Decompression

30

0

10

ZipNN gzip

20

30

Storage reduction (%)

Figure 5. Storage reduction versus compression and decompression throughput. Upper right is better; lines show the Pareto frontiers. 4.4

Synthesis Analysis and Ablation

We analyze synthesis on the first 4.98 GB shard of Llama3.1-8B. At budget 1, Brevis already captures most of the achievable compression and completes in 9.04 seconds. Budgets 32 and 256 save an additional 3.13 MB and 5.48 MB but require 135.04 and 1,399.89 seconds, respectively, motivating the budget of one expansion used in the main evaluation. Table 2 further evaluates A* search and the checkpoint-specific production prior. Removing A* increases archive size by 2,873,336 bytes, removing the prior adds 389 bytes, and removing both increases it by 3,123,197 bytes. Together, these results suggest that bounded A* and the learned prior work synergistically, with A* providing the primary compression gain while the prior further improves guided search.

5

Limitations and Conclusion

Brevis formulates lossless tensor compression as program synthesis over typed, self-contained programs. Its reversible operators expose value, sequence, field, and plane structure,

Jieke Shi et al.

Table 2. Search-guidance ablation on the Llama-3.1-8B shard. Extra bytes are relative to the full configuration. Configuration

Extra bytes vs. full

Time (s)

Full A* + prior No A* No prior No A* or prior

0 +2,873,336 +389 +3,123,197

140.24 118.09 88.82 70.69

while literal codecs encode the resulting streams. Targetdirected expansion preserves bit exactness by construction, a checkpoint-specific production prior guides bounded A* search, and exact serialized size determines the selected program. On 10 public checkpoints spanning language, audio, and image generation models, Brevis reduces 2.130 TB of checkpoint data to 1.41 TB, achieving a 33.93% storage reduction. It produces archives up to 30.87% smaller than four general-purpose compressors, and smaller archives than the tensor-specific compressors. Several limitations remain. The evaluation covers public model checkpoints rather than all tensor workloads, with limited and partly confounded domain and format diversity. The current implementation synthesizes each tensor independently, so cross-tensor synthesis, broader corpora, and accelerator-aware decoding remain future work. Data and Artifact Availability. The anonymous implementation and datasets, as well as the scripts used to generate the evaluation results, are included in our GitHub repository: https://github.com/jiekeshi/Brevis.

References Azim Afroozeh, Leonardo Kuffó, and Peter Boncz. 2023. ALP: Adaptive Lossless Floating-Point Compression. Proceedings of the ACM on Management of Data 1, 4, Article 230 (2023), 230:1–230:26 pages. doi:10.1145/3626717 Rajeev Alur, Rastislav Bodík, Garvit Juniwal, Milo M. K. Martin, Mukund Raghothaman, Sanjit A. Seshia, Rishabh Singh, Armando Solar-Lezama, Emina Torlak, and Abhishek Udupa. 2013. Syntax-Guided Synthesis. In Formal Methods in Computer-Aided Design (FMCAD). 1–8. doi:10.1109/ FMCAD.2013.6679385 Pavol Bielik, Veselin Raychev, and Martin Vechev. 2016. PHOG: Probabilistic Model for Code. In Proceedings of the 33rd International Conference on Machine Learning (ICML), Vol. 48. PMLR, 2933–2942. https://proceedings. mlr.press/v48/bielik16.html Martin Burtscher, Hari Mukka, Annie Yang, and Farbod Hesaaraki. 2016. Real-Time Synthesis of Compression Algorithms for Scientific Data. In SC16: International Conference for High Performance Computing, Networking, Storage and Analysis. 264–275. doi:10.1109/SC.2016.22 Steven Claggett, Sahar Azimi, and Martin Burtscher. 2018. SPDP: An Automatically Synthesized Lossless Compression Algorithm for FloatingPoint Data. In 2018 Data Compression Conference (DCC). 335–344. doi:10. 1109/DCC.2018.00042 Yann Collet and Murray Kucherawy. 2021. Zstandard Compression and the application/zstd Media Type. RFC 8878. doi:10.17487/RFC8878 Yann Collet, Nick Terrell, W. Felix Handte, Danielle Rozenblit, Victor Zhang, Kevin Zhang, Yaelle Goldschlag, Jennifer Lee, Elliot Gorokhovsky, Yonatan Komornik, Daniel Riegel, Stan Angelov, and Nadav Rotem.

2025. OpenZL: A Graph-Based Model for Compression. arXiv preprint arXiv:2510.03203 (2025). arXiv:2510.03203 doi:10.48550/arXiv.2510.03203 L. Peter Deutsch. 1996. GZIP File Format Specification Version 4.3. RFC 1952. doi:10.17487/RFC1952 Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies. 4171–4186. doi:10.18653/v1/N19-1423 Robert W Doran. 2007. The gray code. Technical Report. Department of Computer Science, The University of Auckland, New Zealand. Caleb Fahlgren. 2026. cfahlgren1/hub-stats · Datasets at Hugging Face. https://huggingface.co/datasets/cfahlgren1/hub-stats. Ruibo Fan, Xiangrui Yu, Xinglin Pan, Zeyu Li, Weile Luo, Qiang Wang, Wei Wang, and Xiaowen Chu. 2026. ZipServ: Fast and Memory-Efficient LLM Inference with Hardware-Aware Lossless Compression. In Proceedings of the 31st ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2 (ASPLOS). ACM, 2264–2280. arXiv:2603.17435 doi:10.1145/3779212.3790250 Elias Frantar, Saleh Ashkboos, Torsten Hoefler, and Dan Alistarh. 2023. OPTQ: Accurate Quantization for Generative Pre-trained Transformers. In The Eleventh International Conference on Learning Representations. https://openreview.net/forum?id=tcbBPnfwxS Georgi Gerganov. 2026. ggml/docs/gguf.md. https://github.com/ggmlorg/ggml/blob/master/docs/gguf.md. GLM-5 Team. 2026. GLM-5: From Vibe Coding to Agentic Engineering. arXiv preprint arXiv:2602.15763 (2026). arXiv:2602.15763 https://arxiv. org/abs/2602.15763 Google. 2026. Protocol Buffers: Encoding. https://protobuf.dev/ programming-guides/encoding/. Defines the ZigZag signed-integer encoding. Aaron Grattafiori et al. 2024. The Llama 3 Herd of Models. arXiv preprint arXiv:2407.21783 (2024). arXiv:2407.21783 https://arxiv.org/abs/2407. 21783 Yongchang Hao, Yanshuai Cao, and Lili Mou. 2024. NeuZip: MemoryEfficient Training and Inference with Dynamic Compression of Neural Networks. arXiv preprint arXiv:2410.20650 (2024). arXiv:2410.20650 doi:10.48550/arXiv.2410.20650 Moshik Hershcovitch, Andrew Wood, Leshem Choshen, Guy Girmonsky, Roy Leibovitz, Or Ozeri, Ilias Ennmouri, Michal Malka, Peter Chin, Swaminathan Sundararaman, and Danny Harnik. 2025. ZipNN: Lossless Compression for AI Models. In 2025 IEEE 18th International Conference on Cloud Computing (CLOUD). IEEE, 186–198. doi:10.1109/CLOUD67622. 2025.00028 Samirasadat Jamalidinan and Kazem Cheshmi. 2025. Floating-Point Data Transformation for Lossless Compression. arXiv preprint arXiv:2506.18062 (2025). arXiv:2506.18062 doi:10.48550/arXiv.2506.18062 Albert Q. Jiang, Alexandre Sablayrolles, Antoine Roux, Arthur Mensch, Blanche Savary, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Emma Bou Hanna, Florian Bressand, Gianna Lengyel, Guillaume Bour, Guillaume Lample, Lélio Renard Lavaud, Lucile Saulnier, MarieAnne Lachaux, Pierre Stock, Sandeep Subramanian, Sophia Yang, Szymon Antoniak, Teven Le Scao, Théophile Gervet, Thibaut Lavril, Thomas Wang, Timothée Lacroix, and William El Sayed. 2024. Mixtral of Experts. arXiv preprint arXiv:2401.04088 (2024). arXiv:2401.04088 https://arxiv. org/abs/2401.04088 Woosuk Lee, Kihong Heo, Rajeev Alur, and Mayur Naik. 2018. Accelerating Search-Based Program Synthesis using Learned Probabilistic Models. In Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, 436–449. doi:10.1145/ 3192366.3192410 Ji Lin, Jiaming Tang, Haotian Tang, Shang Yang, Guangxuan Xiao, and Song Han. 2024. AWQ: Activation-Aware Weight Quantization for On-Device LLM Compression and Acceleration. GetMobile: Mobile Computing and

Lossless Tensor Compression as Program Synthesis Communications 28, 4 (2024), 12–17. doi:10.1145/3714983.3714987 Kiyoshi Masui, Mandana Amiri, Liam Connor, Meiling Deng, Mateus Fandino, Carolin Höfer, Mark Halpern, David Hanna, Adam D. Hincks, Gary Hinshaw, Juan Mena Parra, Laura B. Newburgh, J. Richard Shaw, and Keith Vanderlinde. 2015. A Compression Scheme for Radio Data in High Performance Computing. Astronomy and Computing 12 (2015), 181–190. doi:10.1016/j.ascom.2015.07.002 Qwen Team. 2025. Qwen3 Technical Report. arXiv preprint arXiv:2505.09388 (2025). arXiv:2505.09388 https://arxiv.org/abs/2505.09388 Andrew Rodriguez, Noushin Azami, and Martin Burtscher. 2024. Adaptive Per-File Lossless Compression of Floating-Point Data. In 2024 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW). 423–430. doi:10.1109/IPDPSW63119.2024.00092 Kensen Shi, David Bieber, and Rishabh Singh. 2022. TF-Coder: Program Synthesis for Tensor Manipulations. ACM Transactions on Programming Languages and Systems 44, 2, Article 10 (March 2022), 37 pages. doi:10. 1145/3517034 Hongshi Tan, Yao Chen, Gustavo Alonso, Weng-Fai Wong, and Bingsheng He. 2026. Approaching Shannon Bound with Lossless LLM Weight Compression. In Proceedings of the 53rd Annual International Symposium on Computer Architecture (ISCA). arXiv:2606.15789 https://arxiv.org/abs/ 2606.15789 Zirui Wang, Tingfeng Lan, Zhaoyuan Su, Juncheng Yang, and Yue Cheng. 2026. ZipLLM: Efficient LLM Storage via Model-Aware Synergistic Data Deduplication and Compression. In 23rd USENIX Symposium on Networked Systems Design and Implementation (NSDI 26). USENIX Association, Renton, WA, 2371–2387. https://www.usenix.org/conference/ nsdi26/presentation/wang-zirui Ceyu Xu, Yongji Wu, Xinyu Yang, Beidi Chen, Matthew Lentz, Danyang Zhuo, and Lisa Wu Wills. 2025. LLM. 265: Video Codecs are Secretly Tensor Codecs. In Proceedings of the 58th IEEE/ACM International Symposium on Microarchitecture. 445–460. doi:10.1145/3725843.3756078 Jinwu Yang, Jiaan Wu, Zedong Liu, Xinyang Ma, Hairui Zhao, Yida Gu, Yuanhong Huang, Xingchen Liu, Wenjing Huang, Zheng Wei, Jing Xing, Yili Ma, Qingyi Zhang, Baoyi An, Zhongzhe Hu, Shaoteng Liu, Xia Zhu, Jiaxun Lu, Guangming Tan, and Dingwen Tao. 2026a. ENEC: A Lossless AI Model Compression Method Enabling Fast Inference on Ascend NPUs. In Proceedings of the 53rd Annual IEEE/ACM International Symposium on Computer Architecture. arXiv:2604.03298 https://arxiv.org/abs/2604. 03298 Yuchen Yang, Yaru Zhao, Pu Yang, Shaowei Wang, and Zhi-Hua Zhou. 2026c. ZipMoE: Efficient On-Device MoE Serving via Lossless Compression and Cache-Affinity Scheduling. In Proceedings of the 43rd International Conference on Machine Learning (ICML) (Proceedings of Machine Learning Research, Vol. 306). arXiv:2601.21198 https://arxiv.org/abs/2601.21198 Zeyu Yang, Tianyi Zhang, Jianwen Xie, Chuan Li, Zhaozhuo Xu, and Anshumali Shrivastava. 2026b. To Compress or Not? Pushing the Frontier of Lossless GenAI Model Weights Compression with Exponent Concentration. In International Conference on Learning Representations (ICLR). arXiv:2510.02676 https://openreview.net/forum?id=XI1CeufywD Ori Yoran, Kunhao Zheng, Fabian Gloeckle, Jonas Gehring, Gabriel Synnaeve, and Taco Cohen. 2025. The KoLMogorov Test: Compression by Code Generation. In International Conference on Learning Representations (ICLR). https://openreview.net/forum?id=C45YqeBDUM Patrick Yubeaton, Tareq Mahmoud, Shehab Naga, Pooria Taheri, Tianhua Xia, Arun George, Yasmein Khalil, Sai Qian Zhang, Siddharth Joshi, Chinmay Hegde, and Siddharth Garg. 2025. Huff-LLM: End-to-End Lossless Compression for Efficient LLM Inference. arXiv preprint arXiv:2502.00922 (2025). arXiv:2502.00922 doi:10.48550/arXiv.2502.00922 Tianyi Zhang, Mohsen Hariri, Shaochen (Henry) Zhong, Vipin Chaudhary, Yang Sui, Xia Hu, and Anshumali Shrivastava. 2025. 70% Size, 100% Accuracy: Lossless LLM Compression for Efficient GPU Inference via Dynamic-Length Float (DFloat11). In Advances in Neural Information Processing Systems, Vol. 38. Curran Associates, Inc., 98966–98994.

arXiv:2504.11651 https://proceedings.neurips.cc/paper_files/paper/2025/ hash/8e8b4449c80879215ff2ee47b6dd01a6-Abstract-Conference.html

Related documents

• FSZ: Breaking the Prediction-Throughput Trade-off in GPU Lossy Compression#381719
• Ozaki 2.5: Engineering the Deconstruction Path of fp64-Emulated Dense Matrix Multiplication on FP8 Tensor Cores#667974
• ISO: An RLVR-Native Optimization Stack#386854
• VIREL: Verified Integer-Residual Encoding on Lattices for Exact and Error-Bounded Floating-Point Time-Series Compression#411168
• Quantum-Inspired Algorithms beyond Unitary Circuits: the Laplace Transform#927218