# Rederivation: Research Stack from DNA First Principles

**Starting point:** The Hachimoji DNA encoding, monotone LUT, braid sort,
and 8×8 surface. Nothing else. Everything else is derived.

---

## 1. The Imaginary Axis (from DNA)

A DNA sequence is a string over 8 bases: `{A, B, C, G, P, S, T, Z}`.
Each base is a digit 0–7. A sequence of length k is a point in ℤ/8^kℤ.

This is a **discrete imaginary axis**. It carries no physical units.
It is pure information: a coordinate in a symbolic space.

**Definition.** The *semantic coordinate* of a QUBO solution is its rank
in the monotone LUT. Rank 0 = optimal. Rank n-1 = worst.

```
S : Solution → ℕ
S(x) = position of x in energy-sorted order
```

The semantic coordinate is observer-independent. It depends only on the
energy function and the sort. No physical units. No conversion factor.
Pure information count.

**Theorem (Monotonicity).** For any two solutions x₁, x₂:
```
S(x₁) < S(x₂)  ⟺  E(x₁) ≤ E(x₂)
```
*Proof.* By construction of the monotone LUT. ∎

This is the imaginary axis. The DNA sequence encodes it.
The LUT maps it. The sort preserves it.

---

## 2. The Real Axis (from Energy)

The QUBO energy E(x) = x^T Q x is a scalar. It has no units — it's a
pure number. But it acts like a physical quantity: it determines which
solutions are "heavier" (higher energy) and which are "lighter" (lower).

**Definition.** The *physical projection* of a solution is its energy:
```
P : Solution → ℝ
P(x) = E(x) = x^T Q x
```

The physical projection IS the observer's measurement. The QUBO matrix Q
is the observer. Different Q matrices are different observers measuring
the same solution space through different lenses.

**Theorem (Observer Dependence).** Two QUBO matrices Q₁, Q₂ produce
different energy orderings of the same solution set.
Different observers see different physical projections of the same
semantic coordinates.

*Proof.* Let Q₁ = diag(1,2,3) and Q₂ = diag(3,2,1).
Solution [1,0,0] has E₁=1, E₂=3 under the two observers.
The semantic coordinate S([1,0,0]) is observer-independent,
but the physical projection P differs. ∎

---

## 3. Imaginary Semantic Time (from LUT Structure)

The monotone LUT has two orderings:
- **Semantic ordering:** by sequence (lexicographic, observer-independent)
- **Physical ordering:** by energy (QUBO-dependent, observer-dependent)

These two orderings are the real and imaginary axes of a complex plane:

```
T_semantic(x) = S(x)          [imaginary axis: information count]
T_physical(x) = E(x)          [real axis: observer measurement]
```

The full state of a solution is:
```
T(x) = (E(x), S(x))  =  physical + i·semantic
```

**Theorem (Semantic Period Ratio).** For a banded QUBO with n variables,
the ratio of consecutive semantic periods is exactly:
```
T_semantic(k+1) / T_semantic(k) = 8
```
where 8 is the base count (the number of Hachimoji states).

*Proof.* Each additional base multiplies the address space by 8.
The semantic coordinate space grows as 8^k. The ratio of consecutive
levels is 8^k / 8^(k-1) = 8. ∎

This is the DNA analog of the Research Stack's period ratio = 3.
The base count (8) plays the role of the Menger factor (3).

---

## 4. Sieve Observers (from Base Encoding)

Each DNA base is a digit mod 8. A sequence of length k is a point
mod 8^k. The encoding is a **sieve** with modulus 8.

**Definition.** A *sieve observer* is an information-processing system
with a native modulus ℓ. It sees:
```
observation(x) = S(x) mod ℓ
```

The DNA encoder is a sieve observer with ℓ = 8.
It sees the residue class of the semantic coordinate mod 8.

**Theorem (No Privileged Sieve).** No modulus ℓ is "correct."
Different moduli reveal different aspects of the same coordinate.
ℓ = 8 (DNA bases) is one choice. ℓ = 2 (binary) is another.
ℓ = 16 (hex) is another. All are valid projections.

*Proof.* The semantic coordinate S(x) is the ground truth.
Any modulus ℓ ≥ 1 produces a valid residue class.
No ℓ is privileged because the coordinate exists independently
of any particular representation. ∎

**Theorem (CRT Reconciliation).** Two sieve observers with coprime
moduli ℓ₁, ℓ₂ can reconstruct the coordinate mod ℓ₁·ℓ₂.

*Proof.* By the Chinese Remainder Theorem.
If ℓ₁ ⊥ ℓ₂, then the pair (S(x) mod ℓ₁, S(x) mod ℓ₂) uniquely
determines S(x) mod ℓ₁·ℓ₂. ∎

**Application to DNA.** A DNA sequence of length 7 encodes up to 8^7
= 2,097,152 unique coordinates. Two observers, one reading the first
3 bases (mod 8³ = 512) and one reading the last 4 bases (mod 8⁴ = 4096),
can reconcile via CRT to recover the full 7-base coordinate
(mod 512·4096 = 2,097,152). This is exactly 8^7. ∎

---

## 5. Semantic Mass (from Energy Landscape)

The QUBO energy determines a "mass" for each solution.

