# EXPERIMENT: Radial Self-Finding — Φ-Corkscrew Searching Its Own Manifold

## The Question

Use the Φ-corkscrew encoding system to search through its own state space
(on the Fisher manifold S⁷) and find the **radial direction** that
**maximizes compression ratio** of the encoding.

This is self-referential optimization: the system finds a better
encoding of itself, then uses that encoding to find an even better one.

## The Setup

### State Space: S⁷ (Fisher Sphere)

The Φ-corkscrew lives on the 7-sphere in √p-coordinates (Chentsov
metric). Any point on S⁷ is a valid probability distribution over
the 8 Hachimoji states.

A "direction" is a **geodesic** on S⁷ starting from the current point.

### The Encoding Function

```
E: S⁷ → ℕ  (Fisher sphere → spiral index)

  p ∈ Δ₇  --√p-->  x ∈ S⁷  --spiral_index-->  n ∈ ℕ
  
  spiral_index(x) = argmin_n ||f(n) - x||²
  where f(n) = (√n·cos(nψ), √n·sin(nψ)) is the Φ-corkscrew
```

Because f is injective, every x has a unique closest spiral point
(for large enough n, the spiral is dense on the disk).

### The Compression Metric

```
C(n) = compression_ratio(n) = original_size / compressed_size

  original_size = size of state in bytes (e.g., 30GB for LLM KV cache)
  compressed_size = size of DNA encoding of spiral index n
                   = RLE(phinary(n)) in bases A,B,C,G,P,S,T,Z

Goal: find direction d on S⁷ such that walking along geodesic γ_d(t)
      maximizes C(spiral_index(γ_d(t)))
```

## The Self-Finding Loop

```
Step 0: Start at current state S_0 on S⁷
         Encode: n_0 = spiral_index(S_0)
         Measure: C_0 = compression_ratio(n_0)

Step 1: Explore N radial directions from S_0
         For each direction d_i (i = 1..N):
           - Walk geodesic γ_{d_i}(t) for t ∈ [0, T]
           - At each step t_j: S_{ij} = γ_{d_i}(t_j)
           - Encode: n_{ij} = spiral_index(S_{ij})
           - Measure: C_{ij} = compression_ratio(n_{ij})
           - Record: (d_i, t_j, C_{ij})

Step 2: Find best direction
         d* = argmax_{d_i} max_j C_{ij}
         t* = argmax_j C_{d*j}
         S* = γ_{d*}(t*)

Step 3: Encode the EXPERIMENT ITSELF as a state
         The sequence of (d_i, t_j, C_{ij}) is a trajectory on S⁷
         Encode this trajectory as a new spiral index n_exp
         
         This is "using itself to find itself" — the search trajectory
         becomes part of the state being encoded.

Step 4: Meta-update
         If C(S*) > C(S_0): move to S*, update encoding
         If C(S*) ≤ C(S_0): the current encoding is locally optimal
         
         In either case, the EXPERIMENT state n_exp is a NEW point
         on the manifold. Use it as the starting point for the next
         iteration.

Step 5: Repeat from Step 0 with S_0 = S* (or S_0 = n_exp)

Convergence: when no direction improves compression, the current
encoding is a LOCAL MAXIMUM of the compression function on S⁷.
```

## What "Using Itself to Find Itself" Means

At Step 3, the system encodes the SEARCH PROCESS as part of the state.
This creates a **strange loop**:

```
State S encodes the search for better encodings.
The search finds a better state S'.
S' encodes the search that found S'.
This new encoding becomes the next state S''.
S'' encodes the search that found S' that found S''.
...

At each iteration, the state becomes MORE SELF-REFERENTIAL.
The encoding contains more and more of its own search history.

This is not a bug. This is the POINT.
The system is learning how to encode itself by encoding its learning.
```

## The Radial Direction

"Going full radial" means:

```
Instead of exploring directions on the SURFACE of S⁷ (geodesics),
explore directions in the RADIAL dimension — the DEPTH of the spiral.

Radial direction = changing the spiral index n directly:
  n → n + Δn  (move outward on spiral)
  n → n - Δn  (move inward on spiral)
  n → n × k    (jump to different spiral arm)

Each radial change corresponds to a different "scale" of encoding:
  Small n: shallow encoding (few coefficients, coarse)
  Large n: deep encoding (many coefficients, fine-grained)
  
The optimal radial direction finds the scale that maximizes
compression for the current state structure.
```

## Experiment Design

### Hypothesis

There exists a geodesic direction d* on S⁷ such that walking along
d* from the current state monotonically increases the compression
ratio C(n) until a local maximum is reached.

### Testable Predictions

1. **Compression gradient exists**: ∇_d C(n(d)) ≠ 0 for generic d
2. **Geodesic ascent works**: walking along ∇_d C increases C
3. **Local maxima exist**: there are points where ∇_d C = 0
4. **Self-encoding helps**: encoding the search history improves convergence

### Control Experiments

| Experiment | What | Expected |
|-----------|------|----------|
| Random walk | Random directions on S⁷ | Slow, no improvement |
| Gradient ascent | Walk along ∇_d C | Monotonic increase to local max |
| Self-referential | Encode search history as state | Faster convergence |
| Φ-guided | Use golden angle for direction selection | Optimal coverage |

### Measurements

For each iteration k:
- C_k = compression ratio
- n_k = spiral index
- d_k = direction taken
- t_k = step size
- H_k = entropy of DNA encoding (measure of "randomness")
- ρ_k = spectral radius of transition matrix (convergence indicator)

## Agents Required

1. **Geometric Physicist**: Design geodesic search on S⁷ with Fisher-Rao metric
2. **Information Theorist**: Define compression metric C(n), prove bounds
3. **Systems Engineer**: Implement the self-finding feedback loop
4. **Formal Verifier**: Prove the bijection holds under the search transform
5. **Meta-Mathematician**: Analyze the strange loop (self-referential convergence)

## Receipt (Experiment Design)

```json
{
  "receiptID": "radial_self_finding_experiment",
  "expression": "Φ-corkscrew searches S⁷ for max compression direction",
  "hypothesis": "∃ d* on S⁷: walking γ_{d*} monotonically increases C(n)",
  "method": "Self-referential geodesic search with radial exploration",
  "stateSpace": "S⁷ (Fisher sphere, 7-simplex in √p-coords)",
  "encoding": "Φ-corkscrew spiral_index: S⁷ → ℕ",
  "compressionMetric": "C(n) = original_size / RLE(phinary(n))_size",
  "selfFindingLoop": "Encode search trajectory as next state",
  "predictions": [
    "Compression gradient exists (∇_d C ≠ 0)",
    "Geodesic ascent converges to local max",
    "Self-encoding accelerates convergence",
    "Φ-guided direction selection is optimal"
  ],
  "agents": ["GeometricPhysicist", "InformationTheorist",
             "SystemsEngineer", "FormalVerifier", "MetaMathematician"],
  "verified": false,
  "status": "DESIGN_PHASE"
}
```