rational trigonometry 2/3

…continued from Part 1 here. 

Try the App here!

This follow-up post, nearly a year after Part 1, is to summarize the reasons for, and the logic behind a new geometric explorer app using JavaScript and THREE.js as a renderer/UI, which is now almost complete, and which uses all of the methods of Rational Trigonometry, together with interactive math demos with realtime performance tracking wherever practical. The app is a proof of concept for the subsequent foundation of new Synergetics-based approach BIM/BEM and geometric modelling engines. At the heart of this is Buckminster Fuller’s lifelong quest to discover and understand the coordinate system that Universe actually uses, which is related to his friend Einstein’s quote below.

To recap from part 1, this series of posts is to:

1. To serve as the foundation for programmers and software developers in an open-source collaboration of ideas around Rational Trigonometry (RT) and Synergetics, with a working draft application now complete at: ARTexplorer.
2. As a background article for the linking of three key ideas, a) Synergetic Geometry , b) Timelessness (Barbour), Platonism, Neo-Platonism, Rationalism/Hyper-Rationalism, and c) Rational Trigonometry in the context of physics, philosophy, structural design and ecologically optimized architecture, together with computational efficiency, accuracy and simplicity.
3. As an explainer of the practical experiments in RT using javascript as a polyhedral modelling tool and 3D rendering solution.

Gravity is a response to Geometry~ Albert Einstein

Now if you’re like me, one of the first places your mind goes after reading that Einstein quote is to stall out in a kind-of chicken-egg causation loop. We, being ordinary mortal humans, tend to always think in terms of Time and therefore causation and consequences. What comes first, the ‘Force’ of Gravity, or the ‘Shape’ of space? The way Bucky pictured it, and others agree, is that space has an inherent shape, or in other words, it has certain spatial rules that inform how all energy and matter behaves. Space, Fuller posits, has Structure. Which comes first, Gravity or Geometry, may be as irrelevant as Martha Heyneman’s question “What is North of the North Pole?” We also need to think differently about time, but we’ll get to that in Part 4. Another thought to park in your mind for later: there are no straight lines in Universe, only curved ones (Geodesics) – even though for now we are looking at a system of ‘straight lines’ forming polyhedra.

This geometry for a full series of polyhedra has been created almost exclusively with Rational Trigonometric and Vector Algebraic methods, which means the irrationals and approximations present in Cos/Sin/Tan/Pi, etc. are largely absent. One of the two foundations of the system are the Cube and the Tetrahedron, which are generated thus:

 * Polyhedra generator functions
 * All functions return {vertices, edges, faces}
 * @namespace Polyhedra
 */
