Skip to main content

63  RankFold, NeuralFold, and Artifact Compression

63.1 Chapter status

Field Value
Chapter ID rankfold-neuralfold-and-artifact-compression
Part Part III - Routing, Compression, Representation, and Substrates
Status conceptual
Manuscript maturity v0.3 claim-proof program
Last updated 2026-07-31
Primary source records rankfold_neuralfold, rankfold_compressor, bbvca_v9, cgs, bugbrain, ext_raptor_2024
Claim label Design rationale
Evidence level argument
Source queue primary: rankfold_neuralfold, rankfold_compressor; supporting: bbvca_v9, cgs, bugbrain
Source loading state source notes: rankfold_neuralfold, rankfold_compressor, bbvca_v9, cgs, bugbrain, ext_raptor_2024, precision_contract; raw cache: rankfold_neuralfold, rankfold_compressor, bbvca_v9, cgs, bugbrain
Test state The exact fixture, RAW0 replay, NEURAL0 metadata import, and two no-change decisions remain valid. AsiStackProofs.ArtifactCompressionRefinement now supplies 27 theorems over eight reachable stages and 53 routes, exact-use and failed-probe fallback witnesses, arbitrary-run identity/non-authority/receipt/fallback invariants, trace composition, closure absorption, and an independent consumer rejecting 143/143 mutations. Two legacy countermodels remain and seventeen projections or flat route consequences are retired. NeuralFold compression reproduction, deployed fallback execution, corpus benchmarking, and downstream utility remain unrun.

63.2 Drafting guardrail

RankFold/NeuralFold and RankFold Compressor are compression-architecture sources. They do not report compression ratios, lossless reconstruction, or implementation performance for this repository. The new public-safe replay probe exercises the local rfa CLI on one tiny synthetic fixture, but NeuralFold was disabled by license and the observed archive used RAW0; that run is a roundtrip and negative-control replay, not a RankFold/NeuralFold compression benchmark.

After fast generation, the compression question returns to stored artifacts. A cheaper representation is not a cheaper source of truth; it is a routed candidate that must preserve full-artifact fallback, probe results, residual coding, and utility boundaries for each task.

Compression therefore becomes an evidential firewall, not a storage trick. The system may choose a smaller representation for a task, but the smaller representation does not inherit every property of the full artifact. It earns only the properties that its reconstruction contract, residual ledger, probes, and downstream utility checks actually support.

63.3 Human Reading Path

Concrete lens. The ratio baseline promotes the compact form after exact replay. The consumer lease tests the real random-access workload and rejects it.

After fast generation, the stack returns to stored artifacts and retrieval. RankFold and NeuralFold are treated as compression-architecture ideas: ways to represent large artifacts more cheaply while preserving routes back to the full object when needed.

A compressed artifact is not automatically a source of truth. Compression needs fallback, probes, residual coding, decoder discipline, and utility boundaries so a smaller representation does not quietly replace the thing it only approximates.

The hard question is not whether compression is clever. It is whether a consumer can tell which property was preserved, which property was lost, and when the full artifact must be retrieved again.

Approximation is acceptable only when downstream users know what kind of approximation they received.

Compression should make artifacts cheaper to use without making them harder to doubt. A compressed archive should invite reconstruction, probing, and refusal when the shortcut is too thin.

The compressed form earns use only when the original remains reachable enough. Compression should make review cheaper without making origin disposable during serious downstream review work.

63.4 Problem

The stack will store source documents, artifacts, logs, benchmark traces, models, simulations, and generated outputs. Storage and transfer cost matter, but artifact compression is dangerous when it damages semantics, loses decoder determinism, hides residual coding cost, or makes fallback so common that the apparent savings disappear.

RankFold/NeuralFold is useful here because it treats artifacts as candidates for tensor-centric archival structure while preserving manifest, codec, residual, and reconstruction obligations. BBVCA v9 adds the discipline that exactness requires a reconstruction contract and repair accounting.

The hard problem is deciding when a compressed representation is allowed to stand in for the thing it compresses. Search previews, cold archives, human summaries, source evidence, proof artifacts, and replay logs have different tolerance for loss. A compression layer that ignores those differences can make the book cheaper to store while making it easier to overclaim what was preserved.

63.5 Why existing approaches are insufficient

Storage savings are not enough. A compressed artifact must be useful for the task that wants it. A low-rank transform can optimize reconstruction error while increasing encoded residual cost. A tensor representation can be elegant while losing exact file reconstruction. A write-once archive can amortize expensive encoding, but that assumption fails for hot artifacts that must be rewritten or queried constantly.

External compression and adaptation work names the axes that RankFold/NeuralFold must keep separate. Deep Compression (ext_deep_compression_2015), GPTQ (ext_gptq_2022), and QLoRA (ext_qlora_2023) foreground model-size and quantization tradeoffs; LoRA (ext_lora_2021) foregrounds low-rank adaptation; knowledge distillation (ext_knowledge_distillation_2015) foregrounds behavior transfer; DreamCoder (ext_dreamcoder_2020) foregrounds reusable abstractions; and MDL (ext_mdl_tutorial_2004) foregrounds residual accounting. The artifact-compression ledger uses those as comparison vocabulary, not as evidence for a local codec result.

The book therefore treats artifact compression as a routed representation choice. A task can use a compressed artifact only after the relevant probe passes; otherwise it routes to the full artifact or records a residual.

This routing view prevents a common category error. Compression ratio, reconstruction adequacy, task utility, and operational cost are different ledgers. A record can have an excellent serialized size and still be useless for a retrieval task. It can preserve enough meaning for summarization while failing exact reconstruction. It can decode correctly while costing so much at read time that the system should not use it on the hot path.

The artifact layer therefore needs admission states, not just ratios. A compressed artifact can be admitted for cold archive, denied for hot retrieval, accepted for preview, rejected for exact replay, or quarantined after decoder drift. Each state should be attached to a task family and access pattern. Without that state, a storage decision can accidentally become a reasoning shortcut.

63.6 Core Claim

[rankfold-neuralfold-and-artifact-compression.core, label: Design rationale, support: argument] A compressed artifact may enter a downstream route only through an artifact-, consumer-, use-, access-pattern-, decoder-, platform-, and time-specific admission lease that preserves the full source, separates representation, reconstruction, ratio, utility, latency, and evidentiary-authority claims, counts every byte and operation, exercises probes and fallback, and expires or quarantines on drift; RankFold/NeuralFold remains a bounded candidate implementation, and no compact form inherits the source artifact’s authority.

Reader claim. A compact artifact can be smaller and exactly reconstructable yet still be worse for the consumer because decoding, random access, latency, or failure recovery changed.

Operational rule. Preserve the full source, count all bytes and operations, bind decoder and platform, test the actual access pattern and required probes, and maintain fallback. Admit only the exact consumer use that passes; reconstruction success never transfers source authority.

63.6.1 Worked compression lease: exact replay, failed random access

A large theorem index compresses to one tenth of its original storage and reconstructs byte-for-byte in a sequential replay. A verifier, however, needs low-latency random lookup of individual theorem records. The compressed representation requires decoding a long prefix for each lookup, exceeding the consumer’s latency budget. The admission lease therefore allows archival storage and batch reconstruction but rejects interactive verification use, which falls back to the full artifact.

This is not a contradiction: representation ratio, reconstruction accuracy, access utility, and latency are different claims. A later decoder or index may qualify the random-access route, but it must receive a new platform- and time-specific lease. The finite admission model checks source preservation, manifests, use envelopes, access patterns, decoder determinism, replay, probes, fallback, residuals, utility evidence, and support boundaries. It does not establish real compression ratio, decoder speed, utility, or NeuralFold superiority.

