π (GRG)

π (GRG)

Aug 25, 2025

Historical Comparison Page

This page preserves earlier experiments involving a circular constant. It is not the current GRG construction specification and does not establish a computational advantage. Read the current geometric formulation. The calculators and efficiency claims on this historical page require separate validation.

What this page is about

Here we determine π by looking at the circle from the inside. We rotate a central ray with equal step and sum only internal chords. If you “really want π”, this is the simplest way I know: increase only N. Everything else follows from the circle you already hold in your hands.

Angles are measured in turns \(u\in[0,1)\) with period-1 trigonometry: \( c(u):=\cos(2\pi u),\; s(u):=\sin(2\pi u) \). (For degree readers: \( \Delta u = \text{degrees}/360 \).)

Circle — three GRG options: overview · Δx trapezoids · Original corridor · Radial sectors.

The definition is exact and π is not assumed in advance. In turns (period-1 sine s(u)=\sin(2\pi u)) it is fixed by the limit

$$ \pi \;=\; \lim_{N\to\infty}\; 4N\, s\!\Big(\tfrac{1}{8N}\Big) \;=\; \lim_{N\to\infty}\; 2N\, s\!\Big(\tfrac{1}{4N}\Big). $$

For practical work we use the finite version

$$ \pi_N \;=\; 4N\, s\!\Big(\tfrac{1}{8N}\Big), $$

which increases from below and converges to π as N grows. A useful accuracy hint is

$$ \pi - \pi_N \;\approx\; \frac{\pi^3}{96\,N^2}. $$

Consequences you can feel while using the page:

  • Only one knob: raise N for more precision; the formatting “decimals to display” is just how many digits you show.
  • Powers of two shine: when N = 2^k we can compute by pure halving (only square-roots), no trigonometry, no π inside.
  • Predictable growth: multiplying N by 10 adds about 2 correct digits; doubling N adds roughly 0.6 digits.

Angles are measured in turns \(u\in[0,1)\) with period-1 trigonometry: \( c(u):=\cos(2\pi u),\; s(u):=\sin(2\pi u) \). (For degree readers: \( \Delta u = \text{degrees}/360 \).)

Circle — three GRG options: overview · Δx trapezoids · Original corridor · Radial sectors.

Interactive: increase only N

Choose N and how many decimals to display. For powers of two, the calculator uses pure halving (no trig). For general N it uses a high-precision series. Output shows the value, Δ to \( \pi_{2N} \), an error estimate, and detects when numerical verification becomes the limit (“inversion”).

Mode: —

—

—

How this π calculator works

Formula (TURNS): \( \pi_N = 4N\, s(\tfrac{1}{8N}) \) with \(s(u)=\sin(2\pi u)\). Increase only N; the value grows from below and converges to π.

Two modes

Halving (no trig): if N is a power of two, the chord angle is halved repeatedly starting from the quarter-turn \(u=\tfrac{1}{4}\). This uses only square-roots; no trig, no π inside.

Series (turns → radians): for general N, it evaluates \(s(u)\) at \(u=\tfrac{1}{8N}\) via a high-precision series (internally converts to radians).

Precision & inversion

The line shows Δ(N→2N), an internal error estimate \( \approx \tfrac{4}{3}\Delta_N \), and a Richardson “verified digits” check. When internal ratios drift far from the expected \(1/4\) or verified digits stop growing at high precision, the panel turns amber: GRG may be more precise than the numerical checker (inversion).

Concrete examples (GRG)

Here is how the value improves as you raise N (rounded):

  • N = 16 → πN ≈ 3.140331156954753 (error ≈ 1.261×10⁻³)
  • N = 128 → πN ≈ 3.141572940367091 (error ≈ 1.971×10⁻⁵)
  • N = 1024 → πN ≈ 3.141592345570118 (error ≈ 3.080×10⁻⁷)

These numbers come straight from the turn-native formula

$$ \pi_N \;=\; 4N\, s\!\Big(\tfrac{1}{8N}\Big) \quad\text{and}\quad \pi - \pi_N \;\approx\; \frac{\pi^3}{96\,N^2}. $$

When verification becomes the limit (“inversion”)

As you increase N, GRG’s error drops predictably—until a point where the numerical tools used to check your result (floating-point, auxiliary series, etc.) become the real bottleneck. From there on, GRG may be more precise than your verifier: that is the “inversion”.

Angles are measured in turns \(u\in[0,1)\) with period-1 trigonometry:

$$ s(u) := \sin(2\pi u), \qquad c(u) := \cos(2\pi u). $$

What really happens — three regimes

  • Model error dominates. The inside chord-sum approximation $$ \pi_N \;=\; 4N\,s\!\Big(\tfrac{1}{8N}\Big) $$ satisfies the classical asymptotic (from expanding \(s(u)\) at \(u=0\)): $$ \pi - \pi_N \;\approx\; \frac{\pi^{3}}{96\,N^{2}}. $$ Doubling N quarters the error.
  • Transition zone. The theoretical error keeps falling, but rounding and finite working precision begin to matter. If “shown decimals” or internal precision do not increase accordingly, visible gains slow down.
  • Inversion. Numerical/verification error exceeds the GRG error. Philosophically: the method is now better than your ruler.

