topographo 0.1.0rc1__tar.gz

topographo-0.1.0rc1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 The Swan Factory
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

topographo-0.1.0rc1/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: topographo
+Version: 0.1.0rc1
+Summary: Reusable Cayley-Dickson and sedenion settlement math for Topographo.
+Author: The Swan Factory
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/TheSwanFactory/occurence
+Project-URL: Documentation, https://theswanfactory.github.io/occurence/
+Project-URL: Source, https://github.com/TheSwanFactory/occurence
+Project-URL: Issues, https://github.com/TheSwanFactory/occurence/issues
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# Occurrence Theory
+
+This repository contains a draft research paper and verification script for
+Occurrence Theory (OT), defined as an oriented form of Sedenion Settlement
+Dynamics (SSD).
+
+The central object is the Aut-invariant settlement channel on the sedenion
+zero-divisor crack. The paper separates theorem, exact computation,
+measurement, interpretation, and conjecture using explicit ledger tags:
+
+- `[T]` theorem
+- `[C]` computation
+- `[M]` measurement
+- `[I]` interpretation
+- `[X]` conjecture
+
+## Files
+
+- `topographo/` - reusable Python package for Cayley-Dickson algebra,
+  validation gates, operators, and SSD helpers.
+- `occurrence-theory.md` - main paper draft.
+- `occurrence_theory_audit.py` - numerical audit and verification script for
+  the algebraic claims.
+- `exceptional_algebras_lab.py` - supporting exceptional algebra reproduction
+  module used by the audit.
+- `occurrence_theory_prompt.md` - source prompt and writing constraints used to
+  generate the paper.
+- `.github/workflows/audit.yml` - CI workflow that compiles and runs the audit
+  scripts.
+- `LICENSE` - MIT license.
+
+## Requirements
+
+The audit script requires Python 3.11 or newer and NumPy. The verified
+`exceptional_algebras_lab` module is included in this repository and is used by
+the audit at runtime.
+
+`uv` is the preferred runner for local audit work:
+
+```bash
+uv run python occurrence_theory_audit.py
+```
+
+For editable package installation:
+
+```bash
+uv pip install -e .
+```
+
+After installation, the core math layer is importable without running the
+Occurrence Theory audit narrative:
+
+```python
+from topographo.core import CayleyDicksonAlgebra, verify_gates
+from topographo.ssd import SedenionAlgebra
+```
+
+API documentation is generated with `pdoc` and published to GitHub Pages:
+<https://theswanfactory.github.io/occurence/>
+
+To build it locally:
+
+```bash
+uv run pdoc \
+  topographo \
+  topographo.core \
+  topographo.core.algebra \
+  topographo.core.cayley_dickson \
+  topographo.core.gates \
+  topographo.ssd \
+  topographo.ssd.channel \
+  topographo.ssd.sedenion \
+  -o site
+```
+
+## Run the Audit
+
+From the repository root:
+
+```bash
+uv run python occurrence_theory_audit.py
+```
+
+To save the output:
+
+```bash
+uv run python occurrence_theory_audit.py > audit_results.txt
+```
+
+After installation, the same audit is also available as:
+
+```bash
+occurrence-theory-audit
+```
+
+CI runs the audit workflow on pull requests and pushes to `main`.
+
+## Status
+
+This is a research workspace, not a packaged library. The paper is the primary
+artifact; the script is included to reproduce the computation-backed claims.
+
+## License
+
+MIT. See `LICENSE`.

topographo-0.1.0rc1/README.md

