Research-Stack/6-Documentation/docs/specs/CONTINUED_FRACTION_COMPRESSION_ADAPTATION.md

Continued Fraction Compression Adaptation

Status: Draft v0.1 Date: 2026-05-08 Scope: adapting ratio-heavy Research Stack math to exact continued-fraction carriers for compression Claim state: formal scaffold and adaptation map; not a global compression benchmark, optimality proof, or floating-point numerical claim

1. Purpose

Continued fractions are useful for this stack when a value is naturally a ratio, threshold, scaling law, phase increment, or calibration constant.

The compression opportunity is:

rational value
  -> finite partial quotients
  -> compact integer stream
  -> exact replay to numerator / denominator
  -> residual if an approximation was chosen
  -> receipt

Lean anchor:

0-Core-Formalism/lean/Semantics/Semantics/ContinuedFractionCompression.lean

The design stays vectorless and integer-only. It does not use embedding similarity, floats, or decimal string parsing in the law layer.

2. Adaptable Math Surfaces

The repo already has several math lanes that can use continued fractions.

Surface	Existing Shape	CF Adaptation
Fibonacci / phi ratios	FibonacciEncoding.lean, phi/golden scaling notes	all-ones partial quotients encode Fibonacci convergents
Golden-angle phase sampling	GoldenAngleEncoding.lean	approximate phase steps as rational carriers with byte-cost receipts
Recursive branch-cut ratios	recursive_branch_cut_self_similarity.md	scale ratios become partial-quotient streams instead of decimal prose
Fixed-point thresholds	Q0.16/Q16.16 gates and calibration constants	thresholds can be stored as (partial_quotients, residual_bound)
Sidecar byte law	logogram payload plus residual plus receipt accounting	CF route promotes only when encoded quotient stream beats baseline
Holographic boundary/bulk split	boundary descriptor plus exact residual	boundary ratio can be a compact CF descriptor with exact residual replay

3. Core Equation

Finite continued fraction:

[a0; a1, a2, ..., an]

Replay recurrence:

evalCf([])        = 0 / 1
evalCf([a])       = a / 1
evalCf(a :: rest) =
  let n / d = evalCf(rest)
  (a*n + d) / n

Admission:

partial quotients admissible
+ exact replay to target numerator / denominator
+ byte-sized quotient stream
+ residual and receipt bytes counted
+ encoded bytes < baseline bytes

4. Byte Law

For a continued-fraction packet:

B(partial_quotients)
+ B(residual)
+ B(receipt)
< B(baseline numerator/denominator or decimal form)

If the inequality fails, the continued fraction can remain an inspection surface, but it is not a compression promotion.

Important negative case:

[1000] = 1000 / 1

This is exact but not one-byte quotient-sized. The current Lean witness rejects it for the first hardware-friendly path.

5. Current Lean Witnesses

Verified examples:

[1, 1, 1, 1, 1]     -> 8 / 5
[2, 1, 1, 1, 1]     -> 13 / 5
[10, 2]             -> 21 / 2

Witness outcomes:

phiFivePacket                  promotable
phiSquaredPacket               promotable
tenPointFivePacket             promotable
largeQuotientPacket            not promotable
aestheticCfPacket              not promotable
promotable_cf_reconstructs     theorem
promotable_cf_satisfies_byte_law theorem

These witnesses prove the gate shape:

compression promotion -> exact rational replay
compression promotion -> byte law satisfied

6. Where This Helps Most

Phi / Fibonacci Surfaces

Your phi-heavy math is the cleanest match. The all-ones continued fraction:

[1; 1, 1, 1, ...]

generates Fibonacci convergents:

1/1, 2/1, 3/2, 5/3, 8/5, 13/8, ...

That gives a compact route for:

• phi/golden scale prompts
• golden-angle approximants
• recursive branch-cut candidate ratios
• dictionary thresholds that drift toward Fibonacci ratios

Recursive Branch-Cut Ratios

The branch-cut document already says the ratios are not constant and cluster by regime. Continued fractions are useful here because they make this explicit:

ratio cluster
  -> exact rational carrier
  -> partial quotient pattern
  -> regime label
  -> residual for mismatch

This avoids pretending Phi^2 is always the true scale factor. A ratio can be stored exactly if known, or approximated with a declared residual.

Logogram Sidecars

The sidecar path can use continued fractions for compact thresholds and local ratio metadata:

candidate dictionary route
  -> phrase length / residual size ratio
  -> CF packet
  -> sidecar decision

This is especially useful for corpus-trained agents that need to carry small integer model parameters without vectors.

7. Compiler Integration

Proposed pipeline:

numeric ratio / threshold / phase increment
  -> normalize to numerator / denominator
  -> continued fraction expansion
  -> choose quotient byte policy
  -> compute residual if truncated
  -> emit CF packet
  -> verify exact replay or declared residual
  -> promote only if byte law wins

