# Enhancement: PIST + Braid Integration with Sprint Results

## 1. PIST.Spectral Bridge (Lean ↔ Python)

The Lean `computeSpectral` operates on 8x8 Int matrices in Q16_16 fixed-point.
The sprint's `compute_spectral_properties` uses `scipy.sparse.eigsh` on the Laplacian.

**Integration**: Add a Python→Lean bridge that:
- Takes the sprint's 8x8 spectral coefficient matrix (from `pack_eigenvalues`)
- Converts to Q16_16 fixed-point representation
- Runs through `SilverSight.PIST.Spectral.computeSpectral`
- Compares: Python float gap vs Lean Q16_16 gap

This validates that the floating-point spectral analysis is consistent with
fixed-point arithmetic — critical for embedded/ESP32 deployment.

## 2. Golden Centering ↔ Φ-Corkscrew

`BraidEigensolid.goldenCentering` = 40560 in Q16_16 = φ⁻¹ ≈ 0.618896.

The Φ-corkscrew uses ψ = 2π/φ² where φ² = φ + 1.

**Integration**: Add a `phiTorusWinding` function that:
- Computes the spiral index n from spectral coefficients
- Maps n → TorusWinding counts (a,b) via: a = n mod φ-step, b = floor(n/φ-step)
- Where φ-step = round(1/φ⁻¹) = round(φ) = 2

The torus carrier T² gives the braid a surface to live on — the spiral index
becomes a winding number around the two fundamental cycles.

## 3. BraidField PIST ↔ 4-Mode Sprint Receipt

The PIST operator has 4 areas: B (burden), G (geometry), A (adaptation), P (protection).

The sprint produces 4 receipts (one per mode) with:
- executionTimeMs → B (burden)
- dominantEigenvalue + spectralGap → G (geometry)
- mode selection logic → A (adaptation)
- OOM guards + checks_passed → P (protection)

**Integration**: Add `sprint_to_pist_field` that computes the PIST field from
sprint results and compares across modes. If all 4 modes produce the same PIST
field (within Q16_16 tolerance), the cross-mode agreement is structurally sound.

## 4. BraidSpherionBridge ↔ Cross-Mode Agreement

Proven theorem: `braidCross on (i,j) ↔ Mountain.merge for corresponding pair`

**Integration**: The 4 execution modes (ESP32, photonic, quantum, tensor) are
analogous to 4 braid strand pairs. Cross-mode agreement means all 4 pairs
converge to the same eigensolid. The `receipt_correspondence` theorem gives
formal backing to the "all modes agree" check.

## 5. TreeBraid ↔ Resumable DAG

`BraidField.rgFlow` = fold of `betaStep` over spike train = tree braid.
`Mountain.merge` = tree node merge. `MMR.append` = tree rebalancing.

**Integration**: The resumable DAG's chunked Ryser with manifold coordinate
transforms IS `rgFlow` in disguise. Each chunk is a spike; the DAG checkpoint
is the MMR state; the manifold coordinate transform is the PIST field update.

## 6. Octagonal Norm ↔ Fisher-Rao Metric

`BraidBracket.PhaseVec.normApprox` = max(|x|,|y|) + 3/8·min(|x|,|y|)

This is a norm on the phase space. The Fisher-Rao metric on Δ₇ maps to S⁷
via √p. The octagonal norm could be a Finsler metric on the same space.

**Integration**: Show that the octagonal norm upper-bounds the Fisher-Rao
distance for the 8-strand braid state embedded in Δ₇. This connects the
braid formalism to Chentsov's theorem.

## Implementation Priority

| Priority | Enhancement | Files Changed | Complexity |
|----------|-------------|--------------|------------|
| P0 | PIST.Spectral bridge (Python→Lean) | `PIST/Spectral.lean` + Python | Medium |
| P0 | Golden centering torus winding | `BraidEigensolid.lean` + Python | Low |
| P1 | PIST field from sprint receipt | `BraidField.lean` + Python | Medium |
| P1 | Cross-mode as eigensolid convergence | `BraidSpherionBridge.lean` | Low |
| P2 | TreeBraid ↔ Resumable DAG mapping | New doc + Python | Medium |
| P2 | Octagonal norm ↔ Fisher-Rao bound | New Lean proof | High |
