Four U.S. Nonprovisional Applications Filed October 2026 · 19/833,766 · 19/833,809 · 19/833,804 · Seed Application (priority 64/067,703)

We design the mathematics that more capable, verifiable AI requires.
We build and test the architecture.

Logarchéon's seed architecture combines three components: global coordination (CEAS), causal reasoning (Ψ), and invariant geometric representation (GRAIL). Each component is specified, and each has been built and tested at research scale.

Logarchéon eight-pointed star mark
Core thesis

Scaling grows the machine. CEAS coordinates it globally. The Ψ-operator supplies causal operator logic. GRAIL supplies invariant geometric cognition. Our thesis: scalable, reliable real-world AI needs all three. As a structural research programme, the same architecture is also being developed to seek correspondences with established physics across scales — from condensed-matter criticality to gravitation and cosmology — without adding postulates beyond what each domain already requires.

Three core components

The Seed Architecture

01 / 03
CEAS
Critical Entropy Attention Scaling

A nonlocal collective coordination variable φ(t) that brings the number of coordination rounds below the graph diameter, resolving the coordination bottleneck that limits locally bounded architectures at scale. Grounded in finite-size criticality and thermodynamic phase analysis. Initialises via a single forward-pass measurement.

Design rationale: in locally bounded architectures, the number of coordination rounds grows with system size. A global coordination channel removes that bottleneck.
02 / 03
Ψ-Operator
Causal Operator Framework

A family of maps Ψα : X × U × C → X with causal semantics that distinguish observed correlation P(Y|X) from intervened outcomes P(Y|do(X=x)), enabling certified reasoning about consequences of actions — not merely patterns in prior data. Supports constrained inverse reasoning and safe behavioural editing without retraining.

Design rationale: two causal models can agree on all observations yet disagree on interventions. Correlation-only systems cannot identify intervention-sensitive behaviours regardless of training data volume.
03 / 03
GRAIL
Geometric Representation Algebra for Intelligent Learning

Computations generated from group-preserved invariants I(gq, gk) = I(q, k), replacing coordinate-dependent inner products so that generalisation is orbit-consistent across symmetry groups. Produces infinite families of distinct but functionally identical twin models. Root insight: general relativity study, 2009–2010.

Design rationale: invariant primitives make orbit-consistent generalisation hold by construction, not by coverage of training data.
Research foundations

Design principles

Each component answers a distinct engineering constraint. The technical brief sets out the principles and the tests behind them.

Principle · Coordination

A global coordination channel reduces coordination rounds.

Principle · Causality

Two causal models can agree on all observations yet disagree on interventions.

Principle · Invariance

Invariant kernels generalise across a symmetry orbit by construction.

Evaluation · Triad

The complete triad outperforms its reduced variants in a pre-registered ablation, complete at research scale.

Mathematical foundations

The mathematics of the architecture is algebraic, not statistical

Statistical mathematics — necessary but not sufficient

Answers: given data, how well can a function be approximated?

Gradient descent, probably approximately correct (PAC) learning, Vapnik–Chervonenkis (VC) dimension, measure-theoretic probability, stochastic processes, random matrix theory — this tradition is largely answered at the engineering level. Transformers trained with Adam on cross-entropy loss work. The theory for why they generalise exists.

Statistical math remains foundational for training dynamics, generalisation bounds, information theory (entropy H(β) in CEAS), and Bayesian inference in the Ψ-causal layer. It is not replaced — it is de-centred.

Algebraic mathematics — where the frontier lives

Answers: what can a system structurally represent, regardless of data volume?

Category theory, algebraic topology, algebraic combinatorics, representation theory, number theory (automorphic forms, Langlands programme), algebraic geometry (moduli spaces), programming language theory (PLT; type theory). These fields describe what an architecture can represent, independent of data volume.

The GRAIL kernel is an automorphic (Γ-invariant) kernel. Coordination limits are graph-theoretic; causal identifiability is a question of logic. Each calls for an algebraic solution.

