# COMPRESSION METRIC C(n) — Formal Specification

## for the Radial Self-Finding Experiment

---

## 1. Notation and Preliminaries

| Symbol | Definition |
|--------|------------|
| `φ` | Golden ratio = (1 + √5) / 2 ≈ 1.6180339887... |
| `ψ` | Golden angle = 2π / φ² rad ≈ 2.39996 rad = 137.5077...° |
| `ℕ` | Natural numbers {0, 1, 2, ...} |
| `Σ_DNA` | DNA alphabet = {A, B, C, G, P, S, T, Z}, \|Σ_DNA\| = 8 |
| `n` | Spiral index ∈ ℕ, the integer being encoded |
| `r = √n` | Spiral depth (radial coordinate) |
| `L_S` | Original state size in bits (e.g., 30 GB × 8 = 240 Gbit for LLM KV cache) |

### Phinary Representation

**Definition 1.1 (Phinary / Base-φ)**. The *phinary representation* of a positive integer n is the unique sequence P(n) = (p₀, p₁, ..., p_{k-1}) with pᵢ ∈ {0, 1} such that:

```
n = Σᵢ pᵢ · φⁱ     (value equation)
pᵢ · pᵢ₊₁ = 0      ∀ i     (no consecutive 1s — standard form)
```

**Lemma 1.2 (Uniqueness).** The phinary standard form is unique for every n ∈ ℕ.
*Proof.* This is the well-known uniqueness theorem for base-φ representations. The absence of consecutive 1s eliminates the identity φⁱ = φⁱ⁻¹ + φⁱ⁻² (Fibonacci relation), ensuring no two distinct digit strings evaluate to the same integer. ∎

**Lemma 1.3 (Length bound).** The length of P(n) satisfies:
```
⌊log_φ(n)⌋ ≤ |P(n)| ≤ ⌈log_φ(n)⌉ + 1
```
*Proof.* Since φᵏ ≤ n < φᵏ⁺¹ implies k ≤ log_φ(n) < k+1, and the highest non-zero digit is at position ⌊log_φ(n)⌋. The +1 accounts for the standard-form constraint which may push the representation one digit longer. ∎

**Corollary 1.4.** |P(n)| = Θ(log n) with base φ.

---

## 2. The Compression Pipeline

The compression pipeline is a composition of four functions:

```
C(n) = L_S / |RLE(DNA(phinary(n)))|

Pipeline:  n ──phinary──► P(n) ──dna_encode──► D(n) ──rle──► R(n)
           ℕ                {0,1}*            Σ_DNA*        compressed
```

### 2.1 Step 1: phinary(n) → P(n)

**Function:** `phinary: ℕ → {0, 1}*`

Input: integer n ≥ 0
Output: phinary digit string P(n) = (p₀, p₁, ..., p_{k-1})

**Algorithm (greedy standard form):**
```python
def phinary(n: int) -> list[int]:
    """Convert n to phinary standard form (digits 0 or 1, no consecutive 1s)."""
    if n == 0:
        return [0]
    
    # Precompute Fibonacci numbers F[2]=1, F[3]=2, F[4]=3, F[5]=5, ...
    fib = [1, 2]  # F[2], F[3]
    while fib[-1] <= n:
        fib.append(fib[-1] + fib[-2])
    fib.pop()  # remove overflow
    
    digits = []
    remaining = n
    for f in reversed(fib):
        if remaining >= f:
            digits.append(1)
            remaining -= f
        else:
            digits.append(0)
    
    return digits   # most-significant-digit first
```

**Key property:** `phinary(n)` uses the Fibonacci number system (Zeckendorf representation), which is isomorphic to phinary standard form via the substitution φⁱ ↔ F_{i+2}.

**Output properties:**
- P(n) ∈ {0, 1}ᵏ where k = |P(n)|
- No two consecutive 1s
- P(n) is a prefix code (self-delimiting by construction)

### 2.2 Step 2: dna_encode(P(n)) → D(n)

**Function:** `dna_encode: {0, 1}* → Σ_DNA*`

Maps binary phinary digits to the 8-symbol DNA alphabet by grouping bits.

**Algorithm:**
```python
DNA_ALPHABET = ['A', 'B', 'C', 'G', 'P', 'S', 'T', 'Z']  # 8 bases

def dna_encode(phinary_digits: list[int]) -> str:
    """Map phinary digit string to DNA sequence."""
    # Pad to multiple of 3 bits
    padded = phinary_digits.copy()
    while len(padded) % 3 != 0:
        padded.append(0)
    
    dna = []
    for i in range(0, len(padded), 3):
        triplet = (padded[i] << 2) | (padded[i+1] << 1) | padded[i+2]
        dna.append(DNA_ALPHABET[triplet])
    
    return ''.join(dna)
```