Self-checking from the inside (no external \( \pi \))

  1. \(\Delta\)–ratio test (asymptotics). Define $$ \Delta_N := \pi_{2N}-\pi_N, \qquad R_N := \frac{\pi_{4N}-\pi_{2N}}{\pi_{2N}-\pi_N}. $$ For clean numerics, \( R_N \to \tfrac{1}{4} \). If you see ≈ 0.25, you are still in the \(1/N^{2}\) regime (all good). If it wanders far from 0.25, numerics have taken over ⇒ inversion.
  2. Internal error estimate (no \( \pi \)). From the series behavior, $$ \pi - \pi_N \;\approx\; \frac{4}{3}\,\Delta_N. $$ The constant \( \tfrac{4}{3} \) comes from analysis; the factors \( \pi^{3} \) cancel out. You can therefore display: “Estimated error ≈ \( \tfrac{4}{3}\,\Delta_N \)”.
  3. Internal acceleration (Richardson). Cancel the \(1/N^{2}\) term by combining two steps: $$ \pi_{\text{ex}} \;=\; \pi_{2N} \;+\; \frac{\pi_{2N}-\pi_N}{3}, \qquad \pi - \pi_{\text{ex}} \;=\; O(N^{-4}). $$ Then compare with \( \pi_{4N} \): $$ E_N := \big|\pi_{\text{ex}} - \pi_{4N}\big|, \qquad \text{verified digits} \;\approx\; \big\lfloor -\log_{10} E_N \big\rfloor. $$ If verified digits stop growing when you double N, the numerical checker is limiting you (inversion).

Takeaway

  • Intellectual simplicity (GRG): one knob N, monotone inside-approximation, predictable error.
  • Honest inversion: beyond a threshold, tools used to verify are the limit — not GRG.
  • Self-certification: via \( \Delta_N \), \( \pi_{\text{ex}} \), and \( E_N \), no external \( \pi \) needed.

In the calculator above, when the internal checks suggest inversion, the panel turns amber and an explanatory note appears. Prefer powers of two for N, or increase working precision, if you need to push further.

Context note (as of 10 Sep 2025)

GRG’s turn-based, chord-sum definition of \( \pi \) is presented here as a new approach that increases accuracy by raising a single internal parameter N. This page documents the method and its error behavior; it is not intended to compete with record-breaking \( \pi \) algorithms.

For extremely large digit counts, established methods (AGM/Salamin–Brent, Borwein, Ramanujan/Chudnovsky) remain the fastest due to decades of optimization. GRG is primarily valued for conceptual clarity, monotone bounds, and controlled \( N\!\to\!\infty \) convergence.

Concrete examples (GRG)

Here is how the value improves as you raise N (rounded):

  • N = 16 → πN ≈ 3.140331156954753 (error ≈ 1.261×10⁻³)
  • N = 128 → πN ≈ 3.141572940367091 (error ≈ 1.971×10⁻⁵)
  • N = 1024 → πN ≈ 3.141592345570118 (error ≈ 3.080×10⁻⁷)

These numbers come straight from the turn-based chord-sum formula (angles in turns \(u\in[0,1)\) with \(s(u):=\sin(2\pi u)\)):

$$ \pi_N \;=\; 4N\,s\!\Big(\tfrac{1}{8N}\Big), \qquad \pi - \pi_N \;\approx\; \frac{\pi^3}{96\,N^2}. $$

Tip: use powers of two for N (16, 32, 64, …) for cleaner Δ-tests and steadier convergence; if verified digits stop increasing when doubling N, raise working precision.

How other methods reach π (in plain words)

Long alternating sums (Gregory–Leibniz)

This is the famous series \( \pi/4 = 1 - 1/3 + 1/5 - 1/7 + \dots \). After \(n\) terms, the error in \( \pi \) is about \( \frac{4}{2n+1} \approx \frac{2}{n} \). It’s beautiful but very slow: ~10,000 terms give ≈4 correct decimals; ~1,000,000 terms ≈6 decimals. A mountain of fractions.

Nilakantha’s refinement

Nilakantha’s series \( \pi = 3 + \frac{4}{2\cdot3\cdot4} - \frac{4}{4\cdot5\cdot6} + \frac{4}{6\cdot7\cdot8} - \dots \) converges much faster: the error shrinks like \(1/n^2\). Ten terms already land close; one hundred or one thousand terms push several more digits — still, you juggle many fractions.

Machin-like formulas (arctangents)

Here \( \pi \) is a combination of arctangents, e.g. \( \pi = 16\arctan(1/5) - 4\arctan(1/239) \). The arctan series converges fast because powers \(1/5^{\,2k+1}\) and \(1/239^{\,2k+1}\) drop quickly. With just a handful of terms you already see many correct digits.

