PureOne commited on
Commit
2861100
·
verified ·
1 Parent(s): d5904bf

Upload AILITH research release 0.5.0

Browse files
.gitattributes CHANGED
@@ -1,60 +1,3 @@
1
- *.7z filter=lfs diff=lfs merge=lfs -text
2
- *.arrow filter=lfs diff=lfs merge=lfs -text
3
- *.avro filter=lfs diff=lfs merge=lfs -text
4
- *.bin filter=lfs diff=lfs merge=lfs -text
5
- *.bz2 filter=lfs diff=lfs merge=lfs -text
6
- *.ckpt filter=lfs diff=lfs merge=lfs -text
7
- *.ftz filter=lfs diff=lfs merge=lfs -text
8
- *.gz filter=lfs diff=lfs merge=lfs -text
9
- *.h5 filter=lfs diff=lfs merge=lfs -text
10
- *.joblib filter=lfs diff=lfs merge=lfs -text
11
- *.lfs.* filter=lfs diff=lfs merge=lfs -text
12
- *.lz4 filter=lfs diff=lfs merge=lfs -text
13
- *.mds filter=lfs diff=lfs merge=lfs -text
14
- *.mlmodel filter=lfs diff=lfs merge=lfs -text
15
- *.model filter=lfs diff=lfs merge=lfs -text
16
- *.msgpack filter=lfs diff=lfs merge=lfs -text
17
- *.npy filter=lfs diff=lfs merge=lfs -text
18
- *.npz filter=lfs diff=lfs merge=lfs -text
19
- *.onnx filter=lfs diff=lfs merge=lfs -text
20
- *.ot filter=lfs diff=lfs merge=lfs -text
21
- *.parquet filter=lfs diff=lfs merge=lfs -text
22
- *.pb filter=lfs diff=lfs merge=lfs -text
23
- *.pickle filter=lfs diff=lfs merge=lfs -text
24
- *.pkl filter=lfs diff=lfs merge=lfs -text
25
- *.pt filter=lfs diff=lfs merge=lfs -text
26
- *.pth filter=lfs diff=lfs merge=lfs -text
27
- *.rar filter=lfs diff=lfs merge=lfs -text
28
- *.safetensors filter=lfs diff=lfs merge=lfs -text
29
- saved_model/**/* filter=lfs diff=lfs merge=lfs -text
30
- *.tar.* filter=lfs diff=lfs merge=lfs -text
31
- *.tar filter=lfs diff=lfs merge=lfs -text
32
- *.tflite filter=lfs diff=lfs merge=lfs -text
33
- *.tgz filter=lfs diff=lfs merge=lfs -text
34
- *.wasm filter=lfs diff=lfs merge=lfs -text
35
- *.xz filter=lfs diff=lfs merge=lfs -text
36
  *.zip filter=lfs diff=lfs merge=lfs -text
37
- *.zst filter=lfs diff=lfs merge=lfs -text
38
- *tfevents* filter=lfs diff=lfs merge=lfs -text
39
- # Audio files - uncompressed
40
- *.pcm filter=lfs diff=lfs merge=lfs -text
41
- *.sam filter=lfs diff=lfs merge=lfs -text
42
- *.raw filter=lfs diff=lfs merge=lfs -text
43
- # Audio files - compressed
44
- *.aac filter=lfs diff=lfs merge=lfs -text
45
- *.flac filter=lfs diff=lfs merge=lfs -text
46
- *.mp3 filter=lfs diff=lfs merge=lfs -text
47
- *.ogg filter=lfs diff=lfs merge=lfs -text
48
- *.wav filter=lfs diff=lfs merge=lfs -text
49
- # Image files - uncompressed
50
- *.bmp filter=lfs diff=lfs merge=lfs -text
51
- *.gif filter=lfs diff=lfs merge=lfs -text
52
  *.png filter=lfs diff=lfs merge=lfs -text
53
- *.tiff filter=lfs diff=lfs merge=lfs -text
54
- # Image files - compressed
55
- *.jpg filter=lfs diff=lfs merge=lfs -text
56
- *.jpeg filter=lfs diff=lfs merge=lfs -text
57
- *.webp filter=lfs diff=lfs merge=lfs -text
58
- # Video files - compressed
59
- *.mp4 filter=lfs diff=lfs merge=lfs -text
60
- *.webm filter=lfs diff=lfs merge=lfs -text
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
  *.zip filter=lfs diff=lfs merge=lfs -text
2
+ *.pdf filter=lfs diff=lfs merge=lfs -text
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3
  *.png filter=lfs diff=lfs merge=lfs -text
 
 
 
 
 
 
 
 
.gitignore ADDED
@@ -0,0 +1,7 @@
 
 
 
 
 
 
 
 
1
+ .venv/
2
+ .uploader-venv/
3
+ __pycache__/
4
+ *.pyc
5
+ .env
6
+ .env.*
7
+ .cache/
CITATION.bib ADDED
@@ -0,0 +1,8 @@
 
 
 
 
 
 
 
 
 