**Output:** D(n) ∈ Σ_DNA^L where L = ⌈|P(n)| / 3⌉.

**Mapping table:**

| Triplet (b₂b₁b₀) | DNA Base | Name |
|:---:|:---:|:---|
| 000 | A | Adenine-like |
| 001 | B | Bromouracil-like |
| 010 | C | Cytosine-like |
| 011 | G | Guanine-like |
| 100 | P | Purine-like |
| 101 | S | Strong-binding |
| 110 | T | Thymine-like |
| 111 | Z | Zero/depth |

### 2.3 Step 3: rle(D(n)) → R(n)

**Function:** `rle: Σ_DNA* → ({0, 1} × Σ_DNA × ℕ)*`

Run-length encoding with adaptive format selection.

**Algorithm:**
```python
def rle(dna: str) -> list[tuple[str, int]]:
    """Run-length encode DNA sequence.
    
    Format: sequence of (base, run_length) pairs.
    Uses flag bit: if run_length == 1, omit length (save 1 bit).
    """
    if not dna:
        return []
    
    runs = []
    current_base = dna[0]
    current_run = 1
    
    for base in dna[1:]:
        if base == current_base:
            current_run += 1
        else:
            runs.append((current_base, current_run))
            current_base = base
            current_run = 1
    runs.append((current_base, current_run))
    
    return runs

def rle_bit_size(runs: list[tuple[str, int]], max_run_length: int) -> int:
    """Compute bit size of RLE encoding."""
    bits = 0
    for base, length in runs:
        bits += 3   # base identifier (3 bits for 8 bases)
        if length == 1:
            bits += 1   # flag: single (0)
        else:
            bits += 1   # flag: run (1)
            bits += ceil(log2(max_run_length + 1))  # run length
    return bits
```

**Smart RLE** (only compress when beneficial):
```python
def smart_rle(dna: str) -> tuple[list, bool]:
    """Apply RLE only if it reduces size."""
    runs = rle(dna)
    rle_bits = rle_bit_size(runs, len(dna))
    raw_bits = len(dna) * 3  # 3 bits per base
    
    if rle_bits < raw_bits:
        return (runs, True)   # compressed
    else:
        return (dna, False)   # raw (no benefit)
```

### 2.4 Full Pipeline (Pseudocode)

```python
def compression_ratio(n: int, original_size_bits: int) -> float:
    """Compute C(n) = compression ratio for spiral index n."""
    
    # Step 1: Phinary representation
    P = phinary(n)                          # list of {0,1}
    
    # Step 2: DNA encoding (3 bits → 1 base)
    D = dna_encode(P)                       # string over Σ_DNA
    
    # Step 3: Smart run-length encoding
    R, was_compressed = smart_rle(D)        # compressed representation
    
    # Step 4: Compute sizes
    compressed_bits = rle_bit_size(R, len(D)) if was_compressed else len(D) * 3
    
    # Step 5: Compression ratio
    C = original_size_bits / compressed_bits
    
    return C
```

---

## 3. Formal Definition of C(n)

### 3.1 Component Functions

**Definition 3.1 (Phinary length).**
```
ℓ_P(n) := |phinary(n)| = number of phinary digits of n
```

**Definition 3.2 (DNA sequence length).**
```
ℓ_D(n) := ⌈ℓ_P(n) / 3⌉ = number of DNA bases
```

**Definition 3.3 (Run count).** Let D(n) = d₀ d₁ ... d_{ℓ_D-1}. Define the *run count*:
```
r(n) := 1 + |{i ∈ {0, ..., ℓ_D-2} : dᵢ ≠ dᵢ₊₁}|
       = number of maximal runs of identical bases in D(n)
```

**Definition 3.4 (Compressed size).** Let r(n) be the number of runs and let L_max(n) = max run length. The compressed size in bits is:
```
|rle(D(n))| = r(n) · [3 + 1 + ⌈log₂(L_max(n) + 1)⌉]   if RLE beneficial
            = 3 · ℓ_D(n)                                otherwise (raw)
```

Simplifying (using the smart RLE convention):
```
|rle(D(n))| = min( 3·ℓ_D(n),  r(n)·[4 + ⌈log₂(ℓ_D(n) + 1)⌉] )
```