Ramanujan, Chudnovsky & co.

“Rocket” series: each term yields many digits (≈8 per term for several Ramanujan formulas, ≈14 per term for Chudnovsky). They power modern record computations — superb for huge digit counts, but conceptually heavier than turning a single \(N\).

AGM (Salamin–Brent) and Borwein algorithms

Iterative methods with quadratic (or higher) convergence: each step roughly multiplies the correct digits. A dozen iterations already exceeds everyday needs — fantastic speed, less “from-the-inside” geometry.

Monte Carlo & Buffon’s needle

Random points/needles relate probabilities to \( \pi \). Charming and educational, but accuracy grows like \(1/\sqrt{T}\) (here \(T\) = trials): even millions of trials yield only a few decimals.

Why GRG feels intellectually simple

GRG is not about naming \( \pi \); it is about holding the circle. You dial only one parameter, \(N\), and everything else follows. The value increases from below (no overshoot), and its error is easy to estimate. If you truly need \( \pi \), this is the most direct, inside-out way I know — increasing a single internal factor means the computation belongs to the circle, not to an external \( \pi \).

Honest side-by-side (objective)

  • What you increase — GRG: just N. Archimedean polygons: sides m (inside/outside). Gregory–Leibniz / Nilakantha: number of terms. Machin / Ramanujan / Chudnovsky: number of series terms. AGM / Borwein: iteration count.
  • Speed of accuracy — GRG: error ≈ \(C/N^2\) (predictable, monotone). Gregory–Leibniz: \(O(1/n)\) (very slow). Nilakantha: \(O(1/n^2)\). Machin: fast; Ramanujan / Chudnovsky: very fast (many digits per term). AGM / Borwein: digits multiply each step.
  • When to use — GRG: concept, clarity, control “from the inside”, and up to many digits without extra machinery. For records or industrial-scale digits, AGM / Borwein / Chudnovsky win on raw speed.

Editor’s note (external view)

This note reflects an external opinion I chose to publish for fairness. The GRG approach is conceptually elegant: it defines \( \pi \) from inside the circle and lets accuracy grow by increasing only N. That simplicity is a real strength for understanding and for controlled, monotone inside-approximations.

As of August 25, 2025, GRG and this GRG-based \( \pi \) formula are newly introduced here. Researchers and practitioners still rely on established algorithms (AGM/Salamin–Brent, Borwein, Ramanujan/Chudnovsky) partly because these tools have been analyzed and optimized for decades and deliver record-speed convergence for very large digit counts.

The two views are compatible: GRG offers a clear, internal definition and a practical “increase only N” pathway with transparent self-checks; record algorithms remain the fastest instruments when one needs extreme digits or industrial-scale computations.

When verification becomes the limit (“inversion”)

As you increase N, GRG’s error drops predictably—until a point where the numerical tools used to check your result (floating point, auxiliary series, etc.) become the real bottleneck. From there on, GRG may be more precise than your verifier: that is the “inversion”.

Angles are measured in turns \(u\in[0,1)\) with period-1 trigonometry \( s(u):=\sin(2\pi u) \), \( c(u):=\cos(2\pi u) \).

What really happens — three regimes

  • Model error dominates. The GRG approximation $$ \pi_N \;=\; 4N\,s\!\Big(\tfrac{1}{8N}\Big) $$ satisfies $$ \pi - \pi_N \;\approx\; \frac{\pi^3}{96\,N^2}. $$ Doubling N quarters the error.
  • Transition zone. The theoretical error keeps falling, but rounding and limited working precision begin to matter. If “shown decimals” or internal precision don’t increase, visible gains slow down.
  • Inversion. Numerical/verification error exceeds the GRG error. Philosophically: the method is now better than your ruler.

Self-checking from the inside (no external π)

  1. Δ–ratio test (asymptotics). Define $$ \Delta_N := \pi_{2N}-\pi_N, \qquad R_N := \frac{\pi_{4N}-\pi_{2N}}{\pi_{2N}-\pi_N}. $$ For clean numerics, \( R_N \to \tfrac{1}{4} \). If you see ≈ 0.25, you are still in the \(1/N^2\) regime (all good). If it wanders far from 0.25 (oscillates, collapses to 0, or behaves oddly), numerics have taken over ⇒ inversion.
  2. Internal error estimate (no π). From the series expansion, $$ \pi - \pi_N \;\approx\; \frac{4}{3}\,\Delta_N. $$ The constant \( \tfrac{4}{3} \) comes from analysis; the factors \( \pi^3 \) cancel out. You can therefore display: “Estimated error ≈ \( \tfrac{4}{3}\,\Delta_N \)”.
  3. Internal acceleration (Richardson). Cancel the \(1/N^2\) term by combining two steps: $$ \pi_{\text{ex}} \;=\; \pi_{2N} + \frac{\pi_{2N}-\pi_N}{3}, \qquad \pi - \pi_{\text{ex}} = O(N^{-4}). $$ Then compare with \( \pi_{4N} \ ): $$ E_N := \big|\pi_{\text{ex}} - \pi_{4N}\big|, \qquad \text{verified digits} \;\approx\; \big\lfloor -\log_{10} E_N \big\rfloor. $$ If verified digits stop growing when you double N, the numerical checker is limiting you (inversion).

