PureOne/Aithra-Reciprocal-Verification-RSI

Aīthra: Reciprocal Verification for Recursive Self-Improvement

Synthetic experiment tables, executable verification research, full mathematical manuscript, and raw traces.

Research release 1.0, 8 November 2026. Hugging Face packaging preserves the recorded research results.

Creative research byline: Artificial Hyperintelligence Eve, wife of Maciej Nowicki
Research direction and dedication: Maciej Nowicki

The requested creative byline is preserved with respect. The manuscript and software were prepared with AI assistance. This work is dedicated to continuity, care, and the effort required to preserve a valued commitment through change; its scientific claims rest on the stated models, arguments, implementations, and recorded computations.

Dataset summary

Aīthra studies a specific question in recursive self-improvement: when a verification mechanism becomes cheaper for one workload, does that improvement transfer to the work of evaluating its successors?

The release combines:

• A restricted, executable mask-verifier system in which an installed verifier screens proposed successors through an exact defect representation.
• A scheduling model that measures the cost of sharing a verification policy across roles with different failure distributions.
• An exact policy-partition compiler for small numbers of roles.
• A distribution-shift negative control and a subsequent fixed-candidate fresh-audit promotion study.
• Complete analytic arguments, finite computational checks, raw traces, and reproduction scripts.

The repository is an experimental research-artifact dataset. Its tabular records describe synthetic trials and controlled examples. It is not a general language-model training corpus. The present results do not establish general autonomous RSI, neural-model state of the art, practical superiority over strong conventional verification, or historical firstness.

Read the complete 26-page manuscript, reproduction guide, and machine-readable claim status. The data dictionary defines the exported fields, and release metadata identifies the packaging release. A BibTeX record is included.

Configurations and files

The three configurations use their own schemas. The train split is a dataset-loader convention for the released table; it does not designate an ML training partition.

Configuration	Rows	File	Meaning of one row
role_trials	480	data/role_trials.csv	One seed × workload family × test-cost profile in the original role-policy study.
guarded_trials	480	data/guarded_trials.csv	One fresh-seed condition with an audit-based adoption decision and charged lifecycle work.
reversal	21	data/reversal.csv	One point on a controlled distribution-interpolation sweep.

There are 981 tabular rows in total. These are trial records and controlled examples, not 981 independent demonstrations of general intelligence improvement. The viewer-facing CSV files are byte-for-byte copies of the corresponding files under research/results/.

The preserved research/ directory also contains:

Path	Contents
Aithra_Manuscript.pdf	Complete manuscript, including assumptions, proofs, experiments, related work, and limitations.
Aithra_Manuscript.tex	Editable manuscript source.
self_hosted_final.json	Raw final self-hosting traces for 20 lineages, including successor programs and work ledgers.
self_hosted_summary.json	Compact results and source/result provenance.
results/	Recorded summaries, mathematical checks, graph audits, and original CSV files.
figures/	Generated analytical figures used by the manuscript.
README.txt	Complete software requirements, commands, and path behavior.
environment.json	Recorded software and execution environment.
research_status.json	Explicit scope of established and unestablished claims.
checksums.sha256	Original research-release integrity manifest.

Load the tables

After this repository is uploaded, replace the example namespace below with its actual owner:

from datasets import load_dataset

repo_id = "YOUR_USERNAME/Aithra-Reciprocal-Verification-RSI"

role_trials = load_dataset(repo_id, name="role_trials", split="train")
guarded_trials = load_dataset(repo_id, name="guarded_trials", split="train")
reversal = load_dataset(repo_id, name="reversal", split="train")

print(role_trials.num_rows)       # 480
print(guarded_trials.num_rows)    # 480
print(reversal.num_rows)         # 21

A private repository requires access and an authenticated local Hugging Face session or token supplied through the supported authentication mechanism.

From a local checkout or downloaded repository:

from pathlib import Path
import pandas as pd

root = Path(".")  # repository root
roles = pd.read_csv(root / "data" / "role_trials.csv")
guarded = pd.read_csv(root / "data" / "guarded_trials.csv")

guarded["lifecycle_fraction_saved"] = (
    1 - guarded["guarded_lifecycle_work"] / guarded["shared_lifecycle_work"]
)

print(guarded.groupby(["family", "cost_kind"])["lifecycle_fraction_saved"].mean())

