axiom
Get started
Axiom / alpha state

Assignments that
adapt with the graph.

A deterministic maximal-matching engine for changing graphs. Basic and Multilevel are integrated with a durable local service; resource and deployment qualification is still in progress.

Try the alpha See what’s next

Research preview — not production-qualified.
The latest million-vertex Linux gate exposed memory failures in startup/recovery. Read the current evidence.

BASIC + MULTILEVEL   /   SQLITE DURABILITY   /   ALPHA

BASIC / EIGHT VERTICESVerified small trace
Recovered matching at committed version threeAn eight-vertex degree-four ring, with sixteen edges and matching pairs zero-one, two-three, four-five, six-seven. Delete and reinsert edge zero-one, then reopen the SQLite store: the matching is recovered exactly.01234567
16 edges4 matching pairsMaximal ✓
  1. 01delete(0, 1)v2 · partner ∅
  2. 02insert(0, 1)v3 · partner 1
  3. ↳close → reopenv3 · partner 1
Small deterministic example; not scale qualification.Reproduce →
2
paper matching modes
basic + multilevel
1 million
Basic updates exercised
recovery gate still fails
0
modes deployment-qualified
qualification is open
10k/s
durable update target
not yet demonstrated
One update. A complete path.

Incremental repair. Durable state.
One coherent answer.

A local graph component with explicit contracts at every boundary. No hidden network service. No silent admission on overload.

01 / COMPUTE

Repair, not recompute.

Basic and Multilevel paper modes maintain maximal matching over compact graph storage. Their million-vertex memory envelope is still being qualified.

Matcher
02 / COMMIT

Acknowledge durably.

SQLite FULL-WAL operation history is the recovery authority. The selected paper mode replays that history; constrained recovery currently has an open memory failure.

Durable
03 / PUBLISH

Query a coherent version.

Thread-safe admission, one mutation owner and partner queries coupled to committed versions. Bounded queues reject overload.

Service
Current qualification · Linux resource gate

Measure the system
that ships now.

Historical native-engine rates are not evidence for today’s paper modes. The current 512 MiB address-space qualification exposes unresolved memory failures.

Basic · incomplete

Updates complete.
Recovery still fails.

1,000,000 durable updates in 110.443 seconds (~9,054/s), with 14,971 partner queries and backup completed. Disk-pressure recovery then raised MemoryError rebuilding System indexes.

Multilevel · failed

Startup exceeds
the resource cap.

The million-vertex service could not finish its initial matching refresh under the 512 MiB address-space limit. This run does not qualify startup, updates, or recovery.

Run 37202924572 · 512 MiB address cap · 192 MiB ext4 volumeInspect workflow logs ↗

The Basic figures come from this run’s Basic matrix job; its later recovery step failed. These are constrained resource diagnostics, not a throughput qualification or production-readiness claim. The 10k durable updates/s target remains unproven for Basic and Multilevel.

See the alpha roadmap →
Small interface. Explicit contracts.

Python at the edge.
Durability at the core.

Submit an ordered update. Wait for commit. Query a partner and its committed version. Keep the database when your process stops.

  • Bounded, thread-safe client admission
  • Deterministic Basic/Multilevel paper matching
  • SQLite recovery and exact retained retries
Read the API contracts →

ALPHA / INSTALL FROM SOURCE

pip install git+https://github.com/sachncs/axiom.git
service.pyVerified Python example
from pathlib import Path
from tempfile import TemporaryDirectory
from axiom.durable import Request
from axiom.service import Service

with TemporaryDirectory() as directory:
    with Service(Path(directory) / "graph.db", n=128) as graph:
        outcome = graph.submit(Request(1, "delete", 0, 1)).result(5)
        assert graph.partner(0).result(5) == (outcome.version, None)
        assert graph.check().result(5)
Local component · GIL-enabled CPython · C++17 build required
Two ways in

Engineered to use.
Open to inspect.

For engineers

Keep a changing graph current.

Explore the bounded, thread-safe local Service with paper-mode matching, SQLite durability, versioned reads, and clearly documented recovery limits.

Production contracts →
For researchers

Trace the theorem to the code.

Compare the paper’s subgraph system, recursive levels, invariants, and the exact boundary of what is not yet claimed.

Explore research →
Paper algorithm integration

Explore the paper.
Inspect the boundary.

A Faster Deterministic Algorithm for
Fully Dynamic Maximal MatchingJulia Chuzhoy · Sanjeev Khanna · Junkai Song · STOC 2026Read the paper ↗

Basic and Multilevel share the durable local service, bounded SQLite batches, and deterministic operation-log recovery. Qualification is not complete: the latest constrained million-vertex run fails Multilevel startup and Basic disk-pressure recovery. The 10k updates/s target and paper-level asymptotic guarantees are not established. Historical native-matcher measurements do not qualify these paper modes.

Paper areaAxiom status
Subgraph systemImplemented
Recursive levelsImplemented and checked
Invariant I3Runtime checked
Colouring and full boundValidation ongoing · not claimed
See the complete implementation boundary →
Alpha · research and integration preview

Build on a graph that
keeps moving.

Paper-derived matching with SQLite-backed local durability. Start with the API, and review the open resource and recovery gates before deployment.

pip install git+https://github.com/sachncs/axiom.git

Alpha · install from source; neither matcher mode is deployment-qualified.

Read alpha status & evidenceRun the walkthrough