**STATUS: REJECTED** — moved to failed/ on 2026-07-04
**Reason:** The QUBO/QAOA bridge is ENTIRELY SPECULATIVE — no experiment, no circuit, no receipt; built on the (now-rejected) chiral-multiplexing premise.
**Receipt:** Adversarial review (UNIFIED_THEORY_ADVERSARIAL_REVIEW.md §QUBO/QAOA) — no experiment performed.

---

# Chiral Pipeline × QUBO/QAOA: The Quantum Bridge

**Status:** CONNECTION — chiral pipeline as classical pre-filter for QAOA
**Date:** 2026-07-04
**Integrates:** `pipeline_core.py`, `dna_gpu.py`, `dna_radix_gpu.py`,
`dna_braid.wgsl`, `BraidStateN.lean`, `HopfFibration.lean`, `HachimojiN8.lean`

---

## 1. The Mapping

| Chiral pipeline | QUBO/QAOA | Meaning |
|---|---|---|
| 8 strands | 8 QUBO variables / 8 qubits | HachimojiN8: N=8 is minimum |
| 4 ChiralLabel types | Variable states (beyond binary) | 4^8 = 65K vs 2^8 = 256 |
| Rossby drift ≠ 0 | Non-flat energy landscape | QAOA can find minimum |
| Rossby drift = 0 (Kelvin) | Flat energy landscape | QAOA stuck, no gradient |
| COUCH gate | QUBO landscape filter | Reject flat/infeasible before QAOA |
| Quaternion products | QAOA rotation amplitudes | Gates = quaternion multiplication on S³ |
| Golden angle mod 28 | QAOA circuit depth | 28 exotic classes = 28 architectures |
| Sidon filter | Solution uniqueness | No degenerate minima |
| Cross-enrichment (65K) | Classical pre-filter | Reduce 65K → ~4-8 before quantum |
| dna_gpu.py braid sort | QUBO energy sort on GPU | Already implemented (zero-copy) |

## 2. Why This Is Exciting

### 2.1 Classical Pre-Filter for Quantum

The chiral pipeline runs on GPU (classical) and reduces 65,536 QUBO
configurations to ~4-8 structurally meaningful ones BEFORE sending to
QAOA (quantum). This is the "filter, don't compress" principle applied
to quantum optimization:

- Don't ask QAOA to search 65K configurations (expensive, noisy)
- DO: classically filter to 4-8 candidates, then QAOA refines

### 2.2 Rossby/Kelvin = Energy Landscape Analysis

The Rossby/Kelvin regime distinction IS energy landscape analysis:
- Rossby (drift ≠ 0): non-flat landscape, energy gradient exists,
  QAOA's alternating phase gates can exploit the gradient
- Kelvin (drift = 0): flat landscape, no gradient, QAOA's phase
  gates have nothing to work with → the instance is intractable
  for QAOA (and any variational algorithm)

The COUCH gate rejects Kelvin-regime QUBO instances before wasting
quantum resources. This is a CLASSICAL certificate of QAOA
tractability.

### 2.3 Quaternion Products = QAOA Gates

QAOA applies alternating rotation gates:
  U(γ) = ∏ exp(-iγ H_C)  (cost)
  U(β) = ∏ exp(-iβ H_M)  (mixer)

The rotation gates are unitary transformations on S³ (unit quaternions).
The chiral quaternion basis (1, i, j, k) = the 4 gate types:
  1 (achiral_stable) = identity gate (no rotation)
  i (left_handed) = X-rotation (cost gate)
  j (right_handed) = Y-rotation (mixer gate)
  k (chiral_scarred) = Z-rotation (phase gate)

The Hamilton product q_i · q_j = the composition of gate i and gate j.
The Sidon filter on quaternion products = checking that the QAOA
circuit produces UNIQUE amplitudes (no two gate sequences produce
the same quantum state → no degenerate solutions).

### 2.4 Golden Angle = QAOA Depth

