Explaining Soliton Manifold Calculation Trace
Given a raw expression (e.g., 0.1 + 0.2), produce the stage-by-stage trace description by filling this template per stage:
Stage N · [Name] (T_k)
Pulses [range] · R=..., r=..., W=... · [freq] Hz ([plane])
[One-sentence geometric/arithmetic summary]
1. Stage Entry (Pulse X) — [diamond color] diamond drop, coordinates/angle
2. Arithmetic Operation — exact formula applied (fractions, gcd, cross-mult, etc.)
3. Geometric Translation — how the arithmetic step maps to torus geometry
4. Exit & Quadrance Gate — Q1, Q2, Q3, Q̂, A_R values; which torus is entered next
Always keep arithmetic exact rational (BigInt numerator/denominator) — never introduce floating point or trigonometric functions (sin/cos/tan) into the actual calculation logic. Trig only appears as an optional operator (sin, cos) inside Stage 2 superposition, not as the mechanism of arithmetic itself.
Progress:
- Identify the operand pair and operator (+, −, ×, ÷, ^, √, sin, cos)
- Stage 0 (T4): Parse decimal strings into exact coprime fractions via
gcd(digits, 10^k) - Stage 1 (T3): Cross-multiply to common denominator using Shunting-Yard precedence
- Stage 2 (T2): Apply the operator to produce unreduced
{N_raw, D_raw} - Stage 3 (T1): Euclidean GCD collapse — prune collinear/redundant factors (A_R = 0 check)
- Stage 4 (T0): Unwind digits via remainder winding (
rem = (rem*10) mod D) untilrem = 0or repeat detected - Map each stage's state onto the 5-tier geometry table (R_n, r_n, W_n, f_n, ω ratio)
- Compute quadrances Q1, Q2, Q3, Q̂ and the collinearity check A_R = (Q1+Q2+Q3)² − 2(Q1²+Q2²+Q3²)
- Verify total pulse count = 150 (5 stages × 30 nodes), holonomic spinor = 720°
| Tier | R_n = 5n²+15n+15 | r_n = 2n+4 | W_n = 16−2n | f_n = 6W_n | ω_n/ω_4 |
|---|---|---|---|---|---|
| T4 (n=0) | 15 ... wait, use formula at n=0→15? | 4 | 16 | 96 Hz | 1.00× |
Always compute from the closed forms, don't eyeball a table. Example at n=4 (outermost, Stage 0): R₄ = 5(16)+15(4)+15 = 80+60+15 = 155 ✓, r₄ = 2(4)+4 = 12 ✓, W₄ = 16−8 = 8 ✓, f₄ = 48 Hz ✓. At n=0 (core, Stage 4): R₀=15, r₀=4, W₀=16, f₀=96 Hz, ω₀/ω₄ = W₀/W₄ = 2.00×. Stage index and tier index n run opposite directions — Stage 0 = T4 (n=4), Stage 4 = T0 (n=0). Always state this inversion explicitly to avoid confusion.
Example 1:
Input: 0.1 + 0.2
Output:
- Stage 0: A = 1/10, B = 1/5 (from gcd(1,10)=1, gcd(2,10)=2)
- Stage 1: cross-multiply over D_com=50 → A'=5, B'=10
- Stage 2: N_raw = 15, D_raw = 50
- Stage 3: gcd(15,50)=5 → N_pruned=3, D_pruned=10
- Stage 4: 3/10 → digit wind: 3*10=30, 30÷10=3 rem 0 → "0.3", lock
Example 2: Input: "Does the engine use sine, cosine, or tangent for arithmetic?" Output: No. Trig functions (sin/cos) only appear as selectable operators at Stage 2 (same tier as +,−,×,÷,^,√) when the user explicitly chooses a trig operation. All default arithmetic (add/subtract/multiply/divide) is performed with exact BigInt rational fractions — no floating point, no trig, no approximation. Decimal output is produced by exact remainder-winding division, not float formatting.
Example 3: Input: Gear-train preset "8-12-16 Inward Doubler" Output: Outer Driver T4 (W=8) → Middle Clutch T2 (W=12) → Inner Anchor T0 (W=16). Net overdrive = W0/W4 = 16/8 = 2.00×. LCM(8,12,16)=48 teeth phase-lock window. W_stack = 8+12+16 = 36.
- Preserve exactness as the core thesis: every stage must reinforce that this is unbounded rational BigInt arithmetic, never IEEE-754 float — this is the system's signature differentiator (explains why
0.1+0.2gives exact0.3, not0.30000000000000004). - Keep stage order and direction consistent: T4→T3→T2→T1→T0 is Stage 0→4, outer to inner, 30 pulses each, 90° plane flip at every gate (XY↔XZ alternating), always ending flat XY at T0.
- Tie every geometric claim to a formula: R_n, r_n, W_n, f_n are all closed-form in
n; derive rather than invent numbers when extending to new stages/tiers. - Quadrance terminology: use Q1, Q2, Q3 for pairwise squared-distances between active node and adjacent tori, Q̂ for a normalized/cosine-like ratio, and A_R for the rational collinearity discriminant (A_R=0 ⟺ triangle degenerates to a line ⟺ "prune this factor").
- Gear-train sections are a separate mechanical metaphor (teeth, LCM phase-lock, overdrive ratio) layered on top of the torus tiers — keep gear math (LCM, ratio) distinct from quadrance/rational-arithmetic math.
- 150 pulses / 720° total is a fixed invariant (5 stages × 30 nodes = 150; 2 full 360° turns = 720° "holonomic spinor cycle") — use it to sanity-check any new animation or scrub-bar spec.
- Don't let floating-point ever creep into the "Arithmetic Operation" step of any stage — even intermediate scratch math should be phrased in terms of BigInt numerator/denominator operations.
- Don't confuse stage index with tier subscript — Stage 0 is tier T4, Stage 4 is tier T0 (inverse mapping); always double check when generating new copy.
- Don't imply sin/cos/tan drive the default + − × ÷ pipeline — they're optional Stage-2 operator choices only, not the computation substrate.
- Don't invent R/r/W/f values from a table by eye; recompute from the closed-form formulas to avoid arithmetic drift when adding new tiers or presets.
- Don't drop the 90° plane-flip alternation (XY→XZ→XY→XZ→XY) when describing stage transitions — it's a structural invariant across all five stages.