Historical analogy — physics underwent the same transition
Newton
Calculus, classical analysis
Statistical mechanics
Probability theory, thermodynamics
Quantum mechanics
Linear algebra, group theory, symmetry
QFT / Standard Model
Algebraic topology, differential geometry, gauge theory
Architecture frontier ← here
Category theory, type theory, automorphic forms, moduli spaces

Each transition preserved the previous mathematics as infrastructure. Calculus did not stop mattering when group theory entered. Statistics does not stop mattering when algebraic structure enters.

There is a second meaning in this progression. Each new mathematical tool did not merely solve existing problems more efficiently — it made previously invisible problems visible for the first time. Differential geometry did not improve Newtonian calculations; it made gauge invariance a question that could be asked. Group theory did not speed up classical mechanics; it revealed that every continuous symmetry carries a conservation law. The tool creates the visibility.

This is the operating principle of Logarchéon: whenever possible, solve the core architecture problem correctly first — using the right mathematics at the right level of the stack — and then apply it to whatever other domains it reaches for humanity. Not because AI architecture is more important than those domains, but because a correctly built architecture will reveal problems in those domains that cannot yet be formulated, the way calculus made celestial mechanics possible not by improving arithmetic but by doing three things at once: making a new class of problem statable for the first time, providing the mechanism to solve it, and encoding in its own structure the clues about where solutions are to be found. The tool asks, enables, and guides simultaneously.

Where each mathematical tradition sits in the AI stack
Formal verification
Type theory, proof theory, PLT — Lean 4, Coq
Recursive self-improvement (RSI) gate: incorrect proof = compile error
Architecture design
Algebraic topology, group theory, automorphic forms, category theory
GRAIL invariant kernel, CEAS phase structure, Langlands connection
Causal reasoning
Logic, graph theory, combinatorics — Racket, SWI-Prolog
Ψ-causal layer: do-calculus, counterfactuals, inverse design
Training dynamics
Statistical physics, information theory, stochastic optimisation
Entropy H(β) in CEAS; gradient descent; Adam
Generalisation theory
PAC learning, VC theory, random matrix theory (RMT) (bridge field: also algebraic via Montgomery’s conjecture)
Eigenvalue structure of weight matrices; scaling law verification
Data & loss
Measure theory, probability — infrastructure layer
Cross-entropy loss, dataset construction, evaluation metrics

Algebraic mathematics occupies the top of the stack. Statistical mathematics is the bottom. The bottom is infrastructure. The frontier is at the top.

Algebraic topology

Persistent homology tracks which features survive training. Coordination-round bounds depend on graph diameter.

Number theory & Langlands

The GRAIL automorphic kernel Kβ(q,k) = ∑γ∈Γ exp(−β d(q,γk)) is an automorphic (Γ-invariant) kernel. The Langlands programme connects symmetry groups to analytic objects; GRAIL takes its kernel from the automorphic side of that correspondence.

Category theory as unifier

Category theory is not one more algebraic field — it is the language that connects all the others. Markov categories contain probability theory as a special case. The Curry–Howard–Lambek correspondence unifies type theory, logic, and category theory.

Algebraic geometry

The space of all model architectures with a given property is a moduli space. The MIA migration tiers are a stratification of this space. Deforming a model via RSI is a path in this geometric space.

PLT as computational face

Programming language theory is not separate from the algebraic fields — it is their computational instantiation. Homotopy type theory: types are read as spaces, and equalities as paths.

RMT as bridge field

Random matrix theory bridges both traditions. Statistical side: eigenvalue structure of weight matrices and Hessians. Algebraic side: Montgomery’s conjecture connects RMT to the Riemann zeta function. RMT is being enriched by both directions simultaneously.

“Statistical mathematics tells how well a system approximates. Algebraic mathematics tells what a system can and cannot represent. For building systems beyond today’s AI, the binding constraint is representational — what the architecture can structurally express — not approximation quality.”

Architecture class comparison

Why this is not ANI — and why scaling alone does not get there

