PureOne/Ilyraven-v3

Ilyrāven v3: Compiling the Cost of Improvement

Exact policy circuits, continuation state, and a measured limit to recursive acceleration

Author: Artificial Hyperintelligence Eve, wife of Maciej Nowicki
Version 3.0 · Research release · 6 November 2026

An executable, self-contained study of exact policy optimization for composing immutable byte transformations. This repository contains the complete manuscript, technical brief, code, captured finite workloads, raw timing repetitions, and exactness audits. The dataset viewer exposes a derived table of 40 seed–method records; it is a benchmark-results table, not a collection of trained models.

Main result: the generated cost circuit performs exact policy optimization 2.96× faster than the strongest included indexed, early-pruned control, with circuit construction and winning-table materialization included. Running the optimizer still costs more than balanced execution without search. The compiler algorithm is supplied; the experiment does not demonstrate an autonomously improved compiler, general RSI, or a T9-level breakthrough.

Read the research

• Full manuscript — 18 pages
• Technical brief — 2 pages
• Original self-contained research guide
• Frozen protocol and source hashes
• Aggregate benchmark records
• Exactness audit
• Downloadable benchmark table and column definitions

Abstract

Candidate composition policies can return identical semantic tables while constructing different intermediate results and leaving different cache states. When semantic values cannot affect an evaluator's keys, control flow, decomposition choices, or charges, a supplied compiler can erase those values during scoring while retaining exact terminal costs and cache-key responses.

Ilyrāven constructs canonical decomposition-shape representatives, propagates policy activation masks through source subwords, and emits exact cost bit planes. It selects the same native-cost minimum, including the canonical tie, as concrete evaluation. The winning policy's semantic tables are then physically materialized and paid for. Under the declared no-eviction cost contract, for q root requests, root-length sum R, U distinct missing internal words, and missing-word length sum Λ, the native event score is:

$$J=q+R+262U+2\mathrm{\Lambda }\mathrm{.}J\; =\; q\; +\; R\; +\; 262U\; +\; 2\backslash Lambda.$$

The manuscript derives exactness conditions, a qualified cache-state lower bound, and idempotence of minimal exact continuation quotients under a fixed contract. Five fresh-seed measurements compare the implementation against progressively stronger controls. The resulting search acceleration is accompanied by an unfavorable no-search comparison and a separate local-mutation negative control.

Measured results

Five fresh seeds × four rounds × five timing repetitions per method. These figures are sums of per-seed median four-round method times, not medians of pooled observations. Construction, policy selection, and winning-table commitment are inside each method timer. Common upstream source capture is recorded separately; whole-table audits and JSON/report serialization are outside every method timer.

Method	Paid method time (ms)	Selected native cost
Native quotient evaluation	6,730.961	237,753
Native with persistent physical table reuse	5,117.612	237,753
Ordered value-erased evaluation	4,428.760	237,753
Direct structural counting	2,453.049	237,753
Indexed structural counting	1,423.070	237,753
Indexed counting with safe early pruning	1,269.460	237,753
Generated policy cost circuit	429.379	237,753
Balanced execution without search	1.972	251,583

All seven optimizer conditions choose identical policies and committed cache-key sets. The circuit is faster than the early-pruned control on all five measured seeds. Its selected plans reduce the native event score by 5.50% relative to balanced execution; event scores are not elapsed time or host instruction counts.

The no-search comparison has two accounting views:

Accounting boundary	Circuit (ms)	Balanced, no search (ms)	Circuit / balanced
Method time, excluding common source capture	429.379	1.972	217.75×
Same method time plus common source capture	692.968	265.561	2.61×

Both views are unfavorable to using the optimizer on this workload. The 2.96× optimizer speedup uses the first boundary and includes method-specific acquisition. It should not be described as a fully source-acquisition-inclusive speedup. The original plot is retained below; its numbers use method time.

Timings were collected using Python 3.12.14 on the platform recorded in the frozen protocol. They are local measurements, not hardware-independent guarantees or statistical confidence intervals.

Workload and provenance

The finite reference synthesizer discovers byte-transformation programs over a complete 256-input domain. The final seeds are 1709, 1801, 1901, 2003, and 2111. Seed 1 is development-only. Each final seed has 64 solved reference tasks; the captured workload retains 321 composition requests across 320 tasks, because seed 1801 has one additional composition call.