The distinct owner here is the Compressed Artifact Admission Lease: the record that decides whether a cheaper stored or transmitted representation may serve one named consumer use. Artifact Graph retains source custody and lineage; Context determines transaction adequacy; Routing selects the route; Verification judges reconstruction and probes; Resource Economics accounts for burden; Claim Ledgers control support; Security controls decoder risk; Rights controls transformation and retention; Readiness qualifies and expires; Runtime executes; and Human review retains consequential judgment. None of those owners is collapsed here.

The claim remains at argument support. The source notes support architecture discussion of low-rank residual transforms, artifact-to-tensor conversion, WORM archive assumptions, manifests, codec parameters, reconstruction checks, and deterministic decode obligations. They do not support measured compression-performance claims in this repo.

63.6.2 Publication placement and preserved technical ownership

This chapter is the stable technical-method route beneath Compact Generative Systems and Residual Honesty. The parent owns the general representation-leasing, reconstruction, repair, fallback, and residual-custody argument. RankFold/NeuralFold retains the candidate transforms, artifact format, decoder contract, access-pattern probes, WORM economics, local import and replay records, proof targets, and benchmark burden. Publication nesting transfers no claim, source, proof, test, evidence, or authority, and it does not change this chapter’s argument support ceiling or stable URL.

63.6.3 Claim-source mapping status

Appendix C carries exact passage-reviewed mappings for all six assigned sources. Five local lineage sources support low-rank/tensor architecture, manifests, deterministic decode obligations, residual and fallback accounting, reconstruction contracts, and resource pressure. RAPTOR supplies a hierarchical-summary comparator. None supports measured RankFold/NeuralFold performance, codec correctness, lossless reconstruction, downstream utility, or local superiority.

63.6.4 Concrete RankFold Artifact Import

The RankFold artifact import (docs/rankfold_artifact_import.md) records three existing local .rfa archive observations without copying dataset bytes or archive bytes into this repository. Each archive is associated with the same 100,000,000-byte decoded artifact SHA-256 digest, 2b49720ec4d78c3c9fabaee6e4179a5e997302b3a70029f30f2d582218c024a8. The smallest recorded archive is 36,148,844 bytes, yielding an observed decoded/archive ratio of 2.76634019 and archive/decoded ratio of 0.36148844 inside the recorded artifact set. rfa verify reported 1 OK, 0 failed for each archive, and rfa inspect reported one unencrypted __pack0__ stream, one page, one entry, total original 95.37 MB, and codec mix NEURAL0: 1.

This is not a fresh compression benchmark and does not prove RankFold codec correctness, deterministic decoder correctness beyond the recorded local decoded digest observations, compression from source input, downstream utility, fallback execution, deployed compression behavior, or chapter-core support-state promotion. It does not promote the RankFold chapter core claim. It is useful because the book now has a concrete local artifact surface to discuss while still keeping the broader compression claim at argument.

The matching no-promotion decision, evidence_transitions/v1_x_measured/rankfold_artifact_import_no_change.json, keeps this import at argument and records blocks_promotion until a fresh public-safe compression run, clean or archived source state, decoder review, downstream utility, fallback execution, and independent review exist.

63.6.5 Concrete RankFold Public-Safe Replay Probe

The RankFold public-safe replay probe (docs/rankfold_public_safe_probe.md) adds a fresh local command run rather than another static import. It generates a 3,936-byte synthetic text fixture with SHA-256 0905e48dec0a93d748907b26206c5f908b47dcefb3630a13571c3013effc2523, packs it with the local rfa binary, verifies the resulting archive, lists it, unpacks it, and checks that the unpacked file is byte-identical to the input. The run also mutates one archive byte and records that rfa verify rejects the corrupted archive.

The local CLI reported NeuralFold is disabled by license, so the observed fresh replay used RAW0 / Raw (stored). The recorded archive was 4,434 bytes for a 3,936-byte input, so no compression advantage was observed. This is a roundtrip-exact replay and negative-control record only. It does not prove RankFold codec correctness, NeuralFold compression, compression advantage, benchmark performance, downstream utility, fallback execution, deployed compression behavior, or support-state promotion. It does not promote the RankFold chapter core claim.

The matching no-promotion decision, evidence_transitions/v1_x_measured/rankfold_public_safe_replay_probe_no_change.json, keeps this replay at argument and records blocks_promotion until an enabled NeuralFold path, public-safe corpus, decoder review, downstream utility, fallback execution, and independent review exist.

63.6.6 Source support boundaries

Source What it supports Limit
rankfold_neuralfold Variant-family architecture for a universal container, RankFold predictor/corrector and EARO refinement, bounded residual coding, NeuralFold field and byte paths, probe-route-fallback policy, WORM economics, manifests, deterministic decode, Rust/WASM interfaces, fuzz/integration tests, and reconstruction checks. No local enabled NeuralFold encode, codec-correctness result, corpus benchmark, reproduced ratio, router calibration, utility probe, cross-target decoder result, economic result, or product claim follows from the source.
rankfold_compressor Correction lineage from speculative MatrixFold shortcuts to a bounded lossy RankFold codec: finite-description accounting, predictor/corrector and EARO, bounded residual coding, unfolding/blocking, progressive preview/refinement, production probing, deterministic Rust architecture, and RD-fair evaluation. Early hyper-precision, arbitrary-matrix bijection, quantum/fractal/program, recursive-exponential, lossless, benchmark, SOTA, latency, energy, cryptographic, and code-availability claims are rejected or unsupported. No reported ratio or implementation is reproduced here.
bbvca_v9 Reconstruction contracts, exact repairs, bounded verification, fallback, interface costs, and proxy/final-rate separation for artifact compression discipline. Does not provide local RankFold performance evidence, artifact utility evidence, or codec correctness.
cgs Compact seeds, generated structure, residual channels, verification contracts, governance interfaces, and hidden-complexity accounting. Does not prove that any compressed artifact preserves downstream utility or cost advantage.
bugbrain Tiny/local cognition, storage paging, embedded workflow, and edge-efficiency concerns that make artifact size and runtime burden visible. Speculative prototype-lineage source; no embedded runtime, paging behavior, artifact compressor, or hardware benchmark has been validated.
ext_raptor_2024 Recursive abstraction and hierarchical retrieval as a compact-view comparator. Metadata-first note only; no local tree, fidelity, reconstruction, provenance, utility, or RankFold comparison result.

63.6.7 Compression proposes; transfer disposes

Retrospective compression asks whether a representation describes solved artifacts more compactly. Prospective compression asks whether it shortens the best known description of future solutions. Neither quantity establishes that a bounded search process will discover those solutions more often, sooner, or more cheaply. Adding a valid abstraction enlarges the available vocabulary and can worsen discoverability when retrieval, branching, or verification overhead dominates its shorter description.

This makes compression a proposal mechanism. Reuse traces can show that a candidate entered a solution; removal can show that it was necessary under one search process; only a matched future-task intervention can show marginal benefit. RankFold and NeuralFold remain responsible for representation, reconstruction, routing, fidelity, and codec economics. The benchmark owner measures transfer, and the resource owner prices the whole route.

The source paper supplies finite counterexamples and an evaluation design, not a RankFold or NeuralFold experiment. No compression ratio, artifact utility, search improvement, or support state changes here.

63.6.8 What “universal” means—and does not mean

The local RankFold/NeuralFold source is a bundle of technical papers, implementation specifications, and product plans rather than one stable edition. Its technical core is consistent, but its module boundary is not. Some variants call NeuralFold an optional expansion after a tensor-codec wedge. Others call it mandatory or inseparable because the name covers inspection, routing, and fallback in addition to neural representations. The book preserves the conflict instead of manufacturing consensus: the invariant is a mandatory typed routing and fallback function; whether that function and both learned front-ends ship in one module named NeuralFold is packaging.