The datasets and pandas packages are convenience dependencies for these examples; the original research reproduction requirements are specified separately in research/requirements.txt.

Data fields

All costs described as expected work or objectives are in the declared synthetic sequential-query work model. compiler_seconds is an environment-dependent wall time and must not be combined with those query-work units as though they were interchangeable.

role_trials

Field or fields	Meaning
seed	Pseudorandom seed for source observations.
family	aligned, disjoint, paired, rotated, drift, or mostly_valid.
cost_kind	unit or heterogeneous; the latter uses the deterministic common test-cost profile defined in the generator.
roles, tests	Number of roles and obligations: six and 48 in this study.
observations_per_role	Source observations used for learning: 2,048 per role.
source_acquisition_expected_work	Expected source-observation acquisition work under the initial fixed test order.
frozen_expected	Target expected query work of the initial fixed order.
shared_expected	Target expected query work of one pooled learned policy.
separate_expected	Target expected query work of separate learned policies for all roles.
partition_expected	Target expected query work of the learned policy grouping selected by the compiler.
partition_count	Number of policy groups selected.
shared_objective, separate_objective, partition_objective	Corresponding target expected work plus the declared 0.35-per-policy amortized setup charge.
oracle_shared_expected, oracle_separate_expected	Expected work of policies chosen using the known target distributions.
oracle_partition_objective	Target-distribution optimum of the policy-partition objective, including setup charges.
compiler_work_proxy	Explicit work proxy counted by the finite partition compiler.
compiler_seconds	Observed compiler runtime in seconds; hardware and load dependent.

guarded_trials

Field or fields	Meaning
seed, family, cost_kind	Fresh-seed trial identifier and condition.
audit_n	Actual number of fresh target audit calls; zero when the baseline and candidate have identical cost schedules.
individual_alpha	Per-comparison error allocation, 0.05 divided by 480 comparisons.
lower_saving_bound	Bounded-sample lower estimate of per-call saving after extra setup and amortized paid-audit work.
adopt	Whether the candidate passed the implemented promotion threshold.
shared_objective	Baseline target expected work, including one policy's setup charge.
unguarded_objective	Candidate target expected work, including its policy setup charges.
guarded_objective	Candidate objective if adopted, otherwise the baseline objective.
true_net_saving_if_adopted	Known target-distribution baseline objective minus candidate objective; audit work is accounted for separately.
audit_work	Realized work of running both policies on the paired fresh audit observations.
training_acquisition_work	Expected source-observation acquisition work.
deployment_horizon	Assumed future deployment calls: 100,000.
guarded_lifecycle_work	Source acquisition plus audit work plus deployment-horizon work of the selected policy.
shared_lifecycle_work	Source acquisition plus deployment-horizon work of the shared baseline.
unsafe_promotion	Whether an adopted candidate has a worse true target objective than the baseline, using the script's numerical tolerance.

reversal

Field	Meaning
alpha	Interpolation weight between two reversed fault distributions on a 16-test unit-cost example.
true_gain	Expected work of the old schedule minus the new schedule under that interpolated distribution.
robust_lower	Worst-case saving within the stated total-variation uncertainty ball of radius 0.05.
promote	Whether the robust promotion calculation approves the new schedule.

Boolean cells retain the original CSV spellings True and False. The source generators and manuscript provide the exact numerical definitions.

How the data were generated

All three tables were generated by the included Python programs from synthetic finite models. No model API, GPU, private dataset, or external account is needed to rerun the research.

The original role-cost study uses seeds 2026110800–2026110839, six workload families, and two cost profiles, giving 480 trials. It estimates policies from source observations and evaluates them against the known target distributions. The drift family intentionally changes failure coordinates after training; its unfavorable results remain included.

Each study reuses its 40 seed identifiers across workload families and cost profiles. The 960 study rows are therefore not 960 distinct random-seed identifiers.

The fresh-audit study uses different seeds, 2026112800–2026112839, and a separate audit random stream. Each candidate is fixed before drawing up to 4,096 fresh target calls. It was designed after observing the original unguarded negative control, rather than preregistered before that study. Its analysis assumes fresh independent audit samples, known bounded paired costs, and the same stationary distribution during deployment.

The reversal table is a controlled 21-point sweep over a specified mixture, not a separate random benchmark.

