INTERACTIVE RUNTIME PROOF EMPIRICAL DEMONSTRATION
Input Python.
Generated Rust. Zero delta.
Fresh quickstart run on Linux x86-64 (CPython 3.13, rustc 1.98.1) converting financial pricing algorithms through COMPARE.
# Precision pricing hot-path
def ema(window: int, alpha: float, prices: list[float]) -> list[float]:
if not prices or window <= 0:
return []
out = [prices[0]]
for p in prices[1:]:
out.append(alpha * p + (1.0 - alpha) * out[-1])
return out
def max_drawdown(equity: list[float]) -> float:
peak = equity[0]
max_dd = 0.0
for val in equity:
if val > peak: peak = val
dd = (peak - val) / peak
if dd > max_dd: max_dd = dd
return max_dd
// Auto-generated by ELYREON Rust Transfer
pub fn ema(window: i64, alpha: f64, prices: &[f64]) -> Vec<f64> {
if prices.is_empty() || window <= 0 {
return Vec::new();
}
let mut out = Vec::with_capacity(prices.len());
out.push(prices[0]);
for &p in &prices[1..] {
let prev = *out.last().unwrap();
out.push(alpha * p + (1.0 - alpha) * prev);
}
out
}
pub fn max_drawdown(equity: &[f64]) -> f64 {
let mut peak = equity[0];
let mut max_dd = 0.0;
for &val in equity {
if val > peak { peak = val; }
let dd = (peak - val) / peak;
if dd > max_dd { max_dd = dd; }
}
max_dd
}
$ elyreon-rust verify --target pricing --seed 1337 --cases 900
[TEST ENGINE] Initializing bwrap sandbox with Python 3.13 and native compiled cdylib...
[SUITE: pricing:ema] Generating 300 randomized price streams (len 100..5000)...
✓ Batch 01 (100 cases) -> PASS · max observed ULP delta = 0
✓ Batch 02 (100 cases) -> PASS · max observed ULP delta = 0
✓ Batch 03 (100 cases) -> PASS · max observed ULP delta = 0
[SUITE: pricing:max_drawdown] Generating 300 randomized volatility sequences...
✓ Batch 01 (100 cases) -> PASS · max observed ULP delta = 0
✓ Batch 02 (100 cases) -> PASS · max observed ULP delta = 0
✓ Batch 03 (100 cases) -> PASS · max observed ULP delta = 0
[SUITE: pricing:fees_total] Generating 300 randomized tier calculations...
✓ Batch 01 (100 cases) -> PASS · max observed ULP delta = 0
✓ Batch 02 (100 cases) -> PASS · max observed ULP delta = 0
✓ Batch 03 (100 cases) -> PASS · max observed ULP delta = 0
----------------------------------------------------------------------------------------------------
FINAL VERDICT: 900 / 900 PASS · 0 MISMATCHES · 0 EXCLUDED · 0 ULP DIFFERENCE · VERIFIED
THE 4-STAGE PIPELINE GROUNDED VERIFICATION
Mathematical rigor.
Never hallucinated.
How ELYREON Rust Transfer transforms critical code without gambling on unverified LLM translations or dangerous compiler assumptions.
STAGE 01 · STATIC INSPECTION
AST Parsing & Strict Subset Boundary Check
"Fast code that computes the wrong number is negative value."
ELYREON reads your typed Python Abstract Syntax Tree. It validates supported constructs (checked i64, IEEE-754 binary64 floats, fixed Decimal, container typing, loops) and explicitly refuses unsafe constructs. Any file I/O, network requests, or dynamic reflection are separated and kept in Python.
STAGE 02 · ZERO-ALLOCATION SYNTHESIS
Deterministic Rust Crate Emission
"Translate the math, respect the borrow checker."
Synthesizes idiomatic Rust code with pre-allocated buffer capacities, borrow-checked slices, and zero heap-thrashing inner loops. Uses Maturin and PyO3 C-bindings to create a standalone native shared library (`.so` / `.dylib`).
STAGE 03 · DIFFERENTIAL FUZZING
Automated 900-Case Differential Verification
"Passing differential cases is finite evidence, but failure to test is negligence."
Generates hundreds of randomized edge-case inputs (fuzzing boundary values, NaN/Inf handling, empty sequences, extremes). Executes both your original Python code and the compiled Rust in parallel, comparing outputs down to the exact float bit (Unit in the Last Place / ULP). If a single mismatch occurs, compilation halts.
STAGE 04 · LOCAL ISOLATION
Sandboxed Delivery & Zero Telemetry
"Your proprietary algorithms stay on your hardware."
Runs entirely within local bubblewrap (`bwrap`) Linux namespaces. Zero network phone-home, zero remote code telemetry, and zero telemetry tokens. Delivers an offline wheel with complete SBOM and reproducibility logs.
HONEST BOUNDARIES THE SUPPORTED SUBSET
What we accelerate.
What stays in Python.
We do not claim universal Python transpilation. Real systems maintain strict, honest boundaries.
Accelerated in Native Rust
- Checked Numerical Loops: Hot iteration over time-series, grids, and numeric arrays.
- Typed Scalar Math: i64 integers with overflow checks, IEEE-754 binary64 floats, fixed Decimal.
- Supported Containers: Typed lists, tuples, dictionaries, and fixed-type sets.
- Dataclasses & Structs: Data objects with statically resolvable typed fields.
- List Comprehensions: Deterministic filter, map, and accumulator loops.
- Selected Math Builtins: sqrt, log, exp, floor, ceil, abs, and trig primitives.
Retained Safely in Python
- Disk & Network I/O: Database queries, HTTP endpoints, file reading, and logging.
- Heavy Dataframe Libraries: Pandas, Polars, and NumPy remain on their native C-backends.
- Asynchronous Runtimes: asyncio event loops, coroutines, and generator pipelines.
- Dynamic Reflection: eval(), exec(), inspect, and untyped dynamic monkey-patching.
- Untyped Dynamic Objects: Missing type hints are flagged and refused before compilation.
- External Cloud APIs: Third-party SDKs and service integrations.
EMPIRICAL PROVENANCE RECORDED TEST RUN
Audited proof.
Inspect the ledger.
Full test configuration and hardware provenance from the October 2026 verification audit.
| PARAMETER |
VALUE |
VERIFICATION SCOPE |
| Audit Job ID |
rust-20261021-215954-3c4fd00935 |
Recorded in verification.json |
| Host Environment |
Linux x86-64 · Ubuntu 24.04 LTS · i5-10600K |
Isolated bwrap namespace |
| Compilers |
CPython 3.13.15 · rustc / cargo 1.98.1 |
Standard production toolchains |
| Differential Cases |
900 / 900 PASS (0 mismatches, 0 errors) |
300 cases each: ema, max_drawdown, fees |
| Observed Float Deviation |
0 ULP (Bit-for-bit identical IEEE-754) |
Verified on binary64 IEEE-754 output |
| Release & Telemetry |
1.0.0 Evaluation Preview · 0 Telemetry |
Local offline execution only |