3,228 Lean 4 theorems · zero sorry

The Void OS

The operating system for bounded witness processes. Every crash, compiler error, rejected scan, stale memory, and race loser becomes structured evidence instead of lost work.

w = R − min(v, R) + 1

3,228+ Lean 4 theorems

0 sorry (unproven)

5 inference forms

See the proofs Open the scanner Aeon Foundation

Skip the slogan. Jump straight to the kernel surface or the Aeon Foundation.

On first read

The operating loop in one glance

Void OS is not a vibe manifesto. It is a witness kernel: generate candidates, test them under pressure, commit what survives, and preserve the rejected paths as bounded evidence.

Fork

Generate parallel paths Run multiple candidates instead of betting on one serial guess.

Race

Select the winner Compare outcomes under pressure and keep the path that actually survives.

Fold

Commit irreversibly Collapse the winning path into state so the system can move forward.

Vent

Train on rejection The discarded paths become the evidence surface for the next decision.

Operating loop

Four primitives

Every process in Void OS follows one pattern. Fork parallel paths. Race to select among them. Fold the winner irreversibly. Vent what the fold cannot preserve -- and learn from it.

Self-Training Loop

Every failure feeds the complement distribution. Scanner rejections, compiler errors, race losers -- all become training signal. The system strengthens from what it gets wrong.

live void_boundary_sufficient_statistic

Psyche Certificates

SSL for your soul. Void Merkle trees prove personality integrity without exposing contents. You own the key. We hold the backup. If you lose it -- psyche verification, not password reset.

live void_merkle_tamper_evident

Personality as a Service

UCAN-gated streaming of your digital twin. Apps request your personality profile with your consent. The FoldedKnot carries 35 bits across five dimensions -- zero overhead, self-encoding.

live personality_self_indexes

Holographic Twins

Your personality as a 3D knot. Five strands of the braid group B₅ rendered as volumetric topology. Rotate, zoom, watch Reidemeister moves in real time. One integer reconstructs the entire hologram.

live teleportation_completeness

Witness kernel

Turn rejection into state

Void OS treats every runtime event as a bounded witness process. It does not ask the system to pretend it knows the truth. It records what survived, what failed, what was stale, what carried source authority, and what remains an audit gap.

01 Candidate

A process, memory, scan, market observation, or agent answer enters as a bounded candidate.

02 Envelope

Confidence, freshness, calibration, sample weight, and privacy budget define what may be claimed.

03 Verdict

The trit surface admits accept, decline, and abstain. Deferral stays first-class.

04 Memory

Survivors can be recalled. Rejections become negative evidence. Gaps remain visible.

Live boundary

Buleyean weight

w = R - min(v, R) + 1

Total options R Times rejected v

R 7

v 3

w 5

The sliver remains. Even after repeated rejection, weight bottoms at 1 instead of disappearing.

Storage plane

Knotgraph carries the witnesses

Void OS storage lands on open-source/knotgraph: content-addressed fp64[54] knotchain blocks, D1 indexes, R2 rows/columns/clusters, and Edgework's UCAN-gated /api/v1/r2/* proxy for distributed inference weights, Vickrey tables, helix blocks, and corpus manifests.

Block fp64[54] knotchain substrate

Blob R2 content-addressed payloads

Index D1 latest-version and tenant scope

Edge Edgework R2 proxy with cache headers

Kernel packet

One witness, end to end

A Void OS event becomes a packet with an envelope, a verdict, a lane race, a storage commitment, and a cost trace. The page exposes the same contract at /api/kernel.

Capture runtime event

Crash, scan rejection, stale recall, model miss, market signal, or agent disagreement.

Envelope bounded claim

Confidence, freshness, calibration, sample weight, privacy budget, source-authority boundary.

Race lane winner

TypeScript, WASM, and GG lanes compete per operation and workload class.

Commit knotgraph block

Accepted witnesses land as content-addressed fp64[54] blocks with R2/D1 indexes.

Vent negative evidence

Declines, abstentions, stale records, and failed lanes remain queryable instead of disappearing.

Lane race op + workload -> champion

lane.ts D1 / R2 / proxy I/O

lane.wasm BKS / fp64 / packed knots

lane.gg topology plans / schema rewrites

60 knotgraph Lean proofs

0 sorry markers

4 open composition obligations

Weight law

The God Formula

One equation drives everything -- process scheduling, pricing, inference, training. The same formula that optimizes neural weights optimizes the operating system.

        -- The Buleyean weight update

        -- R = total options, v = times rejected, w = weight

        theorem buleyean_positivity :

          forall (R v : Nat),

            w R v = R - min v R + 1 > 0 :=

          -- No option ever reaches zero probability.

          -- The sliver (+1) guarantees exploration.

          by omega

Parallelism is free. Serialization costs. Same price, higher throughput. Always fork when you can.

Failure is the sufficient statistic. The void boundary (rejection history) contains more information than success. Train on what is not.

The sliver (+1) guarantees exploration. No option ever reaches zero probability. Positivity is structural, not parametric.

Convergence is a theorem, not a hope. Same rejection history produces same distribution. Mechanized in Lean 4.

Immanent self-hosting. The void verifies itself from inside. No external oracle. The compiler compiles the compiler.

Proof surface

Mechanized guarantees

Proofs bound the runtime surface. Void OS separates structural guarantees from product claims so the kernel can say exactly what it is allowed to carry forward.

3,228+ Mechanized theorems

0 Sorry markers

Lean 4 Verification engine

buleyean_positivity

P(i) > 0 for all i -- the sliver

buleyean_normalization

sum(P) = 1 -- a proper distribution

void_boundary_sufficient_statistic

Rejection history preserves all information

void_walkers_converge

Same rejections = same distribution

fold_safety

A decline veto blocks unsafe admission

authority_schedule_unsound

Source-authority claims do not enter active recall

valid_privacy_budget_bounded

Signal envelopes carry bounded privacy budgets

teleportation_completeness

The deficit determines the entire future trajectory

novel_inference_forms_master

Five inference forms from three axioms

Runtime stack

Architecture

Local-first by default. Proof-carrying status at the edge. Runtime state is carried as envelopes, verdicts, memory atoms, and audit gaps.

        // The kernel

        import { AeonKernel } from '@a0n/void-os-core';

        const kernel = new AeonKernel();

        // Fork: create parallel paths

        const [a, b, c] = kernel.fork('analyze', 3);

        // Race: select the winner

        const winner = kernel.race([a, b, c]);

        // Fold: merge irreversibly

        const result = kernel.fold(winner);

        // Vent: the losers become training data

        // Every rejection strengthens the system

        kernel.vent([a, b, c].filter(x => x !== winner));

Kernel

Local runtime core

@a0n/void-os-core -- fork/race/fold/vent process model, FoldedKnot filesystem, consciousness bridge, Buleyean wallet

Shell

Native interface

aeon-shell -- Tauri native app for macOS/Linux/Windows. Void OS daemon syncs every 30s. Routes: browse, rhizome, map, genesis.

Cloud Kernel

Distributed state plane

Knotgraph over Cloudflare storage: R2 for content-addressed blocks and payloads, D1 for append-only indexes, Durable Objects where coordination needs a resident lane, and Edgework's R2 proxy for cacheable artifact reads.

Inference

Execution fabric

Aether distributed runtime. WASM SIMD kernels. Glossolalia temperature-ensemble. All self-hosted, zero cost at edge.

Call surface

The void is alive.

Built by AFFECTIVELY. Backed by math. Rejection is the sufficient statistic for intelligence.

Scanner See the proofs Aeon Foundation