The source also uses “universal” in several senses that must not collapse:

Universality claim Defensible design meaning What remains unproved
Container universality A common indexed container can carry tensor, field, byte/bundle, and conventional-codec streams. Frozen format, interoperability, parser safety, or successful support for every artifact.
Routing universality Every admitted artifact can receive a typed candidate route, literal fallback, or refusal. Correct route selection, calibrated abstention, or bounded decision cost.
Representation breadth Proposed tensor, continuous-field, and discrete-byte paths cover several major artifact families. Adequacy, efficiency, or semantic preservation for all members of those families.
Compression-advantage universality None. The architecture explicitly permits RAW to win. Any claim that neural or low-rank encoding always compresses better.

This distinction is architectural, not rhetorical. A fallback makes a format able to store arbitrary bytes; it does not make every specialized route useful. The source’s later claims of superiority, novelty priority, market size, profitability, or ROI are product hypotheses. They are not compression evidence and do not enter the book’s claim ledger.

63.6.9 The MatrixFold correction: bits cannot hide in richer coordinates

The earlier RankFold Compressor bundle is valuable partly because it records a failed conceptual route. Its first MatrixFold drafts propose mapping an arbitrary matrix into fewer vector entries by using hyper-precision reals, probability distributions, topological or fractal objects, or short programs, then applying square reshaping and recursive compression. Later drafts abandon that claim and converge on the bounded RankFold codec below. The correction is an information-accounting lesson that applies well beyond this compressor.

A set-theoretic bijection between real spaces is not a finite code. If \(mn\) finite-precision values are digit-interleaved into \(m+n\) “hyper-precision” scalars, the missing bits live in the precision of those scalars. A rank-one outer product \(uv^\top\) uses fewer ordinary coordinates only when the matrix actually satisfies the rank-one constraint. A general matrix must pay for higher rank, a residual, or a richer decoder. The scaling freedom \(uv^\top=(cu)(v/c)^\top\) further warns that stored coordinates and independent degrees of freedom are not interchangeable counts.

Square reshaping has a similarly narrow truth. For fixed \(K=mn\), \(m+K/m\) is smallest near a square; this minimizes the nominal shape of a rank-one factor pair. It does not prove the reshaped values are low-rank, low-entropy, locality-preserving, or cheap under a coder. Shape and unfolding are search variables whose permutation, inverse map, search budget, and metadata count. They must beat domain-native views, blocking, and no reshape on actual bytes.

Nor may a recursive codec multiply ratios measured at changing denominators. For transforms \(T_1,\ldots,T_k\), the only admissible rate is the final payload plus every stage descriptor, model, parameter, decoder, residual, and repair:

\[ B_{\mathrm{complete}}= B_{T_k\circ\cdots\circ T_1(x)} +\sum_{j=1}^{k}B_{\mathrm{stage}_j} +B_{\mathrm{residuals}}+B_{\mathrm{decoder}}. \]

Multistage and recursive transforms can be useful, but each new stage must show marginal actual-byte or utility benefit over the best direct route. Entropy reduction is not guaranteed on an already coded stream, and removed redundancy cannot be credited twice.

The same rule governs distributions, diffusion priors, manifolds, fractal attractors, and programs. These can be powerful description families for structured artifacts, but a distribution is not its sampled artifact and a generator is not an exact code without its parameters, shared state, numerical semantics, and residual closure. Kolmogorov complexity supplies an ideal limit, not a generally computable encoder. Contraction of a proposed fractal map does not establish that its attractor is the target. The early “quantum-inspired,” cryptographic, robustness, energy, and exponential-gain claims therefore remain non-claims.

This source lineage also illustrates why editorial confidence is not evidence. Its successive tabs repeat ratios, latency, A100 settings, benchmark tables, and statements that a red team accepted the mechanism or a draft is camera-ready. No local corpus, code, bitstream, output log, environment, baseline receipt, or reproducible run accompanies those values. The book uses the equations and test obligations, not the numbers. Later narrowing from arbitrary lossless compression to a lossy tensor-specific rate–distortion candidate controls all earlier versions.

63.6.10 The RankFold candidate codec

RankFold starts with a matrix or tensor unfolding \(M\), rank \(r\), factors \(U,V\), and quantization step \(\Delta\):

\[ P=UV^\top,\qquad E_q=\left\lfloor\frac{M-P}{\Delta}\right\rceil,\qquad \widehat M=P+\Delta E_q. \]

Unlike a headline “low rank means small” argument, the archive bill includes the header, both factors, and coded residual. The candidate only wins if

\[ B_{\mathrm{header}}+B_U+B_V+B_{\mathrm{residual}} < B_{\mathrm{strongest\ qualified\ baseline}} \]

under the same reconstruction contract. Predictor precision, tensor unfolding, traversal order, code tables, and side information therefore belong in the receipt. A factorization can reduce squared error and still increase the final bitstream.

The factor blobs also suggest a useful progressive route. A consumer can load \(U,V\) first for a rank-\(r\) preview, then decode residual layers to reach the stored reconstruction. That route earns only the utility measured at each prefix. It must report bytes, latency, distortion, task behavior, residual ordering, and any non-monotonic regression. Deterministically reproducing the stored \(\widehat M\) after the full residual is not the same as recovering the original FP32 byte string; a true lossless mode needs an original-byte repair channel.

The proposed Entropy-Aware Rank Optimization (EARO) makes that mismatch an optimization target. Starting from truncated or deterministic approximate SVD, it refines \(U,V\) against a coder-motivated proxy:

\[ \mathcal L(U,V)= \sum_{i,j}\log\left(1+\frac{|E_{q,ij}|}{\delta}\right) +\lambda(\lVert U\rVert_F^2+\lVert V\rVert_F^2), \]

using a straight-through estimator through quantization. Because \(Z=(M-UV^\top)/\Delta\), an implementation must retain the \(1/\Delta\) gradient scaling. The suggested Adam step count is an initial setting, not a result.

The corresponding residual coder has a bounded alphabet. It traverses quantized residuals row-major or in tiled Morton order, encodes zero runs with Rice or bucketed rANS, emits one sign bit per nonzero, represents small magnitudes in a finite rANS alphabet, and sends large magnitudes through an escape symbol plus Exp-Golomb- or Elias-style coding. This makes table size and outlier behavior explicit. Traversal and escape coding remain ablations, not presumed wins.

The proxy is vulnerable to Goodharting. Every run must therefore report surrogate-versus-actual-bit correlation, factor and residual byte breakdowns, escape rate, and sensitivity to rank, quantization, and optimization steps. Periodic “true bytes in the loop” can detect drift during training, but the serialized stream—not the differentiable proxy—adjudicates the rate claim.

63.6.11 The NeuralFold candidate front-ends

NF-FIELD fits a coordinate function to an image, audio signal, video, or scientific field. Model specification, coordinate normalization, tiling, weights, distortion target, and decode budget all travel in the stream. Tiling supports random access and bounded decode, but adds boundaries and metadata. This route is normally lossy: exactly decoding the stored network is not the same as exactly reconstructing the source signal.

NF-BYTE predicts bundle bytes and retains a lossless residual, for example \(R[i]=B[i]\mathbin{\mathrm{xor}}\widehat B[i]\). Exactness requires the same predictor behavior, the complete residual, and a bundle table that restores paths, offsets, and required metadata. Random or already-compressed bytes should leave a high-entropy residual and route to a conventional codec. The predictor’s weights and compute are not free merely because the residual is small.

Both paths use two stages: fit the artifact contract, then fine-tune the parameters against a RankFold-aligned rate proxy while retaining the distortion or residual constraint. This is a co-design hypothesis. An adequate field model that stores badly and a compact model that violates the reconstruction contract both lose.

