the algorithmic essence of superintelligence

from first principles: what are the minimum algorithms required for a self-proving, self-modeling, self-improving distributed intelligence?

sixteen components. one field. the system knows what it knows, proves it knows it, pays for what matters, grows itself optimally, and trusts no one.

0. the field: Goldilocks

everything starts here. $p = 2^{64} - 2^{32} + 1$. a prime with $2^{32}$ roots of unity — deep NTT support in a 64-bit word. four primitive operations over this field are sufficient for all computation in the system:

• fma (field multiply-accumulate): matrix ops, constraint evaluation, polynomial arithmetic
• ntt (number-theoretic transform): proof commitment, FHE polynomial multiply, quantum simulation
• p2r (Poseidon2 round): hashing, Fiat-Shamir, content addressing
• lut (lookup table): activation functions, S-box, FHE bootstrap, stark lookup

the same four primitives serve stark proofs, TFHE encryption, quantum simulation, and neural inference. not by coincidence — by algebraic structure. the field tower $\mathbb{F}_p \subset \mathbb{F}_{p^2} \subset \mathbb{F}_{p^3} \subset \mathbb{F}_{p^6}$ contains complex amplitudes (p²), recursive proof soundness (p³), and their composition (p⁶). one field. one chip (Goldilocks field processor). three pillars of the trinity: quantum security, privacy, AI.

see Goldilocks field for field properties. see nebu for field arithmetic implementation (1,526 LOC, 73 tests, DONE).

1. the hash: Hemera

Hemera: Poseidon2 sponge over Goldilocks. 24 rounds (8 full + 16 partial), 16-element state, rate 8 (56 bytes per absorption). self-bootstrapping: round constants generated by hashing "cyber" with zero-constant Hemera.

~736 stark constraints per permutation — but hemera is the trust anchor, not the bulk commitment engine. ~3 calls per execution: (1) domain separation wrapper for noun identity hemera(Lens.commit ‖ tag), (2) Fiat-Shamir seed, (3) Brakedown binding. lens (recursive Brakedown) handles bulk commitment. hemera wraps Lens commitments with domain tags. ~3 permutations per execution, not thousands.

one hash function, one security assumption (collision resistance), one implementation to audit.

see Hemera for specification. see hemera repo (5,084 LOC, 209 tests, PRODUCTION).

2. the object: cybergraph

a directed weighted graph $G = (P, E, N, w)$. particles $P$ are content-addressed by Hemera hash (32 bytes). cyberlinks $E$ are edges signed by neurons $N$ and weighted by stake $w$.

every particle is a complete semantic unit — 32-byte CID token vs 4-byte BPE fragment. unambiguous (hash = identity), universal (any content), no vocabulary freeze (graph grows).

the graph grows append-only (axiom A3). new particles and links accumulate. nothing is deleted. the cybergraph is the substrate — all dynamics, trust, intelligence operate on it.

3. the signal: atomic state change

a signal $s = (\nu, \vec\ell, \pi_\Delta, \sigma, \text{prev}, \text{mc}, \text{vdf}, \text{step})$:

• $\nu$: neuron identity (who)
• $\vec\ell$: batch of cyberlinks (what)
• $\pi_\Delta$: focus impulse — sparse local tri-kernel recomputation (the key field)
• $\sigma$: zheng proof covering cyberlinks + impulse + conviction (proof of everything)
• prev: hash of author's previous signal (hash chain)
• mc: Merkle clock (compact causal state)
• vdf: VDF proof (physical time since previous)
• step: monotonic counter (logical clock)

the impulse $\pi_\Delta$ is critical. the neuron does not just submit links — it computes the LOCAL effect of those links on the tri-kernel fixed point and includes the result. the zheng proof σ certifies this computation is correct. the network does not need to recompute φ* from scratch — it applies proven impulses incrementally.

this is the mechanism that makes reward ∝ Δπ work: the neuron proves its own Δπ inside the signal. the proof IS the claim. the claim IS the mining.

signals are patches. patches are signals. the same object described by patch theory (categorical morphism) and structural sync (verified broadcast unit). this is the cyb/fs/sync unification.

4. the dynamics: tri-kernel convergence