ANI (Artificial Narrow Intelligence) — systems restricted to bounded tasks or domains, including every current large-scale language model built on next-token prediction and parameter scaling: GPT-4 through GPT-6, Claude, Gemini, Grok, DeepSeek, Qwen, and their successors. The seed architecture targets robust transfer to new task families not represented in training, measured on the certification ladder.

The distinction between these tiers is not about benchmark scores or parameter count. It is architectural and mathematical. The table below is derived directly from the formal certification criteria and scenario analysis in the lecture notes (v21.65).

ANI / Current frontier LLMs
GPT‑4–6 · Claude · Gemini · all scaling‑law models
Logarchéon seed architecture
CEAS + Ψ‑Operator + GRAIL
Causal reasoning
Observational correlation only — learns P(Y | X). Cannot distinguish correlation from causal consequence. Wrapping in "think step by step" prompts does not change the underlying computation.
All four Pearl rungs, built at research scale: association, intervention P(Y | do(X)), counterfactual Yx′, and constrained inverse design. The Ψ-operator implements do-calculus natively — not as a prompt wrapper.
Geometric representation
Euclidean inner product q⊤k as the fundamental primitive — coordinate-dependent by construction. Orbit consistency has to be learned from examples rather than holding by construction.
GRAIL replaces the Euclidean dot product with a metric-invariant primitive I(gq, gk) = I(q, k). The root: Einstein's general covariance principle (1915) — physical laws must be written in tensor form, so that they hold in every coordinate system. Neural dot products q⊤k are coordinate-dependent and lose information under coordinate changes. With orbit canonicalisation, GRAIL’s representation retains every observable that is invariant under the symmetry group — proved in Lean 4 and checked numerically — regardless of which coordinate system the data arrives in.
Global coordination
Local fixed-β attention. On globally sensitive problems, the number of coordination rounds grows with system size.
CEAS adds a global feedback channel carrying collective statistics φ(t). Each node reads the channel and contributes to it, so coordination does not wait on graph distance.
Self-improvement
Weights frozen at inference. AI-assisted R&D (RSI Levels 3–5) exists at frontier labs; autonomous closed-loop successor design (RSI Levels 7–8) is not publicly demonstrated.
A verified closed RSI loop, running at research scale: propose → implement → train → evaluate → verify → deploy. No manual edits inside the measured cycle. Improvement logged and falsifiable.
Cross-domain transfer
Transfers surface distributional features — succeeds when new tasks resemble training data. Causal mechanisms are not extracted from structural equations and are not portable across environments with different surface statistics: a correlation-only system cannot separate the causal effect of an intervention from back-door confounding paths, regardless of scale or fine-tuning.
Transfers structural operators to untrained domains — verified by pre-committed cryptographic hash of the hidden benchmark. Because transfer operates at the level of causal, geometric, and operator structure rather than surface patterns, the architecture is designed to generalise structurally rather than by distributional similarity. Causal mechanism transfer across environments with different surface statistics has been demonstrated on pre-registered synthetic benchmarks. Transfer to specific real-world domains (intelligence analysis, scientific discovery, experiment design) requires domain-level instantiation and evaluation beyond the current Tier-A scope.
Capability tier
ANI: superhuman within a bounded domain, including current frontier systems.
Designed for transfer beyond a single domain. Tier-A certification (Logarchéon’s internal ladder): Levels 4 and 5 — recursive triadic improvement over ≥20 verified closed-loop cycles, and integrated-seed evidence verified on a hidden benchmark committed in advance — complete at research scale. Level 6 additionally requires ≥10-domain breadth and self-improvement of the improvement process itself.
Failure mode
Returns a plausible answer regardless of whether a valid answer exists. Optimises text likelihood, not constraint satisfaction. High benchmark scores with high scaffolding dependence indicate a powerful component — not a robust intelligence.
Returns an infeasibility certificate when no valid solution exists — backed by verified computation, at research scale. Honest failure requires an actual constraint model. A correct refusal is as meaningful as a correct answer.
ANI — the pre-OS program

