Research-Stack/6-Documentation/docs/specs/HYDROGENIC_PHI_TORSION_BRAID.md

Hydrogenic Phi-Torsion Braid

Status: FORMING

Purpose

This spec formalizes the hydrogenic Phi-torsion braid as a parametric manifold:

Fibonacci spine -> hydrogenic 2s constraint groove -> Phi torsion -> stair/event trace

The object is not a literal atom simulation. It is a generation surface that exposes how a scale-delayed mass-number event cell was produced.

Parameters

theta       continuous state/evolution parameter
phi         (1 + sqrt(5)) / 2
r0          initial radius
a0          Bohr-radius-like scale
R_tube      torsion amplitude
k           logarithmic growth constant

There are two useful growth gauges:

k_code       = (2 / pi) * ln(phi)
k_steep      = (pi / 2) * ln(phi)

k_code matches the original Python generator. k_steep matches the steeper derivation form and climbs faster. Treat this as a gauge choice, not a hidden correction.

1. Base Fibonacci Expansion

r_base(theta) = r0 * exp(k * theta)

This is the unconstrained manifold expansion.

2. Hydrogenic 2s Constraint Groove

Normalize the base radius into hydrogenic scale:

rho(theta) = r_base(theta) / a0

Use the topology-shape form of the 2s radial wavefunction:

psi_2s(rho) = (2 - rho) * exp(-rho / 2)
D_topology(rho) = psi_2s(rho)^2
                = (2 - rho)^2 * exp(-rho)

The node is:

rho = 2
r_base = 2a0

The constrained radius is:

R_c(theta) = r_base(theta) * normalize(D_topology(rho(theta)))

If physical radial probability is desired instead of topology shape:

D_radial(rho) = r_base(theta)^2 * psi_2s(rho)^2

The current braid uses D_topology because it makes the node act as a hard geometric groove.

3. Planar Spine

x_spine(theta) = R_c(theta) * cos(theta)
y_spine(theta) = R_c(theta) * sin(theta)

4. Phi Torsion

The canonical torsion phase is:

gamma(theta) = phi * theta

The UI/generalized generator can split this into:

gamma(theta)       = radial_torsion * theta
alpha(theta)       = angular_torsion * theta

Canonical mode sets:

radial_torsion = phi
angular_torsion = 1

The screenshot/user-control mode used:

radial_torsion = 5
angular_torsion = 3

5. Final Position Vector

Canonical equation:

P(theta) =
[
  R_c(theta) * cos(theta) + R_tube * cos(phi * theta) * cos(theta),
  R_c(theta) * sin(theta) + R_tube * cos(phi * theta) * sin(theta),
  R_tube * sin(phi * theta)
]

Generalized UI equation:

P(theta) =
[
  R_c(theta) * cos(theta) + R_tube * cos(gamma(theta)) * cos(alpha(theta)),
  R_c(theta) * sin(theta) + R_tube * cos(gamma(theta)) * sin(alpha(theta)),
  R_tube * sin(gamma(theta))
]

6. Stair/Event Lift

For the FPGA/event-cell trace, keep a second z channel:

stair_period = (2pi) / stair_divisions
stair_index(theta) = floor((gamma(theta) - gamma(0)) / stair_period)
z_stair(theta) = R_tube * sin(gamma(theta)) + stair_index(theta) * stair_rise

The bounded channel z_torsion preserves the braid. The monotonic channel z_stair exposes the climb.

7. Generation Trace Fields

The generated data should retain:

theta
r_base
rho
D_topology
D_radial
R_c
gamma
alpha
stair_index
stair_phase
strain = abs(gradient(R_c, theta))
emitted_amplitude = abs(gradient(z_stair, theta)) * selected_constraint
P(theta)
P_stair(theta)

These fields are the bridge from visual manifold to fixed-point FPGA event cells.

8. Color Rope Mapping

The braid can be combined with the CMYK rope concept by treating each color channel as a typed load path through the generated equation trace:

C = constraint / monitor channel
M = evidence / verification channel
Y = residual / prune channel
K = admissible action / stable axis channel

For hard-math triage:

C <- orbital groove constraint
M <- attached evidence mass
Y <- residual risk + proof debt
K <- admissible mass + lattice pressure

This turns a visual braid into a color-coded routing object. If Y dominates, the rope is fraying and the state should remain residue or be pruned. If C + M + K dominates Y, the state may be eligible for promotion, provided the fracture and evidence thresholds also pass.

9. Fractionalized Tensegrity Configuration

The core equation should be split into load-bearing members:

fibonacciSpine
orbitalGroove
planarSpine
phiTorsion
stairLift
strainField
emissionPacket
colorRope

The default tensegrity skeleton uses pull/compression edges:

fibonacciSpine --tension--> orbitalGroove
orbitalGroove --compression--> phiTorsion
phiTorsion --tension--> stairLift
stairLift --tension--> strainField
strainField --compression--> emissionPacket
emissionPacket --tension--> colorRope

Each member carries a Q0.16-style load. Each edge compares its current load difference or compression average against a rest length. Total strain becomes the sieve's structural stress signal.

This is the hard-math use: do not ask whether a whole problem is solved. Split the problem into typed members, let the members strain each other, and route the state as:

stable signal
residue
quarantine
no-CFD route

Why It Does Not Close

When radial_torsion = phi, the torsion phase is irrational relative to the spine phase:

cos(phi * theta) does not synchronize with cos(theta)

The result is an unclosed braid: bounded by the hydrogenic constraint groove, but not periodic in the ordinary spine frame.