Cubrim-2 · research track

Global Addresser

Cubrim-2 asks a different question than the Cubrim-1 archiver: instead of squeezing bytes locally, can data be transmitted as short references (aiming for a sensible minimum — on the order of tens to a few hundred bytes) into shared, pre-distributed structures — the Valentov Universal Data Matrices? If sender and receiver already hold the same large structure, one can send instructions for selecting and assembling fragments rather than the object itself. This page is the live research log of that track: the hypothesis list and every status below come straight from the research database — nothing here is hardcoded or embellished.

The honest limit, stated first

A fixed short code can distinguish only a finite number of states, while the space of possible files grows exponentially with length — so a short address alone can never uniquely denote every long sequence. An address is meaningful only together with a catalog where the object already exists. And any honest result must charge the full cost: the addresses, the metadata, the residual data — and the shared matrix itself, which is only worth its size when amortized across many files and devices. Cubrim-2 therefore does not promise to “compress any file into 16 bytes”. It maps where global addressing genuinely beats local compression — and records, just as openly, where it structurally cannot.

Wave 1 — current state

All wave-1 hypotheses start as OPEN: formulated, not yet measured. Predicted levers are predictions. A measured result appears here only after a hypothesis has actually been probed.

NO-GO · 3 GO · 6 OPEN · 14 PROBED · 1

shared context (dictionary / fragments) · 4 identity dedup — reference ≪ payload on exact match · 3 structurally cannot win (boundary) · 4 infrastructure cost accounting · 10 near-match + delta · 3

Generated: 2026-07-14T20:11:46Z · db:addressor_hypotheses

Hypotheses · 24

AH-01 NO-GO W1 · 2026-07-13

Matrix as a shared dictionary

If a versioned, immutable global dictionary is fixed as a matrix section and transmission becomes dict_id + a stream compressed against it, then net bytes on small structured files (<128 KiB) drop versus plain local zstd, because a small file never has time to learn its own statistics.