**Definition 3.5 (Compression metric).**
```
                    L_S                          L_S
C(n) := ──────────────────────── = ─────────────────────────────
        |rle(DNA(phinary(n)))|     min(3·ℓ_D, r(n)·[4 + ⌈log₂(ℓ_D+1)⌉])
```

where L_S is the original state size in bits (a constant for the experiment).

---

## 4. Proof of Bounds: C_min ≤ C(n) ≤ C_max

### 4.1 Upper Bound (Maximum Compression)

**Theorem 4.1 (C_max).** For any spiral index n ≥ 0:

```
                    L_S
C(n) ≤ ──────────────────────────
       4 + ⌈log₂(ℓ_D(n) + 1)⌉
```

with equality when r(n) = 1 (all DNA bases identical).

*Proof.* The minimum compressed size occurs when all DNA bases are the same, giving exactly one run: r(n) = 1. Each run costs 4 + ⌈log₂(ℓ_D+1)⌉ bits (3 for base + 1 flag + log for length). With one run:

```
|rle(D(n))| = 4 + ⌈log₂(ℓ_D(n) + 1)⌉
```

This is the smallest possible non-trivial encoding. Therefore:

```
         L_S                           L_S
C(n) ≤ ─────────────── ≤ ──────────────────────────
         |rle|_min        4 + ⌈log₂(ℓ_D(n) + 1)⌉
```

For large n, ℓ_D(n) ~ log_φ(n)/3, so:
```
C_max(n) ~ L_S / log₂(log_φ n) = L_S / O(log log n)
```

This is extremely large but finite for any finite n. ∎

**Corollary 4.2.** For the LLM KV cache (L_S = 240 Gbit):
- If ℓ_D = 10⁶: C_max ≈ 240×10⁹ / 24 ≈ 10¹⁰
- If ℓ_D = 10¹²: C_max ≈ 240×10⁹ / 40 ≈ 6×10⁹

### 4.2 Lower Bound (Minimum Compression)

**Theorem 4.3 (C_min).** For any spiral index n ≥ 0:

```
           L_S
C(n) ≥ ───────────
       3 · ℓ_D(n)
```

with equality when RLE provides no benefit (all runs of length 1, or smart RLE falls back to raw).

*Proof.* The maximum compressed size (minimum compression) occurs when every DNA base differs from its neighbors, giving r(n) = ℓ_D(n) runs of length 1. In this case, smart RLE falls back to raw encoding at 3 bits per base:

```
|rle(D(n))| = 3 · ℓ_D(n)
```

Therefore:
```
         L_S                L_S
C(n) ≥ ─────────── = ───────────────────
       3·ℓ_D(n)      3·⌈ℓ_P(n)/3⌉
```

Using ℓ_P(n) ≤ ⌈log_φ(n)⌉ + 1 from Lemma 1.3:
```
           L_S
C(n) ≥ ──────────────────────
       log_φ(n) + O(1)
```

This lower bound decreases as n increases. ∎

### 4.3 Combined Bound Theorem

**Theorem 4.4 (Bounds on C(n)).** For all n ≥ 2:

```
           L_S                                 L_S
─────────────────────────  ≤  C(n)  ≤  ──────────────────────────
3 · ⌈(⌈log_φ(n)⌉ + 1) / 3⌉            4 + ⌈log₂(⌈log_φ(n)/3⌉ + 1)⌉
```

Or more compactly:
```
      Ω(L_S / log n)  ≤  C(n)  ≤  O(L_S / log log n)
```

*Proof.* Direct combination of Theorems 4.1 and 4.3 with Lemma 1.3 for ℓ_P(n). ∎

### 4.4 Asymptotic Behavior

**Theorem 4.5 (Asymptotic envelope).** As n → ∞:

```
C(n) ∈ [ L_S / Θ(log n),  L_S / Θ(log log n) ]
```

The exact value depends on the *run structure* of D(n), not just its length.

**Corollary 4.6.** For a "random" spiral index (uniform in [0, N]):
- Expected r(n) ≈ ℓ_D(n) · (7/8) (since 7/8 of transitions change the base)
- Expected C(n) ≈ L_S / Θ(log n) (near the lower bound)

*Proof sketch.* For random ℓ_D bases from 8 symbols, the probability that dᵢ = dᵢ₊₁ is 1/8. So expected runs = ℓ_D · (7/8) + O(1), giving near-worst-case compression. ∎

---

## 5. Gradient Analysis: ∇_n C(n)