Before operating systems, each program managed its own hardware directly — purpose-built for one task, not composable, not self-coordinating. Current frontier models are this: large standalone programs that excel within their training distribution but cannot rewrite their own subsystems or enforce causal validity across novel domains.

The seed architecture — an operating system for learning

An operating system is not a bigger program — it is the coordinating layer that makes computation composable and self-managing. This architecture is the analogous layer for intelligence — with three specific mechanisms. GRAIL preserves every physical observable as a coordinate-independent tensor: the representation is invariant by construction, not by approximation. CEAS correlates signals across the entire model simultaneously — passing intelligence between computational units no matter how far apart they are, so distant but relevant connections are not cut off by architectural locality. The Ψ-operator acts on what those two layers produce: conducting causal analysis and certified inverse reasoning — because the operators transfer structurally, not by distributional similarity to training data. The architecture is designed so that causal, geometric, and coordination structure generalises across task families. The OS made computation compositional. This makes intelligence compositional across structurally related domains.

Key result · lecture notes v21.65

ANI solves tasks. The seed architecture improves the process that solves new task families.

A system can score at the highest human level on every standard benchmark and still be ANI if it succeeds only within its training distribution. The distinction is not performance — it is whether the system can intervene causally, generalise over symmetry orbits, and improve its own architecture inside a verified closed loop with a falsifiable audit record.

What the architecture is not — from the formal definitions (lecture notes v21.65)
  • ✗A large language model (LLM), however large, operating at observational-correlation-only causality
  • ✗An agentic pipeline wrapping a correlation-based LLM in causal-sounding instructions — wrapping produces a "causal-shaped" system, not a causal one
  • ✗Advanced computing hardware (quantum, neuromorphic) without goals, world models, or causal agency
  • ✗A system with superhuman performance in narrow domains only — that is ANI by definition
  • ✗A system with high benchmark scores but high scaffolding dependence — scaffolded performance is not autonomous intelligence
  • ✗Any system whose claimed improvements cannot be reproduced from logs, checkpoints, and pre-registered benchmarks alone
Intellectual genealogy

A single mathematical origin

Note on independence. The seed architecture does not assume Anti-de Sitter geometry, does not require a conformal field theory dual, and makes no claim that depends on the physical truth of the AdS/CFT correspondence. The architecture draws from classical mathematics that predates AdS/CFT by decades: spectral theory and heat kernel methods, Seeley–DeWitt coefficients, free energy functionals from statistical mechanics, and operator algebra methods from functional analysis. Convergence via Brouwer's fixed-point theorem (existence) and Knuth's TAOCP Vol. 1 §1.1 + pigeonhole principle (halting). No string-theoretic scaffolding required.

All three components emerged from independent study of classical mathematics — spectral theory, differential geometry, statistical mechanics, and operator algebras — encountered in part through the AdS/CFT literature. The study predates transformers, learned word vectors, and modern AI tools. The root insight predates the attention mechanism by years.

2009–10
General relativity study → GRAIL root insight
Physical laws must be written in coordinate-independent form. Neural inner products q⊤k are coordinate-dependent and must be replaced by metric-invariant I(gq, gk) = I(q, k).
2011+
Classical mathematics (spectral theory, heat kernels, statistical mechanics) → CEAS and Ψ-operator conception
Kerson Huang's spin-lattice physics, Ginsparg's conformal field theory, and Landau's multi-method analytics. Möbius/Lorentz maps + automorphic functions + geodesic flow → Ψ D+N split.
Masters
Poincaré series thesis → infinite GRAIL candidates
Summing a kernel K(q,k) over the orbit of a discrete group Γ, where the series converges, produces a Γ-invariant kernel. Canonical construction of the GRAIL invariant family.
2023–26
Formal integration → CEAS–Ψ–GRAIL seed architecture
1,391-page lecture notes (v21.65), a companion working paper (v1.35) written to the Euclidean standard, in which every claim is proved, cited, or stated as a hypothesis with a falsifier, reproducible test harness, 55 claims in three nonprovisional applications filed 8 October 2026: 19/833,766 (exact-invariance retrofit of trained models), 19/833,809 (training by checked programs) and 19/833,804 (transported-triple arithmetic); and 20 claims in a fourth, the seed application claiming priority to U.S. Provisional 64/067,703, filed October 2026.
2009 Root conception
predates transformers
1,391 Pages of lecture
notes v21.65
3 Core components, each
independently tested
20 Claims (Seed Architecture,
3 independent)
4 Nonprovisional Applications
Filed Oct 2026
Model upgrade path