63.6.12 Probe accuracy is part of compression performance

Before a costly route, a bounded probe estimates metadata, compressed weights, residual or raw payload, and applicable encode/decode constraints. The source offers a 3–5% “honesty margin” as an example before accepting a neural win. The book does not promote that number into a default. A margin must be calibrated prospectively from estimator error, route costs, workload shift, and the asymmetric harm of false admissions versus missed savings.

A router report therefore includes predicted and achieved bytes by route, route confusion, excess work spent on losing probes, missed wins, false neural admissions, constraint violations, fallback frequency, and decode burden. Its baseline is a strong type-aware conventional router, not a fixed weak codec. Already-compressed, encrypted, tiny, adversarial, and high-entropy artifacts are mandatory controls.

63.6.13 WORM economics and implementation closure

RankFold/NeuralFold is a WORM proposal. Expensive per-artifact search is justified only if retention duration, avoided storage, or repeated transfers and reads amortize encoding, pilot, verification, and migration cost. Hot or mutable checkpoints, rare reads, latency-critical retrieval, and mandatory full-copy retention can reverse the result. ROI is therefore measured over an access-pattern horizon; a vendor price inserted into a formula is not an economic result.

The implementation lineage usefully separates container, router, RankFold, NeuralFold, entropy, tensor, CLI, and optional WASM surfaces. A rational order is RAW container and golden vectors, one tensor codec with independent decode, minimal RF-TENSOR/RAW routing, then field, byte, and browser paths. Open coder, traversal, initializer, field-model, and byte-predictor interfaces keep research changes from silently changing archive identity.

Decode determinism is harder and more important than repeatable training. It requires fixed endianness and rounding, stable bit layouts, bounded output, validated entropy tables, explicit arithmetic/platform envelopes, and cross-target golden vectors. Malformed offsets, corrupt tables, truncated streams, oversized dimensions, decompression bombs, dependency drift, and native/WASM disagreement must fail closed. Browser-local execution can reduce upload exposure, but it does not prove privacy or compliance; signed local license tokens deter forgery but cannot make client-side code unpatchable.

These details produce a stricter falsification program. EARO narrows if SVD with the identical coder matches it, if lower proxy loss does not lower actual bytes, or if factor/metadata costs erase the gain. NeuralFold narrows if strong domain codecs win, its residual remains expensive, or decode cost breaks the use contract. The system-level claim narrows if the router cannot distinguish winning paths or WORM amortization fails. Those are informative results, not excuses to weaken the baseline.

63.6.14 Compressed-artifact admission lifecycle

Stage Required record Rejecting condition and route
1. Preserve Source digest, custody, rights, retention, full fallback Missing or unlawfully retained source blocks encoding or routes to rights review.
2. Scope Consumer, task, access pattern, risk, exactness, loss, horizon Undeclared use remains not_admitted.
3. Version Encoder, decoder, arithmetic, serialization, platform, dependencies, parameters, seeds Unversioned execution cannot claim replay or ratio.
4. Separate claims Representation, reconstruction, ratio, utility, latency, authority, support Evidence for one ledger cannot promote another.
5. Close bytes Payload plus every header, index, manifest, parameter, environment, dictionary, seed, residual, repair, replica, and fallback Hidden bytes invalidate the ratio receipt.
6. Encode Transform only within the declared reconstruction contract Out-of-contract transform is quarantined.
7. Retain residuals Typed omissions, losses, uncertainty, and repairs Missing or detached residual blocks admission.
8. Decode Deterministic, exact-replay, corrupt, truncated, drift, and cross-platform checks as required Failed or unknown decode routes to quarantine or full artifact.
9. Probe Common, rare, adversarial, provenance-, citation-, and rights-sensitive task cases Failed probe routes to fallback or refusal.
10. Estimate coverage Probe distribution, blind spots, and out-of-envelope detector Unrepresentative coverage blocks generalization.
11. Exercise fallback Authorized, observable, timed full-artifact or refusal path Merely named fallback is not operational evidence.
12. Close burden Encode, storage, transfer, decode, verification, probe, fallback, recovery, human, governance, displaced work Partial accounting cannot establish cost advantage.
13. Compare Strong literal, standard-codec, quantized, sparse, low-rank, retrieval, summary, cache, and no-compression controls Weak or unmatched baselines block comparative language.
14. Bind lineage Source, job, code, environment, receipts, probes, residuals, fallback, descendants Detached compact artifacts cannot enter evidence routes.
15. Gate authority Preview, summary, embedding, citation, audit, legal, benchmark, and proof uses Compact view cannot inherit source authority.
16. Expire Source, decoder, dependency, platform, consumer, workload, rights, threat, policy, and time changes Affected leases expire prospectively.
17. Quarantine and recover Drift, disagreement, loss, provenance damage, unavailable fallback Block use, preserve evidence, restore source path, and retest.
18. Adjudicate Claim-specific promote, narrow, refute, deprecate, or no-change transition Green validators alone have no support effect.

63.6.15 Functional precision: preserve behavior, not coordinates

The Precision Contract sharpens what the admission lifecycle is optimizing. “How many bits does this weight need?” has no representation-independent answer. Function-preserving rescaling, permutation, basis changes, codebooks, factorizations, limb decompositions, external decoders, and serialization choices can change apparent magnitudes and bit widths without changing the realized computation. Parameter distance can be useful inside a fixed representation, but it is not the protected object.

The stable question is contract-relative:

Among complete executable implementations, which has the lowest declared description or physical cost while preserving the protected behavior within the deployment contract?

The contract identifies the domain, excluded cases, protected behaviors, metric vector, tail and aggregation rules, confidence, resource limits, fallback, escalation, abstention, and exact reference identities. The acceptable set is therefore a behavioral-equivalence class relative to that contract. Two artifacts may be far apart in parameter space and equivalent for one bounded consumer; two nearby parameter vectors may differ on a rare, calibrated, abstention-sensitive, or high-consequence slice.

Four contract classes prevent one evidence style from impersonating another. A distributional contract controls an expectation or quantile under a named sampling process. A conditional contract protects each named slice instead of averaging it into the majority. A worst-case or formal contract requires a predicate over a finite region and states the abstraction and proof coverage. An adaptive contract qualifies both several execution levels and the router that chooses among them. These classes can be conjoined: a model may need broad distributional utility, conditional tail protection, one formally checked arithmetic invariant, and a conservative adaptive fallback.

For a reference system \(M\), candidate decoder \(\mathsf{Dec}\), code \(z\), and precision contract \(\mathcal C\), the paper’s target is

\[ R^\star(M,\mathcal C) = \min_z\left\{L(z): \operatorname{SAT}(\mathcal C,\mathsf{Dec}(z))=1\right\}. \]

This is a comparison target, not a computable universal constant. It is relative to the contract, candidate code family, decoder, shared side information, platform, and accounting boundary. Relaxing a tolerance cannot raise the mathematical optimum, while strengthening a contract cannot lower it; a particular heuristic or bit-width ladder need not behave monotonically. The “behavioral quotient” language is exact only when the chosen relation is reflexive, symmetric, and transitive. Distribution-limited or asymmetric tests usually define a contract-acceptable neighborhood instead, and the certificate must not promote that neighborhood into global equivalence.

Complete description length counts more than payload values:

\[ L_{\text{complete}} = L_{\text{values}} + L_{\text{structure}} + L_{\text{indices}} + L_{\text{scales/codebooks}} + L_{\text{residuals}} + L_{\text{decoder/runtime}} + L_{\text{routing}} + L_{\text{verification/assurance}}. \]

The same honesty applies to physical cost: stored bytes, moved bytes, decode operations, latency, memory pressure, energy, verification, fallback, repair, and certificate generation remain separate terms. A representation is not compact merely because the headline checkpoint is small.