### 5.1 What Makes C(n) Increase?

Since C(n) = L_S / |R(n)|, maximizing C(n) is equivalent to **minimizing |R(n)|**, the compressed size.

The compressed size is:
```
|R(n)| = min( 3·ℓ_D(n),  r(n)·[4 + ⌈log₂(ℓ_D(n)+1)⌉] )
```

**Therefore C(n) increases when:**

| Factor | Effect on C(n) | Mechanism |
|--------|---------------|-----------|
| **r(n) ↓** (fewer runs) | **↑ C(n)** | Longer runs → better RLE |
| **ℓ_D(n) ↓** (shorter DNA) | **↑ C(n)** | Fewer bases to encode |
| **Run lengths become more uneven** | **↑ C(n)** | One very long run + many short ones is better than uniform runs |
| **r(n) = 1** (single run) | **↑↑ C(n)** | Maximum: one base repeated ℓ_D times |

### 5.2 Discrete Gradient

Define the **forward difference**:
```
ΔC(n) := C(n + 1) - C(n)
```

**Lemma 5.1 (Gradient sign from run changes).** Let Δr = r(n+1) - r(n) and Δℓ = ℓ_D(n+1) - ℓ_D(n). Then:

```
ΔC(n) > 0  ⟺  |R(n+1)| < |R(n)|
           ⟺  the encoding of n+1 has better compressibility
```

**Cases:**
1. If ℓ_D(n+1) = ℓ_D(n) and r(n+1) < r(n): then C(n+1) > C(n)
2. If ℓ_D(n+1) > ℓ_D(n) but r(n+1) ≪ r(n): C may still increase
3. If ℓ_D(n+1) = ℓ_D(n) and r(n+1) > r(n): then C(n+1) < C(n)

### 5.3 Continuous Relaxation (for Gradient Ascent)

To make C(n) differentiable, define a **soft version** on ℝ⁺:

**Definition 5.2 (Soft compression metric).** For x ∈ ℝ⁺:

```
C̃(x) = L_S / |R̃(x)|
```

where |R̃(x)| is a smoothed approximation using sigmoid transitions:

```
ℓ̃_D(x) = ⌈log_φ(x)⌉ / 3                         (interpolate between integer lengths)

r̃(x) = ℓ̃_D(x) / L̄_run(x)                        (estimated run count)

L̄_run(x) = 1 + Σᵢ₌₁^{ℓ̃_D-1} σ(δ · sim(dᵢ, dᵢ₊₁))   (soft run count)

where σ(z) = 1 / (1 + e⁻ᶻ) is the sigmoid
      sim(dᵢ, dⱼ) = 1 if dᵢ = dⱼ, 0 otherwise
      δ > 0 is a steepness parameter
```

**Theorem 5.3 (Differentiability).** C̃(x) is differentiable on ℝ⁺ \{φᵏ : k ∈ ℕ} (all points except phinary length boundaries).

*Proof.* ℓ̃_D(x) is piecewise constant with jumps at x = φᵏ. Between jumps, ℓ̃_D is constant and r̃(x) depends smoothly on the digit similarities. The sigmoid σ is C^∞, so the composition is differentiable. ∎

### 5.4 Gradient on the Manifold

In the experiment, we optimize over directions d on S⁷, not directly over n. The chain rule gives:

```
∇_d C = ∂C/∂n · ∂n/∂d
```

where:
- **∂C/∂n** is the discrete derivative (or ∂C̃/∂x for the soft version)
- **∂n/∂d** comes from the spiral index mapping:

```
n(d) = argminₙ ||f(n) - γ_d(t)||²

∂n/∂d ≈ - (∂²/∂n² ||f(n) - γ_d(t)||²)⁻¹ · (∂/∂n ∂/∂d ||f(n) - γ_d(t)||²)
```

**Practical gradient ascent:**
```python
def gradient_ascent_step(S_current, directions, step_size, original_size):
    n_current = spiral_index(S_current)
    C_current = compression_ratio(n_current, original_size)
    
    best_direction = None
    best_gradient = 0
    
    for d in directions:
        # Walk a small step along geodesic
        S_next = geodesic_step(S_current, d, epsilon)
        n_next = spiral_index(S_next)
        C_next = compression_ratio(n_next, original_size)
        
        # Estimate directional derivative
        grad_d = (C_next - C_current) / epsilon
        
        if grad_d > best_gradient:
            best_gradient = grad_d
            best_direction = d
    
    return best_direction, best_gradient
```