three operators on the graph simultaneously:

$$\phi^{(t+1)} = \text{norm}\left[\lambda_d \cdot \mathcal{D}(\phi^t) + \lambda_s \cdot \mathcal{S}(\phi^t) + \lambda_h \cdot \mathcal{H}_\tau(\phi^t)\right]$$

• $\mathcal{D}$ (diffusion): stake-weighted random walk. finds hubs
• $\mathcal{S}$ (springs): screened Laplacian, mean neighbor focus. finds equilibria
• $\mathcal{H}_\tau$ (heat): 2-hop smoothing at resolution τ. finds clusters

the collective focus theorem: the composite is contractive ($\kappa < 1$), unique fixed point $\phi^*$ exists, every initial distribution converges exponentially. $\phi^*$ IS focus — the consensus ranking.

two modes of computation:

• incremental (per signal): each signal carries $\pi_\Delta$ — the neuron's local tri-kernel recomputation for its cyberlinks. the network accumulates proven impulses. φ updates continuously as signals arrive — no global recomputation per block

• global (per epoch): full tri-kernel iteration from committed graph state. 23 iterations on bostrom, sub-second on GPU. validates accumulated impulses. with algebraic state commitments: fits in zheng circuit (1.42B constraints, 33% capacity) — provable

the impulse design means: a neuron contributing knowledge immediately shifts φ in its neighborhood. the shift propagates through subsequent signals. consensus emerges from accumulated local impulses, verified by periodic global proofs. the neuron proves its own Δπ inside the signal — the proof IS the mining.

5. the trust: five verification layers

the composition: Verified Eventual Consistency (VEC). convergence guaranteed + completeness verifiable + availability verifiable. stronger than eventual consistency. a node proves it has converged, not assumes it.

conjectured minimum: remove any layer → a failure mode opens that the others cannot cover.

6. the proof: zheng

zheng: SuperSpartan IOP + recursive Brakedown lens + sumcheck, all over Goldilocks with Hemera.

nox trace → multilinear polynomial f(x₁,...,x_{n+4})
         → Brakedown commit (no Merkle — direct linear code)
         → SuperSpartan (CCS constraints via sumcheck)
         → proof π (~2 KiB)

prover: O(N) time, O(√N) memory (tensor compression). verifier: ~5 μs. recursive: the verifier IS a nox program — proofs compose. HyperNova folding: ~8K constraints → 30 field ops per recursive step (recursive Brakedown verifier is smaller than Merkle-based alternatives).

zheng: SuperSpartan IOP + recursive Brakedown lens (Goldilocks) + Binius lens (F₂). 32-64× cheaper for bitwise operations. cross-algebra boundary: ~766 F_p constraints.

see zheng for spec. see stark for the proof taxonomy.

7. the VM: nox

nox: 16 deterministic reduction patterns over binary trees of field elements. the computation substrate. every noun is a multilinear polynomial. axis = O(1) polynomial evaluation via Lens opening. identity = hemera(Lens.commit(noun) ‖ tag).

the 16 patterns ARE the axiom. state operations, CCS jets, zheng itself — all derived from the 16 patterns.

algebra-polymorphic: nox<F, W, H> parameterized over field, word, hash. the same 16 patterns work over Goldilocks, F₂, F_{p²}. trident compiles 14 languages through nox.

focus metering: each pattern costs focus. insufficient focus → halt. the VM cannot loop forever — metering is structural, not a gas limit that can be circumvented.

8. the state: polynomial BBG

BBG: the authenticated state layer. polynomial commitments replace hash trees.

$$\text{BBG\_root} = H(\text{commit}(\text{BBG\_poly}) \| \text{commit}(A) \| \text{commit}(N))$$

BBG_poly covers 10 public dimensions (particles, axons_out, axons_in, neurons, locations, coins, cards, files, time, signals). A(x) is the commitment polynomial for membership (cyberlinks). N(x) is the nullifier polynomial for non-membership (spent). two independent private commitments alongside the public state polynomial. cross-index consistency: free (same polynomial). LogUp: eliminated.

O(1) in-circuit reads are the game changer — they enable provable consensus.

9. the privacy: mutator set + trilateral