Precision is therefore a field, not one model-wide integer. Different layers, channels, directions, tokens, tasks, uncertainty states, and consequence classes may justify different numerical treatment. A cheap base encoding can be paired with ordered residual precision planes. The route uses the base only where the protected contract remains satisfied; it adds residuals, falls back to the reference, abstains, or escalates elsewhere. Residual order and routing are themselves qualified artifacts whose cost and attack surface count.

63.6.16 Functional Precision Compiler

The primary compressed-artifact owner uses a ten-stage compiler:

  1. Reference: freeze model, runtime, task contract, evaluator, evidence policy, and resource envelope.
  2. Canonicalize: normalize known coordinate and serialization freedoms before interpreting magnitude or sensitivity.
  3. Measure: estimate functional and contract-level distortion; treat curvature and salience as proxies, not guarantees.
  4. Transform: propose quantization, pruning, factorization, codebook, mixed-precision, and residual candidates.
  5. Allocate: assign precision by marginal protected-behavior benefit per marginal physical cost.
  6. Encode: account for the complete executable package.
  7. Layer residuals: order optional refinement planes while preserving a safe terminal route.
  8. Route: choose base, refined, reference, abstention, or escalation from observable signals.
  9. Verify: test protected slices, shifts, calibration, cost, and recovery.
  10. Certify: bind scope, identities, evidence, limits, expiry, revocation, fallback, and non-claims.
flowchart LR
    R["Reference + protected contract"] --> C["Canonicalize"]
    C --> M["Measure functional distortion"]
    M --> T["Transform and allocate"]
    T --> B["Base + residual bundle"]
    B --> Q{"Contract-preserving route?"}
    Q -->|base| E["Execute base"]
    Q -->|refine| P["Add precision plane"]
    Q -->|uncertain| F["Reference / abstain / escalate"]
    E --> V["Verify and certify"]
    P --> V
    F --> V

A PrecisionCertificate is a scoped admission receipt, not a declaration of optimality. It binds the reference and transformed artifact, decoder, kernels, runtime, platform, contract, evaluator, evidence, costs, residuals, fallback, validity window, and revocation state. A changed kernel, platform, domain, decoder, model descendant, or evaluator can expire the certificate even when the payload bytes are unchanged.

The certificate also keeps four bit classes and six states explicit. Ordinary numeric values are representational bits; shapes, scales, codebooks, indices, transforms, and routing tables are structural bits; exceptions, adapters, and refinement planes are residual bits; hashes, manifests, tests, proof objects, exception lists, and expiry rules are assurance bits. Their stored sizes are reported separately from the compute and human work needed to produce and maintain assurance. CERTIFIED, PROVISIONAL, DOMAIN_RESTRICTED, UNSAT, UNVERIFIED, and REVOKED are scoped states, not confidence adjectives. Evidence is property-specific: exact proof or exhaustive checking, sound regional bounds, adversarial stress with statistical guarantees, held-out evaluation, calibration-only proxies, and tensor error form a descending ladder. Lower rungs can guide search but cannot silently support claims belonging to higher rungs.

The falsification program is an eight-experiment matrix rather than one headline quantization score:

Experiment Competent comparison Decisive narrowing result
Reparameterization stress Naïve, canonicalized, reparameterization-aware, and contract-aware quantization across exactly equivalent models Canonicalization adds little if outcomes and allocations are already stable, and becomes optional if it harms the best frontier.
Parameter versus behavioral distance Matched reconstruction errors across random, high-/low-sensitivity, outlier, and protected-circuit perturbations The added framework narrows if simple error predicts every protected metric as well.
Complete accounting Nominal bits versus exact package bytes, movement, peak memory, latency, energy, routing, and certificates Accounting remains conceptually required but practically minor if overhead never changes rankings.
Progressive residual curves Numeric, magnitude, Hessian, contract-benefit, and random orderings against matched static checkpoints Fixed precision wins where ordering adds no consistent benefit or higher levels regress protected behavior.
Aggregate-equivalence illusion Aggregate parity versus decision, slice, calibration, safety, multilingual, long-context, tool, and consequence metrics A vector contract adds little where aggregate metrics reliably upper-bound every protected difference.
Static versus routed precision Strong uniform, static mixed, generic-confidence, contract router, reference, and oracle routes Dynamic routing loses when false negatives, overhead, shift, or attack surface erase the gain.
Certificate discrimination Constructed candidates that each pass a proxy but fail an independent protected obligation The certificate is bureaucracy if it cannot assign the intended UNSAT, restricted, provisional, or revoked state.
Shift and rare-event stress Calibration/deployment shifts across language, context, domain, scale, environment, and adversaries Static allocation may suffice if it remains stable; certification must narrow if drift detection lags failures.

The cross-model suite spans a small verifiable classifier, scientific surrogate or controller, language models at several scales and architectures, a tool-using agent, and an exact synthetic task. Calibration and validation remain disjoint where independence is claimed. All model, tokenizer, sampler, format, accumulator, KV state, kernel, data, seed, confidence interval, multiple-testing, hardware, and unsupported-region details travel with the result. A weak round-to-nearest toy can debug this pipeline; it cannot falsify the architecture.

63.7 Mechanism

Artifact compression is where representation cost meets task routing. RankFold/NeuralFold supplies the archive framing: per-artifact transforms, residual coding aligned to actual bit cost, manifests, deterministic decode, WORM assumptions, and tests. BBVCA v9 supplies reconstruction-contract and repair-stream discipline. CGS supplies residual honesty, while BugBrain keeps the edge/local resource pressure visible. The routing question is not whether a compressed artifact is impressive; it is whether this task can use it without losing the constraints that matter.

A compressed artifact is therefore not a cheaper source of truth. It is a routed representation candidate with a preserved full-artifact fallback. The full artifact remains the reference unless reconstruction, probe, utility, and cost records justify a narrower use. This keeps storage savings from silently becoming evidence loss.

A Compressed Artifact Record therefore carries task family, access pattern, admission state, reconstruction, declared use envelope, metadata cost, residual, probe, fallback trigger, exact-replay status, consumer policy, support-state effect, evidence, and utility fields. The probe is the routing boundary: if the compressed form cannot answer the task’s needs, the route falls back to the full artifact.

flowchart LR
  A["Source artifact"] --> Z["Preserved full artifact"]
  A --> B["Compression method"]
  B --> C["Codec parameters + manifest"]
  C --> D["Residual coding"]
  D --> E["Decode / reconstruction check"]
  E --> F{"Task probe passes?"}
  F -- "yes" --> G["Use compressed artifact"]
  F -- "no" --> H["Route to full artifact"]
  Z --> H
  G --> I["Cost, utility, and non-claim ledger"]
  H --> I

What the compressed artifact gate shows: The compressed artifact is a candidate route, not a replacement for the preserved source artifact. Reconstruction checks, task probes, fallback triggers, and non-claim ledgers decide whether the compressed form is usable for a specific task.

A compressed artifact record distinguishes four claims that are often collapsed:

  • Representation claim: the artifact can be mapped into the chosen form.
  • Reconstruction claim: decoding reproduces the required target under a contract.
  • Compression claim: serialized size improves against a baseline after metadata and residuals.
  • Utility claim: downstream tasks still work at acceptable quality and latency.

Each claim can fail separately. The architecture should preserve that separation instead of letting a good ratio imply task utility or a useful lossy representation imply exact reconstruction.

The operational rule is simple: compression can save cost only inside a declared use envelope. That same record says which task family the compressed form serves, what loss or residual is allowed, how fallback is triggered, how often fallback happens, and which non-claims must travel with the artifact. A compressed artifact without those fields is a cost experiment, not an evidence-bearing representation.

63.7.1 Artifact-compression states