@@ -0,0 +1,105 @@
+# Occurrence Theory
+
+This repository contains a draft research paper and verification script for
+Occurrence Theory (OT), defined as an oriented form of Sedenion Settlement
+Dynamics (SSD).
+
+The central object is the Aut-invariant settlement channel on the sedenion
+zero-divisor crack. The paper separates theorem, exact computation,
+measurement, interpretation, and conjecture using explicit ledger tags:
+
+- `[T]` theorem
+- `[C]` computation
+- `[M]` measurement
+- `[I]` interpretation
+- `[X]` conjecture
+
+## Files
+
+- `topographo/` - reusable Python package for Cayley-Dickson algebra,
+  validation gates, operators, and SSD helpers.
+- `occurrence-theory.md` - main paper draft.
+- `occurrence_theory_audit.py` - numerical audit and verification script for
+  the algebraic claims.
+- `exceptional_algebras_lab.py` - supporting exceptional algebra reproduction
+  module used by the audit.
+- `occurrence_theory_prompt.md` - source prompt and writing constraints used to
+  generate the paper.
+- `.github/workflows/audit.yml` - CI workflow that compiles and runs the audit
+  scripts.
+- `LICENSE` - MIT license.
+
+## Requirements
+
+The audit script requires Python 3.11 or newer and NumPy. The verified
+`exceptional_algebras_lab` module is included in this repository and is used by
+the audit at runtime.
+
+`uv` is the preferred runner for local audit work:
+
+```bash
+uv run python occurrence_theory_audit.py
+```
+
+For editable package installation:
+
+```bash
+uv pip install -e .
+```
+
+After installation, the core math layer is importable without running the
+Occurrence Theory audit narrative:
+
+```python
+from topographo.core import CayleyDicksonAlgebra, verify_gates
+from topographo.ssd import SedenionAlgebra
+```
+
+API documentation is generated with `pdoc` and published to GitHub Pages:
+<https://theswanfactory.github.io/occurence/>
+
+To build it locally:
+
+```bash
+uv run pdoc \
+  topographo \
+  topographo.core \
+  topographo.core.algebra \
+  topographo.core.cayley_dickson \
+  topographo.core.gates \
+  topographo.ssd \
+  topographo.ssd.channel \
+  topographo.ssd.sedenion \
+  -o site
+```
+
+## Run the Audit
+
+From the repository root:
+
+```bash
+uv run python occurrence_theory_audit.py
+```
+
+To save the output:
+
+```bash
+uv run python occurrence_theory_audit.py > audit_results.txt
+```
+
+After installation, the same audit is also available as:
+
+```bash
+occurrence-theory-audit
+```
+
+CI runs the audit workflow on pull requests and pushes to `main`.
+
+## Status
+
+This is a research workspace, not a packaged library. The paper is the primary
+artifact; the script is included to reproduce the computation-backed claims.
+
+## License
+
+MIT. See `LICENSE`.