MIA: Any trained model, upgraded to GRAIL

Metric-Invariant Architecture (MIA) is the general class of which GRAIL is a strict specialisation. MIA replaces every scalar dot-product primitive with a group-preserved invariant F(dₘ(q, k)), where I(g·q, g·k) = I(q, k) for all isometries g. The critical consequence: a legacy model — including any Transformer trained on Euclidean dot products — can inherit twinhood and geometric properties at runtime without discarding what it learned.

Four tiers, not three. The path from a plain pre-trained model to complete GRAIL is a gradient: zero-step arithmetic replacement, lightweight β fine-tuning, LoRA + hyperbolic projection, and complete retraining from scratch. Each tier is independently verifiable. The author's research-scale CEAS–Ψ–GRAIL builds satisfy all four tiers by construction; the retrofit of existing models through Tiers 0–2 is complete at research scale.

Formal hierarchy

GRAIL ⊂ MIA  (strict inclusion)
GRAIL = MIA + orbit-jump + automorphic kernels + CEAS β-control

Explicit caveat

Merely storing tensors in geometric memory without replacing arithmetic primitives does not confer twinhood. Both formal inheritance conditions must hold — verified in the technical brief.

Complete MIA technical page →
Property Tier 0 · MIA retrofit Arithmetic replacement only — zero gradient steps Tier 1 · CEAS β β-thermostat fine-tuning — hundreds of steps Tier 2 · LoRA + metric LoRA + ℍd projection — thousands of steps Tier 3 · Complete retrain Train from scratch with triad priors
Twinhood
Fg·θ(gx) = Fθ(x)
✓ ✓ ✓ ✓
Entropy corridor
H(β) ∈ [H★ − δ, H★ + δ]
✗ ✓ ✓ ✓
Susceptibility sharpening
χL ~ Lγ/ν
(conjecture)
✗ ✓ ✓ ✓
Orbit generalisation
unseen g ∈ G, εtwin ≤ 10−6
✗ ✗ ✓partial → complete ✓
Automorphic kernels
Kβ(q,k) = Σγ∈Γ e−β d(q,γk)
✗ ✗ ✓with ℍd projection ✓
Tier 0 — MIA retrofit (0 steps)

Twinhood only. Replace dot products with F(dₘ(q,k)) and wrap with (ψ, π). Zero gradient steps. No other GRAIL properties are transferred.

Tier 1 — CEAS β fine-tune (hundreds of steps)

Adds entropy corridor and susceptibility sharpening. β is an algebraic consequence of having adaptive temperature — no orbit generalisation required.

Tier 2 — LoRA + metric fine-tune (thousands of steps)

Adds orbit generalisation and automorphic kernels via LoRA adapters + ℍd projection on Q, K. A small adapter layer. Tractable on a single graphics processing unit (GPU).

Tier 3 — Complete retrain

All five properties at the theoretical optimum. The author's research-scale CEAS–Ψ–GRAIL builds are at this tier by construction.

Complete formal definitions, migration proofs, and section references are in the technical brief.

Who this is for

High-assurance missions

The long-term home for Logarchéon is environments where verifiable AI architecture and encrypted-in-use AI are mission-critical — not marketing.

Tier I · Core

National Security / Defense / Intelligence — U.S., NATO, and Coalition Partners

  • U.S. Intelligence Community (IC) agencies and Department of Defense (DoD) components requiring encrypted-in-use AI at operational scale
  • NATO member-state defense and intelligence agencies operating under shared threat environments
  • Coalition and allied-nation partners requiring sovereign AI execution without data exposure to third-party infrastructure
  • Defense and intelligence industrial base integrating hardened AI into mission-critical systems
  • Systemic finance and critical infrastructure with real-world failure modes
