The Geometric Harmonics Calculator: Instruction Manual & Explainer

The big idea

Most calculators treat a sum as an instant, invisible event. This engine slows a calculation down and gives it a shape: a journey inward through five nested rings, ending in an answer that is exact rather than "very close".

Why ordinary computers get 0.1 + 0.2 wrong

Almost every computer stores decimal numbers in a binary format called IEEE-754 floating point. A 64-bit "double" keeps about 15 to 17 significant digits (53 binary digits, the mantissa) and throws the rest away.

That works well for most things, but some everyday decimals have no exact binary form. One tenth is the classic example: in base 2 it repeats forever, 0.000110011001100…, much as one third repeats forever in base 10 (0.333…). The computer has to cut it off, and the tiny leftover error shows up when you add:

A second failure is the precision ceiling. Try 9.0000000000000005 + 0.30000008 on a normal calculator. The tiny …0005 at the end is beyond the 53-bit limit, so it silently disappears and you get 9.30000008. The engine keeps every digit: 9.3000000800000005.

The engine's answer, in two layers

The vocabulary you'll meet

The engine uses the language of the research paper behind it: manifold, soliton, holonomy, spinor. You don't need any of it to use the calculator, and each term is explained where it first matters (and again in the glossary). As a first translation:

Quick start: your first calculation

Five minutes, no theory needed. Open the engine in another tab and follow along.

1. Look around. The coloured rings in the middle are the five tiers. Drag with the mouse (or one finger) to rotate the view, scroll (or pinch) to zoom, right-drag (or two fingers) to pan. The crosshair button at the bottom left recentres the camera.
2. Open the TERMINAL. In the left panel, click 2. TERMINAL. This is the calculator keypad.
3. Load the classic test. Click IEEE Test: 0.1 + 0.2. The expression appears in the display.
4. Press RESOLVE MANIFOLD (=). The right panel switches to REGISTER. A pink orb appears on the outer red ring (T4) and a red diamond marks where it started.
5. Watch the five stages. The orb winds around each ring, then jumps inward. Each jump drops a new coloured diamond: amber (T3), green (T2), purple (T1), blue (T0). The Register lists the stages and ticks them off. Stages 3 and 4 run more slowly on purpose; that's where the answer is "trimmed" and "latched".
6. Read the result. When the last stage finishes, the display shows 0.3 exactly, a message confirms the result, and an explanation card appears in the Register (Node A = 1/10, Node B = 1/5, Collapse = 3/10).
7. Try the ceiling test. Back in TERMINAL, click 64-Bit Ceiling Test and resolve again. The answer keeps all 16 decimal places.
8. Inspect what happened. In the Register, click any stage card (or the S0–S4 pills) to replay that stage's 30 frames, and click a frame row to see its measurements. Then drag the bottom Frame Scrubber to move the orb back and forth along its path.
9. Make a fingerprint. Click Hash to Engram (next to Reset Before Calc). The left panel jumps to 3. ENGRAM and shows your result as a 64-bit tile.

A tour of the screen

The engine fills the whole window. Everything sits on top of the 3D view in floating glass panels you can hide.

1. Left panel, four tabs: 1. PAPER (four guided demonstrations from the paper, chapter 13), 2. TERMINAL (the calculator, chapter 7), 3. ENGRAM (the 64-bit tile, chapter 12) and 4. CLUTCH (the gear train and clock-rate coupling, chapter 11). The header badge WΣ = 60 and a status icon (wave = idle, spinning arrows = computing, tick = result ready) sit at the top. The [Paper] link opens the research paper.
2. 3D view: the five tori, the braided helix tubes, the square particles, thin radial lines to the centre, the glowing core, the calculation trace and any checkpoint diamonds or TQF polygons you switch on.
3. Right panel, four tabs: TELEMETRY, REGISTER, HUB and VISIBILITY (chapter 14).
4. Bottom control bar: camera reset, play/pause, free spin, trace, degree overlay, sync mode, speed and the frame scrubber (chapter 15).
5. Panel tabs: the small chevron tabs on the inner edge of each side panel slide that panel off-screen, so you can see the full 3D view. Click again to bring it back.
6. Site bar: the floating bar at the top centre takes you back to the main site, to this manual, signs you in with Google (the same sign-in as the rest of the site) and links to GitHub, X, YouTube and Patreon. Its arrow button tucks it away into a small ••• button.