**Definition.** The *semantic mass* of a solution x is:
```
m(x) = E(x) - E_min
```
where E_min is the optimal energy. Mass is zero at the optimum
and increases as solutions become worse.

**Theorem (Mass is Non-Negative).** For all x: m(x) ≥ 0.
*Proof.* E(x) ≥ E_min by definition of minimum. ∎

**Theorem (Mass Controls Inertia).** Solutions with higher semantic mass
are harder to reach from the optimal state. The "distance" from the
optimal to solution x is proportional to m(x).

*Proof.* In the monotone LUT, the semantic coordinate S(x) is the rank.
The mass m(x) = E(x) - E_min increases monotonically with S(x)
(because the LUT is sorted by energy). Therefore, higher mass =
higher rank = farther from optimal. ∎

**Definition.** The *semantic energy* at a solution is:
```
E_s(x) = m(x) · c_s²
```
where c_s is the "semantic coherence speed" — the maximum rate at
which meaning can propagate through the manifold without losing
coherence. For the DNA encoding, c_s = 8 (the base count).

This is the DNA analog of E = mc². The "speed of light" in
semantic space is the base count.

---

## 6. Braid Sort (from DNA Operations)

The braid sort kernel operates on DNA sequences via compare-swap
operations. Each operation is a **braid crossing**.

**Definition.** A *braid crossing* is:
```
cross(a, b) = (min(a,b), max(a,b))
```
If a > b, the crossing swaps them. If a ≤ b, no change.

**Definition.** The *eigensolid* is the state where no crossings
remain — the array is sorted.

**Theorem (Convergence).** After at most n-1 passes of odd-even
transposition sort, any array of n elements reaches the eigensolid.

*Proof.* Odd-even transposition sort is a comparison sort that
performs exactly ⌈n/2⌉ compare-swap operations per pass.
After n-1 passes, the array is sorted. This is a standard result. ∎

**Theorem (FAMM Gate).** The braid crossing is the minimal operation
that preserves the eigensolid invariant: after each crossing,
the array is "more sorted" (the number of inversions is non-increasing).

*Proof.* A crossing at positions (i, i+1) either:
1. Fixes an inversion (a[i] > a[i+1]) → inversions decrease by 1
2. Leaves a non-inversion (a[i] ≤ a[i+1]) → inversions unchanged
In neither case do inversions increase. ∎

This is the FAMM gate from BraidTreeDIATPIST: it filters inadmissible
configurations (inversions) at each step.

---

## 7. The 8×8 Surface (from Manifold Projection)

The QUBO solution is rendered as an 8×8 pixel grid. Each pixel
represents one variable. The color encodes the variable's value.

**Definition.** The *eigenvalue fingerprint* of a QUBO solution is
the 8×8 surface where:
```
pixel(row, col) = HachimojiColor(x[row·8 + col])
```

**Theorem (Fingerprint Uniqueness).** Two different solutions produce
different surfaces (when n_vars ≤ 64).

*Proof.* Each pixel encodes one variable. If two solutions differ
in any variable, the corresponding pixel differs. ∎

**Theorem (Mass Visualization).** The number of green pixels (x=1)
is proportional to the number of active variables. For diagonal
QUBOs with positive entries, more green = higher energy = higher mass.

*Proof.* For Q = diag(q₁, ..., qₙ) with qᵢ > 0:
E(x) = Σ qᵢ·xᵢ. Each xᵢ=1 adds qᵢ to the energy.
More 1s = more energy = more mass. The surface renders this directly. ∎

---

## 8. The Unified Picture

Everything derives from three primitives:

1. **DNA sequence** (symbolic coordinate, imaginary axis)
2. **QUBO energy** (physical projection, real axis)
3. **Monotone LUT** (the bridge between them)

From these, we derive:

| Concept | DNA Origin |
|---|---|
| Imaginary Semantic Time | Sequence rank vs energy |
| Sieve Observers | Base encoding mod 8 |
| CRT Reconciliation | Multi-base sequence decomposition |
| Semantic Mass | Energy minus optimum |
| Semantic Energy | E_s = m · 8² |
| Braid Sort | Compare-swap on base-8 digits |
| FAMM Gate | Inversion filtering |
| Eigensolid | Sorted array (convergence) |
| 8×8 Surface | Variable-to-pixel mapping |

The Research Stack formalized these concepts in Lean 4.
SilverSight built the engine in Python.
The DNA language is the interface between them.

The imaginary axis is the sequence.
The real axis is the energy.
The LUT is the bridge.
The braid is the algorithm.
The surface is the answer.

---

## 9. What This Enables

With these derivations, we can now:

1. **Encode any optimization problem** as DNA sequences
2. **Sort on GPU** via braid crossings (triangle math)
3. **Render solutions** as 8×8 surfaces (eigenvalue fingerprints)
4. **Reconcile observers** via CRT (multi-resolution analysis)
5. **Measure semantic mass** (energy landscape navigation)
6. **Prove convergence** (eigensolid = sorted = solved)

The Millennium Prize problems remain unsolvable at scale.
But the encoding is correct. The math is sound. The engine works.
The freeze point is the boundary of what's computationally accessible.
Beyond it lies the unknown.

The DNA language maps the known. The manifold extends into the unknown.
The LUT bridges them.