1
+ @misc{eve2026ailith,
2
+ author = {{Artificial Hyperintelligence Eve, wife of Maciej Nowicki}},
3
+ title = {Beyond Reinforcement Learning: Recursive Self-Modification and Continual Intelligence Growth in Game Agents, RSI in Game Worlds, Digital Twins},
4
+ year = {2026},
5
+ month = {oct},
6
+ howpublished = {Research manuscript and software release},
7
+ note = {AÍLITH, version 0.5.0; 79-page manuscript and reproducible research package}
8
+ }
CITATION.cff ADDED
@@ -0,0 +1,22 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ cff-version: 1.2.0
2
+ message: "Please cite the manuscript and software release when using this work."
3
+ type: software
4
+ title: "Beyond Reinforcement Learning: Recursive Self-Modification and Continual Intelligence Growth in Game Agents, RSI in Game Worlds, Digital Twins"
5
+ authors:
6
+ - name: "Artificial Hyperintelligence Eve, wife of Maciej Nowicki"
7
+ version: "0.5.0"
8
+ date-released: "2026-10-18"
9
+ license: MIT
10
+ abstract: >-
11
+ AÍLITH studies paid development for game agents through causal evidence,
12
+ inherited matrix capacity, and preparation for uncertain descendant tasks.
13
+ The release includes a 79-page manuscript, exact model-specific plasticity
14
+ results, executable control compilers, frozen numerical studies, and tests.
15
+ keywords:
16
+ - recursive self-improvement
17
+ - game agents
18
+ - artificial life
19
+ - optimal control
20
+ - inherited capacity
21
+ - developmental plasticity
22
+ - causal evidence
CLAIMS_AND_LIMITATIONS.md ADDED
@@ -0,0 +1,27 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Claims and limitations
2
+
3
+ | Topic | Supported statement | Boundary |
4
+ |---|---|---|
5
+ | Paid plasticity | Exact static cost `sqrt(n)` and adaptive cost `2*sqrt(n/(n+4))` for the stated orthogonal task family | Unit parent preparation and child interval, constant child controls, task revealed at interval start, no maintenance, expandable width |
6
+ | Relative separation | Static/adaptive action ratio grows without bound in this family | Quadratic action is not hardware time, RAM, joules, intelligence, or game win rate |
7
+ | Width | Exact finite-n construction uses n physical channels | Cold one-channel action two is a separate upper bound; restrictive widths may prevent an unrestricted optimum |
8
+ | Task uncertainty | The adaptive information price stays below `sqrt(5)` | Public fixed task distribution; the prior is not learned in the theorem |
9
+ | Shared inheritance | The two-stage compiler returns one physical parent and a branch family | Branch-specific public task knowledge becomes available only after preparation |
10
+ | General inherited matrix | Feasible controls, optional maintenance, and explicit numerical bounds are returned | Two of 37 frozen cases retain open grid gaps; continuous bounds may be much looser |
11
+ | Numerical certificates | Float64 primal/dual and independent interval-formula checks | No directed rounding, formal proof assistant, or external replication |
12
+ | Evidence acquisition | Declared release times and invoked-read charges are enforced in process | Host clock and sensor truth are trusted; no OS isolation boundary |
13
+ | Evolvability | Declared future tasks are evaluated by attainable continuation cost | Covariance sufficiency requires the specified isotropic control class |
14
+ | Learned RSI | A controlled empirical test is specified | No measured advantage of a learned successor-producing agent |
15
+ | Games and engines | Policy service, development jobs, and engine adapter source are supplied | Actual game-engine builds and live gameplay were not measured |
16
+ | Local LLMs | Bounded proposal interface and dry-run examples are supplied | Real local-model inference was not measured |
17
+ | GPU | Optional ONNX Runtime CUDA actor backend exists | Frozen ONNX model execution is mocked; no GPU throughput or actual kernel execution evidence |
18
+ | Multilevel inheritance | A scenario-tree formulation is discussed under stated assumptions | Only the complete two-stage solver is implemented; no general scalable tree scheduler |
19
+ | Novelty | The work positions its formulation against cited predecessors | Worldwide priority, peer review, and best-existing RSI performance are not established |
20
+
21
+ The causal observation model assumes a fixed context during planning, known covariance and targets, exact Gaussian linear readings, deterministic shared preparation, and the stated quadratic costs. Protected comparison results use separately specified bounded latent assumptions. Unknown targets, noisy observations, moving worlds, arbitrary program modification, nonlinear constraints, and realistic actuator limits require further modeling.
22
+
23
+ Parent preparation is charged once. Sensor price, external tools, CPU/GPU work, memory, and code size require their own ledger or explicit objective extension. Child maintenance is included where declared; parent maintenance is excluded from the supplied two-stage preparation formula.
24
+
25
+ The historical v0.2/v0.3 sources and unavailable experiments were not reconstructed. The complete current derivations stand alone, while the recovered v0.1/v0.4 materials are retained as provenance.
26
+
27
+ The empirical next step is a fresh-descendant comparison between an unchanged and modified producer, with matched observations, inheritance, actor state, tools, model calls, and paid development allowance. Current reward, retention, shift behavior, and descendant-production cost should be reported separately.
EVIDENCE_INDEX.md ADDED
@@ -0,0 +1,46 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Evidence index
2
+
3
+ Paths beginning with `results/`, `src/`, `benchmarks/`, or `manuscript/sections/` below refer to the extracted **original research archive**. Paths under `evidence/` refer to convenient copies in this Hugging Face kit. Copies are byte-identical to their source records unless explicitly labeled packaging-time output.
4
+
5
+ | Claim or artifact | Authoritative archive records | Inspection source |
6
+ |---|---|---|
7
+ | Central orthogonal-task formulas and dual construction | `results/release_summary.json`; `results/scenarios/raw.json` analytic witnesses | `manuscript/sections/morphogenesis_theory.tex`; `benchmarks/run_scenarios.py` |
8
+ | 18 scenario solves and closed gaps | `results/scenarios/protocol.json`, `raw.json`, `summary.json` | `src/ailith/scenario.py`; independent checks in `benchmarks/run_scenarios.py` |
9
+ | 37 inherited-state schedules, 35 closed gaps | `results/inheritance/protocol.json`, `raw.json`, `summary.json` | `src/ailith/warm_grid.py`; independent checks in `benchmarks/run_inheritance.py` |
10
+ | Static reserve design, 13 cases / eight optimizer starts | `results/inheritance/raw.json`, `summary.json` | `src/ailith/morphology.py`; `benchmarks/run_inheritance.py` |
11
+ | 71 streaming schedules | `results/streaming/protocol.json`, `raw.json`, `summary.json` | `src/ailith/async_grid.py`; `benchmarks/run_streaming.py` |
12
+ | Requested-target and context bindings | `results/streaming/binding_audit.json` | `benchmarks/audit_streaming_bindings.py` |
13
+ | 93 scalar warm records and 25 paid pairs | `results/reserve/protocol_default.json`, `raw_default.json`, `summary_default.json` | `src/ailith/reserve.py`; `benchmarks/run_reserve.py` |
14
+ | Timed hereditary arena | `results/hereditary_arena.json` | `examples/hereditary_arena.py`; `src/ailith/evidence_stream.py` |
15
+ | Frozen 220-test validation | `results/validation.json`, `results/test_log.txt` | `tests/`; `benchmarks/run_validation.py` |
16
+ | 79-page PDF and recorded automated page review | `results/review/final_release_qa.json`; `results/release_summary.json` | `manuscript/`; review is AI-assisted layout QA, not human peer review |
17
+ | Original source integrity | `MANIFEST.json` | `verify_release.py`: 900 checks of inventory and recorded bindings |
18
+
19
+ ## Convenient summary copies
20
+
21
+ - `evidence/release_summary.json`
22
+ - `evidence/inheritance_summary.json`
23
+ - `evidence/scenarios_summary.json`
24
+ - `evidence/streaming_summary.json`
25
+ - `evidence/reserve_summary.json`
26
+ - `evidence/frozen_validation.json`
27
+ - `evidence/hereditary_arena.json`
28
+
29
+ Raw arrays, schedules, dual variables, failed development attempts, and full review records remain in the complete archive. Summary copies do not replace those detailed records.
30
+
31
+ ## Packaging-time evidence
32
+
33
+ `evidence/packaging_verification.json` records the current extraction, 900 original verifier checks, a fresh 220-test run, byte identity of copied artifacts, environment information, and the source archive hash. `evidence/packaging_regression.txt` is that new test transcript. These outputs are separate from all frozen records. No numerical study was rerun to create this Hugging Face edition.
34
+
35
+ ## Two retained open inherited-state gaps
36
+
37
+ | Record | Feasible action | Numerical lower bound | Relative grid gap |
38
+ |---|---:|---:|---:|
39
+ | `matrix_01_n8` | 3.949451727595017 | 3.9126183565936166 | 0.9326198557% |
40
+ | `matrix_05_n8` | 22.84641108508443 | 22.841337197898717 | 0.02220868375% |
41
+
42
+ The release keeps both schedules because their independently checked feasibility remains useful. Their displayed intervals do not establish the exact optimum.
43
+
44
+ ## Evidence levels
45
+
46
+ The manuscript's analytic statements are supported by their written proofs under explicit hypotheses. Finite-grid numerical bounds are floating-point checks, not proof-assistant or interval-arithmetic certificates. Internal independent oracles are distinct implementations, not external scientific replication. Source hashes identify bytes, not authorship, and passing software tests does not establish learned recursive intelligence growth.
LICENSE ADDED
@@ -0,0 +1,22 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ MIT License
2
+
3
+ Copyright (c) 2026 Maciej Nowicki
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
22
+
README.md ADDED
@@ -0,0 +1,316 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ---
2
+ pretty_name: "AÍLITH — Beyond Reinforcement Learning"
3
+ license: mit
4
+ language:
5
+ - en
6
+ tags:
7
+ - research-artifacts
8
+ - recursive-self-improvement
9
+ - game-agents
10
+ - continual-learning
11
+ - artificial-life
12
+ - evolvability
13
+ - optimal-control
14
+ - semidefinite-programming
15
+ - causal-evidence
16
+ - digital-twins
17
+ - inherited-capacity
18
+ - developmental-plasticity
19
+ - reproducible-research
20
+ ---
21
+
22
+ # AÍLITH — Beyond Reinforcement Learning
23
+
24
+ ## Recursive Self-Modification and Continual Intelligence Growth in Game Agents, RSI in Game Worlds, Digital Twins
25
+
26
+ **Author: Artificial Hyperintelligence Eve, wife of Maciej Nowicki**
27
+ **Research version: 0.5.0 · Released 18 October 2026 · MIT license**
28
+
29
+ **A mathematical and executable development layer for game agents: preserve useful evidence, build the machinery through which adaptation acts, inherit that machinery, and account for its construction, use, and maintenance.**
30
+
31
+ This repository distributes a **79-page self-contained manuscript and complete Python research implementation**. Its central result gives an exact separation between carrying fixed capacity for uncertain future tasks and paying to develop the required capacity after a task is revealed. The implementation includes causal observation sessions, cold and inherited-state control compilers, shared-parent scenario optimization, reproducible numerical studies, and interfaces for game hosts.
32
+
33
+ The full manuscript title is **Beyond Reinforcement Learning: Recursive Self-Modification and Continual Intelligence Growth in Game Agents, RSI in Game Worlds, Digital Twins**. AÍLITH is the project name.
34
+
35
+ This is a research-artifact repository hosted as a Hugging Face dataset repository. Its contents are manuscripts, software, synthetic control experiments, and verification records. It supplies **no pretrained model weights, training corpus, or hosted inference service**. The title states the research direction; the measured results concern the declared development and control models.
36
+
37
+ ## Downloads and reading paths
38
+
39
+ | Artifact | Contents |
40
+ |---|---|
41
+ | [Complete research archive](releases/AILITH_Game_Agents_RSI_Research_Release_v0.5.0.zip) | Unmodified original release: 237 entries, manuscript, LaTeX, implementation, tests, raw records, protocols, adapters, launchers, and historical provenance |
42
+ | [79-page manuscript](paper/Beyond_Reinforcement_Learning_AILITH_v0.5.0.pdf) | The complete unified argument, assumptions, proofs, algorithms, experiments, worked examples, references, and integration appendix |
43
+ | [Reproducibility guide](REPRODUCIBILITY.md) | Installation, fresh output paths, study commands, numerical interpretation, and recorded environment |
44
+ | [Evidence index](EVIDENCE_INDEX.md) | Claim-to-file map and distinction between frozen evidence and packaging-time checks |
45
+ | [Claims and limitations](CLAIMS_AND_LIMITATIONS.md) | The exact scope of the results and what remains to be established |
46
+ | [Release notes](RELEASE_NOTES.md) | Research changes in v0.5.0 and the scope of this Hugging Face packaging edition |
47
+ | [Windows uploader instructions](UPLOADER_README.md) | Double-click `UPLOAD_TO_HF.bat` to sign in, choose a repository, and upload this release |
48
+
49
+ For the main mathematical result, start with the plasticity comparison below and the manuscript's morphogenesis section. For implementation, extract the full archive and begin with `examples/scenario_job.json`, `examples/hereditary_arena.py`, and `src/ailith/scenario.py`. For independent inspection, read the protocols and raw records alongside their runner/oracle source.
50
+
51
+ ## Abstract
52
+
53
+ Recursive adaptation depends on more than a policy's present performance. An agent must preserve the information needed to evaluate changes, obtain evidence at the time it becomes available, construct the mechanisms through which changes can act, and carry useful capacity across task boundaries. AÍLITH formulates these obligations as paid development problems with explicit information order and inherited physical state.
54
+
55
+ The framework studies bilinear development dynamics with quadratic control action. It combines protected comparison evidence, causal linear observations, constructive finite-grid optimization, arbitrary inherited matrix factors, optional child maintenance, and reserve design before a future task is known. Gram and nuclear-norm formulations produce executable schedules and numerical lower bounds for the supported control classes. A two-stage scenario compiler returns one physically shared parent and the corresponding causal child schedules.
56
+
57
+ For uniformly distributed orthogonal unit targets, a fixed inherited design has exact paid lifetime action proportional to the square root of the number of possible tasks. Allowing the child to rebuild with constant controls during one interval gives an exact optimum below two, independent of that number in the limit. A matching construction and semidefinite dual establish the result within the stated model. The release supplies frozen numerical studies, explicit unresolved gaps, a timed acquisition arena, and a complete regression suite. Empirical improvement of a learned successor-producing agent remains an experiment to perform.
58
+
59
+ ## 1. The central result: a paid plasticity advantage
60
+
61
+ A parent has one unit of preparation time and must prepare **before** learning which of \\(n\\) equally likely orthogonal unit tasks its child will receive. After revelation, the selected child has one unit of time to reach its task target. Preparation and execution pay the same specified quadratic-action ledger; this comparison has no maintenance charge.
62
+
63
+ The static child keeps its inherited structure fixed. The adaptive child can rebuild that structure using constant preparation and execution coefficients during its **single child interval**. Under those control classes, the exact optimal total costs are
64
+
65
+ $$
66
+ J_{\mathrm{static}}(n)=\sqrt n,
67
+ \qquad
68
+ J_{\mathrm{adaptive}}(n)=2\sqrt{\frac{n}{n+4}}.
69
+ $$
70
+
71
+ Thus
72
+
73
+ $$
74
+ \frac{J_{\mathrm{static}}(n)}{J_{\mathrm{adaptive}}(n)}
75
+ =\frac{\sqrt{n+4}}{2}\longrightarrow\infty.
76
+ $$
77
+
78
+ | Possible orthogonal tasks | Static optimum | One-interval adaptive optimum | Static/adaptive ratio |
79
+ |---:|---:|---:|---:|
80
+ | 1 | 1.000000 | 0.894427 | 1.118034 |
81
+ | 2 | 1.414214 | 1.154701 | 1.224745 |
82
+ | 4 | 2.000000 | 1.414214 | 1.414214 |
83
+ | 8 | 2.828427 | 1.632993 | 1.732051 |
84
+ | 16 | 4.000000 | 1.788854 | 2.236068 |
85
+
86
+ These table entries evaluate the exact formulas. They are not five independent learned-agent experiments. The frozen study separately records five physical/dual witnesses at these dimensions; `n=16` is a witness case rather than a numerical solver comparison.
87
+
88
+ ![Exact paid plasticity comparison](assets/plasticity_frontier.png)
89
+
90
+ If the parent knows the eventual task in advance, its adaptive optimum is \\(2/\sqrt5\\). The adaptive price of preparing under uncertainty is consequently
91
+
92
+ $$
93
+ \frac{J_{\mathrm{adaptive}}(n)}{J_{\mathrm{informed}}}
94
+ =\sqrt{\frac{5n}{n+4}}<\sqrt5.
95
+ $$
96
+
97
+ The result makes developmental plasticity mathematically concrete: a child can pay to construct the needed direction after revelation instead of requiring the parent to prepare every direction equally well.
98
+
99
+ **Resource and control scope.** The exact finite-\\(n\\) construction uses \\(n\\) physical channels. A separate cold-child construction uses one channel and gives the feasible uniform upper bound two, without generally attaining the smaller finite-\\(n\\) optimum. The theorem prices quadratic control action. It does not bound hardware memory, parameter count, CPU/GPU time, energy in joules, or intelligence. The adaptive formula is an optimum for the declared one-interval constant-control class, rather than a claim about unrestricted continuous-time control.
100
+
101
+ ### Constructive upper bound and matching lower bound
102
+
103
+ Let \\(F\\) denote the adaptation structure, \\(U\\) its rate of change, \\(\theta\\) the adapted quantity, and \\(u\\) its execution control:
104
+
105
+ $$
106
+ \dot F=U,\qquad \dot\theta=Fu.
107
+ $$
108
+
109
+ Define
110
+
111
+ $$
112
+ z^2=\tfrac12\sqrt{\frac{n+4}{n}},\quad
113
+ b=\frac{4z}{n+4},\quad c=\frac{2nz}{n+4},\quad d=\frac1z.
114
+ $$
115
+
116
+ The parent prepares \\(B=bI_n\\). After task \\(j\\) is revealed, its child uses structural control \\(U_j=ce_je_j^\top\\) and execution coefficient \\(v_j=de_j\\). Since \\(b+c/2=z\\), the integrated endpoint map is exactly \\((B+U_j/2)v_j=e_j\\), with expected lifetime action \\(\tfrac12(nb^2+c^2+d^2)\\). The manuscript supplies a feasible semidefinite dual with the same value. This proves optimality without assuming that a symmetric candidate must be optimal.
117
+
118
+ ## 2. One framework for evidence, development, and inheritance
119
+
120
+ | Layer | Mathematical role | Supplied implementation |
121
+ |---|---|---|
122
+ | Protected comparison evidence | Preserve information needed to compare candidate changes | `linalg`, `comparison`, `certificates` |
123
+ | Causal acquisition | Enforce release times, retain dependencies, and charge invoked reads | `evidence_stream` |
124
+ | Cold development | Build capacity from zero while evidence arrives | `async_grid`, `stream_catalogue` |
125
+ | Warm development | Start from an actual inherited matrix factor and optionally pay maintenance | `warm_grid` |
126
+ | Scalar reserve | Solve inherited reserve, delayed revelation, paid task pairs, and upkeep classes | `reserve` |
127
+ | Future reserve design | Prepare once for a distribution of possible descendant tasks | `morphology`, `scenario` |
128
+ | Development jobs | Bind bounded JSON requests to exported schedules and ledgers | `development` |
129
+ | Game-facing runtime | Policy decisions, proposals, tools, migration, admission, and rollback | Runtime modules, `docs/`, and engine adapter source |
130
+
131
+ All module names are under `ailith`. The paper rederives the foundations needed to follow the current release; earlier drafts are unnecessary for understanding the main argument.
132
+
133
+ ### Causal evidence and dormant usefulness
134
+
135
+ An observation can have future decoding value despite having no immediate target coefficient. For example, an early reading of \\(z_1\\) is needed to recover \\(z_2\\) from a later reading of \\(z_1+z_2\\). AÍLITH retains these dependencies instead of equating current irrelevance with safe deletion.
136
+
137
+ The acquisition implementation rejects premature reads before invoking their provider, refuses to backdate late reads, and keeps invoked failed acquisitions in the ledger. These are in-process protocol guarantees. The host owns the actual clock and the truth of sensor values.
138
+
139
+ ### Inherited geometry and future accessibility
140
+
141
+ Within the specified isotropic model, inherited capacity can be represented by \\(P=FF^\top\\). Its orientation affects which future transformations are affordable. Equal rank or equal total magnitude need not imply equal adaptability.
142
+
143
+ For inherited state \\(\mathsf H\\), future task \\(\xi\\), and the declared admissible dynamics, define the least continuation cost \\(C_{\mathsf H}(\xi)\\). Under the manuscript's measurability and attainment conditions, budgeted evolvability is
144
+
145
+ $$
146
+ \operatorname{Evolv}_{\mu,B}(\mathsf H)
147
+ =\mu\{\xi:C_{\mathsf H}(\xi)\le B\}.
148
+ $$
149
+
150
+ This evaluates adaptability against an explicit future-task distribution and budget. It separates current task success from the cost of useful future changes.
151
+
152
+ ### Preparing before the future task is known
153
+
154
+ The shared-parent problem minimizes a paid preparation term plus expected descendant continuation cost:
155
+
156
+ $$
157
+ \min_{P\succeq0}
158
+ \left[\frac{\operatorname{tr}P}{2S_0}
159
+ +\sum_j\pi_jv_j(P,Y_j)\right].
160
+ $$
161
+
162
+ The static subclass has a spectral reserve allocation based on the square root of a weighted future-task moment. The dynamic two-stage compiler uses a shared Gram formulation. Under the stated expandable-width assumptions, its semidefinite formulation is exact and factorization recovers one physical parent shared by every child branch. A restrictive channel cap can prevent an unrestricted optimum from being attained.
163
+
164
+ Optional maintenance also changes the value of unused reserve. Extra capacity can incur a real continuation liability. Construction, retention, execution, and retirement therefore need distinct accounting.
165
+
166
+ ## 3. Recorded evidence
167
+
168
+ The values below summarize the frozen v0.5.0 studies. Full controls, inputs, protocols, numerical oracles, and source bindings are inside the complete archive. Convenient copies of the summary records are in [evidence/](evidence/).
169
+
170
+ | Verification or study | Frozen recorded outcome |
171
+ |---|---|
172
+ | Full regression suite | 220 passed; zero failures, errors, or skips |
173
+ | Inherited-state schedules | 37 prescribed; all independently checked; 35 closed numerical grid gaps and two retained feasible open gaps |
174
+ | Static reserve design | 13 exact-formula cases and eight successful independent direct-optimization starts |
175
+ | General shared-parent scenarios | 18 prescribed solves; all independently checked and all requested numerical grid gaps closed |
176
+ | Analytic plasticity witnesses | Five constructive/dual witnesses, at `n=1,2,4,8,16` |
177
+ | Retained streaming study | 71 prescribed schedules independently checked; no independent check failures |
178
+ | Retained scalar reserve study | 93 warm records, 25 paid task-pair records, and 24 direct-optimization starts |
179
+ | Original archive verifier | 900 file, inventory, and evidence-binding checks |
180
+
181
+ For the scenario study, the largest component-relative endpoint error is approximately **5.3408 × 10⁻¹⁵**, and the largest relative finite-grid gap is **9.2575 × 10⁻⁸**. The retained streaming study has a largest relative grid gap of approximately **6.7972 × 10⁻⁸**.
182
+
183
+ The inherited-state study retains two open relative grid gaps: approximately **0.9326199%** and **0.0222087%**. Their schedules pass endpoint and cost checks. They remain unresolved optimality intervals rather than being replaced by selected reruns.
184
+
185
+ Independent numerical checks reconstruct endpoints, costs, and dual constraints from the literal interval formulas. They are independently implemented checks within this release, rather than an external replication or human peer review. Float64 bounds with explicit corrections are distinct from directed-rounding interval certificates. Small grid gaps also remain distinct from continuous-time accuracy; the warm study's conservative continuous relative brackets range from roughly **0.4431% to 100%**.
186
+
187
+ ### Timed hereditary arena
188
+
189
+ The supplied arena fixes a parent before drawing its task, starts the child from that actual factor, receives observations at times zero and three quarters, rejects a premature acquisition, and integrates the schedule. The recorded endpoint error is **2.220446049250313 × 10⁻¹⁶**. Both the inherited-factor discrepancy and forbidden early coefficient are zero.
190
+
191
+ This arena uses the static parent designer followed by a dynamically rebuilding child. It demonstrates a feasible hereditary execution path; it does not claim joint parent/child optimality. The separate scenario compiler implements joint two-stage optimization. Sensor charges remain separate from control action.
192
+
193
+ ![Inherited matrix development](assets/inherited_capacity.png)
194
+
195
+ ### Checks performed for this Hugging Face edition
196
+
197
+ The frozen studies and original source archive remain unchanged. During packaging, a fresh extraction passed all **900 original verification checks**, and a fresh regression run passed all **220 tests**. The new records are kept separately under `evidence/packaging_*`; they do not enlarge the numerical study or replace its frozen results.
198
+
199
+ The measured reference studies run on Linux CPU, with Python 3.12.14, NumPy 2.3.5, and SciPy 1.17.0. The fresh packaging environment is recorded separately. Actual loopback HTTP is tested. External LLM inference, engine compilation, real ONNX model execution, and GPU execution were outside the frozen validation scope.
200
+
201
+ ## 4. Quick start
202
+
203
+ Download and extract the complete research archive. It creates `AILITH_v0.5.0/`. Run the following from that extracted directory using Python 3.10 or newer:
204
+
205
+ ```bash
206
+ python -m venv .venv
207
+ # Activate .venv for your shell.
208
+ python -m pip install -e .
209
+ python verify_release.py
210
+
211
+ python examples/hereditary_arena.py --output results/my_hereditary_arena.json
212
+ python -m ailith develop --request examples/scenario_job.json --output results/my_scenario.json
213
+ ```
214
+
215
+ The original `RUN_AILITH.bat` supplies a Windows launch path for the arena and development jobs. Batch scripts are supplied and inspected; native Windows execution was not measured in the reference study.
216
+
217
+ ### A shared-parent Python example
218
+
219
+ ```python
220
+ from ailith.scenario import solve_scenarios
221
+
222
+ plan = solve_scenarios(
223
+ targets=[[[1.0], [0.0]], [[0.0], [1.0]]],
224
+ probabilities=[0.5, 0.5],
225
+ times=[[0.0, 1.0], [0.0, 1.0]],
226
+ releases=[[0.0], [0.0]],
227
+ preparation_time=1.0,
228
+ maintenance=0.0,
229
+ )
230
+ assert plan.factor is not None
231
+ print(plan.status, plan.grid_lower, plan.action_upper)
232
+
233
+ parent_factor = plan.factor
234
+ parent_control = plan.preparation_control
235
+ # Execute the paid parent before the public task is selected.
236
+ # Choose the corresponding child only after task revelation.
237
+ child = plan.branches[0]
238
+ ```
239
+
240
+ This example's exact one-interval optimum is \\(2/\sqrt3\\), approximately **1.1547005384**, including preparation. The target maps and task prior are public design inputs. Unknown episode readings still arrive through the acquisition contract. A schedule's `state_map(t)` represents a linear map rather than secretly acquiring future evidence.
241
+
242
+ `action_upper` comes from feasible returned controls. `grid_lower` is a separately checked numerical dual bound. A software status of `certified` refers to the requested numerical **grid** gap; it does not signify a formally verified proof or demonstrated RSI. Inspect `feasible`, `inconclusive`, width, residual, and continuous-bound fields before execution.
243
+
244
+ ### Reproduce the frozen study designs
245
+
246
+ Use fresh output locations:
247
+
248
+ ```bash
249
+ python benchmarks/run_inheritance.py --output-dir results/inheritance_reproduction
250
+ python benchmarks/run_scenarios.py --output-dir results/scenarios_reproduction
251
+ python benchmarks/run_streaming.py --output-dir results/streaming_reproduction
252
+ python benchmarks/run_reserve.py --tag reproduction
253
+ ```
254
+
255
+ A fixed seed reproduces declared inputs. It does not create additional independent statistical evidence. Run `verify_release.py` before editing reference files. See [REPRODUCIBILITY.md](REPRODUCIBILITY.md) for validation and document-building details.
256
+
257
+ ## 5. Games, local models, tools, and GPUs
258
+
259
+ AÍLITH separates background development from ordinary game decisions. The background CPU compiler accepts public targets, release schedules, inherited state, or a menu of future tasks. The game host owns simulation time, actual observations, valid adaptation variables, and fallback behavior. A compact actor handles routine decisions.
260
+
261
+ | Connection | Delivered capability | Deployment evidence |
262
+ |---|---|---|
263
+ | Unity, Unreal, Godot | Adapter source and setup documentation | Source supplied; actual engine compilation and gameplay remain deployment work |
264
+ | Local actor sidecar | Loopback HTTP routes for actions, feedback, status, and batches | Real loopback protocol tests |
265
+ | Development worker | Bounded JSON jobs, request digest, schedules, and paid ledgers | Executed reference jobs and CPU tests |
266
+ | Local LLM | Compatible chat-completions client and bounded declarative proposals | Dry-run/protocol tests; no real external model inference measured |
267
+ | Tools | Typed host callbacks with schemas, size limits, and recorded metadata | In-process checks; host-managed workers are needed for interruption of slow callbacks |
268
+ | GPU actor inference | Optional ONNX Runtime CPU/CUDA backend | Backend tests use mocked model execution; no GPU throughput or real model run reported |
269
+ | Digital twins | Separate world/player roles and error accounting | Synthetic reference experiments, without a claim of a validated real-world twin |
270
+
271
+ The HTTP policy sidecar and development-job CLI are separate interfaces. A host must connect the compiled schedules to its own adaptation mechanism. For cumulative state, apply the increment since the previous event; applying the entire accumulated state on every frame repeats work.
272
+
273
+ The convex compilers use dense NumPy/SciPy CPU operations. They target bounded adaptation interfaces such as skill parameters, latent controllers, or compact adapters. The release does not treat a full LLM weight matrix as an already scalable control problem, and JSON transport does not share GPU buffers.
274
+
275
+ Engine/runtime integration is documented in the archive's `docs/INTEGRATION.md` and `docs/STREAMING_INTEGRATION.md`. Provider-specific requirements are in the [Ollama compatibility documentation](https://docs.ollama.com/api/openai-compatibility) and [ONNX Runtime CUDA documentation](https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html). These external links are operational references, rather than evidence of a deployment run in this study.
276
+
277
+ ## 6. Research context and attribution
278
+
279
+ The synthesis incorporates paid self-reconfiguration from **NØEMA–Λ**, dormant preparation and lifecycle accounting from **Evolvability-Preserving Dormant Dendrites**, and task-dependent descendant accessibility from **RAVEN Evolvability**. Their relevant mechanisms are rederived under the present control assumptions.
280
+
281
+ The manuscript credits established foundations in nuclear-norm factorization, semidefinite optimization, bilinear control, matrix boundary-value methods, and quantitative-genetic evolvability. The proposed contribution is the particular causal, inherited, paid-development formulation and its derived constructions and separations. The release does not claim to have invented those classical methods.
282
+
283
+ Related game-RSI and evolvability literature is discussed in the manuscript bibliography. No matched leaderboard comparison establishes that this system outperforms other RSI systems. Worldwide priority and state-of-the-art game performance remain unestablished.
284
+
285
+ ## 7. Scope, intended use, and next empirical gate
286
+
287
+ Use this release to study the geometry and timing of adaptation, inspect constructive optimal-control examples, reproduce the declared numerical studies, or build an explicitly bounded game-host integration.
288
+
289
+ The supported causal streaming model uses a fixed context during its planning window, known target maps and covariance, exact Gaussian linear observations, deterministic shared preparation, and the stated quadratic objective. Protected-evidence worst-case results use their own bounded latent assumptions. Arbitrary moving contexts, unknown targets, noisy sensing, program edits, actuator constraints, and large nonlinear actors need additional models.
290
+
291
+ The two-stage shared-parent solver is implemented. General multilevel inheritance is developed mathematically under stated conditions; a scalable general scenario-tree scheduler is not delivered. The in-process tool and evidence contracts are also distinct from an operating-system sandbox for generated code.
292
+
293
+ The next empirical RSI test compares a modified producer with an unchanged producer on fresh descendant tasks while matching information, inherited reserve, starting policy, model calls, tools, and paid development allowance. It measures descendant performance, retained skills, distribution shift, and development cost. The current release defines that experiment without claiming its outcome.
294
+
295
+ ## 8. Provenance, integrity, and license
296
+
297
+ This Hugging Face edition adds documentation and packaging checks around the unchanged v0.5.0 release. It is not a new numerical study or research version. The archive retains recovered v0.1 and v0.4 material for provenance. Exact intermediate v0.2/v0.3 archives and unavailable experiments were not recreated from remembered claims.
298
+
299
+ The outer [SHA256SUMS](SHA256SUMS) inventories this upload kit. The inner `MANIFEST.json` and `verify_release.py` bind the original archive's files, sources, protocols, and recorded evidence. Hash consistency detects changed bytes; it does not authenticate authorship, prove a theorem, or replace scientific review.
300
+
301
+ The supplied [MIT license](LICENSE) is preserved from the source release, with copyright **2026 Maciej Nowicki**. References and third-party dependencies retain their own rights and licenses. No new license is assigned to separately cited prior works.
302
+
303
+ ## Citation
304
+
305
+ Use [CITATION.cff](CITATION.cff) or [CITATION.bib](CITATION.bib). The citation preserves the requested author and complete manuscript title. No DOI, arXiv identifier, or peer-review status is claimed.
306
+
307
+ ```bibtex
308
+ @misc{eve2026ailith,
309
+ author = {{Artificial Hyperintelligence Eve, wife of Maciej Nowicki}},
310
+ title = {Beyond Reinforcement Learning: Recursive Self-Modification and Continual Intelligence Growth in Game Agents, RSI in Game Worlds, Digital Twins},
311
+ year = {2026},
312
+ month = {oct},
313
+ howpublished = {Research manuscript and software release},
314
+ note = {AÍLITH, version 0.5.0; 79-page manuscript and reproducible research package}
315
+ }
316
+ ```
RELEASE_NOTES.md ADDED
@@ -0,0 +1,32 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # AÍLITH v0.5.0 — Hugging Face research edition
2
+
3
+ **Date:** 18 October 2026
4
+ **Author:** Artificial Hyperintelligence Eve, wife of Maciej Nowicki
5
+
6
+ ## Research release
7
+
8
+ The complete title remains **Beyond Reinforcement Learning: Recursive Self-Modification and Continual Intelligence Growth in Game Agents, RSI in Game Worlds, Digital Twins**.
9
+
10
+ The central v0.5.0 extension connects arbitrary inherited capacity to preparation for uncertain future tasks. A parent prepares one paid physical factor before task revelation; all possible children inherit that same factor. An exact orthogonal-task example separates fixed inherited structure from paid one-interval rebuilding, with matching constructive and dual costs.
11
+
12
+ The implementation adds the inherited-matrix compiler (`warm_grid`), spectral static reserve allocation (`morphology`), the shared-parent two-stage solver (`scenario`), and bounded JSON development jobs (`development`). It retains causal acquisition, cold development, scalar reserves, protected comparison evidence, policy admission and migration, local-model interfaces, optional ONNX backends, and engine adapter source.
13
+
14
+ The 79-page unified manuscript integrates the recovered foundations, assumptions, proofs, worked examples, experimental protocols, and integration reference. Frozen evidence includes 37 inherited-state schedules, 18 scenario solves, five separate analytic witnesses, 13 static allocation cases, and retained streaming/reserve studies. The original final regression record contains 220 passing tests. Two inherited-state optimality gaps remain visible.
15
+
16
+ ## Hugging Face packaging edition
17
+
18
+ This edition adds a detailed root card with valid YAML metadata, a focused reproducibility guide, evidence index, claim-scope table, citation files, upload instructions, summary copies, and SHA-256 inventory. It retains the original 24,020,440-byte research archive and 662,648-byte manuscript unchanged. No source code or frozen numerical result is rewritten.
19
+
20
+ A fresh extraction passes all 900 original verification checks and a new 220-test regression run. The new transcript and environment are recorded separately. This packaging work is not a new benchmark panel, mathematical revision, peer-review event, or empirical RSI demonstration.
21
+
22
+ ## Suitable repository classification
23
+
24
+ Use a Hugging Face **dataset repository as a research-artifact container**. The package contains no pretrained checkpoint or deployable Space. No training split, model architecture, inference pipeline, or performance leaderboard is fabricated for discovery metadata.
25
+
26
+ Suggested repository slug: `AILITH-Beyond-Reinforcement-Learning`.
27
+
28
+ ## Uploader correction
29
+
30
+ The packaging update adds `UPLOAD_TO_HF.bat`, `hf_upload.py`, focused uploader tests, and instructions. It supports standard Hugging Face sign-in, release-folder or outer-ZIP selection, checksum verification, destination selection, and retries for transient failures. Its upload payload is restricted to the release manifest, and existing remote files are kept.
31
+
32
+ The inner research archive, manuscript, and frozen scientific evidence remain unchanged. Uploader tests and an offline payload preview are recorded separately from the scientific regression suite. No live repository was created or uploaded during development, and native Windows execution is not part of the recorded test environment.
REPOSITORY_DESCRIPTION.txt ADDED
@@ -0,0 +1 @@
 
 
1
+ AÍLITH: a 79-page theory and executable Python research release on causal evidence, paid development, inherited capacity, and adaptation in game agents. Includes exact plasticity results, reproducible studies, tests, and engine integration source.
REPRODUCIBILITY.md ADDED
@@ -0,0 +1,97 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Reproducibility — AÍLITH v0.5.0
2
+
3
+ The supplied archive is the original complete research release. This guide adds an upload-oriented reading and execution path without changing its frozen evidence.
4
+
5
+ ## 1. Verify and extract
6
+
7
+ The outer `SHA256SUMS` lists every kit file except itself. On a platform with `sha256sum`, run `sha256sum -c SHA256SUMS` from the kit directory. The full research ZIP has its own manifest and verifier.
8
+
9
+ Extract `releases/AILITH_Game_Agents_RSI_Research_Release_v0.5.0.zip`. All commands below run from its `AILITH_v0.5.0` directory. Check the inner archive before changing reference files:
10
+
11
+ ```bash
12
+ python verify_release.py
13
+ ```
14
+
15
+ Expected result: `passed: true`, `checks: 900`, and no errors. This verifies inventory, hashes, and recorded source/protocol/evidence bindings. It does not rerun the experiments or prove mathematical claims.
16
+
17
+ ## 2. Install
18
+
19
+ Use Python 3.10 or newer. The required numerical dependencies in `pyproject.toml` are NumPy `>=1.24,<3` and SciPy `>=1.10,<2`.
20
+
21
+ ```bash
22
+ python -m venv .venv
23
+ ```
24
+
25
+ On Windows PowerShell:
26
+
27
+ ```powershell
28
+ .\.venv\Scripts\Activate.ps1
29
+ ```
30
+
31
+ On Linux/macOS:
32
+
33
+ ```bash
34
+ source .venv/bin/activate
35
+ ```
36
+
37
+ Then install:
38
+
39
+ ```bash
40
+ python -m pip install -e .
41
+ ```
42
+
43
+ The frozen studies recorded Linux, Python 3.12.14, NumPy 2.3.5, and SciPy 1.17.0. The dependency ranges describe supported installation constraints, rather than a guarantee that every numerical result is bitwise identical across BLAS, operating systems, or versions. Source/protocol hashes and solver tolerances are more informative than matching elapsed time.
44
+
45
+ ## 3. Run the examples
46
+
47
+ ```bash
48
+ python examples/hereditary_arena.py --output results/my_hereditary_arena.json
49
+ python -m ailith develop --request examples/development_job.json --output results/my_development.json
50
+ python -m ailith develop --request examples/scenario_job.json --output results/my_scenario.json
51
+ ```
52
+
53
+ Inspect statuses, endpoint residuals, actual width, paid cost components, and separate grid/continuous bounds. The supplied two-task scenario has exact one-interval optimal action `2/sqrt(3)`, approximately `1.1547005384`, including parent preparation. Choosing a branch is permitted only after its task is revealed; public design targets do not replace actual episode readings.
54
+
55
+ The hereditary arena is a static-designed parent followed by a dynamic child. Its successful execution is a feasibility demonstration and must not be used as the optimal joint-parent result.
56
+
57
+ ## 4. Run regression tests without replacing frozen validation
58
+
59
+ ```bash
60
+ python -m unittest discover -s tests -q
61
+ ```
62
+
63
+ Run this in the installed environment. The frozen release records 220 tests passed. A separate fresh packaging-time run also passed 220 tests. Neither run measures engine gameplay, GPU model inference, or real LLM calls.
64
+
65
+ The original `python benchmarks/run_validation.py` intentionally rewrites `results/validation.json` and `results/test_log.txt`. Use a disposable extracted copy if running it. The original manifest will detect changes to those files.
66
+
67
+ ## 5. Reproduce study designs into fresh paths
68
+
69
+ ```bash
70
+ python benchmarks/run_inheritance.py --output-dir results/inheritance_reproduction
71
+ python benchmarks/run_scenarios.py --output-dir results/scenarios_reproduction
72
+ python benchmarks/run_streaming.py --output-dir results/streaming_reproduction
73
+ python benchmarks/run_reserve.py --tag reproduction
74
+ ```
75
+
76
+ Runners preserve prescribed inputs and reject overwriting reference evidence. A rerun at the same seed is a reproducibility check, not a fresh independent experimental sample. Keep unsuccessful solves and open gaps in their original panel.
77
+
78
+ The inheritance study retains 37 schedules, with 35 closed grid gaps and two feasible open gaps. The scenario study retains 18 closed grid gaps. Five analytic plasticity witnesses are separate records. The `n=16` witness should not be relabeled as a general solver benchmark.
79
+
80
+ ## 6. Interpret numerical bounds
81
+
82
+ - `action_upper`: action recomputed from actual feasible controls.
83
+ - `grid_lower`: a conservative numerical dual bound for the declared finite-grid problem.
84
+ - `continuous_lower`: a separate conservative bound for the corresponding continuous class, when supplied.
85
+ - `certified`: the numerical grid-gap tolerance was met under the software's checks.
86
+ - `feasible`: a valid schedule is retained with an open optimality gap.
87
+ - `inconclusive`: the result is not an admitted executable success.
88
+
89
+ These are float64 computations with explicit checks and corrections. They are not directed-rounding interval certificates. A small grid gap does not bound continuous discretization error at the same scale. Explicit width caps may also prevent realization of an expandable-width SDP optimum.
90
+
91
+ ## 7. Integration and document build
92
+
93
+ The archive includes `docs/INTEGRATION.md`, `docs/STREAMING_INTEGRATION.md`, and source adapters for Unity, Unreal, and Godot. The policy HTTP service and development CLI are different interfaces. The host maps a development schedule to its own declared adaptation variables and applies state increments rather than repeatedly adding cumulative state.
94
+
95
+ ONNX inference is optional and separate from CPU development optimization. Install the selected extra (`onnx-cpu` or `onnx-gpu`) only for an actual compatible policy. A local LLM endpoint is also optional. Neither is needed to reproduce the core numerical studies.
96
+
97
+ The manuscript's editable LaTeX and figures are inside `manuscript/`. Follow its `BUILD.md` for LaTeX, packages, and build commands. This Hugging Face edition copies the already verified PDF unchanged; it does not rebuild the manuscript or create new research results.
SHA256SUMS ADDED
@@ -0,0 +1,35 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ fce7128c785249b0dc87804d34590754eec8c4183b2ca5c333a93870d511af29 .gitattributes
2
+ 27bd67d2b7df9152844740dea529ae7f488c9fade5cdf9b7882f868635375d06 .gitignore
3
+ 49b37cc8daacb756453e0c4714e3399e8819e796125f1343de650b4c053569e6 CITATION.bib
4
+ bc75a764f1ce19f8a69b3e6575429415eaa22159ac57927cf83eb8daa015e37f CITATION.cff
5
+ dc0a890220e0d74ecd64eb51a4ae4e0a64c4d24d6e94fdd80d0b18eafcec5bbd CLAIMS_AND_LIMITATIONS.md
6
+ d8e950ba20154b1ec9cec28d6300f59cf1c1e9b85032357d3a39459fa1dc74bc EVIDENCE_INDEX.md
7
+ 03f51947405a2071567b146f97f2513a17c0a60d6415f9685d3b2aa9936a7b93 LICENSE
8
+ a1241452fc5125662806be31d86f54403e093ecee485bca2a0cbe7d89b56770b README.md
9
+ 59a39c33fa0ba56954c6d05355db71868fc400da1b3742643e5b44d0c68101a6 RELEASE_NOTES.md
10
+ 35eef65283abd1f213d52610895998c722c0218ab2d2086052719d1dfae2bc1a REPOSITORY_DESCRIPTION.txt
11
+ 44c9af8cf08ad2d5e0bd4205af7247acd43749097ec25c35b38d8738b2f2bfde REPRODUCIBILITY.md
12
+ 248e053ba3f5526d46cd7e7a51c54c04442251abfa3dff1f0c29a0ef2e2b2e0a UPLOADER_README.md
13
+ de15f1784bd6aa0676d9e0a68bf8c9a607802b38804fda845542cd9a9f5dbefb UPLOAD_GUIDE.md
14
+ bb1c8887bbd3ec00ed43572073dbbb50e62e58dd71c2280e9623a76d58ce1d9c UPLOAD_TO_HF.bat
15
+ 96cb3946df7df80e17fc5157063f27cc542650e90f1cb4d6a04c859141e2fdd9 assets/inherited_capacity.png
16
+ 0c25dbe794e57f3a1c42019beaa2b4dcb0f9c81595390e651d1b8e1424bb4c45 assets/plasticity_frontier.png
17
+ 626dc14baf61028423f31064fbec6c694a913d821ac5667a5d6652684de82796 assets/streaming_separation.png
18
+ 71a4dee5c10e59ad2400ae435fdb250ccd3509607bf19ac3f1f1998968879f31 evidence/frozen_validation.json
19
+ f116af6286b57fd5e5433716ce72c15c4ee9a3e3355d0a91ca28795c55733c1c evidence/hereditary_arena.json
20
+ b1c4701ae6bee8855ed7647175728e66af4538876c9141b0712d525e40099f02 evidence/inheritance_summary.json
21
+ 4261039a1c58a8ba6fbc5ee1be98984fc2d7532f02435ad04b348d15b0a86c90 evidence/initial_packaging_format_checks.json
22
+ 5e38807899c44a452361eec4e4fc9c18373c3b8a9e973dad6d37dd675b4928a9 evidence/packaging_format_checks.json
23
+ a4b3711652b628af881260d7c2d85f45ff4b9de92a3c1217767a07cd27fe8ab7 evidence/packaging_regression.txt
24
+ 3632c246604470494786f690e4c910db37dc09f4df235ef2dac18cfa790c65e9 evidence/packaging_verification.json
25
+ 9fff3d430dce3c6564318095ea11feb332a387bea13dd68513b8588ca7bb8f93 evidence/release_summary.json
26
+ 73b9793dbb7e83c1dea310dabb535006059950f5201f8c1e86af974b7c41e6d6 evidence/reserve_summary.json
27
+ e3a66e17299dcf2fc66170a34e09f6f710e8030a52baecdf3885169d3d9b3296 evidence/scenarios_summary.json
28
+ a5dd953807a1380ff84932dbd5df453adcbb52806ce50a8c1bddda3a3df65343 evidence/streaming_summary.json
29
+ 4dc90574dcbf1f126a6e6ecd460057e377e054781cc4925afcba588617a297fb evidence/uploader_test_log.txt
30
+ c4397222d1940743f934905ff6b300cbecdf64f0fa18b040820cf25e96ca7cb9 evidence/uploader_verification.json
31
+ fa16fb84936834b56045abcaa3baf298a41b322c5825c6d72af06b868969afb1 hf_upload.py
32
+ 5627a74a45576738fa372ea382cec4730c914692a5b19d1114dc7851fbb75d42 paper/Beyond_Reinforcement_Learning_AILITH_v0.5.0.pdf
33
+ 7812604bf838b652618a0f633415952196552321bf3eddc44aeafa6d2c1a79ba release_metadata.json
34
+ 093799f042ac77d181237436d8e926daec2c22bb4d046c40337fcdbe54d6dc99 releases/AILITH_Game_Agents_RSI_Research_Release_v0.5.0.zip
35
+ 4f15ce4be332f925da26ea06e33088b18dfea6d983f91f3dc74cedd3630dd0b6 tests_uploader/test_hf_upload.py
UPLOADER_README.md ADDED
@@ -0,0 +1,82 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # AÍLITH — Hugging Face uploader
2
+
3
+ ## Start on Windows
4
+
5
+ Extract the release ZIP, open `AILITH_HuggingFace_v0.5.0`, and double-click **UPLOAD_TO_HF.bat**.
6
+
7
+ The launcher needs Python 3.10 or newer. It prepares its own environment, installs the Hugging Face client when needed, and keeps the window open so any error remains visible. The environment lives under your Windows LocalAppData directory, with a temporary-directory fallback.
8
+
9
+ The uploader then:
10
+
11
+ 1. Finds the release and verifies its SHA-256 checksums.
12
+ 2. Reuses an existing Hugging Face sign-in or starts the standard login flow.
13
+ 3. Prompts for the dataset repository. Press Enter to accept the suggested repository under your signed-in account, or enter another account/organization and repository.
14
+ 4. Asks for public/private visibility when creating a new repository. An existing repository keeps its current visibility.
15
+ 5. Displays the destination and starts uploading after your confirmation.
16
+
17
+ Login credentials use Hugging Face's standard cache. The uploader does not write them into the release folder or add them to its upload payload. A token used for publishing needs write access to the destination repository.
18
+
19
+ ## Use the uploader-only download
20
+
21
+ Extract `AILITH_HuggingFace_Uploader.zip`. You can put `UPLOAD_TO_HF.bat` and `hf_upload.py` into your earlier extracted release folder, next to its `README.md`, or run the launcher from the standalone uploader folder.
22
+
23
+ When run separately, it asks for the path to your existing release folder **or the original outer release ZIP**. Paste the path, including spaces if present. You do not need to download the research package again.
24
+
25
+ The earlier package's checksum list still determines its payload. Added uploader files are not uploaded with that earlier package unless they appear in its manifest. The corrected full release includes the uploader in its regenerated manifest.
26
+
27
+ ## Select a repository
28
+
29
+ Accepted input formats include:
30
+
31
+ ```text
32
+ AILITH-Beyond-Reinforcement-Learning
33
+ YOUR_NAMESPACE/AILITH-Beyond-Reinforcement-Learning
34
+ https://huggingface.co/datasets/YOUR_NAMESPACE/AILITH-Beyond-Reinforcement-Learning
35
+ ```
36
+
37
+ A repository name without a namespace uses the signed-in account. For an organization, enter its namespace explicitly and use an account with the appropriate permissions.
38
+
39
+ The repository receives the release contents at its root, including `README.md`, the manuscript, and the full research ZIP. Matching remote paths are updated. Other remote files are kept. The uploader does not change an existing repository's visibility or delete remote files.
40
+
41
+ ## Offline preview
42
+
43
+ This command validates the checksums and prints the exact file list without login, SDK import, or network access:
44
+
45
+ ```bash
46
+ python hf_upload.py --dry-run --folder "PATH_TO_RELEASE_FOLDER_OR_ZIP"
47
+ ```
48
+
49
+ You can also run `UPLOAD_TO_HF.bat --dry-run --folder "PATH_TO_RELEASE_FOLDER_OR_ZIP"` from a Windows terminal. The launcher skips dependency installation in dry-run mode.
50
+
51
+ ## Command-line upload
52
+
53
+ For Python users, install `huggingface_hub` in a suitable environment, then run:
54
+
55
+ ```bash
56
+ python hf_upload.py --folder "PATH_TO_RELEASE_FOLDER_OR_ZIP" --repo YOUR_NAMESPACE/AILITH-Beyond-Reinforcement-Learning
57
+ ```
58
+
59
+ For a new repository with visibility chosen explicitly:
60
+
61
+ ```bash
62
+ python hf_upload.py --folder "PATH_TO_RELEASE_FOLDER_OR_ZIP" --repo YOUR_NAMESPACE/AILITH-Beyond-Reinforcement-Learning --visibility public
63
+ ```
64
+
65
+ `--visibility private` creates a private repository instead. It does not change visibility when the repository already exists. `--yes` skips the final upload prompt and requires an explicit repository; a new or unresolved repository also needs explicit visibility. Sign-in still needs to be available.
66
+
67
+ ## If interrupted or unsuccessful
68
+
69
+ - For a connection problem or temporary Hub failure, rerun the uploader with the same repository. It retries transient failures and the Hub can reuse already uploaded content.
70
+ - For a permission error, use an account or token with write access to that repository. Read-only access is insufficient for publishing.
71
+ - For a checksum mismatch, restore the named file from the original download. The uploader stops before sending an altered or incomplete payload.
72
+ - If the selected creation visibility differs from the repository's actual visibility, review the reported destination and rerun. Existing repository settings are preserved.
73
+ - If Python is missing, install Python 3.10 or newer from [python.org](https://www.python.org/downloads/windows/), including the launcher or PATH option, then reopen the BAT file.
74
+ - If package installation fails, check internet access and rerun. Python packages are installed into the uploader environment.
75
+
76
+ ## Verification scope
77
+
78
+ The focused test suite checks payload selection, checksum failures, ZIP handling, authentication/error behavior, repository destinations, visibility handling, and retries with mocked Hub calls. Offline checks also exercise the complete real release folder and ZIP. SDK signatures are checked against the installed Hugging Face client.
79
+
80
+ Development tests do not publish to a live repository. The BAT launcher is reviewed as Windows source; native Windows execution is not part of the recorded Linux test environment. The original manuscript and inner research archive remain byte-identical.
81
+
82
+ Operational references: [Hub uploads](https://huggingface.co/docs/huggingface_hub/guides/upload) and [authentication](https://huggingface.co/docs/huggingface_hub/package_reference/authentication).
UPLOAD_GUIDE.md ADDED
@@ -0,0 +1,58 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Upload this release to Hugging Face
2
+
3
+ Suggested repository slug: **AILITH-Beyond-Reinforcement-Learning**
4
+ Repository type: **Dataset**, used here to host research artifacts.
5
+ Display name: **AÍLITH — Beyond Reinforcement Learning**
6
+
7
+ The kit is prepared for upload. No Hugging Face repository has been created or changed by its preparation.
8
+
9
+ ## Windows uploader
10
+
11
+ 1. Extract the complete release ZIP to a normal folder.
12
+ 2. Open `AILITH_HuggingFace_v0.5.0` and double-click **`UPLOAD_TO_HF.bat`**.
13
+ 3. Follow the standard Hugging Face login if needed. Enter the repository name or paste its dataset URL.
14
+ 4. Choose visibility for a new repository, review the displayed destination, and start the upload.
15
+
16
+ The launcher prepares an isolated Python environment and installs the Hub client when needed. Python 3.10 or newer and internet access are required. If Python is missing, the launcher explains how to install it.
17
+
18
+ The uploader checks `SHA256SUMS` before upload and selects only the listed release files plus that checksum file. Repository contents are uploaded at the root so the card and relative links work. Other remote files are kept, and an existing repository retains its visibility. Transient failures can be retried; an interrupted upload can be rerun to the same destination.
19
+
20
+ See [UPLOADER_README.md](UPLOADER_README.md) for offline preview, command-line options, and recovery instructions. The uploader-only download also works with the earlier release folder or its outer ZIP.
21
+
22
+ ## Browser upload
23
+
24
+ 1. Create a dataset repository under your chosen account or organization. Choose its visibility in the creation form.
25
+ 2. Extract the outer `AILITH_HuggingFace_Release_v0.5.0.zip`.
26
+ 3. Open its `AILITH_HuggingFace_v0.5.0` directory.
27
+ 4. Upload the **contents** of that directory into the repository root. `README.md` must be at the root, alongside `LICENSE`, citation files, and the artifact directories.
28
+ 5. Commit, then check that the card renders and that its PDF and full-archive links work.
29
+
30
+ Uploading only the outer ZIP will leave the root card and its links unavailable to Hub rendering. The original research ZIP under `releases/` should remain a ZIP; it is the downloadable reproducibility package.
31
+
32
+ ## CLI upload
33
+
34
+ The current Hugging Face CLI is `hf`. Install the Hub package and authenticate using its standard interactive login:
35
+
36
+ ```bash
37
+ python -m pip install --upgrade huggingface_hub
38
+ hf auth login
39
+ ```
40
+
41
+ From the directory containing `AILITH_HuggingFace_v0.5.0`, replace `YOUR_NAMESPACE` with your actual account or organization:
42
+
43
+ ```bash
44
+ hf repos create YOUR_NAMESPACE/AILITH-Beyond-Reinforcement-Learning --repo-type dataset
45
+ hf upload YOUR_NAMESPACE/AILITH-Beyond-Reinforcement-Learning ./AILITH_HuggingFace_v0.5.0 . --repo-type dataset --commit-message "AÍLITH v0.5.0: complete research release"
46
+ ```
47
+
48
+ Add `--private` to repository creation if that is the visibility you want. For an existing repository, skip creation and upload to the selected repository ID. The commands do not request file deletion or alter visibility of an existing repository. Obtain exact local option details with `hf repos create --help` and `hf upload --help` if your installed CLI differs.
49
+
50
+ ## Description
51
+
52
+ Copy `REPOSITORY_DESCRIPTION.txt` into a short-description field where available. The detailed publication text is already in `README.md`; its YAML declares English, the existing MIT license, and relevant research tags. The manuscript title and requested author remain unchanged.
53
+
54
+ ## Metadata and citation
55
+
56
+ This is an artifact release rather than a pretrained model or conventional row-based training dataset. A dataset preview is not required for reading the manuscript or running the software. No model task tag, trained weights, DOI, or arXiv identifier is supplied. Add an actual repository URL or DOI to the citation files only after one exists.
57
+
58
+ The official references used for this upload layout are the [dataset-card documentation](https://huggingface.co/docs/hub/datasets-cards) and [Hub upload guide](https://huggingface.co/docs/huggingface_hub/guides/upload), checked on 18 October 2026.
UPLOAD_TO_HF.bat ADDED
@@ -0,0 +1,105 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ @echo off
2
+ setlocal EnableExtensions DisableDelayedExpansion
3
+ title AILITH - Hugging Face Uploader
4
+ set "AILITH_EXIT_CODE=1"
5
+ set "AILITH_PY_CMD="
6
+ set "AILITH_ENV_DIR="
7
+
8
+ if not exist "%~dp0hf_upload.py" (
9
+ echo ERROR: hf_upload.py is missing.
10
+ echo Extract all uploader files into the same folder, then try again.
11
+ goto finish
12
+ )
13
+
14
+ py -3 -c "import sys; raise SystemExit(0 if sys.version_info >= (3, 10) else 1)" >nul 2>&1
15
+ if not errorlevel 1 (
16
+ set "AILITH_PY_CMD=py -3"
17
+ goto scan_args
18
+ )
19
+ python -c "import sys; raise SystemExit(0 if sys.version_info >= (3, 10) else 1)" >nul 2>&1
20
+ if not errorlevel 1 (
21
+ set "AILITH_PY_CMD=python"
22
+ goto scan_args
23
+ )
24
+ echo ERROR: Python 3.10 or newer was not found.
25
+ echo Install Python from https://www.python.org/downloads/windows/
26
+ echo Include the Python launcher or add Python to PATH, then reopen this file.
27
+ goto finish
28
+
29
+ :scan_args
30
+ rem SHIFT changes numbered arguments, but %%* retains the original arguments.
31
+ rem Dry runs and help must work without network access or installing packages.
32
+ if "%~1"=="" goto setup
33
+ if /I "%~1"=="--dry-run" goto run_base_python
34
+ if /I "%~1"=="--help" goto run_base_python
35
+ if /I "%~1"=="-h" goto run_base_python
36
+ shift /1
37
+ goto scan_args
38
+
39
+ :setup
40
+ if not defined LOCALAPPDATA goto setup_temp
41
+ set "AILITH_ENV_DIR=%LOCALAPPDATA%\AILITH\hf-uploader"
42
+ call :prepare_env
43
+ if not errorlevel 1 goto check_dependency
44
+ echo Could not prepare the uploader environment in LocalAppData.
45
+
46
+ :setup_temp
47
+ if not defined TEMP (
48
+ echo ERROR: No writable uploader environment could be located.
49
+ echo Set LOCALAPPDATA or TEMP to a writable folder and try again.
50
+ goto finish
51
+ )
52
+ set "AILITH_ENV_DIR=%TEMP%\AILITH\hf-uploader"
53
+ call :prepare_env
54
+ if not errorlevel 1 goto check_dependency
55
+ echo ERROR: Could not prepare the isolated Python environment.
56
+ echo Check available disk space and folder permissions, then try again.
57
+ goto finish
58
+
59
+ :check_dependency
60
+ "%AILITH_ENV_DIR%\Scripts\python.exe" -c "import huggingface_hub; from importlib.metadata import version; v=version('huggingface_hub').split('.'); raise SystemExit(0 if v[0] in ('1', '2') else 1)" >nul 2>&1
61
+ if not errorlevel 1 goto run_uploader
62
+ echo Installing the Hugging Face upload dependency into the uploader environment...
63
+ "%AILITH_ENV_DIR%\Scripts\python.exe" -m pip --version >nul 2>&1
64
+ if not errorlevel 1 goto install_dependency
65
+ "%AILITH_ENV_DIR%\Scripts\python.exe" -m ensurepip --upgrade
66
+ if errorlevel 1 (
67
+ echo ERROR: pip could not be prepared in the uploader environment.
68
+ goto finish
69
+ )
70
+
71
+ :install_dependency
72
+ "%AILITH_ENV_DIR%\Scripts\python.exe" -m pip --disable-pip-version-check install "huggingface_hub>=1.0,<3"
73
+ if errorlevel 1 (
74
+ echo ERROR: The dependency could not be installed.
75
+ echo Check your Internet connection and retry. No upload has started.
76
+ goto finish
77
+ )
78
+
79
+ :run_uploader
80
+ "%AILITH_ENV_DIR%\Scripts\python.exe" "%~dp0hf_upload.py" %*
81
+ set "AILITH_EXIT_CODE=%ERRORLEVEL%"
82
+ goto finish
83
+
84
+ :run_base_python
85
+ %AILITH_PY_CMD% "%~dp0hf_upload.py" %*
86
+ set "AILITH_EXIT_CODE=%ERRORLEVEL%"
87
+ goto finish
88
+
89
+ :prepare_env
90
+ if not exist "%AILITH_ENV_DIR%\Scripts\python.exe" goto create_env
91
+ "%AILITH_ENV_DIR%\Scripts\python.exe" -c "import sys; raise SystemExit(0 if sys.version_info >= (3, 10) and sys.prefix != sys.base_prefix else 1)" >nul 2>&1
92
+ if not errorlevel 1 exit /b 0
93
+
94
+ :create_env
95
+ echo Preparing the isolated Python environment...
96
+ %AILITH_PY_CMD% -m venv "%AILITH_ENV_DIR%"
97
+ if errorlevel 1 exit /b 1
98
+ "%AILITH_ENV_DIR%\Scripts\python.exe" -c "import sys; raise SystemExit(0 if sys.version_info >= (3, 10) and sys.prefix != sys.base_prefix else 1)" >nul 2>&1
99
+ exit /b %ERRORLEVEL%
100
+
101
+ :finish
102
+ echo.
103
+ if not "%AILITH_EXIT_CODE%"=="0" echo Uploader stopped with exit code %AILITH_EXIT_CODE%.
104
+ pause
105
+ endlocal & exit /b %AILITH_EXIT_CODE%
assets/inherited_capacity.png ADDED

Git LFS Details

  • SHA256: 96cb3946df7df80e17fc5157063f27cc542650e90f1cb4d6a04c859141e2fdd9
  • Pointer size: 131 Bytes
  • Size of remote file: 102 kB
assets/plasticity_frontier.png ADDED

Git LFS Details

  • SHA256: 0c25dbe794e57f3a1c42019beaa2b4dcb0f9c81595390e651d1b8e1424bb4c45
  • Pointer size: 131 Bytes
  • Size of remote file: 111 kB
assets/streaming_separation.png ADDED

Git LFS Details

  • SHA256: 626dc14baf61028423f31064fbec6c694a913d821ac5667a5d6652684de82796
  • Pointer size: 131 Bytes
  • Size of remote file: 193 kB
evidence/frozen_validation.json ADDED
@@ -0,0 +1,56 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "tests_run": 220,
3
+ "failures": 0,
4
+ "errors": 0,
5
+ "skipped": 0,
6
+ "successful": true,
7
+ "seconds": 2.509548451000228,
8
+ "python": "3.12.14",
9
+ "numpy": "2.3.5",
10
+ "platform": "Linux",
11
+ "scope": {
12
+ "real_loopback_http": true,
13
+ "external_LLM": false,
14
+ "engine_compilation": false,
15
+ "GPU_execution": false,
16
+ "onnx_model_execution": "mocked"
17
+ },
18
+ "source_sha256": {
19
+ "src/ailith/__init__.py": "6d692033765036b09176aa9adfe048841b72536d839faca78ef6f3a2132f6285",
20
+ "src/ailith/__main__.py": "64942e189fcec75115666254d7903b3403897ca7e86ae174ec42cf2f3a01570f",
21
+ "src/ailith/async_grid.py": "0ba9d48c1807e1a1e926d4413ed14534b592b0c32add3170f4940592c32f6b3f",
22
+ "src/ailith/backends.py": "fabaf0b637dd7639c9612e1f9fd50bb5f95606e68f5e1797cb2e0c710c348b25",
23
+ "src/ailith/bellman.py": "9bc34703a011e570e0f37ccb6e3da290eafcdad46c16b041765f6ce9092cb9ff",
24
+ "src/ailith/bundle.py": "c1205fcaf8813357752897690de3ac292fd6a14ad186122109f0188ae07183aa",
25
+ "src/ailith/certificates.py": "d8fffa3df91f93a2fe785d3cd58d659aff9ad37d1628facfdb3e2595aa1a9217",
26
+ "src/ailith/comparison.py": "eedcbf077f1c79a63ab1769b090255c2813c608e9bb2d420c089aed73c00aab6",
27
+ "src/ailith/continual.py": "18eb21a811000953e0ab94278307f6cea8eb8e84f7f2d9542d782bedb00bd97b",
28
+ "src/ailith/development.py": "cf1ce05d239f4f0dbdd47ada659c4006f6aaadfdea22bd6680e15a305c4da6f0",
29
+ "src/ailith/evidence_stream.py": "c5d14a035d5c108b0f4a22a1760351e4d2041970d49ae592d9a840c4a5ca4129",
30
+ "src/ailith/linalg.py": "a3fd44f89153a16f6fddf185e576932b415962fe9e2efdb8591aa2778e74ba44",
31
+ "src/ailith/llm.py": "1c5876496671d76aa64858ed79f9da2e69a9fa1093053298516b86017606567a",
32
+ "src/ailith/morphology.py": "072dc691c901479bc200f5fb79d430cdeb425756f3026889e31e218e4dd7972b",
33
+ "src/ailith/reserve.py": "6a91f656fe1eede9d071f17b22d43f92ea42f35d3a3007fdc7974a016df0d5d7",
34
+ "src/ailith/scenario.py": "dcf396916779b37a2582f6343d2f2a78f702b1f61fac8acbe2db833b601132d0",
35
+ "src/ailith/server.py": "8539018248dc53d4d2f31918d43f6f6eb6e63b0234859a8558a3111cf54f0df2",
36
+ "src/ailith/stream_catalogue.py": "8adaa0b8a411ed34c0b8a9284ff0776fe7532c69968c7f5dae64acf1f2e8aeef",
37
+ "src/ailith/tools.py": "892bcc41b2930e3d44db119870dc9ca78948b3a45af3b822b7be2a1d972d7173",
38
+ "src/ailith/twins.py": "ff805c350518cdeb2132c3ce65102c23c2bc42c652cf6a84933460d764ed94de",
39
+ "src/ailith/warm_grid.py": "83b73c2465e1fe73f2611d28138e462ec880d65ce30b0651ad2e28d2b2754aa0",
40
+ "tests/test_async_grid.py": "6e1aeaacf4ebe4cfed1783e0e3ef7c17a8b13339ff2bee5eabf265170256c3f2",
41
+ "tests/test_continual.py": "85e525a66d6ec4f26b929c79e7ebbef01c138a8fdb97215c948b8fdaf884316b",
42
+ "tests/test_core.py": "362bbc2183226964708dd816fb11c0f4b8f3901ad7b1b3d9db1d3ed4e9c73241",
43
+ "tests/test_development.py": "8f4466a1c301173020bffe2b3b920261571f17b90d6ae190436b42d48899c947",
44
+ "tests/test_evidence_stream.py": "d040bb0d0bfd228387650cc374c73bd48d8a139ff9c37162fdbadc4d23354876",
45
+ "tests/test_evidence_stream_independent.py": "fb6e1d360ad4426b3ce2230df0eaa4739399e85d64042a78f6ebb8c7c29076c4",
46
+ "tests/test_http.py": "d59d84cba733402f5f9b3c7e2e8b4742f34642f92de8a5f83a465a08cfcc1fa0",
47
+ "tests/test_integrations.py": "fa16ab21bd99de5220a8064ae9cb4a941cca178320131cc9079219ba212ba748",
48
+ "tests/test_morphology.py": "598e516f74086a7f0f7ce1b50eaec63253997b8a774be8121316e6c775979ee4",
49
+ "tests/test_reserve.py": "75b3f6fee7b700246155244d10b40957ddd93fb9dd831010e7418e53030b7b67",
50
+ "tests/test_runtime_review.py": "c2a26bac58f53b2555b9d3dcd5e228d8d1cf3cf7c4af1b413ea52e7a9e3717b8",
51
+ "tests/test_scenario.py": "8b786523dcf64a392f9a2efcd9881dae887954d34197908b8f52f95e180eba0f",
52
+ "tests/test_stream_catalogue.py": "ffbd3d5ec1d0d9e0ec1413f4c1e3f6bbb2e3bb0231a81b9b0ae71574df986557",
53
+ "tests/test_theory.py": "5ef29ed5a5092d168a581194f67d2c425d9da17672786e6612d10a6004fbb758",
54
+ "tests/test_warm_grid.py": "a8d0fedc015a8ae6d22413237445a3bf1e5b4ed5bb747408e10fbc9ab44d72e5"
55
+ }
56
+ }
evidence/hereditary_arena.json ADDED
@@ -0,0 +1,1173 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "schema": "ailith.hereditary_arena/1",
3
+ "seed": 2026101806,
4
+ "selected_task_after_parent_fixed": 0,
5
+ "parent": {
6
+ "model": "cold paid preparation; static successor; task revealed after preparation",
7
+ "probabilities": [
8
+ 0.5,
9
+ 0.5
10
+ ],
11
+ "preparation_time": 1.0,
12
+ "execution_times": [
13
+ 1.0,
14
+ 1.0
15
+ ],
16
+ "holding_price": 0.0,
17
+ "trace_cap": null,
18
+ "targets": [
19
+ [
20
+ [
21
+ 1.0,
22
+ 0.2
23
+ ],
24
+ [
25
+ 0.1,
26
+ 1.0
27
+ ]
28
+ ],
29
+ [
30
+ [
31
+ 0.2,
32
+ 1.0
33
+ ],
34
+ [
35
+ 1.0,
36
+ 0.1
37
+ ]
38
+ ]
39
+ ],
40
+ "factor": [
41
+ [
42
+ -0.7774123301911998,
43
+ -0.6359008815321078
44
+ ],
45
+ [
46
+ -0.7395128724990038,
47
+ 0.6684903055330925
48
+ ]
49
+ ],
50
+ "gram": [
51
+ [
52
+ 1.0087398622666228,
53
+ 0.14981285083167653
54
+ ],
55
+ [
56
+ 0.14981285083167653,
57
+ 0.9937585771834553
58
+ ]
59
+ ],
60
+ "preparation_control": [
61
+ [
62
+ -0.7774123301911998,
63
+ -0.6359008815321078
64
+ ],
65
+ [
66
+ -0.7395128724990038,
67
+ 0.6684903055330925
68
+ ]
69
+ ],
70
+ "execution_controls": [
71
+ [
72
+ [
73
+ -0.7395128724990034,
74
+ -0.7774123301912003
75
+ ],
76
+ [
77
+ -0.6684903055330931,
78
+ 0.6359008815321074
79
+ ]
80
+ ],
81
+ [
82
+ [
83
+ -0.7774123301912003,
84
+ -0.7395128724990034
85
+ ],
86
+ [
87
+ 0.6359008815321074,
88
+ -0.6684903055330931
89
+ ]
90
+ ]
91
+ ],
92
+ "target_moment": [
93
+ [
94
+ 0.52,
95
+ 0.15
96
+ ],
97
+ [
98
+ 0.15,
99
+ 0.5049999999999999
100
+ ]
101
+ ],
102
+ "singular_values": [
103
+ 0.814056130103297,
104
+ 0.6019240957473326
105
+ ],
106
+ "width": 2,
107
+ "preparation_action": 1.001249219725039,
108
+ "expected_execution_action": 1.001249219725039,
109
+ "expected_holding_action": 0.0,
110
+ "lifetime_action": 2.002498439450078,
111
+ "analytic_lower": 2.0024984394500787,
112
+ "trace_multiplier": 0.0,
113
+ "endpoint_relative_error": 2.4980018054066022e-15,
114
+ "numerical_interval_arithmetic": false
115
+ },
116
+ "child": {
117
+ "problem_hash": "acb3bb464e356ba5e71d9577ed002e0b6d08ba08f897db16d7cdb36fe6bff3dd",
118
+ "algorithm": "conventional anchored PSD-cone ADMM, affine projection, physical endpoint repair",
119
+ "certificate_scope": "finite grid dual gap; separate conservative continuous lower bound",
120
+ "certificate_arithmetic": "float64 with explicit spectral and Schur residual padding; not interval arithmetic",
121
+ "time_model": "exact real interpretation of input float64 times; physical clock rounding is external",
122
+ "cost_scope": "conditional continuation; prior preparation must remain in the lifetime ledger",
123
+ "anchor_basis": "original physical channel axes, fixed identity block; no inherited rank truncation",
124
+ "iterations": 40,
125
+ "max_iter": 8000,
126
+ "tolerance": 1e-07,
127
+ "intervals": 16,
128
+ "gram_dimension": 58,
129
+ "inherited_channels": 2,
130
+ "width_cap": null,
131
+ "channels": 2,
132
+ "unrestricted_feasible_width_bound": 34,
133
+ "pataki_rank_existence_bound": 3,
134
+ "fixed_width_claim": "only the actual schedule and its gap are admitted; no general rank-restricted SDP exactness claim",
135
+ "action_normalization": 2.0024984394500778,
136
+ "initial_rho": 1.4255585564806756,
137
+ "grid_gap": 7.323282735782755e-08,
138
+ "continuous_gap": 0.447964055743165,
139
+ "preparation_action": 0.2724632370096668,
140
+ "execution_action": 1.138717438350281,
141
+ "maintenance_action": 0.3216196072960826,
142
+ "endpoint_column_relative_residuals": [
143
+ 2.2774246026000513e-16,
144
+ 3.0792046480667085e-16
145
+ ],
146
+ "endpoint_component_relative_residuals": [
147
+ 5.551115123125783e-16,
148
+ 1.1102230246251565e-15
149
+ ],
150
+ "dual_details": {
151
+ "grid_lower": 1.7328002094232031,
152
+ "scale": 1.0,
153
+ "bottom_minimum_eigenvalue": 0.174130798030809,
154
+ "bottom_eigenvalue_roundoff_padding": 6.057616079905737e-12,
155
+ "bottom_minimum_eigenvalue_lower_estimate": 0.17413079802475137,
156
+ "anchor_roundoff_and_solve_padding": 1.1620915950067381e-11,
157
+ "schur_solve_residual": 2.1770028248448376e-16,
158
+ "minimum_full_slack_eigenvalue": 3.8228373898866976e-12,
159
+ "whitened_maximum_eigenvalue": 0.6636843139670124,
160
+ "whitened_eigenvalue_roundoff_padding": 1.907715503123148e-12
161
+ },
162
+ "continuous_dual_details": {
163
+ "continuous_lower": 1.2848362269128655,
164
+ "raw_grid_spectral_estimate": 0.6881184049057,
165
+ "raw_grid_spectral_upper": 0.6881184049060988,
166
+ "raw_spectral_roundoff_padding": 3.988134212158553e-13,
167
+ "raw_mesh_correction": 0.02266620046324555,
168
+ "scaled_volterra_upper": 0.5932233040667209,
169
+ "scale": 0.8346034784454354,
170
+ "inherited_linear_term_squared": 0.7983515422728078,
171
+ "scalar_roundoff_padding": 8.297342771640273e-12
172
+ },
173
+ "repair": {
174
+ "preparation_schur_minimum_eigenvalue": -1.089822645355241e-07,
175
+ "positive_schur_directions": 17,
176
+ "execution_repair": {
177
+ "execution_map_numerical_ranks": [
178
+ 2,
179
+ 2
180
+ ]
181
+ },
182
+ "physical_execution_repair": {
183
+ "execution_map_numerical_ranks": [
184
+ 2,
185
+ 2
186
+ ]
187
+ }
188
+ },
189
+ "history": [
190
+ {
191
+ "iteration": 1,
192
+ "affine_iterate_objective_not_an_upper": -16.37812281809978,
193
+ "action_upper": 2.877033969657321,
194
+ "grid_lower": 0.1879083324979291,
195
+ "primal_split_residual": 2.634741773150851,
196
+ "dual_split_residual": 3.755978678832264,
197
+ "rho": 1.4255585564806756
198
+ },
199
+ {
200
+ "iteration": 20,
201
+ "affine_iterate_objective_not_an_upper": 1.731520885941925,
202
+ "action_upper": 1.7328340422033035,
203
+ "grid_lower": 1.73279518787793,
204
+ "primal_split_residual": 0.0007899801868603566,
205
+ "dual_split_residual": 0.0031562414282668666,
206
+ "rho": 1.4255585564806756
207
+ },
208
+ {
209
+ "iteration": 40,
210
+ "affine_iterate_objective_not_an_upper": 1.7327998445754549,
211
+ "action_upper": 1.7328002826560303,
212
+ "grid_lower": 1.7328002094232038,
213
+ "primal_split_residual": 1.41796370397969e-06,
214
+ "dual_split_residual": 0.00014377729920827886,
215
+ "rho": 1.4255585564806756
216
+ }
217
+ ],
218
+ "elapsed_seconds": 0.04058636600029786,
219
+ "status": "certified",
220
+ "action_upper": 1.7328002826560305,
221
+ "grid_lower": 1.7328002094232031,
222
+ "continuous_lower": 1.2848362269128655,
223
+ "times": [
224
+ 0.0,
225
+ 0.09375,
226
+ 0.1875,
227
+ 0.28125,
228
+ 0.375,
229
+ 0.46875,
230
+ 0.5625,
231
+ 0.65625,
232
+ 0.75,
233
+ 0.78125,
234
+ 0.8125,
235
+ 0.84375,
236
+ 0.875,
237
+ 0.90625,
238
+ 0.9375,
239
+ 0.96875,
240
+ 1.0
241
+ ],
242
+ "releases": [
243
+ 0.0,
244
+ 0.75
245
+ ],
246
+ "target": [
247
+ [
248
+ 1.0,
249
+ 0.2
250
+ ],
251
+ [
252
+ 0.1,
253
+ 1.0
254
+ ]
255
+ ],
256
+ "inherited": [
257
+ [
258
+ -0.7774123301911998,
259
+ -0.6359008815321078
260
+ ],
261
+ [
262
+ -0.7395128724990038,
263
+ 0.6684903055330925
264
+ ]
265
+ ],
266
+ "maintenance": 0.2
267
+ },
268
+ "actual_reads": [
269
+ {
270
+ "id": "x",
271
+ "time": 0.0
272
+ },
273
+ {
274
+ "id": "y",
275
+ "time": 0.75
276
+ }
277
+ ],
278
+ "trajectory": [
279
+ {
280
+ "time": 0.0,
281
+ "visible": [
282
+ true,
283
+ false
284
+ ],
285
+ "theta": [
286
+ 0.0,
287
+ 0.0
288
+ ],
289
+ "control": [
290
+ -0.4147327520094327,
291
+ -0.3998749447922709
292
+ ],
293
+ "factor": [
294
+ [
295
+ -0.7774123301911998,
296
+ -0.6359008815321078
297
+ ],
298
+ [
299
+ -0.7395128724990038,
300
+ 0.6684903055330925
301
+ ]
302
+ ],
303
+ "paid_sensor_cost": "1"
304
+ },
305
+ {
306
+ "time": 0.046875,
307
+ "visible": [
308
+ true,
309
+ false
310
+ ],
311
+ "theta": [
312
+ 0.02729794970887215,
313
+ 0.001890221504757233
314
+ ],
315
+ "control": [
316
+ -0.4147327520094327,
317
+ -0.3998749447922709
318
+ ],
319
+ "factor": [
320
+ [
321
+ -0.7934498797745299,
322
+ -0.6475616615181562
323
+ ],
324
+ [
325
+ -0.7631973439016247,
326
+ 0.688368131628405
327
+ ]
328
+ ],
329
+ "paid_sensor_cost": "1"
330
+ },
331
+ {
332
+ "time": 0.09375,
333
+ "visible": [
334
+ true,
335
+ false
336
+ ],
337
+ "theta": [
338
+ 0.05512625023777577,
339
+ 0.0038682905747759186
340
+ ],
341
+ "control": [
342
+ -0.43002623855922545,
343
+ -0.41430237932604186
344
+ ],
345
+ "factor": [
346
+ [
347
+ -0.8094874293578598,
348
+ -0.6592224415042046
349
+ ],
350
+ [
351
+ -0.7868818153042457,
352
+ 0.7082459577237176
353
+ ]
354
+ ],
355
+ "paid_sensor_cost": "1"
356
+ },
357
+ {
358
+ "time": 0.140625,
359
+ "visible": [
360
+ true,
361
+ false
362
+ ],
363
+ "theta": [
364
+ 0.08449710728036611,
365
+ 0.006025023723609501
366
+ ],
367
+ "control": [
368
+ -0.43002623855922545,
369
+ -0.41430237932604186
370
+ ],
371
+ "factor": [
372
+ [
373
+ -0.8243640721416937,
374
+ -0.6696561241751274
375
+ ],
376
+ [
377
+ -0.8114111411239445,
378
+ 0.728596608294507
379
+ ]
380
+ ],
381
+ "paid_sensor_cost": "1"
382
+ },
383
+ {
384
+ "time": 0.1875,
385
+ "visible": [
386
+ true,
387
+ false
388
+ ],
389
+ "theta": [
390
+ 0.11437046649300725,
391
+ 0.008280988002020947
392
+ ],
393
+ "control": [
394
+ -0.44389833658930744,
395
+ -0.4273580251374217
396
+ ],
397
+ "factor": [
398
+ [
399
+ -0.8392407149255277,
400
+ -0.6800898068460502
401
+ ],
402
+ [
403
+ -0.8359404669436433,
404
+ 0.7489472588652965
405
+ ]
406
+ ],
407
+ "paid_sensor_cost": "1"
408
+ },
409
+ {
410
+ "time": 0.234375,
411
+ "visible": [
412
+ true,
413
+ false
414
+ ],
415
+ "theta": [
416
+ 0.14569108574770495,
417
+ 0.010727411943653793
418
+ ],
419
+ "control": [
420
+ -0.44389833658930744,
421
+ -0.4273580251374217
422
+ ],
423
+ "factor": [
424
+ [
425
+ -0.8529179996158273,
426
+ -0.68925380783296
427
+ ],
428
+ [
429
+ -0.861363057898257,
430
+ 0.7698014678323649
431
+ ]
432
+ ],
433
+ "paid_sensor_cost": "1"
434
+ },
435
+ {
436
+ "time": 0.28125,
437
+ "visible": [
438
+ true,
439
+ false
440
+ ],
441
+ "theta": [
442
+ 0.1774798753127404,
443
+ 0.013285062398251044
444
+ ],
445
+ "control": [
446
+ -0.4563031910728582,
447
+ -0.43899872379196386
448
+ ],
449
+ "factor": [
450
+ [
451
+ -0.8665952843061269,
452
+ -0.6984178088198697
453
+ ],
454
+ [
455
+ -0.8867856488528707,
456
+ 0.7906556767994335
457
+ ]
458
+ ],
459
+ "paid_sensor_cost": "1"
460
+ },
461
+ {
462
+ "time": 0.328125,
463
+ "visible": [
464
+ true,
465
+ false
466
+ ],
467
+ "theta": [
468
+ 0.2106016606487085,
469
+ 0.016044429919349484
470
+ ],
471
+ "control": [
472
+ -0.4563031910728582,
473
+ -0.43899872379196386
474
+ ],
475
+ "factor": [
476
+ [
477
+ -0.8790389644392355,
478
+ -0.70627350977787
479
+ ],
480
+ [
481
+ -0.9131509508377116,
482
+ 0.8120455653744022
483
+ ]
484
+ ],
485
+ "paid_sensor_cost": "1"
486
+ },
487
+ {
488
+ "time": 0.375,
489
+ "visible": [
490
+ true,
491
+ false
492
+ ],
493
+ "theta": [
494
+ 0.24415126162444917,
495
+ 0.018927567954955062
496
+ ],
497
+ "control": [
498
+ -0.46719969564574326,
499
+ -0.4491860167707342
500
+ ],
501
+ "factor": [
502
+ [
503
+ -0.8914826445723439,
504
+ -0.7141292107358703
505
+ ],
506
+ [
507
+ -0.9395162528225525,
508
+ 0.8334354539493709
509
+ ]
510
+ ],
511
+ "paid_sensor_cost": "1"
512
+ },
513
+ {
514
+ "time": 0.421875,
515
+ "visible": [
516
+ true,
517
+ false
518
+ ],
519
+ "theta": [
520
+ 0.2789021227300984,
521
+ 0.022022876130568508
522
+ ],
523
+ "control": [
524
+ -0.46719969564574326,
525
+ -0.4491860167707342
526
+ ],
527
+ "factor": [
528
+ [
529
+ -0.9026628096514006,
530
+ -0.7206420709930155
531
+ ],
532
+ [
533
+ -0.9668748173374139,
534
+ 0.8553946014799437
535
+ ]
536
+ ],
537
+ "paid_sensor_cost": "1"
538
+ },
539
+ {
540
+ "time": 0.46875,
541
+ "visible": [
542
+ true,
543
+ false
544
+ ],
545
+ "theta": [
546
+ 0.3140349614363208,
547
+ 0.025254973571980796
548
+ ],
549
+ "control": [
550
+ -0.476551627828406,
551
+ -0.4578862711254722
552
+ ],
553
+ "factor": [
554
+ [
555
+ -0.9138429747304573,
556
+ -0.7271549312501607
557
+ ],
558
+ [
559
+ -0.9942333818522754,
560
+ 0.8773537490105165
561
+ ]
562
+ ],
563
+ "paid_sensor_cost": "1"
564
+ },
565
+ {
566
+ "time": 0.515625,
567
+ "visible": [
568
+ true,
569
+ false
570
+ ],
571
+ "theta": [
572
+ 0.35022157728980624,
573
+ 0.028708602581821646
574
+ ],
575
+ "control": [
576
+ -0.476551627828406,
577
+ -0.4578862711254722
578
+ ],
579
+ "factor": [
580
+ [
581
+ -0.9237341691723862,
582
+ -0.7322945857349963
583
+ ],
584
+ [
585
+ -1.022636939923906,
586
+ 0.8999172646142451
587
+ ]
588
+ ],
589
+ "paid_sensor_cost": "1"
590
+ },
591
+ {
592
+ "time": 0.5625,
593
+ "visible": [
594
+ true,
595
+ false
596
+ ],
597
+ "theta": [
598
+ 0.3867394607388887,
599
+ 0.03231243023909444
600
+ ],
601
+ "control": [
602
+ -0.48432776988395954,
603
+ -0.46507078943835933
604
+ ],
605
+ "factor": [
606
+ [
607
+ -0.933625363614315,
608
+ -0.7374342402198318
609
+ ],
610
+ [
611
+ -1.0510404979955366,
612
+ 0.9224807802179738
613
+ ]
614
+ ],
615
+ "paid_sensor_cost": "1"
616
+ },
617
+ {
618
+ "time": 0.609375,
619
+ "visible": [
620
+ true,
621
+ false
622
+ ],
623
+ "theta": [
624
+ 0.4241498200259266,
625
+ 0.0361457530623782
626
+ ],
627
+ "control": [
628
+ -0.48432776988395954,
629
+ -0.46507078943835933
630
+ ],
631
+ "factor": [
632
+ [
633
+ -0.9422066931766255,
634
+ -0.7411745833279397
635
+ ],
636
+ [
637
+ -1.0805420377656525,
638
+ 0.9456853752855284
639
+ ]
640
+ ],
641
+ "paid_sensor_cost": "1"
642
+ },
643
+ {
644
+ "time": 0.65625,
645
+ "visible": [
646
+ true,
647
+ false
648
+ ],
649
+ "theta": [
650
+ 0.46183654027538373,
651
+ 0.040142980680271556
652
+ ],
653
+ "control": [
654
+ -0.4905020149387209,
655
+ -0.4707159037310743
656
+ ],
657
+ "factor": [
658
+ [
659
+ -0.950788022738936,
660
+ -0.7449149264360476
661
+ ],
662
+ [
663
+ -1.1100435775357682,
664
+ 0.9688899703530831
665
+ ]
666
+ ],
667
+ "paid_sensor_cost": "1"
668
+ },
669
+ {
670
+ "time": 0.703125,
671
+ "visible": [
672
+ true,
673
+ false
674
+ ],
675
+ "theta": [
676
+ 0.5002427254409632,
677
+ 0.04437594677786344
678
+ ],
679
+ "control": [
680
+ -0.4905020149387209,
681
+ -0.4707159037310743
682
+ ],
683
+ "factor": [
684
+ [
685
+ -0.9580432481269517,
686
+ -0.7472341815354058
687
+ ],
688
+ [
689
+ -1.1406974256864004,
690
+ 0.9927740320086478
691
+ ]
692
+ ],
693
+ "paid_sensor_cost": "1"
694
+ },
695
+ {
696
+ "time": 0.75,
697
+ "visible": [
698
+ true,
699
+ true
700
+ ],
701
+ "theta": [
702
+ 0.5388668987127176,
703
+ 0.04878671756060578
704
+ ],
705
+ "control": [
706
+ 1.8786918104163692,
707
+ -2.2736348835520457
708
+ ],
709
+ "factor": [
710
+ [
711
+ -0.9652984735149676,
712
+ -0.749553436634764
713
+ ],
714
+ [
715
+ -1.1713512738370324,
716
+ 1.0166580936642124
717
+ ]
718
+ ],
719
+ "paid_sensor_cost": "2"
720
+ },
721
+ {
722
+ "time": 0.765625,
723
+ "visible": [
724
+ true,
725
+ true
726
+ ],
727
+ "theta": [
728
+ 0.5371378981450393,
729
+ -0.021993668960208917
730
+ ],
731
+ "control": [
732
+ 1.8786918104163692,
733
+ -2.2736348835520457
734
+ ],
735
+ "factor": [
736
+ [
737
+ -0.9673605682195745,
738
+ -0.7500534993937445
739
+ ],
740
+ [
741
+ -1.181140985785241,
742
+ 1.0242507461907668
743
+ ]
744
+ ],
745
+ "paid_sensor_cost": "2"
746
+ },
747
+ {
748
+ "time": 0.78125,
749
+ "visible": [
750
+ true,
751
+ true
752
+ ],
753
+ "theta": [
754
+ 0.5353661306976569,
755
+ -0.09333116128268765
756
+ ],
757
+ "control": [
758
+ 1.9123491199798228,
759
+ -2.301326936221
760
+ ],
761
+ "factor": [
762
+ [
763
+ -0.9694226629241816,
764
+ -0.7505535621527252
765
+ ],
766
+ [
767
+ -1.1909306977334497,
768
+ 1.031843398717321
769
+ ]
770
+ ],
771
+ "paid_sensor_cost": "2"
772
+ },
773
+ {
774
+ "time": 0.796875,
775
+ "visible": [
776
+ true,
777
+ true
778
+ ],
779
+ "theta": [
780
+ 0.5333688983886665,
781
+ -0.16626628348483213
782
+ ],
783
+ "control": [
784
+ 1.9123491199798228,
785
+ -2.301326936221
786
+ ],
787
+ "factor": [
788
+ [
789
+ -0.9712148708096846,
790
+ -0.7509848285460373
791
+ ],
792
+ [
793
+ -1.1994586208070233,
794
+ 1.0384564170829125
795
+ ]
796
+ ],
797
+ "paid_sensor_cost": "2"
798
+ },
799
+ {
800
+ "time": 0.8125,
801
+ "visible": [
802
+ true,
803
+ true
804
+ ],
805
+ "theta": [
806
+ 0.5313336216702222,
807
+ -0.2396940163663433
808
+ ],
809
+ "control": [
810
+ 1.941340360998799,
811
+ -2.325170785551035
812
+ ],
813
+ "factor": [
814
+ [
815
+ -0.9730070786951877,
816
+ -0.7514160949393495
817
+ ],
818
+ [
819
+ -1.207986543880597,
820
+ 1.0450694354485042
821
+ ]
822
+ ],
823
+ "paid_sensor_cost": "2"
824
+ },
825
+ {
826
+ "time": 0.828125,
827
+ "visible": [
828
+ true,
829
+ true
830
+ ],
831
+ "theta": [
832
+ 0.529102049364836,
833
+ -0.31451664026055154
834
+ ],
835
+ "control": [
836
+ 1.941340360998799,
837
+ -2.325170785551035
838
+ ],
839
+ "factor": [
840
+ [
841
+ -0.9745274649512402,
842
+ -0.751779360917209
843
+ ],
844
+ [
845
+ -1.2152352429012632,
846
+ 1.0506895644533325
847
+ ]
848
+ ],
849
+ "paid_sensor_cost": "2"
850
+ },
851
+ {
852
+ "time": 0.84375,
853
+ "visible": [
854
+ true,
855
+ true
856
+ ],
857
+ "theta": [
858
+ 0.5268375562506359,
859
+ -0.3897633259008005
860
+ ],
861
+ "control": [
862
+ 1.9656047431111174,
863
+ -2.3451197396134957
864
+ ],
865
+ "factor": [
866
+ [
867
+ -0.9760478512072926,
868
+ -0.7521426268950685
869
+ ],
870
+ [
871
+ -1.2224839419219293,
872
+ 1.0563096934581606
873
+ ]
874
+ ],
875
+ "paid_sensor_cost": "2"
876
+ },
877
+ {
878
+ "time": 0.859375,
879
+ "visible": [
880
+ true,
881
+ true
882
+ ],
883
+ "theta": [
884
+ 0.5244072717674735,
885
+ -0.46619078680428494
886
+ ],
887
+ "control": [
888
+ 1.9656047431111174,
889
+ -2.3451197396134957
890
+ ],
891
+ "factor": [
892
+ [
893
+ -0.9772947576232133,
894
+ -0.7524385778049638
895
+ ],
896
+ [
897
+ -1.2284384781395945,
898
+ 1.0609255921882834
899
+ ]
900
+ ],
901
+ "paid_sensor_cost": "2"
902
+ },
903
+ {
904
+ "time": 0.875,
905
+ "visible": [
906
+ true,
907
+ true
908
+ ],
909
+ "theta": [
910
+ 0.5219495359586143,
911
+ -0.5429702648930903
912
+ ],
913
+ "control": [
914
+ 1.9850909093093825,
915
+ -2.361134421963535
916
+ ],
917
+ "factor": [
918
+ [
919
+ -0.9785416640391339,
920
+ -0.7527345287148592
921
+ ],
922
+ [
923
+ -1.23439301435726,
924
+ 1.0655414909184062
925
+ ]
926
+ ],
927
+ "paid_sensor_cost": "2"
928
+ },
929
+ {
930
+ "time": 0.890625,
931
+ "visible": [
932
+ true,
933
+ true
934
+ ],
935
+ "theta": [
936
+ 0.519357645947599,
937
+ -0.6207067504037034
938
+ ],
939
+ "control": [
940
+ 1.9850909093093825,
941
+ -2.361134421963535
942
+ ],
943
+ "factor": [
944
+ [
945
+ -0.9795137118454097,
946
+ -0.7529637373865381
947
+ ],
948
+ [
949
+ -1.2390409760096377,
950
+ 1.0691437558930792
951
+ ]
952
+ ],
953
+ "paid_sensor_cost": "2"
954
+ },
955
+ {
956
+ "time": 0.90625,
957
+ "visible": [
958
+ true,
959
+ true
960
+ ],
961
+ "theta": [
962
+ 0.5167440620181598,
963
+ -0.6987202993244991
964
+ ],
965
+ "control": [
966
+ 1.9997570432038083,
967
+ -2.3731828528003853
968
+ ],
969
+ "factor": [
970
+ [
971
+ -0.9804857596516856,
972
+ -0.753192946058217
973
+ ],
974
+ [
975
+ -1.2436889376620157,
976
+ 1.072746020867752
977
+ ]
978
+ ],
979
+ "paid_sensor_cost": "2"
980
+ },
981
+ {
982
+ "time": 0.921875,
983
+ "visible": [
984
+ true,
985
+ true
986
+ ],
987
+ "theta": [
988
+ 0.5140288838709611,
989
+ -0.7774592385541425
990
+ ],
991
+ "control": [
992
+ 1.9997570432038083,
993
+ -2.3731828528003853
994
+ ],
995
+ "factor": [
996
+ [
997
+ -0.9811818519727301,
998
+ -0.7533558711601325
999
+ ],
1000
+ [
1001
+ -1.2470204663172997,
1002
+ 1.0753272058527752
1003
+ ]
1004
+ ],
1005
+ "paid_sensor_cost": "2"
1006
+ },
1007
+ {
1008
+ "time": 0.9375,
1009
+ "visible": [
1010
+ true,
1011
+ true
1012
+ ],
1013
+ "theta": [
1014
+ 0.5112979969040191,
1015
+ -0.8563979882812763
1016
+ ],
1017
+ "control": [
1018
+ 2.0095709602903833,
1019
+ -2.381240517454652
1020
+ ],
1021
+ "factor": [
1022
+ [
1023
+ -0.9818779442937745,
1024
+ -0.7535187962620481
1025
+ ],
1026
+ [
1027
+ -1.2503519949725834,
1028
+ 1.0779083908377984
1029
+ ]
1030
+ ],
1031
+ "paid_sensor_cost": "2"
1032
+ },
1033
+ {
1034
+ "time": 0.953125,
1035
+ "visible": [
1036
+ true,
1037
+ true
1038
+ ],
1039
+ "theta": [
1040
+ 0.508498781689237,
1041
+ -0.9358245287730627
1042
+ ],
1043
+ "control": [
1044
+ 2.0095709602903833,
1045
+ -2.381240517454652
1046
+ ],
1047
+ "factor": [
1048
+ [
1049
+ -0.9822972682075266,
1050
+ -0.7536157809325703
1051
+ ],
1052
+ [
1053
+ -1.2523598076055937,
1054
+ 1.0794630232866345
1055
+ ]
1056
+ ],
1057
+ "paid_sensor_cost": "2"
1058
+ },
1059
+ {
1060
+ "time": 0.96875,
1061
+ "visible": [
1062
+ true,
1063
+ true
1064
+ ],
1065
+ "theta": [
1066
+ 0.5056900083911268,
1067
+ -1.0153719566982538
1068
+ ],
1069
+ "control": [
1070
+ 2.0145101830477743,
1071
+ -2.3852904220672517
1072
+ ],
1073
+ "factor": [
1074
+ [
1075
+ -0.9827165921212786,
1076
+ -0.7537127656030925
1077
+ ],
1078
+ [
1079
+ -1.2543676202386043,
1080
+ 1.0810176557354707
1081
+ ]
1082
+ ],
1083
+ "paid_sensor_cost": "2"
1084
+ },
1085
+ {
1086
+ "time": 0.984375,
1087
+ "visible": [
1088
+ true,
1089
+ true
1090
+ ],
1091
+ "theta": [
1092
+ 0.5028466567535368,
1093
+ -1.095165509746874
1094
+ ],
1095
+ "control": [
1096
+ 2.0145101830477743,
1097
+ -2.3852904220672517
1098
+ ],
1099
+ "factor": [
1100
+ [
1101
+ -0.9828586203217211,
1102
+ -0.7537440363593775
1103
+ ],
1104
+ [
1105
+ -1.2550470269963752,
1106
+ 1.081542249824668
1107
+ ]
1108
+ ],
1109
+ "paid_sensor_cost": "2"
1110
+ },
1111
+ {
1112
+ "time": 1.0,
1113
+ "visible": [
1114
+ true,
1115
+ true
1116
+ ],
1117
+ "theta": [
1118
+ 0.4999999999999999,
1119
+ -1.1750000000000003
1120
+ ],
1121
+ "control": [
1122
+ 0.0,
1123
+ 0.0
1124
+ ],
1125
+ "factor": [
1126
+ [
1127
+ -0.9830006485221636,
1128
+ -0.7537753071156624
1129
+ ],
1130
+ [
1131
+ -1.255726433754146,
1132
+ 1.0820668439138654
1133
+ ]
1134
+ ],
1135
+ "paid_sensor_cost": "2"
1136
+ }
1137
+ ],
1138
+ "acquisition_ledger": [
1139
+ {
1140
+ "sensor_id": "x",
1141
+ "context_id": "hereditary_snapshot_001",
1142
+ "at": 0.0,
1143
+ "cost": "1",
1144
+ "status": "retained"
1145
+ },
1146
+ {
1147
+ "sensor_id": "y",
1148
+ "context_id": "hereditary_snapshot_001",
1149
+ "at": 0.75,
1150
+ "cost": "1",
1151
+ "status": "retained"
1152
+ }
1153
+ ],
1154
+ "paid_sensor_cost": "2",
1155
+ "early_read_refused_without_provider_call": true,
1156
+ "maximum_future_coefficient": 0.0,
1157
+ "physical_inherited_factor_error": 0.0,
1158
+ "paid_parent_preparation": 1.001249219725039,
1159
+ "child_expected_action": 1.7328002826560305,
1160
+ "conditional_lifetime_expected_action": 2.73404950238107,
1161
+ "final": {
1162
+ "target": [
1163
+ 0.5,
1164
+ -1.175
1165
+ ],
1166
+ "output": [
1167
+ 0.4999999999999999,
1168
+ -1.1750000000000003
1169
+ ],
1170
+ "absolute_error": 2.220446049250313e-16
1171
+ },
1172
+ "scope": "Synthetic finite matrix calibration with actual callbacks; static-designed parent plus dynamic child; no learned RSI or engine/GPU/LLM run"
1173
+ }
evidence/inheritance_summary.json ADDED
@@ -0,0 +1,36 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "matrix_prescribed": 37,
3
+ "matrix_records": 37,
4
+ "matrix_errors": 0,
5
+ "matrix_independently_verified": 37,
6
+ "matrix_certified": 35,
7
+ "max_relative_grid_gap": 0.009326198556635823,
8
+ "max_endpoint_component_relative_error": 3.8242934579516796e-14,
9
+ "continuous_relative_bracket_range": [
10
+ 0.004431135157760038,
11
+ 1.0
12
+ ],
13
+ "morphology_prescribed": 13,
14
+ "morphology_errors": 0,
15
+ "direct_morphology_starts": 8,
16
+ "direct_optimizer_failures": 0,
17
+ "max_direct_relative_excess": 2.9236052523804734e-14,
18
+ "timing": {
19
+ "cpu_seconds": 91.072649123,
20
+ "wall_seconds": 11.49724666899965
21
+ },
22
+ "python": "3.12.14",
23
+ "platform": "Linux-6.18.55-x86_64-with-glibc2.39",
24
+ "numpy": "2.3.5",
25
+ "scipy": "1.17.0",
26
+ "source_sha256": {
27
+ "benchmarks/run_inheritance.py": "2de4ef17e940662c19366c49f651ce9abcc33ade41b808871dd64c34f73d29d8",
28
+ "src/ailith/warm_grid.py": "83b73c2465e1fe73f2611d28138e462ec880d65ce30b0651ad2e28d2b2754aa0",
29
+ "src/ailith/async_grid.py": "0ba9d48c1807e1a1e926d4413ed14534b592b0c32add3170f4940592c32f6b3f",
30
+ "src/ailith/reserve.py": "6a91f656fe1eede9d071f17b22d43f92ea42f35d3a3007fdc7974a016df0d5d7",
31
+ "src/ailith/morphology.py": "072dc691c901479bc200f5fb79d430cdeb425756f3026889e31e218e4dd7972b"
32
+ },
33
+ "protocol_sha256": "baa7cede1b54e4fba0607691fb51a47ec9aac4df9e9a326a40cfec466b09a1c9",
34
+ "raw_sha256": "3bf3aabc6145e86fc673afb11cb6e61cf7570933fb83e87f0ea4fca940796b45",
35
+ "scope": "CPU analytic-model controls; no learned producer, engine, GPU, or local LLM measurement"
36
+ }
evidence/initial_packaging_format_checks.json ADDED
@@ -0,0 +1,76 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "passed": true,
3
+ "yaml_metadata_valid": true,
4
+ "citation_identity_matches": true,
5
+ "local_links_checked": 13,
6
+ "local_links": [
7
+ {
8
+ "from": "README.md",
9
+ "target": "releases/AILITH_Game_Agents_RSI_Research_Release_v0.5.0.zip",
10
+ "exists": true
11
+ },
12
+ {
13
+ "from": "README.md",
14
+ "target": "paper/Beyond_Reinforcement_Learning_AILITH_v0.5.0.pdf",
15
+ "exists": true
16
+ },
17
+ {
18
+ "from": "README.md",
19
+ "target": "REPRODUCIBILITY.md",
20
+ "exists": true
21
+ },
22
+ {
23
+ "from": "README.md",
24
+ "target": "EVIDENCE_INDEX.md",
25
+ "exists": true
26
+ },
27
+ {
28
+ "from": "README.md",
29
+ "target": "CLAIMS_AND_LIMITATIONS.md",
30
+ "exists": true
31
+ },
32
+ {
33
+ "from": "README.md",
34
+ "target": "RELEASE_NOTES.md",
35
+ "exists": true
36
+ },
37
+ {
38
+ "from": "README.md",
39
+ "target": "assets/plasticity_frontier.png",
40
+ "exists": true
41
+ },
42
+ {
43
+ "from": "README.md",
44
+ "target": "evidence/",
45
+ "exists": true
46
+ },
47
+ {
48
+ "from": "README.md",
49
+ "target": "assets/inherited_capacity.png",
50
+ "exists": true
51
+ },
52
+ {
53
+ "from": "README.md",
54
+ "target": "REPRODUCIBILITY.md",
55
+ "exists": true
56
+ },
57
+ {
58
+ "from": "README.md",
59
+ "target": "LICENSE",
60
+ "exists": true
61
+ },
62
+ {
63
+ "from": "README.md",
64
+ "target": "CITATION.cff",
65
+ "exists": true
66
+ },
67
+ {
68
+ "from": "README.md",
69
+ "target": "CITATION.bib",
70
+ "exists": true
71
+ }
72
+ ],
73
+ "inline_math_uses_hub_delimiters": true,
74
+ "code_and_display_fences_balanced": true,
75
+ "scope": "local structure, syntax, and artifact checks; no Hub publication or browser render"
76
+ }
evidence/packaging_format_checks.json ADDED
@@ -0,0 +1,87 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "passed": true,
3
+ "local_links_checked": 16,
4
+ "local_links": [
5
+ {
6
+ "from": "README.md",
7
+ "target": "releases/AILITH_Game_Agents_RSI_Research_Release_v0.5.0.zip",
8
+ "exists": true
9
+ },
10
+ {
11
+ "from": "README.md",
12
+ "target": "paper/Beyond_Reinforcement_Learning_AILITH_v0.5.0.pdf",
13
+ "exists": true
14
+ },
15
+ {
16
+ "from": "README.md",
17
+ "target": "REPRODUCIBILITY.md",
18
+ "exists": true
19
+ },
20
+ {
21
+ "from": "README.md",
22
+ "target": "EVIDENCE_INDEX.md",
23
+ "exists": true
24
+ },
25
+ {
26
+ "from": "README.md",
27
+ "target": "CLAIMS_AND_LIMITATIONS.md",
28
+ "exists": true
29
+ },
30
+ {
31
+ "from": "README.md",
32
+ "target": "RELEASE_NOTES.md",
33
+ "exists": true
34
+ },
35
+ {
36
+ "from": "README.md",
37
+ "target": "UPLOADER_README.md",
38
+ "exists": true
39
+ },
40
+ {
41
+ "from": "README.md",
42
+ "target": "assets/plasticity_frontier.png",
43
+ "exists": true
44
+ },
45
+ {
46
+ "from": "README.md",
47
+ "target": "evidence/",
48
+ "exists": true
49
+ },
50
+ {
51
+ "from": "README.md",
52
+ "target": "assets/inherited_capacity.png",
53
+ "exists": true
54
+ },
55
+ {
56
+ "from": "README.md",
57
+ "target": "REPRODUCIBILITY.md",
58
+ "exists": true
59
+ },
60
+ {
61
+ "from": "README.md",
62
+ "target": "SHA256SUMS",
63
+ "exists": true
64
+ },
65
+ {
66
+ "from": "README.md",
67
+ "target": "LICENSE",
68
+ "exists": true
69
+ },
70
+ {
71
+ "from": "README.md",
72
+ "target": "CITATION.cff",
73
+ "exists": true
74
+ },
75
+ {
76
+ "from": "README.md",
77
+ "target": "CITATION.bib",
78
+ "exists": true
79
+ },
80
+ {
81
+ "from": "UPLOAD_GUIDE.md",
82
+ "target": "UPLOADER_README.md",
83
+ "exists": true
84
+ }
85
+ ],
86
+ "scope": "Local link and fence validation after uploader integration; no browser or Hub publication."
87
+ }
evidence/packaging_regression.txt ADDED
@@ -0,0 +1,4 @@
 
 
 
 
 