The five tiers

Everything in the engine hangs off five tori. Their sizes and winding speeds aren't arbitrary: each follows a simple formula in the tier number n (0 for the core, 4 for the outside).

What a torus is, and how a path winds around it

A torus is a doughnut shape. It has two radii: the major radius R (from the centre of the doughnut to the middle of its tube) and the minor radius r (the thickness of the tube). A point on it is fixed by two angles: θ goes the long way round the ring, φ goes round the tube.

If you tie the two angles together as φ = W·θ, a point travelling once round the ring wraps round the tube W times, drawing a spiral like the stripe on a candy cane bent into a circle. W is the tier's winding number. The coloured helix tubes on each torus in the 3D view are exactly these spirals.

The three tier laws

The four ratios that tie them together

1. The winding invariant, W_Σ = 60. Add the winding numbers: 8 + 10 + 12 + 14 + 16 = 60. This is the WΣ = 60 badge in the header, and 60 is also the engine's base pulse rate (60 pulses per second at nominal speed).
2. The 2:1 inward acceleration. Every stage takes the same number of pulses (30), but inner tiers wrap more often: 8 wraps on T4, 16 on T0. So the spin rate doubles from outside to inside, ω₀/ω₄ = 16/8 = 2, like a skater spinning faster as they pull their arms in. The tier frequencies f = 6W run 48, 60, 72, 84, 96 Hz.
3. Quadratic compression. The gaps between rings shrink in equal steps (50, 40, 30, 20: a constant "second difference" of 10, which is what a quadratic formula produces). Overall the ring shrinks from 155 to 15, a factor of 31/3 ≈ 10.33.
4. The π/6 handshake. The middle tier T2 has W = 12, which splits a full turn into twelve 30° (π/6) sectors. 30° becomes the "gear tooth" that the outer and inner tiers have to agree on (chapter 10).

Why the tiers alternate between flat and upright

Neighbouring tiers are orthogonal: T4, T2 and T0 lie flat, T3 and T1 stand upright. A calculation moving inward therefore has to "fold" through 90° at every stage. The paper calls the jump between tiers an orthogonal geodesic plunge; on screen it's the moment the orb leaves one ring and swoops onto the next. Because consecutive rings are perpendicular, no two neighbours ever overlap, and each stage begins in a fresh plane.

What else is drawn on each tier

• Dual-helix braid tubes. Six spirals per tier: three starting phases (0°, 120°, 240°, the C₃ triad) times two directions (forward, blue, and reverse, amber, the C₂ chirality). Together they form a braid.
• Square particle fields. Sixteen square particles ride each of those six spirals, so 96 per tier and 480 in all. They flow at the tier's frequency whenever the engine is running, which makes the inward speed-up visible.
• Orthogonal radial lines. A faint line from the centre to every particle, a reminder that every point is measured from the core.
• The scalar core. The white sphere at the centre. It glows blue when the system is in lock and turns red when the clutch slips or drift is injected (chapter 11).
• A polar grid lies faintly in the background for orientation.

The 30-node clock

The engine replaces "frames per second" with a clock built from the geometry itself. Each ring is divided into 30 nodes, and the pattern those nodes follow is what the paper calls the intrinsic topological clock.

Thirty nodes, 12° apart

Each tier is cut into 30 equal steps of 12°: node k sits at θ_k = 2πk/30. The engine labels them F1/30 … F30/30. Two repeating patterns run across them at once:

• C₃, the triadic phase. Every three nodes cycle through 0°, 120° and 240° (k mod 3). This keeps the path balanced: no direction is favoured.
• C₂, chiral parity. Nodes alternate between the forward braid (+1) and the reverse braid (−1) (k mod 2).

Together they form a 6-node pattern (C₃×C₂), and 30 nodes hold exactly five copies of it. That's what the label |C₃ × C₂| × 5 Tiers on the Active Node card refers to.

The Cesium-133 half-cycle

The international definition of the second is 9,192,631,770 oscillations of a caesium-133 atom. At the engine's base rate of 60 pulses per second, one pulse lasts

That trailing .5 is the parity residual, shown as φ_p on the Parity State card. After an odd number of pulses there's half a cycle left over (φ_p = 0.5); after an even number it cancels (φ_p = 0.0). At node 30 that integer closure coincides with a full 360° turn and the end of the fifth C₃×C₂ pattern:

So one 30-node lap takes half a second at nominal speed and contains a whole number of caesium cycles. That is the gate the engine waits for before letting a calculation move inward to the next tier.

From 30 nodes to 150 pulses to 720 frames

• A calculation visits all five tiers, 30 nodes each: 150 pulses. At the nominal 60 pulses per second that's 0.5 s per stage and 2.5 s in total.
• On screen it runs slower so you can follow it. During a calculation the clock runs at 6× the speed slider for stages 0–2 and 2.5× for stages 3–4. At the default 0.10x that's roughly 0.8 s per outer stage and 2 s per inner stage: about 6–7 seconds in all.
• The same journey can also be counted as 720 frames, two full turns of 360°. The paper calls this the holonomic or spinor view. Spinors are mathematical objects that only return to their starting state after 720°, not 360° (the "belt trick" is the everyday example). The bottom scrubber can count in either unit (chapter 15).

The calculation trace

The fuchsia orb and its comet trail show where the calculation "is". Here is exactly how it starts, moves and finishes.

Where it starts

With Reset Before Calc ticked, pressing = resets the clock, the pulse counter and the manifold's rotation to zero, so the same expression always traces the same path. The orb starts on T4 at θ = 0, φ = 0:

A crimson-rose octahedron, the first checkpoint diamond, is dropped there to mark the start of Stage 0.

Spinning around a tier

During each stage the orb winds around the current tier along its helix (φ = Wθ), so it circles the inner tiers faster than the outer ones. Each animation frame it moves a quarter of the way toward its target point (lerp(target, 0.25)), which smooths the motion into a flowing comet trail.

Jumping between tiers

When the clock reaches node 30 on the current tier (the parity gate from chapter 5), the stage advances:

1. A new checkpoint diamond is dropped where the orb is, coloured for the stage it's entering: amber (Stage 1, T3), green (Stage 2, T2), purple (Stage 3, T1), blue (Stage 4, T0). Each diamond wears a white halo ring.
2. The orb's target switches to the next tier inward, which is turned 90° from the one it's leaving.
3. Because the orb eases toward its new target, it sweeps across the gap in a curve rather than teleporting: that curve is the inward bridge you see in the trail.
4. Entering Stage 3 the engine deliberately slows down (the clock drops from 6× to 2.5×). This is the pruning stage, and the slower pace lets you see the last two tiers clearly.

Where it finishes

The calculation is complete when the clock closes node 30 on T0, the fifth and last parity gate: 5 stages × 30 nodes = 150 pulses, or 720° of the holonomic cycle. At that moment the engine:

• writes the result into the display and the Register, and shows the explanation card;
• stops the animation (unless FREE SPIN is on, in which case the rings keep turning);
• pops up a message such as Manifold Resolution Complete: 0.1 + 0.2 = 0.3.

Exact arithmetic, stage by stage

What the engine computes is exact rational arithmetic: every value is a fraction n/d of two whole numbers with no size limit. Here is the pipeline, mapped onto the five stages.

Stage 0 on T4: turning decimals into exact fractions

Each number is read as text, never as a float. A number with k digits after the decimal point becomes (all its digits) / 10^k, then is reduced by the greatest common divisor (GCD), found with Euclid's 2,300-year-old algorithm:

Examples: 0.1 → 1/10. 0.2 → 2/10 → 1/5. 9.0000000000000005 has 16 decimals:

Nothing has been rounded. The fraction is the number, exactly.

Stage 1 on T3: putting operations in order

The expression is reordered with Dijkstra's shunting-yard algorithm so that operations happen in the right order: brackets first, then ^, then * and /, then + and -. Powers group from the right, so 2^3^2 means 2⁹ = 512, as in standard maths. Conceptually this is also where pairs of fractions are brought onto a common denominator:

Stage 2 on T2: the operator acts

For 0.1 + 0.2 this stage produces 5/50 + 10/50 = 15/50.

The square root uses Newton's method on whole numbers, starting from S/2 and repeating until the guess stops shrinking:

The sine and cosine are the polynomials

computed with fractions, so they use no floating-point hardware at all. (See chapter 8 for how accurate this is.)

