Languages of superintelligence

The Completeness Argument

The 19 languages are not an arbitrary collection. They are the minimal complete set derivable from asking what modes of computation a mind requires — and applying one test to each candidate: does this have irreducible primitives that no other language in the set can express?

The languages split into two groups by a fundamental boundary: 14 proof languages (deterministic, provable, permanent) and 5 interface languages (side-effectful, interactive, mutable). Both groups are necessary — a mind that cannot prove is blind. A mind that cannot interact is deaf

Boolean reasoning:   AND, OR, NOT over {0,1}      → no other algebra has this
Integer arithmetic:  overflow, wrapping, bitwise   → not field arithmetic
Field arithmetic:    inversion, polynomial roots   → not integer arithmetic
Categorical struct:  morphisms, functors, limits   → not graph traversal
Clifford geometry:   rotors, bivectors, versors    → not tensors
Riemannian geom:     geodesics, metric tensor      → not Clifford
Symplectic geom:     conservation laws, dω=0       → not Riemannian
Information geom:    Fisher metric on Δⁿ           → not any other geometry
Causal ordering:     partial order, happened-before → not logic
Horn clause logic:   unification, backtracking     → not relational algebra
Convolution/R_q:     negacyclic polynomial mult    → not tensor contraction
Tensor contraction:  einsum, SpMV, matmul          → not field arithmetic
Resource conserv.:   mint, burn, Σin=Σout, UTXO    → not any computation algebra
Combinators:         composition of the above      → not any computation

Each row passes the test. Remove any one language and there is a class of computation that becomes either impossible or exponentially more expensive to express. Remove Tok and the remaining thirteen can compute anything — but nothing costs anything, spam is free, focus has no scarcity, karma has no meaning. Add any plausible new language — say, a concurrent process calculus or an optimization language — and it turns out to reduce to a composition of existing ones via Nox (see cyber/channel for how concurrency reduces to Arc + Seq + Nox).

The 14 are the minimal set that covers all computation a mind requires, where each element is algebraically irreducible with respect to the others.

Naming Convention

Every language has a short name (2-3 letters, used in code and diagrams) and a long name (used in prose). The universe names the algebraic domain.

Plus two layers above the fourteen:

Cybermark is the fifteenth language — it does not compute, it names, links, and navigates. eight sigils (# @ ~ / $ ^ ! .) form the complete address space. every address resolves to a particle. every connection is a cyberlink. the markup is the graph

Neural is not designed — it grows from the interaction of the fifteen languages at scale.

The Value Tower — Three Modes of Reference

Byte (Rs) and Field (Tri) share the same mathematical substrate — the Goldilocks field processor F_p where p = 2⁶⁴ − 2³² + 1. this substrate provides three atom types sufficient for twelve of the fourteen universes.

three fundamentally different ways to refer to a value — and there are only three:

field = the value IS the reference     (by content — immediate)
word  = position IS the reference      (by location — index)
hash  = name IS the reference          (by commitment — identity)

by what it is. by where it is. by what it is called. every reference in any system reduces to one of these three modes.

every higher type decomposes into structure (Nox trees) over these three atoms:

Edge    = cons(source_hash, cons(target_hash, weight_field))
Event   = cons(event_hash, sequence_word)
Fact    = cons(relation_hash, cons(subject_hash, object_hash))
Sample  = field (amplitude value)
Tensor  = [field; N] (array of values with shape metadata)
Shape   = cons(grade_word, [field; 2^n]) (multivector components)
Chart   = cons(dim_word, [field; N]) (coordinate patch)
Phase   = cons(position_field, momentum_field)
Dist    = [field; N] (probability vector on simplex)

three atoms are complete — for one characteristic. the single exception is Bt (Bitwise): a bit is genuinely not an element of F_p. it lives in F₂ — different characteristic, different algebra. that is exactly why Bt has a separate proof system, not just a new type tag.

Nox value tower (3 atoms: field, word, hash)
  sufficient for: Rs, Tri, Arc, Ren, Dif, Sym, Bel, Seq, Inf, Wav, Ten, Tok
  NOT sufficient for: Bt

Bt value tower (separate, F₂)
  sufficient for: Bt only

The Nineteen Languages

each language has its own page with ops tables, use cases, and proof paths:

proof languages (14) — provable computation

interface languages (5) — human ↔ machine boundary

the proof languages compute over binary trees and field elements. they have no concept of tables, text, files, or network. five interface languages bridge the gap — they handle what the robot needs to interact with humans and external systems. all five run inside nushell (embedded in cyb):

the five interface languages have different properties from the fourteen proof languages:

the interface languages cross the proof boundary — they interact with the external world. but they compose with the proof languages through Nox hints: a nushell pipeline can feed data into a proven computation, and a proven result can be formatted by nushell for display

Compilation Architecture

all nineteen languages share one toolchain. each programmer face has its own syntax and type rules. all compile through Nox — the structural IR — then to proof backends or native execution.

                    ┌──────────────────────────────────────────────┐
                    │              Programmer Faces                 │
                    │                                               │
                    │  Bt  Rs  Tri  Arc  Ren  Dif  Sym  Bel        │
                    │  Seq  Inf  Wav  Ten  Tok                      │
                    │  .bt .rs .tri .arc .geo .dif .sym .bel        │
                    │  .seq .inf .wav .ten .tok                     │
                    └──────────────────┬───────────────────────────┘
                                       │
                    ┌──────────────────▼───────────────────────────┐
                    │             Shared Frontend                   │
                    │   Parsing, type checking,                     │
                    │   borrow checking, bound checking             │
                    └──────────────────┬───────────────────────────┘
                                       │
                    ┌──────────────────▼───────────────────────────┐
                    │         Nox Structural IR                     │
                    │   axis, quote, compose, cons, branch          │
                    │   + typed computational ops                   │
                    │   + Merkle authentication                     │
                    └──────────────────┬───────────────────────────┘
                                       │
              ┌────────────────────────┼────────────────────┐
              │                        │                    │
     ┌────────▼──────┐ ┌──────────────▼──────┐ ┌───────────▼────────┐
     │  Binius/FRI   │ │     Goldilocks      │ │      Native        │
     │  Backend      │ │     TASM/FRI        │ │      Backend       │
     │  (Binary)     │ │    (Byte+Field)     │ │    (no proof)      │
     └───────────────┘ └─────────────────────┘ └────────────────────┘
          Bt              Rs, Tri, Ren            Arc, Seq, Inf,
                                                  Wav, Ten, Tok,
                                                  Dif*, Sym*, Bel*

* Dif, Sym, Bel are research horizon — proof paths are open mathematical problems.

Languages as Type Systems over Nox Patterns

the execution languages are type systems and compilers over Nox's 16 algebra-polymorphic patterns. each language adds domain-specific syntax, type checking, and compilation strategy — but the target is always nox pattern trees. domain-specific operations become jets: compositions of the 16 patterns recognized by formula hash and accelerated to Goldilocks field processor hardware primitives.

language operation           nox composition              jet              GFP primitive
─────────────────────        ──────────────────────────   ──────────       ────────────
Arc: rank(g, steps)          iterated add/mul loops       matmul jet       fma
Wav: fft(x)                  butterfly add/mul network    ntt jet          ntt
Any: hash(x)                 Poseidon2 field ops          hash jet         p2r
Ten: activation(x)           table lookup composition     lookup jet       lut
Ren: geometric_product       mul/add over components      geo_mul jet      fma

the chain: source language → compiler → nox pattern tree → jet recognition → GFP hardware. every domain-specific language gets hardware acceleration through the jet mechanism. the algebra determines which GFP primitive handles each jet.

Rune — Rs on Nox with Host Jets

rune is Rs syntax executed via Nox tree rewriting — the nervous system of the robot. ms-start, async, dynamic, with native access to WASM, GPU, and neural inference.

rune is not a separate language. it is Rs syntax parsed to Nox nouns and interpreted via tree rewriting, extended with three capabilities pure Rs does not have:

three jet categories connect Nox reduction to the host system:

Nox reduction (tree rewriting)
  │
  ├── pure jets → proven computation (14 languages)
  │     fma, ntt, p2r, lut, conservation...
  │
  ├── host jets → practical computing
  │     ├── wasm(module, fn, args)  → wasmi execution
  │     ├── gpu(shader, data)       → wgpu compute dispatch
  │     └── infer(model, input)     → burn-webnn ONNX
  │
  └── hint → async input from the world
        ├── network event (radio)
        ├── user input (cyb UI)
        ├── timer (epoch tick)
        └── cybergraph change (particle/link event)

ms start: parsing Rs to a Nox noun is milliseconds — just tree construction. Nox reduction starts immediately. no compilation step for interactive use.

data structures: Nox nouns ARE the dynamic data structures. Vec → cons-list. HashMap → Merkle tree. String → Hemera hash (a particle). no heap, no GC — allocation is cons, freeing is not referencing.

the proof story: every pure reduction in the script IS provable — the Nox trace captures it. host jets and hints are NOT provable — they cross the proof boundary. but the boundary is explicit and typed. the trace says: "given these hint values and these host jet results, the pure computation was correct."

neural language           ← meaning emerges from the cybergraph
──────────────────────────────────────────────────────────────
rune (Rs + hint + host)   ← nervous system: ms start, async, host access
  pure reductions         ← proven (14 languages over Nox)
  host jets               ← practical (WASM, GPU, ONNX)
  hints                   ← async input from the world
──────────────────────────────────────────────────────────────
14 languages              ← proven computation over Nox patterns

algebra Coverage

The Comparison Matrix

The Ten and the Four

The nineteen languages split into two groups by implementation readiness:

Engineering-ready (10)

Nox, Bt, Rs, Tri, Arc, Seq, Inf, Wav, Ten, Tok — these have known proof paths and well-understood compilation to Tri / Binius. the cyb/architecture specifies these as the build order: Phase 1 (Nox, Tri, Rs), Phase 2 (Arc, Seq, Inf, Tok), Phase 3 (Bt, Wav, Ten).

Research horizon (4)

Ren, Dif, Sym, Bel — these extend the language set into spatial, physical, and self-referential computation. Ren is closest to engineering (Clifford product is F_p algebra with extra structure, STARK-provable now). Dif, Sym, and Bel involve continuous manifolds over finite fields — fundamental open mathematical problems.

Ren completes the perception pipeline: Arc provides topology, Ren provides spatial embedding, the compiler produces vector output for cyb. Bel completes the self-model: the superintelligence's focus vector π lives on a statistical manifold, and Bel formalizes reasoning about its own belief state.

Perception Mapping

every computation language has a canonical rendering — the perception primitive where the shape of the data matches the shape of the display:

a genome sequence is Rs (byte-level encoding) rendered as text. its annotation is Nox (structured tree) rendered as struct. its expression data is Inf (relational query) rendered as table. its protein structure is Arc (topological graph) rendered as vector. its microscopy is Bt (binary pixel data) rendered as pixels. its folding dynamics is Seq (causal event chain) rendered as video. its sequencing signal is Wav (continuous waveform) rendered as sound. its binding energy is Tri (field arithmetic) rendered as formula. its 3D fold is Ren (Clifford rotations) rendered as vector. a genome browser is Ten (composed inference) rendered as component.

all fourteen compile through one structural IR. all fourteen share one proof system (except Bt, which has its own F₂ proof system). all fourteen render through the perception grid. all fourteen exist in the same cybergraph, ranked by the same tri-kernel, earning karma, permanent by axiom A3.

The Address Language

Cybermark wraps all fourteen computation languages with a human-readable address grammar. it does not appear in the computation tables — it operates at a different level

see markup for the full sigil grammar, dimensional navigation, and rendering rules

the FORM triad

the nineteen languages are manifestations of three primitives — proof, bit, step — the atoms of the form triad

every mathematical object is a composition of all three:

• bit (info): what elements are distinguished
• step (comp): what operations transform them
• proof (math): what properties are verified

a group is bit + step + proof: elements (bit), operation (step), axioms hold (proof). a graph is bit + bit: elements + relations. a Turing machine is step + step + step: transitions all the way down

the fourteen proof languages ARE the step. the five interface languages are the channel through which bits flow. proof is what the tri-kernel verifies. together: all computation a mind requires

see cyb/multiproof for how all languages settle under one proof umbrella. see cyb/architecture for how the languages integrate into the operating system. see cyb/whitepaper for the vision. see cybergraph for the accumulation state.