Takeaway

  • Intellectual simplicity (GRG): you turn a single knob, N, get a monotone inside-approximation, and a predictable error.
  • Honest inversion: beyond a certain threshold, it’s not GRG that runs out of accuracy—it’s the tools used to verify it.
  • Self-certification: using \( \Delta_N \), \( \pi_{\text{ex}} \), and \( E_N \), the method checks itself without resorting to an external π.

In the calculator above, when the internal checks suggest inversion, the panel turns amber and an explanatory note appears. Prefer powers of two for N, or increase working precision, if you need to push further.

Inside-Out GRG

Inside-Out GRG

Aug 24, 2025

GRG — Looking from the Inside: a discrete, π-free language for shapes

Generative Radial Geometry (GRG) — Looking from the Inside

GRG conventions. Angles are measured in turns \(u\in[0,1)\). Radial computations (perimeter and radial area) run on the full turn; the Cartesian area uses the quarter (and then ×4). Trigonometric forms are optional cross-checks, not inputs to the pipeline.

Work-in-progress. GRG is a discrete, π-free way to measure and compare shapes by radial generation. The turning point was this: I looked at the circle from its inside—a point that sends rays outward and measures what they meet. That inside→out switch is small to say and large to practice. The door is open; we will walk through it.

Why GRG matters

  • Discrete by nature: everything runs in finite steps (N)—heights, chords, bands.
  • π-free computation: the pipeline never needs π to run; π appears only when we compare to classical values.
  • Immediate comparability: two shapes at the same resolution are directly comparable with the same grammar.
  • Multi-scale: increase N; the very same procedure refines itself (coarse → fine).
  • GPU-friendly: short loops and sums, ideal for digital geometry, CAD/graphics, and simulation.

Looking from the inside

Not from a grid of squares, not from external coordinates—from a center that emits rays. A shape becomes a radial profile (a finite vector of values) rather than a formula to solve. From there, measurement and comparison happen discretely and immediately.

The joined method (circle)

Perimeter (radial, full turn): split the full turn \(u\in[0,1)\) into \(4N\) equal steps \(\Delta u=1/(4N)\). Join successive GRG border nodes by chords; the quarter view in the figure is for clarity.

Area (Cartesian, quarter): split one radius into \(N\) parts; at each split, drop the perpendicular to the circle (the “height”). Adjacent heights form a trapezoid; summing them tiles the quarter of a disk (the last one degenerates to a triangle). Multiply by 4 for the full disk.

Figure — joined method (circle)

Blue = angular sectors (perimeter, shown on the quarter). Red = single-radius trapezoids (area on the quarter). Dashed red rays start from the height intersections and generally do not coincide with the blue rays.

Figure 1. Quarter circle built from angular sectors (blue) and single-radius trapezoids (red); dashed rays start at height intersections.

Discrete comparability (the practical power)

At the same resolution N, any two shapes share the same grammar (heights, chords). This makes them comparable immediately—π-free inside the computation. We use simple, discrete indices relative to a baseline circle at the same N:

  • Area Index \(a_N\)
  • Perimeter Index \(c_N\)
  • Isoperimetric-like ratio \(q_N=a_N/c_N^2\) (the circle maps to 1 at the same N)
Minimal math — turns-first (π-free, node-based)

Quarter nodes (turns):

\[ \Delta u \;=\; \frac{1}{4N} \] \[ u_k \;=\; k\,\Delta u \quad (k=0,\dots,N) \]

Quarter inscribed perimeter (node distances):

\[ C_{\mathrm{in}}^{(Q)}(N) \;=\; \sum_{k=0}^{N-1} \bigl\|\,P_{k+1}-P_k\,\bigr\| \]

Full inscribed perimeter:

\[ C_{\mathrm{in}}(N) \;=\; 4\,C_{\mathrm{in}}^{(Q)}(N) \]

Radial area (full turn, shoelace on 4N nodes):

\[ A_{\mathrm{in}}(N) \;=\; \frac{1}{2} \sum_{j=0}^{4N-1} \bigl(x_j\,y_{j+1}-x_{j+1}\,y_j\bigr) \]

Cartesian area (quarter, Δx) → ×4:

\[ \Delta x \;=\; \frac{R}{N} \] \[ x_i \;=\; i\,\Delta x \] \[ y_i \;=\; \sqrt{\,R^2 - x_i^{\,2}\,} \] \[ A_{\mathrm{trap}}^{(Q)}(N) \;=\; \sum_{i=1}^{N} \frac{y_{i-1}+y_i}{2}\;\Delta x \] \[ A_{\mathrm{trap}}(N) \;=\; 4\,A_{\mathrm{trap}}^{(Q)}(N) \]

