Go-Live Attestations: 9/9 Approved

Theorem-Guided Sovereign FL
in Under 5 Minutes

Start with a Flower-compatible quickstart, then scale into formally verified aggregation, TPM-rooted trust, PQC migration readiness, and Byzantine-resilient coordination.

10M nodes is a formal design target for the Lean theorems below, not an operational deployment claim. Real, reproducible multi-node evidence currently covers 500 live Kubernetes pods.

Repository Badge Header

Live release, CI, security, compatibility, and readiness indicators from the main branch.

Latest Tag Build Go Test CodeQL Security Audit Gate Security Supply Chain Simulator Scale Smoke Verify Proofs Action Pin Check Performance Gate Latest Release Performance Gate Mainnet Readiness Gate Mainnet Chaos Gate GA Tag Safety Go Version Python SDK Compatibility Testnet Status PQC Transport TPM Identity PQC Migration EU AI Act High-Risk Readiness License

CI Status

Live workflow status for test, benchmark, and performance evidence gates.

Performance, Lean, and Machine-Verified Evidence

This documentation map is updated for current repository status so auditors can jump directly to performance evidence, Lean formalization artifacts, CI validation gates, and machine-readable proof outputs.

Test Suite
745
Go test functions across the module
Open Go Test Workflow
Lean Traceability
19
Claim rows, each with its own status label
Open Traceability Matrix
Machine Verifiable
JSON
Machine-readable report + bundle manifest
Open Formal Validation JSON
CI Gates
Live
Lean, test, readiness, and performance workflows
Open Actions Dashboard

Today-Relevant Documentation

Machine-Checkable + Lean Paths

Real-World Scale & Transport Evidence (2026-08-10)

Reproducible, hands-on evidence collected against the actual runtime and transport stack - each doc includes an explicit "what this does and does not establish" section rather than extrapolating beyond what was measured.

  • Kubernetes Scale Deployment Test - 500 real Kubernetes pods running unmodified orchestrator/node-agent binaries with real mTLS identity per replica and real gradient submissions; includes security tests (mTLS enforcement, wrong-token rejection) and real performance data. Explicitly does not claim 1M-node evidence. Reproducible via deploy/kubernetes/scale-test/.
  • Distributed Systems Transport Evidence - real exercise of the repository's libp2p transport stack (relay, hole-punching, partition-style probes), independently re-verified across two hosts. Single-host scope; explicitly does not claim WAN/geographic distribution or TPM attestation.

Empirical Validation & Testing

CI-gated runtime validation with readiness, chaos, and benchmark evidence

Go-Live Gate PASS
9/9
Required go-live attestations approved
Proof Verify Mean Measured
10.55ms
Measured BN254 Groth16 path; fixed genesis identity
PQC Transport Default
Hybrid
x25519-mlkem768-hybrid
Observability Live
Grafana
Tokenomics and runtime dashboards

Byzantine Resilience: What Is and Is Not Proved

Disproven as originally stated

The claim that hierarchical composition of per-tier Multi-Krum guards gives “55.5% Byzantine resilience” has a machine-checked counterexample (hierarchical_composition_counterexample): a two-tier tree in which every tier’s honest-majority guard holds while the global Byzantine leaf fraction is 60%. The 5/9 figure survives only as a single-tier, guard-conditional fact (9f < 5n).

What is machine-checked

Single-tier guard arithmetic (Theorem1BFT.lean), the corrected deterministic composition predicate (ProtocolSafety.lean fractionSafe), and a probabilistic Chernoff repair at deployment scale (chernoff_hierarchical_bound_deployment_scale).

No accuracy-vs-malicious-fraction sweep exists in this repository, so no such chart is shown. The previous version of this page also reported a “Round 45 (30% malicious injection)” attack analysis; no run matching that description exists in the repository and it has been removed. See row 1 of the traceability matrix.

Measured FL Run: Divergence Decay & Accuracy (2026-02-23)

Round 1: divergence 0.141308, accuracy 90.2% Round 16: divergence 0.000145, accuracy 91.2%

20 clients, 16 scheduled rounds (11 executed), no attack injection. Source: results/fl/adaptive_schedule_report.json. This is a small measured run — it is not the 10M-node convergence theorem, and the earlier “83.57% at round 30” figure previously shown here is flagged in the repository itself as needing a reproducible artifact.

Implementation Architecture

Production-grade implementation with formal verification artifacts

Core Runtime (Go 1.27.4+)

cmd/ entry points + internal/ packages

  • cmd/ - 14 entry points: orchestrator, node-agent, federated-router, tpm-metrics
  • internal/ - multikrum, rdp_accountant, hbft, transport, federation, token, tpm, wasmhost
  • internal/pyapi/ - Python SDK C-shared exports (cgo)
  • proofs/ - Lean 4 formalization + traceability matrix

Python SDK v2.2.0

C-shared bridge over the Go runtime

  • Accelerator, gradient, hybrid-proof and utility-ledger operations over cgo
  • Context-managed and async node lifecycle (MohawkNode / AsyncMohawkNode)
  • Structured bridge error codes for verification flows
  • Commitment-bound ZK-proof verification path

Hardware Root of Trust

TPM

TPM 2.0

Trusted Platform Module attestation prevents model poisoning at silicon level

WASM

Wasmtime Runtime

Hardware-agnostic execution environment for edge devices

ARM

Edge Device Support

ARM edge devices today; the NPU port is an open track in CONTRIBUTING

Abstract

