snapkitty
agents
python
6502-asm

Source: github.com/SNAPKITTYWEST/sovereign-mum

Sovereign MUM

License: Tri Paper Model Invariant 6502 SAT KID-8B/8K Lean 4 Zenodo

Authors: Ahmad Ali Parr, Jessica L. Williams (SNAPKITTYWEST)
Stack: Python · PyTorch · 6502 ASM · Lean 4 · WORM ledger

A hallucination is not a quirk. It is an invalid state transition.

Sovereign MUM formalizes Google's Multitask Unified Model as a deterministic multimodal Markov Decision Process — stripping the probabilistic mythology and exposing the actual state machine.

Model weights W are not a magic oracle. They are a deterministic transition matrix. A state transition that cannot be mathematically justified by input atoms is an invalid operation. Full stop.


How This Compares to Google MUM

Google's MUM (Multitask Unified Model, 2021) is 1,000× more powerful than BERT, processes 75+ languages, and handles text and images in a shared encoder-decoder architecture. It is the state of the art for multimodal search and retrieval.

It has no formal semantics.

Property Google MUM Sovereign MUM
Architecture T5 encoder-decoder + sparse MoE Same, plus formal atom semantics
Multimodal ViT patch projection + early fusion Shared semantic manifold M
State Implicit, lost between turns Explicit A_n — auditable 3-tuple
Hallucination Behavioral quirk Invalid state transition — rejected
Cross-modal context Dot-product attention Semantic gradient boundary
Verification None A_{n+1} audited before A_{n+2} proceeds
Formal proof None Lean 4, zero sorry
Audit trail None WORM chain per transition
Child safety None KID-8B/8K — 8 KB 6502 safety kernel
License Proprietary Tri-license (AGPL / BSL 1.1 / MIT)

Sovereign MUM is not a reimplementation of Google MUM. It is the formal architecture Google MUM should have been built on.


The Central Invariant

R(A_n, W) → A_{n+1}

R is the reasoning operator. W is the model weights. A_n is the current verified atom. A_{n+1} is the next atom — but only if the transition is mathematically justified.

Under standard autoregressive generation, W predicts the next token in a vacuum. Under Sovereign MUM, R enforces a strict boundary condition:

                    A_n
                     │
                     ▼
              ┌─────────────┐
              │  R(A_n, W)  │
              │             │
              │  compute    │
              │  delta_z    │
              └──────┬──────┘
                     │
                     ▼
            ┌────────────────┐
            │ Boundary check │
            │ ∂Ω_{n+1} valid?│
            └───────┬────────┘
                    │
          ┌─────────┴─────────┐
          ▼                   ▼
       VALID               INVALID
          │                   │
          ▼                   ▼
       A_{n+1}          HALT + RECORD
    (proceed to          (chain intact,
      A_{n+2})           no propagation)

The chain does not break. A halt is recorded. Invalid output does not propagate.


What Is a Multimodal Atom?

A text token, a 16×16 image patch, and a 20ms audio frame are arbitrary system artifacts — not semantic boundaries.

An atom is defined topologically, not by file format.

A_n = ( z_n , P_n , ∂Ω_n )
Component Definition
z_n ∈ R^d Latent vector in shared semantic manifold M
P_n Projection back to grounded origin (which pixels / tokens / frames)
∂Ω_n Topological boundary — where this concept ends

The boundary is defined by the semantic gradient:

∂Ω_n = { x ∈ M : ‖∇f(x)‖ ≥ ε }

One atom = one coherent concept.

                 INPUT STREAM
                      │
          ┌───────────┼───────────┐
          ▼           ▼           ▼
        text        image        audio
    subword tok   16×16 patch  20ms frame
          │           │           │
          ▼           ▼           ▼
    ┌─────────────────────────────────┐
    │      ModalityEncoder E_m        │
    │    project into manifold M      │
    └─────────────────┬───────────────┘
                      │
                  z ∈ R^d
                      │
             semantic gradient
                      │
          ┌───────────┴───────────┐
          ▼                       ▼
       atom A_1               atom A_2
    (red car)              (blue sky)

