"""exact.py — de laag "exact nagerekend" van maze.swarp.nl/bewezen (28-10-2026). Canoniek model: docs/vacuum-net-canon.md (Foundations 9.2 + Physics 9.0). Wat in Lean bewezen is staat in maze/lean/Foundations/; hier staat wat de editie "computed" noemt en wat buiten Lean exact te rekenen is: gehele getallen, breuken en SymPy. Drijvende komma met hoge precisie (mpmath) alleen bij: T17 en de centkolom van T18 (80 cijfers), muziek-53, T24b (30 cijfers, foutgrens 5·10⁻⁷) en de eigenwaarde in P-T4b — telkens met de grens erbij. Elke toets slaagt of faalt; niets wordt "ongeveer" bevonden. Gebruik: python3 maze/nieuw/bewezen/exact.py → exact-meting.json (+ sha256) """ import json, hashlib, itertools, os from fractions import Fraction import sympy as sp hier = os.path.dirname(os.path.abspath(__file__)) UIT = os.environ.get("EXACT_UIT", hier) # rechters schrijven naar een eigen map T = (-1, 0, 1) uit = [] def boek(id_, wat, uitkomst, ok): uit.append({"id": id_, "wat": wat, "uitkomst": uitkomst, "geslaagd": bool(ok)}) # ── Foundations T6: sluitkans (1/3)[1 + p̂(ω)³ + p̂(ω²)³] ── p0, pp, pm = sp.symbols("p0 pp pm", real=True) kans = {0: p0, 1: pp, -1: pm} direct = sum(kans[a] * kans[b] * kans[c] for a, b, c in itertools.product(T, repeat=3) if (a + b + c) % 3 == 0) w = sp.exp(2 * sp.pi * sp.I / 3) ph = lambda z: p0 + pp * z + pm * z**2 formule = sp.Rational(1, 3) * (1 + ph(w)**3 + ph(w**2)**3) verschil = sp.simplify(sp.expand(sp.expand_complex((formule - direct).subs(p0, 1 - pp - pm)))) # een kansverdeling: p₀ + p₊ + p₋ = 1 uniform = direct.subs({p0: sp.Rational(1, 3), pp: sp.Rational(1, 3), pm: sp.Rational(1, 3)}) boek("F-T6", "sluitkans: formule = directe som over de 27 vensters, als veelterm onder p₀ + p₊ + p₋ = 1; uniform = 1/3", f"verschil {verschil}, uniform {uniform}", verschil == 0 and uniform == sp.Rational(1, 3)) # ── Foundations T13: 3^(n−1) woorden met gesloten eerste venster; g(n) = 3, 6, 11, 24, 51, 130 ── ok_i = all(sum(1 for wd in itertools.product(T, repeat=n) if sum(wd[:3]) % 3 == 0) == 3**(n - 1) for n in range(3, 9)) def g(n): return sum(sp.totient(n // d) * 3**d for d in sp.divisors(n)) // n def brute(n): return len({min(wd[i:] + wd[:i] for i in range(n)) for wd in itertools.product(T, repeat=n)}) gs = [int(g(n)) for n in range(1, 7)]; bs = [brute(n) for n in range(1, 7)] boek("F-T13", "open woorden: 3^(n−1) met gesloten eerste venster (n = 3…8); rotatieklassen g(n) formule = brute kracht (n = 1…6)", f"g = {gs}, brute = {bs}", ok_i and gs == bs == [3, 6, 11, 24, 51, 130]) # ── Foundations T14: cijferafbeelding in ℤ[ω], ω² = −1 − ω ── def res(a, b): # gebalanceerd residu van a + bω (≡ a + b mod 3) r = (a + b) % 3 return r if r < 2 else -1 def stap(a, b): d = res(a, b); x, y = a - d, b # (x + yω)/(1 − ω) = (x + yω)(1 − ω²)/3 = (x + yω)(2 + ω)/3 # (x + yω)(2 + ω) = 2x + xω + 2yω + yω² = 2x − y + (x + y)ω re, im = 2 * x - y, x + y assert re % 3 == 0 and im % 3 == 0 return re // 3, im // 3 def eind(a, b): """volg de baan; geeft ('rust', cijfers) bij 0, of ('draai', eindpunt) bij een herhaling""" gezien, cijfers = set(), [] while (a, b) != (0, 0): if (a, b) in gezien: return "draai", (a, b) gezien.add((a, b)); cijfers.append(res(a, b)); a, b = stap(a, b) return "rust", cijfers vast = stap(1, 1) == (1, 1) and stap(-1, -1) == (-1, -1) def keer(d_lijst): """Σ dᵢβⁱ exact, met (x + yω)·(1 − ω) = (x + y) + (2y − x)ω [want ω² = −1 − ω]""" re, im, px, py = 0, 0, 1, 0 for d in d_lijst: re += d * px; im += d * py px, py = px + py, 2 * py - px return re, im def box(m): draai, terug, alleen_vast = 0, True, True for a in range(-m, m + 1): for b in range(-m, m + 1): soort, x = eind(a, b) if soort == "draai": draai += 1; alleen_vast &= x in ((1, 1), (-1, -1)) else: terug &= keer(x) == (a, b) return draai, (2 * m + 1)**2, alleen_vast, terug v40, v100 = box(40), box(100) w_ = sp.Rational(-1, 2) + sp.sqrt(3) * sp.I / 2 # ω zes = sp.simplify((1 + w_)**6) == 1 and sp.simplify((1 + w_) + w_**2) == 0 and sp.simplify(sp.arg(1 + w_) - sp.pi / 3) == 0 herhaald = res(1, 1) == -1 and stap(1, 1) == (1, 1) and res(-1, -1) == 1 and stap(-1, -1) == (-1, -1) boek("F-T14b", "1 + ω = −ω² is een zesde eenheidswortel (draai van 60°); de cijferreeks van 1 + ω is −1 herhaald, van −(1 + ω) is +1 herhaald", f"zesde wortel {zes}; herhaald cijfer {herhaald}", zes and herhaald) voorbeeld = [(2, 0), stap(2, 0), stap(*stap(2, 0))] boek("F-T14", "ℤ[ω], |a|,|b| ≤ 40 en ≤ 100: ±(1+ω) vast; elke draai eindigt in ±(1+ω); elke rust geeft een eindig woord dat z exact teruggeeft; aandelen; voorbeeld 2 → 2+ω → 1+ω", f"vast {vast}; {v40[0]}/{v40[1]}, {v100[0]}/{v100[1]}; eindpunt alleen ±(1+ω): {v40[2] and v100[2]}; terug exact: {v40[3] and v100[3]}; voorbeeld {voorbeeld}", vast and v40[:2] == (1788, 6561) and v100[:2] == (16546, 40401) and v40[2] and v100[2] and v40[3] and v100[3] and voorbeeld == [(2, 0), (2, 1), (1, 1)]) # ── Foundations T17: sluitdieptes tot 10⁶, en de convergenten van log₂3 ── import mpmath as mp mp.mp.dps = 80 th = mp.log(3) / mp.log(2) rec, best = [], mp.mpf(1) for k in range(1, 10**6 + 1): x = k * th; dist = abs(x - mp.nint(x)) if dist < best: best = dist; rec.append(k) termen, x = [], th for _ in range(25): a = int(mp.floor(x)); termen.append(a); x = 1 / (x - a) noem, (h0, h1), (k0, k1) = [], (1, termen[0]), (0, 1) for a in termen[1:]: h0, h1 = h1, a * h1 + h0; k0, k1 = k1, a * k1 + k0 if k1 <= 10**6: noem.append(k1) verwacht = [1, 2, 5, 12, 41, 53, 306, 665, 15601, 31867, 79335, 111202, 190537] boek("F-T17", "sluitdieptes k ≤ 10⁶ (record-afstanden met 80 cijfers) = noemers van de convergenten", f"records {rec}; kettingbreuk {termen[:15]}", rec == verwacht and noem == verwacht and termen[:15] == [1, 1, 1, 2, 2, 3, 1, 5, 2, 23, 2, 2, 1, 1, 55]) # ── Foundations T18: de komma en de resten in cent ── komma = Fraction(3**12, 2**19) cent = lambda k, n: float(1200 * abs(k * th - n)) paren = [(1, 2, 498.045), (2, 3, 203.910), (5, 8, 90.225), (12, 19, 23.460), (41, 65, 19.845), (53, 84, 3.615), (306, 485, 1.770), (665, 1054, 0.0756), (15601, 24727, 0.0315)] def afr(x, c): d = len(repr(c).split(".")[1]); return round(x, d) == c ok = komma == Fraction(531441, 524288) and all(afr(cent(k, n), c) for k, n, c in paren) d665 = len(str(3**665)); lead = int(str(3**665)[:3]) boek("F-T18c", "3⁶⁶⁵ fijnste doorgangen op diepte 665 (ringladder): ≈ 1,9 · 10³¹⁷", f"{str(3**665)[0]},{str(3**665)[1:3]} · 10^{d665 - 1}", d665 - 1 == 317 and round(lead / 100, 1) == 1.9) pct = [(1, 2, "33.3"), (2, 3, "11.1"), (5, 8, "5.35"), (12, 19, "1.35"), (41, 65, "1.15"), (53, 84, "0.21"), (306, 485, "0.10"), (665, 1054, "0.0044"), (15601, 24727, "0.0018")] def pr(k, n): r = abs(Fraction(2**n, 3**k) - 1) * 100 return float(r) pct_ok = all(abs(pr(k, n) - float(v)) <= 0.5 * 10**(-(len(v.split(".")[1]))) + 1e-12 for k, n, v in pct) boek("F-T18b", "procentkolom |2ⁿ/3ᵏ − 1| op de sluitdieptes, exact met breuken, tegen de afronding van de editie", f"{[round(pr(k, n), 4) for k, n, _ in pct]}", pct_ok) boek("muziek-53", "53-toonsstemming: kwint van 31 stappen tegen de reine kwint 3/2, in cent", f"{1200 * 31 / 53 - float(1200 * mp.log(1.5, 2)):.4f} cent", abs(1200 * 31 / 53 - float(1200 * mp.log(1.5, 2)) + 0.0682) < 1e-3) boek("F-T18", "komma 3¹²/2¹⁹ = 531441/524288; resten in cent op de sluitdieptes, gelijk na afronding op het aantal decimalen van de editie", f"komma {komma} = {float(komma):.6f}; cent {[round(cent(k, n), 4) for k, n, _ in paren]}", ok) # ── Foundations T19/T20: drie-kleuring en de bracket van de klaverblad-knoop ── # PD-code klaverblad: X[1,5,2,4], X[3,1,4,6], X[5,3,6,2] (bogen 1..6, drie overbogen) pd = [(1, 5, 2, 4), (3, 1, 4, 6), (5, 3, 6, 2)] # bogen (arcs) als klassen van randen: onder-randen a,c zijn verschillende bogen; over-randen b,d één boog uf = {e: e for e in range(1, 7)} def f(e): while uf[e] != e: e = uf[e] return e for a, b, c, d in pd: uf[f(b)] = f(d) bogen = sorted({f(e) for e in range(1, 7)}) kleur = 0 for kl in itertools.product(range(3), repeat=len(bogen)): c = {bo: kl[i] for i, bo in enumerate(bogen)} if all((c[f(b)] * 2 - c[f(a)] - c[f(cc)]) % 3 == 0 for a, b, cc, d in pd): kleur += 1 A, t = sp.symbols("A t", positive=True) def bracket(pd): tot = 0 for st in itertools.product((0, 1), repeat=len(pd)): u = {e: e for e in range(1, 2 * len(pd) + 1)} def ff(e): while u[e] != e: e = u[e] return e for s, (a, b, c, d) in zip(st, pd): if s == 0: u[ff(a)] = ff(b); u[ff(c)] = ff(d) else: u[ff(a)] = ff(d); u[ff(b)] = ff(c) lussen = len({ff(e) for e in u}); na = st.count(0); nb = st.count(1) tot += A**(na - nb) * (-A**2 - A**-2)**(lussen - 1) return sp.expand(tot) K = bracket(pd) editie = A**-7 - A**-3 - A**5 # writhe uit de georiënteerde PD-code, tekenregel van KnotTheory (Bar-Natan): X[i,j,k,l] positief als j − l = 1 of l − j > 1 teken = lambda i, j, k, l: 1 if (j - l == 1 or l - j > 1) else -1 writhe = sum(teken(*x) for x in pd) V = sp.expand(sp.simplify(((-A**3)**(-writhe) * K).subs(A, t**sp.Rational(-1, 4)))) jones_ok = sp.simplify(V - (t + t**3 - t**4)) == 0 vz = sp.expand_complex(V.subs(t, sp.exp(sp.I * sp.pi / 3))) # het spiegeldiagram zelf doorgerekend (elke kruising gespiegeld: X[i,j,k,l] → X[l,i,j,k]) pd_sp = [(l, i, j, k) for i, j, k, l in pd] K_sp = bracket(pd_sp) w_sp = sum(teken(*x) for x in pd_sp) Vsp = sp.expand(sp.simplify(((-A**3)**(-w_sp) * K_sp).subs(A, t**sp.Rational(-1, 4)))) vz_ok = sp.simplify(vz - sp.I * sp.sqrt(3)) == 0 fox = sp.nsimplify(sp.simplify(3 * (sp.re(vz)**2 + sp.im(vz)**2))) # het kruisingsloze diagram: één boog, geen kruisingen — elke kleuring is toegestaan def kleuringen(pd, bogen): n = 0 for kl in itertools.product(range(3), repeat=len(bogen)): c = {bo: kl[i] for i, bo in enumerate(bogen)} n += all((c[f(b)] * 2 - c[f(a)] - c[f(cc)]) % 3 == 0 for a, b, cc, d in pd) return n onbekend = kleuringen([], [1]) boek("F-T19", "Fox-driekleuringen: standaardklaverblad (PD X[1,5,2,4] X[3,1,4,6] X[5,3,6,2]) en het kruisingsloze diagram", f"klaverblad {kleur}, kruisingsloos {onbekend}", kleur == 9 and onbekend == 3) boek("F-T20", "bracket door toestandssom over de 2³ gladmakingen = A⁻⁷ − A⁻³ − A⁵ (strikt); writhe uit de PD-code; V(t) = t + t³ − t⁴; spiegeldiagram doorgerekend: writhe −3, ⟨K̄⟩ = A⁷ − A³ − A⁻⁵, V = t⁻¹ + t⁻³ − t⁻⁴ ≠ V; V(e^{iπ/3}) = i√3; 3|V|² = 9", f"⟨K⟩ = {K}; writhe {writhe}; V = {V}; spiegeldiagram ⟨K̄⟩ = {K_sp}, writhe {w_sp}, V = {Vsp}; V(e^(iπ/3)) = {sp.simplify(vz)}; 3|V|² = {fox}", sp.expand(K - editie) == 0 and writhe == 3 and jones_ok and fox == 9 and vz_ok and w_sp == -3 and sp.expand(K_sp - (A**7 - A**3 - A**-5)) == 0 and sp.expand(Vsp - (1/t + t**-3 - t**-4)) == 0 and sp.expand(Vsp - V) != 0) # ── Foundations T21: dubbele overdekking ── th_, = sp.symbols("theta", real=True), q = lambda ang: sp.Quaternion(sp.cos(ang / 2), 0, 0, sp.sin(ang / 2)) v = sp.Quaternion(0, *sp.symbols("x y z", real=True)) rot = lambda qq: sp.simplify((qq * v * qq.conjugate())) qa, qb, qc, qd = sp.symbols("qa qb qc qd", real=True) qg = sp.Quaternion(qa, qb, qc, qd) algemeen = sp.simplify(rot(qg) - rot(-qg)) == sp.Quaternion(0, 0, 0, 0) boek("F-T21b", "q en −q geven dezelfde afbeelding v ↦ q v q* voor een willekeurig quaternion q (symbolisch)", "algemeen", algemeen) boek("F-T21", "pad q(θ) = (cos θ/2, 0, 0, sin θ/2): q en −q dezelfde rotatie; q(2π) = −1, q(4π) = +1", f"q(2π) = {q(2*sp.pi)}, q(4π) = {q(4*sp.pi)}", sp.simplify(rot(q(th_)) - rot(-q(th_))) == sp.Quaternion(0, 0, 0, 0) and q(2 * sp.pi) == sp.Quaternion(-1, 0, 0, 0) and q(4 * sp.pi) == sp.Quaternion(1, 0, 0, 0)) # ── Foundations T23: constitutieve vergelijking ── g2, g3, n, nb = sp.symbols("g2 g3 n nbar") e = g2 / 2 * n**2 + g3 / 6 * n**3 gbar = g2 + g3 * nb; gam = g3 * nb / gbar; dl = (n - nb) / nb boek("F-T23", "g_eff = e''(n) = ḡ(1 + γδ) en g₂ = ḡ(1 − γ)", "symbolisch", sp.simplify(sp.diff(e, n, 2) - gbar * (1 + gam * dl)) == 0 and sp.simplify(g2 - gbar * (1 - gam)) == 0) # ── Foundations T24: hefboom van een vrij pad ── P = sp.symbols("P", positive=True) q_ = 1 - P s = sp.symbols("s") cgf = sp.log(q_ * sp.exp(s) / (1 - P * sp.exp(s))) k1 = sp.simplify(sp.diff(cgf, s).subs(s, 0)); k2 = sp.simplify(sp.diff(cgf, s, 2).subs(s, 0)); k3 = sp.simplify(sp.diff(cgf, s, 3).subs(s, 0)) lever = sp.simplify(-k1 * k3 / k2**2) waarden = {3: 0.3405373, 4: 0.1932017, 5: 0.1351786} boek("F-T24", "geometrische V: hefboom −n̄κ₃/κ₂² = −(1+P)/P (symbolisch)", f"hefboom {lever}", sp.simplify(lever + (1 + P) / P) == 0) # ── Physics T1: Q² = (E² − p² − m²)·1 in een 4×4-voorstelling ── E, m = sp.symbols("E m", real=True); px, py, pz = sp.symbols("p_x p_y p_z", real=True) s1, s2, s3 = sp.Matrix([[0, 1], [1, 0]]), sp.Matrix([[0, -sp.I], [sp.I, 0]]), sp.Matrix([[1, 0], [0, -1]]) I2 = sp.eye(2); kron = sp.kronecker_product qi, qj, qk = [kron(-sp.I * s, I2) for s in (s1, s2, s3)] # quaterniondelen vi, vj, vk = [kron(I2, s) for s in (s1, s2, s3)] # vectoreenheden pvec = px * vi + py * vj + pz * vk Q = sp.I * qk * E + qi * pvec + qj * m Q2 = sp.simplify(Q * Q) boek("P-T1", "Rowlands' nilpotente vorm: Q² = (E² − p² − m²)·𝟙 (quaternion-eenheden −iσ⊗1, vectoreenheden 1⊗σ)", "exact, symbolisch", sp.simplify(Q2 - (E**2 - px**2 - py**2 - pz**2 - m**2) * sp.eye(4)) == sp.zeros(4)) g0 = sp.Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, -1, 0], [0, 0, 0, -1]]) def gi(sig): return sp.Matrix(sp.BlockMatrix([[sp.zeros(2), sig], [-sig, sp.zeros(2)]])) g1, g2_, g3_ = gi(s1), gi(s2), gi(s3) g5 = sp.I * g0 * g1 * g2_ * g3_ Qd = g0 * E + g1 * px + g2_ * py + g3_ * pz + sp.I * g5 * m boek("P-T1b", "onafhankelijk met Dirac-matrices: Q = γ⁰E + γ·p + iγ⁵m geeft Q² = (E² − p² − m²)·𝟙", "exact, symbolisch", sp.simplify(Qd * Qd - (E**2 - px**2 - py**2 - pz**2 - m**2) * sp.eye(4)) == sp.zeros(4)) # ── Physics T2–T5 ── qv = sp.Matrix(sp.symbols("q1 q2 q3", real=True)); nv = sp.Matrix(sp.symbols("n1 n2 n3", real=True)); av = sp.Matrix(sp.symbols("a1 a2 a3", real=True)) QQ = sp.Quaternion(0, *qv); NN = sp.Quaternion(0, *nv); AA = sp.Quaternion(0, *av) QNA = QQ * NN * AA det = sp.Matrix.hstack(qv, nv, av).det() Vqna = -(qv.dot(nv)) * av + (qv.dot(av)) * nv - (nv.dot(av)) * qv S4 = (QNA * QQ).a eenheid = {qv[2]: sp.sqrt(1 - qv[0]**2 - qv[1]**2)} boek("P-T3", "zuivere quaternionen: S(QNA) = −det[q,n,a]; V(QNA) = −(q·n)a + (q·a)n − (n·a)q; bij |q| = 1: −V(QNA)·q = n·a en S(QNAQ) = n·a", "symbolisch", sp.expand(QNA.a + det) == 0 and all(sp.expand(x - y) == 0 for x, y in zip((QNA.b, QNA.c, QNA.d), Vqna)) and sp.simplify(S4.subs(eenheid) - nv.dot(av)) == 0 and sp.simplify((-sp.Matrix([QNA.b, QNA.c, QNA.d]).dot(qv)).subs(eenheid) - nv.dot(av)) == 0) D = [None, sp.Matrix(sp.symbols("d0 d1 d2 d3", real=True))] boek("P-T4", "ringmaat: spoor DDᵀ = |D|² (dus 1 voor eenheidsquaternionen); (−D)(−D)ᵀ = DDᵀ", "spoor 1; tekeninvariant", sp.simplify((D[1] * D[1].T).trace() - sum(x**2 for x in D[1])) == 0 and ((-D[1]) * (-D[1]).T - D[1] * D[1].T) == sp.zeros(4)) phi = lambda x, y, z: (x - 3 * z, y + 3 * z) boek("P-T5", "brug φ(x,y,z) = (x − 3z, y + 3z): snelheid S/T, energie T/S, impuls T²/S², massa T³/S³; kern z(3, −3, 1)", f"{phi(1,-1,0)}, {phi(2,-2,1)}, {phi(1,-1,1)}, {phi(0,0,1)}, kern {phi(3,-3,1)}", (phi(1, -1, 0), phi(2, -2, 1), phi(1, -1, 1), phi(0, 0, 1), phi(3, -3, 1)) == ((1, -1), (-1, 1), (-2, 2), (-3, 3), (0, 0))) # ════════ aanvullingen 28-10 (controle "alles of weg") ════════ # T7, tweede deel: onder sluitingen met alleen niet-nul stappen is een ontmoeting de kortste met winding 0, een ring de kortste met |w| = 1 kort = {} for L in range(1, 7): for wd in itertools.product((-1, 1), repeat=L): if sum(wd) % 3 == 0: wn = sum(wd) // 3 kort.setdefault(abs(wn), L) boek("F-T7b", "niet-nul stappen, lengte 1…6: kortste sluiting met winding 0 en met |winding| = 1", f"{kort}", kort.get(0) == 2 and kort.get(1) == 3) # T8, de telling: voor n = 3…9 precies 9 woorden die overal sluiten def overal(wd): return all((wd[i] + wd[i + 1] + wd[i + 2]) % 3 == 0 for i in range(len(wd) - 2)) t8 = [sum(1 for wd in itertools.product(T, repeat=n) if overal(wd)) for n in range(3, 10)] boek("F-T8b", "woorden die in elk venster sluiten, n = 3…9", f"{t8}", t8 == [9] * 7) # T9, rotatieklassen van ringen die overal sluiten: 5 als 3 | n, anders 3 (n = 3…9) def ringOveral(wd): n = len(wd); return all((wd[i] + wd[(i + 1) % n] + wd[(i + 2) % n]) % 3 == 0 for i in range(n)) klassen = {n: len({min(wd[i:] + wd[:i] for i in range(n)) for wd in itertools.product(T, repeat=n) if ringOveral(wd)}) for n in range(3, 10)} gelabeld = {n: sum(1 for wd in itertools.product(T, repeat=n) if ringOveral(wd)) for n in range(3, 10)} boek("F-T9b", "ringen die overal sluiten, n = 3…9: gelabeld 9 of 3, rotatieklassen 5 of 3", f"gelabeld {gelabeld}; klassen {klassen}", all(gelabeld[n] == (9 if n % 3 == 0 else 3) and klassen[n] == (5 if n % 3 == 0 else 3) for n in range(3, 10))) # T12.3: n ≥ 1 heeft ⌊log₃(2n − 1)⌋ + 1 cijfers (gehele getallen, n < 2·10⁵) def cijfers(n): d = 0 while (3**d - 1) // 2 < n: d += 1 return d def flog3(x): k = 0 while 3**(k + 1) <= x: k += 1 return k ok12 = all(cijfers(n) == flog3(2 * n - 1) + 1 for n in range(1, 200000)) boek("F-T12.3b", "aantal cijfers = ⌊log₃(2n − 1)⌋ + 1 voor 1 ≤ n < 2·10⁵, met gehele getallen", "alle gelijk" if ok12 else "afwijking", ok12) # Fox-driekleuring: 2b ≡ a + c (mod 3) ⇔ de drie kleuren zijn gelijk of alle verschillend fox_regel = all(((2 * b - a - c) % 3 == 0) == ((a == b == c) or len({a, b, c}) == 3) for a in range(3) for b in range(3) for c in range(3)) boek("Fox", "de Fox-regel op een kruising (2b ≡ a + c mod 3) is de vensterregel van T4: gelijk of alle drie verschillend", f"regel {fox_regel}", fox_regel) # T17: de kleinste record-afstand moet ver boven de rekenfout liggen mink = min(abs(k * th - mp.nint(k * th)) for k in verwacht) boek("F-T17b", "kleinste record-afstand tegen de rekenfout (80 cijfers, k ≤ 10⁶)", f"min {mp.nstr(mink, 4)}", mink > mp.mpf(10)**-60) # T24: de terugkeerkansen P₃, P₄, P₅ zelf nagerekend: u_d = ∫₀^∞ e^{−t} I₀(t/d)^d dt, P_d = 1 − 1/u_d; # P₃ ook uit de gesloten vorm u₃ = √6/(32π³) Γ(1/24)Γ(5/24)Γ(7/24)Γ(11/24) (twee onafhankelijke wegen) mp.mp.dps = 30 u3w = mp.sqrt(6) / (32 * mp.pi**3) * mp.gamma(mp.mpf(1) / 24) * mp.gamma(mp.mpf(5) / 24) * mp.gamma(mp.mpf(7) / 24) * mp.gamma(mp.mpf(11) / 24) def ud(d): return mp.quad(lambda tt: mp.exp(-tt) * mp.besseli(0, tt / d)**d, [0, 10, 100, mp.inf]) Pd = {d: 1 - 1 / ud(d) for d in (3, 4, 5)} P3w = 1 - 1 / u3w okP = abs(P3w - mp.mpf("0.3405373")) < 5e-7 and all(abs(Pd[d] - mp.mpf(v)) < 5e-7 for d, v in waarden.items()) gam_ber = [round(float(-(1 + Pd[d]) / Pd[d]), 4) for d in (3, 4, 5)] okP = okP and gam_ber == [-3.9365, -6.1759, -8.3976] boek("F-T24b", "P₃, P₄, P₅ nagerekend (gesloten Γ-vorm voor P₃; integraal met Bessel-I₀ voor alle drie) tegen 0,3405373 · 0,1932017 · 0,1351786", f"Γ-vorm {mp.nstr(P3w, 9)}; integraal {[mp.nstr(Pd[d], 9) for d in (3, 4, 5)]}; γ uit de berekende P_d {gam_ber}", okP) # Physics T2 met echte vectoren: |q + a|² − |q − a|² = 4 q·a (dus 4c voor eenheidsvectoren) q3 = sp.Matrix(sp.symbols("u1 u2 u3", real=True)); a3 = sp.Matrix(sp.symbols("w1 w2 w3", real=True)) pol = sp.expand((q3 + a3).dot(q3 + a3) - (q3 - a3).dot(q3 - a3) - 4 * q3.dot(a3)) == 0 boek("P-T2b", "polarisatie-identiteit met symbolische vectoren", "exact", pol) # Physics T4: xᵀ(DDᵀ)x = (D·x)² ≥ 0 (positief semidefiniet) en het uitgewerkte voorbeeld R_Q = (1 + D₁·D₂)/2 xs = sp.Matrix(sp.symbols("x0:4", real=True)); Dd = sp.Matrix(sp.symbols("e0:4", real=True)) psd = sp.expand((xs.T * (Dd * Dd.T) * xs)[0] - (Dd.dot(xs))**2) == 0 d1 = sp.Matrix([1, 0, 0, 1]) / sp.sqrt(2) d2 = sp.Matrix([sp.Rational(653, 1000), -sp.Rational(653, 1000), -sp.Rational(271, 1000), sp.Rational(271, 1000)]) Bv = (d1 * d1.T + d2 * d2.T) / 2 lam = max(sp.N(ev) for ev in Bv.eigenvals()) boek("P-T4b", "PSD-identiteit symbolisch; voorbeeld uit de editie: λ₁ van B met D₁, D₂ (afgerond op 3 cijfers) ≈ 0,827", f"psd {psd}; λ₁ = {sp.N(lam, 4)}; (1 + D₁·D₂)/2 = {sp.N((1 + d1.dot(d2)) / 2, 4)}", psd and abs(float(lam) - 0.827) < 2e-3 and abs(float(lam) - float((1 + d1.dot(d2)) / 2)) < 2e-3) # Physics T5: de kern van φ is precies z·(3, −3, 1) xx, yy, zz = sp.symbols("x y z") kern = sp.linsolve([xx - 3 * zz, yy + 3 * zz], [xx, yy, zz]) # energie per tijd = 1/S; massa · beweging² = energie; S ↔ T verwisselen is een involutie die beweging op energie afbeeldt spl = lambda u, v: (u[0] + v[0], u[1] + v[1]); neg = lambda u: (-u[0], -u[1]); wissel = lambda u: (u[1], u[0]) energie, tijd, massa, beweging = phi(2, -2, 1), phi(0, 1, 0), phi(0, 0, 1), phi(1, -1, 0) ok5 = spl(energie, neg(tijd)) == (-1, 0) and spl(massa, spl(beweging, beweging)) == energie and wissel(wissel(beweging)) == beweging and wissel(beweging) == energie boek("P-T5c", "energie/tijd = 1/S; massa·beweging² = energie; S↔T is een involutie en stuurt beweging naar energie (exponenten van S en T)", f"energie/tijd {spl(energie, neg(tijd))}; m·v² {spl(massa, spl(beweging, beweging))}; wissel(v) {wissel(beweging)}", ok5) boek("P-T5b", "kern van φ: alle oplossingen van x − 3z = 0, y + 3z = 0", f"{kern}", kern == sp.FiniteSet((3 * zz, -3 * zz, zz))) json.dump({"bron": "Foundations 9.2 + Physics 9.0 (docs/vacuum-net-canon.md)", "toetsen": uit, "geslaagd": sum(x["geslaagd"] for x in uit), "totaal": len(uit)}, open(os.path.join(UIT, "exact-meting.json"), "w"), ensure_ascii=False, indent=1) h = hashlib.sha256(open(os.path.join(UIT, "exact-meting.json"), "rb").read()).hexdigest() open(os.path.join(UIT, "exact-meting.sha256"), "w").write(h + " exact-meting.json\n") for x in uit: print(("✓" if x["geslaagd"] else "✗"), x["id"], "—", x["uitkomst"][:110]) print(f"{sum(x['geslaagd'] for x in uit)}/{len(uit)} geslaagd")