Data class (Z): small structured files (JSON/HTML/logs/configs)
Address target: n/a
Predicted lever: >=25% on smalls (prediction), tending to 0 above 4 MiB
Ceiling category: shared context (dictionary / fragments)
Mechanism: ready-made context from the very first byte; one-time dictionary delivery amortized
Falsification test: corpus of real small files: gain <25% or the dictionary never amortizes -> NO-GO
Full cost (total_cost): address: 8 B dict_id · metadata: zstd frame header · residual: the ENTIRE compressed stream (not a reference scheme) · amortized: dict_size/N_files per device + one-time dictionary delivery.
Probe verdict: NO-GO by the pre-registered bar: a real zstd dictionary (110 KiB, hash-parity train/test split) yielded 2.94 pp absolute / 9.95% relative versus plain zstd-3 — far from the predicted >=25%. The lever exists but its magnitude is eaten by the strength of the local codec itself (Gotcha #11 family); the dictionary remains the baseline competitor for fragment schemes.
Measured result: {"date":"2026-07-14","probe":"W1-fragments-v1b-fair","split":{"test_bytes":320725794,"test_files":59936,"train_files":61704},"class_z":"small structured files (<128 KiB, text-ish), real KB","verdict":"NO-GO","dict_bytes":112640,"gain_abs_pp":2.94,"gain_rel_pct":9.95,"verdict_note":"NO-GO по пре-регистрированному бару: реальный zstd-словарь (110 КиБ, train\/test split по чётности хэша) дал 2.94 пп абсолютных \/ 9.95% относительных против плоского zstd-3 — далеко от предсказанных >=25%. Рычаг существует, но величина съедена силой самого локального кодека (семейство Gotcha #11); словарь остаётся полезным baseline-конкурентом для фрагментных схем.","L1_dict_ratio":0.2664,"L0_plain_ratio":0.2959}

AH-02 GO W1 · 2026-07-13

Matrix as a CAS chunk store (CDC)

If the matrix is a global content-addressable store of immutable CDC chunks, then net transmitted bytes on recurring content collapse to a sequence of 32 B hash references, because the receiver already holds the chunks and CDC survives shifts and inserts.

Data class (Z): OS images, packages, re-shared files, backups
Address target: 32 B
Predicted lever: hit_rate x (1 - 0.4%) by mass; enterprise backup literature reports 10-30x (external, not our measurement)
Ceiling category: identity dedup — reference ≪ payload on exact match
Mechanism: exact chunk dedup against the catalog; the receiver stores the chunks
Falsification test: chunk hit-rate by mass on a realistic multi-device mix; <30% -> only as a router mode (AH-18)
Full cost (total_cost): address: 32 B per chunk on hit · metadata: file manifest (chunk list, lengths, order) · residual: new chunks in full plus their upload · amortized: CAS storage x time + catalog (AH-09/10) + integrity (AH-21) + the first transfer of every block (AH-19).
Probe verdict: GO: chunk dup mass 43.01% on the 3-host union (the <30% falsification bar did not fire) plus a MEASURED competitive win of the charged Addresser over local zstd-3 (+7.81 pp with the 11.6 pp chunk-context penalty). The verdict is conditioned on realistic corpus composition; multi-device emulated by hash aggregation (AH-23), payload never left the hosts.
Measured result: {"cdc":{"max":65536,"min":2048,"avg_chunk":8192},"date":"2026-07-14","probe":"W1-dupmass-v0","corpus":{"host":"arcana-devs","files":204275,"roots":["~\/arcanada","~\/cubrim-sources","~\/cubr-cm-work\/cubrim-code"],"caveat":"single-host snapshot; cross-device realism via AH-23; worktree copies inflate dup-mass","total_bytes":8517809533},"verdict":"GO","competitive":{"date":"2026-07-14","codec":"zstd-3 both sides (level cancels out)","probe":"W1-competitive-v1","corpus":{"host":"arcana-devs","files":197910,"caveat":"single-host; worktree copies inflate dup-mass; cross-device pending AH-23","total_bytes":8709420841},"local_ratio":0.5562,"charge_terms":{"refs_bytes":42971680,"catalog_bytes":21690132,"residual_comp_bytes":4099360171},"verdict_note":"REAL competitive win of the charged Addresser over local compression on this corpus (+7.81 pp) despite the 11.6 pp chunk-context penalty; the operator's criterion (net bytes < local compression with reference << payload) is MET on the single-host slice; GO after cross-device confirmation (AH-23, delivered).","win_delta_pct":7.81,"addresser_charged_ratio":0.4781,"chunk_context_penalty_pct":11.6},"crossdevice":{"date":"2026-07-14","probe":"W1-crossdevice-v1","union":{"hosts":["arcana-devs","arcana-prod","arcana-www"],"total_bytes":12941464032},"chunk_dup_intra_pct":26.8,"chunk_dup_total_pct":43.01,"chunk_dup_cross_device_pct":16.21},"charge_terms":{"catalog_bytes":21907639,"addr_manifest_bytes":42980416},"chunks_total":934588,"verdict_note":"GO: chunk dup mass 43.01% on the 3-host union (the <30% falsification bar did not fire) plus a MEASURED competitive win of the charged Addresser over local zstd-3 (+7.81 pp with the 11.6 pp chunk-context penalty). The verdict is conditioned on realistic corpus composition; multi-device emulated by hash aggregation (AH-23), payload never left the hosts.","chunks_unique":638474,"chunk_dup_mass_pct":28.09,"naive_stored_ratio":0.7191,"charged_stored_ratio":0.7267}

AH-03 OPEN W1 · 2026-07-13

Generated matrix (PRNG/pi/de Bruijn) — anti-hypothesis

If the matrix is made deterministically generatable (distribution cost ~0), then total_cost does not improve on any real data class, because an address into an exhaustive or random catalog costs at least as much as the content itself (information conservation).

Data class (Z): any real class
Address target: n/a
Predicted lever: strict NO-GO (predicted)
Ceiling category: structurally cannot win (boundary)
Mechanism: M/2^512 coverage for a random pool; a k-gram's address inside a de Bruijn sequence occupies exactly the k-gram's own bits
Falsification test: exhibit a class where addressing into a generated pool beats the entropy cost — not expected
Full cost (total_cost): address: by theorem >= the information content of the addressed fragment · metadata/residual: effectively the whole file · amortized: distribution ~0 — and it does not help.
Measured result: not measured yet — honestly null

AH-04 OPEN W1 · 2026-07-13

Cube occupancy bitmap as a matrix section

If the operator's 'bits mark which bytes of the N-cube exist' is realized as a succinct rank/select (RRR) bitmap over the Cubrim-1 phi geometry, then the cost of transmitting the SET of occupied coordinates on sparse inputs (rho<0.3) approaches log2 C(L,k), because RRR encodes sets near-optimally.

Data class (Z): sparse inputs (rho < 0.3)
Address target: n/a
Predicted lever: as a data carrier — NO-GO (predicted); as a search key — see AH-14
Ceiling category: shared context (dictionary / fragments)
Mechanism: succinct set encoding; but a set carries neither order nor values (Gotchas #2/#7)
Falsification test: share of the file's information held by the occupancy set; <5% on real classes -> dead as a carrier
Full cost (total_cost): address: n/a · metadata: RRR bitmap ~ log2 C(L,k) bits · residual: permutation + values — 99%+ of the file's information (Gotcha #2) · amortized: the occupancy section's share of the matrix.
Measured result: not measured yet — honestly null

AH-05 GO W1 · 2026-07-13

Whole-file identity dedup — the benchmark of an ultra-short reference

If the address is a cryptographic hash of the whole file (tens of bytes with metadata) and the object already sits in the catalog, then transmission on exact-repeat classes collapses to a reference far smaller than the payload for a file of any size, because we only distinguish what is already stored (pigeonhole intact). Reference size is a metric to minimize, not a hard gate (operator clarification 2026-07-14).

Data class (Z): installers, re-shared media, packages
Address target: 64 B
Predicted lever: the track's largest honest lever; enterprise dup mass 20-50% (external literature)
Ceiling category: identity dedup — reference ≪ payload on exact match
Mechanism: exact whole-file match against the catalog
Falsification test: file-level dup mass on a real mix; <10% of mass -> the lever is narrow
Full cost (total_cost): address: 32 B hash + <=32 B metadata (<=64 B total) · metadata: catalog record · residual: 0 on exact hit, the WHOLE file on miss · amortized: matrix copy storage + catalog + the file's first transfer (AH-19).
Probe verdict: GO: whole-file dup mass 34.99% on a real 3-host union (12.94 GiB), of which 15.9% is PURELY cross-host — that slice is free of the worktree distortion and alone clears the 10% narrowness bar; charged surcharge at file granularity is 0.23 pp. Dedup is deterministic — the verdict is conditioned on realistic corpus composition; multi-device is emulated by hash aggregation (AH-23), payload never left the hosts.
Measured result: {"date":"2026-07-14","probe":"W1-dupmass-v0","corpus":{"host":"arcana-devs","files":204275,"roots":["~\/arcanada","~\/cubrim-sources","~\/cubr-cm-work\/cubrim-code"],"caveat":"single-host snapshot; cross-device realism via AH-23; worktree copies inflate dup-mass","total_bytes":8517809533},"verdict":"GO","dup_files":91856,"crossdevice":{"date":"2026-07-14","probe":"W1-crossdevice-v1","union":{"files":363020,"hosts":["arcana-devs","arcana-prod","arcana-www"],"total_bytes":12941464032},"dup_intra_pct":19.09,"dup_total_pct":34.99,"dup_cross_device_pct":15.9},"charge_terms":{"catalog_bytes":3857308,"addr_manifest_bytes":16012992},"dup_mass_pct":17.79,"verdict_note":"GO: whole-file dup mass 34.99% on a real 3-host union (12.94 GiB), of which 15.9% is PURELY cross-host — that slice is free of the worktree distortion and alone clears the 10% narrowness bar; charged surcharge at file granularity is 0.23 pp. Dedup is deterministic — the verdict is conditioned on realistic corpus composition; multi-device is emulated by hash aggregation (AH-23), payload never left the hosts.","charged_savings_pct":17.55}

AH-06 OPEN W1 · 2026-07-13

Histogram+hash as a data carrier — anti-hypothesis

If a byte histogram plus hash is used as an address for reconstruction, then recovery on any non-trivial class is computationally infeasible, because the histogram destroys order (L!/prod(ci!) candidates) and transmitting the permutation explicitly costs the file's entropy.

Data class (Z): any non-trivial class
Address target: n/a
Predicted lever: NO-GO as a carrier; honest role — integrity check / search key (AH-14)
Ceiling category: structurally cannot win (boundary)
Mechanism: loss of order; infeasible search for the canonical representative by hash
Falsification test: a class where the multiset nearly determines order (sorted data) — a <<1% niche
Full cost (total_cost): address: histogram+hash (hundreds of bytes) · metadata: — · residual: an explicit permutation of log2(L!/prod ci!) bits ~ the file's entropy, or an infeasible search · amortized: —.
Measured result: not measured yet — honestly null

AH-07 NO-GO W1 · 2026-07-13

Two-level fragment address into the matrix

If a fragment address is (version, section, offset, len, flags) ~16-24 B for a fragment already present in the matrix, then net bytes on structured boilerplate drop by covered_fraction x (1 - address/fragment_len), because typical fragments are long and frequent.

Data class (Z): boilerplate, licenses, templates, format wrappers, copy-pasted code
Address target: 24 B
Predicted lever: coverage by fragments >=256 B on office/code/web classes 20-60% (prediction)
Ceiling category: shared context (dictionary / fragments)
Mechanism: a reference is cheaper than a long frequent fragment
Falsification test: corpus scan: coverage <15% OR savings <= zstd-with-dictionary -> NO-GO (AH-01 subsumes)
Full cost (total_cost): address: 16-24 B x fragment count · metadata: insertion-point markup (its own decoder branch — charged per Gotcha #6) · residual: uncovered bytes through the local codec · amortized: matrix sections holding the fragment pool.
Probe verdict: NO-GO — both pre-registered conditions fired: coverage by >=256 B fragments is only 10.69% (<15%) AND savings <= the zstd dictionary (per-file: fragments 0.2781 without catalog / 0.3017 with catalog vs dictionary 0.2664). The first probe version showed an apparent win — the AH-22 stand caught the confound (the residual was compressed as one solid stream against per-file baselines); with arms aligned the win vanished: the solid scenario with the catalog charged is 0.228 vs solid local 0.2153. Fragment addressing on this class degenerates into what a dictionary provides more cheaply.
Measured result: {"date":"2026-07-14","probe":"W1-fragments-v1b-fair","solid":{"L0_solid":0.2153,"A_no_catalog":0.2044,"A_with_catalog":0.228},"class_z":"small structured files (<128 KiB, text-ish), real KB","verdict":"NO-GO","per_file":{"L1_dict":0.2664,"A_no_catalog":0.2781,"A_with_catalog":0.3017},"coverage_pct":10.69,"verdict_note":"NO-GO — оба пре-регистрированных условия сработали: покрытие фрагментами >=256 Б всего 10.69% (<15%) И экономия <= zstd-словаря (per-file: фрагменты 0.2781 без каталога \/ 0.3017 с каталогом против словаря 0.2664). Первая версия пробы показывала мнимый выигрыш — стенд AH-22 поймал конфаунд (residual жался солидным потоком против пофайловых базлайнов); после выравнивания плеч выигрыш исчез: solid-сценарий с заряженным каталогом 0.228 против солидного локального 0.2153. Фрагментная адресация на этом классе вырождается в то, что словарь даёт дешевле.","pool_fragments":221086}

AH-08 OPEN W1 · 2026-07-13

Entropy coding of the reference stream

If the stream of matrix references is rANS-coded (frequent fragments get short codes), then the average reference cost on Zipf-distributed access classes falls from a nominal 16-32 B to effective single bytes, because access to a shared matrix is heavily skewed toward top fragments.

Data class (Z): anything with Zipf-like access (web/code)
Address target: n/a
Predicted lever: top 1% of fragments >=50% of accesses (prediction)
Ceiling category: shared context (dictionary / fragments)
Mechanism: skewed reference distribution -> short codes for frequent entries
Falsification test: access distribution on a web/code corpus; near-uniform -> no lever; charge through the real backend (Gotcha #11)
Full cost (total_cost): address: compressed by rANS down to the entropy of the access distribution · metadata: coder frequency tables/context · residual: unchanged · amortized: unchanged.
Measured result: not measured yet — honestly null

AH-09 OPEN W1 · 2026-07-13

MPH catalog

If the matrix index is built on minimal perfect hashing (~2-3 bits/key) plus a short fingerprint (8-16 bits) with cryptographic confirmation on hit, then catalog bytes per chunk become small enough for a billion-chunk store to fit in a few GiB, because MPH is near-optimal in memory.

Data class (Z): catalog infrastructure (meta)
Address target: n/a
Predicted lever: a 10^9-chunk catalog in a few GiB (prediction)
Ceiling category: infrastructure cost accounting
Mechanism: near-optimal MPH memory + a cheap fingerprint prefilter
Falsification test: fp/bytes curve; if a safe fp-rate is unreachable with a 16-bit fingerprint and the catalog eats the amortization -> configuration NO-GO
Full cost (total_cost): infra line item: catalog_bytes/chunk ~ 2-3 bits MPH + 8-16 bit fingerprint; on hit — confirmation by full hash (network) · amortized: divided across all fleet accesses.
Measured result: not measured yet — honestly null

AH-10 OPEN W1 · 2026-07-13

Sender-side Bloom prefilter

If the sender keeps a local Bloom filter of the catalog (fp ~1%), then network lookups on a typical user mix fall to roughly hit_rate x (1+fp) of chunks, because known-new chunks are rejected locally without a round trip.

Data class (Z): typical user mix
Address target: n/a
Predicted lever: orders of magnitude fewer network lookups (prediction)
Ceiling category: infrastructure cost accounting
Mechanism: local rejection of misses
Falsification test: matrix churn model vs filter-update traffic; updates costlier than the saved lookups -> NO-GO
Full cost (total_cost): infra line item: client filter ~1-2 bytes per catalog chunk + UPDATE TRAFFIC under matrix churn · savings: lookup round-trips.
Measured result: not measured yet — honestly null

AH-11 GO W1 · 2026-07-13

Break-even threshold N*

If the benefit is formalized as B(N) = sum(savings) - M_size - C_catalog_sync - C_residual_overhead, then a measurable threshold N* exists, reachable on enterprise-backup classes and N* -> infinity on unique personal content, because savings are proportional to cross-device repetition.

Data class (Z): enterprise backup vs personal-unique
Address target: n/a
Predicted lever: the formula plus an N* table per class — the track's honesty gauge
Ceiling category: infrastructure cost accounting
Mechanism: amortizing the matrix's fixed cost through repetition
Falsification test: compute N* on 2-3 real mixes; classes with N* beyond a realistic fleet are 'outside the Addresser's market'
Full cost (total_cost): this IS the track's total_cost aggregator: B(N) = sum(savings(N)) - M_size - C_catalog_sync(N) - C_residual_overhead(N); threshold N* = root of B.
Probe verdict: GO — both predictions confirmed on MEASURED parameters: for the office/infra class the break-even threshold exists and is tiny (N*=2: the second device already turns the balance positive, +0.613 GiB), for the unique personal class c~0 -> N* -> infinity (a clean personal corpus is the AH-16 follow-up). The formula and N* table are the track's honesty gauge; matrix distribution equals the devices' own data acquisition (first transfers charged under AH-19).
Measured result: {"date":"2026-07-14","B_GiB":{"N1":-0.019,"N2":0.613,"N3":1.245,"N10":5.669,"N100":62.555},"probe":"W1-nstar-v1","formula":"B(N) = c*d*(N-1) - 2*k_cat*u*N","verdict":"GO","verdict_note":"GO — оба предсказания подтверждены на ИЗМЕРЕННЫХ параметрах: для office\/infra-класса порог окупаемости существует и мал (N*=2: уже второе устройство делает баланс положительным, +0.613 ГиБ), для уникального персонального класса c~0 -> N*->бесконечность (чистый корпус личных файлов — за AH-16 follow-up). Формула и таблица N* — измеритель честности трека, дистрибуция матрицы = приобретение данных устройствами (первые передачи учтены в AH-19).","inputs_measured":{"source":"W1-crossdevice-v1 (3 реальных хоста) + AH-09 catalog-модель","c_cross_chunk_dup":0.1621,"d_bytes_per_device":4313821344,"u_unique_per_device":2458446783,"k_cat_per_unique_byte":0.00419},"N_star_office_infra":2}

AH-12 OPEN W1 · 2026-07-13

Frozen-matrix drift

If the matrix is frozen (immutable v1, as the canon requires), then hit-rate on fresh content degrades monotonically at a measurable d(hit)/dt, because real data distributions are non-stationary while a frozen matrix is a snapshot of the past.

Data class (Z): news, updating software, new formats
Address target: n/a
Predicted lever: dictionary sections decay faster than chunk sections (prediction, no numbers)
Ceiling category: infrastructure cost accounting
Mechanism: data non-stationarity vs a snapshot of the past
Falsification test: hit-rate(t) on dated corpus snapshots
Full cost (total_cost): each new matrix version costs distribution+sync per device; the gain is the recovered hit-rate; the net effect is the difference.
Measured result: not measured yet — honestly null

AH-13 OPEN W1 · 2026-07-13

Phi-normalized fragment keys (cross-container dedup)

If fragment keys are built from the Cubrim-1 cube normal form (section value multiset + local map) instead of raw bytes, then cross-file dedup hit-rate on 'same payload, different wrapper' classes rises versus raw CDC, because phi normalization abstracts positional shift within a section.

Data class (Z): same payload / shifted container (tar vs zip-stored)
Address target: n/a
Predicted lever: wins only where the per-fragment permutation cost < the value of the exposed match; presumption AGAINST per CUBR-0032 (intra-file case closed)
Ceiling category: near-match + delta
Mechanism: key invariance to in-section shift; but the permutation is paid in full (Gotcha #7)
Falsification test: charged end-to-end on a shifted-container pair; (match - permutation cost) <= CDC baseline -> NO-GO
Full cost (total_cost): address: normal-form section key · metadata: local map / per-fragment permutation — paid IN FULL (Gotcha #7) · residual: uncovered · amortized: normal-form index over the matrix.
Measured result: not measured yet — honestly null

AH-14 OPEN W1 · 2026-07-13

(occupancy-hash, histogram-hash) as a composite search key

If the pair of cube-section signatures is used as an LSH-like catalog key for finding SIMILAR sections (not as a data carrier), then near-duplicate recall on versioned data rises at fixed precision versus pure crypto-hash chunking, because these signatures tolerate small local edits.

Data class (Z): versioned / lightly edited data
Address target: n/a
Predicted lever: recall gain on a multiversion corpus (prediction: >=10 pp to pay off)
Ceiling category: near-match + delta
Mechanism: signature robustness vs crypto-hash brittleness to a single bit
Falsification test: recall/precision vs simhash/CDC on multiversion; gain <10 pp -> NO-GO
Full cost (total_cost): infra/catalog line item: a second signature per section + LSH buckets in the catalog · gain: recall of near-dup candidates for AH-15.
Measured result: not measured yet — honestly null

AH-15 OPEN W1 · 2026-07-13

Near-match address + delta (rsync kin)

If the address points to the nearest matrix fragment and only a delta is transmitted, then net bytes on versioned data fall to address + delta << full, because adjacent versions are close in content.

Data class (Z): code, documents, backup chains
Address target: 32 B
Predicted lever: large (rsync practice — external reference, not a measurement)
Ceiling category: near-match + delta
Mechanism: small deltas between versions; rolling-hash nearest search
Falsification test: charged: address + delta + catalog share vs local zstd-19 with dictionary on multiversion; loses -> NO-GO
Full cost (total_cost): address: 32 B of the nearest fragment · metadata: delta application instructions · residual: the delta itself · amortized: a rolling-hash index over the ENTIRE matrix — a heavy catalog line item.
Measured result: not measured yet — honestly null

AH-16 PROBED W1 · 2026-07-13

Impossibility class: unique already-compressed/encrypted — anti-hypothesis

If any addressing is applied to unique already-compressed or encrypted streams, then total_cost is strictly >= the original, because such streams are statistically indistinguishable from random, never recur in the global pool (hit-rate ~0), and addresses plus manifest are pure overhead.

Data class (Z): personal .jpg/.mp4/.zst, TLS dumps
Address target: n/a
Predicted lever: boundary confirmation: 0 whole-chunk hits (predicted)
Ceiling category: structurally cannot win (boundary)
Mechanism: statistical randomness + absence of global repeats
Falsification test: hit-rate on a unique-media corpus; a systematic non-zero hit would refute (not expected)
Full cost (total_cost): address+manifest: pure overhead · residual: the whole file · amortized: repaid by nothing — hit-rate ~0 by class construction.
Probe verdict: PROBED with a class refinement: media type as a proxy for 'unique' is REFUTED — published assets (jpg/mp3/gz/pdf deployed to the sites) are 93-100% replicated and belong to the re-share class (almost fully addressable!), while the dominant unpublished png slice (2.99 GiB of screenshots) shows only 8.82%. The boundary for truly unique data stays theoretically firm, but a clean test needs a verifiably personal corpus (own camera files); the rule: the class is decided by MEASURED dup-ness, not by file type.
Measured result: {"date":"2026-07-14","probe":"W1-unique-media-v1","by_ext":{"gz":92.59,"jpg":93.54,"mp3":100,"pdf":100,"jpeg":93.51,"png_2.99GiB":8.82},"corpus":"3347 media files 3.1 GiB (exact file-dups excluded), union 3-host occurrence pool","verdict":"PROBED","verdict_note":"PROBED c уточнением класса: медиа-тип как прокси «уникальности» ОПРОВЕРГНУТ — published-ассеты (jpg\/mp3\/gz\/pdf, задеплоены на сайты) реплицированы на 93-100% и принадлежат re-share классу (адресуемы почти целиком!), тогда как доминирующий непубликуемый png-срез (2.99 ГиБ скриншотов) даёт лишь 8.82%. Граница для истинно-уникального остаётся теоретически твёрдой, но чистая проверка требует корпуса достоверно личных файлов (личная камера); правило: класс определяется ИЗМЕРЕННОЙ дубликатностью, не типом файла.","repeated_chunk_mass_pct":12.04}

AH-17 NO-GO W1 · 2026-07-13

Inversion on small unique files

If chunk addressing is applied to small unique files (<4 KiB), then total_cost becomes worse than local compression, because fixed costs (manifest, address, catalog, sync) exceed any saving.

Data class (Z): small unique files (<4 KiB)
Address target: n/a
Predicted lever: the measured inversion point X becomes the router rule for AH-18
Ceiling category: structurally cannot win (boundary)
Mechanism: constant costs do not amortize over a small size
Falsification test: net bytes vs zstd by size bin; absence of an inversion would refute (not expected)
Full cost (total_cost): constant items (manifest + >=1 address + catalog record + sync) give cost/size -> infinity as size -> 0; the saving is bounded by the file size.
Probe verdict: NO-GO — the predicted inversion point X is ABSENT on the real mix: the charged Addresser wins in EVERY size bin including <=1 KiB (0.5225 vs 0.5937), because small files are the most duplicated in real data. For a strictly unique file the Addresser's loss is arithmetic (same compressed bytes + refs + manifest) and needs no threshold; the router rule (AH-18) keys on measured dup-ness, not size.
Measured result: {"bins":[{"bin":"1-1024","addr":0.5225,"files":76360,"local":0.5937,"addr_wins":true},{"bin":"1025-4096","addr":0.2764,"local":0.3986,"addr_wins":true},{"bin":"4097-16384","addr":0.2313,"local":0.3311,"addr_wins":true},{"bin":"16385-65536","addr":0.197,"local":0.2922,"addr_wins":true},{"bin":"65537-262144","addr":0.1955,"local":0.3037,"addr_wins":true},{"bin":"262145-1048576","addr":0.7053,"local":0.7621,"addr_wins":true},{"bin":"1M-4M","addr":0.6237,"local":0.705,"addr_wins":true},{"bin":">4M","addr":0.2538,"local":0.3942,"addr_wins":true}],"date":"2026-07-14","probe":"W1-inversion-v1","corpus":"real 3-tree mix, 8.5 GiB, per-file transmission model, charged refs+manifest","verdict":"NO-GO","verdict_note":"NO-GO — предсказанная точка инверсии X ОТСУТСТВУЕТ на реальном миксе: заряженный адресатор выигрывает во ВСЕХ бинах размера, включая <=1 КиБ (0.5225 против 0.5937), потому что мелкие файлы в реальных данных дублируются сильнее всех. Для строго-уникального файла проигрыш адресатора — арифметика (те же сжатые байты + refs + манифест), порог не нужен; правило маршрутизации router'а (AH-18) — по измеренной дубликатности, а не по размеру."}

AH-18 GO W1 · 2026-07-13

Router: Addresser + Cubrim-1 (competitive selection)

If a two-phase codec is built — phase 1: exact dedup against the matrix (whole-file AH-05, then CDC AH-02); phase 2: residual into the local Cubrim-1 codec — then total_cost on real mixed user data is <= min(either method alone) + epsilon and strictly better on mixes with non-zero dup mass, because the levers are orthogonal.

Data class (Z): real mixed user data
Address target: n/a
Predicted lever: strict no-worse guarantee + additive gain on dup mass
Ceiling category: identity dedup — reference ≪ payload on exact match
Mechanism: global repetition and local statistics do not compete for the same bytes; regression-proof per the Gotcha #4 pattern
Falsification test: the dup-mass threshold below which integration overhead eats the gain
Full cost (total_cost): sum of phases: dedup line items (AH-02/05) on covered mass + the full Cubrim-1 total_cost on the residual + scheme bytes and phase boundaries (integration overhead).
Probe verdict: GO — the two-phase router is MEASURED on the real 8.79 GiB mix: 0.4504 <= min(local 0.5535, pure Addresser 0.4528), and with the catalog fully charged 0.4533 — still 10.0 pp better than local; scheme-byte epsilon is 0.0023% (regression-proof per the Gotcha #4 pattern). The empirical phase-1 enable threshold is a sharp step at ~10% per-file dup fraction (below it the local codec wins; above it the Addresser is chosen in 96.6-100% of files). zstd-3 stood in for the local codec on both sides (the level cancels out); swapping in the real Cubrim-1 backend is the next engineering step.
Measured result: {"date":"2026-07-14","probe":"W1-router-v1","ratios":{"router":0.4504,"local_only":0.5535,"addresser_only":0.4528,"router_with_catalog":0.4533},"routing":{"files_to_local":107567,"whole_file_hits":95557,"files_to_addresser":96278},"verdict":"GO","corpus_bytes":8788989359,"deciles_note":"0-9% покрытия -> addr выбран у 1.0% файлов; >=10% -> 96.6-100%","verdict_note":"GO — двухфазный router ИЗМЕРЕН на реальном миксе 8.79 ГиБ: 0.4504 <= min(локальный 0.5535, чистый адресатор 0.4528), с полностью заряженным каталогом 0.4533 — всё равно на 10.0 пп лучше локального; ε scheme-байтов 0.0023% (regression-proof по паттерну Gotcha #4). Эмпирический порог включения фазы 1 — резкая ступень ~10% пофайловой dup-fraction (ниже — локальный кодек, выше — адресатор в 96.6-100% случаев). zstd-3 замещал локальный кодек с обеих сторон (уровень сокращается); подстановка реального бэкенда Cubrim-1 — инженерная деталь следующего шага.","catalog_bytes":25204723,"router_beats_both":true,"epsilon_scheme_bytes_pct":0.0023,"dup_fraction_enable_threshold_pct":10}

AH-19 OPEN W1 · 2026-07-13

First transfer and the re-access coefficient r

If we account for every matrix block having been transferred once, then the system's global net benefit is positive only at r > r* ~ 1 + overhead_share on a class with re-access coefficient r, because only repeat accesses repay the first delivery.

Data class (Z): popular vs long-tail content
Address target: n/a
Predicted lever: curate the matrix by popularity, do not hoard everything (predicted)
Ceiling category: infrastructure cost accounting
Mechanism: full price of the first delivery + storage x time
Falsification test: r distribution per class; median r ~1 by bytes with a dominant tail -> an uncurated matrix is globally lossy
Full cost (total_cost): global system balance: sum(first transfers at full price) + storage x time - sum(repeat accesses x savings); positive only at r > r* ~ 1 + overhead_share.
Measured result: not measured yet — honestly null

AH-20 OPEN W1 · 2026-07-13

Sectional (partial) matrix delivery

If the matrix is split into thematic sections and a device holds only relevant ones ('the user downloads only the needed sections' — direct canon), then amortized matrix cost per device falls roughly in proportion to the section share while hit-rate loss stays SMALLER than that share, because a device's data is thematically local.

Data class (Z): thematically concentrated devices
Address target: n/a
Predicted lever: amortization becomes reachable even for small devices (predicted)
Ceiling category: infrastructure cost accounting
Mechanism: thematic concentration of a device's data
Falsification test: hit-rate(section share) curve; >50% of sections needed for 80% hit -> weak locality, NO-GO
Full cost (total_cost): amortized matrix cost x share of stored sections against the lost hit-rate; the gain is the sub-proportionality of the hit loss.
Measured result: not measured yet — honestly null

AH-21 OPEN W1 · 2026-07-13

Cost of trust (Merkle/verification)

If the matrix is distributed (IPFS-like), then every hit carries a full block hash plus a Merkle path to a trusted root, adding a measurable surcharge to address_cost, because trust in an open network is not free and a poisoned matrix means corruption on thousands of devices.

Data class (Z): distributed matrix (IPFS-like)
Address target: n/a
Predicted lever: surcharge <5% of the gain on high-repetition classes (prediction)
Ceiling category: infrastructure cost accounting
Mechanism: cryptographic verification of every hit; Non-Harm makes integrity mandatory
Falsification test: measure the Merkle overhead on a real manifest of a typical file
Full cost (total_cost): surcharge per hit: +32 B full block hash + O(log) Merkle path in the manifest + verification compute.
Measured result: not measured yet — honestly null

AH-22 GO W1 · 2026-07-13

Charged test stand BEFORE experiments (process)

If an honest-accounting stand is built before any measurements — a separate cost term for every branch of the reconstructing decoder — then the hypothesis kill-rate at the model stage rises and falsely-optimistic GOs fall, because Cubrim-1 was twice caught by uncharged models (CUBR-0026/0032).

Data class (Z): process (all track hypotheses)
Address target: n/a
Predicted lever: cheap kills before Rust; trustworthy GOs
Ceiling category: infrastructure cost accounting
Mechanism: generalization of Gotchas #6/#8 to address+metadata+residual+amortized line items
Falsification test: the first implementation exposing a GO the model missed -> the stand is incomplete, fix immediately
Full cost (total_cost): process line item: engineering cost of the stand; the return is cheap hypothesis kills before Rust and trustworthy GOs (false-GO precedents: CUBR-0026/0032).
Probe verdict: GO: the stand's kill-power is DEMONSTRATED on a live probe — the naive W1-fragments-v1 design produced a false fragment win (solid-stream residual against per-file baselines); the charged fair re-run v1b flipped AH-07 to NO-GO. The falsification condition (a missed false GO) did not fire — the stand caught it itself.
Measured result: {"date":"2026-07-14","probe":"W1-dupmass-v0","stand":"charged v0: a separate cost term for every decoder branch (refs, manifests, catalog, residual); naive and charged are reported as a pair","verdict":"GO","verdict_note":"MEASURED: stand v0 built and applied to the first two measurements; kill-power small at coarse granularity (0.23 pp \/ 0.0076) — it will decide on 256 B fragments (AH-07) and delta schemes (AH-15); the falsification condition (a missed false GO) has not fired.","first_application":{"AH-05_kill_power_pp":0.23,"AH-02_kill_power_ratio":0.0076},"kill_demonstrated":{"date":"2026-07-14","probe":"W1-fragments-v1 -> v1b-fair","false_go_caught":"solid-vs-per-file confound: naive A-arm 0.2044 'beat' per-file baselines; fair aligned re-run flipped AH-07 to NO-GO"}}

AH-23 GO W1 · 2026-07-13

Corpus realism: multi-device mixes, not synthetics (process)

If the Addresser corpus is built from real multi-device mixes with time snapshots, then dup-mass/hit-rate estimates come out LOWER than synthetic ones by a measurable amount, because synthetics inherit their generator's statistics (the rho=1 trap, Gotcha #1, in a new guise).

Data class (Z): process (track corpus)
Address target: n/a
Predicted lever: protects every track measurement from optimistic bias
Ceiling category: infrastructure cost accounting
Mechanism: generator self-similarity inflates repetition
Falsification test: parallel estimation on synthetic and real corpora; divergence <10% -> synthetics acceptable, hypothesis refuted
Full cost (total_cost): process line item: the cost of assembling a real multi-device corpus; the return is protecting all track measurements from optimistic bias. Dedup is deterministic — multi-device is emulated by hash-set aggregation; payload never leaves the hosts.
Probe verdict: GO (process): the real multi-device corpus method is delivered and proved decisive — the cross-host slice (15.9% files / 16.21% chunks) materially changed the AH-05/AH-02 verdicts versus the single-host view; adopted as the track standard. The synthetic-inflation sub-prediction remains an open footnote — the track deliberately builds no synthetic corpus.
Measured result: not measured yet — honestly null

AH-24 OPEN W1 · 2026-07-13

Privacy as a hard dedup constraint

If dedup is cross-user, then the very hit/miss fact leaks information about others' data, so private classes admit only convergent encryption with per-domain salt, which kills cross-user dedup, because identical plaintexts stop matching across domains.

Data class (Z): private data vs public content
Address target: n/a
Predicted lever: a privacy-safe Addresser is limited to public content + intra-domain dedup (predicted)
Ceiling category: infrastructure cost accounting
Mechanism: a known attack class on cloud deduplication; salt breaks convergence
Falsification test: mode model; a mode retaining >=80% of the original hit-rate would soften the constraint
Full cost (total_cost): the price of privacy: cross-domain hit-rate lost under convergent encryption with per-domain salt; plus side-channel risk (hit/miss leak) without it.
Measured result: not measured yet — honestly null

Where the Addresser cannot beat local compression

Six boundaries are fixed by wave 1 as explicit anti-hypotheses and no-win zones: unique high-entropy data (personal media, encrypted streams — nothing repeats globally); tiny unique files below the inversion point (fixed catalog costs exceed any saving); mathematically generated matrices (an address into an exhaustive or random pool costs at least as much as the content itself); a byte histogram or hash used as the data carrier (order is lost and buying it back costs the file’s entropy); long-tail content fetched roughly once (the first transfer is never repaid); and fragment schemes whose gain collapses into what a shared dictionary already provides. A tiny fixed-size reference per object (tens of bytes) is honestly achievable only on an exact match against a catalog that already stores the object; everywhere else the win criterion is simply that the reference plus all charged costs stay well below the payload it replaces — the reference size is a metric to minimize, not a hard gate.