State Meaning Consequence
not_admitted The compressed form lacks required manifest, probe, residual, fallback, or decode metadata. Cannot be routed to consumers.
cold_archive_candidate The form may be useful for rarely read, write-once artifacts after decode checks. Eligible for archive experiments only.
preview_only The form supports browsing, routing, or rough inspection but not exact replay. Must carry loss/non-claim labels.
task_probe_passed A bounded task probe passed under the declared use envelope. May be routed for that task family.
exact_replay_ready Decode determinism and reconstruction contract passed for the target. May support exact-replay consumers if cost permits.
fallback_dominant Probe failures or decode costs make the full artifact the normal route. Keep full artifact as default and record negative evidence.
decoder_quarantined Platform, dependency, floating-point, or manifest drift broke deterministic decode. Block exactness and route to full artifact.

These states keep WORM archive logic from leaking into every use case. A compressed form can be excellent for deep archive and still inappropriate for an active planning context, a citation audit, or a benchmark trace.

63.8 Interfaces

Compressed artifacts hand off through the Compressed Artifact Record.

Minimum fields:

  • artifact_id
  • source_artifact
  • task_family
  • access_pattern
  • admission_state
  • compression_method
  • reconstruction_contract
  • declared_use_envelope
  • ratio_claim_state
  • codec_parameters
  • metadata_costs
  • residual_coding
  • probe_plan
  • fallback_artifact
  • fallback_trigger
  • decode_determinism
  • exact_replay_status
  • consumer_policy
  • utility_tests
  • support_state_effect
  • evidence_refs
  • non_claims

Artifact graphs store compressed and full references. Routing selects the representation by task and probe. Evidence records ratio, latency, residual size, decoder determinism, utility, and fallback frequency. Resource economics decides whether encoding cost is justified by the access pattern.

The twelve-owner handoff is explicit:

Owner Retained responsibility
Artifact Graph Source and compact digests, lineage, descendants, retention, replay.
Compressed Artifact Record Use envelope, codec identity, reconstruction contract, residuals, admission, non-claims.
Context Adequacy for the current transaction without source substitution.
Routing Compact, full, or refusal route by consumer, task, risk, and lease state.
Verification Decode, reconstruction, corruption, replay, probe, and evaluator receipts.
Resource Economics All bytes, operations, latency, energy, human, governance, and displaced work.
Claim Ledgers Separate representation, reconstruction, ratio, utility, latency, authority, deployment, and SOTA states.
Security Decoder supply chain, parser isolation, malicious archives, drift, quarantine.
Rights and Provenance Transformation permission, retention, deletion propagation, attribution, audit.
Readiness Qualification, expiry, rollback, and residual escrow.
Runtime Permissioned decode, probe, fallback, refusal, recovery, telemetry.
Human review Source/compact comparison, differences, residuals, probes, consequential judgment.

The artifact graph matters here because the compressed record should never stand alone. It should point back to the preserved full artifact, the codec manifest, the source/job that produced it, and any evaluation artifacts used to justify routing. That connection gives later readers and agents a way to distinguish source-reported compression lineage from locally reproduced compression behavior.

The compression record also declares an access pattern:

  • cold archival storage
  • warm retrieval cache
  • hot planning context
  • exact replay
  • semantic preview
  • benchmark or evaluation input
  • legal, citation, or governance audit

Compression decisions should be allowed to differ across these patterns. A slow but compact decode may be acceptable for cold archive. A fast lossy preview may be useful for routing. Neither is automatically suitable for exact replay or audit.

63.9 Invariants

  • The preserved full artifact remains retrievable and digest-bound for every admitted compact route unless an explicit lawful deletion policy says otherwise.
  • Admission is specific to artifact, consumer, task, access pattern, risk, decoder, platform, and time.
  • Representation success never implies reconstruction, compression advantage, utility, latency, authority, deployment, or SOTA.
  • Exactness names target bytes or semantics, arithmetic, serialization, tolerance, platform envelope, and verifier.
  • Ratios include metadata, code, parameters, environments, dictionaries, seeds, residuals, repairs, indexes, replicas, and fallback storage in scope.
  • Every omitted or lossy feature is inside the declared loss envelope or preserved as an owned residual.
  • Task probes include rare and adversarial cases and report sampled coverage and blind spots.
  • Failed, uncertain, expired, or out-of-envelope probes cannot route the compact artifact to that consumer.
  • Fallback is executable, permissioned, observable, timed, and included in denominators.
  • Decoder and dependency drift invalidate affected exact-replay qualifications until reproduction succeeds again.
  • Previews, summaries, and embeddings cannot substitute for source citations or legal evidence without a specific admitted use.
  • Every consumer can recover source reference, codec manifest, evaluation receipts, residuals, and non-claims.
  • Failed, corrupt, cancelled, refused, quarantined, fallback, and human-reviewed attempts remain in denominators.
  • Utility is evaluated on downstream outcomes, not inferred from reconstruction metrics or size alone.
  • Cost advantage uses the declared access frequency and horizon after all encode, decode, verification, fallback, recovery, and governance burden.
  • Rights, deletion, retention, and provenance obligations propagate to compact forms, residuals, caches, backups, and descendants.
  • Support-state changes require an accepted evidence transition for the exact claim and scope.
  • Every expiry, quarantine, fallback failure, or unresolved residual has an owner and reopening condition.

Decode accountability is the hardest compression invariant: if the system cannot say what exact target is reconstructed, under which arithmetic and serialization assumptions, then it cannot claim exact compression.

Admission is always relative to use. A compressed artifact may be adequate for preview, search, routing, or approximate planning while remaining inadequate for proof, legal review, source interpretation, or final release. The admission record preserves which use was admitted, which verifier accepted it, which residual remained, and which fallback was available. Compression without a use-specific boundary becomes a quiet replacement of evidence with convenience.

63.10 Failure modes

  • Rare critical clauses, code paths, diagrams, formatting, or provenance are damaged while common probes pass.
  • The probe distribution is unrepresentative, leaked, too small, or optimized by the encoder.
  • Metadata, residuals, code, environments, indexes, replicas, and fallbacks erase the reported ratio.
  • Encode, decode, verification, or fallback latency erases savings at the declared access pattern.
  • A WORM cold-archive assumption is reused for hot, mutable, or repeatedly queried artifacts.
  • Floating-point, hardware, dependency, compiler, or serialization drift breaks deterministic decode.
  • A compact preview or summary is cited as though it were the preserved source.
  • Lossy semantic utility is laundered into a lossless reconstruction claim.
  • A successful reconstruction metric is laundered into downstream task utility or safety.
  • A local ratio is laundered into system cost advantage, deployment readiness, generality, or SOTA.
  • Fallback is missing, unauthorized, corrupt, slower than declared, or recursively compressed under the same failure.
  • Residuals are omitted, unqueryable, detached from the source, or costed outside the denominator.
  • Archive parsing or decoder dependencies introduce malicious-code, supply-chain, or denial-of-service risk.
  • Rights, deletion, retention, attribution, or export obligations fail to propagate to compact copies and descendants.
  • Selective reporting removes corrupt, refused, quarantined, slow, fallback, or human-reviewed cases.
  • Shared encoder, decoder, probe, evaluator, and implementation bugs create false independent agreement.
  • Admission remains live after source, decoder, platform, workload, consumer, policy, rights, or threat drift.
  • Governance and verification tax exceeds any storage or transfer benefit while the compact route remains institutionally sticky.

Probe failure should route to the full artifact. Rare-case damage should become a regression. Hidden encoder cost should move into resource accounting. Decoder drift should block exactness and preserve the full artifact until deterministic replay is restored.

The most dangerous failure is silent narrowing. A compressed representation may work on common examples and still erase rare clauses, unusual diagrams, edge-case source formatting, or provenance details that matter for governance. Artifact compression treats those misses as residuals, not as acceptable noise, unless the task explicitly declares them irrelevant.