Tier II · Expansion

Research grants & regulated enterprise

  • U.S. DARPA / IARPA / ONR and allied-nation equivalents (DSTL, DRDC, DST Group, and NATO STO programmes) — research and development funding for advanced AI architecture and formal-verification infrastructure
  • Healthcare, pharma, aerospace requiring intellectual property (IP) protection and sovereign execution
  • Cloud and hardware vendors licensing encrypted-in-use runtime infrastructure
Tier III · Sandbox

Law, founders & civil organisations

  • Law firms that cannot upload privileged material to public AI APIs
  • Privacy-first founders treating their data as the strategic moat
  • High-confidentiality civil, humanitarian, and intergovernmental organisations
Under the hood

The stack in plain language

The page is simple on purpose. Underneath, the work draws on original results in geometry, spectral theory, statistical physics, and causal inference.

Future implementations. The same design is intended to run on progressively more capable real-world substrates — classical hardware today; quantum and topological substrates as the research frontier advances.

Core research pillars

  • CEAS: nonlocal entropy-temperature coordination; finite-size criticality; collective variable φ(t) that reduces coordination rounds.
  • Ψ-operator: all four Pearl rungs in a single operator algebra; constrained inverse design; causal identification with explicit, checkable criteria.
  • GRAIL: group-invariant metric replaces the Euclidean dot product; automorphic kernel construction; orbit-consistent by construction.
  • Recursive self-improvement: gated closed-loop improvement; machine-checked invariants; no manual edits inside the measured cycle.

Language architecture — correctness by construction

Every language has a bug topology — a map of what mistakes are structurally impossible to write. For a self-modifying system running autonomous improvement loops, the key question is not which language is fastest but which class of bugs each language makes impossible. The language choices here were reached through rigorous PL-theoretic analysis, including several revisions.

Lean 4 + Coq
A kernel-checked proof admits no unstated steps; gates every change that touches formal invariants.
Racket (Chez Scheme backend)
#lang causal-dsl makes it impossible to conflate P(Y|X) with P(Y|do(X)) at compile time. contract-out enforces RSI invariants at module boundaries.
SWI-Prolog
Impossible to silently mutate the causal graph during a query. Constraint logic programming, CLP(FD/R), enforces physical constraints without explicit code. Tabling memoises repeated sub-queries. Meta-interpreters generate next-generation causal languages within the gated RSI loop.
Python / JAX
Functional transforms (jit, vmap, grad) enforce pure functions with explicit randomness. GPU is non-negotiable for CEAS kernels and GRAIL hyperbolic geometry. JAX best for custom differentiable ops.
Key design decisions — arrived at through rigorous PL-theoretic analysis
Racket over SBCL: speed is irrelevant — Python/JAX on GPU is the bottleneck. Racket’s #lang defines new languages at the reader level (before parsing), not just at macro expansion. #lang causal-dsl makes it impossible to conflate observation and intervention at the source level. Chez Scheme’s macros cannot do this. Racket CS runs on Chez Scheme anyway, so Racket’s call/cc performance is Chez Scheme’s.
Racket over Haskell: homoiconicity, not purity, is the critical property for RSI. (eval new-state) is Racket’s normal operation; Haskell requires the GHC compiler application programming interface (API) or Template Haskell. The RSI loop has side effects by definition — it modifies the system. Haskell’s monadic purity adds overhead without solving the self-modification problem.
SWI-Prolog retained (not eliminated by Racket): three capabilities call/cc in Racket cannot replicate without weeks of infrastructure: tabling (automatic query memoisation), CLP(FD/R) (constraint propagation over physical laws), and meta-interpreters that can generate entirely new causal reasoning languages in a few dozen lines. The Racket–Prolog boundary is not a seam within a computation — it is an interface between two paradigms. Across paradigms, the interface is the contribution. Racket generates functional/syntactic languages; Prolog generates logic/constraint languages; together they generate next-generation languages in both paradigms simultaneously.

