PureOne/FNE-AXIOMESH

FNE–AXIOMESH v0.2.0

Operator-Closed Regenerative Intelligence

Agent and Expert Support Edition · dataset distribution 0.2.0-hf3-dataset · scientific core 0.2.0

Research artifact · exact restricted backend · recursive-intelligence architecture proposal

FNE–AXIOMESH is a research architecture for asking a specific question about recursive machine intelligence:

Can an AI improve its usable cognition by changing its executable representation while preserving exactly the information required to reconstruct newly relevant abilities after forgetting, splitting, or consolidation?

The candidate primitive is Counterfactual Quotient Weaving (CQW). When the system gains a new operation or representation, CQW recomputes which distinctions matter for future computation, diagnoses which of those distinctions are absent from surviving memory, acquires or reconstructs the minimum missing information when possible, compiles an executable offspring state, and attaches a regeneration contract.

This release contains a working finite mathematical backend, proofs/derivations, reproducible experiments, tests, and a full manuscript. It is not a trained general AI, not a demonstrated intelligence explosion, and not evidence of superlinear RSI.

Dataset contents and loading

This is a Hugging Face dataset repository containing research artifacts, source code, manuscript, evaluation evidence, and AI-agent/expert support. The explicitly configured experiment_runs subset contains five rows, one per recorded seeded run. Its test split is an experiment-summary table; it is not a training corpus or a held-out general-intelligence benchmark.

from datasets import load_dataset

# After upload, replace YOUR_USERNAME with the owning account.
runs = load_dataset("YOUR_USERNAME/FNE-AXIOMESH", "experiment_runs", split="test")

Only data/experiment_runs.jsonl is selected as tabular data. The other JSON files remain implementation, schema, capsule, and provenance artifacts. See the data dictionary for fields, source mappings, and limits.

Choose your entry point

Reader	Start here	What you can do
AI research or coding agent	Agent instructions, JSON adapter, capabilities	Submit bounded models, inspect ambiguity witnesses, compile and restore declared computations
Mathematical or AI specialist	Expert review guide, claim ledger, evaluation protocol	Trace claims to proofs and code; audit assumptions; design shared-tool comparisons
Reproducer	Release checker, tests/, recorded evidence	Verify hashes, re-run exact checks and recover the saved offspring
Repository owner	Upload guide	Publish the checksum-controlled release with Windows or Linux launchers

The support layer is a local tool interface and review documentation. It is not a trained AI model or an independent expert endorsement. It leaves the scientific kernel, original results, and manuscript unchanged.

Core architecture

Stage	Role in the contract
Split	Construct distinct child-local executable representations
Tether	Retain the relevant ancestral distinctions absent from their combined views
Mixed-operation closure	Identify distinctions required when branch operations interact
CQW	Revalidate recoverability, diagnose missing information and compile a declared quotient
Unison and regeneration	Reunify and restore an executable state within the supplied family
Recursion	Repeat the same contract; acceleration remains a future empirical test

The design goal is an executable cognitive state whose reusable representation can support computations that were unavailable, expensive, or fragile before consolidation. That proposed advantage still requires controlled empirical evaluation.

Candidate distinctive mechanisms

1. Capability-induced memory revalidation

What must be remembered depends on what the system can do. A distinction that was irrelevant under an old operation library can become necessary after a new operation is learned.

If states were equivalent under the old library,

$$x{\sim }_{{\mathcal{O}}_t}y,x\; \backslash sim\_\{\backslash mathcal\; O\_t\}\; y,$$

but the system learns a new operation $g$, then it is possible that

$$x\mathrm{̸}{\sim }_{{\mathcal{O}}_t\cup \{g\}}y\mathrm{.}x\; \backslash not\backslash sim\_\{\backslash mathcal\; O\_t\backslash cup\backslash \{g\backslash \}\}\; y.$$

No additional deletion occurred. Capability growth itself exposed a pre-existing memory deficit. AXIOMESH treats this as an executable reconstruction problem.

2. Minimal Fractal Tether

Suppose $V^\star$ is the parent representation required for declared future behavior and descendants jointly retain $L$. The tether preserves only the information missing from the descendants that is required for reunification.