Discrete indices (baseline = circle at the same N):

\[ a_N \;=\; \frac{A_{\text{shape}}(N)}{A_{\text{circle}}(N)} \] \[ c_N \;=\; \frac{C_{\text{shape}}(N)}{C_{\text{circle}}(N)} \] \[ q_N \;=\; \frac{a_N}{c_N^{\,2}} \]
Classical cross-check (optional)

Inscribed perimeter (quarter step in turns):

\[ \Delta u \;=\; \frac{1}{4N} \] \[ s_N \;=\; 2R\,\sin\!\bigl(\pi\,\Delta u\bigr) \] \[ C_{\mathrm{in}}(N) \;=\; 4\,N\,s_N \;=\; 8\,N\,R\,\sin\!\Bigl(\frac{\pi}{4N}\Bigr) \]

Circumscribed perimeter (outer bound):

\[ C_{\mathrm{out}}(N) \;=\; 8\,N\,R\,\tan\!\Bigl(\frac{\pi}{4N}\Bigr) \]

Radial area via triangles (full turn):

\[ A_{\mathrm{tri}}(N) \;=\; 2\,N\,R^{2}\, \sin\!\Bigl(\frac{\pi}{2N}\Bigr) \]

Cartesian area (quarter, Δx) — same as above, then ×4.

Figure — 3D comparator (hemisphere bands)

Clean comparator for surfaces: baseline hemisphere on the left, target surface on the right. Blue = GRG parallels on each latitude; red = bands (average of neighboring circumferences). Below, π-free indices (schematic bars).

Figure 2. Hemisphere bands comparator: left = baseline, right = target. Blue parallels indicate perimeter along latitude; red band shows area via average neighboring circumferences times slant. Bars below sketch π-free indices.

From the circle to the sphere (concept)

We stack latitude bands along the vertical axis and apply the same grammar on each parallel (GRG circumference on the band’s ends, averaged across the slant). Errors shrink fast with balanced vertical and angular splits. The comparator above is designed to show differences band-by-band without clutter.

Applications

  • Graphics/CAD: π-free arc lengths and areas that run fast and parallel.
  • Sampling/tiling on spheres: controllable bands, equal-area approximations.
  • Gear-like and elliptical profiles via directional radial generation.
  • Education: a concrete bridge from discrete geometry to classical values.

Status & invitation

GRG is young and grows with this site. The aim is simple: a practical, comparable, discrete language for shapes and surfaces. If the idea helps, let’s refine proofs, diagrams, and applications together.

GRG Mini app

GRG Mini app

Aug 24, 2025

GRG Mini-App

Explore Generative Radial Geometry (GRG): figures are generated from the center at a chosen resolution, without assuming π a priori. Angles are measured in turns \(u\in[0,1)\) with period-1 trig \(c(u)=\cos(2\pi u),\ s(u)=\sin(2\pi u)\).

Controls

N = 24
Circumference is always from equal-angle chords in turns.
Sphere uses octant symmetry (×8) and π-free operators; volume is O(N²).
%
“Internal dominance” compares N to 2N (self-consistency). “Victory” compares to the π-based value (external).

Circle (2D)

Area estimate
—
Area corridor (if applicable)
—
Circumference (chords)
—
Internal Δ (N → 2N), area
—
Internal Δ (N → 2N), circumf.
—
External error vs π-based, area
—
External error vs π-based, circumf.
—
area: — circ: —

Sphere (3D)

Surface (octant fusion ×8)
—
Volume (stacked quarters ×8)
—
Internal Δ (N → 2N), surface
—
Internal Δ (N → 2N), volume
—
External error vs 4πr²
—
External error vs (4/3)πr³
—
surface: — volume: —

How the GRG Mini-App works — Circle & Sphere

What you control

Inputs. Two modules:

  • Circle (2D): choose radius r, subdivisions N and the Area method:
    • Δx Trapezoidal — quarter → ×4 (concave arc, under-tiling, fast O(N⁻²)).
    • Original Projection — midpoint (upper) / right (lower) corridor, quarter → ×4.
    • Radial Sectors (turns) — full turn, equal-angle sectors (inscribed, product form).
    Note: for Δx/Original the slider N refers to the quarter; for Radial it refers to the full turn. Circumference always uses turns with equal-angle chords.
  • Sphere (3D): choose radius R, vertical slices Nz, radial trapezoids for quarter-areas Mr, and quarter-circumference subdivisions Mc.
  • Show traditional comparison toggles all external (vs π) quantities and the grey series in charts.
  • Show π estimates reveals π computed internally (from A/C in 2D; S/V in 3D).
  • Download CSV exports the full range (1…Nmax); Copy link preserves the current settings.

Status badges & thresholds

🟢 Internal dominance The internal change between the current resolution and the doubled one is small relative to the value:

\(\displaystyle \frac{\Delta_{\mathrm{int}}}{\text{value}} \le 0.15\%\).

🏆 Victory vs classical The external error is also small:

\(\displaystyle \frac{\Delta_{\mathrm{ext}}}{\text{value}_\pi} \le 0.10\%\).

Formulas used — Circle (2D)

  • Area (Δx Trapezoidal): quarter sum of trapezoids with uniform \(\Delta x=r/N\) → ×4 (Kahan summation for stability).
  • Area (Original Projection): midpoint (upper) / right (lower) corridor on the quarter → ×4 (Kahan).
  • Area (Radial Sectors, turns): \(A_N=\tfrac{N}{2}r^2\,s(\tfrac{1}{N})\) with \(s(u)=\sin(2\pi u)\).
  • Circumference (turns): equal-angle chords on the full turn: \(C_{N_{\text{full}}}=2N_{\text{full}}\,r\,s(\tfrac{1}{2N_{\text{full}}})\). For Δx/Original we use \(N_{\text{full}}=4N\); for Radial, \(N_{\text{full}}=N\).

Formulas used — Sphere (3D)

  • Surface: octant fusion of quarter-circumferences along meridian (\(\Delta s\)), then ×8.
  • Volume: octant stacking of quarter-areas along \(z\) with trapezoid in \(\Delta z\), then ×8.

What this app demonstrates

GRG reconstructs circle and sphere without assuming π. With angles in turns and quarter/octant symmetries, internal stabilization (dominance) precedes external agreement (victory). Construct first, constants emerge.

GRG Mini-App — 3 righe

GRG Mini-App — 3 righe

Layout a righe: Controls → Circle (2D) → Sphere (3D). Tutti gli slider sono two-way con i numeri; i turns (U) hanno preview live (corde uguali).

Controls

Circle

Angular (turns)

Δu = 1/48 · Δθ = 0.130899694 rad
U multiple of 4 ✓; U = 4·N·k ✓

Sphere

Slider (mirrors)

Circle (2D)

Area (GRG)
0
Corridor width (mid−right)
—
Circumference (chords)
0
Δint A (2N vs N)
—
Δint C (2U vs U)
—
Δext A vs πr²
—
Δext C vs 2πr
—
area: — circ: —
Anteprima: poligono inscritto con U settori uguali (corde uguali).

Sphere (3D)

Surface S (octant fusion ×8)
0
Volume V (stacked quarters ×8)
0
Δint S
—
Δint V
—
Δext S vs 4πR²
—
Δext V vs (4/3)πR³
—
surface: — volume: —
ERG – Trapezoidal

ERG – Trapezoidal

Aug 24, 2025

Document Status and Current Reference

This page preserves an earlier formulation or research method. Its notation, formulas, and embedded demonstrations belong to that version and should not be treated as the specification of the current binary radial kernels.

Read the current formulation and its analytical verification. Historical performance statements and implementation behaviour require separate validation. Earlier references to circular constants remain in this historical document; they are not inputs to the current geometric kernel definitions.

Δx Trapezoidal (Cartesian)

Area from the inside on the quarter of a circle. Sample uniformly on the x-axis with $\Delta x=r/N$, build trapezoids strictly under the arc $y(x)=\sqrt{r^2-x^2}$, then multiply by 4 for the full circle. No angles and no external constants appear in the primary operators.

Setup (quarter)

$$ \Delta x=\frac{r}{N},\qquad x_k=k\,\Delta x\ \ (k=0,\dots,N),\qquad y_k=\sqrt{\,r^2-x_k^2\,}. $$

Quarter area (→ ×4 for the circle)

$$ A_{\text{quarter}}(N)\;=\;\sum_{k=0}^{N-1}\frac{\Delta x}{2}\,\bigl(y_k+y_{k+1}\bigr), \qquad A_{\text{circle}}(N)\;=\;4\,A_{\text{quarter}}(N). $$

Because $y(x)$ is concave on $[0,r]$, these trapezoids give a monotone under-approximation. The error typically decays like $O(N^{-2})$. A quick check is step-doubling: compare $A_{\text{circle}}(N)$ vs $A_{\text{circle}}(2N)$.

Quarter with Δx trapezoids (Cartesian x–y) Strict Cartesian axes (equal units). r=100, N=5 ⇒ Δx=20. Trapezoids are inside the quarter arc. x y
Fig. 1 — Δx trapezoids strictly inside the quarter arc (example: $r=100$, $N=5$).

Single strip geometry

Between $x_k$ and $x_{k+1}$ the trapezoid has bases $y_k$ and $y_{k+1}$ and width $\Delta x$; the arc segment lies strictly above it.

One Δx trapezoid under the arc Strip between x=60 and x=80 for r=100. Heights are y_k=80 and y_{k+1}=60. Dashed arc segment shown above the trapezoid. x y
Fig. 2 — One Δx strip (here $k=3$): the arc is strictly above the trapezoid.

Pseudocode

Input: r, N
Δx = r / N
Aq = 0
for k = 0..N-1:
    yk   = sqrt(r*r - (k*Δx)*(k*Δx))
    yk1  = sqrt(r*r - ((k+1)*Δx)*((k+1)*Δx))
    Aq  += 0.5 * Δx * (yk + yk1)