Stage 3 on T1: pruning (TQF collinear collapse)

Every intermediate fraction is reduced to lowest terms by dividing top and bottom by their GCD:

For our example, gcd(15, 50) = 5, so 15/50 → 3/10. The paper connects this to geometry: a common factor carries no new information, just as three points on a straight line (where the TQF area is zero, chapter 9) carry no new curvature. Both get "pruned". This is the stage where the engine slows down.

Stage 4 on T0: the latch (writing out the decimals)

The final fraction N/D is turned back into decimal digits by long division, exactly as you'd do on paper:

1. The whole-number part is N ÷ D (rounded down); the remainder is N mod D.
2. While the remainder isn't zero: multiply it by 10, the next digit is (remainder × 10) ÷ D, and the new remainder is what's left over. Each repetition is one "base-10 wrap".
3. Stop when the remainder is zero, or after 48 decimal places (then ... is added to show the digits go on).

For 3/10: 30 ÷ 10 = 3 remainder 0, so the answer is 0.3, with no binary error anywhere. For the ceiling test, every one of the 16 decimal places comes out: 9.3000000800000005.

What is exact, and what isn't

Being clear about the boundaries makes the exact parts more convincing, not less. This is how version 10 of the engine behaves.

Between the manifolds: quadrance and the TQF

The space between the rings isn't empty in this model. At every node the engine measures how the calculation point sits between its two neighbouring tiers, using rational trigonometry.

Quadrance instead of distance

Ordinary distance needs a square root, d = √(Δx² + Δy² + Δz²), and square roots are usually irrational. Rational trigonometry (developed by mathematician Norman Wildberger) uses the quadrance instead, which is just the distance squared:

If the coordinates are fractions, so is the quadrance. No square root, no rounding.

The four vertices

For each node the engine takes four points:

The outermost and innermost tiers have only one neighbour each, so they borrow the next one along: T4 is bounded by T3 and T2, T0 by T2 and T1. The Register shows this as Bounds: T3 & T2 and so on. The three points are spread round the tube by the C₃ phases (0°, 120°, 240°) and offset slightly along the ring, so they always form a genuine 3D triangle.

Three quadrances and two ratios

• Projective quadrance \( \hat{Q} = \dfrac{Q_1 + Q_2}{Q_1 + Q_2 + Q_3} \), always between 0 and 1. It measures how the node is "stretched" between its two neighbours: near 1, the node is far from both compared with how far apart they are.
• Inverse projective quadrance \( \hat{Q}^{-1} = 1/\hat{Q} \), always above 1. The paper reads it as the local compression acting on the path as the gaps between rings narrow.

The Triple Quad Formula and the area remainder

Three points lie on one straight line exactly when their quadrances satisfy the Triple Quad Formula:

The difference between the two sides is Archimedes' function, which the engine calls the area remainder A_R. It equals 16 times the triangle's area squared (it's Heron's formula written in quadrances):

• A_R = 0: the points are collinear. The middle one adds no new "bend", so in the paper's compression scheme it's redundant and can be pruned, just as Stage 3 prunes common factors.
• A_R > 0: a real triangle, with area \( A = \sqrt{A_R}/4 \).

Finding the 4th point

V4 completes the triangle into a parallelogram-like shape: start at V1, add the two edge vectors toward V2 and V3, and scale by an amount that grows with the triangle's area. In engine version 10:

With q = 1 this would be exact parallelogram completion (V4 = V2 + V3 − V1). A flat, collinear triple gives q = 0.65; a fat triangle pushes V4 further out.

A worked example: Stage 0, frame 1

With the sliders at their defaults (tension 180°, torsion 150°), the engine reports for STAGE 0 | FRAME F1/30 (T4, bounds T3 & T2):