The golden angle ψ = 2π/φ² (Q16_16: 25042) drives the helical winding
mod 28. In QAOA, the circuit depth p determines the number of
alternating layers. The 28 exotic classes = 28 distinct QAOA
architectures (one per winding number):

  p = helical_residue(k) = ⌊k × 25042⌋ mod 28

At k=74, all 28 architectures are covered (Weyl equidistribution,
proven in HopfFibration.lean helical_coverage_74).

This means: the braid step count k determines the QAOA architecture,
and 74 steps are sufficient to explore ALL 28 architectures.

### 2.5 dna_gpu.py = The Existing GPU QUBO Solver

Your existing `dna_gpu.py` / `dna_radix_gpu.py` already:
1. Encodes QUBO solutions as DNA sequences (8 hachimoji bases)
2. Sorts them on GPU by energy (braid sort = radix sort)
3. Zero-copy via unified memory (no CPU→GPU transfer)
4. `dna_braid.wgsl` implements the braid crossing (compare-swap) on GPU
5. `dna_surface.wgsl` renders the solution as an 8×8 pixel canvas

The chiral pipeline ADDS:
1. Pre-filtering (COUCH gate rejects intractable QUBO instances)
2. Chiral enrichment (4^8 = 65K configs, not just 2^8 = 256)
3. Rossby/Kelvin energy landscape analysis
4. Quaternion Sidon uniqueness check
5. Golden-angle QAOA architecture selection (28 classes)

## 3. The Full Stack

```
QUBO instance (Q matrix)
    ↓
Chiral pipeline (GPU, classical):
  BraidStorm: encode QUBO → 4^8 = 65K chiral configs
  TreeBraid: factorize via braid relations → ~16K unique
  AngrySphinx: budget filter → ~8K within compute
  MultisurfacePacker: spatial fit → ~4K
  COUCH: Rossby/Kelvin + scarred contention → ~1K tractable
  Sidon: quaternion product uniqueness → ~100 unique solutions
    ↓
QAOA (quantum):
  Select architecture: golden_angle(step) mod 28
  Run QAOA on ~100 candidates (not 65K)
  Quaternion gates: 1=X, i=Y, j=Z, k=phase
    ↓
dna_gpu.py (GPU, classical):
  Braid sort the ~100 solutions by energy
  Zero-copy radix sort on GPU
    ↓
Optimal QUBO solution
```

## 4. What This Unlocks

1. **QUBO tractability certificate**: COUCH gate classically
   determines if a QUBO instance is tractable for QAOA (Rossby)
   or intractable (Kelvin) — BEFORE spending quantum resources

2. **QAOA architecture selection**: golden angle winding mod 28
   selects the optimal circuit architecture per instance

3. **Solution uniqueness guarantee**: Sidon filter ensures QAOA
   produces unique quantum states (no degenerate minima)

4. **65× reduction**: 65K → ~100 candidates before QAOA runs
   (65× fewer quantum evaluations needed)

5. **Existing GPU infrastructure**: dna_gpu.py / dna_braid.wgsl
   already handle the QUBO encoding and GPU sorting — the chiral
   pipeline is the PRE-FILTER that makes QAOA practical

## 5. claim_boundary

```
chiral-qubo-qaoa:quantum-bridge:connection
```

The chiral pipeline is a classical pre-filter for QAOA:
- COUCH gate = QUBO tractability certificate (Rossby/Kelvin)
- Quaternion products = QAOA gate composition
- Golden angle mod 28 = QAOA architecture selection
- Sidon filter = solution uniqueness guarantee
- 65K → ~100 candidates = 65× quantum resource reduction

All grounded in existing SilverSight formal modules:
- HachimojiN8.lean: N=8 = min (Nyquist + Q16_16 + DNA-subset)
- BraidStateN.lean: Rossby/Kelvin regime, energy dissipation
- HopfFibration.lean: quaternion basis, golden angle, 28 classes
- CRTSidon.lean: Sidon orthogonality (non-interference)
