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.
Live workflow status for test, benchmark, and performance evidence gates.
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.
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.
CI-gated runtime validation with readiness, chaos, and benchmark evidence
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).
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.
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.
Production-grade implementation with formal verification artifacts
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
C-shared bridge over the Go runtime
MohawkNode / AsyncMohawkNode)
Trusted Platform Module attestation prevents model poisoning at silicon level
Hardware-agnostic execution environment for edge devices
ARM edge devices today; the NPU port is an open track in CONTRIBUTING
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.
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.
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).
fully_formalized; corrected predicate fractionSafe (ProtocolSafety.lean)
and the deployment-scale Chernoff repair (chernoff_hierarchical_bound_deployment_scale)
machine-checked.
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.
surrogate_verified_with_gaussian_axiom; core composition closed for independent and adaptive
mechanisms; full (ε, δ) conversion no longer a gap.
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)$.
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.
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.
model_verified — proved about the stated probability model, not the deployed runtime.
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.
model_verified — the 10.55 ms verify figure is a measured runtime number, not a
formal constant.
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.
measure_theoretic_verified; unbiasedness hypothesis open.
Complete implementation with formal specifications, test suites, and verification artifacts available on GitHub.