export const Polyhedra = {
  /**
   * Hexahedron (Cube) - vertices at (±1, ±1, ±1)
   * Edge quadrance Q = 4 (edge length = 2)
   * Z-up convention: Z is vertical axis
   */
  cube: (halfSize = 1) => {
    const s = halfSize;
    const vertices = [
      // Bottom face (Z = -s)
      new THREE.Vector3(-s, -s, -s), // 0: left-back-bottom
      new THREE.Vector3(s, -s, -s), // 1: right-back-bottom
      new THREE.Vector3(s, s, -s), // 2: right-front-bottom
      new THREE.Vector3(-s, s, -s), // 3: left-front-bottom
      // Top face (Z = +s)
      new THREE.Vector3(-s, -s, s), // 4: left-back-top
      new THREE.Vector3(s, -s, s), // 5: right-back-top
      new THREE.Vector3(s, s, s), // 6: right-front-top
      new THREE.Vector3(-s, s, s), // 7: left-front-top
    ];

    // 12 edges (3 groups of 4 parallel edges)
    const edges = [
      // Bottom face (Z = -s)
      [0, 1],
      [1, 2],
      [2, 3],
      [3, 0],
      // Top face (Z = +s)
      [4, 5],
      [5, 6],
      [6, 7],
      [7, 4],
      // Vertical edges (parallel to Z-axis)
      [0, 4],
      [1, 5],
      [2, 6],
      [3, 7],
    ];

    // 6 square faces
    const faces = [
      [0, 1, 2, 3], // Bottom (Z = -s)
      [4, 5, 6, 7], // Top (Z = +s)
      [0, 1, 5, 4], // Back (Y = -s)
      [2, 3, 7, 6], // Front (Y = +s)
      [0, 3, 7, 4], // Left (X = -s)
      [1, 2, 6, 5], // Right (X = +s)
    ];

    // RT VALIDATION: Check edge quadrance uniformity
    const expectedQ = 4 * halfSize * halfSize; // Q = (2s)² = 4s²
    const validation = RT.validateEdges(vertices, edges, expectedQ);
    const maxError = validation.reduce((max, v) => Math.max(max, v.error), 0);
    console.log(
      `Cube: Expected Q=${expectedQ.toFixed(6)}, Max error=${maxError.toExponential(2)}`
    );

    return { vertices, edges, faces };
  }

Why halfSize? It’s an easy way to generate a cube at the absolute centre of the coordinate systems. halfSize (1) is thus the fundamental unit of the entire system. Here’s the code for the complementary Tetrahedron, note: we only call a single √2, but do not expand it until we render into the THREE.js user-interface, but under the hood the math remains rational. All operations occur algebraically, symbolically, for as long as necessary before expansion to control precision and limit rounding and subsequent errors. As you can see, so far no angles, no cos/sin/tan or Math.Pi calls. 

/**
   * Tetrahedron inscribed in cube
   * Uses alternating vertices (every other corner)
   * Edge quadrance Q = 8 (edge length = 2√2)
   */
  tetrahedron: (halfSize = 1) => {
    const s = halfSize;
    // Select 4 vertices of cube such that no two share an edge
    // These form a regular tetrahedron
    const vertices = [
      new THREE.Vector3(-s, -s, -s), // 0: (-, -, -)
      new THREE.Vector3(s, s, -s), // 2: (+, +, -)
      new THREE.Vector3(s, -s, s), // 5: (+, -, +)
      new THREE.Vector3(-s, s, s), // 7: (-, +, +)
    ];
    // 6 edges (all pairs - complete graph K4)
    const edges = [
      [0, 1],
      [0, 2],
      [0, 3],
      [1, 2],
      [1, 3],
      [2, 3],
    ];
    // 4 triangular faces
    const faces = [
      [0, 1, 2],
      [0, 1, 3],
      [0, 2, 3],
      [1, 2, 3],
    ];
    // RT VALIDATION: Check edge quadrance uniformity
    const expectedQ = 8 * halfSize * halfSize; // Q = (2√2·s)² = 8s²
    const validation = RT.validateEdges(vertices, edges, expectedQ);
    const maxError = validation.reduce((max, v) => Math.max(max, v.error), 0);
    console.log(
      `Tetrahedron: Expected Q=${expectedQ.toFixed(6)}, Max error=${maxError.toExponential(2)}`
    );
    return { vertices, edges, faces };
  }

Fundamental to the ART Explorer app — Algebraic Rational Trigonometry (and my initials) — is a Platonic view of geometry, in which forms are treated as intelligible structures that exist independently of their material instances. For this reason, forms in the software always emerge at the origin: (0,0,0) in Cartesian coordinates, or (0,0,0,0) in Quadray coordinates. The origin is not a location in space so much as a conceptual reference point, from which form is generated before being instantiated.

The app supports two complementary coordinate systems: Cartesian (XYZ) and Quadray (WXYZ). Each has its own construction grid, which can be displayed independently or together. The grids themselves are dimensionless with respect to scale; rationality enters only through the choice of edge length used to generate a form. A user may choose to make the cube edge length rational, or the tetrahedron edge length rational, and this choice propagates through all related forms — whether a single polyhedron or a matrix-generated family.

Preferring the tetrahedron as the rational basis has certain advantages, since a larger family of related polyhedra then remain rational. This relationship is made explicit through the dual sliders: when the cube edge is held rational, the tetrahedron becomes irrational; when the tetrahedral edge is held rational, the cube becomes irrational. The Quadray grid (shown by default) reflects tetrahedral rationality, while the Cartesian grid reflects cubic rationality. Importantly, the grids themselves do not change — only the polyhedra (what the app calls Forms) vary within them, in deliberate deference to Plato’s distinction between intelligible form and sensible instance. With tetrahedral rationality, you will notice the forms lock or snap at each of the ISM grid intervals as whole numbers ie. 2.000.

At any point, the user may create an instance — a snapshot in time — of the currently selected form (following Julian Barbour’s notion of “now”). By pressing the Now button, the form is instantiated either in place or transformed elsewhere, while a fresh original remains at the origin. Instances can be left active or switched off and subsequently edited using the Controls panel, reinforcing the distinction between the generative form and its temporal manifestations.

Easier than verbally explaining everything is to simply try the system out, as the design was made intentionally to be as intuitive as possible, since this is fundamental to Bucky Fuller’s approach to understanding the Universe. The math is actually easier than classical trig. But the UI of the app makes exploring the family of polyhedra obvious to even those that suffer from math allergies like I do, a symptom of a terrible elementary school math curriculum that demanded we know only How but never Why. 

You made it this far? Congratulations! Now let me give you some of the reasons WHY this matters. We’re dipping our toes into topological models using Wildberger’s Rational Trigonometry as a computationally cleaner alternative to angle-based trig. By replacing angles with quadrance and spread, this avoids transcendental functions entirely—no π, no sin, cos, or tan lurking under the hood.

Computers can carry massive decimals, sure—but repeated floating-point trig introduces cumulative error. In large geometric systems, that drift shows up as misaligned nodes, warped meshes, and constraint kludges instead of precision. Rational, algebraic formulations aren’t just elegant—they’re structurally stable. Fewer transcendental evaluations, fewer rounding traps, clearer topology. But there is so much more to this. Here are the key considerations in 14 sections. 

1. Rational Trigonometry as a computational framing

Wildberger’s rational trig replaces:

• angles → quadrances
• sines/cosines → spreads

and this:

• avoids transcendental functions
• works entirely with algebraic operations
• aligns naturally with coordinate geometry and topology

For polyhedral geometry, domes, meshes, and graph-like structures, this framing is very attractive.

2. Floating-point error accumulation is real

This is not hypothetical.

• Repeated trig evaluations accumulate floating-point error
• Meshes, nodes, and constraints can drift
• Large systems (esp. iterative solvers) can degrade into “kludge geometry”

This is especially true in:

• physics engines
• CAD/BIM kernels
• procedural geometry
• constraint solvers for domes and shells

3. Whole-number / algebraic formulations are structurally more stable

Even if computers can store huge decimals, that doesn’t mean:

• they compose well
• they compare well
• they survive many transformations

Rational / integer-preserving formulations:

• reduce rounding noise
• make equality meaningful again
• are easier to validate topologically

This is a real advantage—not just philosophical. I’ve dealt with laser-cut machined stainless steel panel joints that were off by enough millimetres to break seals. The root causes were not a failure to observe bend radiuses, but were fundamental to this software kludge I’m referring to. ArchiCad is not Catia – but it could be. 

4. Rational trig does not guarantee whole numbers:

• quadrances are rational, but not necessarily integers
• spreads are rational but can also involve division
• many real-world geometries still require irrationals somewhere, eventually

Wildberger’s claim is: “…You can avoid transcendental functions, but not all irrationality.“

5. What’s the bigger picture here then? 

If, globally, we could replace;

• transcendental functions (sin, cos, tan, exp…)
• long floating-point mantissas
• repeated re-normalization and rounding

with:

• integer or rational arithmetic
• fewer operations
• fewer corrective passes

then, at planetary scale, the impact would be massive. Not because: “sin() burns the planet” —but because small inefficiencies multiplied by trillions of executions become infrastructure-scale costs.

6. It’s not the decimals — it’s the error correction

Modern computation pays an enormous hidden tax on:

• denormals
• rounding modes
• tolerances
• epsilon comparisons
• constraint stabilization
• iterative convergence “nudges”

Floating-point trig doesn’t just cost cycles — it creates uncertainty, and uncertainty forces:

• more iterations
• more passes
• more memory churn
• more branching

That’s where energy goes.

Integer/rational formulations:

• converge faster
• fail more predictably
• need fewer “fix-up” stages

That absolutely scales.

7. Memory bandwidth dwarfs ALU cost

This is the killer argument here.

• Moving bits costs far more energy than flipping them.
• A 64-bit float carried through a pipeline millions of times matters.
• Extra buffers, caches, and retries amplify this.

If geometry, physics, and simulation pipelines could:

• operate on smaller, exact representations
• avoid repeated storage of approximate states

the savings aren’t marginal — they’re architectural.

8. Global compute is dominated by geometry and simulation

Consider how much compute involves:

• rendering
• CAD/BIM
• digital twins
• physics engines
• GIS
• robotics
• climate and structural models
• games (yes, games! never underestimate the impact of this industry!)

All of these:

• are geometry-heavy
• rely deeply on trig
• suffer from floating-point instability

Even a single-digit percentage reduction in retries, corrections, or over-precision would be enormous at hyperscale. Approximation forces defensive computation, and defensive computation is where the energy goes, not to flipping bits. Exactness reduces algorithmic waste. The cost isn’t the decimals themselves — it’s the cascade of approximation management they force. At global scale, exact algebraic formulations don’t just improve clarity; they reduce corrective computation, memory churn, and iterative stabilization. That’s where the real energy and emissions footprint lives. Reducing this computational impact would plausibly be measured in exabytes to zettabytes of avoided data motion per year, and terawatt-hours of energy. Not because integers are magic — but because exactness collapses entire layers of defensive computation. 

9. First: what “global compute” actually spends energy on

Roughly speaking (very roughly, but directionally correct):

• ~60–70% of energy in large compute systems → data movement
• ~20–30% → control, retries, synchronization, error handling
• <10% → actual arithmetic (ALU/FPU ops)

So the fantasy isn’t: “Integers are cheaper than floats”, it’s Exact models need fewer passes, fewer buffers, fewer retries, and fewer stored intermediate states. That’s where the leverage is.

10. A conservative global scale snapshot

Let’s anchor to something real:

• Global data center electricity use ≈ 400–500 TWh/year
• A huge fraction of that supports:
  • geometry
  • simulation
  • graphics
  • physics
  • ML preprocessing
  • optimization loops

Let’s call it 30–40% tied to numerically unstable or approximation-heavy workloads. That’s already ~150–200 TWh/year in play.

11. What exact / rational-first computation plausibly reduces

Not “everything.” Let’s be conservative. Even if rational / algebraic formulations reduced:

• iterative correction passes by 10–20%
• intermediate state storage by 10%
• synchronization retries by 5–10%

Those numbers are not wild. They’re modest. That yields a net system-wide savings on the order of: 5–10% of geometry/simulation compute, Apply that to 150–200 TWh: ~7.5–20 TWh/year saved

That’s:

• the annual electricity use of a small country
• millions of tons of CO₂
• without changing hardware — just math culture

And that’s the boring, conservative case. We’re not even considering here that this approach is more mathematically comprehensible, easier to teach, and easier to code. 

12. Now let’s talk in ridiculous data units 😄

Where the “bytes saved” actually live

Exactness reduces:

• stored intermediate meshes
• cached approximations
• rollback buffers
• epsilon-expanded representations
• duplicated near-equal states

At hyperscale, geometry-heavy systems routinely move zettabytes/year internally (not over the internet — inside data centers). If exact computation eliminated even:

• 0.1% of internal data motion

That’s on the order of: 1–10 exabytes/year of avoided data movement. At ~10–100 picojoules per bit moved, that alone explains the TWh-scale savings. Exabytes is not poetic exaggeration. It’s the right unit.

13. The ancient-Greece fork in the road (this matters)

If the Pythagoreans had:

• normalized disclosure instead of secrecy
• framed number as structure instead of mysticism
• avoided the metaphysical panic over irrationals

Then Descartes’ coordinate geometry might have evolved into:

• algebra-first geometry
• topology-first physics
• exactness as default

Instead, we got:

• angles everywhere
• transcendental crutches
• approximation as cultural norm

Modern compute inherited that conceptual debt. We’re really pointing at a 2,000-year-old abstraction choice whose interest we are still paying — in silicon, heat, and power.

14. Thesis (historically + technically)

A civilization that had stuck with and further developed exact algebraic geometry (as they did in Babylon ca. 3,700 yrs ago per Plimpton 322) from the outset would have built computational systems that waste less effort managing approximation. At modern scale, even small reductions in corrective computation translate into exabytes of avoided data motion and tens of terawatt-hours of energy per year.

That’s not sci-fi. That’s path dependence. We’re not imagining a world where: “Integers magically save the planet”. We’re imagining a world where: Exactness reduces entropy at scale, and entropy is expensive. This is a deeply rational thing to wonder — I think Pythagoras would have approved, even if he’d have sworn us to secrecy afterward. Part 3 coming soon!

https://www.researchgate.net/publication/400054293_Extending_the_Janus_Point_from_Temporal_to_Spatial_Geometry_via_Tetrahedral_Quadray_Coordinates