Check the projective quadrance yourself: (4,992 + 10,784) / (4,992 + 10,784 + 1,773) = 15,776 / 17,549 = 0.8990. (If you recompute A_R from the rounded Q values you'll get a slightly different number, because the engine uses the unrounded ones.)

Seeing it in the engine

• REGISTER → 30-Frame Stage Telemetry Breakdown lists every frame of the inspected stage with its C₃ phase, C₂ sign, parity, Q₁, Q₂ and Q̂. Click a row to load it into the Selected Frame card above it (Q₁, Q₂, Q₃, Q̂, Q̂⁻¹, A_R and V4's coordinates).
• VISIBILITY → Archimedean Triangulation (TQF) draws the polygons in 3D: small spheres for V1–V3, an octahedron for V4, solid edges for the triangle, dashed-style fuchsia edges to V4, and lightly shaded faces. Choose the scope (whole system: all 150; current stage: 30; or a single node), turn persistent trails for each vertex on or off, and pick your own vertex colours. It is off when the engine opens and stays off until you tick it. Once it is on, only the phase you are inspecting is lit: the inspected stage's polygons from node 1 up to the current node. The rest of the scope is drawn as faint grey ghosts. Clicking a Register stage or a node, moving the scan or frame slider, and a running calculation all update the lit polygons.
• ALL TQF (in the Register's stage pills) switches the triangulation on with the whole-system scope in one click. Clicking a stage pill on its own changes which stage is lit but never switches the triangulation on.

Tension, torsion and the π/6 lock

The two outer tiers and the three inner tiers can be twisted against each other. When their twist differs by a multiple of 30°, the paper says the system is "locked"; otherwise it's under "shear".

The two fields

The twist is applied to everything that belongs to a tier: the torus itself, its helix tubes, its particles, the calculation path and every TQF vertex. Move a slider and you'll see the quadrances and A_R on the TQF Area Remainder card change immediately (its sub-line shows Q̂ and the current Δθ).

The lock rule

The defaults give Δθ = 30°, so the engine starts locked (green π/6 LOCKED badge). Any other difference shows an amber SHEAR (x°) badge, where x is the remainder. Because the sliders move in 5° steps, the possible shear remainders are 5°, 10°, 15°, 20° and 25°.

• Snap π/6 (30°) Lock rounds both sliders to the nearest multiple of 30°, which always produces a lock.
• Test 15° Shear Twist sets torsion to tension + 45°. 45 mod 30 = 15, the worst possible shear (exactly half a tooth). If Archimedean Triangulation is on, you can watch the polygons twist.

Both pairs of sliders (TELEMETRY and VISIBILITY tabs) control the same two values and stay in sync.

The differential clutch (CLUTCH tab)

The CLUTCH tab models two clocks running at different rates, and a clutch that engages them in five steps. Everything here feeds back into the 3D tiers.

The 12-10-8 torsional pump

The left drawing shows three nested gears:

• an outer 12-tooth gear (blue), standing for the tension tiers T4 and T3;
• a middle 10-tooth clutch gear (purple) that turns the opposite way (σ = −1) and, when the clutch slips, more slowly;
• an inner 8-tooth anchor gear (amber, red when there is drift), standing for the torsion tiers T1 and T0.

The right drawing is the 8-ray π-cycle rotor: eight spokes at 45° (π/4) intervals. The highlighted spoke is the current step k = 1…8. Spokes 2 and 6 are drawn in amber: these are the two handshake windows, where the rotor points along +i and −i (in the complex plane, (1+i)² = 2i and (1+i)⁶ = −8i).

• +1 Pulse advances everything by one tick: the pulse counter (out of 60), the outer frame (by 12 of 720, i.e. 6°), the rotor step, and the calculation path by one node.
• Inject Drift introduces a holonomy drift of ||log H|| = 0.342. It twists T1 and T0 by an extra 17° (0.342 × 50°; T2 by half that), turns the inner gear and the scalar core red, and logs an alert.

Two engines, two rates

Choose a local rate for Engine A (60, 40 or 72 Hz) and a remote rate for Engine B (45, 72, 90 or 144 Hz). The engine then computes:

• Ratio γ_AB = f_B/f_A in lowest terms (60 and 90 give 3/2).
• Boost cosh = (f_A² + f_B²) / (2 f_A f_B). For 60/90 this is 13/12 ≈ 1.083.
• Q_h^clk = (f_A² − f_B²)² / (2 f_A f_B)². For 60/90 this is 25/144 ≈ 0.1736.

The clutch ramp and slip

The Clutch Ramp slider r runs from 0 (barely engaged) to 4 (fully locked). From it the engine derives a slip coefficient λ_r, an engagement η and an effective frequency:

η = 1 means the clutch is locked and the system runs at Engine B's rate. Lower η means slip: the effective rate is a blend of the two. Slip also twists the inner tiers in 3D by (1 − η) × 28° (T2 by half), and turns the core red below η = 0.99.

The bigger the mismatch between the two rates (larger Q_h), the more the clutch slips before it locks.

Two buttons that tie it together

• 5-Stage Handshake steps the ramp through r = 0, 1, 2, 3, 4 about a third of a second apart, advancing the clock one pulse each time, clearing any drift at the final step, and logging η and f_eff at every stage. It mirrors the five-stage structure of a calculation.
• Form 3 Sync is the recovery button: it clears holonomy drift, sets the ramp to 4 (locked), and writes Form ID 3 ("Clutch Offset") into the engram tile (chapter 12). The log confirms Holonomy H=1 and Clutch η=1.000 restored.

The 64-bit engram (ENGRAM tab)

An engram is a memory trace. Here it's a 64-bit word laid out as an 8×8 grid, the "Einstein tile", made from a result or any text you type.

Making a tile

1. Type anything into Engram Grounding Seed (a number, an expression, a word), or press Hash to Engram in the TERMINAL to send the latest result there.
2. Pick a Form (see below) and press Synthesize 64-Bit Tile.
3. The 8×8 kernel lights up, the full value appears in hex (e.g. 0x…), and the four region readouts update.

Reading the grid

Bit 63 is at the top left; bits count down left to right, row by row, to bit 0 at the bottom right. Hover over a cell to see what it means in the bit inspector; click it to flip it. The colours show four regions:

Why 690,017,701?

It's 881 × 883 × 887, three primes close together (881 and 883 are twin primes). By the Chinese Remainder Theorem, any whole number below that product is pinned down exactly by its three remainders mod 881, 883 and 887. Splitting a value into small independent remainders is a classic way to do big-number arithmetic in parallel: this is "Form 2".

The Forms

Choosing Form: Auto leaves those four bits as the hash produced them; any other choice overwrites them immediately.

The packet register (TELEMETRY tab)

The same 64 bits are also shown as four 16-bit words, like the four components of a quaternion: X = bits 0–15, Y = 16–31 (together, the core), Z = 32–47 (the ctrl field) and W = 48–63 (halo and gate).

The PAPER tab: four guided demonstrations

Each card summarises one pillar of the paper and has a button that configures the 3D scene to show it. The tags are the paper's own rating of each claim.

[PROVEN] a result the paper proves; [HEURISTIC] a guiding model; [UNIFIED] a mapping that connects separate systems.

Right panel reference

TELEMETRY

• Header: an icon, a status tag and a description that change with the PAPER module you last ran.
• Four metric cards: Winding Invariant (60 wraps; relabelled by some PAPER modules), Active Node (Node k / 30), Parity State (φ_p = 0.0 or 0.5), and TQF Area Remainder (A_R of the inspected node, with Q̂ and Δθ; updates when you move the sliders).
• 64-Bit Packet Register: the engram as four 16-bit words X, Y, Z, W (chapter 12). The RESONANT label is its status.
• System Dynamics: the tension and torsion sliders, the lock badge, Snap π/6, Test 15° Shear Twist and the phase read-out (chapter 10).
• Synthesis box: a short takeaway for the current module.

REGISTER

• Pause / Step: pauses or resumes a running calculation (or, when idle, toggles free spin), the same as the play button below.
• Status line: what's happening (Traversing Tier T3..., Paused at Stage 2, or the result) and a Stage s/4 | Node k/30 read-out.
• Stage pills S0 (T4) … S4 (T0) jump to a stage and switch on its TQF web; ALL TQF shows all five stages at once.
• Five stage cards: a tick when done, a spinner for the active stage (a pause icon if paused), a dot if not reached yet. Click any card to inspect that stage.
• 30-Frame Stage Telemetry Breakdown: the Selected Frame card and the clickable list of 30 frames (chapter 9). Click the heading to fold the list away.
• Explanation card (after a result): a title, an introduction, three boxes (Node A, Node B, Collapse) and three steps. The two preset tests have their own detailed write-ups; other expressions get a general one.

HUB

• Base-10 Trajectory Scan: a 1–100% slider for the whole journey. 1% is the start on T4, and each 20% is one stage (25%, 50% and 75% marks are labelled T3, T2, T1). It's linked to the bottom scrubber.
• 2D map: the five tiers as circles seen from above and the path as a spiral shrinking from radius 155 to 15. It turns 0.25 radians per pulse (about six turns in all), with a small square where each stage begins (fuchsia for the stage you're inspecting) and a dot for the current position.
• Three summary cards: T4 (ingestion), T2 (superposition and TQF) and T0 (crystallisation).

VISIBILITY

• Archimedean Triangulation (TQF) on/off (off by default), plus: TQF System Scope (whole system, current stage, single node), Trail Span (full T4→T0, or the current stage loop), Persistent Vertex Trails, 3D Shaded Polygon Faces, a colour picker and trail toggle for each of V1–V4, and a second copy of the tension and torsion sliders.
• Scene toggles: checkpoint diamonds (with a size/glow slider), square particle fields, dual-helix braid tubes and orthogonal radial lines.
• Per-tier controls for T4…T0: show or hide, colour, opacity (0.02–0.95) and glow (0–1.5).

Bottom control bar

The wider architecture: Loom & Weave and the Zero-Point engine

The calculator is one piece of a larger design. Two companion programs describe what happens before data reaches the five tiers, and what happens at the very centre. This chapter summarises how they fit together. They are separate simulations, not controls in this engine.

Three scales, one pipeline

The Loom & Weave in five subsystems

1. The 64-bit seed with 1/16 symmetry. An 8×8 bit lattice whose rows have hardware roles (structural form, parity, frequency, a 32-bit quaternion core, spin class, amplitude). Four seed bits in one corner are mirrored across both axes to set all 64, so 4/64 = 1/16 of the tile determines the rest.
2. The outer Hilbert envelope. Three perpendicular planes, each with three concentric 12-point star polygons. Eight times per 720-frame cycle (every 90 frames) the envelope shrinks by a factor of φ⁻⁴ (φ = the golden ratio), pumping energy inward.
3. Six directional faces, two lenses each. Along ±X, ±Y and ±Z, an outer 3×3 "trefoil triad" (three layers riding a trefoil-knot path) feeds a middle 4×4 pandiagonal magic square that acts as a focusing lens.
4. 54 Fibonacci streams. 6 faces × 9 columns of streams run from the triads through the lenses to the core, wrapped in spiral waves whose amplitude shrinks by powers of φ as they approach the centre. Where a stream passes close to one of 64 orbiting core voxels, a spark marks a collision and it's logged.
5. The Markov pump funnel and the toroidal weave. At the centre, a nested gear train implements the 12-6-7-3-1 compression protocol: a 12-point ring feeds 6-pointed hexagrams, then 7-pointed heptagrams, then a central scalar ring, with 12 Clifford–Strassen tensor stations around it. The whole core travels round a torus of radius 25 while twisting, and the paths of its 24 outer points braid the "toroidal manifold weave".

Breathing: the 720-frame cycle

Most sizes in the Loom follow sin(πt) as t runs from 0 to 1 over 720 frames. From frame 0 to 360 the field expands (inhale, decompression); from 360 to 720 it collapses back into the centre (exhale, compression). At frame 720, sin π = 0 and everything has converged on the central point. That moment is where the Zero-Point process belongs.

Joining them: the integration roadmap

• A two-epoch state machine. Rather than jumping from frame 720 straight back to 0, the combined system alternates between Loom & Weave (frames 0–720, collecting collisions into a 64-bit change mask) and Zero-Point (8 steps × 90 sub-frames = 720 micro-frames at the centre, with the Loom frozen at 20% opacity and the camera moving into the core). The Zero-Point result becomes the next seed, the weave is recomputed, and a counter-propagating "phase-conjugate" wave travels back out as the next cycle begins.
• Matching the scales. The Zero-Point tiers (radii 1.2, 2.8, 5.2, 8.4, 12.4) fit inside the Loom's core rings (2.5, 5, 10, 16) when scaled by about 1.25–1.29: the outer tier lands on the 12 Clifford–Strassen stations at radius 16.
• 72 kissing nodes. The Zero-Point's third manifold has 12 wraps × 6 channels = 72 nodes; the Loom's 12 stations each carry 3 rings = 6 half-arcs, also 72. The two counts line up one to one.
• Two ways to run time. Mode A, sequential: run the Loom, pause at frame 720, run the 8 Zero-Point steps, resume; best for watching each system clearly. Mode B, parallel: each of the Loom's eight 90-frame beats runs one Zero-Point step inside the moving core; best for seeing the scales couple in real time.

How this calculator connects

• The 720-frame holonomic cycle is the same count the calculator's SYNC: HOLONOMIC mode uses.
• The 12-6-7-3-1 engine is the coupling behind PAPER module 3 and the π/6 lock.
• Both use a 64-bit, 8×8 tile, though each assigns the bits differently.
• The 12-10-8 gears and the 8-step π-cycle rotor in the CLUTCH tab echo the eight beats of the Loom and the eight Zero-Point steps.

Related simulations on this site: Geometric Weave and Loom Processing, Holographic 64-Voxel Memory Weave, Geometric Engine of Time and SHD-CCP Jacquard Tensor Weave Architecture.

Glossary

A_R (area remainder)

Archimedes' function of three quadrances, (Q₁+Q₂+Q₃)² − 2(Q₁²+Q₂²+Q₃²) = 16×area². Zero means collinear.

BigInt

JavaScript's whole-number type with no size limit. The engine's exactness rests on it.

C₃ × C₂

The 6-step symmetry pattern of the nodes: three phases (0°, 120°, 240°) times two directions (+1, −1).

Canonical trajectory

The idealised path drawn when you scrub or inspect: one smoothed point per node.

Checkpoint diamond

A glowing octahedron dropped at the start of each stage.

Chirality

Handedness. Here, whether a braid winds forward (+1) or in reverse (−1).

Clutch / η

The coupling between two clock rates. η = 1 is fully locked; less than 1 means slip.

Collinear

Lying on one straight line.

CRT

Chinese Remainder Theorem: a number is fixed by its remainders modulo pairwise coprime numbers (here 881, 883, 887).

Engram / Einstein tile

The 64-bit word shown as an 8×8 grid, made by hashing a result or text.

f_eff

The effective frequency while the clutch slips: (1 − η)f_A + ηf_B.

Form ID

Bits 43–40 of the tile, naming which encoding "grammar" the word follows.

GCD

Greatest common divisor. Dividing top and bottom of a fraction by it gives lowest terms.

Holonomy / holonomic

What changes when you carry something round a closed loop. Here: the 720-frame view of the journey, and the "drift" the clutch can correct.

IEEE-754

The standard binary floating-point format used by almost all computers.

Latch

The release of the answer at the end of Stage 4.

Manifold / tier

One of the five tori, T0 (core) to T4 (outer).

Mantissa

The significant-digits part of a floating-point number; 53 bits in a double.

Mod-30 wheel

The eight remainders 1, 7, 11, 13, 17, 19, 23, 29 that every prime above 5 falls into when divided by 30.

Node / frame

One of the 30 positions around a tier, 12° apart (F1–F30).

Orthogonal

At right angles. Neighbouring tiers are orthogonal.

Parity residual φ_p

The half caesium cycle left after an odd number of pulses (0.5), cancelled after an even number (0.0).

Projective quadrance Q̂

(Q₁+Q₂)/(Q₁+Q₂+Q₃): where a node sits between its neighbouring tiers, from 0 to 1.

Pulse

One clock tick; one node of movement. 150 per calculation.

Quadrance Q

Squared distance. Stays rational when coordinates are rational.

Rapidity

ln of a rate ratio; the "boost" between two clocks is its cosh.

Shear

A tension/torsion difference that isn't a multiple of 30°.

Shunting-yard

Dijkstra's algorithm for putting operators in the right order of precedence.

Soliton

In physics, a wave that keeps its shape. Here, the calculation orb and the stable result it settles into.

Spinor

An object that needs a 720° turn, not 360°, to return to its starting state.

Tension / torsion

The twist applied to the outer tiers (T4, T3) and the inner tiers (T2, T1, T0).

Torus

A doughnut shape with a major radius R and a minor (tube) radius r.

TQF

Triple Quad Formula: (Q₁+Q₂+Q₃)² = 2(Q₁²+Q₂²+Q₃²) exactly when three points are collinear.

W, W_Σ

Winding number: tube wraps per trip round the ring (8 to 16). Their sum, W_Σ, is 60.

V1–V4

The four TQF vertices: node, upper, lower, inferred.

Troubleshooting & FAQ