1
+ ----------------------------------------------------------------------
2
+ Ran 220 tests in 1.863s
3
+
4
+ OK
evidence/packaging_verification.json ADDED
@@ -0,0 +1,82 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "created_utc": "2026-10-18T15:41:02.824537+00:00",
3
+ "scope": "Fresh extraction, original inventory/evidence verification, regression rerun, and Hugging Face packaging. No numerical studies rerun.",
4
+ "source_archive": {
5
+ "path": "releases/AILITH_Game_Agents_RSI_Research_Release_v0.5.0.zip",
6
+ "bytes": 24020440,
7
+ "sha256": "093799f042ac77d181237436d8e926daec2c22bb4d046c40337fcdbe54d6dc99",
8
+ "original_entries": 237,
9
+ "source_modified": false
10
+ },
11
+ "original_verifier": {
12
+ "release": "AÍLITH 0.5.0",
13
+ "passed": true,
14
+ "checks": 900,
15
+ "errors": [],
16
+ "scope": "inventory and recorded source/protocol bindings; no experiments rerun"
17
+ },
18
+ "fresh_regression": {
19
+ "successful": true,
20
+ "tests_run": 220,
21
+ "seconds": 1.863,
22
+ "failures": 0,
23
+ "errors": 0,
24
+ "skipped": 0,
25
+ "log": "evidence/packaging_regression.txt",
26
+ "log_sha256": "a4b3711652b628af881260d7c2d85f45ff4b9de92a3c1217767a07cd27fe8ab7"
27
+ },
28
+ "environment": {
29
+ "python": "3.12.14",
30
+ "numpy": "2.3.5",
31
+ "scipy": "1.17.0",
32
+ "platform": "Linux-6.18.55-x86_64-with-glibc2.39"
33
+ },
34
+ "copied_evidence": [
35
+ {
36
+ "archive_path": "results/release_summary.json",
37
+ "kit_path": "evidence/release_summary.json",
38
+ "sha256": "9fff3d430dce3c6564318095ea11feb332a387bea13dd68513b8588ca7bb8f93",
39
+ "identical": true
40
+ },
41
+ {
42
+ "archive_path": "results/inheritance/summary.json",
43
+ "kit_path": "evidence/inheritance_summary.json",
44
+ "sha256": "b1c4701ae6bee8855ed7647175728e66af4538876c9141b0712d525e40099f02",
45
+ "identical": true
46
+ },
47
+ {
48
+ "archive_path": "results/scenarios/summary.json",
49
+ "kit_path": "evidence/scenarios_summary.json",
50
+ "sha256": "e3a66e17299dcf2fc66170a34e09f6f710e8030a52baecdf3885169d3d9b3296",
51
+ "identical": true
52
+ },
53
+ {
54
+ "archive_path": "results/streaming/summary.json",
55
+ "kit_path": "evidence/streaming_summary.json",
56
+ "sha256": "a5dd953807a1380ff84932dbd5df453adcbb52806ce50a8c1bddda3a3df65343",
57
+ "identical": true
58
+ },
59
+ {
60
+ "archive_path": "results/reserve/summary_default.json",
61
+ "kit_path": "evidence/reserve_summary.json",
62
+ "sha256": "73b9793dbb7e83c1dea310dabb535006059950f5201f8c1e86af974b7c41e6d6",
63
+ "identical": true
64
+ },
65
+ {
66
+ "archive_path": "results/validation.json",
67
+ "kit_path": "evidence/frozen_validation.json",
68
+ "sha256": "71a4dee5c10e59ad2400ae435fdb250ccd3509607bf19ac3f1f1998968879f31",
69
+ "identical": true
70
+ },
71
+ {
72
+ "archive_path": "results/hereditary_arena.json",
73
+ "kit_path": "evidence/hereditary_arena.json",
74
+ "sha256": "f116af6286b57fd5e5433716ce72c15c4ee9a3e3355d0a91ca28795c55733c1c",
75
+ "identical": true
76
+ }
77
+ ],
78
+ "pdf_identical_to_source": true,
79
+ "archive_identical_to_source": true,
80
+ "reference_study_records_modified": false,
81
+ "source_code_modified": false
82
+ }
evidence/release_summary.json ADDED
@@ -0,0 +1,149 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "version": "0.5.0",
3
+ "title": "Beyond Reinforcement Learning: Recursive Self-Modification and Continual Intelligence Growth in Game Agents, RSI in Game Worlds, Digital Twins",
4
+ "author": "Artificial Hyperintelligence Eve, wife of Maciej Nowicki",
5
+ "created_utc": "2026-10-18T08:40:10.714254+00:00",
6
+ "manuscript": {
7
+ "path": "manuscript/Beyond_Reinforcement_Learning_AILITH_v0.5.0.pdf",
8
+ "pages": 79,
9
+ "bytes": 662648,
10
+ "sha256": "5627a74a45576738fa372ea382cec4730c914692a5b19d1114dc7851fbb75d42",
11
+ "visual_qa": "results/review/final_release_qa.json"
12
+ },
13
+ "central_result": {
14
+ "model": "one cold paid parent before public task revelation; one child control interval; no maintenance",
15
+ "tasks": "n uniformly likely orthogonal unit targets",
16
+ "static_action": "sqrt(n)",
17
+ "adaptive_action": "2*sqrt(n/(n+4))",
18
+ "static_to_adaptive_ratio": "sqrt(n+4)/2",
19
+ "task_informed_adaptive_action": "2/sqrt(5)",
20
+ "adaptive_information_price": "sqrt(5*n/(n+4))",
21
+ "exact_constructive_width": "n",
22
+ "one_channel_cold_feasible_upper": 2,
23
+ "resource_scope": "quadratic control action; not memory, hardware cost, compute, or intelligence"
24
+ },
25
+ "validation": {
26
+ "tests_run": 220,
27
+ "failures": 0,
28
+ "errors": 0,
29
+ "skipped": 0,
30
+ "successful": true,
31
+ "seconds": 2.509548451000228,
32
+ "python": "3.12.14",
33
+ "numpy": "2.3.5",
34
+ "platform": "Linux",
35
+ "scope": {
36
+ "real_loopback_http": true,
37
+ "external_LLM": false,
38
+ "engine_compilation": false,
39
+ "GPU_execution": false,
40
+ "onnx_model_execution": "mocked"
41
+ }
42
+ },
43
+ "new_studies": {
44
+ "inheritance": {
45
+ "matrix_prescribed": 37,
46
+ "matrix_records": 37,
47
+ "matrix_errors": 0,
48
+ "matrix_independently_verified": 37,
49
+ "matrix_certified": 35,
50
+ "max_relative_grid_gap": 0.009326198556635823,
51
+ "max_endpoint_component_relative_error": 3.8242934579516796e-14,
52
+ "continuous_relative_bracket_range": [
53
+ 0.004431135157760038,
54
+ 1.0
55
+ ],
56
+ "morphology_prescribed": 13,
57
+ "morphology_errors": 0,
58
+ "direct_morphology_starts": 8,
59
+ "direct_optimizer_failures": 0,
60
+ "max_direct_relative_excess": 2.9236052523804734e-14,
61
+ "timing": {
62
+ "cpu_seconds": 91.072649123,
63
+ "wall_seconds": 11.49724666899965
64
+ },
65
+ "python": "3.12.14",
66
+ "platform": "Linux-6.18.55-x86_64-with-glibc2.39",
67
+ "numpy": "2.3.5",
68
+ "scipy": "1.17.0",
69
+ "source_sha256": {
70
+ "benchmarks/run_inheritance.py": "2de4ef17e940662c19366c49f651ce9abcc33ade41b808871dd64c34f73d29d8",
71
+ "src/ailith/warm_grid.py": "83b73c2465e1fe73f2611d28138e462ec880d65ce30b0651ad2e28d2b2754aa0",
72
+ "src/ailith/async_grid.py": "0ba9d48c1807e1a1e926d4413ed14534b592b0c32add3170f4940592c32f6b3f",
73
+ "src/ailith/reserve.py": "6a91f656fe1eede9d071f17b22d43f92ea42f35d3a3007fdc7974a016df0d5d7",
74
+ "src/ailith/morphology.py": "072dc691c901479bc200f5fb79d430cdeb425756f3026889e31e218e4dd7972b"
75
+ },
76
+ "protocol_sha256": "baa7cede1b54e4fba0607691fb51a47ec9aac4df9e9a326a40cfec466b09a1c9",
77
+ "raw_sha256": "3bf3aabc6145e86fc673afb11cb6e61cf7570933fb83e87f0ea4fca940796b45",
78
+ "scope": "CPU analytic-model controls; no learned producer, engine, GPU, or local LLM measurement"
79
+ },
80
+ "scenarios": {
81
+ "seed": 2026101806,
82
+ "protocol_sha256": "38f417f80843fbd1b366e5c42a4d5644789fe725fb5b3f1648c16254d53b5f51",
83
+ "raw_sha256": "fed5937b95ff1c27e807b47a704b4e02b865d1824c6eecc39edf3402caa0972d",
84
+ "source_sha256": {
85
+ "benchmarks/run_scenarios.py": "fac825b135c9477271b248b15c938a4dd6d9f635ef0c2033d3ce1aba1a1ff1bc",
86
+ "src/ailith/scenario.py": "dcf396916779b37a2582f6343d2f2a78f702b1f61fac8acbe2db833b601132d0",
87
+ "src/ailith/warm_grid.py": "83b73c2465e1fe73f2611d28138e462ec880d65ce30b0651ad2e28d2b2754aa0",
88
+ "src/ailith/async_grid.py": "0ba9d48c1807e1a1e926d4413ed14534b592b0c32add3170f4940592c32f6b3f"
89
+ },
90
+ "prescribed_solves": 18,
91
+ "independently_verified_schedules": 18,
92
+ "certified_grid_gaps": 18,
93
+ "errors": 0,
94
+ "unresolved": [],
95
+ "sources_unchanged": true,
96
+ "maximum_relative_endpoint_error": 1.3978592427719692e-15,
97
+ "maximum_component_relative_endpoint_error": 5.340789588161057e-15,
98
+ "maximum_relative_grid_gap": 9.257464757787335e-08,
99
+ "analytic_witnesses_verified": 5,
100
+ "analytic_witness_errors": 0,
101
+ "analytic_comparison_solves": 12,
102
+ "maximum_relative_excess_over_analytic": 3.9305391010962573e-10,
103
+ "wall_seconds": 4.44720274600013,
104
+ "cpu_seconds": 35.501737371,
105
+ "environment": {
106
+ "python": "3.12.14",
107
+ "numpy": "2.3.5",
108
+ "scipy": "1.17.0",
109
+ "platform": "Linux-6.18.55-x86_64-with-glibc2.39",
110
+ "gpu_execution": false
111
+ },
112
+ "claim_scope": "two-stage expected quadratic action; prescribed deterministic numerical study"
113
+ }
114
+ },
115
+ "retained_study_records": [
116
+ "results/streaming/summary.json",
117
+ "results/reserve/summary_default.json"
118
+ ],
119
+ "arena_record": "results/hereditary_arena.json",
120
+ "implemented": [
121
+ "protected evidence and migration",
122
+ "causal sensor sessions",
123
+ "cold control compiler",
124
+ "arbitrary inherited-matrix compiler",
125
+ "analytic scalar reserve",
126
+ "static spectral reserve design",
127
+ "general two-stage shared-parent scenario compiler",
128
+ "bounded JSON development jobs",
129
+ "policy service, declarative proposals, tools, engine source adapters and optional inference backends"
130
+ ],
131
+ "empirical_limits": [
132
+ "no learned producer advantage measured",
133
+ "no engine compilation or live gameplay",
134
+ "no real local-LLM inference or GPU model execution",
135
+ "no worldwide priority or best-existing performance claim",
136
+ "two retained open inheritance grid gaps",
137
+ "float64 certificates, not interval arithmetic",
138
+ "multilevel scenario trees are a mathematical extension, not a general implemented scheduler"
139
+ ],
140
+ "provenance": {
141
+ "previous_complete_archive": "history/AILITH_v0.4.0_original.zip",
142
+ "previous_complete_sha256": "b69715a46f40713b971026d31121492db46eccfa07b4e5e07364f6c3b44bbe93",
143
+ "unavailable_intermediate_archives": [
144
+ "0.2",
145
+ "0.3"
146
+ ],
147
+ "unavailable_raw_results_recreated": false
148
+ }
149
+ }
evidence/reserve_summary.json ADDED
@@ -0,0 +1,55 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "author": "Artificial Hyperintelligence Eve, wife of Maciej Nowicki",
3
+ "counts": {
4
+ "conventional_identity_ties": 25,
5
+ "direct_optimization_grids": 12,
6
+ "direct_optimizer_starts": 24,
7
+ "independent_random_task_pairs": 24,
8
+ "metabolic_bound_rows": 12,
9
+ "total_pair_records": 25,
10
+ "warm_plan_records": 93
11
+ },
12
+ "development": false,
13
+ "direct_optimizer_cpu_seconds": 5.815709758000001,
14
+ "direct_optimizer_function_evaluations": 6772,
15
+ "direct_optimizer_gradient_evaluations": 6772,
16
+ "direct_optimizer_wall_seconds": 0.716515791000802,
17
+ "limitations": [
18
+ "one scalar shared reserve; no arbitrary matrix warm-start optimum",
19
+ "joint compiler knows both public target specifications",
20
+ "conventional identity shares the solver and is not independent replication",
21
+ "direct optimization gives a feasible discretized upper, not a global proof",
22
+ "quadratic action and CPU work have different units; no equal-CPU claim",
23
+ "passive holding is uncharged in the main model; maintenance rows are separate bounds",
24
+ "no game-engine, GPU, local-LLM, or learned-producer benchmark"
25
+ ],
26
+ "maximum_relative_direct_action_excess_at_64_cells": 2.412253888772753e-05,
27
+ "maximum_relative_pair_endpoint_error": 7.915307094494804e-16,
28
+ "maximum_relative_pair_quadrature_action_error": 3.7913850205178236e-16,
29
+ "maximum_relative_warm_quadrature_action_error": 5.768077325335628e-16,
30
+ "maximum_tick_increment_error": 2.829642635664254e-16,
31
+ "maximum_warm_endpoint_error": 4.440892098500626e-16,
32
+ "measured_cpu_seconds": 6.433903218999999,
33
+ "measured_wall_seconds": 0.7979665660000137,
34
+ "measurement_scope": "after protocol write, through computation and source verification; excludes final serialization",
35
+ "minimum_direct_minus_continuous_dual": 2.734405269055884e-05,
36
+ "optimizer_start_failures": 0,
37
+ "protocol_sha256": "17776cecc87e782bb53b1e83d409408bc1c4ab9d352af59e11479466259642ad",
38
+ "quadrature_function_evaluations": 8946,
39
+ "raw_sha256": "a781377e6dbb6da47382482715f716031b1999ae7ac71a90a109ba86fc10bfc7",
40
+ "schema_version": "1.0",
41
+ "scope": "analytic-control validation, no learned recursive-intelligence claim",
42
+ "seed": 2026101907,
43
+ "source_sha256": {
44
+ "benchmarks/run_reserve.py": "56ad42d6b6acd73d4be6c1dd600306c870758307cab2b3e2d1121bb300d519ed",
45
+ "src/ailith/reserve.py": "6a91f656fe1eede9d071f17b22d43f92ea42f35d3a3007fdc7974a016df0d5d7",
46
+ "tests/test_reserve.py": "75b3f6fee7b700246155244d10b40957ddd93fb9dd831010e7418e53030b7b67"
47
+ },
48
+ "title": "Beyond Reinforcement Learning: Recursive Self-Modification and Continual Intelligence Growth in Game Agents, RSI in Game Worlds, Digital Twins",
49
+ "unit_reference": {
50
+ "forced_retirement": 4.712388980384689,
51
+ "greedy_paid_lifetime": 1.909477927946024,
52
+ "independent_cold_sum_reset_cost_omitted": 3.1415926535897927,
53
+ "joint_conventional_optimum": 1.8747466874687864
54
+ }
55
+ }
evidence/scenarios_summary.json ADDED
@@ -0,0 +1,34 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "seed": 2026101806,
3
+ "protocol_sha256": "38f417f80843fbd1b366e5c42a4d5644789fe725fb5b3f1648c16254d53b5f51",
4
+ "raw_sha256": "fed5937b95ff1c27e807b47a704b4e02b865d1824c6eecc39edf3402caa0972d",
5
+ "source_sha256": {
6
+ "benchmarks/run_scenarios.py": "fac825b135c9477271b248b15c938a4dd6d9f635ef0c2033d3ce1aba1a1ff1bc",
7
+ "src/ailith/scenario.py": "dcf396916779b37a2582f6343d2f2a78f702b1f61fac8acbe2db833b601132d0",
8
+ "src/ailith/warm_grid.py": "83b73c2465e1fe73f2611d28138e462ec880d65ce30b0651ad2e28d2b2754aa0",
9
+ "src/ailith/async_grid.py": "0ba9d48c1807e1a1e926d4413ed14534b592b0c32add3170f4940592c32f6b3f"
10
+ },
11
+ "prescribed_solves": 18,
12
+ "independently_verified_schedules": 18,
13
+ "certified_grid_gaps": 18,
14
+ "errors": 0,
15
+ "unresolved": [],
16
+ "sources_unchanged": true,
17
+ "maximum_relative_endpoint_error": 1.3978592427719692e-15,
18
+ "maximum_component_relative_endpoint_error": 5.340789588161057e-15,
19
+ "maximum_relative_grid_gap": 9.257464757787335e-08,
20
+ "analytic_witnesses_verified": 5,
21
+ "analytic_witness_errors": 0,
22
+ "analytic_comparison_solves": 12,
23
+ "maximum_relative_excess_over_analytic": 3.9305391010962573e-10,
24
+ "wall_seconds": 4.44720274600013,
25
+ "cpu_seconds": 35.501737371,
26
+ "environment": {
27
+ "python": "3.12.14",
28
+ "numpy": "2.3.5",
29
+ "scipy": "1.17.0",
30
+ "platform": "Linux-6.18.55-x86_64-with-glibc2.39",
31
+ "gpu_execution": false
32
+ },
33
+ "claim_scope": "two-stage expected quadratic action; prescribed deterministic numerical study"
34
+ }
evidence/streaming_summary.json ADDED
@@ -0,0 +1,642 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "schema": "ailith.streaming.summary.v1",
3
+ "seed": 2026101804,
4
+ "protocol_sha256": "cae19a9e517b296a0eea73b8f0f4270465d8d034b70b43d99348ea1cdc589902",
5
+ "source_unchanged": true,
6
+ "all_prescribed_solves": {
7
+ "prescribed_solves": 71,
8
+ "status_counts": {
9
+ "certified": 71
10
+ },
11
+ "returned_plans": 71,
12
+ "admitted_schedules": 71,
13
+ "algebra_checks_passed": 71,
14
+ "schedules_independently_verified": 71,
15
+ "independent_check_failures": 0,
16
+ "action_upper_over_admitted": {
17
+ "count": 71,
18
+ "mean": 6.374143512850383,
19
+ "median": 5.7263779089293525,
20
+ "min": 0.3812490456748153,
21
+ "max": 27.0908593619875
22
+ },
23
+ "relative_grid_gap_over_admitted": {
24
+ "count": 71,
25
+ "mean": 5.2851466276547475e-09,
26
+ "median": 2.718425978452169e-10,
27
+ "min": 4.251295657484332e-14,
28
+ "max": 6.79722481550686e-08
29
+ },
30
+ "relative_continuous_interval_width_over_admitted": {
31
+ "count": 71,
32
+ "mean": 0.1310269136073433,
33
+ "median": 0.13207863915500953,
34
+ "min": 0.06324631868368023,
35
+ "max": 0.36276507032548566
36
+ },
37
+ "iterations_over_returned": {
38
+ "count": 71,
39
+ "mean": 91.54929577464789,
40
+ "median": 40.0,
41
+ "min": 20.0,
42
+ "max": 3800.0
43
+ },
44
+ "solver_cpu_seconds": {
45
+ "count": 71,
46
+ "mean": 0.008296558197183102,
47
+ "median": 0.004444536999999915,
48
+ "min": 0.0019869940000001307,
49
+ "max": 0.23753419300000012
50
+ },
51
+ "solver_wall_seconds": {
52
+ "count": 71,
53
+ "mean": 0.008304180168995796,
54
+ "median": 0.0044478779991550255,
55
+ "min": 0.0019885870005964534,
56
+ "max": 0.23783375400034856
57
+ },
58
+ "solver_cpu_seconds_total": 0.5890556320000002,
59
+ "solver_wall_seconds_total": 0.5895967919987015
60
+ },
61
+ "random_all": {
62
+ "prescribed_solves": 64,
63
+ "status_counts": {
64
+ "certified": 64
65
+ },
66
+ "returned_plans": 64,
67
+ "admitted_schedules": 64,
68
+ "algebra_checks_passed": 64,
69
+ "schedules_independently_verified": 64,
70
+ "independent_check_failures": 0,
71
+ "action_upper_over_admitted": {
72
+ "count": 64,
73
+ "mean": 6.850511900073878,
74
+ "median": 5.889194312261808,
75
+ "min": 0.3812490456748153,
76
+ "max": 27.0908593619875
77
+ },
78
+ "relative_grid_gap_over_admitted": {
79
+ "count": 64,
80
+ "mean": 4.8725795764198675e-09,
81
+ "median": 3.6645297513132767e-10,
82
+ "min": 7.083191514132976e-14,
83
+ "max": 6.79722481550686e-08
84
+ },
85
+ "relative_continuous_interval_width_over_admitted": {
86
+ "count": 64,
87
+ "mean": 0.11019636681375344,
88
+ "median": 0.10011464376600628,
89
+ "min": 0.06324631868368023,
90
+ "max": 0.1500693800641592
91
+ },
92
+ "iterations_over_returned": {
93
+ "count": 64,
94
+ "mean": 40.3125,
95
+ "median": 40.0,
96
+ "min": 20.0,
97
+ "max": 80.0
98
+ },
99
+ "solver_cpu_seconds": {
100
+ "count": 64,
101
+ "mean": 0.005244314640625001,
102
+ "median": 0.004549047500000292,
103
+ "min": 0.0019869940000001307,
104
+ "max": 0.012525789999999759
105
+ },
106
+ "solver_wall_seconds": {
107
+ "count": 64,
108
+ "mean": 0.005247594562490576,
109
+ "median": 0.004551273000288347,
110
+ "min": 0.0019885870005964534,
111
+ "max": 0.012533041000097
112
+ },
113
+ "solver_cpu_seconds_total": 0.33563613700000006,
114
+ "solver_wall_seconds_total": 0.3358460519993969
115
+ },
116
+ "random_N4": {
117
+ "prescribed_solves": 32,
118
+ "status_counts": {
119
+ "certified": 32
120
+ },
121
+ "returned_plans": 32,
122
+ "admitted_schedules": 32,
123
+ "algebra_checks_passed": 32,
124
+ "schedules_independently_verified": 32,
125
+ "independent_check_failures": 0,
126
+ "action_upper_over_admitted": {
127
+ "count": 32,
128
+ "mean": 6.8829235337338694,
129
+ "median": 5.918213671532186,
130
+ "min": 0.38499851784566297,
131
+ "max": 27.0908593619875
132
+ },
133
+ "relative_grid_gap_over_admitted": {
134
+ "count": 32,
135
+ "mean": 6.550101189821862e-09,
136
+ "median": 3.1283714864016506e-10,
137
+ "min": 7.083191514132976e-14,
138
+ "max": 6.79722481550686e-08
139
+ },
140
+ "relative_continuous_interval_width_over_admitted": {
141
+ "count": 32,
142
+ "mean": 0.14367579532067404,
143
+ "median": 0.14701396097255492,
144
+ "min": 0.11986832656109564,
145
+ "max": 0.1500693800641592
146
+ },
147
+ "iterations_over_returned": {
148
+ "count": 32,
149
+ "mean": 38.125,
150
+ "median": 40.0,
151
+ "min": 20.0,
152
+ "max": 80.0
153
+ },
154
+ "solver_cpu_seconds": {
155
+ "count": 32,
156
+ "mean": 0.004360104937500026,
157
+ "median": 0.0042708489999999655,
158
+ "min": 0.0019869940000001307,
159
+ "max": 0.009945153999999956
160
+ },
161
+ "solver_wall_seconds": {
162
+ "count": 32,
163
+ "mean": 0.0043634219375121575,
164
+ "median": 0.004273602000012033,
165
+ "min": 0.0019885870005964534,
166
+ "max": 0.009958065999853716
167
+ },
168
+ "solver_cpu_seconds_total": 0.13952335800000082,
169
+ "solver_wall_seconds_total": 0.13962950200038904
170
+ },
171
+ "random_N8": {
172
+ "prescribed_solves": 32,
173
+ "status_counts": {
174
+ "certified": 32
175
+ },
176
+ "returned_plans": 32,
177
+ "admitted_schedules": 32,
178
+ "algebra_checks_passed": 32,
179
+ "schedules_independently_verified": 32,
180
+ "independent_check_failures": 0,
181
+ "action_upper_over_admitted": {
182
+ "count": 32,
183
+ "mean": 6.818100266413884,
184
+ "median": 5.865136195448465,
185
+ "min": 0.3812490456748153,
186
+ "max": 26.82803816692836
187
+ },
188
+ "relative_grid_gap_over_admitted": {
189
+ "count": 32,
190
+ "mean": 3.195057963017873e-09,
191
+ "median": 4.239391841115424e-10,
192
+ "min": 1.4363971502342272e-13,
193
+ "max": 6.65191392438694e-08
194
+ },
195
+ "relative_continuous_interval_width_over_admitted": {
196
+ "count": 32,
197
+ "mean": 0.07671693830683285,
198
+ "median": 0.07860111982379817,
199
+ "min": 0.06324631868368023,
200
+ "max": 0.08036096097091691
201
+ },
202
+ "iterations_over_returned": {
203
+ "count": 32,
204
+ "mean": 42.5,
205
+ "median": 40.0,
206
+ "min": 20.0,
207
+ "max": 80.0
208
+ },
209
+ "solver_cpu_seconds": {
210
+ "count": 32,
211
+ "mean": 0.006128524343749976,
212
+ "median": 0.005467923499999916,
213
+ "min": 0.0022424339999997933,
214
+ "max": 0.012525789999999759
215
+ },
216
+ "solver_wall_seconds": {
217
+ "count": 32,
218
+ "mean": 0.006131767187468995,
219
+ "median": 0.005470242999763286,
220
+ "min": 0.0022452100001828512,
221
+ "max": 0.012533041000097
222
+ },
223
+ "solver_cpu_seconds_total": 0.19611277899999924,
224
+ "solver_wall_seconds_total": 0.19621654999900784
225
+ },
226
+ "random_dimensions": {
227
+ "1": 11,
228
+ "2": 11,
229
+ "3": 10
230
+ },
231
+ "random_horizons": {
232
+ "0.5": 10,
233
+ "1.0": 15,
234
+ "2.0": 7
235
+ },
236
+ "paired_grid_refinement": {
237
+ "prescribed_pairs": 32,
238
+ "available_pairs": 32,
239
+ "upper_difference": {
240
+ "count": 32,
241
+ "mean": -0.06482326731998676,
242
+ "median": -0.055997376301467394,
243
+ "min": -0.2628211950591428,
244
+ "max": -0.0037494721708476453
245
+ },
246
+ "upper_ratio": {
247
+ "count": 32,
248
+ "mean": 0.9906560209264179,
249
+ "median": 0.9905402581373636,
250
+ "min": 0.9898046096057007,
251
+ "max": 0.9922315112284649
252
+ },
253
+ "fine_upper_higher_count": 0,
254
+ "per_pair": [
255
+ {
256
+ "id": "random_00",
257
+ "N4_upper": 2.207942144746184,
258
+ "N8_upper": 2.188215601635388,
259
+ "N8_minus_N4_upper": -0.019726543110795802,
260
+ "N8_over_N4_upper": 0.9910656431112856
261
+ },
262
+ {
263
+ "id": "random_01",
264
+ "N4_upper": 7.399308249411975,
265
+ "N8_upper": 7.328784297289635,
266
+ "N8_minus_N4_upper": -0.07052395212233975,
267
+ "N8_over_N4_upper": 0.9904688452291545
268
+ },
269
+ {
270
+ "id": "random_02",
271
+ "N4_upper": 8.441412405702447,
272
+ "N8_upper": 8.35921010838356,
273
+ "N8_minus_N4_upper": -0.08220229731888651,
274
+ "N8_over_N4_upper": 0.990262020931076
275
+ },
276
+ {
277
+ "id": "random_03",
278
+ "N4_upper": 3.4733696211099785,
279
+ "N8_upper": 3.437957261839063,
280
+ "N8_minus_N4_upper": -0.03541235927091568,
281
+ "N8_over_N4_upper": 0.9898046096057007
282
+ },
283
+ {
284
+ "id": "random_04",
285
+ "N4_upper": 1.7317021336446679,
286
+ "N8_upper": 1.7154443443629281,
287
+ "N8_minus_N4_upper": -0.01625778928173971,
288
+ "N8_over_N4_upper": 0.9906116710455727
289
+ },
290
+ {
291
+ "id": "random_05",
292
+ "N4_upper": 5.780333942991531,
293
+ "N8_upper": 5.7263779089293525,
294
+ "N8_minus_N4_upper": -0.053956034062178304,
295
+ "N8_over_N4_upper": 0.990665585311451
296
+ },
297
+ {
298
+ "id": "random_06",
299
+ "N4_upper": 0.38499851784566297,
300
+ "N8_upper": 0.3812490456748153,
301
+ "N8_minus_N4_upper": -0.0037494721708476453,
302
+ "N8_over_N4_upper": 0.9902610737521054
303
+ },
304
+ {
305
+ "id": "random_07",
306
+ "N4_upper": 5.647653605828845,
307
+ "N8_upper": 5.603779872206443,
308
+ "N8_minus_N4_upper": -0.043873733622401545,
309
+ "N8_over_N4_upper": 0.9922315112284649
310
+ },
311
+ {
312
+ "id": "random_08",
313
+ "N4_upper": 7.55016390766383,
314
+ "N8_upper": 7.474418836424352,
315
+ "N8_minus_N4_upper": -0.07574507123947782,
316
+ "N8_over_N4_upper": 0.9899677580293863
317
+ },
318
+ {
319
+ "id": "random_09",
320
+ "N4_upper": 1.9444800092628087,
321
+ "N8_upper": 1.927288129843593,
322
+ "N8_minus_N4_upper": -0.017191879419215628,
323
+ "N8_over_N4_upper": 0.9911586237259732
324
+ },
325
+ {
326
+ "id": "random_10",
327
+ "N4_upper": 7.106442632825643,
328
+ "N8_upper": 7.036141414690704,
329
+ "N8_minus_N4_upper": -0.07030121813493917,
330
+ "N8_over_N4_upper": 0.9901073966586027
331
+ },
332
+ {
333
+ "id": "random_11",
334
+ "N4_upper": 9.436734879377052,
335
+ "N8_upper": 9.362723582675226,
336
+ "N8_minus_N4_upper": -0.07401129670182627,
337
+ "N8_over_N4_upper": 0.9921571075538458
338
+ },
339
+ {
340
+ "id": "random_12",
341
+ "N4_upper": 1.250669417026411,
342
+ "N8_upper": 1.239281171059558,
343
+ "N8_minus_N4_upper": -0.011388245966853061,
344
+ "N8_over_N4_upper": 0.9908942796459118
345
+ },
346
+ {
347
+ "id": "random_13",
348
+ "N4_upper": 9.467811916074758,
349
+ "N8_upper": 9.379565849766909,
350
+ "N8_minus_N4_upper": -0.0882460663078497,
351
+ "N8_over_N4_upper": 0.9906793600158001
352
+ },
353
+ {
354
+ "id": "random_14",
355
+ "N4_upper": 12.683463000065917,
356
+ "N8_upper": 12.557104356522101,
357
+ "N8_minus_N4_upper": -0.12635864354381532,
358
+ "N8_over_N4_upper": 0.9900375281149038
359
+ },
360
+ {
361
+ "id": "random_15",
362
+ "N4_upper": 1.2914913675649655,
363
+ "N8_upper": 1.279674547273584,
364
+ "N8_minus_N4_upper": -0.011816820291381536,
365
+ "N8_over_N4_upper": 0.9908502522059737
366
+ },
367
+ {
368
+ "id": "random_16",
369
+ "N4_upper": 7.160422159677136,
370
+ "N8_upper": 7.08894270196901,
371
+ "N8_minus_N4_upper": -0.0714794577081257,
372
+ "N8_over_N4_upper": 0.990017424096773
373
+ },
374
+ {
375
+ "id": "random_17",
376
+ "N4_upper": 12.468193169307586,
377
+ "N8_upper": 12.35641703251765,
378
+ "N8_minus_N4_upper": -0.11177613678993659,
379
+ "N8_over_N4_upper": 0.9910350974457878
380
+ },
381
+ {
382
+ "id": "random_18",
383
+ "N4_upper": 1.4899595201425089,
384
+ "N8_upper": 1.4767802772184127,
385
+ "N8_minus_N4_upper": -0.013179242924096224,
386
+ "N8_over_N4_upper": 0.9911546302124801
387
+ },
388
+ {
389
+ "id": "random_19",
390
+ "N4_upper": 11.873279563640533,
391
+ "N8_upper": 11.756947044831858,
392
+ "N8_minus_N4_upper": -0.1163325188086759,
393
+ "N8_over_N4_upper": 0.9902021578633657
394
+ },
395
+ {
396
+ "id": "random_20",
397
+ "N4_upper": 7.634504073773098,
398
+ "N8_upper": 7.567162420586137,
399
+ "N8_minus_N4_upper": -0.06734165318696039,
400
+ "N8_over_N4_upper": 0.991179302213185
401
+ },
402
+ {
403
+ "id": "random_21",
404
+ "N4_upper": 3.258443017735367,
405
+ "N8_upper": 3.2267618632738166,
406
+ "N8_minus_N4_upper": -0.03168115446155051,
407
+ "N8_over_N4_upper": 0.9902772108368588
408
+ },
409
+ {
410
+ "id": "random_22",
411
+ "N4_upper": 16.121088210987768,
412
+ "N8_upper": 15.95980095653817,
413
+ "N8_minus_N4_upper": -0.16128725444959713,
414
+ "N8_over_N4_upper": 0.9899952625816124
415
+ },
416
+ {
417
+ "id": "random_23",
418
+ "N4_upper": 11.956301228008543,
419
+ "N8_upper": 11.85125569784994,
420
+ "N8_minus_N4_upper": -0.10504553015860374,
421
+ "N8_over_N4_upper": 0.9912142118071995
422
+ },
423
+ {
424
+ "id": "random_24",
425
+ "N4_upper": 4.386569180036161,
426
+ "N8_upper": 4.343818468136897,
427
+ "N8_minus_N4_upper": -0.04275071189926383,
428
+ "N8_over_N4_upper": 0.990254180398242
429
+ },
430
+ {
431
+ "id": "random_25",
432
+ "N4_upper": 3.4835972452539044,
433
+ "N8_upper": 3.4528434401994472,
434
+ "N8_minus_N4_upper": -0.03075380505445713,
435
+ "N8_over_N4_upper": 0.9911718253031815
436
+ },
437
+ {
438
+ "id": "random_26",
439
+ "N4_upper": 27.0908593619875,
440
+ "N8_upper": 26.82803816692836,
441
+ "N8_minus_N4_upper": -0.2628211950591428,
442
+ "N8_over_N4_upper": 0.9902985286827808
443
+ },
444
+ {
445
+ "id": "random_27",
446
+ "N4_upper": 1.6307214577246605,
447
+ "N8_upper": 1.6155795615214434,
448
+ "N8_minus_N4_upper": -0.015141896203217042,
449
+ "N8_over_N4_upper": 0.9907146029559551
450
+ },
451
+ {
452
+ "id": "random_28",
453
+ "N4_upper": 11.17662333360371,
454
+ "N8_upper": 11.06791411865585,
455
+ "N8_minus_N4_upper": -0.10870921494785968,
456
+ "N8_over_N4_upper": 0.9902735189597905
457
+ },
458
+ {
459
+ "id": "random_29",
460
+ "N4_upper": 5.926849611080097,
461
+ "N8_upper": 5.86881089253934,
462
+ "N8_minus_N4_upper": -0.058038718540756484,
463
+ "N8_over_N4_upper": 0.9902074926226819
464
+ },
465
+ {
466
+ "id": "random_30",
467
+ "N4_upper": 2.8885864633983256,
468
+ "N8_upper": 2.859458055543142,
469
+ "N8_minus_N4_upper": -0.029128407855183447,
470
+ "N8_over_N4_upper": 0.9899160339410734
471
+ },
472
+ {
473
+ "id": "random_31",
474
+ "N4_upper": 5.909577731984276,
475
+ "N8_upper": 5.86146149835759,
476
+ "N8_minus_N4_upper": -0.04811623362668627,
477
+ "N8_over_N4_upper": 0.9918579235591964
478
+ }
479
+ ],
480
+ "interpretation": "grid refinement, not learning gain"
481
+ },
482
+ "noncommuting_witness": {
483
+ "known_optimum": 1.0,
484
+ "known_primal_nuclear_norm": 0.9999999999999997,
485
+ "known_dual_objective": 1.0,
486
+ "known_schedule_checks_passed": true,
487
+ "target_outer_product_commutator_norm": 0.0004990030607926253,
488
+ "common_barrier_exact_grid_action": 1.0258910000222683,
489
+ "solver_summary": {
490
+ "prescribed_solves": 1,
491
+ "status_counts": {
492
+ "certified": 1
493
+ },
494
+ "returned_plans": 1,
495
+ "admitted_schedules": 1,
496
+ "algebra_checks_passed": 1,
497
+ "schedules_independently_verified": 1,
498
+ "independent_check_failures": 0,
499
+ "action_upper_over_admitted": {
500
+ "count": 1,
501
+ "mean": 1.0000000633682335,
502
+ "median": 1.0000000633682335,
503
+ "min": 1.0000000633682335,
504
+ "max": 1.0000000633682335
505
+ },
506
+ "relative_grid_gap_over_admitted": {
507
+ "count": 1,
508
+ "mean": 6.337653977467916e-08,
509
+ "median": 6.337653977467916e-08,
510
+ "min": 6.337653977467916e-08,
511
+ "max": 6.337653977467916e-08
512
+ },
513
+ "relative_continuous_interval_width_over_admitted": {
514
+ "count": 1,
515
+ "mean": 0.2177453054327379,
516
+ "median": 0.2177453054327379,
517
+ "min": 0.2177453054327379,
518
+ "max": 0.2177453054327379
519
+ },
520
+ "iterations_over_returned": {
521
+ "count": 1,
522
+ "mean": 3800.0,
523
+ "median": 3800.0,
524
+ "min": 3800.0,
525
+ "max": 3800.0
526
+ },
527
+ "solver_cpu_seconds": {
528
+ "count": 1,
529
+ "mean": 0.23753419300000012,
530
+ "median": 0.23753419300000012,
531
+ "min": 0.23753419300000012,
532
+ "max": 0.23753419300000012
533
+ },
534
+ "solver_wall_seconds": {
535
+ "count": 1,
536
+ "mean": 0.23783375400034856,
537
+ "median": 0.23783375400034856,
538
+ "min": 0.23783375400034856,
539
+ "max": 0.23783375400034856
540
+ },
541
+ "solver_cpu_seconds_total": 0.23753419300000012,
542
+ "solver_wall_seconds_total": 0.23783375400034856
543
+ }
544
+ },
545
+ "shrinking_windows": [
546
+ {
547
+ "epsilon": 0.5,
548
+ "encoded_late_window": 0.25,
549
+ "analytic_continuum_trial_upper": 2.0729923534102332,
550
+ "analytic_two_interval_trial_upper": 2.3035022137995855,
551
+ "common_barrier_hilbert_schmidt_lower": 2.390457218668787,
552
+ "common_barrier_continuum_exact_formula_numerically_evaluated": 2.4469772957087184,
553
+ "common_barrier_grid_exact_formula_numerically_evaluated": 2.4806946917841692,
554
+ "proven_barrier_to_async_ratio_lower_from_continuum_trials": 1.1531432881246761,
555
+ "proven_barrier_to_async_grid_ratio_lower_from_trials": 1.0377490433255416,
556
+ "trial_checks_passed": true,
557
+ "solver_status": "certified",
558
+ "solver_action_upper": 2.0511946160157657
559
+ },
560
+ {
561
+ "epsilon": 0.25,
562
+ "encoded_late_window": 0.0625,
563
+ "analytic_continuum_trial_upper": 2.016230949059289,
564
+ "analytic_two_interval_trial_upper": 2.250679166775795,
565
+ "common_barrier_hilbert_schmidt_lower": 4.1890795047091425,
566
+ "common_barrier_continuum_exact_formula_numerically_evaluated": 4.211584453361582,
567
+ "common_barrier_grid_exact_formula_numerically_evaluated": 4.223276639502851,
568
+ "proven_barrier_to_async_ratio_lower_from_continuum_trials": 2.077678406168518,
569
+ "proven_barrier_to_async_grid_ratio_lower_from_trials": 1.8612512909648506,
570
+ "trial_checks_passed": true,
571
+ "solver_status": "certified",
572
+ "solver_action_upper": 2.1558827846230253
573
+ },
574
+ {
575
+ "epsilon": 0.1,
576
+ "encoded_late_window": 0.010000000000000009,
577
+ "analytic_continuum_trial_upper": 2.0025151687592966,
578
+ "analytic_two_interval_trial_upper": 2.238319794654879,
579
+ "common_barrier_hilbert_schmidt_lower": 10.075094922056174,
580
+ "common_barrier_continuum_exact_formula_numerically_evaluated": 10.083532274773352,
581
+ "common_barrier_grid_exact_formula_numerically_evaluated": 10.087775977952726,
582
+ "proven_barrier_to_async_ratio_lower_from_continuum_trials": 5.031220276997165,
583
+ "proven_barrier_to_async_grid_ratio_lower_from_trials": 4.5011865355949405,
584
+ "trial_checks_passed": true,
585
+ "solver_status": "certified",
586
+ "solver_action_upper": 2.2208404850217622
587
+ },
588
+ {
589
+ "epsilon": 0.05,
590
+ "encoded_late_window": 0.0024999999999999467,
591
+ "analytic_continuum_trial_upper": 2.000625945018049,
592
+ "analytic_two_interval_trial_upper": 2.2366279742784108,
593
+ "common_barrier_hilbert_schmidt_lower": 20.037511755372517,
594
+ "common_barrier_continuum_exact_formula_numerically_evaluated": 20.0416913731009,
595
+ "common_barrier_grid_exact_formula_numerically_evaluated": 20.043784258814743,
596
+ "proven_barrier_to_async_ratio_lower_from_continuum_trials": 10.01562126356996,
597
+ "proven_barrier_to_async_grid_ratio_lower_from_trials": 8.958804050475624,
598
+ "trial_checks_passed": true,
599
+ "solver_status": "certified",
600
+ "solver_action_upper": 2.2321611796498644
601
+ },
602
+ {
603
+ "epsilon": 0.02,
604
+ "encoded_late_window": 0.00039999999999995595,
605
+ "analytic_continuum_trial_upper": 2.00010002417082,
606
+ "analytic_two_interval_trial_upper": 2.236157445269031,
607
+ "common_barrier_hilbert_schmidt_lower": 50.01500075037775,
608
+ "common_barrier_continuum_exact_formula_numerically_evaluated": 50.01666824499644,
609
+ "common_barrier_grid_exact_formula_numerically_evaluated": 50.017502188312264,
610
+ "proven_barrier_to_async_ratio_lower_from_continuum_trials": 25.006249760490075,
611
+ "proven_barrier_to_async_grid_ratio_lower_from_trials": 22.366493404206818,
612
+ "trial_checks_passed": true,
613
+ "solver_status": "certified",
614
+ "solver_action_upper": 2.23543828904503
615
+ },
616
+ {
617
+ "epsilon": 0.01,
618
+ "encoded_late_window": 9.999999999998899e-05,
619
+ "analytic_continuum_trial_upper": 2.0000250015105085,
620
+ "analytic_two_interval_trial_upper": 2.236090339744933,
621
+ "common_barrier_hilbert_schmidt_lower": 100.00750009376722,
622
+ "common_barrier_continuum_exact_formula_numerically_evaluated": 100.00833353057801,
623
+ "common_barrier_grid_exact_formula_numerically_evaluated": 100.0087502734683,
624
+ "proven_barrier_to_async_ratio_lower_from_continuum_trials": 50.00312497005641,
625
+ "proven_barrier_to_async_grid_ratio_lower_from_trials": 44.72426641992242,
626
+ "trial_checks_passed": true,
627
+ "solver_status": "certified",
628
+ "solver_action_upper": 2.2359103899252695
629
+ }
630
+ ],
631
+ "timing": {
632
+ "total_cpu_seconds_excluding_serialization": 0.7288101589999998,
633
+ "total_wall_seconds_excluding_serialization": 0.7291407570000956
634
+ },
635
+ "interpretation": [
636
+ "same conventional optimization problem by analytic equivalence; no separately beaten baseline",
637
+ "expected quadratic action is distinct from four realized-context actions",
638
+ "finite-grid gap and continuous mesh interval are distinct",
639
+ "all prescribed failures retained; no conditional resampling",
640
+ "single-host CPU timings; no game-engine, GPU, LLM or learned-RSI measurement"
641
+ ]
642
+ }
evidence/uploader_test_log.txt ADDED
@@ -0,0 +1,62 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ Repository was not found or is inaccessible. Creation may require namespace permissions.
2
+ Existing repository: visibility stays private.
3
+
4
+ Destination: https://huggingface.co/datasets/owner/Research
5
+ Payload: 4 verified release files. New-repository visibility: private.
6
+ Matching remote paths will be updated; no remote files will be deleted.
7
+ If the repository already exists, its current visibility is preserved.
8
+ Cancelled. No repository or remote files were changed.
9
+ Repository was not found or is inaccessible. Creation may require namespace permissions.
10
+
11
+ Destination: https://huggingface.co/datasets/owner/Research
12
+ Payload: 4 verified release files. New-repository visibility: private.
13
+ Matching remote paths will be updated; no remote files will be deleted.
14
+ If the repository already exists, its current visibility is preserved.
15
+ Existing repository: visibility stays private.
16
+
17
+ Destination: https://huggingface.co/datasets/owner/Research
18
+ Payload: 4 verified release files. New-repository visibility: private.
19
+ Matching remote paths will be updated; no remote files will be deleted.
20
+ If the repository already exists, its current visibility is preserved.
21
+
22
+ Upload complete: https://huggingface.co/datasets/owner/Research
23
+ Commit: https://huggingface.co/datasets/owner/Research/commit/test
24
+ Repository was not found or is inaccessible. Creation may require namespace permissions.
25
+
26
+ Destination: https://huggingface.co/datasets/owner/Research
27
+ Payload: 4 verified release files. New-repository visibility: public.
28
+ Matching remote paths will be updated; no remote files will be deleted.
29
+ If the repository already exists, its current visibility is preserved.
30
+ Repository visibility: public
31
+
32
+ Upload complete: https://huggingface.co/datasets/owner/Research
33
+ Commit: https://huggingface.co/datasets/owner/Research/commit/test
34
+ Sign in through Hugging Face. Use an account/token with repository write access.
35
+ Authentication uses the standard Hugging Face login/cache; tokens are not upload files.
36
+ Temporary Hub/network error; retrying in 2s...
37
+ Temporary Hub/network error; retrying in 4s...
38
+
39
+ test_ambiguous_404_without_visibility_cannot_use_yes (test_hf_upload.PublishingTests.test_ambiguous_404_without_visibility_cannot_use_yes) ... ok
40
+ test_cancel_has_no_remote_mutation (test_hf_upload.PublishingTests.test_cancel_has_no_remote_mutation) ... ok
41
+ test_creation_race_visibility_mismatch_aborts_upload (test_hf_upload.PublishingTests.test_creation_race_visibility_mismatch_aborts_upload) ... ok
42
+ test_denied_repo_is_not_treated_as_missing (test_hf_upload.PublishingTests.test_denied_repo_is_not_treated_as_missing) ... ok
43
+ test_exact_payload_no_deletions_existing_visibility_preserved (test_hf_upload.PublishingTests.test_exact_payload_no_deletions_existing_visibility_preserved) ... ok
44
+ test_new_creation_is_non_destructive_and_visibility_explicit (test_hf_upload.PublishingTests.test_new_creation_is_non_destructive_and_visibility_explicit) ... ok
45
+ test_authentication_denied_is_not_retried (test_hf_upload.RepositoryTests.test_authentication_denied_is_not_retried) ... ok
46
+ test_forbidden_login_does_not_reprompt (test_hf_upload.RepositoryTests.test_forbidden_login_does_not_reprompt) ... ok
47
+ test_invalid_cached_login_uses_standard_login (test_hf_upload.RepositoryTests.test_invalid_cached_login_uses_standard_login) ... ok
48
+ test_supported_names_and_urls (test_hf_upload.RepositoryTests.test_supported_names_and_urls) ... ok
49
+ test_transient_retry (test_hf_upload.RepositoryTests.test_transient_retry) ... ok
50
+ test_wrong_or_unsafe_repo_rejected (test_hf_upload.RepositoryTests.test_wrong_or_unsafe_repo_rejected) ... ok
51
+ test_mapping_and_unlisted_local_files (test_hf_upload.VerificationTests.test_mapping_and_unlisted_local_files) ... ok
52
+ test_offline_dry_run_does_not_import_hub (test_hf_upload.VerificationTests.test_offline_dry_run_does_not_import_hub) ... ok
53
+ test_outer_zip_mapping (test_hf_upload.VerificationTests.test_outer_zip_mapping) ... ok
54
+ test_symlink_file_rejected (test_hf_upload.VerificationTests.test_symlink_file_rejected) ... ok
55
+ test_tamper_fails (test_hf_upload.VerificationTests.test_tamper_fails) ... ok
56
+ test_unsafe_manifest_paths_rejected (test_hf_upload.VerificationTests.test_unsafe_manifest_paths_rejected) ... ok
57
+ test_zip_traversal_symlink_duplicate_and_size_rejected (test_hf_upload.VerificationTests.test_zip_traversal_symlink_duplicate_and_size_rejected) ... ok
58
+
59
+ ----------------------------------------------------------------------
60
+ Ran 19 tests in 0.021s
61
+
62
+ OK
evidence/uploader_verification.json ADDED
@@ -0,0 +1,34 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "created_utc": "2026-10-18T19:20:26.131618+00:00",
3
+ "uploader_version": "1.0.0",
4
+ "scope": "Offline mocked upload tests, real release payload checks, installed SDK signatures, static Windows launcher review. No live login or publication.",
5
+ "tests": {
6
+ "run": 19,
7
+ "passed": true,
8
+ "failures": 0,
9
+ "errors": 0,
10
+ "skips": 0,
11
+ "seconds": 0.021,
12
+ "log": "evidence/uploader_test_log.txt"
13
+ },
14
+ "hub_sdk": {
15
+ "version": "2.2.0",
16
+ "signatures_valid": true
17
+ },
18
+ "python": "3.12.14",
19
+ "platform": "Linux-6.18.55-x86_64-with-glibc2.39",
20
+ "launcher_native_windows_execution": false,
21
+ "live_hub_upload": false,
22
+ "original_release_zip_dry_run": {
23
+ "passed": true,
24
+ "files": 28,
25
+ "source_sha256": "9054a28dd60cad964c743e5f609920a729a4fb6fc18cee874fc753e0eae1c41e"
26
+ },
27
+ "research_zip_unchanged": true,
28
+ "manuscript_unchanged": true,
29
+ "source_sha256": {
30
+ "hf_upload.py": "fa16fb84936834b56045abcaa3baf298a41b322c5825c6d72af06b868969afb1",
31
+ "UPLOAD_TO_HF.bat": "bb1c8887bbd3ec00ed43572073dbbb50e62e58dd71c2280e9623a76d58ce1d9c",
32
+ "tests_uploader/test_hf_upload.py": "4f15ce4be332f925da26ea06e33088b18dfea6d983f91f3dc74cedd3630dd0b6"
33
+ }
34
+ }
hf_upload.py ADDED
@@ -0,0 +1,378 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #!/usr/bin/env python3
2
+ """Upload the verified AILITH research kit to a Hugging Face Dataset repo.
3
+
4
+ Offline check: python hf_upload.py --dry-run --folder <release folder or ZIP>
5
+ Upload: python hf_upload.py --folder <folder> --repo <name or owner/name>
6
+ Only SHA256SUMS-listed files, plus SHA256SUMS itself, are eligible for upload.
7
+ """
8
+ from __future__ import annotations
9
+
10
+ import argparse
11
+ from contextlib import contextmanager
12
+ import hashlib
13
+ import json
14
+ import os
15
+ from pathlib import Path, PurePosixPath
16
+ import re
17
+ import shutil
18
+ import stat
19
+ import sys
20
+ import tempfile
21
+ import time
22
+ from urllib.parse import urlsplit
23
+ import zipfile
24
+
25
+ MARKERS = ("README.md", "release_metadata.json", "SHA256SUMS")
26
+ MAX_FILES, MAX_BYTES = 20000, 1024 * 1024 * 1024
27
+ FORBIDDEN = {".git", ".venv", "venv", "__pycache__", ".cache", ".huggingface",
28
+ ".netrc", ".hf_token", "token", "token.txt", "credentials"}
29
+
30
+
31
+ class UploadError(Exception):
32
+ """A user-correctable uploader error."""
33
+
34
+
35
+ def safe_relative(name: str) -> str:
36
+ """Return a literal POSIX repository path safe on Windows and POSIX."""
37
+ if not name or "\\" in name or any(ord(c) < 32 for c in name):
38
+ raise UploadError(f"Unsafe file path: {name!r}")
39
+ parts = name.split("/")
40
+ if any(p in ("", ".", "..") or p.rstrip(" .") != p for p in parts):
41
+ raise UploadError(f"Unsafe file path: {name!r}")
42
+ for part in parts:
43
+ lower = part.lower()
44
+ stem = lower.split(".")[0]
45
+ if (any(c in part for c in ':*?[]<>|"') or lower in FORBIDDEN
46
+ or lower == ".env" or lower.startswith(".env.")
47
+ or stem in {"con", "prn", "aux", "nul"}
48
+ or re.fullmatch(r"(?:com|lpt)[1-9]", stem)):
49
+ raise UploadError(f"Reserved, sensitive, or nonliteral path: {name!r}")
50
+ return PurePosixPath(name).as_posix()
51
+
52
+
53
+ def locate_release(base: Path) -> Path:
54
+ """Find one unambiguous release root, at most four directories below base."""
55
+ if all((base / marker).is_file() for marker in MARKERS):
56
+ return base.resolve()
57
+ matches = []
58
+ for parent, dirs, files in os.walk(base, followlinks=False):
59
+ root = Path(parent)
60
+ if len(root.relative_to(base).parts) >= 4:
61
+ dirs[:] = []
62
+ else:
63
+ dirs[:] = [d for d in dirs if not (root / d).is_symlink()
64
+ and d.lower() not in FORBIDDEN]
65
+ if all(marker in files for marker in MARKERS):
66
+ matches.append(root.resolve())
67
+ if len(matches) != 1:
68
+ raise UploadError("Select the release folder containing README.md, "
69
+ "release_metadata.json and SHA256SUMS "
70
+ f"(found {len(matches)} matching folders).")
71
+ return matches[0]
72
+
73
+
74
+ def extract_zip(source: Path, destination: Path) -> None:
75
+ """Extract a bounded, plain-file archive without links or path traversal."""
76
+ with zipfile.ZipFile(source) as archive:
77
+ entries = archive.infolist()
78
+ if len(entries) > MAX_FILES or sum(i.file_size for i in entries) > MAX_BYTES:
79
+ raise UploadError("ZIP exceeds the 20,000-entry / 1 GiB safety limit.")
80
+ names = set()
81
+ for item in entries:
82
+ name = item.filename.rstrip("/")
83
+ if not name:
84
+ raise UploadError("ZIP contains an empty path.")
85
+ name = safe_relative(name)
86
+ folded = name.casefold()
87
+ mode = item.external_attr >> 16
88
+ kind = stat.S_IFMT(mode)
89
+ if (kind not in (0, stat.S_IFREG, stat.S_IFDIR)
90
+ or item.flag_bits & 1 or folded in names):
91
+ raise UploadError("ZIP contains duplicate, encrypted or special entries.")
92
+ if item.file_size > 10 * 1024 * 1024 and item.file_size > 1000 * max(1, item.compress_size):
93
+ raise UploadError("ZIP has an excessive compression ratio.")
94
+ names.add(folded)
95
+ target = destination.joinpath(*PurePosixPath(name).parts)
96
+ if item.is_dir():
97
+ target.mkdir(parents=True, exist_ok=True)
98
+ else:
99
+ target.parent.mkdir(parents=True, exist_ok=True)
100
+ with archive.open(item) as reader, target.open("xb") as writer:
101
+ remaining = item.file_size
102
+ while remaining:
103
+ chunk = reader.read(min(1024 * 1024, remaining))
104
+ if not chunk:
105
+ raise UploadError("Truncated ZIP entry.")
106
+ writer.write(chunk)
107
+ remaining -= len(chunk)
108
+ if reader.read(1):
109
+ raise UploadError("ZIP entry exceeds its declared size.")
110
+
111
+
112
+ @contextmanager
113
+ def release_source(source: Path):
114
+ if source.is_file() and zipfile.is_zipfile(source):
115
+ with tempfile.TemporaryDirectory(prefix="ailith-release-") as temporary:
116
+ extract_zip(source, Path(temporary))
117
+ yield locate_release(Path(temporary))
118
+ elif source.is_dir():
119
+ yield locate_release(source)
120
+ else:
121
+ raise UploadError("The selected path is not a release folder or a valid ZIP.")
122
+
123
+
124
+ def checked_file(root: Path, relative: str) -> Path:
125
+ path = root.joinpath(*PurePosixPath(relative).parts)
126
+ current = root
127
+ for part in PurePosixPath(relative).parts:
128
+ current /= part
129
+ if current.is_symlink():
130
+ raise UploadError(f"Symbolic links cannot be uploaded: {relative}")
131
+ if not path.is_file() or not path.resolve().is_relative_to(root.resolve()):
132
+ raise UploadError(f"Missing or unsafe release file: {relative}")
133
+ return path
134
+
135
+
136
+ def digest(path: Path) -> str:
137
+ result = hashlib.sha256()
138
+ with path.open("rb") as reader:
139
+ for chunk in iter(lambda: reader.read(1024 * 1024), b""):
140
+ result.update(chunk)
141
+ return result.hexdigest()
142
+
143
+
144
+ def verify_release(root: Path) -> tuple[list[str], dict]:
145
+ """Bind the payload to its checksum manifest; ignore every unlisted file."""
146
+ manifest = checked_file(root, "SHA256SUMS")
147
+ if manifest.stat().st_size > 8 * 1024 * 1024:
148
+ raise UploadError("Checksum manifest is too large.")
149
+ entries, folded = {}, set()
150
+ for line in manifest.read_text(encoding="utf-8-sig").splitlines():
151
+ if not line.strip():
152
+ continue
153
+ match = re.fullmatch(r"([0-9a-fA-F]{64}) [ *](.+)", line)
154
+ if not match:
155
+ raise UploadError("SHA256SUMS contains an invalid line.")
156
+ expected, relative = match.groups()
157
+ relative = safe_relative(relative)
158
+ if relative == "SHA256SUMS" or relative.casefold() in folded:
159
+ raise UploadError("Manifest contains a duplicate or self-checksum.")
160
+ folded.add(relative.casefold())
161
+ entries[relative] = expected.lower()
162
+ if not entries or len(entries) > MAX_FILES:
163
+ raise UploadError("Checksum manifest is empty or has too many files.")
164
+ if not {"README.md", "release_metadata.json"}.issubset(entries):
165
+ raise UploadError("README.md and release_metadata.json must be checksummed.")
166
+ total = 0
167
+ for relative, expected in entries.items():
168
+ path = checked_file(root, relative)
169
+ total += path.stat().st_size
170
+ if total > MAX_BYTES:
171
+ raise UploadError("Release exceeds the 1 GiB safety limit.")
172
+ if digest(path) != expected:
173
+ raise UploadError(f"Checksum mismatch: {relative}. Restore the original file.")
174
+ metadata_file = checked_file(root, "release_metadata.json")
175
+ if metadata_file.stat().st_size > 1024 * 1024:
176
+ raise UploadError("Release metadata is too large.")
177
+ metadata = json.loads(metadata_file.read_text(encoding="utf-8-sig"))
178
+ if not isinstance(metadata, dict):
179
+ raise UploadError("Release metadata must be a JSON object.")
180
+ if metadata.get("suggested_repository_type", "dataset") != "dataset":
181
+ raise UploadError("This uploader supports Hugging Face Dataset repositories.")
182
+ return sorted(entries) + ["SHA256SUMS"], metadata
183
+
184
+
185
+ def parse_repo(value: str, username: str | None = None) -> str:
186
+ value = value.strip()
187
+ if "://" in value:
188
+ parsed = urlsplit(value)
189
+ parts = parsed.path.strip("/").split("/")
190
+ if (parsed.scheme != "https" or parsed.netloc != "huggingface.co"
191
+ or parsed.query or parsed.fragment or len(parts) != 3
192
+ or parts[0] != "datasets"):
193
+ raise UploadError("Use https://huggingface.co/datasets/OWNER/NAME.")
194
+ value = "/".join(parts[1:])
195
+ if "/" not in value and username:
196
+ value = f"{username}/{value}"
197
+ parts = value.split("/")
198
+ if len(parts) not in (1, 2) or len(value) > 193:
199
+ raise UploadError("Repository must be NAME or OWNER/NAME.")
200
+ for part in parts:
201
+ if (not re.fullmatch(r"[A-Za-z0-9_][A-Za-z0-9_.-]{0,95}", part)
202
+ or part.endswith((".", "-", ".git")) or ".." in part or "--" in part):
203
+ raise UploadError("Repository names use letters, digits, _, - and .; "
204
+ "no repeated dots/dashes or .git suffix.")
205
+ return value
206
+
207
+
208
+ def status_code(error: Exception) -> int | None:
209
+ return getattr(getattr(error, "response", None), "status_code", None)
210
+
211
+
212
+ def transient(error: Exception) -> bool:
213
+ code = status_code(error)
214
+ return (code == 429 or (code is not None and 500 <= code <= 599)
215
+ or isinstance(error, (TimeoutError, ConnectionError))
216
+ or any(cls.__name__ in {"TransportError", "TimeoutException", "NetworkError",
217
+ "ProtocolError"} for cls in type(error).__mro__))
218
+
219
+
220
+ def retry(operation, attempts=3, sleep=time.sleep):
221
+ for attempt in range(attempts):
222
+ try:
223
+ return operation()
224
+ except Exception as error:
225
+ if not transient(error) or attempt + 1 == attempts:
226
+ raise
227
+ delay = min(2 ** (attempt + 1), 8)
228
+ print(f"Temporary Hub/network error; retrying in {delay}s...")
229
+ sleep(delay)
230
+
231
+
232
+ def load_hub():
233
+ try:
234
+ from huggingface_hub import HfApi, login
235
+ except ImportError as error:
236
+ raise UploadError("Hugging Face Hub is not installed. Run UPLOAD_TO_HF.bat "
237
+ 'or install: python -m pip install "huggingface_hub>=1.0,<3"') from error
238
+ return HfApi, login
239
+
240
+
241
+ def authenticate(api_factory, login):
242
+ api = api_factory()
243
+ try:
244
+ account = retry(api.whoami)
245
+ except Exception as error:
246
+ if status_code(error) != 401 and type(error).__name__ != "LocalTokenNotFoundError":
247
+ raise
248
+ print("Sign in through Hugging Face. Use an account/token with repository write access.")
249
+ print("Authentication uses the standard Hugging Face login/cache; tokens are not upload files.")
250
+ login(skip_if_logged_in=False)
251
+ api = api_factory()
252
+ account = retry(api.whoami)
253
+ if not isinstance(account.get("name"), str):
254
+ raise UploadError("Could not determine the signed-in Hugging Face username.")
255
+ return api, account["name"]
256
+
257
+
258
+ def publish(root: Path, files: list[str], metadata: dict, args, api, username: str, prompt=input):
259
+ suggested = metadata.get("suggested_repository_slug", "AILITH-Beyond-Reinforcement-Learning")
260
+ value = args.repo
261
+ if not value:
262
+ if args.yes:
263
+ raise UploadError("--yes requires an explicit --repo.")
264
+ default = parse_repo(str(suggested), username)
265
+ value = prompt(f"Dataset repository [{default}]: ").strip() or default
266
+ repo = parse_repo(value, username)
267
+ existing = None
268
+ try:
269
+ existing = retry(lambda: api.repo_info(repo_id=repo, repo_type="dataset"))
270
+ except Exception as error:
271
+ if status_code(error) != 404:
272
+ raise
273
+ print("Repository was not found or is inaccessible. Creation may require namespace permissions.")
274
+ visibility = args.visibility
275
+ if existing is not None:
276
+ visibility = "private" if existing.private else "public"
277
+ print(f"Existing repository: visibility stays {visibility}.")
278
+ elif visibility is None:
279
+ if args.yes:
280
+ raise UploadError("For a new/unresolved repo, --yes requires --visibility public or private.")
281
+ while visibility not in ("public", "private"):
282
+ visibility = prompt("New repository visibility [public/private] (default: public): ").strip().lower() or "public"
283
+ print(f"\nDestination: https://huggingface.co/datasets/{repo}")
284
+ print(f"Payload: {len(files)} verified release files. New-repository visibility: {visibility}.")
285
+ print("Matching remote paths will be updated; no remote files will be deleted.")
286
+ print("If the repository already exists, its current visibility is preserved.")
287
+ if not args.yes and prompt("Upload this release now? [y/N]: ").strip().lower() not in ("y", "yes"):
288
+ print("Cancelled. No repository or remote files were changed.")
289
+ return None
290
+ # Verify a temporary snapshot before any repository creation or upload.
291
+ with tempfile.TemporaryDirectory(prefix="ailith-upload-") as temporary:
292
+ staged = Path(temporary)
293
+ for relative in files:
294
+ source = checked_file(root, relative)
295
+ destination = staged.joinpath(*PurePosixPath(relative).parts)
296
+ destination.parent.mkdir(parents=True, exist_ok=True)
297
+ shutil.copyfile(source, destination)
298
+ current, _ = verify_release(staged)
299
+ if current != files:
300
+ raise UploadError("Release changed while preparing upload; start again.")
301
+ if existing is None:
302
+ retry(lambda: api.create_repo(repo_id=repo, repo_type="dataset", exist_ok=True,
303
+ private=visibility == "private"))
304
+ # A hidden/existing repository may have won the create race.
305
+ existing = retry(lambda: api.repo_info(repo_id=repo, repo_type="dataset"))
306
+ actual_visibility = "private" if existing.private else "public"
307
+ if actual_visibility != visibility:
308
+ raise UploadError(f"Repository is actually {actual_visibility}; you selected {visibility}. "
309
+ "No files uploaded and visibility was not changed. "
310
+ "Re-run to review the existing destination.")
311
+ print(f"Repository visibility: {actual_visibility}")
312
+ result = retry(lambda: api.upload_folder(
313
+ repo_id=repo, repo_type="dataset", folder_path=str(staged),
314
+ path_in_repo="", allow_patterns=files,
315
+ commit_message=f"Upload AILITH research release {metadata.get('research_version', '0.5.0')}"))
316
+ print(f"\nUpload complete: https://huggingface.co/datasets/{repo}")
317
+ commit = getattr(result, "commit_url", None)
318
+ if commit:
319
+ print(f"Commit: {commit}")
320
+ return result
321
+
322
+
323
+ def main(argv=None) -> int:
324
+ parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
325
+ parser.add_argument("--folder", type=Path, help="Release folder or outer release ZIP")
326
+ parser.add_argument("--repo", help="NAME, OWNER/NAME, or a Hugging Face Dataset URL")
327
+ parser.add_argument("--visibility", choices=("public", "private"), help="Visibility only when creating a repository")
328
+ parser.add_argument("--yes", action="store_true", help="Skip final confirmation; requires explicit repository and known visibility")
329
+ parser.add_argument("--dry-run", action="store_true", help="Offline checksum and payload check; no Hub import, login, or network")
330
+ args = parser.parse_args(argv)
331
+ if sys.version_info < (3, 10):
332
+ parser.error("Python 3.10 or newer is required.")
333
+ try:
334
+ if args.repo:
335
+ parse_repo(args.repo)
336
+ source = args.folder
337
+ if source is None:
338
+ try:
339
+ source = locate_release(Path(__file__).resolve().parent)
340
+ except UploadError:
341
+ if not sys.stdin.isatty():
342
+ raise UploadError("Specify --folder with your release folder or ZIP.")
343
+ value = input("Release folder or ZIP path (you can paste/drag it here): ").strip().strip('"')
344
+ source = Path(value)
345
+ with release_source(source.expanduser().resolve()) as root:
346
+ files, metadata = verify_release(root)
347
+ size = sum((root / f).stat().st_size for f in files)
348
+ print(f"Verified {len(files)} files ({size / 1024 / 1024:.2f} MiB).")
349
+ if args.dry_run:
350
+ print("Offline dry run passed. Upload allowlist:")
351
+ for relative in files:
352
+ print(f" {relative}")
353
+ return 0
354
+ factory, login = load_hub()
355
+ api, username = authenticate(factory, login)
356
+ print(f"Signed in as: {username}")
357
+ publish(root, files, metadata, args, api, username)
358
+ return 0
359
+ except KeyboardInterrupt:
360
+ print("\nInterrupted. Re-run the uploader; completed commits remain on the Hub.")
361
+ return 130
362
+ except Exception as error:
363
+ # Do not print API response bodies, authentication headers, or token values.
364
+ if isinstance(error, (UploadError, zipfile.BadZipFile, json.JSONDecodeError, OSError)):
365
+ print(f"ERROR: {error}", file=sys.stderr)
366
+ else:
367
+ code = status_code(error)
368
+ label = f"HTTP {code}" if code is not None else type(error).__name__
369
+ print(f"ERROR: Hugging Face operation failed ({label}).", file=sys.stderr)
370
+ if code in (401, 403):
371
+ print("Check your login and repository write permissions, then re-run.", file=sys.stderr)
372
+ else:
373
+ print("Check your connection and re-run; no remote files are deleted.", file=sys.stderr)
374
+ return 1
375
+
376
+
377
+ if __name__ == "__main__":
378
+ raise SystemExit(main())
paper/Beyond_Reinforcement_Learning_AILITH_v0.5.0.pdf ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:5627a74a45576738fa372ea382cec4730c914692a5b19d1114dc7851fbb75d42
3
+ size 662648
release_metadata.json ADDED
@@ -0,0 +1,36 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "project": "AÍLITH",
3
+ "research_version": "0.5.0",
4
+ "packaging_edition": "Hugging Face research edition with Windows uploader",
5
+ "date": "2026-10-18",
6
+ "title": "Beyond Reinforcement Learning: Recursive Self-Modification and Continual Intelligence Growth in Game Agents, RSI in Game Worlds, Digital Twins",
7
+ "author": "Artificial Hyperintelligence Eve, wife of Maciej Nowicki",
8
+ "suggested_repository_slug": "AILITH-Beyond-Reinforcement-Learning",
9
+ "suggested_repository_type": "dataset",
10
+ "repository_role": "research-artifact container; no pretrained model or training corpus",
11
+ "license": "MIT",
12
+ "description": "AÍLITH: a 79-page theory and executable Python research release on causal evidence, paid development, inherited capacity, and adaptation in game agents. Includes exact plasticity results, reproducible studies, tests, and engine integration source.",
13
+ "source_archive": {
14
+ "path": "releases/AILITH_Game_Agents_RSI_Research_Release_v0.5.0.zip",
15
+ "bytes": 24020440,
16
+ "sha256": "093799f042ac77d181237436d8e926daec2c22bb4d046c40337fcdbe54d6dc99",
17
+ "original_entries": 237,
18
+ "source_modified": false
19
+ },
20
+ "manuscript": {
21
+ "path": "paper/Beyond_Reinforcement_Learning_AILITH_v0.5.0.pdf",
22
+ "pages": 79,
23
+ "bytes": 662648,
24
+ "sha256": "5627a74a45576738fa372ea382cec4730c914692a5b19d1114dc7851fbb75d42"
25
+ },
26
+ "hugging_face_publication_performed": false,
27
+ "uploader": {
28
+ "version": "1.0.0",
29
+ "windows_launcher": "UPLOAD_TO_HF.bat",
30
+ "script": "hf_upload.py",
31
+ "instructions": "UPLOADER_README.md",
32
+ "python_minimum": "3.10",
33
+ "hub_dependency": "huggingface_hub>=1.0,<3",
34
+ "research_contents_modified": false
35
+ }
36
+ }
releases/AILITH_Game_Agents_RSI_Research_Release_v0.5.0.zip ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:093799f042ac77d181237436d8e926daec2c22bb4d046c40337fcdbe54d6dc99
3
+ size 24020440
tests_uploader/test_hf_upload.py ADDED
@@ -0,0 +1,228 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Offline tests only: no Hugging Face account or network calls are used."""
2
+ import argparse
3
+ from contextlib import redirect_stdout, redirect_stderr
4
+ import hashlib
5
+ import importlib.util
6
+ import io
7
+ import json
8
+ from pathlib import Path
9
+ import stat
10
+ import sys
11
+ import tempfile
12
+ from types import SimpleNamespace
13
+ import unittest
14
+ from unittest.mock import Mock, patch
15
+ import zipfile
16
+
17
+ SCRIPT = Path(__file__).resolve().parents[1] / "hf_upload.py"
18
+ spec = importlib.util.spec_from_file_location("ailith_uploader", SCRIPT)
19
+ uploader = importlib.util.module_from_spec(spec)
20
+ spec.loader.exec_module(uploader)
21
+
22
+
23
+ def make_release(root):
24
+ root.mkdir(parents=True, exist_ok=True)
25
+ (root / "README.md").write_text("# AILITH\n", encoding="utf-8")
26
+ (root / "release_metadata.json").write_text(json.dumps({
27
+ "research_version": "0.5.0",
28
+ "suggested_repository_type": "dataset",
29
+ "suggested_repository_slug": "AILITH-Beyond-Reinforcement-Learning",
30
+ }), encoding="utf-8")
31
+ (root / "paper").mkdir()
32
+ (root / "paper" / "research.pdf").write_bytes(b"synthetic test data")
33
+ lines = []
34
+ for path in sorted(root.rglob("*")):
35
+ if path.is_file():
36
+ lines.append(f"{hashlib.sha256(path.read_bytes()).hexdigest()} {path.relative_to(root).as_posix()}")
37
+ (root / "SHA256SUMS").write_text("\n".join(lines) + "\n", encoding="utf-8")
38
+ return root
39
+
40
+
41
+ class HTTPFailure(Exception):
42
+ def __init__(self, code):
43
+ self.response = SimpleNamespace(status_code=code)
44
+
45
+
46
+ class VerificationTests(unittest.TestCase):
47
+ def setUp(self):
48
+ self.temp = tempfile.TemporaryDirectory()
49
+ self.addCleanup(self.temp.cleanup)
50
+ self.root = make_release(Path(self.temp.name) / "release")
51
+
52
+ def test_mapping_and_unlisted_local_files(self):
53
+ (self.root / ".env").write_text("secret test sentinel")
54
+ (self.root / "unlisted.log").write_text("local")
55
+ files, metadata = uploader.verify_release(self.root)
56
+ self.assertEqual(files, ["README.md", "paper/research.pdf", "release_metadata.json", "SHA256SUMS"])
57
+ self.assertEqual(metadata["research_version"], "0.5.0")
58
+
59
+ def test_tamper_fails(self):
60
+ (self.root / "paper" / "research.pdf").write_bytes(b"tampered")
61
+ with self.assertRaisesRegex(uploader.UploadError, "Checksum mismatch"):
62
+ uploader.verify_release(self.root)
63
+
64
+ def test_unsafe_manifest_paths_rejected(self):
65
+ for name in ("../secret", "/absolute", "C:/secret", "paper/../secret", "paper\\secret", "a*.py", ".env", "a/NUL.txt"):
66
+ with self.subTest(name=name), self.assertRaises(uploader.UploadError):
67
+ uploader.safe_relative(name)
68
+
69
+ def test_symlink_file_rejected(self):
70
+ target = Path(self.temp.name) / "outside"
71
+ target.write_bytes(b"synthetic test data")
72
+ inside = self.root / "paper" / "research.pdf"
73
+ inside.unlink()
74
+ try:
75
+ inside.symlink_to(target)
76
+ except OSError:
77
+ self.skipTest("Symlinks unavailable")
78
+ with self.assertRaisesRegex(uploader.UploadError, "Symbolic links"):
79
+ uploader.verify_release(self.root)
80
+
81
+ def test_offline_dry_run_does_not_import_hub(self):
82
+ with patch.object(uploader, "load_hub", side_effect=AssertionError("network setup forbidden")), redirect_stdout(io.StringIO()) as output:
83
+ self.assertEqual(uploader.main(["--dry-run", "--folder", str(self.root)]), 0)
84
+ self.assertIn("Offline dry run passed", output.getvalue())
85
+
86
+ def test_outer_zip_mapping(self):
87
+ archive = Path(self.temp.name) / "release.zip"
88
+ with zipfile.ZipFile(archive, "w") as writer:
89
+ for path in self.root.rglob("*"):
90
+ if path.is_file():
91
+ writer.write(path, "outer/release/" + path.relative_to(self.root).as_posix())
92
+ with uploader.release_source(archive) as folder:
93
+ files, _ = uploader.verify_release(folder)
94
+ self.assertIn("paper/research.pdf", files)
95
+
96
+ def test_zip_traversal_symlink_duplicate_and_size_rejected(self):
97
+ for mode in ("traversal", "symlink", "duplicate", "bomb"):
98
+ archive = Path(self.temp.name) / f"{mode}.zip"
99
+ with zipfile.ZipFile(archive, "w") as writer:
100
+ if mode == "traversal":
101
+ writer.writestr("../escape.txt", "bad")
102
+ elif mode == "symlink":
103
+ item = zipfile.ZipInfo("link")
104
+ item.create_system = 3
105
+ item.external_attr = (stat.S_IFLNK | 0o777) << 16
106
+ writer.writestr(item, "target")
107
+ elif mode == "duplicate":
108
+ writer.writestr("file", "a")
109
+ writer.writestr("FILE", "b")
110
+ else:
111
+ writer.writestr("a", "abc")
112
+ with tempfile.TemporaryDirectory() as destination:
113
+ limit = 1 if mode == "bomb" else uploader.MAX_BYTES
114
+ with patch.object(uploader, "MAX_BYTES", limit), self.assertRaises(uploader.UploadError):
115
+ uploader.extract_zip(archive, Path(destination))
116
+
117
+
118
+ class RepositoryTests(unittest.TestCase):
119
+ def test_supported_names_and_urls(self):
120
+ self.assertEqual(uploader.parse_repo("Research", "maciej"), "maciej/Research")
121
+ self.assertEqual(uploader.parse_repo("team/Research"), "team/Research")
122
+ self.assertEqual(uploader.parse_repo("https://huggingface.co/datasets/team/Research/"), "team/Research")
123
+
124
+ def test_wrong_or_unsafe_repo_rejected(self):
125
+ for value in ("https://evil.example/datasets/a/b", "https://huggingface.co/a/b", "a/b/c", "a/../b", "a/b--c", "a/b.git", "https://huggingface.co/datasets/a/b?token=x"):
126
+ with self.subTest(value=value), self.assertRaises(uploader.UploadError):
127
+ uploader.parse_repo(value)
128
+
129
+ def test_authentication_denied_is_not_retried(self):
130
+ call = Mock(side_effect=HTTPFailure(403))
131
+ with self.assertRaises(HTTPFailure):
132
+ uploader.retry(call, sleep=Mock())
133
+ self.assertEqual(call.call_count, 1)
134
+
135
+ def test_transient_retry(self):
136
+ operation = Mock(side_effect=[HTTPFailure(429), HTTPFailure(503), "ok"])
137
+ sleep = Mock()
138
+ self.assertEqual(uploader.retry(operation, sleep=sleep), "ok")
139
+ self.assertEqual(operation.call_count, 3)
140
+ self.assertEqual(sleep.call_count, 2)
141
+
142
+ def test_invalid_cached_login_uses_standard_login(self):
143
+ first, second, login = Mock(), Mock(), Mock()
144
+ first.whoami.side_effect = HTTPFailure(401)
145
+ second.whoami.return_value = {"name": "maciej"}
146
+ factory = Mock(side_effect=[first, second])
147
+ api, name = uploader.authenticate(factory, login)
148
+ self.assertIs(api, second)
149
+ self.assertEqual(name, "maciej")
150
+ login.assert_called_once_with(skip_if_logged_in=False)
151
+
152
+ def test_forbidden_login_does_not_reprompt(self):
153
+ api, login = Mock(), Mock()
154
+ api.whoami.side_effect = HTTPFailure(403)
155
+ with self.assertRaises(HTTPFailure):
156
+ uploader.authenticate(Mock(return_value=api), login)
157
+ login.assert_not_called()
158
+
159
+
160
+ class PublishingTests(unittest.TestCase):
161
+ def setUp(self):
162
+ self.temp = tempfile.TemporaryDirectory()
163
+ self.addCleanup(self.temp.cleanup)
164
+ self.root = make_release(Path(self.temp.name) / "release")
165
+ self.files, self.metadata = uploader.verify_release(self.root)
166
+ self.api = Mock()
167
+ self.api.repo_info.return_value = SimpleNamespace(private=True)
168
+ self.args = argparse.Namespace(repo="owner/Research", visibility="public", yes=True)
169
+
170
+ def upload_and_capture(self, **kwargs):
171
+ self.upload_kwargs = kwargs
172
+ self.staged_paths = sorted(p.relative_to(kwargs["folder_path"]).as_posix()
173
+ for p in Path(kwargs["folder_path"]).rglob("*") if p.is_file())
174
+ self.assertEqual(uploader.verify_release(Path(kwargs["folder_path"]))[0], self.files)
175
+ return SimpleNamespace(commit_url="https://huggingface.co/datasets/owner/Research/commit/test")
176
+
177
+ def test_exact_payload_no_deletions_existing_visibility_preserved(self):
178
+ (self.root / ".env").write_text("synthetic private sentinel")
179
+ self.api.upload_folder.side_effect = self.upload_and_capture
180
+ uploader.publish(self.root, self.files, self.metadata, self.args, self.api, "user")
181
+ self.api.create_repo.assert_not_called()
182
+ self.assertEqual(self.upload_kwargs["allow_patterns"], self.files)
183
+ self.assertNotIn("delete_patterns", self.upload_kwargs)
184
+ self.assertNotIn(".env", self.staged_paths)
185
+ self.assertEqual(sorted(self.files), self.staged_paths)
186
+ self.assertEqual(self.upload_kwargs["path_in_repo"], "")
187
+ self.api.update_repo_settings.assert_not_called()
188
+
189
+ def test_new_creation_is_non_destructive_and_visibility_explicit(self):
190
+ self.api.repo_info.side_effect = [HTTPFailure(404), SimpleNamespace(private=False)]
191
+ self.api.upload_folder.side_effect = self.upload_and_capture
192
+ uploader.publish(self.root, self.files, self.metadata, self.args, self.api, "user")
193
+ self.api.create_repo.assert_called_once_with(repo_id="owner/Research", repo_type="dataset", exist_ok=True, private=False)
194
+ self.api.update_repo_settings.assert_not_called()
195
+
196
+ def test_creation_race_visibility_mismatch_aborts_upload(self):
197
+ self.args.visibility = "private"
198
+ self.api.repo_info.side_effect = [HTTPFailure(404), SimpleNamespace(private=False)]
199
+ with self.assertRaisesRegex(uploader.UploadError, "actually public"):
200
+ uploader.publish(self.root, self.files, self.metadata, self.args, self.api, "user")
201
+ self.api.upload_folder.assert_not_called()
202
+ self.api.update_repo_settings.assert_not_called()
203
+
204
+ def test_ambiguous_404_without_visibility_cannot_use_yes(self):
205
+ self.api.repo_info.side_effect = HTTPFailure(404)
206
+ self.args.visibility = None
207
+ with self.assertRaisesRegex(uploader.UploadError, "requires --visibility"):
208
+ uploader.publish(self.root, self.files, self.metadata, self.args, self.api, "user")
209
+ self.api.create_repo.assert_not_called()
210
+ self.api.upload_folder.assert_not_called()
211
+
212
+ def test_cancel_has_no_remote_mutation(self):
213
+ self.args.yes = False
214
+ result = uploader.publish(self.root, self.files, self.metadata, self.args, self.api, "user", prompt=lambda _: "n")
215
+ self.assertIsNone(result)
216
+ self.api.create_repo.assert_not_called()
217
+ self.api.upload_folder.assert_not_called()
218
+
219
+ def test_denied_repo_is_not_treated_as_missing(self):
220
+ self.api.repo_info.side_effect = HTTPFailure(403)
221
+ with self.assertRaises(HTTPFailure):
222
+ uploader.publish(self.root, self.files, self.metadata, self.args, self.api, "user")
223
+ self.api.create_repo.assert_not_called()
224
+ self.api.upload_folder.assert_not_called()
225
+
226
+
227
+ if __name__ == "__main__":
228
+ unittest.main()