We present Sovereign Mohawk, a federated learning (FL) architecture whose formal proofs establish simultaneous guarantees of Byzantine fault tolerance, differential privacy, optimal communication complexity, and cryptographic verifiability for configurations parametrized up to a design target of 10 million nodes. Our core contribution is a proof-driven design methodology that treats formal verification as a constructive tool rather than a post-hoc validation step, yielding a traceability matrix of 19 claim rows that together state exactly which guarantees are machine-checked, which are surrogate or model-level, and which remain open.

The architecture introduces Hierarchical Multi-Krum aggregation. Its earlier “55.5% Byzantine resilience” framing was disproven: a machine-checked counterexample shows a two-tier tree in which every tier’s guard holds while 60% of leaves are Byzantine. What is machine-checked is the single-tier guard arithmetic, a corrected deterministic composition predicate, and a probabilistic Chernoff repair. The hierarchical design is formalized as an $O(d \log n)$ per-update path-depth proxy (total bytes remain model-dependent), and zk-SNARK-based verifiable aggregation is formalized as a constant-cost verifier model — the production verifier checks a fixed genesis identity, not a circuit bound to submitted data.

Scope note: the 10M-node figure is a mathematical parameter in the theorem statements below, formally checked in Lean — it is not a claim that the system has been run at that scale. The largest real, reproducible deployment evidence in this repository is 500 live Kubernetes pods running unmodified orchestrator/node-agent binaries with real mTLS identity and real gradient submissions.

Federated Learning Byzantine Fault Tolerance Zero-Knowledge Proofs Formal Verification Hierarchical Aggregation

Formal Claim Status

The authoritative per-claim status lives in the traceability matrix: 19 claim rows, each labelled fully_formalized, surrogate_verified, model_verified, measure_theoretic_verified or empirically_verified. Every row is machine-checked about a stated model and its hypotheses — none is a machine-checked statement about the deployed Go binary, and the Go↔Lean correspondence is empirical.

CLAIM 1 Byzantine Resilience

Disproven as stated; the corrected guard is machine-checked

The claim that hierarchical composition of per-tier Multi-Krum guards gives “55.5% Byzantine resilience” has a machine-checked counterexample (hierarchical_composition_counterexample): a two-tier tree in which every tier’s honest-majority guard holds while the global Byzantine leaf fraction is 60%. The 5/9 figure survives only as a single-tier, guard-conditional fact (9f < 5n).

Status: compositional claim disproven deterministically; single-tier arithmetic fully_formalized; corrected predicate fractionSafe (ProtocolSafety.lean) and the deployment-scale Chernoff repair (chernoff_hierarchical_bound_deployment_scale) machine-checked.
CLAIM 2 Differential Privacy

RDP composition closed; Gaussian bound still an axiom

Independent and adaptive RDP composition over the additive ledger is machine-checked, and the (ε, δ)-DP conversion Go’s CheckBudget applies is formalized separately through a computable log-bound sandwich (Refinement/RDPLogBound.lean). The Gaussian mechanism bound is carried as an explicit axiom rather than a derived result.

Status: surrogate_verified_with_gaussian_axiom; core composition closed for independent and adaptive mechanisms; full (ε, δ) conversion no longer a gap.
CLAIM 3 Communication

Logarithmic path depth proved; total bytes model-dependent

The hierarchical per-update path depth is formalized as $O(d \log n)$. A separate compression theorem would be required for any sublinear total-byte claim; the naive uncompressed round is exactly dimension·(n+1)·4 bytes (Refinement/Transport.lean), i.e. $O(dn)$.

Status: fully_formalized for path depth; total-byte compression not proved — the earlier “40 TB → 28 MB” figure on this page had no artifact behind it and has been removed.
CLAIM 4 Straggler / Dropout Resilience

Model-verified liveness guards

Liveness guards are proved about an explicit Chernoff probability model for redundancy levels r = 4, 8, 12 at 90% per-replica availability (Theorem4Liveness.lean, Theorem4ChernoffBounds.lean). Probability-measure and full stochastic formalization remain planned work. A superseded 2025 sign-off that claimed “99.902% > 99.99%” contained an arithmetic error and is marked SUPERSEDED in the repository.

Status: model_verified — proved about the stated probability model, not the deployed runtime.
CLAIM 5 Cryptographic Verifiability

Constant-cost verifier model; not a Groth16/q-SDH formalization

The checked claim is a constant-operation verifier cost model with concrete runtime guards. The production verifier checks a fixed genesis identity, not a circuit bound to submitted gradient/model data, and a full Groth16/q-SDH formalization is out of scope. The Schnorr/Ed25519 identification reduction (SchnorrReduction.lean) is fully formalized algebra modulo an explicit forking step.

Status: model_verified — the 10.55 ms verify figure is a measured runtime number, not a formal constant.
CLAIM 6 Convergence

Envelope guard plus an a.s. result with an explicit open hypothesis

The integer/rational convergence envelope is machine-checked as a numeric guard. The measure-theoretic capstone (MultiKrumConvergence.lean) proves almost-sure convergence under a Robbins–Monro diminishing step size, and states openly that it needs an unbiasedness hypothesis the Multi-Krum selection rule does not supply. The stronger non-convex $O(1/\sqrt{KT})$ bounds remain roadmap work.

Status: measure_theoretic_verified; unbiasedness hypothesis open.
19
Traceability Claim Rows
9/9
Go-Live Attestations
745
Go Test Functions
500
Node Scale (Real K8s Deployment)
10M
Node Scale (Formal Design Target)
O(d log n)
Path Depth (Formal)

Open Source Repository

Complete implementation with formal specifications, test suites, and verification artifacts available on GitHub.

rwilliamspbg-ops/Sovereign-Mohawk-Proto
Reference node agent + MOHAWK runtime
Go
Primary Language
9/9
Go-Live Attestations
Gated
Readiness + Chaos CI
View Repository