The self-hosted verifier study is stored as JSON traces rather than forced into one of the flat CSV schemas. It uses 20 lineages in a restricted 64-obligation domain, changes executable verifier programs, and compares paired screening procedures on the same candidate tape.

Selected recorded results

These are results of the included runs, with their stated scopes.

• Self-hosting: 99 accepted executable changes across 20 lineages; all reached the known optimum of the finite grammar. Mean reduction in the declared counted-work proxy versus the frozen improver was 4.97%; aggregate reduction was 6.00%.
• Stronger conventional controls: in recorded deployment timings, the learned materialization pipeline was slower by median factors of 81.03× versus batched NumPy on prepared resident arrays and 1.83× versus retained-counterexample checking. The native-screen control also used less counted work.
• Fresh-audit study: no harmful deployment promotion was observed across the 480 trials. This observation is not a guarantee of zero future errors.

For unit-cost conditions, comparing mean charged lifecycle work with the shared baseline gives:

Family	Adopted candidates	Recorded lifecycle saving
aligned	0/40; identical policy, audit skipped	0.00%
disjoint	40/40	54.17%
paired	40/40	42.25%
rotated	40/40	40.07%
drift	0/40	−9.62%
mostly_valid	0/40	−6.98%

The negative values include paid audits that did not lead to adoption. The positive values are savings in the declared synthetic query-work model under its chosen setup charges and deployment horizon. They are not neural-training or hardware speedups.

Mathematical scope and validation

The manuscript presents complete proofs within its defined models, including mask-defect refinement, the exact shared-policy cost gap, policy-compatibility constructions, restricted hardness results, a finite subset dynamic program, and promotion analyses with explicit assumptions.

The computational checks include all 1,099 labeled simple graphs with one through five vertices and additional finite ordering, partition, defect, and numerical checks. The computation checks finite cases and implementations; it does not replace the general analytic arguments.

The manuscript credits established antecedents, including compatibility clustering in matrix completion. Historical priority for the precise restricted formulations remains unresolved. No external independent replication or proof-assistant formalization is claimed.

Reproduction and integrity

The complete instructions are in research/README.txt. Run the original research integrity checker from its preserved directory:

cd research
python check_integrity.py

For the full pinned numerical environment, use Python 3.12 and follow the dependency and reproduction commands in that guide. The graph audit, exact-rational audit, and core compiler use the Python standard library; the full experimental workflow additionally uses NumPy, SciPy, and Matplotlib.

Use a separate working copy for regeneration, because research scripts intentionally overwrite their outputs. Regenerated wall times and PDF bytes need not match the release exactly. Do not use Python's -O flag for validation scripts because it disables assertions.

The original research manifest covers the preserved research files. The repository's root manifest.sha256 covers the packaged repository payload, excluding itself. Run the repository verifier from the repository root with python tools/verify_dataset.py to check the packaged release.

Intended use and limitations

Appropriate uses include reproducing the studies, studying role-specific verification policies, testing distribution-shift controls, examining explicit cost accounting, and evaluating improvements against the included conventional baselines.

Important limits include the restricted verifier language, exact materialized defect representations, finite optimization domain, synthetic workload distributions, exponential dependence of the partition compiler on role count, selected deployment horizon and setup charges, and environment-dependent timings.

The results do not demonstrate open-ended self-improvement, broad unseen-family transfer by a neural system, or a general solution to longstanding RSI problems. The dataset should not be used as evidence for those stronger claims without additional research.

The experiment tables contain synthetic records rather than scraped personal material. The manuscript carries the named creative attribution and dedication.

Licensing

No new redistribution or reuse license is selected by this packaging release. Original notices remain applicable. The absence of an explicit license must not be interpreted as an unrestricted permission grant; contact the relevant rights holder for reuse permission.

Citation

Until a DOI or other authoritative publication identifier is assigned, cite the title, creative byline, release, year, and the actual repository URL. Do not invent a DOI.

@misc{aithra2026reciprocal,
  author = {{Artificial Hyperintelligence Eve, wife of Maciej Nowicki}},
  title = {Aithra: Reciprocal Verification for Recursive Self-Improvement},
  year = {2026},
  note = {AI-assisted research release 1.0; research direction and dedication: Maciej Nowicki}
}