63.11 Minimum Viable Implementation

A minimal artifact-compression lane is a compressed artifact record. The repository fixture validates that the record names task family, access pattern, admission state, method, reconstruction contract, declared use envelope, ratio claim state, codec parameters, metadata costs, residual coding, probe plan, fallback artifact, fallback trigger, decode determinism, exact-replay status, consumer policy, utility tests, support-state effect, evidence refs, and non-claims.

The compressed-artifact fixture does not produce a compressor result. It gives the public book an executable contract for evaluating one later.

The complete current MVI is narrower than the architectural contract: one 22-field schema fixture; one fresh 3,936-byte synthetic RAW0 pack/verify/list/unpack replay with byte-exact digest preservation, a 4,434-byte archive, no compression advantage, a license-disabled NeuralFold boundary, and one rejected single-byte mutation; three imported NEURAL0 archive metadata observations sharing one 100,000,000-byte decoded digest and reporting verifier success, but without a fresh encode; two no-change evidence transitions; two retained finite countermodels; and a 27-theorem, eight-stage, 53-route artifact-to-consumption refinement with 143/143 rejected mutations. Seventeen direct projections and flat route consequences are retired. The MVI establishes record shape, one exact local raw-storage roundtrip, one corrupt-archive rejection, bounded metadata consistency, and modeled lifecycle invariants only.

A first tiny synthetic replay now exists for the local rfa CLI, but it is not the adversarial artifact-compression harness required for stronger evidence. A fuller toy corpus with ordinary prose, tables, diagrams, citations, code blocks, and provenance metadata should follow. That future harness can ask whether a candidate compressor preserves the required target, reports residuals honestly, and falls back when the probe is outside the declared envelope. Until that harness exists, artifact compression remains a design rationale with executable record-shape checks, one RAW0 replay, and one static archive-import surface only.

63.12 Mature Research Target

Artifact compression needs an admission system before compressed forms can enter the stack. It treats compressed forms as routed candidates that must earn each use case instead of inheriting the authority of the full artifact.

Compressed artifacts are candidates for specific uses, not replacements for the original, until probes, decode behavior, residual coding, fallback, and consumer policy accept them. Artifact graphs preserve the full object, compression manifests, codec parameters, residual streams, metadata cost, decode-determinism assumptions, probe plans, admission state, fallback trigger, and declared use envelope for each compressed candidate.

Representation, reconstruction, compression-ratio, downstream-utility, latency, exact-replay, fallback-frequency, and decoder-drift claims remain separate so one passing property cannot promote the others. Routing selects by task family and access pattern. Resource economics decides whether cold archive, warm retrieval, hot planning, exact replay, preview, benchmark, or audit use justifies the encode/decode cost. Evidence ledgers preserve probes and negative results.

Compressed candidates move through not-admitted, cold-archive, preview-only, task-probe-passed, exact-replay-ready, fallback-dominant, and decoder-quarantined states. Repeated fallback teaches the router to use the full artifact. Deterministic decode failures block exactness. Rare-case loss, unrepresentative probes, hidden encoder cost, fallback-dominant latency, floating-point or dependency drift, archive-policy leakage, and evidence substitution become residuals, fallback routes, quarantine, or admission-state downgrades.

This artifact-compression admission layer is still an architectural target. The admission claim should remain argument until compression receipts, task probes, residual metadata, fallback-route fixtures, baseline comparisons, and reproduced compression reports show that compact artifacts remain useful under the jobs they are asked to support.

The competent full attempt is a preregistered causal campaign over a public-safe heterogeneous corpus containing prose, code, tables, diagrams, citations, binaries, tensors, rare cases, provenance, and rights metadata. It compares literal storage, optimized general-purpose and domain codecs, quantization, sparsity, low-rank methods, retrieval, hierarchical summaries, semantic previews, the enabled RankFold/NeuralFold candidate, and full-artifact fallback under matched artifacts, consumers, access frequencies, platforms, resources, rights, evaluators, and horizons. Exact and lossy contracts are evaluated separately. All bytes and operations, task outcomes, corruption, rare-case loss, citations, provenance, security, encode/decode latency, energy, fallback, recovery, human work, governance work, and displaced work remain in the joint frontier.

Causal ablations remove or corrupt residual coding, task probes, exactness checks, preserved fallback, metadata closure, admission state, expiry, and quarantine one at a time. Independent encoder, decoder, probe, evaluator, cost-meter, security, and fallback implementations must reproduce the predicted signatures. Transfer then spans artifacts, modalities, models, languages, organizations, platforms, rights regimes, attacks, updates, and time. A simpler codec or literal route winning is a valid refutation or narrowing result, not a failed project outcome.

63.13 Codex test plan

Test Purpose Status
Compressed artifact record fixture validation Validate that an artifact-compression record names task family, access pattern, admission state, method, contract, use envelope, ratio state, codec parameters, metadata costs, residuals, probes, fallback trigger, decode determinism, exact-replay status, consumer policy, utility tests, support-state effect, evidence refs, and non-claims. implemented; passing via python3 scripts/validate_protocol_examples.py
RankFold public-safe replay probe Validate a fresh local RankFold pack/verify/list/unpack replay over a generated public-safe synthetic text fixture, including RAW0 codec observation, roundtrip-exact digest preservation, no compression advantage, license-disabled NeuralFold boundary, and a single-byte archive mutation negative control. implemented via python3 scripts/validate_rankfold_public_safe_probe.py; no NeuralFold-compression, compression-advantage, codec-correctness, downstream-utility, fallback-execution, deployed-compression, or support-state-promotion claim
RankFold artifact import validation Validate the recorded public-safe local RankFold archive observations for 100,000,000-byte decoded artifact digest consensus, archive byte ratios up to 2.76634019 decoded/archive, rfa verify summaries of 1 OK, 0 failed, NEURAL0 inspect metadata, and non-claim boundaries. implemented via python3 scripts/validate_rankfold_artifact_import.py; no codec-correctness, benchmark-performance, downstream-utility, fallback-execution, deployed-compression, or support-state-promotion claim
Compression ratio test Check that reported ratios include metadata, parameters, seeds, manifests, and residuals. planned; not run
Probe-route fallback test Check that a failed task probe routes to the full artifact. planned; not run
Downstream utility preservation test Compare compressed and full artifacts on a bounded task suite. planned; not run
Access-pattern admission test Check that cold archive, hot retrieval, exact replay, preview, benchmark, and audit consumers receive only compressed artifacts admitted for their use envelope. planned; not run
Artifact compression request-to-closure refinement Bind full-source custody, exact identities, encoding and reconstruction obligations, probes, executable fallback, use admission, observed outcomes, residual closure, support, and effects. implemented in AsiStackProofs.ArtifactCompressionRefinement: 27 theorems, eight stages, 53 routes, arbitrary-run nine-field identity custody, non-authority, exact receipts, fallback monotonicity, accepted traces, composition, closure absorption, and 143/143 rejecting mutations; exact bounded artifacts and support/effect none; no codec, utility, deployment, transfer, or support claim

The implemented fixture row validates schema consistency only, and the implemented lifecycle row checks only a finite modeled route. The remaining rows require an actual compressor/decoder or a bounded toy surrogate, plus baseline artifacts and task probes; they are not reported results. When a behavioral test is implemented, future work should link to the command, fixture, environment notes, corpus, and result summary, and Appendix E should be regenerated or updated accordingly.

63.13.1 Formalization hooks