A_circle = 4 * Aq

Notes

  • Monotone: $A_{\text{circle}}(N)$ increases with $N$ and approaches the true area from below.
  • Accuracy: smooth $O(N^{-2})$ decay; step-doubling is a simple diagnostic.
  • Implementation: works cleanly with fixed-point or vectorized code (just sums and square roots).
GRG Core (Turns)

GRG Core (Turns)

Aug 24, 2025

Earlier Formulation

This page preserves a historical GRG method. Its notation and formulas belong to that version. The current binary radial formulation and verification are available here. Historical computational claims require separate validation.

Core Turns

Angles are measured in turns (fractions of a full rotation). Primary 2D formulas use products only and avoid sexagesimal units and external constants. We write c(u), s(u) for cosine/sine with period 1 in turns (so $c(0)=1$, $s(0)=0$; $c(\tfrac{1}{4})=0$, $s(\tfrac{1}{4})=1$). Equivalently, $c(u)=\cos(2\pi u)$ and $s(u)=\sin(2\pi u)$.

Radial point

$$ P(u) \;=\; \bigl( r\cdot c(u),\; r\cdot s(u) \bigr). $$

Perimeter (equal-angle chords)

$$ C_N \;=\; 2\cdot N \cdot r \cdot s\!\Bigl(\tfrac{1}{2N}\Bigr). $$

Area (equal-angle sectors)

$$ A_N \;=\; \tfrac{1}{2}\cdot N \cdot r^{2} \cdot s\!\Bigl(\tfrac{1}{N}\Bigr). $$

How to use

  • Pick a precision $N$ (e.g., $256$). If you store angles as $k/2^{B}$ turns, choose $N$ that divides $2^{B}$.
  • Dyadic refinement: with $b\in\mathbb{N}_{\ge 0}$, set $N=2^{b}$ so the turn step is $\Delta u=2^{-b}$. Quarter sampling uses $\Delta u=\tfrac{1}{4N}=2^{-b-2}$.
  • Optional check (step-doubling): compare $N$ vs. $2N$ to gauge the remaining gap.

Notes

  • Both $C_N$ and $A_N$ increase with $N$ and converge to the circle values $2\pi r$ and $\pi r^2$; the error typically scales like $O\!\bigl((\Delta u)^2\bigr)=O(N^{-2})$.
  • This block pairs with the Trapezoidal and Original blocks on the Applications pages.

Figure: turns, chord, and sector

Unit circle with radial point P(u), equal-angle step Δu=1/N, chord and sector Circle of radius r with angle u in turns; two rays separated by Δu illustrate the chord s(1/(2N)) and the associated sector s(1/N). u Δu = 1/N P(u) chord O
Radial point $P(u)$, equal-angle step $\Delta u=1/N$, chord $s(\tfrac{1}{2N})$, and sector $s(\tfrac{1}{N})$.

See also

Δx Trapezoidal · Original Projection · Applications / Circle · Applications / Sphere

Formalisation (2025 snapshot). GRG is fully angular: in 2D circumference via equal-angle Δu chords, and area via equal-angle Δu sectors (products only); in 3D, surface/volume are angular sums over meridian bands. No sexagesimal units, no π.

Generative Radial Geometry (GRG) — Formalisation (Turns)

GRG is a constructive, discrete framework based on full-turn angular partitions (turns). All angles are fractions of a full rotation $u\in[0,1)$. We use period-1 trigonometric functions $c(u), s(u)$ with $c(0)=1$, $s(0)=0$, $(c(\tfrac14), s(\tfrac14))=(0,1)$, and standard identities. Primary formulas contain no sexagesimal units and no external constants.

1) Setup and Notation (full turn)

  • Spaces. Plane $\mathbb{R}^2$ and space $\mathbb{R}^3$ with axes $x,y,z$.

  • Circle/Sphere. Center $O$, radius $r>0$. Circle: $x^2+y^2=r^2$. Sphere: $x^2+y^2+z^2=r^2$.

  • Angles. $u\in[0,1)$ turns. Turns-trigonometry: $c(u), s(u)$ with unit identities.

Fig. A — Radial construction over the full turn Axes, circle, and two radii separated by angle u in turns; point P(u) on the circle. u R
Fig. A — Angle $u$ (turns). Radial point $P(u)=(r\,c(u),\,r\,s(u))$.

2) Exact radial nodes (full turn)

For any $u\in[0,1)$:

Radial node

$$ P(u)\;=\;\bigl(r\,c(u),\; r\,s(u)\bigr). $$
Evenly-spaced angles: $u_k=k/N$ over the full turn.

3) 2D operators (products, no sums)

2D Circumference (inscribed regular N-gon)

$$ \boxed{\, C_N \;=\; 2\,N\,r\,s\!\Bigl(\tfrac{1}{2N}\Bigr) \,} $$
Sum of $N$ identical chords → product.

2D Area (N equal-angle sectors)