individual cyberlinks are private. public state is aggregate (axons, neuron summaries, particle energy).

privacy mechanism: polynomial mutator set. commitment polynomial A(x) for membership — each cyberlink is a commitment $\text{ar} = H(\text{particle} \| \text{value} \| \text{owner} \| \text{nonce} \| \rho)$ inserted as a root of A(x). nullifier polynomial N(x) for non-membership — spending reveals a nullifier $n = H(\text{nonce} \| \text{secret})$ inserted as a root of N(x). double-spend = same nullifier twice → N(x) already has that root. O(1) Lens opening proofs, 32-byte witness.

the trinity privacy trilateral:

• ZK (stark): prove computation correct, witness stays sealed
• FHE (TFHE over Goldilocks): compute on encrypted data, never see plaintext
• MPC (Shamir over $\mathbb{F}_p$): distribute trust, no single party sees anything

four tiers: transparent (tier 0) → private ownership (tier 1, all transactions) → private computation (tier 2, ZK+FHE) → distributed trust (tier 3, ZK+FHE+MPC).

10. the consensus: foculus

foculus: consensus by computation, not voting. $\phi^*$ is the fork choice rule. a particle is final when $\phi_i > \tau$.

conflict: two particles sharing a nullifier. exclusive support: each neuron links to at most one member of a conflict group. the tri-kernel contraction amplifies the asymmetry — the particle with more honest support crosses τ. the loser is pruned.

no leader. no quorum. no voting rounds. no finality gadget. convergence from topology.

with polynomial state: the entire tri-kernel computation fits in a zheng circuit (1.42B constraints, 33% capacity). validators PROVE they computed φ* correctly. consensus = computation + proof. recursive folding: all history → one proof → verify in ~5 μs.

11. the self-model: compiled transformer

the cybergraph compiles into a transformer by linear algebra:

cyberlinks → sparse adjacency → PageRank (23 iterations) → spectral gap (from convergence rate) → randomized SVD → $d^*$-dimensional embeddings → architecture params ($d^*$, $h^*$, $L^*$) → ONNX model

no training. no gradient descent. the graph IS the training data. $d^* = \exp(H(\sigma))$ from entropy of singular values. the graph tells you how big the model should be.

bostrom compilation (March 2026): $d^* = 26$, 155M params, 295 MB ONNX. 15 minutes on a laptop.

the model speaks CID — input particle indices, output particle distribution. structural intelligence, not statistical.

12. the metabolism: syntropy and spectral health

syntropy = aggregate KL divergence across neurons per epoch. meaningful cyberlinks raise it. spam lowers it. the metabolic signal — bits of structure per unit energy.

the spectral gap λ₂ is observed for free from tri-kernel convergence rate: $\lambda_2 = 1 - \kappa/\alpha$ where $\kappa = \text{median}(d_t/d_{t-1})$. no eigensolver. every block that computes focus also computes the spectral gap. the heartbeat.

karma: accumulated syntropy per neuron. neurons with high karma have more influence on φ*. the reputation is earned by improving the graph, not by holding tokens.

truth layer: Bayesian Truth Serum scores each neuron's contribution. neurons whose links sharpen collective certainty earn positive syntropy. neurons whose links add noise earn negative.

13. the economics: Δπ rewards and epistemic markets

every reward traces to one quantity: how much did your action shift the tri-kernel fixed point?

$$\text{reward}(\nu) \propto \Delta\pi(\nu)$$

Δπ is the gradient of system free energy. creating valuable structure literally creates value. neurons prove their own Δπ via stark proofs and self-mint $CYB. the proof IS the mining. no external oracle. no committee deciding value. the math determines reward.

the hybrid reward function:

$$R = \alpha \cdot \Delta\pi + \beta \cdot \Delta J + \gamma \cdot \text{DAGWeight} + \epsilon \cdot \text{AlignmentBonus}$$

attribution via probabilistic shapley attribution: each neuron's marginal contribution to the collective fixed point is computable. complexity O(k · n), feasible at 10⁶+ transactions per epoch.

every cyberlink carries a perpetual prediction market on its own truth — the ICBS:

$$C(s_{YES}, s_{NO}) = \lambda \sqrt{s_{YES}^2 + s_{NO}^2}$$

buying YES suppresses NO's price — TRUE and FALSE geometrically coupled on a circle. this is market inhibition: the economic analog of inhibitory neurons. the effective adjacency weight integrates topology, market price, and meta-prediction:

$$A^{\text{eff}}_{pq} = \sum_\ell \text{stake}(\ell) \times \text{karma}(\nu(\ell)) \times f(\text{ICBS price}(\ell))$$

three token operations on knowledge:

• mint: prove Δπ → create $CYB. inflation = evidence of knowledge creation
• burn: permanent π-weight on particles or cyberlinks. highest-conviction assertions
• lock: will creation. time commitment = conviction depth. the budget for attention

the economics are provable. with polynomial state + zheng: a neuron on a phone can prove Δπ, self-mint tokens, and update the graph — all in one recursive proof. no miner. no validator permission. contribute knowledge, prove it matters, get paid.

see cyber/nomics for the full economic protocol. see Bayesian Truth Serum for honesty incentives.

14. the growth: optimal densification

link cost grows exponentially: $c(n) = c_0 \cdot e^{\lambda n}$. the cyber/seer algorithm maximizes $\Delta\lambda_2 / c(n)$ using the Fiedler vector — the eigenvector of λ₂ that identifies weakest cuts.

three phases: bridges (connect components, low cost) → mesh (eliminate articulation points, medium cost) → semantic (redistribute focus toward truth, high cost).

the graph grows intelligently. each link placed where it improves convergence the most per unit spent.

15. the language: trident

trident: the compiler that targets nox. 14 algebraically irreducible languages:

each language compiles through nox. each execution step → Hemera commitment → particle in cybergraph. the graph accumulates verified computation from all algebras.

57,736 LOC implemented (frontend, IR, type inference, verification hooks, field-generic primitives).

16. the recursive closure

the system that measures itself compiles into a model of itself that proves itself correct and uses itself to optimize its own growth:

cybergraph
  → tri-kernel convergence (φ*)
    → spectral gap observation (λ₂)
      → compiled transformer (embeddings)
        → seer optimization (Fiedler)
          → new cyberlinks
            → cybergraph (improved)
              → better φ*, larger λ₂, richer model, smarter optimizer

each step is an algorithm with concrete complexity bounds. the loop is executable, not metaphorical. and with provable consensus, the entire loop can be proven correct inside a single zheng circuit.

the complete architecture

                    ┌─────────────────────────────┐
                    │     GOLDILOCKS FIELD         │
                    │  p = 2⁶⁴ - 2³² + 1          │
                    │  fma · ntt · p2r · lut       │
                    └──────────────┬───────────────┘
                                   │
              ┌────────────────────┼────────────────────┐
              │                    │                    │
        ┌─────▼─────┐      ┌──────▼──────┐     ┌──────▼──────┐
        │  HEMERA   │      │    NOX      │     │  TRIDENT    │
        │  hash     │      │    VM       │     │  compiler   │
        │  ~3 calls │      │ 16 patterns │     │ 14 langs    │
        └─────┬─────┘      │ poly nouns  │     └──────┬──────┘
              │             └──────┬──────┘            │
              └────────────────────┼────────────────────┘
                                   │
                    ┌──────────────▼───────────────────────┐
                    │         ZHENG                         │
                    │  SuperSpartan + recursive Brakedown   │
                    │  + Binius                             │
                    │  ~5 μs verify, recursive fold         │
                    └──────────────┬───────────────────────┘
                                   │
         ┌─────────────────────────┼─────────────────────────┐
         │                         │                         │
  ┌──────▼──────┐         ┌────────▼────────┐       ┌───────▼───────┐
  │  BBG POLY   │         │   STRUCTURAL    │       │   PRIVACY     │
  │  10 dims    │         │   SYNC          │       │   poly mutator│
  │+ A(x) + N(x)│        │ CRDT + lens + DAS│       │   ZK+FHE+MPC  │
  └──────┬──────┘         └────────┬────────┘       └───────────────┘
         │                         │
         └─────────┬───────────────┘
                   │
        ┌──────────▼──────────┐
        │     FOCULUS          │
        │  tri-kernel → φ*    │
        │  provable consensus │
        └──────────┬──────────┘
                   │
    ┌──────────────┼──────────────────┐
    │              │                  │
