The binary radial formulation combines complementary internal and external sector triangles. The area kernel uses one internal contribution and two external contributions, unlike the circumference kernel’s two-to-one chord–tangent balance.
Geometric Elements
Resolve one Turn into N equal symmetric sectors. Let a be the internal triangle’s height, h half its chord, and e half the external tangent side. Define q = h/a.
$$ N=2^b,\quad b\ge2,\quad R>0,\qquad a^2+h^2=R^2,\quad e=R\frac ha. $$
Regular geometric bisection yields a scale bound. Together with the expansion, it proves second-order total error for the arithmetic kernel and fourth-order total error for the weighted kernel in exact arithmetic.
The earlier version introduced this quarter-step sampling parameter inside each module. The proof here concerns the complete sector triangles defined above. A different sample-based area construction requires its own explicit definition and proof.
Internal–external weights are reversed between the circumference and area kernels. This diagram is schematic; the triangle definitions determine the calculation.
Research Status
The cancellation is established for the regular triangular elements above. This does not establish original authorship of the weighting, numerical stability of an implementation, or a computational advantage. Those questions require separate literature and implementation comparisons.
Earlier revisions of this page described fourth-order behaviour as a candidate. The current analytical clarification identifies the geometric assumptions under which that behaviour follows.
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.
GRG in One Page: π-Free Corridors, Benchmarks, and a Lean Mini-App
This single page addresses reviewer questions with concrete numbers, one minimal code box, and a practical validation plan. All constructions are turns-first and dyadic: b ∈ ℕ≥0, N = 2^b, step Δu = 2^{-(b+2)} = 1/(4N). We use only sums and square roots.
1) Worked example (r = 100) with certified circumference/area corridors
Let c_N be the unit-radius chord spanning an arc of 1/N turns. Starting from the square, c_4 = √2, we refine dyadically by a π-free half-angle step:
Certified corridors for circumference and area using only sums and square roots (r = 100).
Chord (inscribed), tangent (circumscribed), and apothem define GRG corridors.
2) One minimal code box (Python) that reproduces the table
Drop-in, π-free implementation. Only square roots and sums via half-angle edge doubling.
# GRG: π-free corridors for circumference and area (dyadic N=2^b)
# r: radius; N: number of edges (dyadic)
import math
def c_dyadic(N):
# start from square (N=4): c_4 = sqrt(2)
if N & (N-1):
raise ValueError("N must be a power of 2")
if N < 4:
raise ValueError("N must be >= 4")
c = math.sqrt(2.0)
n = 4
while n < N:
c = math.sqrt(2.0 - 2.0*math.sqrt(1.0 - 0.25*c*c))
n *= 2
return c # unit radius
def corridors(r=100.0, b_list=(3,4,5,6)):
out = []
for b in b_list:
N = 2**b
c = c_dyadic(N)
t = c / math.sqrt(1.0 - (0.5*c)**2) # computed π-free
C_minus = N * r * c
C_plus = N * r * t
apothem = r * math.sqrt(1.0 - (0.5*c)**2)
A_minus = 0.5 * C_minus * apothem
A_plus = 0.5 * C_plus * r
pi_lo, pi_hi = C_minus/(2*r), C_plus/(2*r)
out.append(dict(N=N, C_minus=C_minus, C_plus=C_plus,
A_minus=A_minus, A_plus=A_plus,
pi_low=pi_lo, pi_high=pi_hi,
width=pi_hi-pi_lo, mid=0.5*(pi_hi+pi_lo)))
return out
if __name__ == "__main__":
for row in corridors():
print(row)
Why this matters: Reviewers asked for “real code.” The snippet above is reference-grade and numerically stable for dyadic N in double precision.
3) Mini-calculator (in-page): corridor and area, π-free
Try different radii and resolutions. The calculator only uses the recursion above (no trigonometric calls).
Geometry: regular polygon perimeter/area via trig (reference), rasterization by angular stepping, standard kernel approximations.
Optics: Zernike-based phase optimization (asphere/phase plate) and uniform samplers; compare against GRG dyadic turns.
Chemistry: radial distribution (isotropic) vs. anisotropic stress tests; compare GRG dyadic shells to uniform/log binning.
4.2 Datasets and tasks
Circles/Spheres: circumference/area/volume corridors at fixed sample budgets.
Optical toy problem: paraxial lenslet: maximize on-axis MTF at a target spatial frequency under a fixed simulator budget.
Chemical toy problem: radial distribution functions with/without anisotropy; report L_2 error vs. a high-precision reference.
4.3 Metrics and stats
Error vs budget: corridor width or absolute error vs. number of samples.
Time vs accuracy: seconds to reach a target error.
Robustness: worst-case error across seeds; bootstrap CI.
5) Scalability and complexity
Cost: computing c_N is O(log N) half-angle steps; producing C_N^{±}, A_N^{±} is O(1).
Beyond circles/spheres: For radially defined profiles, GRG’s dyadic turns yield nested certified bounds. For anisotropy, use a wedge-stratified scheme: split [0,1) turns into dyadic wedges and apply GRG within each wedge; corridors add up across wedges.
6) GRG Mini-App: current status and UI notes
Scope: live computation of C_N^{±}, A_N^{±}, π corridor, and dyadic overlays (“inscribed polygon preview”, “row layout”).
Roadmap: public demo + short tutorial video; CSV export of computed corridors; copy-paste of the Python above.
Accessibility: keyboard-operable sliders for b, ARIA live regions on numeric outputs (as in the mini-calculator).
7) What to expect next
Open-source drop: the single Python file (MIT/BSD-3) + tiny unit tests.
Benchmarks: publish results vs. Zernike and uniform samplers on the toy problems; scripts and seeds included.
This toy problem shows how GRG guides sampling while any preferred field solver evaluates performance. We optimize a rotationally symmetric height profile under a fixed evaluation budget.
Constraints: height range (manufacturability), smoothness (bounded second difference), and a hard cap on simulator calls.
8.2 GRG sampling policy
Choose dyadic level b; sample radii on N=2^b turns (rings). For anisotropic stress tests, split the pupil into dyadic wedges and apply the same policy per wedge.
At each refinement, reuse prior evaluations (nested design), cutting waste in flat regions.
8.3 Budget-fair comparison
Compare against equal-angle and equal-arc samplers at the same number of simulator calls.
Report \Delta \mathrm{MTF} = \mathrm{MTF}_{\text{GRG}} - \mathrm{MTF}_{\text{baseline}} and time-to-target MTF.
8.4 Reproducibility hook
The π-free recursion and nested sampling policy above serve as the public spec. A scalar paraxial PSF/OTF evaluator—or your preferred solver—can be dropped in without altering the sampling design.
Divide the single radius into N parts: $$\Delta r=\frac{R}{N},\qquad x_k=k\,\Delta r\;(k=0,\dots,N).$$
Define the heights on the circle by Pythagoras: $$b_k=\sqrt{R^2-x_k^2},\qquad b_0=R,\; b_N=0.$$
Trapezoids
The k-th trapezoid (for k=1..N) uses the adjacent heights \(B=b_{k-1}\) and \(b=b_k\) and has height \(\Delta r\):
$$A_k=\frac{(b_{k-1}+b_k)}{2}\,\Delta r \;=\; \frac{(B+b)}{2}\,\frac{R}{N}.$$
First trapezoid: $$A_1=\frac{(R+b_1)}{2}\,\frac{R}{N}.$$
Last trapezoid (degenerates to a triangle since \(b_N=0\)): $$A_N=\frac{(b_{N-1}+0)}{2}\,\frac{R}{N}=\frac{b_{N-1}}{2}\,\frac{R}{N}.$$
Total quarter area
$$A^{(Q)}_{\text{trap}}(N)=\sum_{k=1}^{N}\frac{(b_{k-1}+b_k)}{2}\,\frac{R}{N} \;=\; \sum_{k=0}^{N-1}\frac{\Delta r}{2}\big(b_k+b_{k+1}\big).$$
By symmetry for the full disk: $$A_{\text{trap}}(N)=4\,A^{(Q)}_{\text{trap}}(N).$$
Summary. Yes: the area of the quarter is the sum of all these trapezoids. The last one is automatically a triangle because \(b_N=0\). This matches your picture and the loop a computer would run.
GRG — 3D extension: the sphere (surface area) + error behaviour
Work-in-progress. GRG keeps growing while we build the site. The “joined method” (angular sectors + one-radius trapezoids) lifts naturally from the circle to the sphere.
Setup (hemisphere)
Choose two integers: Nz (vertical splits) and Nθ (angular sectors for circumferences).
This has quadratic error in \(\Delta r\) (order \(N^{-2}\)), so the accuracy rises fast. The same idea—“average of neighbours” along one axis—drives the sphere construction above.
Error behaviour (what shrinks, and why)
Angular sectors (per circumference): chord vs arc gives a relative error that scales like \( \mathcal{O}(N_\theta^{-2})\).
Vertical frusta (along a meridian): the trapezoidal averaging in \(z\) (via the slant step \(s_k\)) yields error \( \mathcal{O}(N_z^{-2})\).
Combined effect: the sphere estimate satisfies
$$A_{\text{sphere}}(N_z,N_\theta) \to 4\pi R^2 \quad\text{as}\quad N_z,N_\theta\to\infty,$$
with total error behaving like $$\mathcal{O}\!\big(N_z^{-2}\big)+\mathcal{O}\!\big(N_\theta^{-2}\big).$$
(We keep formulas π-free in the computation; π appears only when comparing to the classical continuous value.)
Algorithm (summary)
For k = 0..Nz: compute \(z_k, r_k, C_k=C_{GRG}(r_k;N_\theta)\).
For k = 0..Nz−1: compute \(s_k=\sqrt{(\Delta z)^2+(r_{k+1}-r_k)^2}\) and
$$A_k=\tfrac{C_k+C_{k+1}}{2}\,s_k.$$
Sum \(A_k\) for the hemisphere; double for the whole sphere.
Notes
The polar band automatically degenerates (like the “last trapezoid → triangle” in 2D), so the loop stays uniform.
To balance errors, pick \(N_z\approx N_\theta\) (e.g., 24–48 each gives already small relative errors).
Volume of the sphere can be done analogously using cylindrical shells with \(C_{GRG}(r;N_\theta)\) and a height term; we can add that next.
[Optional future figure: hemisphere bands as conical frusta with GRG circumferences]
GRG — Joined method for the circle: perimeter by angular sectors, area by single-radius trapezoids
Work-in-progress. Generative Radial Geometry (GRG) is evolving as we build the website. The idea below emerged today (23 August 2025) and we document it in real time. GRG is a young, living framework: definitions, figures, and formulas grow together with the site.
Setup (quarter of a circle)
Let the radius be R and consider the first-quadrant quarter of the circle. Fix an integer N ≥ 1. We couple two distinct discretisations:
Perimeter (angular division): split the right angle into N equal parts with step
$$ \Delta\theta=\frac{\pi}{2N} $$
Area (single-radius heights): split one radius into N equal parts with
Blue = angular sectors for the perimeter. Red = heights on one radius and the adjacent trapezoids for the area. Dashed red rays start from the intersection points and do not, in general, coincide with the blue rays.
To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions.
Functional
Always active
The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network.
Preferences
The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user.
Statistics
The technical storage or access that is used exclusively for statistical purposes.The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you.
Marketing
The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes.
