U.S. Patent Pending 64/067,703 · 9+ Applications Filed 2025

We design what Artificial Superintelligence 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, built, and tested.

Request a technical brief Read the research

Core thesis

Scaling grows the machine. CEAS coordinates it globally. The Ψ-network supplies causal operator logic. GRAIL supplies invariant geometric cognition. Our thesis: scalable real-world Artificial Superintelligence 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 reduces effective computation-graph diameter to sub-diameter scale, resolving the coordination bottleneck that limits locally bounded architectures at scale. Grounded in finite-size criticality and thermodynamic phase analysis. Initializes 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 behavioral editing without retraining.

Design rationale: two causal models can agree on all observations yet disagree on interventions. Correlation-only systems cannot identify intervention-sensitive behaviors 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 generalization is orbit-consistent across symmetry groups. Produces infinite families of cryptographically distinct but functionally identical twin models. Root insight: GR study, 2009–2010.

Design rationale: invariant primitives make orbit-consistent generalization 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 generalize across a symmetry orbit by construction.

Evaluation · Triad

Whether the complete triad outperforms every pair is tested by a pre-registered ablation.

Mathematical foundations

The mathematics of ASI is algebraic, not statistical

Statistical mathematics — necessary but not sufficient

Answers: given data, how well can you approximate a function?

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 (type theory, PLT). 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

ASI 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 conservation laws and symmetries are the same thing. The tool creates the visibility.

This is the operating principle of Logarchéon: whenever possible, solve the ASI 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 ASI is more important than those domains, but because a correctly built ASI framework 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 ASI stack

Formal verification

Type theory, proof theory, PLT — Lean 4, Coq

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 — precisely what GRAIL formalises for representations.

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 topological spaces.

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 you how well a system approximates. Algebraic mathematics tells you what a system can and cannot represent. For building systems that approach ASI, 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/5, Claude, Gemini, and their successors. Artificial General Intelligence (AGI) (Artificial General Intelligence) — broad, robust competence across most cognitive task families, at least at the level of a competent adult human. ASI (Artificial Superintelligence) — performance exceeding the best human across most major cognitive domains, with robust transfer to new task families not represented in training.

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.1).

ANI / Current frontier LLMs

GPT‑4/5 · Claude · Gemini · all scaling‑law models

Logarchéon ASI Architect Seed

CEAS (Critical Entropy Attention Scaling) + Ψ‑Operator + GRAIL (Geometric Representation Algebra for Intelligent Learning)

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: association, intervention P(Y | do(X)), counterfactual Y_x′, 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) — all physical observables must be written in tensors to be meaningful in physics. Neural dot products q^⊤k are coordinate-dependent and lose information under coordinate changes. GRAIL preserves every physically meaningful observable in the representation without loss of generality, 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.

Designed for a verified closed Recursive Self-Improvement (RSI) (Recursive Self-Improvement) loop: 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.

ANI vs AGI vs ASI

ANI: superhuman within a bounded domain. AGI: adult-human level across most cognitive task families. Current frontier systems are plausibly Emerging AGI (Rank 5) at most — not Competent AGI (Rank 6), not Expert AGI (Rank 7), not ASI (Rank 9+).

Designed as an ASI Seed (Rank 10–12 trajectory). Current Tier-A target: Level 4 certification — recursive triadic improvement over ≥20 verified closed-loop cycles. Actual ASI claim 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. 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.

ASI Architect — the intelligence OS

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.1

ANI solves tasks. An ASI seed 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 is not ASI — from the formal definitions (lecture notes v21.1)