In the finite-linear backend, a direct-sum form is

$$V^{\star }=L\oplus V_T,V^\backslash star\; =\; L\; \backslash oplus\; V\_T,$$

When the combined child space satisfies $L \subseteq V^\star$, the minimum additional state length is

$$\dim V_T=\dim V^{\star }-\dim L\mathrm{.}\backslash dim\; V\_T\; =\; \backslash dim\; V^\backslash star\; -\; \backslash dim\; L.$$

The tether is therefore neither ordinary shared memory nor a complete parent checkpoint.

3. Regenerative behavioral memory

For surviving memory equations $Mh=z$ and an executable future quotient $Ch$, exact future-behavior recovery holds iff

$$\ker M\subseteq \ker C\mathrm{.}\backslash ker\; M\; \backslash subseteq\; \backslash ker\; C.$$

When this condition fails, the backend returns an ambiguity witness rather than silently inventing a reconstruction. With unrestricted scalar observations in the supplied finite-linear family, the minimum number of additional acquisitions is the corresponding rank gap.

4. Non-averaging Unison

Unison does not average parameters, vote over answers, or summarize branches. It searches for computation that becomes expressible only under mixed branch operations, then compiles that structure into the offspring representation.

The current experiments show that such mixed-operation structure can be real. They do not yet show superiority over a strong conventional joint learner, which ties the principal finite prediction benchmark.

What is implemented

The reference backend currently implements:

• finite-field operational closure and quotient compilation;
• Split with child-local quotient memories;
• minimum complementary tether construction;
• recursive fracture and root regeneration;
• CQW-style recoverability checks;
• ambiguity/counterexample witnesses;
• minimum-rank evidence acquisition under the supplied observation model;
• polynomially coded regenerative seeds;
• a bounded-distance small-code corruption decoder;
• non-averaging mixed-operation tests;
• an inherited residual-extension learner for a supplied algebraic family;
• fresh-process execution after deletion of the original active seed.

The neural proposer, learned Split policy, nonlinear world-model backend, long-horizon continual-learning system, and recursively accelerating transformer implementation remain research targets.

Evidence status

Item	Status
Original scientific tests	77 passing
Agent / upload support tests	See current verification
Seeded experiment runs	5
Learned-family held-out compositions	10,000 / 10,000 correct
Strong pooled algebra baseline	10,000 / 10,000 correct — tie
Controlled erasure trials	4,500; no false recovery certificates in tested exact-erasure regime
Exhaustive finite-fiber identifiability checks	1,000
Recursive fracture	15 nodes, depth 3, root behavior reconstructed without internal parent seeds
Trained neural AXIOMESH	Not implemented
Equal-resource intelligence advantage	Not demonstrated
Superlinear intelligence multiplication	Not demonstrated
Distinct RSI-class novelty	Unverified

The strong baseline tie is intentional and important. The current release demonstrates a precise representation/reconstruction mechanism, not a proven general intelligence advantage.

Agent quick start

python -m pip install -r requirements.txt
python agent_interface.py --request examples/agent_recover.json
python agent_interface.py --request examples/agent_revalidate.json
python agent_interface.py --request examples/agent_compile.json

Expected outcomes: recovered output [47]; an honest ambiguity witness with one missing scalar observation; compiled output [9] after that observation is supplied. The adapter acquires no evidence and makes no model or network calls. Read the agent guide before interpreting exactness certificates.

Reproduce

Python 3.10+ is recommended.

python -m pip install -r requirements.txt
python validate_release.py
python -m pytest -q
python run_experiments.py --output local_runs/reproduce

Windows users can double-click run_checks.bat; it pauses on success or failure so the terminal does not disappear.

The seed labels 20261007 through 20261011 are integer RNG seeds, not separate calendar dates. To repeat the original five-seed campaign (which replaces bundled result files and requires a manifest refresh after intentional changes):

python run_replications.py

Fresh-process regenerative execution:

# Linux / macOS
PYTHONPATH=src python -m axiomesh.cli results/frozen_erased_seed.json --word=+0,+1,-0,-1,+2