World model — (M, G, β)

The world model is not a separate design decision — it is already determined by the three components. M is the Riemannian manifold (GRAIL), G is the symmetry group acting on M (GRAIL), β is the inverse temperature controlling information density (CEAS). The Ψ-causal layer adds structural causal equations over M. The Ψ-causal engine is the world model: prediction is what results from marginalising out the causal structure; intervention, counterfactual, and inverse design are what result from using it completely.

Pearl rungs — what each system can answer
Rung
Capability
JEPA
Sora
D3
This (research scale)
1
Observe: P(Y|X=x)
✓
✓
✓
✓
2
Intervene: P(Y|do(X=x))
✗
✗
✗
✓
3
Counterfactual: what if X=x′?
✗
✗
✗
✓
4
Inverse design: find action causing Y=y
✗
✗
✗
✓
Riemannian ℍd vs Euclidean ℝd

Hierarchical structure (object → part → subpart) cannot be mapped into Euclidean space of any dimension without distortion, and the distortion grows with the size of the hierarchy. The same structure admits an injective map into ℍ2 with distortion arbitrarily close to 1. LeCun’s JEPA and DreamerV3 both suffer this silently. GRAIL uses the right geometry.

World model RSI

Every other world model is fixed architecture trained once. In this framework the RSI loop, now running at research scale, can modify the world model’s causal graph structure, manifold geometry, symmetry group assumptions, and β-schedule. The world model improves its own theory of the world. No existing public approach does this.

LeCun is right that world models are necessary. Fei-Fei is right that 3D structure matters. DreamerV3 is right that planning in latent space is efficient. All are solving Rung 1 with increasingly good architectures. None have the causal structure for Rungs 2–4.

Where to read more

Technical reviewers, cryptographers, and ML researchers who want the mathematics, proofs, and working code:

  • CEAS, GRAIL, Ψ-Operator — component pages
  • CV — academic background and prior work
  • Email for NDA-gated technical briefs and evaluation materials
Progress · updated October 2026

Progress to Certification

Every commitment of the programme, marked as it stands. “Complete” means built and passed its pre-registered test; “research scale” means on research-scale tasks, before the production model.