---

## 6. Information-Theoretic Measures

### 6.1 Shannon Entropy H(n)

**Definition 6.1 (Empirical entropy of DNA encoding).** For spiral index n with DNA encoding D(n) = (d₀, ..., d_{ℓ_D-1}):

```
H(n) = - Σ_{b ∈ Σ_DNA} p_b · log₂(p_b)     bits/symbol
```

where p_b = (1/ℓ_D) · |{i : dᵢ = b}| is the empirical frequency of base b.

**Properties:**
- 0 ≤ H(n) ≤ log₂(8) = 3 bits/symbol
- H(n) = 0 iff D(n) uses only one base (r(n) = 1)
- H(n) = 3 iff all 8 bases appear equally often

**Connection to compression:**
```
H(n) ≈ 3   →  poor compressibility  →  C(n) ≈ C_min
H(n) ≈ 0   →  excellent compressibility →  C(n) ≈ C_max
```

### 6.2 Kolmogorov Complexity K(n)

**Definition 6.2 (Kolmogorov complexity).** K(n) is the length of the shortest program (in a fixed universal language) that outputs n and halts.

**Upper bound via compression pipeline:**
```
K(n) ≤ |RLE(DNA(phinary(n)))| + |decoder| + O(1)
```

where `|decoder|` is the constant size of the decompression program (~few hundred bytes).

**Theorem 6.3 (Compression pipeline as upper bound).**
```
K(n) ≤ r(n) · [4 + ⌈log₂(ℓ_D(n) + 1)⌉] + O(1)
```

This means the RLE-compressed DNA encoding is a valid upper bound on Kolmogorov complexity. When C(n) is large, the encoding captures significant structure in n (low K(n) relative to log n).

### 6.3 Self-Delimiting Code Length

**Definition 6.4 (Prefix-free encoding length).** The self-delimiting length:

```
L*(n) = |phinary(n)| + 2·log₂|phinary(n)| + O(1)
```

This is the length when encoding n with a prefix-free code (prepend the length of the phinary representation, encoded in prefix-free form).

**Theorem 6.5 (Expected K(n) for random n).** For n uniformly random in [1, N]:
```
E[K(n)] = log₂ N + O(1)
```

and with high probability, K(n) ≈ log₂ N (incompressible).

### 6.4 Mutual Information with Spiral Structure

**Definition 6.6 (Spiral-phase information).** The golden angle ψ creates structure in the mapping n → (r, θ). Define the *phase* of n:

```
θ(n) = n·ψ mod 2π
```

The mutual information between n and its phase:
```
I(n : θ(n)) = H(θ(n)) - H(θ(n) | n)
```

Since θ(n) is deterministic given n, H(θ(n) | n) = 0, so I(n : θ(n)) = H(θ(n)).

