SGTE — Numerical Verification Notebook¶

Sacred Geometry · Theory of Everything — independent checks of the framework's Tier-A mathematical claims¶

This notebook is fully runnable and self-contained (pure Python standard library — no installs). Every cell recomputes a structural number claim from first principles and asserts it against the value asserted in the SGTE framework. A green OK means the claim is a mathematical fact, not an interpretation. Run top-to-bottom: Kernel → Restart & Run All.

Scope note: this notebook verifies arithmetic / combinatorial claims (Tier A). It deliberately makes no statement about interpretive correspondences (Tier C) or open hypotheses (Tier D) — those are not the kind of claim a computer can settle.

In [1]:
import math, itertools
from functools import reduce

PASS, FAIL = [], []
def check(name, got, want):
    ok = got == want
    (PASS if ok else FAIL).append(name)
    print(f"[{'OK ' if ok else 'XX '}] {name}: computed {got!r}  vs claimed {want!r}")
    return ok

Claim A1 — The 231 Gates¶

The framework states the 22 Hebrew letters form 231 unordered pairs ("gates"), per Sefer Yetzirah. This is the binomial coefficient C(22, 2).

In [2]:
letters = list(range(22))                       # 22 letters
pairs = list(itertools.combinations(letters, 2)) # unordered pairs
check("A1  C(22,2) = 231 gates", len(pairs), 231)
check("A1b math.comb(22,2)", math.comb(22,2), 231)
# closed form n(n-1)/2
check("A1c 22*21/2", 22*21//2, 231)

[OK ] A1  C(22,2) = 231 gates: computed 231  vs claimed 231
[OK ] A1b math.comb(22,2): computed 231  vs claimed 231
[OK ] A1c 22*21/2: computed 231  vs claimed 231
Out[2]:
True

Claim A2 — The 256 Hypercube decomposition¶

The framework decomposes 256 = 4⁴ as 231 + 22 + 3 (gates + letters + mother-letters/axes).

In [3]:
check("A2  4**4", 4**4, 256)
check("A2b 2**8", 2**8, 256)
check("A2c 231 + 22 + 3 = 256", 231 + 22 + 3, 256)

[OK ] A2  4**4: computed 256  vs claimed 256
[OK ] A2b 2**8: computed 256  vs claimed 256
[OK ] A2c 231 + 22 + 3 = 256: computed 256  vs claimed 256
Out[3]:
True

Claim A3 — Sefer Yetzirah 3 / 7 / 12 partition of the 22 letters¶

3 Mother letters + 7 Double letters + 12 Simple letters = 22.

In [4]:
mothers, doubles, simples = 3, 7, 12
check("A3  3+7+12 = 22 letters", mothers + doubles + simples, 22)
check("A3b doubles map to 7 planets", doubles, 7)
check("A3c simples map to 12 zodiac", simples, 12)

[OK ] A3  3+7+12 = 22 letters: computed 22  vs claimed 22
[OK ] A3b doubles map to 7 planets: computed 7  vs claimed 7
[OK ] A3c simples map to 12 zodiac: computed 12  vs claimed 12
Out[4]:
True

Claim A4 — f(n) = 2ⁿ × 33 recursion¶

The framework's expansion law. Verified as an exact closed form and against a doubling recursion.

In [5]:
def f(n): return (2**n) * 33
# recursion: f(0)=33 ; f(n)=2*f(n-1)
g = 33
for n in range(0, 13):
    assert g == f(n), (n, g, f(n))
    g *= 2
print("recursion 2*f(n-1) matches 2**n*33 for n=0..12  -> OK")
check("A4  f(0)=33", f(0), 33)
check("A4b f(3)=264", f(3), 264)
check("A4c f(10)=33792", f(10), 33792)

recursion 2*f(n-1) matches 2**n*33 for n=0..12  -> OK
[OK ] A4  f(0)=33: computed 33  vs claimed 33
[OK ] A4b f(3)=264: computed 264  vs claimed 264
[OK ] A4c f(10)=33792: computed 33792  vs claimed 33792
Out[5]:
True

Claim A5 — Digital root structure¶

Digital root (iterated digit sum) ≡ n mod 9 (with 9 for multiples of 9). Check the framework's key numbers.

In [6]:
def droot(n):
    n = abs(int(n))
    return 0 if n == 0 else 1 + (n - 1) % 9

for n in [22, 231, 256, 72, 33, 243, 25920]:
    print(f"  digital_root({n}) = {droot(n)}   (n mod 9 = {n%9})")
check("A5  droot(231)=6", droot(231), 6)     # 2+3+1
check("A5b droot(256)=4", droot(256), 4)     # 2+5+6=13 ->4
check("A5c droot(72)=9", droot(72), 9)
check("A5d droot(25920)=9 (Great Year)", droot(25920), 9)

  digital_root(22) = 4   (n mod 9 = 4)
  digital_root(231) = 6   (n mod 9 = 6)
  digital_root(256) = 4   (n mod 9 = 4)
  digital_root(72) = 9   (n mod 9 = 0)
  digital_root(33) = 6   (n mod 9 = 6)
  digital_root(243) = 9   (n mod 9 = 0)
  digital_root(25920) = 9   (n mod 9 = 0)
[OK ] A5  droot(231)=6: computed 6  vs claimed 6
[OK ] A5b droot(256)=4: computed 4  vs claimed 4
[OK ] A5c droot(72)=9: computed 9  vs claimed 9
[OK ] A5d droot(25920)=9 (Great Year): computed 9  vs claimed 9
Out[6]:
True

Claim A6 — 72 Names (Shem ha-Mephorash)¶

72 triads derived from Exodus 14:19-21 (three verses of 72 letters each). Structural arithmetic only.

In [7]:
verse_letters = 72
check("A6  3 verses x 72 letters / 3 = 72 names", (3*verse_letters)//3, 72)
check("A6b 72 = 8*9", 8*9, 72)
check("A6c digital root 72 = 9", droot(72), 9)

[OK ] A6  3 verses x 72 letters / 3 = 72 names: computed 72  vs claimed 72
[OK ] A6b 72 = 8*9: computed 72  vs claimed 72
[OK ] A6c digital root 72 = 9: computed 9  vs claimed 9
Out[7]:
True

Claim A7 — 243 = 3⁵ (ternary completeness)¶

The framework uses 243 as the count of 5-position ternary states (3⁵).

In [8]:
states = list(itertools.product([0,1,2], repeat=5))
check("A7  3**5 = 243", 3**5, 243)
check("A7b enumerated 5-trit states", len(states), 243)

[OK ] A7  3**5 = 243: computed 243  vs claimed 243
[OK ] A7b enumerated 5-trit states: computed 243  vs claimed 243
Out[8]:
True

Claim A8 — The Great Year (precession)¶

25,920 years = 12 ages × 2,160 years/age; also 360° ÷ (1°/72yr).

In [9]:
check("A8  12 * 2160", 12*2160, 25920)
check("A8b 360 * 72", 360*72, 25920)
check("A8c 2160 per age", 25920//12, 2160)

[OK ] A8  12 * 2160: computed 25920  vs claimed 25920
[OK ] A8b 360 * 72: computed 25920  vs claimed 25920
[OK ] A8c 2160 per age: computed 2160  vs claimed 2160
Out[9]:
True

Claim A9 — 10 Sefirot & 32 Paths of Wisdom¶

10 Sefirot + 22 letter-paths = the 32 Paths of Wisdom (Sefer Yetzirah 1:1).

In [10]:
sefirot, letter_paths = 10, 22
check("A9  10 + 22 = 32 paths", sefirot + letter_paths, 32)
check("A9b 32 = 2**5", 2**5, 32)

[OK ] A9  10 + 22 = 32 paths: computed 32  vs claimed 32
[OK ] A9b 32 = 2**5: computed 32  vs claimed 32
Out[10]:
True

Claim A10 — Internal consistency of the 256-cube layers¶

Cross-check that the gate/letter/axis decomposition is consistent with the 32-path and 3/7/12 structure.

In [11]:
# 231 gates are pairs over 22 letters; 22 = 3+7+12; 10 sefirot + 22 = 32
assert math.comb(22,2) == 231
assert (3+7+12) == 22
assert (10+22) == 32
assert 231+22+3 == 256 == 4**4
print("All structural identities mutually consistent -> OK")
check("A10 256 - 231 - 22", 256-231-22, 3)

All structural identities mutually consistent -> OK
[OK ] A10 256 - 231 - 22: computed 3  vs claimed 3
Out[11]:
True

Verification summary¶

In [12]:
print("="*52)
print(f"PASSED : {len(PASS)}")
print(f"FAILED : {len(FAIL)}")
if FAIL:
    print("Failing:", FAIL)
else:
    print("\nALL TIER-A NUMERICAL CLAIMS VERIFIED \u2713")
print("="*52)

====================================================
PASSED : 27
FAILED : 0

ALL TIER-A NUMERICAL CLAIMS VERIFIED ✓
====================================================