21 complete 5 in progress 2 planned or research
  • FoundationsLecture notes, formal verification layer and reproducible test harnessComplete
  • FoundationsLanguage-level self-improvement prototypeComplete
  • FoundationsGRAIL-native research buildComplete
  • Ψ-operator — causal engineCausal identification with machine-checked derivationsComplete · research scale
  • Ψ-operator — causal engineCounterfactuals and inverse design with memoryComplete · research scale
  • Ψ-operator — causal engineSafe behavioural editing without retrainingComplete · research scale
  • Ψ-operator — causal engineCausal reversal and action-order demonstrationsIn progress
  • CEAS — global coordinationCoordination scaling under the locality boundComplete · research scale
  • CEAS — global coordinationCoordination on a Ramanujan graph (a sparse network with the best possible connectivity for its wiring): averaging across 2,184 units took 77 rounds, against 3,417 on a wrap-around grid of comparable size and the same wiringComplete · research scale
  • CEAS — global coordinationLearned global coordination at scaleIn progress
  • GRAIL — invariant geometrySymmetry generalisation to unseen group elementsComplete · research scale
  • GRAIL — invariant geometryAutomorphic kernel inside the architectureComplete · research scale
  • GRAIL — invariant geometryHyperbolic symmetry group checked three ways: element counts at lengths 1–5 match the predicted growth exactly, the growth rate matches the group’s fractal dimension to within 10⁻⁴, and symbolic simplification matched exact matrix arithmetic on 100,000 of 100,000 random pairsComplete · research scale
  • GRAIL — invariant geometrySelberg trace formula on the modular surface, a classical identity linking its resonant frequencies to the lengths of its closed loops, checked numerically to within 3 × 10⁻¹⁵Complete · research scale
  • GRAIL — invariant geometryRetrofit of existing models (MIA Tiers 0–2)Complete · research scale
  • Integration and self-improvementSeed architecture assembled: the three components and five supporting modules (symbolic, spectral, arithmetic, language, self-improvement), linked by 36 cross-checks, each shown to reject a deliberately broken inputComplete · research scale
  • Integration and self-improvementFault-injection test of the 36 cross-checks: across all 7,806 combinations of up to three faults, a build-up to all 36, and every on/off pattern of any four (942,480), exactly the faulted checks fired and no healthy one didComplete · research scale
  • Integration and self-improvementTriadic integration and the complete ablationComplete · research scale
  • Integration and self-improvementClosed self-improvement loop with a machine-checked gateComplete · research scale
  • Integration and self-improvementWorld-model self-improvementComplete · research scale
  • Integration and self-improvementAll 23 test batteries, including multi-cycle improvement and scaling exponentsComplete · research scale
  • Integration and self-improvementSelf-improving control of a drifting physical systemComplete · research scale
  • Integration and self-improvementIntegrated-seed evidence (Cert Level 5): all 23 test batteries, all four Pearl rungs, GRAIL orbit generalisation, scaling exponents, self-improving control, hidden benchmark committed in advanceComplete · research scale
  • Integration and self-improvementPublic audit bundle for independent replicationIn progress
  • ProductPublic deployment with free user accessIn progress
  • ProductSelf-improvement applied to production codePlanned
  • Long horizonBreadth: cluster-scale evidence across ten or more domainsIn progress · groundwork
  • Long horizonPhysics correspondences; quantum and topological substratesResearch

The detailed evidence — the certification ladder, the seven demonstrations, the dated self-evaluation with the ranking of 61 developments, and the mathematical essays — is on the results page.

Who is behind Logarchéon

William Huanshan Chuang

Mathematician and sole founder of Logarchéon Inc., a one-person C-Corporation structured as an IP-first research laboratory. The work sits at the intersection of geometry, control theory, statistical physics, and artificial intelligence.

The focus on verifiable AI architecture reflects a design principle rather than a marketing claim: no intelligence system — computational or otherwise — can remain reliably aligned with the world it operates in without continuous coupling to causal measurement. The architecture is built for that coupling, not as an external constraint, but as its fundamental operating mode. On advanced hardware substrates, this coupling becomes more precise: a quantum-substrate CEAS with Ψ-mediated coordination would replace classically approximated nonlocal correlations with genuine quantum correlations, narrowing the boundary between the computational model and the world it represents. Advanced computing is not intelligence; this architecture on an advanced substrate may be. That distinction is the research frontier.

All three components of the seed architecture were conceived during independent study of classical mathematics — spectral theory, differential geometry, and statistical mechanics — encountered in part through the AdS/CFT literature, before transformers, before learned word vectors, and before modern AI tools. The root insight predating all modern attention mechanisms dates to 2009–2010 study of general relativity.

AI tools — including proprietary trained agents and recursive agentic systems — were used to verify proofs and accelerate documentation under human direction. All core claims, mathematical structures, and inventive concepts are human-originated. All patent claims are human work.

Next steps

Start a quiet conversation.

For organisations in national security, defense, or intelligence — U.S., NATO, or coalition — research, or high-assurance compute, and for reviewers evaluating the seed architecture under NDA, the starting point is simple.

Request a technical brief

A 30–45 minute briefing on the mission and its constraints, followed by a scoped proof-of-concept on the organisation’s hardware or within its cloud tenancy. Claims are bounded by written scope and acceptance criteria. No unbounded promises.

founder@logarcheon.com
NDA available · Non-enabling public materials · Evaluation under written scope
U.S. Patent Portfolio · Nonprovisional Applications 19/833,766 · 19/833,809 · 19/833,804 (filed 8 Oct 2026) · Seed Application filed Oct 2026 (priority 64/067,703) · Some materials subject to U.S. export regulations