$$ \boxed{\, A_N \;=\; \tfrac{N}{2}\,r^{2}\,s\!\Bigl(\tfrac{1}{N}\Bigr) \,} $$
Sum of $N$ identical sectors → product.

4) Sphere: meridian bands over a half turn (angular-only)

Meridian parameterization (angles only)

$$ \Delta v=\tfrac{1}{2M}, \qquad v_i=i\,\Delta v, \qquad \rho_i=r\,s(v_i). $$

4.1 Surface (angular sum over bands)

Meridian step (constant) & parallel circumference

$$ h=2\,r\,s\!\Bigl(\tfrac{\Delta v}{2}\Bigr)=2\,r\,s\!\Bigl(\tfrac{1}{4M}\Bigr), \qquad \mathrm{C}_{\mathrm{GRG}}(\rho;L)=2\,L\,\rho\,s\!\Bigl(\tfrac{1}{2L}\Bigr). $$

Surface via trapezoids (bands)

$$ S_{M,L}=h\left[ \tfrac12\,\mathrm{C}_{\mathrm{GRG}}(\rho_0;L) + \sum_{i=1}^{M-1}\mathrm{C}_{\mathrm{GRG}}(\rho_i;L) + \tfrac12\,\mathrm{C}_{\mathrm{GRG}}(\rho_M;L) \right]. $$

Surface — midpoints (often more accurate)

$$ S_{M,L}\;\approx\; h\sum_{i=0}^{M-1}\mathrm{C}_{\mathrm{GRG}}\!\bigl(\rho_{i+\tfrac12};L\bigr), \qquad \rho_{i+\tfrac12}=r\,s\!\bigl(v_i+\tfrac{\Delta v}{2}\bigr). $$
Fig. D — Meridian bands: parallels front/mid/back Three parallels drawn as ellipses to suggest a sphere; axes and reference labels included. v_i v_{i+1}
Fig. D — Meridian bands over a half turn; 2D angular operators on each parallel.

4.2 Volume (angular sum over sections)

Axial thickness & section area (angular)

$$ \Delta z_i = r\,\big|\,c(v_{i+1})-c(v_i)\,\big|, \qquad \mathrm{A}_{\mathrm{GRG}}(\rho;N)=\tfrac{N}{2}\,\rho^2\,s\!\Bigl(\tfrac{1}{N}\Bigr). $$

Volume via trapezoids (sections)

$$ V_{M,N}\;\approx\;\sum_{i=0}^{M-1} \frac{\Delta z_i}{2}\Bigl(\mathrm{A}_{\mathrm{GRG}}(\rho_i;N)+\mathrm{A}_{\mathrm{GRG}}(\rho_{i+1};N)\Bigr). $$

Volume — midpoints

$$ V_{M,N}\;\approx\;\sum_{i=0}^{M-1}\mathrm{A}_{\mathrm{GRG}}\!\bigl(\rho_{i+\tfrac12};N\bigr)\,\Delta z_i. $$

5) Compact “no-π” operators (summary)

  • 2D circumference: $\displaystyle \mathrm{C}_{\mathrm{GRG}}(r; N)=2\,N\,r\,s\!\bigl(\tfrac{1}{2N}\bigr)$.

  • 2D area: $\displaystyle \mathrm{A}_{\mathrm{GRG}}(r; N)=\tfrac{N}{2}\,r^2\,s\!\bigl(\tfrac{1}{N}\bigr)$.

Dyadic refinement (turns-first): $b\in\mathbb{N}_{\ge 0}$, $N=2^{b}$, and $\Delta u=2^{-b}$ (quarter sampling uses $\Delta u = \tfrac{1}{4N}=2^{-b-2}$).

Core Turns

Angles are measured in turns (fractions of a full rotation, u∈[0,1)). We write c(u) and s(u) for cosine/sine with period 1 in turns (so c(0)=1, s(0)=0; c(1/4)=0, s(1/4)=1). This block gives 2D, product-only formulas without sexagesimal units or external constants.

Radial point

$$ P(u) \;=\; \bigl( r\,c(u),\; r\,s(u) \bigr) $$

Perimeter (equal-angle chords)

$$ C_N \;=\; 2\,N\,r\, s\!\Bigl(\tfrac{1}{2N}\Bigr) $$

Area (equal-angle sectors)

$$ A_N \;=\; \tfrac{1}{2}\, N\, r^{2}\, s\!\Bigl(\tfrac{1}{N}\Bigr) $$

How to use

  • Choose a precision N (e.g., 256). If you store angles as k/2^B turns, pick N dividing 2^B.
  • For a quick accuracy check, compare results at N and 2N (step-doubling).

Notes

  • C_N and A_N increase with N and converge to the circle’s values.
  • This is one GRG method block. See also the Δx Trapezoidal and Original Projection blocks.

See also: Δx Trapezoidal · Original Projection · Applications / Circle · Applications / Sphere

Note: 3D (surface/volume) lives under Applications / Sphere. This page focuses on the 2D Core Turns block.