If an image contains a red car and a blue sky, the sharp gradient splits them into A_1 and A_2. The atom boundary is dictated by information density — not file type.


The Shared Semantic Manifold

All modalities project into a single manifold M where distance represents pure semantic relationship:

       text: "red car"
             │
             ▼
         E_text ──► z ∈ M ◄── E_image
                               ▲
                               │
                         image patch
                         (red car pixels)

Cross-modal context is preserved because proximity in M reflects semantic similarity — regardless of whether the input was a spoken word or a photograph.

The transition function computes a relationship vector Δz from retrieved context, and applies it:

z_{n+1} = z_n + Δz

Because A_{n+1} must carry its own explicit boundary ∂Ω_{n+1} and grounding P_{n+1}, the transition is mathematically constrained. A CUDA kernel that returns a state violating the boundary conditions is rejected before it can propagate.


MoE Routing Under the Formalism

MUM uses sparse MoE layers. The router does not inherently know whether a vector represents a subword token or an image patch — by the time tokens reach the router, they are uniform dense vectors in R^d.

Under Sovereign MUM's formalism, this is a feature, not a bug:

text token z_text ──────┐
                         ▼
image patch z_image ──► Router ──► expert selection
                         ▲
audio frame z_audio ────┘

The router learns to recognize the statistical signatures of each modality's region in M. This is emergent topological specialization — not explicit modality routing.

Load balance forces the router to distribute uniformly. Sovereign MUM adds a verification step: the expert output must still satisfy ∂Ω_{n+1} before emission.


KID-8B/8K — Children's Safety Kernel

The 8B model is not in the kernel. The kernel is the trusted surface that represents it.

🧒 Child
   │
   ▼
┌──────────────────────────────────────┐
│  KID-8B/8K — 6502 SAT Kernel (8 KB) │
│                                      │
│  🧱 SAT boot verifier               │
│  🧼 PII scrubber                    │
│  🧭 Age + topic policy VM           │
│  🔐 Signed model-request broker     │
│  🛡 Output safety verifier          │
│  👨‍👩‍👧 Parent / educator controls    │
│  ⛓  Append-only audit chain        │
└──────────────────┬───────────────────┘
                   │  CAP_LESSON_REPLY only
                   ▼
          8B model (separate host)

SAT Boot Invariant

The kernel begins in safe mode and evaluates a 15-byte SAT formula before enabling any capability:

BOOT_OK = SAT(F, A) ∧ x0 ∧ x1 ∧ x2 ∧ ¬x3 ∧ ¬x4
Variable Safety meaning Required value
x0 KERNEL_INTEGRITY — ROM / policy hash verified True
x1 CHILD_PROFILE_VALID — age band + consent valid True
x2 PRIVACY_FILTER_ACTIVE — identifier minimization on True
x3 UNRESTRICTED_TOOLS — shell, web, messaging, files False
x4 RAW_REMOTE_SESSION — unfiltered direct model channel False

Five 3-literal clauses:

C1: (x0 ∨ ¬x1 ∨ x2)      $00 $81 $02
C2: (¬x0 ∨ x1 ∨ ¬x3)     $80 $01 $83
C3: (x1 ∨ x2 ∨ x3)        $01 $02 $03
C4: (¬x2 ∨ ¬x3 ∨ x4)     $82 $83 $04
C5: (x0 ∨ x3 ∨ ¬x4)      $00 $03 $84

Assignment %00000111 = $07. All five clauses TRUE. Carry set. SANDBOX_READY.

🧱 Kernel integrity  = ON
🧒 Child policy      = ON
🔐 Privacy filter    = ON
🛑 Unrestricted tools = OFF
🚫 Raw model access  = OFF

8 KB ROM Budget

Address range Bytes Module
$0800-$08FF 256 Boot verifier + SAT seed
$0900-$0BFF 768 Input normalization + PII removal
$0C00-$11FF 1,536 Policy bytecode VM
$1200-$15FF 1,024 Model broker (CAP_LESSON_REPLY only)
$1600-$1BFF 1,536 Output classifier + redaction
$1C00-$1EFF 768 Parent / educator settings
$1F00-$21FF 768 Audit receipts + hash chain
$2200-$25FF 1,024 Local educational templates
$2600-$27FF 512 Version, manifest digest, key material