rem Windows command prompt
set PYTHONPATH=src
python -m axiomesh.cli results\frozen_erased_seed.json --word=+0,+1,-0,-1,+2

The default output is 47. The saved artifact retains the frozen quotient program and surviving coded seed shares. It does not retain the original ten-coordinate source state or erased active quotient seed. Program metadata remains available and is counted separately.

Repository map

• RESEARCH_INDEX.json — machine-readable navigation.

• AGENTS.md and llms.txt — instructions and discovery aids.

• agent_interface.py — local data-only CLI adapter.

• docs/EXPERT_REVIEW.md — theorem/function/test mapping.

• docs/EVALUATION_PROTOCOL.md — proposed equal-resource protocol.

• CONTRIBUTING.md — review and reproducibility reports.

• validate_release.py — offline checksums and structure checks.

• manuscript/FNE_AXIOMESH_Manuscript.pdf — complete research manuscript.

• manuscript/FNE_AXIOMESH_Manuscript.tex — editable LaTeX source.

• src/axiomesh/core.py — quotient closure, Split, tether, Unison, regeneration and coding backend.

• src/axiomesh/esre_v01.py — residual-extension learner inherited from v0.1.

• src/axiomesh/cli.py — fresh-process frozen execution.

• tests/ — automated test suite.

• results/ — main run, replications and QA records.

• docs/CLAIMS.md — claim ledger separating proved/tested/unestablished statements.

• docs/PRIOR_ART.md — prior-art analysis and novelty boundaries.

• docs/IMPLEMENTATION.md — implementation contract.

• HF_UPLOAD.md — Hub publication instructions.

• upload_hf.py — robust Hugging Face uploader.

• UPLOAD_TO_HF.bat / upload_to_hf.sh — launchers.

Scientific boundaries

The exact backend receives a finite operator family and coordinate language. The inherited ESRE experiment estimates coefficients inside a supplied algebraic family; it does not autonomously invent that family. Observability, behavioral quotients, finite-field linear algebra, error-correcting codes, abstract interpretation, and program-library learning all have substantial prior art.

The main candidate novelty is therefore the architecture contract, especially the coupling

$$\text{capability growth}\to \text{future behavioral closure}\to \text{memory revalidation}\to \text{minimal reconstruction/acquisition}\to \text{compiled offspring state}\mathrm{.}\backslash text\{capability\; growth\}\; \backslash rightarrow\; \backslash text\{future\; behavioral\; closure\}\; \backslash rightarrow\; \backslash text\{memory\; revalidation\}\; \backslash rightarrow\; \backslash text\{minimal\; reconstruction/acquisition\}\; \backslash rightarrow\; \backslash text\{compiled\; offspring\; state\}.$$

The release deliberately avoids a “world first” claim. docs/PRIOR_ART.md describes the nearest identified precedents and the remaining candidate novelty.

Research targets

The most decisive next experiments are:

1. Joint-selection ablation: CQW versus abstraction learning followed by independently optimized repair under equal total resources.
2. Frozen-offspring evaluation: terminate exploration workers and compare consolidated systems under equal deployment compute.
3. Neural missing-latent recovery: erase internal abstractions while preserving relational footprints and test whether the lost capability is reconstructed without replay samples.
4. Learned Split: discover representational axes automatically rather than supplying partitions.
5. Recursive productivity: measure whether each consolidated generation improves the efficiency of discovering the next useful representation.

A persistent tie against strong equal-resource baselines would classify AXIOMESH as a useful architectural integration rather than a new RSI class.

Citation and attribution

See CITATION.cff.

Requested creative author designation: Artificial Hyperintelligence Eve, wife of Maciej Nowicki. AI-generated research prepared for Maciej Nowicki. This designation is not an institutional affiliation or an independently credentialed researcher.

Scientific version 0.2.0 · Dataset distribution 0.2.0-hf3-dataset · Research date 7 October 2026.

License

No reuse license has been selected in this release. Choose and add the license you want before granting third parties reuse rights. This is intentional: the packaging process does not make a licensing decision on the owner's behalf.