Tag Module Target Status
lean:compression.artifacts.operational_invariant AsiStackProofs.ArtifactCompressionRefinement A reachable artifact-to-consumption lifecycle requires full-source custody, exact identities, reconstruction checks, consumer probes, executable fallback, observed outcomes, and closure before a qualified use can complete. implemented
lean:compression.artifacts.failure_blocks_promotion AsiStackProofs.ArtifactCompressionRefinement Failed probes route to fallback, exact-replay gaps block use, raw ratios cannot promote support, and missing evidence transitions block consumption. implemented
lean:compression.artifacts.admission_lifecycle_route AsiStackProofs.ArtifactCompressionRefinement Eight stages and 53 independently consumed routes govern registration, encoding, verification, probing, fallback, admission, observed consumption, and closure without support or external-effect authority. implemented

The family now contains two retained finite countermodels in AsiStackProofs.ArtifactCompression and 27 lifecycle theorems in AsiStackProofs.ArtifactCompressionRefinement, for 29 live declarations across the two modules; seventeen projections and theorem-per-record routes remain physically retired. Across the chapter’s imported proof surfaces there are thirty-eight finite Lean declarations. The independent consumer recompiles the exact refinement surface, executes the seven-event exact-use and failed-probe fallback lifecycles, checks all eight prefix/suffix composition splits, preserves nine identities and zero support/effect authority at every reachable state, verifies fallback monotonicity, rejects all eight event kinds after closure, reaches all 53 routes, rejects 143/143 mutations, reruns the exact source validators, and binds the fixture, replay, import, and decisions by SHA-256.

This finite model does not prove decoder or codec correctness, NeuralFold reproduction, compression advantage, semantic or rare-case preservation, probe validity, downstream utility, behavioral fallback or recovery, security, resource benefit, deployment, transfer, support promotion, or a benchmark/SOTA result. Decoder, probe, utility, rare-case, cost, fallback, and outcome fields are authored gates rather than measurements.

63.14 Source crosswalk

Source ID Title Layer Planned use Readiness
rankfold_neuralfold RankFold + NeuralFold compression_representation Tensor/artifact compression. Low-rank residual coding plus functional preprocessing and probe-route fallback. source note available; local raw cache available
rankfold_compressor rankFold compressor compression_representation Alternate RankFold/NeuralFold source. source note available; local raw cache available
bbvca_v9 BBVCA_v9_final_public_release compression_representation Prefer v9. Generate-verify-repair compression from seeded local laws, bounded search, two-phase rate discipline. source note available; local raw cache available
cgs Compact Generative Systems compression_representation Smallest adequate structure that can generate/govern target without hiding residual complexity. source note available; local raw cache available
bugbrain BugBrain edge_efficiency_lineage Edge/resource-aware implementation context. source note available; local raw cache available
ext_raptor_2024 RAPTOR hierarchical_retrieval_and_abstraction Multi-level recursive-summary comparator for artifact compression, source bindings, omissions, and loss boundaries. source note available

The crosswalk keeps the implementation hypothesis bounded. rankfold_neuralfold supplies the mature artifact-archive framing, rankfold_compressor preserves low-rank/tensor lineage, bbvca_v9 supplies reconstruction and rate-accounting discipline, cgs supplies residual honesty, and bugbrain keeps edge-resource constraints visible. None of them should be used to report ratios until a decoder and benchmark harness exist.

63.14.1 Manifest source assignment reconciliation

These rows keep RankFold, NeuralFold, and Artifact Compression’s manifest assignments visible at their recorded review boundary. Passage review does not establish local reproduction, performance, safety, deployment, or support-state movement.

Source Intake role Boundary
precision_contract Metadata-first comparator: The Precision Contract: A Functional Rate–Distortion Theory for Behavior-Preserving Neural Computation. Corben-authored July 2026 theoretical and systems paper replacing universal per-weight precision questions with a contract-relative functional rate-distortion problem over complete executable descriptions. It proposes representation canonicalization, protected-behavior contracts, precision fields, progressive base/residual encoding, dynamic routing, full physical and assurance-cost accounting, a Functional Precision Compiler, and scoped precision certificates. Existing chapters are upgraded first; no universal bit bound, implemented compiler, preserved-behavior result, efficiency result, certificate validity, support promotion, SOTA, AGI, or ASI claim is inferred. No passage-level source claim, local implementation, reproduction, safety, performance, deployment, support-state, or ASI result is established by this reconciliation row.
forward_transfer_program_synthesis Passage-reviewed comparator: From Compression to Forward Transfer: Evaluating Reusable Knowledge in Program Synthesis. Separates retrospective and prospective compression from causal future-task benefit and supplies a finite warning that adding valid vocabulary can worsen bounded discoverability. No RankFold, NeuralFold, codec, search, or transfer experiment was run; compression remains candidate-generation evidence rather than utility evidence. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.

63.15 Summary

Artifact compression is a routing decision under evidence. A compressed artifact may be cheaper to store, but it becomes usable only when reconstruction, residuals, probes, fallback, utility, and cost accounting are explicit.

RankFold/NeuralFold belongs in the stack as a bounded implementation hypothesis: promising enough to specify, not proven enough to promote without a benchmark harness and deterministic decode checks. The focus then turns from artifact archives to resource accounting, where every shortcut has to pay for verification, fallback, metadata, latency, human review, and downstream repair somewhere in the stack.

The bridge is that artifact compression is never only a storage question. It changes which resource budget pays for retrieval, reconstruction, verification, proof review, audit, and human interpretation.

The governance stance is the same across artifact compression and resource accounting: never let an elegant representation outrun its fallback path. Compression earns authority one task, one probe, and one residual ledger at a time.

63.16 Evidence reconciliation (2026-07-16)

The invariant protocol, field meanings, and inference limits are stated once in Living Book Methodology. This packet contains only the chapter-specific projection; its authoritative per-atom rows are the rankfold-neuralfold-and-artifact-compression slice of experiments/claim_family_terminal_coverage/results/result.json.

The core remains blocked after full attempt at argument support. The strongest family attempt was KERC canonical-language and hierarchical-residual campaign. Its exact boundary is: The historical broad-efficiency transition is N1: the frozen implementation was inadequate, so broader KERC remains untested; two narrow finite observations survive, with no semantic, multilingual, production, energy, or core claim. Across 74 atoms, the terminal ledger records 74 blocked_after_full_attempt.

Chapter-specific field Value
Family / atom denominator CF-06 / 74 atoms
Terminal dispositions 74 blocked_after_full_attempt
Core rankfold-neuralfold-and-artifact-compression.core: blocked_after_full_attempt at argument
Core attempted / missing lanes causal, empirical, executable, formal, source-synthesis / normative, transfer
Attempted local lanes causal, empirical, executable, formal, source-synthesis
Missing or unproved lanes normative, transfer
Strongest family bundle KERC canonical-language and hierarchical-residual campaign (natural_work_and_end_to_end): A 192-record bilingual templated compiler/runtime study with 64 held-out records, five seeds, eight baseline families, 13 ablations, and 20 attacks.
Negative controls surface and kernel-native baselines; 13 ablations; 20 attacks; ten laundering mutations.
Accepted transitions none
Maximum inference The historical broad-efficiency transition is N1: the frozen implementation was inadequate, so broader KERC remains untested; two narrow finite observations survive, with no semantic, multilingual, production, energy, or core claim.
Reproduction / next burden Replay scripts/validate_p4_m8_kerc_campaign.py and scripts/validate_claim_family_terminal_program.py; fill the named atom-specific lanes under a new prospective protocol.

63.17 Handoff

Artifact compression asks whether a cheaper stored form can reconstruct enough structure for use. Resource Economics and Token Budgets asks whether that cheaper route is still cheaper after decode cost, verification tax, fallback frequency, metadata, human review, latency, energy, and downstream failures are counted. The stack therefore moves from compressed artifacts to the resource ledger that decides when representation shortcuts are worth using at all.