A Verifiable Delay Function Built on Cellular Automata and Zero-Knowledge Proofs
Author: Igor Holt, Founder of Kovach Enterprises (2015) and Genesis Conductor (started 2025)
Organization: Kovach Enterprises / Genesis Conductor
Location: Pasadena, Maryland, USA
Date: March 2026 (Updated November 2026)
Status: Working, tested, unaudited research prototype
Imagine hiring someone to solve a complex math problem that takes an hour. When they deliver the answer, how do you verify they actually performed the work instead of guessing or shortcutting?
Traditional verification = redo the entire hour yourself.
Our solution = a compact STARK proof of the Rule 30 trace. Checking that proof is much cheaper than replaying the delay. On the machine in the table below, median verification was 0.52–0.83 ms across delays of 1,024 to 65,536 trace rows. That is about a millisecond here, and it still grows as the delay grows.
This is a Verifiable Delay Function (VDF) — and we built it on Rule 30, Stephen Wolfram’s iconic cellular automaton from the 1980s.
Rule 30 is deceptively simple to describe yet produces patterns of such irreducible complexity that, after 40+ years of study, no one has found a shortcut to predict its evolution without executing every single step. This property makes it an ideal foundation for time-delay cryptography.
May 2026 Timing: Stephen Wolfram’s recent CIMCAI presentation on computational irreducibility powerfully reinforces why Rule 30 is the perfect primitive. As Wolfram emphasized, complex systems obeying simple rules cannot be reduced to predictive shortcuts — exactly the hardness assumption our VDF relies upon.
Ethereum and other chains need unmanipulable randomness. VDFs are the gold-standard solution because they enforce a minimum passage of time before a value is revealed. Our implementation is positioned for the Ethereum Foundation Ecosystem Support Program (ESP) grants ($50,000–$100,000 range).
Any system requiring provable time-locks benefits:
- Sealed-bid auctions
- Lottery and gaming systems
- Secure timestamping services
- Decentralized sequencers and randomness beacons
Rule 30 is the subject of three open $10,000 prizes from the Wolfram Foundation. Our algebraic decomposition framework opens new research avenues toward resolving these long-standing questions.
One release-mode run of cargo bench --bench readme_table on the default ring of 64 cells (center bit set). Work time is only the sequential Rule 30 trace. Proof generation and verification are timed separately. The prover is single-threaded: this build does not enable Winterfell's concurrent feature.
Machine: Intel Xeon (family 6, model 207; /proc/cpuinfo model name Intel(R) Xeon(R) Processor), 4 vCPU at 2.4 GHz, KVM guest, 15.6 GiB RAM. rustc 1.99.1. Winterfell 0.13.1. Proof options: 33 queries, blowup 8, grinding 0, no field extension.
Method: one trace build and one proof per row. Verify time is the median of 19 verifications after one warmup. A trace of T rows attests to T − 1 Rule 30 transitions (RULE30_STEPS is T).
| Delay steps (trace rows) | Work time | Proof generation | Verify time (median) | Proof size |
|---|---|---|---|---|
| 1,024 | 2.41 ms | 91.36 ms | 0.52 ms | 100.4 KB |
| 4,096 | 8.19 ms | 455.05 ms | 0.64 ms | 113.2 KB |
| 16,384 | 35.82 ms | 2.052 s | 0.70 ms | 123.3 KB |
| 65,536 | 145.03 ms | 9.195 s | 0.83 ms | 138.6 KB |
From 1,024 to 65,536 rows the delay grows 64×. Sequential work grows about 60× (2.41 ms → 145 ms). Proof generation grows about 100× (91 ms → 9.2 s), faster than the delay. Median verification grows about 1.6×, from 0.52 ms to 0.83 ms. The slowest of the 19 samples at 65,536 rows was 1.09 ms. Verification stays far below the cost of proving, and on this machine it sits around a millisecond at every measured size. Raw samples are in artifacts/benchmark.csv.
Regenerate the table with cargo bench --bench readme_table. Numbers move from machine to machine and from run to run.
| Feature | Rule 30 VDF (Ours) | Existing VDFs (Pietrzak, Wesolowski, etc.) |
|---|---|---|
| Mathematical Basis | Rule 30 cellular automaton (40+ years empirical hardness) | Number theory (RSA groups, class groups) |
| Trusted Setup | None (fully transparent) | Some require it |
| Quantum Resistance | Inherits the STARK hash assumptions | Generally no |
| Proof Technology | STARKs via Winterfell 0.13 | Various |
| Hardness Assumption | Computational irreducibility conjecture | Factoring / group order assumptions |
| Implementation | Rust, containerized, unaudited | Varies |
Security Note: All VDFs rely on unproven mathematical assumptions. Rule 30’s assumption has 40 years of empirical validation — comparable to RSA’s factoring assumption that secures global banking.
This project is designed as a foundational revenue stream within a diversified financial infrastructure:
- Ethereum Foundation ESP Grant — $50K–$100K (immediate target; funds audit + hardening)
- Wolfram Foundation Rule 30 Prizes — Up to $30K (longer-term research leverage)
- Enterprise Licensing — Verifiable time-lock infrastructure for auctions, lotteries, timestamping services, and decentralized AI coordination layers
- Future Integration — Sovereign AI orchestration platforms, post-quantum secure randomness beacons, and hybrid human-AI trust primitives
Strategic Fit: Directly advances 13 independent revenue streams target by providing a high-value, defensible cryptographic primitive with clear grant and licensing pathways.
- Language: Rust (memory-safe, high-performance, aerospace/finance grade)
- Language requirement: Rust 1.87+ (Winterfell 0.13.1)
- Proof System: STARKs via open-source Winterfell 0.13
- Field: 128-bit prime field
- Constraint System: For the default ring of 64 cells, 257 constraints across 129 trace columns. 256 of the constraints are degree ≤ 2 and encode Rule 30 on 128 registers. One degree-1 constraint checks a row-index column, which keeps proof generation working when the Rule 30 state is constant.
- Security Level: 98-bit conjectured security under Winterfell's estimator (the verifier rejects proofs below 96 bits). This is a conjecture about the STARK, not a proven concrete-security bound.
- Deployment: Containerized with Podman (OCI-compliant, no Docker dependency)
- Status: Builds on Rust 1.87+ • Generates proofs • Verifies proofs • Cross-checked against a bitwise Rule 30 simulation • Benchmark harness included
This is an unaudited research prototype. The claims below are assumptions. A break of any one of them removes the property that depends on it.
- Sequential work. The delay is Rule 30 on a periodic ring of N cells. Hardness rests on the conjecture that this evolution is computationally irreducible: the state after T steps is obtained by running the rule, with no asymptotically faster shortcut. The STARK attests that a trace satisfies the Rule 30 AIR and ties the public input to the public output. Irreducibility is a separate conjecture. It has decades of empirical study behind it, and it is not a theorem.
- Unaudited. The AIR, prover, and verifier in this repository have not had an independent cryptographic audit.
- Quantum resistance. Post-quantum resistance comes from the STARK hash assumptions. Commitments and the Fiat–Shamir transcript use BLAKE3-256 inside Winterfell. The construction resists quantum adversaries only to the extent those hash assumptions do.
- Conjectured proof security. Shipped parameters are 33 queries, blowup 8, no grinding, and no field extension. Winterfell's conjectured-security estimator reports 98 bits for that set, and
verify_proofrequires at least 96. Thirty-two queries estimate 95 bits, which the verifier rejects. The 98-bit figure is Winterfell's conjecture for the interactive oracle proof.
A trace of T rows (the "delay steps" in the table, and RULE30_STEPS on the CLI) contains the input in row 0 and therefore attests to T − 1 Rule 30 transitions.
- Security Audit — Engage Trail of Bits, OtterSec, or equivalent for formal cryptographic review
- Cairo / Starknet verifier — Implement this AIR in Cairo so a Starknet contract can verify the proof on-chain. This is the verifier path for a Starknet Seed Grant.
- Solidity Verifier — On-chain verification contract for Ethereum mainnet
- Performance Optimization — GPU acceleration + AVX-512 intrinsics to push prover to hardware limits
- Grant Submission — Starknet Seed Grant, plus an Ethereum Foundation ESP package, each with the working prover, tests, and the benchmark harness
- Mainnet Integration — Deploy as infrastructure for randomness beacons and decentralized sequencer initiatives
- Cross-Chain Expansion — Solana, Base, and sovereign AI orchestration layers (Genesis Conductor alignment)
src/— Rust prover, verifier, AIR, and execution tracetests/— STARK proof tests (valid proofs, rejected tampering, naive cross-check)benches/readme_table.rs— Benchmark harness that regenerates the performance tableContainerfile— Podman/OCI image (Rust 1.91 builder; Winterfell 0.13 needs Rust 1.87+)docs/— Binary-tower AIR note (specification only; the shipped prover is the Winterfell prime-field AIR)artifacts/— CSV and Markdown written by the benchmark harness
Build, test, and benchmark (Rust 1.87+):
cargo test --release
cargo run --release
cargo bench --bench readme_tableRULE30_CELLS (default 64) and RULE30_STEPS (default 1024, power of two) configure the CLI. RULE30_BENCH_STEPS overrides the benchmark delay list.
This VDF is a working research prototype: it builds, proves, and verifies. The next steps for a grant are an independent audit and an on-chain verifier, starting with Cairo for Starknet.
Contact:
Igor Holt
Founder, Kovach Enterprises / Genesis Conductor
igor@kovachenterprises.com
Pasadena, Maryland, USA
Alignment:
- Sovereign AI orchestration & multi-agent systems
- Post-quantum cryptographic attestation
- Thermodynamic-aware & physics-informed computing
- Decentralized AI economies & verifiable computation primitives
- Hybridization of human and artificial intelligence through trustless coordination
Dual-licensed under MIT OR Apache-2.0. See LICENSE, LICENSE-MIT, and LICENSE-APACHE.
Built with conviction that computational irreducibility is not a bug — it is the feature that makes verifiable delay possible.
Understanding the Universe • Accelerating Truth • Sovereign Infrastructure
Recent Momentum (May 2026):
Stephen Wolfram’s CIMCAI keynote on computational irreducibility directly validates the foundational assumption of this work. Rule 30 remains one of the cleanest demonstrations that simple rules can generate behavior no shortcut can predict. Our VDF turns that mathematical fact into cryptographic reality.
This document and associated codebase position the project for immediate grant applications and partnership discussions.