For large n, θ(n) is uniformly distributed on [0, 2π) (by Weyl's equidistribution theorem, since ψ/2π is irrational). Thus H(θ(n)) → log₂(2π) in the continuous limit.

---

## 7. Spiral Depth vs. Compressibility

### 7.1 The r = √n Relationship

The spiral depth r = √n determines how "far out" on the corkscrew the index lies. The relationship between depth and compressibility is nuanced:

```
Depth regime        r range           ℓ_P(n) ~ log_φ(n)      Compressibility
─────────────────────────────────────────────────────────────────────────────
Shallow             r < 10            < 10 digits           Low (too short)
                    (n < 100)

Structured          10 ≤ r < 10⁶      10–50 digits          HIGH (best regime)
                    (100 ≤ n < 10¹²)                       Phinary patterns emerge

Deep                r ≥ 10⁶           > 50 digits           Medium
                    (n ≥ 10¹²)                               Randomness dominates

Extreme             r ≥ 10²⁵          > 150 digits          Low (near-random)
                    (n ≥ 10⁵⁰)                               Shannon limit
```

### 7.2 Why the Structured Regime is Optimal

**Theorem 7.1 (Optimal compression depth).** There exists a depth r* = √n* such that C(n*) is maximal within a local neighborhood.

*Proof sketch.* Consider C(n) as a function of n:
- For small n: ℓ_D(n) is small, so even perfect compression (r(n)=1) gives limited absolute benefit. C(n) is bounded by L_S / O(1) = O(L_S).
- For intermediate n: ℓ_D(n) is large enough for RLE to be powerful, but n has enough structure (from the phinary constraint of no consecutive 1s) to create long runs. C(n) can approach L_S / O(log log n).
- For large n: The phinary representation approaches randomness (by normality). Runs become short (r(n) ≈ 7ℓ_D(n)/8). C(n) approaches L_S / O(log n).

By continuity of the soft metric C̃(x), there must exist local maxima in the structured regime. ∎

### 7.3 The Phinary Run-Length Property

**Theorem 7.2 (Phinary run structure).** In standard phinary form, the maximum run of consecutive 0s between 1s is unbounded, but the expected run length between 1s is φ² ≈ 2.618.

*Proof.* In phinary standard form, each 1 must be followed by a 0 (no consecutive 1s). The pattern is a sequence of the form:
```
...0 1 0^{k₁} 1 0^{k₂} 1 0^{k₃} ...
```
where kᵢ ≥ 1. For "random" phinary representations, the kᵢ are geometrically distributed with mean φ, giving average gap between 1s of φ + 1 = φ². ∎
n
**Corollary 7.3 (DNA run structure).** When grouped into DNA triplets, the phinary structure creates *correlations* between consecutive triplets. Triplets that differ by one bit are more likely to be adjacent, creating natural clustering in the 8-base DNA alphabet.

This means the DNA encoding of phinary(n) has **more structure than a truly random** base-8 sequence, leading to:
```
E[r(n)] < 7ℓ_D(n)/8   (fewer runs than random)
E[C(n)] > C_min       (better compression than random)
```

---

## 8. Differentiable Approximation for Gradient Ascent

### 8.1 Smooth Run Count

To enable gradient ascent on the manifold, replace the discrete run count with a smooth approximation:

```
r̃_δ(n) = 1 + Σᵢ₌₁^{ℓ_D-1} [1 - tanh²(δ · (dᵢ - dᵢ₊₁))]
```

where δ > 0 controls steepness. As δ → ∞, r̃_δ → r (the discrete run count).

### 8.2 Smooth Compression Metric

```
         L_S
C̃_δ(n) = ──────────────────────────────────────────
         min( 3·ℓ_D(n),  r̃_δ(n)·[4 + log₂(ℓ_D(n)+1)] )
```

**Theorem 8.1 (Gradient existence).** For δ < ∞, C̃_δ is differentiable at all n where ℓ_D(n) is constant (i.e., between phinary length boundaries).

*Proof.* tanh is C^∞. ℓ_D(n) is piecewise constant. The minimum of differentiable functions is differentiable except at crossing points. ∎

### 8.3 Numerical Gradient (Practical)

For the experiment, use finite differences:

```python
def compute_gradient(n, epsilon=1.0, original_size=L_S):
    """Compute ∂C/∂n via central differences."""
    C_plus = compression_ratio(n + epsilon, original_size)
    C_minus = compression_ratio(n - epsilon, original_size)
    dC_dn = (C_plus - C_minus) / (2 * epsilon)
    return dC_dn
```

---

## 9. Summary: The Compression Metric

### 9.1 Final Definition

```
┌─────────────────────────────────────────────────────────────────────┐
│                                                                     │
│   C(n) = L_S / |RLE(DNA(phinary(n)))|                              │
│                                                                     │
│   where:                                                            │
│   • phinary(n)  = standard base-φ representation (digits 0,1)       │
│   • DNA(P)      = group phinary digits in 3s → 1 of 8 bases       │
│   • RLE(D)      = run-length encoding, smart fallback to raw      │
│   • L_S         = original state size in bits (constant)          │
│                                                                     │
│   Bounds:                                                           │
│   L_S / Θ(log n)  ≤  C(n)  ≤  L_S / Θ(log log n)                  │
│                                                                     │
│   Gradient:                                                         │
│   ∇_d C = (∂C/∂n) · (∂n/∂d)  via chain rule on S⁷                │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘
```

### 9.2 Key Properties

| Property | Statement |
|----------|-----------|
| **Bounded** | C_min(n) ≤ C(n) ≤ C_max(n) for all n (Theorem 4.4) |
| **Scale-dependent** | Optimal compression at intermediate spiral depth (Theorem 7.1) |
| **Structure-seeking** | C(n) is maximized when D(n) has few long runs |
| **Phinary advantage** | No-consecutive-1s constraint creates natural DNA runs (Corollary 7.3) |
| **Differentiable** | Soft version C̃_δ is differentiable for gradient ascent (Theorem 8.1) |
| **Information-theoretic** | K(n) ≤ \|RLE(D(n))\| + O(1) — compression upper-bounds Kolmogorov complexity |

### 9.3 Pseudocode: Full Measurement

```python
class CompressionMetric:
    """Compression metric C(n) for the Radial Self-Finding Experiment."""
    
    # Constants
    PHI = (1 + 5**0.5) / 2
    PSI = 2 * math.pi / (PHI**2)  # golden angle in radians
    DNA_ALPHABET = ['A', 'B', 'C', 'G', 'P', 'S', 'T', 'Z']
    DNA_BITS = 3  # log2(8)
    
    def __init__(self, original_size_bits: int):
        self.L_S = original_size_bits
    
    # ─── Pipeline Components ─────────────────────────────────────
    
    def phinary(self, n: int) -> list[int]:
        """Convert n to phinary standard form (Zeckendorf)."""
        if n == 0:
            return [0]
        fib = [1, 2]
        while fib[-1] <= n:
            fib.append(fib[-1] + fib[-2])
        fib.pop()
        digits = []
        rem = n
        for f in reversed(fib):
            digits.append(1 if rem >= f else 0)
            if rem >= f:
                rem -= f
        return digits
    
    def dna_encode(self, phinary_digits: list[int]) -> str:
        """3 phinary bits → 1 DNA base (8 possibilities)."""
        padded = phinary_digits + [0] * ((-len(phinary_digits)) % 3)
        dna = []
        for i in range(0, len(padded), 3):
            triplet = (padded[i] << 2) | (padded[i+1] << 1) | padded[i+2]
            dna.append(self.DNA_ALPHABET[triplet])
        return ''.join(dna)
    
    def rle_encode(self, dna: str) -> list[tuple[str, int]]:
        """Run-length encode DNA sequence."""
        if not dna:
            return []
        runs = []
        curr, count = dna[0], 1
        for b in dna[1:]:
            if b == curr:
                count += 1
            else:
                runs.append((curr, count))
                curr, count = b, 1
        runs.append((curr, count))
        return runs
    
    def compressed_size(self, runs: list[tuple[str, int]], raw_len: int) -> int:
        """Smart RLE: use compressed only if beneficial."""
        max_run = max((r[1] for r in runs), default=1)
        run_len_bits = max(1, math.ceil(math.log2(max_run + 1)))
        rle_bits = len(runs) * (self.DNA_BITS + 1 + run_len_bits)
        raw_bits = raw_len * self.DNA_BITS
        return min(rle_bits, raw_bits)
    
    # ─── Main Metric ─────────────────────────────────────────────
    
    def C(self, n: int) -> dict:
        """Compute full compression metric for spiral index n.
        
        Returns dict with all component values.
        """
        P = self.phinary(n)
        D = self.dna_encode(P)
        runs = self.rle_encode(D)
        
        comp_size = self.compressed_size(runs, len(D))
        ratio = self.L_S / comp_size if comp_size > 0 else float('inf')
        
        # Entropy
        freq = Counter(D)
        lD = len(D)
        entropy = -sum((c/lD) * math.log2(c/lD) for c in freq.values()) if lD > 0 else 0
        
        # Information-theoretic measures
        k_upper = comp_size  # Kolmogorov upper bound
        
        return {
            'C': ratio,                           # compression ratio
            'phinary_digits': P,                  # phinary representation
            'dna_sequence': D,                    # DNA encoding
            'phinary_length': len(P),             # ℓ_P(n)
            'dna_length': len(D),                 # ℓ_D(n)
            'run_count': len(runs),               # r(n)
            'compressed_bits': comp_size,         # |R(n)|
            'entropy_bits': entropy,              # H(n) in bits/symbol
            'entropy_total': entropy * len(D),    # total entropy in bits
            'kolmogorov_upper': k_upper,          # K(n) upper bound
            'spiral_depth': n**0.5,               # r = √n
            'is_locally_optimal': None,           # filled by optimizer
        }
    
    # ─── Gradient ────────────────────────────────────────────────
    
    def gradient(self, n: int, epsilon: float = 1.0) -> float:
        """Compute ∂C/∂n via central differences."""
        if n <= epsilon:
            return (self.C(int(n + epsilon))['C'] - self.C(int(n))['C']) / epsilon
        c_plus = self.C(int(n + epsilon))['C']
        c_minus = self.C(int(n - epsilon))['C']
        return (c_plus - c_minus) / (2 * epsilon)
```

---

## 10. Receipt

```json
{
  "receiptID": "compression_metric_radial_self_finding",
  "expression": "C(n) = L_S / |RLE(DNA(phinary(n)))|",
  "components": {
    "phinary": "n → {0,1}* (base-φ, standard form, no consecutive 1s)",
    "dna_encode": "3 binary bits → 1 of 8 DNA bases {A,B,C,G,P,S,T,Z}",
    "rle": "Run-length encoding with smart fallback to raw"
  },
  "bounds": {
    "lower": "C(n) ≥ L_S / Θ(log n)  (worst: all runs length 1)",
    "upper": "C(n) ≤ L_S / Θ(log log n)  (best: single run)",
    "theorem": "4.4"
  },
  "gradient": {
    "discrete": "ΔC(n) = C(n+1) - C(n) via finite differences",
    "continuous": "C̃_δ(n) with soft run count r̃_δ for differentiability",
    "manifold": "∇_d C = (∂C/∂n) · (∂n/∂d) via chain rule on S⁷"
  },
  "information_theory": {
    "entropy": "H(n) = -Σ p_b log₂ p_b  ∈ [0, 3] bits/symbol",
    "kolmogorov": "K(n) ≤ |RLE(D(n))| + O(1)",
    "depth_relation": "Optimal C(n) at intermediate spiral depth r = √n"
  },
  "status": "SPECIFIED",
  "verified": false
}
```

---

## Appendix A: Phinary-to-DNA Example

**Example: n = 42**

```
Step 1: phinary(42)
  42 = 34 + 8 = F₉ + F₆  (Fibonacci: 1, 2, 3, 5, 8, 13, 21, 34, 55...)
  P(42) = [1, 0, 0, 1, 0, 0, 0, 1, 0]  (length 9)
  Check: 34 + 5 + 2 = 41... recalculate:
  42 = 34 + 8 → positions: F₉=34, F₆=8
  P(42) = [1, 0, 0, 1, 0, 0, 0, 1]  (reading F₈ down to F₂)
  = [1(F₈=21? no, 34= F₉=34)] ... 
  
  Correct Zeckendorf: 42 = 34 + 8 → F₉ + F₆
  Digits (F₉ to F₂): [1, 0, 0, 1, 0, 0, 0, 0] (length 8)
  Wait, need to recheck Fibonacci indexing.
  
  F₂=1, F₃=2, F₄=3, F₅=5, F₆=8, F₇=13, F₈=21, F₉=34
  42 = 34 + 8 = F₉ + F₆ ✓
  P(42) = [1(F₉), 0(F₈), 0(F₇), 1(F₆), 0(F₅), 0(F₄), 0(F₃), 0(F₂)]
        = [1, 0, 0, 1, 0, 0, 0, 0]  (length 8)

Step 2: Pad to multiple of 3
  P(42) → [1, 0, 0, 1, 0, 0, 0, 0, 0] (padded with one 0, length 9)

Step 3: Group into triplets
  [1,0,0] → triplet 4 → 'P'
  [1,0,0] → triplet 4 → 'P'  (same!)
  [0,0,0] → triplet 0 → 'A'
  
  D(42) = "PPA"

Step 4: RLE
  runs = [('P', 2), ('A', 1)]
  rle_bits = 2 × (3 + 1 + 3) = 14 bits  (3 for base, 1 flag, 3 for length)
  raw_bits = 3 × 3 = 9 bits
  
  Smart RLE: raw is smaller → use raw (9 bits)

Step 5: Compression ratio
  If L_S = 240 Gbit:
  C(42) = 240×10⁹ / 9 ≈ 2.67 × 10¹⁰
```

**Note:** This example shows a case where RLE doesn't help (sequence too short). For larger n with longer runs, RLE provides significant benefit.

---

## Appendix B: Glossary

| Term | Meaning |
|------|---------|
| **Phinary** | Base-φ numeral system using digits {0, 1} |
| **Zeckendorf** | Unique representation of integers as sums of non-consecutive Fibonacci numbers |
| **Hachimoji** | Extended 8-letter DNA alphabet (A, B, C, G, P, S, T, Z) |
| **RLE** | Run-Length Encoding — compress repeated symbols |
| **Fisher-Rao** | Information geometry metric on probability simplex |
| **S⁷** | 7-sphere — the Fisher manifold for 8-state distributions |
| **Φ-corkscrew** | Golden spiral encoding f(n) = (√n·cos(nψ), √n·sin(nψ)) |
| **K(n)** | Kolmogorov complexity — shortest program producing n |
| **H(n)** | Shannon entropy — measure of randomness in encoding |
| **Self-finding** | System encoding its own search process as state |