topographo-0.1.0rc1/exceptional_algebras_lab.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+"""
+Exceptional Topography of G2 and F4 Varieties -- reproduction script.
+
+Self-contained (numpy only) reproduction of the headline numerical results in
+"The Exceptional Topography of G_2 and F_4 Varieties: Deformation Dynamics and
+Morse-Bott Singularities":
+
+  1. Octonions O via Cayley-Dickson  ->  dim Der(O) = dim g2 = 14
+  2. Albert algebra J3(O)            ->  dim Der(J3(O)) = dim f4 = 52
+  3. F4-invariant cubic determinant  ->  derivations annihilate det
+  4. det is indefinite on the trace hypersphere (the F4 "crack")
+  5. Peirce decomposition at a primitive idempotent E1 -> (1, 16, 10)
+  6. Hessian signature of det at E1  ->  (+1, -9, 0^17), Morse index 9
+  7. (optional) anisotropy audit of the octonion cubic well from the CSV
+
+Everything is measured under scale-RELATIVE tolerances and cross-checked; no
+result is assumed. Run:  python3 exceptional_algebras_lab.py
+"""
+import numpy as np
+
+# ----------------------------------------------------------------------
+# Octonions via the Cayley-Dickson construction (R -> C -> H -> O)
+# ----------------------------------------------------------------------
+def cayley_dickson_table(dim):
+    """Structure tensor C[i,j,k] with (e_i e_j) = sum_k C[i,j,k] e_k."""
+    def mul(a, b):
+        n = len(a)
+        if n == 1:
+            return np.array([a[0] * b[0]])
+        h = n // 2
+        a1, a2, b1, b2 = a[:h], a[h:], b[:h], b[h:]
+        conj = lambda x: np.concatenate([[x[0]], -x[1:]])
+        z1 = mul(a1, b1) - mul(conj(b2), a2)
+        z2 = mul(b2, a1) + mul(a2, conj(b1))
+        return np.concatenate([z1, z2])
+    C = np.zeros((dim, dim, dim))
+    for i in range(dim):
+        for j in range(dim):
+            ei, ej = np.zeros(dim), np.zeros(dim)
+            ei[i] = ej[j] = 1.0
+            C[i, j] = mul(ei, ej)
+    return C
+
+def relative_nullity(M, rel=1e-9):
+    """Nullity of the domain of M under a scale-RELATIVE cutoff."""
+    s = np.linalg.svd(M, compute_uv=False)
+    cols = M.shape[1]
+    rank = int((s > s.max() * rel).sum())
+    return cols - rank, s
+
+# ----------------------------------------------------------------------
+# 1 + 2. Derivation-defect map for any algebra given its structure tensor
+# ----------------------------------------------------------------------
+def defect_matrix(mu):
+    """
+    Linear map Delta: End(A) -> Hom(A x A, A) sending L to
+        B_L(x,y) = L(x*y) - L(x)*y - x*L(y).
+    Kernel of Delta = derivations of the algebra with tensor mu.
+    Returns the (n^3, n^2) matrix.
+    """
+    n = mu.shape[0]
+    D = np.zeros((n, n, n, n, n))
+    for c in range(n):
+        D[:, :, c, c, :] += mu
+    for a in range(n):
+        D[a, :, :, :, a] -= mu.transpose(1, 2, 0)
+    for b in range(n):
+        D[:, b, :, :, b] -= mu.transpose(0, 2, 1)
+    return D.reshape(n**3, n**2)
+
+def derivations(mu, rel=1e-9):
+    """Orthonormal basis of Der(A) as (k, n, n)."""
+    n = mu.shape[0]
+    Delta = defect_matrix(mu)
+    _, s, Vt = np.linalg.svd(Delta, full_matrices=False)
+    rank = int((s > s.max() * rel).sum())
+    return Vt[rank:].reshape(-1, n, n)
+
+# ----------------------------------------------------------------------
+# Albert algebra J3(O): 3x3 Hermitian octonion matrices, 27-dimensional
+# ----------------------------------------------------------------------
+class Albert:
+    SLOTS = [(0, 1), (1, 2), (0, 2)]  # off-diagonal octonion positions
+
+    def __init__(self):
+        self.C8 = cayley_dickson_table(8)
+        self.mu = self._structure_tensor()          # (27,27,27), sym in (a,b)
+        self.T = np.zeros(27); self.T[:3] = 1.0      # trace linear form
+        self.I = np.zeros(27); self.I[:3] = 1.0      # Jordan identity
+
+    def _omul(self, a, b):
+        return np.einsum('i,j,ijk->k', a, b, self.C8)
+
+    def _oconj(self, a):
+        r = -a.copy(); r[0] = a[0]; return r
+
+    def _basis_mat(self, idx):
+        M = np.zeros((3, 3, 8))
+        if idx < 3:
+            M[idx, idx, 0] = 1.0; return M
+        idx -= 3; s, t = divmod(idx, 8); i, j = self.SLOTS[s]
+        u = np.zeros(8); u[t] = 1.0
+        M[i, j] = u; M[j, i] = self._oconj(u); return M
+
+    def _mat_to_vec(self, M):
+        v = np.zeros(27)
+        for d in range(3):
+            v[d] = M[d, d, 0]
+        for s, (i, j) in enumerate(self.SLOTS):
+            v[3 + 8 * s: 11 + 8 * s] = M[i, j]
+        return v
+
+    def _matmul3(self, X, Y):
+        Z = np.zeros((3, 3, 8))
+        for i in range(3):
+            for k in range(3):
+                for j in range(3):
+                    Z[i, k] += self._omul(X[i, j], Y[j, k])
+        return Z
+
+    def _jordan(self, X, Y):
+        return 0.5 * (self._matmul3(X, Y) + self._matmul3(Y, X))
+
+    def _structure_tensor(self):
+        B = [self._basis_mat(k) for k in range(27)]
+        mu = np.zeros((27, 27, 27))
+        for a in range(27):
+            for b in range(27):
+                mu[a, b] = self._mat_to_vec(self._jordan(B[a], B[b]))
+        return mu
+
+    def prod(self, x, y):
+        return np.einsum('a,b,abc->c', x, y, self.mu)
+
+    def det(self, X):
+        """F4-invariant cubic via the trace-power formula (basis-free)."""
+        X2 = self.prod(X, X); X3 = self.prod(X, X2)
+        t1, t2, t3 = self.T @ X, self.T @ X2, self.T @ X3
+        return (t1**3 - 3 * t1 * t2 + 2 * t3) / 6.0
+
+    def trace_form(self):
+        return np.einsum('abc,c->ab', self.mu, self.T)
+
+    def left_mult(self, X):
+        return np.einsum('a,abc->cb', X, self.mu)
+
+
+# ----------------------------------------------------------------------
+# Analyses
+# ----------------------------------------------------------------------
+def octonion_g2():
+    C8 = cayley_dickson_table(8)
+    dim, _ = relative_nullity(defect_matrix(C8))
+    print(f"[1] dim Der(O) = {dim}   (expected dim g2 = 14)")
+    assert dim == 14
+    return dim
+
+def albert_f4(alb):
+    dim, s = relative_nullity(defect_matrix(alb.mu))
+    ssort = np.sort(s)
+    print(f"[2] dim Der(J3(O)) = {dim}   (expected dim f4 = 52)")
+    print(f"    singular-value gap: {ssort[dim-1]:.2e} | {ssort[dim]:.2e}")
+    assert dim == 52
+    return dim
+
+def determinant_checks(alb):
+    print(f"[3] det(diag(2,3,5)) = {alb.det(np.array([2,3,5]+[0]*24, float)):.4f}  (expected 30)")
+    Der = derivations(alb.mu)
+    rng = np.random.default_rng(1); eps = 1e-5; worst = 0.0
+    for _ in range(40):
+        X = rng.standard_normal(27); D = Der[rng.integers(len(Der))]
+        worst = max(worst, abs((alb.det(X + eps*(D@X)) - alb.det(X - eps*(D@X))) / (2*eps)))
+    print(f"    max |D.det| over derivations = {worst:.2e}  (F4-invariance => ~0)")
+    return Der
+
+def crack_the_sphere(alb, n_samples=200000):
+    G = alb.trace_form()
+    L = np.linalg.cholesky(G)
+    rng = np.random.default_rng(0); vals = np.empty(n_samples)
+    for i in range(n_samples):
+        v = np.linalg.solve(L.T, rng.standard_normal(27))
+        v /= np.sqrt(v @ G @ v)
+        vals[i] = alb.det(v)
+    print(f"[4] det on unit trace-hypersphere in [{vals.min():+.3f}, {vals.max():+.3f}]; "
+          f"crosses 0: {vals.min() < 0 < vals.max()}")
+
+def peirce_and_hessian(alb):
+    E1 = np.zeros(27); E1[0] = 1.0
+    I = np.eye(27); h = 1e-2
+    grad = np.array([(alb.det(E1+h*I[i]) - alb.det(E1-h*I[i])) / (2*h) for i in range(27)])
+    print(f"[5] ||grad det(E1)|| = {np.linalg.norm(grad):.2e}  (E1 is a singular/critical point)")
+
+    # exact Hessian (pure cubic -> central mixed differences exact)
+    H = np.zeros((27, 27))
+    for i in range(27):
+        for j in range(27):
+            H[i, j] = (alb.det(E1+h*I[i]+h*I[j]) - alb.det(E1+h*I[i]-h*I[j])
+                       - alb.det(E1-h*I[i]+h*I[j]) + alb.det(E1-h*I[i]-h*I[j])) / (4*h*h)
+    H = 0.5 * (H + H.T)
+
+    LE = alb.left_mult(E1); LE = 0.5 * (LE + LE.T)
+    w, V = np.linalg.eigh(LE)
+    blocks = {"P1 (radial, lam=1)":   V[:, np.abs(w-1.0) < 1e-6],
+              "P_1/2 (OP^2, lam=1/2)": V[:, np.abs(w-0.5) < 1e-6],
+              "P0 (J2(O), lam=0)":     V[:, np.abs(w-0.0) < 1e-6]}
+    print("[6] Hessian of det at E1, per Peirce block:")
+    tol = 1e-6 * np.max(np.abs(H))
+    for name, B in blocks.items():
+        ev = np.linalg.eigvalsh(B.T @ H @ B)
+        pos = int((ev > tol).sum()); neg = int((ev < -tol).sum()); nul = int((np.abs(ev) <= tol).sum())
+        print(f"    {name:24s} dim={B.shape[1]:2d}  signature (+{pos}, -{neg}, 0x{nul})")
+    ev = np.linalg.eigvalsh(H)
+    pos = int((ev > tol).sum()); neg = int((ev < -tol).sum()); nul = int((np.abs(ev) <= tol).sum())
+    print(f"    {'OVERALL':24s} dim=27  signature (+{pos}, -{neg}, 0x{nul})  Morse index = {neg}")
+
+def octonion_anisotropy(csv_path="octonion_cubic_cross_variation.csv"):
+    import csv, os
+    if not os.path.exists(csv_path):
+        print(f"[7] (skipped: {csv_path} not found)"); return
+    rows = [r for r in csv.reader(open(csv_path))][1:]
+    A = np.zeros((28, 28, 28, 28))
+    for r in rows:
+        if r:
+            A[int(r[0]), int(r[1]), int(r[2]), int(r[3])] = float(r[4])
+    H = A[1:, 1:, 1:, 1:]; d = 27; I = np.eye(d)
+    P = (np.einsum('oi,jk->oijk', I, I) + np.einsum('oj,ik->oijk', I, I)
+         + np.einsum('ok,ij->oijk', I, I)) / 3
+    c = np.sum(H * P) / np.sum(P * P)
+    iso = c * P; aniso = H - iso
+    print(f"[7] octonion cubic well anisotropy audit:")
+    print(f"    pure-27 anisotropic/isotropic norm ratio = "
+          f"{np.linalg.norm(aniso)/np.linalg.norm(iso):.1%}  (isotropic well => 0%)")
+    print(f"    tr(h^3)->conformal channel norm = {np.linalg.norm(A[0,1:,1:,1:]):.4f}  (isotropic => 0)")
+    print("    => the G2 well is STABLE but ANISOTROPIC (symmetry is G2, not O(27)).")
+
+
+def albert_g2_decomposition(alb):
+    """Lift g2 = Der(O) into f4 = Der(J3(O)) and decompose the 27 as a g2-module."""
+    g2 = derivations(cayley_dickson_table(8))
+    def lift(D):
+        M = np.zeros((27, 27))
+        for s in range(3):
+            M[3 + 8*s: 11 + 8*s, 3 + 8*s: 11 + 8*s] = D
+        return M
+    G = [lift(D) for D in g2]
+    rng = np.random.default_rng(0); worst = 0.0
+    for Dh in G:
+        for _ in range(5):
+            x = rng.standard_normal(27); y = rng.standard_normal(27)
+            b = alb.prod(Dh@x, y) + alb.prod(x, Dh@y) - Dh @ alb.prod(x, y)
+            worst = max(worst, np.linalg.norm(b))
+    s = np.linalg.svd(np.vstack(G), compute_uv=False)
+    inv = 27 - int((s > s.max()*1e-9).sum())
+    Cas = sum(Dh @ Dh for Dh in G)
+    ev = np.linalg.eigvalsh(0.5*(Cas + Cas.T))
+    vals, cnts = np.unique(np.round(ev, 4), return_counts=True)
+    print(f"[8] g2 lifted into f4: residual defect on J3(O) = {worst:.2e}")
+    print(f"    g2-invariants in the 27 = {inv}   Casimir spectrum = "
+          f"{ {float(v): int(c) for v, c in zip(vals, cnts)} }")
+    print(f"    => J3(O) = 1^(+6) (+) 7^(+3) under g2  (6 trivial + 3x7)")
+
+
+if __name__ == "__main__":
+    print("=" * 68)
+    octonion_g2()
+    alb = Albert()
+    albert_f4(alb)
+    determinant_checks(alb)
+    crack_the_sphere(alb)
+    peirce_and_hessian(alb)
+    albert_g2_decomposition(alb)
+    octonion_anisotropy()
+    print("=" * 68)