This page shows the build path directly: bare metal to runtime, runtime to screen, screen to evidence. It demonstrates the current system, evaluates the major claims, and points to the exact evidence behind each one.
The point of the page is not to describe the theory in the abstract. It is to show the theory becoming visible, executable evidence in the browser.
Minimal controls, visible state, and one clear job: make the system easy to trust.
Show the cost directly: many representations on the left, one canonical artifact on the right.
namespace freight
transition Dispatch {
pre:
truck.status == Idle
truck.fuel > 0
remove:
truck.location = Depot
add:
truck.location = Route
truck.status = Running
truck.fuel -= 10
}
Code API Database Messaging Audit Replication 6 Different Models
State Transition Proof 1 Model
Workers are active participants here. They partition work, compute local proofs, and merge back into one canonical result.
Analyze repository graph
Worker A: src/ Worker B: docs/ Worker C: contracts/
Canonical reduction pending
These are the claims people care about first. The UI should make them obvious before anyone reads implementation details.
One transition model keeps behavior consistent as actors, modules, and replicas increase.
Replay and canonical reduction remove redundant translation work and shrink the surface area of coordination.
Independent replicas can arrive at the same result from the same history without negotiation.
Loss of a node becomes recovery work, not meaning loss, because the history is append-only and replayable.
Skeptic-facing summary: the page provides evidence for a deterministic compute substrate, while keeping formal claims and implemented demos clearly separated.
Complexity ≈ representations × translations Canonical replay reduces both terms. One state model. One witness model. One replay path.
CPU → same replay GPU → same replay Edge → same replay Mobile → same replay Server → same replay Measured on the browser paths in this demo.
Apps Data Messaging Audit Recovery Contracts Distributed compute Coverage shown across the app surface.
Malicious node changes result Replay rejects proof diverges Tampering is detected in the evidence lab.
Region A → replay → S Region B → replay → S Region C → replay → S Same history Same witness Same final hash
API trust Database trust Queue trust Audit trust Validator trust Replica trust Reduced by: deterministic replay canonical reduction independent verification
This section makes the core thesis explicit: one model can be evaluated across domains, scale tests, and verification paths. It provides evidence for generality without claiming final victory.
Domain A: apps Domain B: data Domain C: contracts Domain D: recovery Domain E: identity Domain F: distributed compute Same primitive: State → Transition → Proof
Region 1 → replay → S Region 2 → replay → S Region 3 → replay → S Region 4 → replay → S Bandwidth grows with history, not with trust negotiations. Local verification, global agreement.
Consensus asks: who agrees? Convergence asks: what does the proof compute? Comparison stack: trust → consensus → convergence Current claim: deterministic verification is the center of gravity.
Each claim is shown as a lemma, a theorem, and an implementation witness.
Deterministic replay defines truth.
Replay(H) = S for a given history H.
The recovery and convergence buttons recompute the same canonical hash from history.
Independent replicas converge.
Replay(Hₐ) = Replay(Hᵦ) if the histories are equal.
Run convergence renders the same hash for Node A, Node B, and Node C.
Invalid transitions are rejected.
Validate → witness → commit only if invariants hold.
The VSE ledger rejects failed invariants and stores the witness hash on commit.
This is the page-level answer to the reviewer critique: the claims below are the obligations that must be proved, not just asserted.
Given identical genesis G and identical valid history H, all honest observers compute one state S. Replay(G + H) = S for every honest node.
Encode(x) = Encode(y) iff x = y No collisions. No ambiguity. No alternate canonical form.
Soundness: invalid transition → no valid witness Completeness: valid transition → valid witness
Adversary may: forge messages reorder delivery drop packets duplicate packets fork history delay witnesses Claim: corruption is detected or rejected.
Modify(H) ⇒ witness failure Any undetected rewrite would violate either proof hash equality or canonical replay equality.
Valid State + Valid Transition = Valid State Invalid Transition → detectable rejection System validity is preserved inductively.
A reviewer asked for a theorem stack, so this section names the missing results in the same order they would normally appear in a paper or formal spec.
1. Deterministic convergence 2. Canonical representation 3. Byzantine resistance 4. Replay correctness
5. Witness validity 6. Fault recovery 7. Consensus reduction 8. Complexity analysis
9. Scalability 10. State transition closure 11. State transition containment 12. History immutability
13. AI verifiability 14. Trust minimization 15. Universal compute model
H ↓ Replay(H)
Worker A → State X Worker B → State X Worker C → State X
Hash(X) == Hash(X) == Hash(X)
Enter a prompt Connect Ollama Inspect workspace
Create a transition Commit τ Verify witness
Destroy a node Replay from genesis Observe recovery
Worker A: alive Worker B: alive Worker C: alive
State restored: pending Hash matches: pending Proof matches: pending
Drop rate: 0% Duplicate rate: 0% Latency: normal Forks: blocked
Worker A Worker B Worker C
Hash A: pending Hash B: pending Hash C: pending
Same history → same transitions → same state → same hash
REST API Service Database Cache Queue Audit System Replication Recovery
State Transition Proof
The stack does not grow by adding more systems. It shrinks by removing representations.
JSON SQL Object Message
Canonical Transition ↓ Proof
Different representations. Same meaning. One canonical form.
Transition ↓ Validate ↓ Witness ↓ Commit ↓ Replay ↓ Proof
Hash alone means: data changed. Witness means: transition was valid.
Identity Signature Consensus Quorum Authority
Modifies history Duplicates messages Creates fork
Replay fails Proof hash mismatch Rejected
Dishonest participants do not change truth because transitions are verified before commit.
API ORM Database Queue Cache Audit Replication
State Transition Proof
Conventional systems replace trust with consensus. JC replaces consensus with convergence. Consensus asks humans to agree. Convergence asks mathematics to compute. Truth emerges from deterministic replay.
Enter natural language. The assistant shapes it into a contract spec, deploys it to the ledger, and lets you interact with it.
Validate → commit → witness → replay. That is the pipeline the spec actually cares about.
Short, visual, and proof-oriented.
Only the essentials, so the docs stay primary.
The docs carry the detail. This page exists to back them up.
Point people to your docs first, then use this page to show the system, state, and proof.
Theorem 3: Independent transitions commute under the stated disjointness assumptions. Includes edge-case validation and convergence analysis.
Reference implementation demonstrating deterministic replay, causal ordering, witness generation, and canonical reduction.
These timings are produced in the browser from the real app paths on this page.
Not measured yet.
Not measured yet.
Not measured yet.
These browser-run checks connect the claims to observable behavior using the same replay, witness, and recovery functions the page already uses.
def independent (τ₁ τ₂ : TransitionSpec) : Prop := Disjoint τ₁.pre τ₂.remove ∧ Disjoint τ₂.pre τ₁.remove ∧ Disjoint τ₁.remove τ₂.remove ∧ Disjoint τ₁.add τ₂.remove ∧ Disjoint τ₂.add τ₁.remove
Identity, witnesses, replay verification, permissions, and application-level credential flows.