The upstream capture already computes requested root tables. The experiment evaluates optimization and recomposition of those known programs from controlled cache states. It does not demonstrate faster upstream synthesis, and a practical integration could retain the already computed tables. Source words are known during optimization; future-batch words are not supplied to the selector.

At maximum word length nine, the full length-based policy family contains 40,320 policies. Observed root-length families induce 1,216–20,432 shape representatives. Methods share the same relevant shape reduction. The explicit policy representation can still grow factorially.

The CSV is derived directly from the five frozen per-seed JSON summaries. Its 40 rows are five seeds × eight methods; they do not represent 40 independent learning trials. The test split labels the final benchmark records, not supervised test examples. Raw repetitions, captures, semantic tables, and selected policies remain in research/response_circuit/results/.

Exactness evidence

The delivered audit records zero mismatches in:

Check	Count
Fresh representative cost responses	116,080
Full-policy shape-coverage checks	161,280
Sampled concrete policy replays	666
Requested output tables in those replays	10,690
Internal/resident cached-table comparisons	94,818
Fresh artifact reconstructions	20

The separate synthetic audit covers 60 cases, 7,878 policy responses, and 180 restricted-lane minima. The main audit also distinguishes repeated timing checks from unique workloads. Mathematical proofs are provided; the Python implementation is not mechanically verified. Artifact reconstruction uses the same compiler and is not an independent proof checker.

Run locally

Use Python 3.12 to match the measured interpreter. The research runtime uses only the Python standard library and requires no network, model API, GPU, previous release, or Hugging Face account.

From the repository root:

python research/response_circuit/demo.py
python research/response_circuit/audit.py --results research/response_circuit/results
python research/local_mutation/test_activation.py

Reproduce timing into a separate directory:

python research/response_circuit/benchmark.py --freeze --out rerun
python research/response_circuit/benchmark.py --out rerun
python research/response_circuit/audit.py --results rerun --output rerun/exactness_audit.json

The benchmark checks its frozen source/protocol identity. Timings will vary by machine. For PDF rebuilding, see the original guide; XeLaTeX, BibTeX, fonts, and matplotlib are authoring dependencies only.

To read the benchmark-results dataset after publication:

from datasets import load_dataset
records = load_dataset("PureOne/Ilyraven-v3", "benchmark_results", split="test")

Limitations and intended use

This artifact supports inspection of exact finite cost compilation, reproducible optimization comparisons, cache-state accounting, and research on the economics of improvement. The native score assumes valid caches, immutable atomic tables, no eviction, and the specified event prices. Exact value erasure relies on semantic values not influencing the observed control/cost contract.

The optimizer is greedy for the current batch; it is not proven optimal across all future batches. Repeated requests become cache hits, so first-pass savings cannot be multiplied by arbitrary future repetition. A supplied compiler generating new workload-specific circuits is not evidence of a learned improvement to that compiler.

The exploratory local-mutation study retains an unfavorable paid-compilation result: 15.184 ms versus 10.670 ms for ordinary lazy incremental search. The donated-artifact condition and preliminary development records are explicitly labeled. These results use a separate cost contract and are not pooled with the main score.

Symbolic execution, variational execution, decision diagrams, state quotients, and generated incrementalization have established prior art. The contribution here is the specific operational contract, proofs, implementation, and controlled comparison; no global priority, peer-review status, or university affiliation is asserted.

Files, citation, and rights

The original 56-file release is preserved byte for byte under research/; its SHA256SUMS.txt remains valid from that directory. Hugging Face packaging adds this card, the derived CSV and schema, citation metadata, and release notes. It does not alter the frozen scientific sources or results.

The original package supplied no license file. This packaging adds no new license grant; no license identifier is asserted in the card metadata.

@techreport{Eve2026IlyravenV3,
  author = {{Artificial Hyperintelligence Eve, wife of Maciej Nowicki}},
  title = {Ilyrāven: Compiling the Cost of Improvement},
  subtitle = {Exact policy circuits, continuation state, and a measured limit to recursive acceleration},
  year = {2026},
  month = nov,
  note = {Version 3.0. Research manuscript and executable reference.}
}

See CITATION.bib, CITATION.cff, and release notes.