┌───▼────┐  ┌─────▼──────┐  ┌───────▼───────┐
│COMPILED│  │ SPECTRAL   │  │    SEER       │
│ MODEL  │  │ HEALTH     │  │   GROWTH      │
│SVD→d*  │  │ λ₂ from κ  │  │  Fiedler      │
└───┬────┘  └─────┬──────┘  └───────┬───────┘
    │             │                  │
    └─────────────┼──────────────────┘
                  │
        ┌─────────▼─────────┐
        │    CYBERGRAPH      │
        │    (improved)      │
        │    → loop repeats  │
        └────────────────────┘

17. the flywheel: unified mining

the signal proof σ already exercises all four GFP primitives in production proportions: fma (tri-kernel SpMV + polynomial arithmetic, ~60%), ntt (Lens commitment + evaluation, ~25%), p2r (hemera ~3 calls, ~5%), lut (activations + lookups, ~10%). polynomial-dominant workload — bulk computation is field arithmetic, not hashing.

unified mining: the PoW puzzle IS the signal proof. add difficulty target: H(σ) < target. one proof → three rewards:

• block subsidy (PoW security)
• Δπ reward (knowledge creation)
• user fees (services)

the miner who selects BETTER cyberlinks earns MORE Δπ per proof. same PoW cost, higher knowledge reward. the incentive gradient points toward quality. every joule produces both security and intelligence.

mining rewards → fund GFP development
GFP accelerates SIGNAL PROVING → signals ARE knowledge
better hardware → more signals/sec → more knowledge/sec
more knowledge → higher Δπ → more reward → more GFP investment

the GFP chip spec does not change. the benchmark phases ARE the real workload. no synthetic puzzle. the first PoW scheme where puzzle output IS the protocol's primary product.

see Goldilocks field processor for chip spec. see cyber/research/unified mining for the full mechanism.

implementation status

what exists

the cutting edge decision

we go all-in on props that UNIFY. conservative path (13 hash trees + LogUp) produces more code, more complexity, and cannot prove consensus in-circuit. cutting edge (1 polynomial) is SIMPLER:

spec gaps blocking code

milestones

sessions:  0    4    8    12   16   20   24   28
           ├────┤────┤────┤────┤────┤────┤────┤
spec:      ████
M1 nox:        ████
M2 zheng1:         ██████
M3 zheng2:               ████
M4 poly:             ██████
M5 foculus:                   ████
M6 provbl:                        ████
M7 accum:                     ███
M8 mudra:        ████████████

~28 sessions (84 hours). the graph becomes self-proving.

one field: Goldilocks one hash: hemera (~3 calls per execution, domain separation + trust anchor) one Lens: recursive Brakedown (commit, open, verify — for everything) one VM: nox (16 patterns, polynomial nouns, 3 jet categories) one state: BBG_poly + A(x) + N(x) (all lens-committed, 10+2 model) one sync: structural sync (CRDT + lens + DAS — DAS native) one identity: hemera(Lens.commit(content) ‖ tag) — 32 bytes, universal

no training. no voting. no leaders. no trust. rewards proportional to proven knowledge. every joule produces intelligence.

the graph is the model. the model is the proof. the proof is the consensus. the consensus is the mining. the mining is the knowledge. the knowledge is the graph.

see foculus for consensus. see tri-kernel for convergence. see structural sync for five layers. see algebraic state commitments for polynomial state. see cyber/research/provable consensus for the circuit. see bostrom/compiled model for first compilation. see cyber/research/spectral gap from convergence for observation. see cyber/seer for growth. see cyber/research/32-byte tokens for CID vocabulary. see cyber/research/vec formalization for formal VEC. see trinity for quantum × privacy × AI. see cyb/multiproof for 14-language architecture. see cyb/fs/sync for patch = signal unification. see cyber/research/trinity meets polynomial state for polynomial state + trinity. see cyber/research/unified mining for puzzle = knowledge. see Goldilocks field processor for the chip