For exact values, replay must recover the numerator and denominator byte-for-byte.

For approximate values:

source rational
  -> convergent
  -> residual bound
  -> receipt

The approximation is lawful only when the residual is declared and replay can recover either the original rational or the explicit residual sidecar.

8. LadderLUT: B-Adic Enumerative Shortcut

The 1 / 998001 pattern is useful as a design witness for a deterministic enumerative LUT kernel:

998001 = (1000 - 1)^2
1 / 998001 = 0.000001002003004005...

The decimal expansion is not the codec. It is the human-visible handle for this family:

base = radix^block_width
denominator = (base - 1)^2
emit fixed-width blocks by counting upward

Reference Lean gate:

0-Core-Formalism/lean/Semantics/Semantics/LadderLUT.lean

Canonical packet:

LadderLUT =
  family
  radix
  block_width
  base
  start
  length
  generator_bytes
  residual_bytes
  receipt_bytes

Replay:

value_i = (start + i) mod base

Admission:

radix > 1
+ block_width > 0
+ base = radix^block_width
+ length > 0
+ generator_bytes + residual_bytes + receipt_bytes
   < length * block_width

The decimal witness:

radix = 10
block_width = 3
base = 1000
denominator = 998001
replay starts 000,001,002,003,004,005,006,007,008,009

The compression-native version should usually be byte-based:

radix = 256
block_width = 3
base = 256^3 = 16777216

Use cases:

• dictionary indices
• glyph IDs
• page-local token IDs
• table rows
• citation numbers
• ordered offset ladders
• semantic basin IDs
• Mass Number registry slots
• O-AVMR lane IDs

The carry behavior of the infinite decimal expansion is not promoted as a codec rule. Carry-disturbed, skipped, permuted, or wrapped entries require a declared residual stream.

9. HexLogogram Atlas: Seeded Grouping Shortcut

The hex version is stronger than a byte stream generator. A hexcode can seed a deterministic logogram grouping field:

hex seed
  -> grouping law
  -> Mass Number / type witness coordinates
  -> generated logogram group IDs
  -> residual exceptions

The seed does not store the words, glyphs, or semantic truth. It stores a replayable law for assigning typed token coordinates into reusable logogram groups.

Reference Lean gate:

0-Core-Formalism/lean/Semantics/Semantics/HexLogogramAtlas.lean

Canonical packet:

HexLogogramAtlas =
  hex_seed
  hex_digit_width
  block_base = 16^hex_digit_width
  grouping_law
  registry_id
  mass_basin
  mass_weight
  chart_id
  type_witness
  group_count
  token_domain
  start_index
  length
  stride
  window
  assignment_bytes
  seed_bytes
  law_bytes
  registry_bytes
  residual_bytes
  receipt_bytes

Replay:

raw_j = grouping_law(hex_seed, start_index + j, mass_basin, chart_id, type_witness)
group_j = raw_j mod group_count

Admission:

hex_digit_width > 0
+ block_base = 16^hex_digit_width
+ registry_id > 0
+ group_count > 0
+ token_domain > 0
+ length > 0
+ stride > 0
+ window > 0
+ assignment_bytes > 0
+ seed_bytes + law_bytes + registry_bytes + residual_bytes + receipt_bytes
   < length * assignment_bytes

This promotes only when a seed-generated atlas beats the explicit token-to-logogram assignment table.

Supported first-pass grouping laws:

Law	Meaning
atlasIdentity	seed plus coordinate
affineMass	seed plus Mass basin, stride, and type witness
windowedMass	seed plus windowed coordinate and Mass/type fields
stridedChart	seed plus stride and chart witness

Use cases:

• generated logogram group families
• page-local logogram clusters
• Mass Number basin grouping
• chart/type-witness lanes
• deterministic registry assignment maps
• substitution-table compression
• Hutter control-plane IDs

Residual policy is mandatory. If the generated grouping assigns a token to the wrong logogram group, the exception must be carried in the residual stream. If exceptions cost more than the explicit assignment table, the atlas stays HOLD.

10. Claim Boundary

10. OMCF / PIST Lift

The Mass-Gaussian lift turns continued fractions into a typed field carrier:

z = R + iαM

where:

R = structural carrier
    ratio, offset, recurrence, byte-law phase, numeric projection

M = Mass Number carrier
    semantic basin, topology class, glyph/domain class

α = Mass gauge
    scale factor that keeps semantic mass from dominating structure

The continued-fraction quotients live over Gaussian integers:

a_j = x_j + i y_j,  a_j in Z[i]

with:

x_j = structural quotient / braid twist count
y_j = Mass Number quotient / imaginary grouping motion

This gives the field object:

OMCF<T> = (R + iαM, A, β, DEP, τ, Ω, ε)

where:

Field	Meaning
A	Gaussian continued-fraction quotient list
β	braid / continuant path
DEP	deterministic expansion packet
τ	RRC type witness
Ω	O-AMVR or O-AVMR receipt
ε	semantic and byte residual repair

PIST is the surface-transform operator family over this carrier:

PIST_OMCF<T> = (z, A, β, Π, C, DEP, τ, Ω, ε)

where:

Π = PIST transform operator
C = local SSROC/SROC operator cell, when used

PIST is not promoted because it is elegant. It is promoted only when its operator ID, cell seed, expansion law, receipt, and residual cost pay for themselves under the byte law.

11. Decoder-Facing Reconstruction Core

The compressed representation emitted by this family is not assembly language, source code, or ordinary human-readable bytecode.

Canonical phrase:

This is not assembly. It is a lawful reconstruction core.

The core is a decoder-facing representation whose validity is established by:

deterministic replay
residual repair
receipts
byte-exact output

Direct readability of the internal representation is not a validity criterion. This is not anti-inspection. Inspection moves to:

codec specification
replay rules
receipts
residuals
hashes
benchmarks
reconstructed bytes

Related spec:

6-Documentation/docs/specs/DECODER_FACING_RECONSTRUCTION_CORE.md

12. Control Filters

The OMCF/PIST reconstruction candidate is guarded by control filters:

Filter	Function
LoC/NES Monster	rejects fake pattern, mirage, or overfit
FYC Gate	rejects impossible constrained-manifold traversal
COUCH	rejects unstable hysteresis or chaotic route dynamics
Tree Fiddy	bounds recursion, retries, and refinement depth
BHOCS	commits only bounded, replayable survivors
FAMM	carries delay/frustration-addressed memory pressure

Admission sketch:

Admit(X) =
  replay_valid(X)
  ∧ byte_gain(X) > 0
  ∧ residual_declared(X)
  ∧ LoC_NES_pass(X)
  ∧ FYC_pass(X)
  ∧ COUCH_stable(X)
  ∧ TreeFiddy_bounded(X)
  ∧ BHOCS_verified(X)

13. One-Symbol LUT Fuzzer

Formal power series and recurrence generators can fuzz the compression ratio by collapsing a structured array into one replay law:

array[n] = generator_law(n, parameters)

This is the "one symbol, massive array" route. It is lawful only when the symbol is a declared generator, not a hidden copy of the array.

Receipt generator:

4-Infrastructure/shim/one_symbol_lut_fuzzer_prior.py

First-pass generator families:

Family	Generating Function / Law	Fuzz Role
arithmetic ladder	x / (1 - x)^2	carry-swallow and missing-coordinate stress
triangular ladder	x / (1 - x)^3	second-order acceleration stress
squares	x(1+x) / (1 - x)^3	curvature / distance-field stress
cubes	x(1+4x+x^2) / (1 - x)^4	volume-like coordinate stress
geometric	1 / (1 - kx)	exponential slot-overlap stress
Fibonacci	x / (1 - x - x^2)	recurrence / branching stress
Lucas mutation	(2 - x) / (1 - x - x^2)	recurrence-basin mutation stress
cyclic prime	digits(1 / p)	rotation-invariant window stress
repunit repeat	c / (B - 1)	obvious repetition baseline
Champernowne decoy	123456789101112...	pseudo-normal decoy from a tiny law

Admission:

B(generator_law)
+ B(parameters)
+ B(residual_exceptions)
+ B(receipt)
< B(explicit_array)

If the target array is random, the generator numerator, exception list, or residual grows until it costs as much as the array. That is the entropy wall.

14. Claim Boundary

This adaptation does not prove that continued fractions improve full-corpus compression. It identifies where the math is compatible:

ratio-heavy
+ recurrence-heavy
+ threshold-heavy
+ integer-replay-friendly

The next empirical step is a corpus-side audit that measures whether CF packets reduce sidecar/model-parameter bytes compared with raw numerators, denominators, decimals, or fixed-point constants.

Likewise, LadderLUT does not prove that ordered IDs compress a corpus by themselves. It promotes only when the deterministic generator plus residual and receipt bytes beats the explicit fixed-width LUT.

Likewise, HexLogogramAtlas does not prove that a hex seed can recover all semantic grouping. It is a deterministic grouping representative admitted only when replay plus residual reconstructs the explicit logogram assignment table more cheaply than storing that table directly.

Manifold Boundary Atlas applies the same seed-generated route to RRC boundary candidate surfaces. It is not a proof of a manifold tear. It only emits candidate coordinates for RRC to identify, and it promotes only when the boundary seed plus residual and receipt bytes beats an explicit boundary list.