✗A large language model (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 ASI seed 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, word embeddings, and modern AI tools. The root insight predates the attention mechanism by years.

2009–10

General relativity study → GRAIL root insight

All physical observables 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 Ψ-network 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

Averaging any kernel K(q,k) over a discrete group Γ produces a Γ-invariant inner product. Canonical construction of the complete GRAIL invariant family.

2023–25

Formal integration → ASI Seed Architecture

510-page lecture notes (v21.1), companion working paper, reproducible test harness, 25 patent claims. U.S. Provisional 64/067,703 filed; non-provisional in preparation. 9+ applications filed 2025.

2009 Root conception
predates transformers

510 Pages of lecture
notes v21.1

3 Core components, each
independently tested

25 Claims (ASI Seed,
4 independent)

9+ Patent Applications
Filed 2025

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 trained CEAS–Ψ–GRAIL models satisfy all four tiers by construction.

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 conditions of the 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 F_g·θ(gx) = F_θ(x)	✓	✓	✓	✓
Entropy corridor H(β) ∈ [H★ − δ, H★ + δ]	✗	✓	✓	✓
Susceptibility sharpening χ_L ~ L^γ/ν (conjecture)	✗	✓	✓	✓
Orbit generalisation unseen g ∈ G, ε_twin ≤ 10⁻⁶	✗	✗	✓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 trained CEAS–Ψ–GRAIL models are at this tier by construction.

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

Λ-secure runtime · V1 / V2 / V3

Encrypted-in-use deployment

The seed architecture includes a λ-secure runtime for deployments requiring encrypted-in-use computation. Buyer-held keys. Policy-gated interfaces. No canonical plaintext during execution. Operates on your hardware or within your cloud tenancy.

V1 — λ-native models

Geometry built into model architecture and training dynamics from the ground up. Maximal integration. Principled semantics. Tighter control of canonicalization. For long-lived sovereign AI assets where architectural integrity is non-negotiable.

V2 — Exported wrapper (NN/LLM)

Adoption-first path. Wraps existing models and runtimes without complete re-architecture. Fastest path to pilots. Reduces reusable plaintext exposure in in-use pipelines via constrained interfaces and protected representations.

V3 — VM/OS/runtime posture

Extends the same non-canonical in-use discipline to OS/VM/runtime boundaries for general-purpose compute — not solely AI. Covers cloud instances, on-premises deployments, hypervisor surfaces, and complete artifact lifecycle control.

Why Fully Homomorphic Encryption (fully homomorphic encryption (FHE))/secure multi-party computation (secure multi-party computation (MPC))/TEEs fall short

FHE: 10³–10⁶× overhead, impractical for large neural pipelines. MPC: communication latency dominates at scale. TEEs: shift trust to vendor firmware, not zero-trust. All reintroduce plaintext through telemetry, caches, or debug steps.

Scope boundary: Public materials are intentionally non-enabling. Detailed substantiation, benchmarks, and evaluation specifics are provided under non-disclosure agreement (non-disclosure agreement (NDA)) for serious technical review. All claims are bounded by written scope and acceptance criteria. No unbounded promises.

Who this is for

High-assurance missions

The long-term home for Logarchéon is environments where ASI 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 injecting 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 ASI 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 organizations

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 organizations

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 parse 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 can generate next-generation causal languages within the 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 you get when you marginalise out the causal structure; intervention, counterfactual, and inverse design are what you get when you use it completely.

Pearl rungs — what each system can answer

Rung

Capability

JEPA

Sora

D3

This

Observe: P(Y|X=x)

✓

Intervene: P(Y|do(X=x))

✗

✓

Counterfactual: what if X=x′?

✗

✓

Inverse design: find action causing Y=y

✗

✓

Riemannian ℍd vs Euclidean ℝd

Hierarchical structure (object → part → subpart) requires exponentially many Euclidean dimensions without distortion. The same structure admits an injective map into ℍ^d with constant distortion. 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 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:

Research page — lecture notes v21.1 (510 pages, under NDA), companion working paper, reproducible test harness, 25-claim patent draft
CEAS, GRAIL, Ψ-Operator — component pages
CV — academic background and prior work
Email for NDA-gated technical briefs and evaluation materials

Execution plan · one-person company

48-Week Roadmap to Certification

Phase 1 · Weeks 1–18 · ~8 months to here

Working product live by week 8. Six discriminating demos. Cert Level 3.

Confidence: weeks 1–8 ~90% · weeks 9–18 ~75%

Phase 2 · Weeks 19–48 · Cert Level 4–5

RSI closed loop. Physical-ASI seed evidence. User feedback compounds improvement.

Confidence: weeks 19–32 ~60% · weeks 33–48 ~50%

AI agents generate ~80% of the code. Irreplaceable human contributions: architecture decisions and causal correctness judgements in the Ψ-engine. Timeline assumes full-time focus — part-time roughly doubles the calendar. Cert Level 4 (RSI closed loop) at week 32 is the primary target; Cert Level 5 at week 48 is the stretch target.

Lean 4 + Coq

Formal verification of core invariants in Lean 4.

SWI-Prolog

Ψ-causal engine, do-calculus, structural causal model (SCM) inference. Logic programming is causal reasoning. User has prior Prolog background.

Racket (Chez Scheme)

RSI loop, #lang causal-dsl enforcement, memory, audit. Homoiconicity + call/cc for RSI reversion. Chez Scheme performance underneath.

Python / JAX

CEAS kernel, GRAIL hyperbolic geometry, neural training, benchmarks. GPU is non-negotiable; JAX best for custom ops.

Phase 0 — Theory & formal verification (complete)

Complete · Sept 2026

Lecture notes v21.1 (510 pages) · formal verification layer · reproducible test harness

Lean 4 + LaTeX + JAX

Theoretical framework, formal verification of core invariants, and a reproducible test harness.

✓ Done

Complete · Sept 2026

Language-level self-improvement prototype

Racket + Lean 4 + Prolog

Gated loop: each language change must make more errors impossible, keep every known-good program valid, and improve on the error suite.

✓ Done

Scale the gated loop to production code

Racket + Lean 4 + Python

Apply the gated language loop to the production codebase.

Phase 1 — Working product, discriminating demos, Cert Level 3

Weeks 1–2

Deploy existing model

Python / FastAPI

Public URL live. Oracle Cloud ARM serving the trained CEAS+Ψ+GRAIL model. Supabase auth. Free user access from day one.

Weeks 3–6

Ψ-causal engine

SWI-Prolog

Ψ-engine outperforms correlation-only LLMs on a do-calculus evaluation suite. Causal reversal and action-order demos live. Correlation-only models cannot identify this in general.

Demos A + B

Weeks 7–8

CEAS coordination

Python / JAX

T_CEAS(N) = o(N) scaling chart — crossover with local attention visible at a defined scale threshold. First public milestone: product live, two demos running.

Demo C

Weeks 9–11

GRAIL geometry

Python / JAX

Symmetry generalisation to unseen group elements. ε_twin ≤ 10⁻⁶. Invariance holds by construction.

Cert Level 2 Demo D

Weeks 12–18

Triadic integration

Lean 4 + Racket + JAX

All three components wired. Pre-registered ablation: the complete triad against all 7 variants.

Cert Level 3

Phase 2 — Memory, RSI loop, Cert Level 4–5 (research, not guaranteed)

Weeks 19–22

Memory + inverse design

Racket + Python

Episodic + semantic memory. Inverse design: given target state, compute action sequence. Pearl Rung 4 — LLMs cannot invert physical dynamics outside training data.

Demo E

Weeks 23–32

RSI-0 closed loop

Racket + Lean 4 + Python

A defined minimum of verified cycles. No manual edits inside the loop. Lean 4 gate active. User feedback compounds improvement each verified cycle.

Cert Level 4 Demo F

Weeks 33–48

Physical-ASI seed evidence

All four languages

All 23 test batteries. J(N) = αN^−p with p_triad > p_baseline. Complete audit bundle on GitHub. Cert Level 5 if all 23 pass simultaneously.

Cert Level 5 attempt

Six discriminating demonstrations

Each targets an architectural difference, not a benchmark gap.

A Weeks 3–4

Causal reversal

A dataset where X appears to prevent Y in observed data, but causes Y when you intervene. LLMs give the wrong direction. The Ψ-engine computes P(Y|do(X=x)) by SCM mutilation — correct whenever the effect is identifiable.

Correlation-only models cannot identify this in general · lecture notes v21.1

B Weeks 5–6

Action order matters

“Open drawer then grasp” ≠ “grasp then open drawer.” LLMs treat these as semantically similar. Ψ-causal has [T_a, T_b] built in — the commutator is measurable and non-zero.

Design principle · lecture notes v21.1

C Weeks 7–8

Global coordination scaling

On N-bit global parity, CEAS reduces coordination rounds via the rank-one collective variable φ(t). Crossover with local attention visible at a measurable scale threshold on a reproducible chart.

Coordination-round analysis · lecture notes v21.1

D Weeks 9–11

Symmetry generalisation

Train on a set of group elements; test on unseen elements from the same group. GRAIL: zero error gap. Euclidean transformer: degrades. I(gq, gk) = I(q, k) holds by construction, not by approximation.

ε_twin ≤ 10⁻⁶ · GRAIL invariant kernel

E Weeks 19–22

Physical inverse design

Given a target state, compute the action sequence that causes it. LLMs pattern-match forward — they do not invert physical dynamics outside their training distribution. The Ψ-engine solves this by construction.

Correlation-only models cannot identify this in general · lecture notes v21.1

F Weeks 23–32

Autonomous improvement loop

A defined minimum of closed-loop cycles with no human edits inside the loop. Lean 4 gate active throughout. User queries feed the continuous fine-tuning cycle.

Gated closed loop · pre-registered cycle count

Certification ladder

Level 1 ANI — one task or one domain

Level 2 One component beats its baseline (week 11)

Level 3 Triad beats all 7 ablation variants (week 18)

Level 4 ≥20 closed-loop RSI cycles, no manual edits (week 32)

Level 5 Physical-ASI seed — all 23 tests, all 4 Pearl rungs, GRAIL orbit verified (week 48)

Level 6 ASI claim — requires cluster-scale evidence, ≥10 domains, beyond Tier-A hardware

Language-level self-improvement · RSI level 2

Generating a better language is formulating a better theory

Level 2 changes the language itself — what can be written and what is rejected before execution.

Each proposed language change passes a gate: it may only make more errors impossible, must keep every known-good program valid, and must improve on the error suite.

The loop cannot regress, always terminates, and blocks over-broad changes.

Homoiconicity · code is data, data is code

When weights and programs live on the same manifold

Weights and inputs share one geometry, so a program edit and a geometric edit can be treated alike. Seven capabilities follow; details in the technical brief.

Knowledge bridge

Retaining pre-trained knowledge

A protocol for importing pre-trained knowledge without breaking invariance is specified in the technical brief.

Lecture notes v21.1 · 510 pages

From theory to implementation

Theory-to-implementation mappings are provided in the technical brief.

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 designation Artificial Superintelligence Architect 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 ASI 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 word embeddings, 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.

Email founder@logarcheon.com CV Academic background Resume Professional background GitHub github.com/williamchuang LinkedIn linkedin.com/in/chuang-william About Formation and vocation Research Papers and working drafts

Next steps

Start a quiet conversation.

If you work in national security, defense, or intelligence — U.S., NATO, or coalition — research, or high-assurance compute — or if you want to evaluate the ASI seed architecture under NDA — the starting point is simple.

Request a technical brief

A 30–45 minute briefing on your mission and constraints, followed by a scoped proof-of-concept on your hardware or within your 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 · 9+ Applications (2025) · Principal: 64/067,703 · Some materials subject to U.S. export regulations

We design what Artificial Superintelligence requires.We build and test the architecture.