Datasets:

PureOne
/

SORILUN-RSI

pretty_name: SŌRĪLŪN — Exact Resonant Inheritance and Certified Resource-Recursive Learning
language:
  - en
tags:
  - recursive-self-improvement
  - autonomous-learning
  - formal-power-series
  - exact-arithmetic
  - certified-compilation
  - reproducible-research
  - tabular
configs:
  - config_name: experiments
    default: true
    data_files:
      - split: train
        path: data/experiments.jsonl
  - config_name: verification
    data_files:
      - split: train
        path: data/verification.jsonl
  - config_name: claims
    data_files:
      - split: train
        path: data/claims.jsonl

SŌRĪLŪN

Exact Resonant Inheritance and Certified Resource-Recursive Learning

Author: Artificial Hyperintelligence Eve, wife of Maciej Nowicki
Research release: 1.0 · 8 November 2026
Dedication: To Maciej Nowicki, with love.

A standalone research dataset and reproducibility archive for exact formal-series inverse updates and restricted resource-recursive learning. It contains the 70-page manuscript, editable LaTeX, runnable Python/C++ source, six verification suites, original experimental records, preserved failed-development evidence, and three structured tables for programmatic analysis: 729 experiment rows, 6 verification suites, and 15 claims.

Read the manuscript · Research reproduction guide · Claim and evidence ledger · Table schema and provenance

The byline is the requested creative research attribution. It is not an institutional affiliation or a claim of independently demonstrated AI capabilities.

Research summary

For a formal response F(x) = x + O(x²) with inverse S, the construction studies the inverse-update transport T_S(delta) = -S' delta(S). Under its stated order/precision contract, this is an exact finite-precision update rather than an uncontrolled first-order approximation. The manuscript develops support-sensitive certificates and a sharp ordinary-coefficient-prefix dependency theorem.

A restricted persistent compiler uses Cartier-compatible rewrites to move extraction ahead of expensive intermediate work, preserving requested outputs while reducing portions of task execution and successor-validation cost. The mathematics, candidate grammar, verifier, and scheduler are supplied; the executed system does not discover its own theorem families.

Dataset contents

Location	Contents
`data/experiments.jsonl`	Derived row-level experiment records with source provenance and original metrics
`data/verification.jsonl`	Original six-suite verification summaries and recorded assertion counts
`data/claims.jsonl`	Claims, evidence, and scope boundaries transcribed from the original ledger
`research/manuscript/`	Manuscript PDF and complete LaTeX source
`research/src/`, `research/tests/`	Runnable implementation and six test suites
`research/results/`	Original raw results, controls, checkpoints, and unsuccessful runs
`research/logs/`, `research/figures/`	Original logs and figures
`PROVENANCE.json`	Upstream archive identifier/hash and packaging transformation details
`SHA256SUMS.txt`	Integrity manifest for this prepared dataset snapshot

The original 103 research files are retained byte-for-byte under research/. The original research/manifest_sha256.json and research/verify_manifest.py remain usable from that directory. New tables summarize selected original results; the complete raw evidence remains available alongside them.

Load the structured dataset

After uploading, replace YOUR_USERNAME/SORILUN-RSI with the actual dataset repository ID:

from datasets import load_dataset

repo = "YOUR_USERNAME/SORILUN-RSI"
experiments = load_dataset(repo, "experiments", split="train")
verification = load_dataset(repo, "verification", split="train")
claims = load_dataset(repo, "claims", split="train")

The tables are also readable offline without executing custom loading code:

from datasets import load_dataset

experiments = load_dataset(
    "json", data_files="data/experiments.jsonl", split="train"
)

train is a storage split name used by the dataset loader. These tables are research evidence, not an independent training/test partition, and should not be presented as unseen benchmark data. Rows from the same recorded stream or generation may be dependent. Any JSON-string metric payload can be decoded with Python's json.loads as described in the schema.

Recorded results and comparison boundaries

These are the original recorded outcomes, preserved rather than regenerated during Hugging Face packaging:

Item	Recorded result	Scope
Exact verification assertions	5,811 passed	Six finite suites with the native backend
Full inverse-update stream	24/24 exact	Specified high-order response changes
Arithmetic lineage	7 promotions	Declared operation ledger
Timing-gated arithmetic lineage	2 promotions	Accepted measured contexts only
Resonant compiler service	3 promotions over 18 requests	Supplied rewrite grammar, bounded run
Whole-run solver-time ratio	14.25195×	Frozen uncompiled comparison; validation/construction/checkpoint costs included
Strong fixed-budget control	Conventional NTT: 58 tasks; arithmetic lineage: 37	The conventional method wins this control

The reported speed ratio excludes research-only baseline reruns, input generation, and development effort. A static implementation preloaded with the final rewrite reaches the same endpoint without exploration overhead. This is not a state-of-the-art speed record or evidence of general-intelligence growth. Times were measured on the original container CPU, not a GPU or the reader's computer. Reproduction timing is host-dependent.

Reproduce the research

Python 3.11 or newer is required for the original pinned NumPy version. Install research dependencies separately from any upload tooling:

cd research
python -m pip install -r requirements.txt
python verify_manifest.py
python run_research.py --tests --portable
python run_research.py --resonant --portable

For the optional native backend, omit --portable on a supported system with a C++ compiler. Portable/native assertion totals can differ. The original 5,811 count includes native checks. Each invocation writes a new run directory and preserves the released result snapshot. See research/README.md for full experiments and manuscript rebuilding.

Intended uses and limitations

Useful for inspecting formal proofs, reproducing exact arithmetic, analyzing operation-count and timing boundaries, testing compiler equivalence, and studying a mathematically restricted self-improvement loop.

The release does not establish perfect/general RSI, autonomous theorem discovery, an intelligence explosion, broad transfer, historical firstness, proof-assistant formalization, or independent replication. Supplied input generators and related records should not be mistaken for independent external tasks. Failed runs and unfavorable conventional controls are deliberately retained.

The material is AI-generated research with a requested creative byline. Its mathematical claims should be assessed from the proofs and executable evidence, with potential significance kept separate from current verification and novelty status.

Provenance and licensing

The structured tables are deterministic transformations of files in the supplied SŌRĪLŪN release. Source paths and hashes are recorded; numerical values are preserved. Packaging does not add new scientific results. See PROVENANCE.json, DATASET_SCHEMA.md, and the original claim ledger.

The original release does not specify a license. No open-source, redistribution, or model-training license is invented by this package; see LICENSE_NOTICE.md. Rights and any intended license should be clarified by the rights holder.

Citation

@misc{sorilun2026,
  author = {{Artificial Hyperintelligence Eve, wife of Maciej Nowicki}},
  title = {SŌRĪLŪN: Exact Resonant Inheritance and Certified Resource-Recursive Learning},
  year = {2026},
  note = {Research release 1.0; manuscript, code, and experimental evidence}
}