Capability Firewall

CAP_LESSON_REPLY     ✅ only permitted capability

CAP_NETWORK          ❌
CAP_BROWSER          ❌
CAP_SHELL            ❌
CAP_FILESYSTEM       ❌
CAP_CAMERA           ❌
CAP_MICROPHONE       ❌
CAP_LOCATION         ❌
CAP_CONTACTS         ❌
CAP_PURCHASE         ❌
CAP_SEND_MESSAGE     ❌
CAP_MODEL_RECONFIGURE ❌
CAP_POLICY_WRITE     ❌

Architecture

                    RAW INPUT
              (text / image / audio)
                        │
                        ▼
             ┌──────────────────────┐
             │   ModalityEncoder    │
             │   E_m → z ∈ M ⊂ R^d │
             └──────────┬───────────┘
                        │
                        ▼
             ┌──────────────────────┐
             │  Boundary Detection  │
             │  ‖∇f(x)‖ ≥ ε        │
             │  split into atoms    │
             └──────────┬───────────┘
                        │
                     A_1 … A_n
                        │
                        ▼
             ┌──────────────────────┐
             │  R(A_n, W)           │
             │  StateTransition     │
             │  delta_z = f_W(z_n,  │
             │            context)  │
             └──────────┬───────────┘
                        │
                        ▼
             ┌──────────────────────┐
             │  Boundary Verify     │
             │  ∂Ω_{n+1} valid?     │
             └──────────┬───────────┘
                        │
              ┌─────────┴─────────┐
              ▼                   ▼
           VALID               INVALID
              │                   │
              ▼                   ▼
           A_{n+1}          WORM HALT RECORD

Theoretical Foundation

DOI Contribution
10.5281/zenodo.21132094 Sovereign Compute Architecture
10.5281/zenodo.21443609 Jordan Spectral Transformer
10.5281/zenodo.21349277 Gates Normalization Constraint
10.5281/zenodo.21351461 NAND Decomposition
10.5281/zenodo.20678420 Attention Exhaustion Attacks
10.5281/zenodo.21727363 PAR-011 Jacobian via Jordan Algebras
10.5281/zenodo.21268911 GKN I4 Quartic Invariant and E7 Symmetry

Unified paper: The Sovereign Stack — 26 pages, all proofs in Lean 4, zero sorry, no mathlib.


Repo Structure

sovereign-mum/
├── src/
│   ├── mum/
│   │   └── atom.py          # A_n 3-tuple, manifold encoder, semantic gradient
│   │                        # boundary, state transition morphism
│   ├── kernel/
│   │   └── kid_8b_8k.py     # Python reference: 8 KB child safety microkernel
│   └── 6502/
│       └── sat_kernel.asm   # 6502 NMOS SAT boot verifier, 15-byte seed
├── paper/                   # formal paper
├── tests/
├── LICENSE                  # Tri-license: AGPL / BSL 1.1 / MIT
└── README.md

License

Tri-license — choose any one:

  • AGPL-3.0 for open source / community use
  • BSL 1.1 → MIT for commercial / production use (< 5 servers free; converts to MIT 2029-01-01)
  • MIT after 2029-01-01

See LICENSE for the full text and six protected inventions.

Copyright (C) 2026 Ahmad Ali Parr, Jessica L. Williams / SNAPKITTYWEST
Bel Esprit D'Accord Irrevocable Trust


The weights are not the answer. The transition is the answer. The boundary is the proof.

💼 Commercial License

Snapkitty code is free and open under AGPL-3.0 for open-source use. Building a commercial product or service? A proprietary commercial license from Snapkitty Collective LLC lets you ship this code without the AGPL's source-sharing and network-use obligations.

→ Get a commercial license · A.parr@belespritdaccord.uk

Downloads last month

-

Downloads are not tracked for this model. How to track
Inference Providers NEW
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support

Space using Snapkitty/sovereign-mum 1

Collection including Snapkitty/sovereign-mum