AUREOLE-R 3.0.0-hf.1: standalone public research release

Verified paper, source, prior, raw evidence, protocols and machine-readable research indexes. Finite CPU reference; full unified SR/RR/FG remains unvalidated.

.gitattributes

@@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+AUREOLE_R_v2.0.0_Research_Release.pdf filter=lfs diff=lfs merge=lfs -text
+AUREOLE_R_v3.0.0_Certified_Innovation_Rendering.pdf filter=lfs diff=lfs merge=lfs -text
+figures/architecture.png filter=lfs diff=lfs merge=lfs -text
+figures/change_recovery.png filter=lfs diff=lfs merge=lfs -text
+figures_v3/innovation_results.png filter=lfs diff=lfs merge=lfs -text
+legacy/AUREOLE_Unified_Latent_World_Model_v1.0.0.pdf filter=lfs diff=lfs merge=lfs -text
+legacy/figures/architecture.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,19 @@
+.venv/
+.venv-publish/
+__pycache__/
+*.pyc
+build/
+dist/
+*.egg-info/
+demo_output/
+reproduced_results/
+figures_reproduced/
+retrained/
+validation_reproduced.json
+.env
+*.token
+publication_receipt.json
+publication_validation_local.json
+innovation_reproduced/
+queries_reproduced/
+innovation_demo/

AGENTS.md

@@ -0,0 +1,11 @@
+# Research-agent entry point
+
+This repository is AUREOLE-R scientific version 3.0.0, publication edition 3.0.0-hf.1.
+
+Read `README.md`, `CLAIMS.json` and `AI_AGENT_INDEX.json` before summarizing conclusions. `MANUSCRIPT.md` is the complete standalone paper; `llms-full.txt` is a convenience full-text bundle. Current root metadata governs v3; `history/` and `legacy/` are explicitly older evidence.
+
+Preserve distinctions between proved-under-assumptions, recorded experiment, estimate and hypothesis. Cite the experiment, comparator, phase and cost boundary with every numerical claim. The 98.40% MSE reduction is specific to smooth known motion and its stated reset baseline. The 76.85% saving is a physical-query count including warmup, not a GPU speedup. The included weights are one small visibility prior, not a full unified renderer. No 100% scientific maturity, GPU benchmark, DLSS compatibility, peer review or arXiv/DOI identifier is established.
+
+Use `REPRODUCIBILITY.md` for commands. Run reproductions into their default new output directories; preserve recorded results, frozen protocols and weights. Use `python scripts/publish_hf.py` for an offline integrity check. The `--publish` flag is a separate explicit public mutation; do not upload or request credentials merely to read or reproduce research. Never put tokens into source, reports or command arguments.
+
+For extensions, keep assumptions, negative outcomes and accounting visible. Use the immutable Hub commit in citations and bug reports. Publication workflow tests in `publication_tests/` are separate from scientific tests. No subagent/delegation requirement is implied by this file.

AI_AGENT_INDEX.json

@@ -0,0 +1,78 @@
+{
+  "version": "3.0.0",
+  "start_here": [
+    "README.md",
+    "STATUS.json",
+    "CLAIMS.json",
+    "docs/RELEASE_SCOPE.md"
+  ],
+  "math": [
+    "MANUSCRIPT.md",
+    "docs/INNOVATION_THEORY.md",
+    "THEOREM_INDEX.md"
+  ],
+  "implementation": [
+    "aureole/certificates.py",
+    "aureole/innovation.py",
+    "docs/CERTIFICATE_API.md"
+  ],
+  "evidence": [
+    "results_v3/innovation_report.json",
+    "results_v3/innovation_raw.csv",
+    "results_v3/queries_report.json",
+    "results_v3/queries_raw.csv"
+  ],
+  "reproduce": [
+    "scripts/demo_innovation.py",
+    "scripts/benchmark_innovation.py",
+    "scripts/benchmark_queries.py",
+    "scripts/validate_release.py"
+  ],
+  "prior_evidence": [
+    "results/rendering_report.json",
+    "results/followup_report.json",
+    "history/v2/STATUS.json"
+  ],
+  "warning": "Current root metadata governs v3. Historical v2 checks and claims retain their earlier scope. No GPU/full SR/RR/FG validation.",
+  "publication_edition": "3.0.0-hf.1",
+  "machine_entry_points": [
+    "llms.txt",
+    "claims.jsonl",
+    "EVIDENCE_INDEX.json",
+    "FILE_CATALOG.json",
+    "metadata/research.jsonld"
+  ],
+  "expert_route": [
+    "EXPERT_REVIEW_GUIDE.md",
+    "docs/INNOVATION_THEORY.md",
+    "aureole/innovation.py",
+    "results_v3/innovation_report.json",
+    "results_v3/queries_report.json"
+  ],
+  "reproduction_route": [
+    "REPRODUCIBILITY.md",
+    "DATA_DICTIONARY.md",
+    "experiments_innovation.json",
+    "experiments_queries.json"
+  ],
+  "full_text": "llms-full.txt",
+  "publication": [
+    "START_HERE.md",
+    "PUBLICATION.json"
+  ],
+  "historical_precedence": "Root v3 scope and results_v3 take precedence for current claims; history and legacy preserve earlier snapshots.",
+  "citation": "CITATION.cff",
+  "scientific_preservation": "publication/SCIENCE_PRESERVATION.json",
+  "research_objective_aliases": [
+    "unified DLSS latent world model",
+    "persistent neural world state",
+    "super resolution",
+    "ray reconstruction",
+    "frame generation",
+    "neural rendering",
+    "denoising",
+    "disocclusion",
+    "adaptive sampling"
+  ],
+  "alias_scope": "Research objectives, not validated product capabilities."
+}

AUREOLE_R_v2.0.0_Research_Release.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:150741a0c8507066eb67034964bf8919823c9b551897bf0cedec1991b5091be3
+size 974277

AUREOLE_R_v3.0.0_Certified_Innovation_Rendering.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75d2fc744ca6e2cf09a396450b6f40744bfedd084933e5e0698417ccc57923ed
+size 1311904

CHANGELOG.md

@@ -0,0 +1,24 @@
+# Publication edition 3.0.0-hf.1
+
+- Added searchable Hub card and expert/AI-agent reading routes.
+- Added exact-result evidence selectors, citation formats, artifact inventory and synthetic-data dictionary.
+- Added hidden-token Windows launcher, account checks, byte-matching retries, parent-commit guard and anonymous public verification.
+- Preserved all scientific evidence and source; no new rendering experiment or performance claim.
+
+# v3.0.0 - Certified Innovation Rendering
+
+Added six scoped results, geometric validity, residual-support elimination, sixteen tests and two new held-out protocols. Retained v2 mathematics, code, weights and adverse evidence. Updated standalone manuscript, API, agent metadata and publication launchers. No new model training, GPU execution or external publication.
+
+# Changes in 2.0.0
+
+Version 1 supplied a broad world-model specification, ten scoped mathematical propositions, six synthetic witnesses and fourteen checks. Version 2 adds a working physical estimation loop rather than relabeling the original proposal as finished.
+
+- Add a frozen exact-integral correction API, with tests exposing same-sample refitting, wrong-integral bias and clipping bias.
+- Add canonical visibility memory, numeric checkpoint persistence, namespace checks, trust epochs and observation-triggered revision.
+- Train and package one small visibility prior, with explicit train/validation/test scene splits and a model card.
+- Execute a direct-light shadow benchmark on eight held-out scenes; retain active-sampling and stale-state failures.
+- Execute an independent eight-scene follow-up testing trust revocation without an oracle event flag.
+- Derive five additional scoped results: conditional correction, residual-risk information value, estimator equivalence, detection-delay limits and a fixed-budget concentration bound.
+- Package an installable NumPy API, physical demo, new tests, exact replay evidence, publication helper, full manuscript and original v1 archive.
+
+There is no full SR/RR/FG implementation, GPU backend, game integration, broad calibration result or production speedup. Scientific maturity is estimated at 65%; the project remains classified as meaningful, not major or transformative.

CHECKSUMS.sha256

@@ -0,0 +1,195 @@
+c801655ac6b3603396c495eff65a26972868eebb16c7dfc5be51b3b8e7edd4c8  .gitignore
+733a1ce5e1b1dc5031e4eb820f1c7077e3d40692261bb909d1bc4064d9266ebd  AGENTS.md
+9f46112aa244ae47a7a606097cfb653194be0f47a99be83775915dce7c3403fc  AI_AGENT_INDEX.json
+150741a0c8507066eb67034964bf8919823c9b551897bf0cedec1991b5091be3  AUREOLE_R_v2.0.0_Research_Release.pdf
+75d2fc744ca6e2cf09a396450b6f40744bfedd084933e5e0698417ccc57923ed  AUREOLE_R_v3.0.0_Certified_Innovation_Rendering.pdf
+4afcd70a9264a0e408ce199a4404e2ddcdb5a69feeca49a9679e337abbd4869e  CHANGELOG.md
+906a94019da72b921ee9ddd52db30687a5772b9209e65b5ca5ba11568644fd8b  CITATION.bib
+0c881654dfb31607e36a6de0aa84276d245073e283d3bf89ae6929c06985659d  CITATION.cff
+2de213f65634ad0de8e98883ece6d91b9e009b7c1433e85fba5cc02faee8bacc  CLAIMS.json
+b990c53386ab9b8a058bdf911d44d03c3026f995f59b60bdc591ac54a7f4f953  DATA_DICTIONARY.md
+ad2b245b2214647ee6112c33910484beccd5d56f9d5e01e288d0fe1e6f42c7b3  EVIDENCE_INDEX.json
+0b72c693c885b71a4cee5b90fbe12e8dc2b461cd821a27f13e4ebdc8b535958b  EXPERT_REVIEW_GUIDE.md
+12ebf395752824d75391cb1cf0defe1642014731803ddf84462e6e18c56707a6  FILE_CATALOG.json
+da83b080f0e7fa682117f5222173acb1f52203ada97c6baba1f1f2676f70d635  LICENSE
+d60ca7f87a194afa20cefd55fcec981ef7a5571abac397365dcd16474acafd8d  MANUSCRIPT.md
+bb153d83af1ce2d7fb906966c0b3788ad9d0bc23170c5ce5bb1912523e31b3e5  MODEL_CARD.md
+628f70c289bbac60c917a5aa6a8a96e7bf451448a4d61388370d9452975d03dc  PUBLICATION.json
+a640e1a071c35d1e3fe971aa65c8bbe28cae3a4e348716155ea1fc62808ae2c0  PUBLIC_RELEASE_NOTES.md
+52a09fada0e33b4a42ac16d2376b4cf3fdc11348e352820b2ee9e93f9c27ee80  PUBLISH_HF.bat
+cdffba2de9bd02aeb6d8eef0194e7e0dbc1da3c9d5252908612b9de858c301c1  PUBLISH_TO_HUGGINGFACE.bat
+85580701af138588bb7b0dffa703d449e357e90fa5d16f10669558705ab0d757  README.md
+3e84976b0aed5c002b1f644bb733fe7068fd47cf1a54d5df3377ac7a23d297c5  RELEASE_MANIFEST.json
+39c830e7953ea587164fbf6af1c6fa351ca55b28320bd064c524d4e250b521e7  RENDERER_INTERFACE.md
+c3f5bc518d2330ec6e27098a57b0f6d735ccc3a0b29001b3f24b4418c5ce2ccf  REPRODUCE.bat
+9661a06e31426f4af41cb037eb411eb937bcdd64752c928d1413865aae966c38  REPRODUCIBILITY.md
+903279b3ec6d35e1a77a2597834998170b1ce1536fda2ccef34d867ab8ffd864  REQUIREMENTS_MAP.md
+eaed23cf10668446ac3afc238199eca0bd8eacf5a957b57383cc493d89705e22  RUN_DEMO.bat
+5a0845e54a9bd7cd237958aab17c5e6fb49e93560570d4c24890e16b999b23b1  RUN_INNOVATION.bat
+d6cfeb037248793e3dc0cb282dc3b72e72c60eabb5be4b4501dd4bd5e3e41429  START_HERE.md
+b544bbda77c4192cfcaa0f70eca332accda4cf5595c0c421c31e3c845c9260e3  STATUS.json
+807151429bdcae24b99e761cfec88e18909ee253931a924acfebe6940a6b134d  THEOREM_INDEX.md
+4386f21756aec41c009d1274e01e96de2ebccee9c6e95994e7707252f83bf74f  aureole/__init__.py
+1a84836b328a3405498194622474bba37c968634791bc0fe7964ad8fca63650c  aureole/certificates.py
+3c9c0316ce9b98b7acb5b36700a06a6f5c65317fb073381605fa9a7866afbf56  aureole/core.py
+f522dfce35f5fc4f2777a7b6a341d0fe426120456cd5fb66a13aba603f55062f  aureole/innovation.py
+d0d4f612acde5e3f78deb6360712c38ad39c5ca1584edca674c4158f31ed7bb6  aureole/memory.py
+841b6f94cc34e61435885a9a497ae2119dc7b47900c7e8bafe46127d3c919411  aureole/renderer.py
+4c1958e8567b708d41291d6d18a1420fbe4fe1081ebe20e176dc0671a6ea4963  claims.jsonl
+c98b0c1b574d8bde702ca4b26f50dab4864fca58d0a818fa10584963359a61d9  docs/CERTIFICATE_API.md
+ce4c91b6b8c7c67dea1d15e5cd29bbf8e4dcb194239ab6462b9a54a30d5f4fba  docs/ERRATA.md
+4571ba92ef00bee38b1569ba54aad157d4126b9cb8865d0b9ea3a0d155dd5360  docs/ESTIMATOR_CONTRACT.md
+4fd4837ff95487ce5bb3a75a4f41cfd42f3457b309168332fb831d916edfa142  docs/INNOVATION_THEORY.md
+bcb48e239ba832c914cc850cfd96f59161ed722b36e887726e0ce2eb4ebd0fd5  docs/PHYSICAL_EVIDENCE.md
+a23850fd37c33640cb69cd843799dca6e97c58bb7eeb1870c2e09e9add9cb83e  docs/RELEASE_SCOPE.md
+b9c5d6ea4cd136f03d2ec749487a477ffa08a27534de5df2dce6235ce8b9564b  docs/RESIDUAL_THEORY.md
+73363e858bb770f72b9a3dd77e60e1032ca10f685f806edc47182d0e746c2140  experiments.json
+a1daabb6dc4672d7cd66aa238271919a7c3d55918ea8aa03703be37eafbfaa3c  experiments_followup.json
+743f7091b6997cd6c9e182d2a4f75db5eaadc8b892e31c9a5c01263eb0a4facd  experiments_innovation.json
+59540fb9ebbb7c35f487df7227bf0ae06fde38f1959c0746192b7463dc363bc6  experiments_queries.json
+7410b8a61c604489b58fc44473f2b504457850e1e0d9ba68e7133b8913bb4d1f  figures/active_sampling.pdf
+a3a0b5d291f3e41f8d4767a67e426fa1ff327ce457bd1e16afd57ccd67a9ed81  figures/active_sampling.png
+23660aa55c2b2f8afcb2d1828e31cfd0d4ec9739a7702c4ca689e39deec2765e  figures/architecture.pdf
+fb99bab78e597b834be55e3e8340fe430d2fef191f3ca7c88e5f78da6b18c862  figures/architecture.png
+9d9489375e56c14fe752037ccad94a6d8fc2631bb9a37b0aa21ff776633aa31a  figures/atlas_changed.pdf
+35a9ce95ab0becc71ac0120db05c85681a9971cf3b0245a1d6b7d186b44e8cd8  figures/atlas_changed.png
+ab5099d9fd75537a45328a3633227d092e176a005adc0d41f5a94dc45a613865  figures/atlas_static.pdf
+6446e8ab1b6d0b5f067bc207f4882465c84189c650e09c3a4058ea4295551db4  figures/atlas_static.png
+5ad9cbbd89e958a8421fe7efd23dfb9ad476059ebdf2a273e4957e6e78791d2d  figures/atlas_views.pdf
+4bce5a77dba3953de7d4323cb62e0c71c9988026d9eab1bb28e226c6d06c8d4b  figures/atlas_views.png
+0679014ccfd6bcc2c25fcb07d31d324ee41e1803e10132efe512eeefc3a3f345  figures/change_recovery.pdf
+02de3c2fd030220be8e061738202cda5aa37bb9fa9100e760cd3b034ed073219  figures/change_recovery.png
+cf45c6e43c504e2b1822507cf5d28740ef9108a181c31bfcebf6dc1de292f213  figures/compression.pdf
+c75c40fd7ef4508dc5669e12bde7d1b469e234a18de7a0c7c2871ec184166d5b  figures/compression.png
+8fb3a5bda028e4e5accccf4cd763eeb4a3965d4449390426e4e5ae9659af9891  figures/physical_frames.pdf
+e24a02875feaba16547afc1ef65640225e5a4710238769a77f89217c4af564c8  figures/physical_frames.png
+3eb211731f273a1ae596611af396b5164746ead32cbe5738811cd611400984bf  figures/physical_results.pdf
+20a8fbd35bdec10411d279a942eaafd0ae2f4d765c15e22d8f79179abf16288f  figures/physical_results.png
+b02cbe7f10c825138e1ded8eda3f44e0a0eedfd705f4531bf56551a6bfc5191b  figures/training_curve.pdf
+5f0bc2553c6a07a7aec6c7b13bd7fa5321acdff11e2c3302cc712778593cb36a  figures/training_curve.png
+65d90ea7cd392b5c51ec41d49bf7767b1ec494a5a35ae5bfdb0d7f78e60e925c  figures_v3/innovation_dynamics.pdf
+a66978fd14a84114a7df22c508bffe5b6f322b6ff8ae5e3f30f0c8e21503d183  figures_v3/innovation_dynamics.png
+6e1c9908547bd928acbc87fcc5b50400a6e600d6c6cc3c5eefff73de7ee53cd7  figures_v3/innovation_results.pdf
+e41747c9d914ce23c0c23c0da9e5cb6180be9db3a2f1772e5602c96c9f5a72ea  figures_v3/innovation_results.png
+3dd1ac2407d2de8685b12b3bab043f73b73d4d6e941d0065d3588d4da75ee2a9  figures_v3/query_readouts.pdf
+57dd803d708c09df037cce03e9e6f09043041f4166a24f12ec659cb8f7e110d1  figures_v3/query_readouts.png
+e72bde00d8581c0813e708aeac5d3f56156b11f071df9de57758e4a636c73349  history/v2/AI_AGENT_INDEX.json
+360b8328666566f448e625e70f84005bcccc2d843316d938c34fccfa775edf1a  history/v2/CLAIMS.json
+340bf5a52873cc08870eaff0ae8e1c18795cb10083264a25b1bf16ff14a15ed9  history/v2/MANUSCRIPT.md
+9f3944a9d021dfcca99cc305d4acb07ec856ed3eb26cfaeec95f9a89b7b6255b  history/v2/ORIGINAL_CHECKSUMS.sha256
+ae543a4de02938672f90516590822dae576044899f635d9764713806fdceae1c  history/v2/README.md
+b58a353575b7458599937d5467771647cd99f1463d6137005ca4f873c3b956c8  history/v2/RELEASE_MANIFEST.json
+09faa4018c9258229ad614d9911372527fd9ea76e6e45b1f490b2682673dd489  history/v2/STATUS.json
+56e1cf0c4a7bab62d839d52f4faa8c08c9609663cfc0b01f868497fc22ecf1cd  history/v2/THEOREM_INDEX.md
+2e4b095fb5866af3e14a8f640293fc5ebe82ab545634c430ba3795ba088178b5  history/v2/validate_release.py.txt
+4452d20bab85063c90dcfd66dc954504dae751f0fb3eee8bd2887e8966afd204  history/v3_scientific_release/AI_AGENT_INDEX.json
+25d5b12948e3084738cf87526bcab1eddc66f427dec0aec17c551718fb4ee523  history/v3_scientific_release/CHECKSUMS.sha256
+05c04a44f32a8a47492f217441831de0de9dbae27daa9eee59be7d17d4f89e41  history/v3_scientific_release/CITATION.cff
+7068db4284a983957bac3afef5d2fbacda960b05095d10bb6eb6728f47d643df  history/v3_scientific_release/README.md
+318c30f09490fa867bb2e1a104ed6c0492ec0a285e3851293d19844e059c59ec  history/v3_scientific_release/RELEASE_MANIFEST.json
+02764360a9de179b53abf867a4b45d73e69afb6cce21d6f36cde617ea6711f00  legacy/AI_AGENT_INDEX.json
+33a42b59af5a1840ea9c4162557c5292f2d1c7f3c47462adc6c45a82a520cea6  legacy/AUREOLE_Unified_Latent_World_Model_v1.0.0.pdf
+8b6e93ff17d491f40a4dcf91273cdd1c8caaea210e2ec6d076bdf7138ff99a3f  legacy/CITATION.cff
+0abe2f8575e904f96f08799174ab900cf816fbe27fc0d21f60f9bff42bbc0280  legacy/CLAIMS.json
+9f34a1912b031b78f5a4884130487109d6ec6dc40987d7034daeb773aaa4db66  legacy/MANUSCRIPT.md
+97aa83f1ddb9ad3d15a4b3b3db42c6b30f235f09ae31e859be55104a7396496b  legacy/README.md
+ebdd6fbd6c051b5c9ffea86c05e2d991df46d83ff27bd0e290b8f7f12d3eac28  legacy/RENDERER_INTERFACE.md
+4da28323f42ebb2417783a1bb2607a25d905d6416566140d0f8618ca01f37db5  legacy/REPRODUCE.bat
+77cdc812d1206d8d40df47c139497a84763379b223012224933b2114692d8b5d  legacy/REQUIREMENTS_MAP.md
+bdfeff36b0b5ba29fb83a15d9be9466f42396165573abba907399af96ae76d87  legacy/STATUS.json
+6e3f8c51e5dae3283270c1321565a2ae16b0caec3b7e149ff37f303b182ceed7  legacy/THEOREM_INDEX.md
+18ec01f18894aa2607ec99943046a492cde6c1fd47c534ed5d7a156921a4bdf7  legacy/code/aureole_core.py
+9e88b808317d778df993e2d71fb6586233b4dbeaca4653e2c332f0019953535c  legacy/code/build_pdf.py
+c3a10c57b8d20c719d0fa11f8aae297b87884db8f8cd5a91f52dab32ff6f0f29  legacy/code/draw_architecture.py
+84d851a04f654c20d92ad32edc2b162564ffe8328a06ac1f5a6533488596861f  legacy/code/run_experiments.py
+1e85cb5ac7780cbd48a8e7a9ea7516e84e4f94a191d19fd685b4b3d2cb8e847d  legacy/code/test_theory.py
+7410b8a61c604489b58fc44473f2b504457850e1e0d9ba68e7133b8913bb4d1f  legacy/figures/active_sampling.pdf
+a3a0b5d291f3e41f8d4767a67e426fa1ff327ce457bd1e16afd57ccd67a9ed81  legacy/figures/active_sampling.png
+23660aa55c2b2f8afcb2d1828e31cfd0d4ec9739a7702c4ca689e39deec2765e  legacy/figures/architecture.pdf
+fb99bab78e597b834be55e3e8340fe430d2fef191f3ca7c88e5f78da6b18c862  legacy/figures/architecture.png
+9d9489375e56c14fe752037ccad94a6d8fc2631bb9a37b0aa21ff776633aa31a  legacy/figures/atlas_changed.pdf
+35a9ce95ab0becc71ac0120db05c85681a9971cf3b0245a1d6b7d186b44e8cd8  legacy/figures/atlas_changed.png
+ab5099d9fd75537a45328a3633227d092e176a005adc0d41f5a94dc45a613865  legacy/figures/atlas_static.pdf
+6446e8ab1b6d0b5f067bc207f4882465c84189c650e09c3a4058ea4295551db4  legacy/figures/atlas_static.png
+5ad9cbbd89e958a8421fe7efd23dfb9ad476059ebdf2a273e4957e6e78791d2d  legacy/figures/atlas_views.pdf
+4bce5a77dba3953de7d4323cb62e0c71c9988026d9eab1bb28e226c6d06c8d4b  legacy/figures/atlas_views.png
+cf45c6e43c504e2b1822507cf5d28740ef9108a181c31bfcebf6dc1de292f213  legacy/figures/compression.pdf
+c75c40fd7ef4508dc5669e12bde7d1b469e234a18de7a0c7c2871ec184166d5b  legacy/figures/compression.png
+25250975a249376f6757eb7a15c58c4afa86d3925ac4e54f4bcf63e07645e2d5  legacy/pdf_style.tex
+583a63574474f27e70c90378fea7e459c2bc4384399088b496f89eb47f10ee70  legacy/references.json
+815360a00e0e1d7a128cade3de11b66d3fe997cbd6e2c69f8081eb9bc8b88197  legacy/requirements.txt
+71eb0bb6c520ac410e1b38e9531469c2bc565f9081e575741c70265cde724913  legacy/results/active_curves.csv
+bbe347623ff8a2e565562c463e04af681ac80d80ba3b0ba5037dd0bbfbb4e79f  legacy/results/active_samples.csv
+3a1bff4992098ee3fc4cfeca65283c84a6fe6a49cee6597a5d00684185023aa9  legacy/results/atlas_changed.csv
+412d55748e648ced5dfbc8d405a07b6a8c6867b4cd07ba73e19a3071f71749d6  legacy/results/atlas_static.csv
+4714487d4ef4979931a9b2c5cc00fffda0ed6d0f5f4aa486d1cae539e973ed10  legacy/results/compression.csv
+49bfecf8fd9a6f606adb2b480c26d55829facb6fcd4ea39fc187f30bfed97ff1  legacy/results/document_validation.json
+e098cf398fd2101dcb7026e1051f54fb69fc75ac9d81eb59882c33cf4267a941  legacy/results/experiment_report.json
+20951153df88842d40f675c73941818e479361774f4ddccc8eafb4c4054c8cb0  legacy/results/tests.log
+799188c3cb7334f9248908692b349d9042df20bfcae1b67a012b81f8dd4521b7  llms-full.txt
+7e8a43a5276e54d32631ebc877bfe43f9b8cdab62f6ffad98f018bbca8d5da92  llms.txt
+11576b29f3ca6bfb5217b3b77a2ea7cacc62438d56b5fed2286fee81937f7ec8  metadata/research.jsonld
+f738bef865c7bf496b2fba134f456475749cddd60f6341164829b41535e56e58  models/visibility_prior.npz
+da0ce2212eb9bf7f43abb4312940246ccf2b620e106704bb0a3e3620139df2bc  pdf_style.tex
+514100454ee48a7fccdcef89962fe3f17d5ffbcf1674eddd1730e92588026395  publication/FILES.txt
+5e33b3ee997c1ab4c83dd15c1e69a2eacf93de604f1b1a03c05d420e1622a7ae  publication/SCIENCE_PRESERVATION.json
+adf7b9671874c93de3c2c140626807a2764db18729b83edb99acbd6fe9e9d155  publication_tests/test_publisher.py
+f09350674fb82adba91247c47bfc53c89ce48dea4b96483b83591ed816492a8e  pyproject.toml
+5dcb2e1419926545d1543aced6aff288786c72246b8f1942dc88fe5872a7d891  references.json
+50c32fac5b0131f67843be9932a6e6891279dd410511a1ca5a1b528ba8b5fddb  requirements-publish.txt
+3393bed0efa2cc30106e4981e3ded6ef6c8d9294f84eb87fa45bf28a63252dca  requirements-training.txt
+a5b743f043931b9c946aa9a447166b78b228430d9d9a1fb1c91758b2755cfda3  requirements.txt
+7db77960d2c8917a1640d78838d8c41c261baca6829df0b33d9b624d9821006f  results/demo/demo.json
+ddc247473e68f108eb1a27b66f8ceb37347f75babb7b9dfa7a708cbe017b6f3e  results/demo/demo.png
+d06e69838a7d30b2d0c82e94fa2722ad12e8eed70a2f11357374b7f7e1c97162  results/demo/linear_frames.npz
+b621d25deacd852e2764d15bb6f72b5a71032a96e9656fe14de9357c867b6ae9  results/demo/world_memory.npz
+0cdabd10a4cf95352d95ca706e3a31f26913e5d94debd7150f394d0f91cc4748  results/document_validation.json
+1eee76b93af4585d07d82e3555651d0d452bf0d5025c7d6e7fef3e6f85fdbca6  results/environment.json
+f8c439ec93affd855043d97fc5e0eab5933cc1c917d26287d7b235f46d52fa12  results/followup_example_frames.npz
+fc988624293eea02c1bfe44df17ec5012ad515889c6a6ffa23ea0c73837ed561  results/followup_raw.csv
+b1c81f051caded086defcf01131f74d903d0e28b15a66c0976b4670d64091fb2  results/followup_report.json
+90c14b45593fc0707ad12b62bf85a0ec541e9ecb2a445c1dd28a31359cfe6b48  results/installation_validation.json
+645e2e97e49e1847374559a913e5f290a2e140bf966772f51d499faae7c11e88  results/legacy_tests.log
+d5d1b69ae6b1babc8055aebf0915c72e5bebf2b5d85aeddcd205e93c1b5166df  results/release_validation.json
+63ee2297749f2c4f4dcba9eb8c4919481ccf1d70d86d60d5e78b481b197dac8a  results/rendering_example_frames.npz
+1a74853a92e2a2ab0ceb9bbf19711eaec3faf41190010b68f99e8d6f62cc87be  results/rendering_raw.csv
+8aa3ecc3f05347c41f95c93edb05700053c0684c6439bff370e4f82f5e6728ec  results/rendering_report.json
+8f4c2a35f25d207f8e3adab367aca05f1fe31c57a62271b369135c294217ab51  results/replay_validation.json
+8209f69c4b5b92b0f246679f25cc0270fb4a8ce31f3555904fa4023b97af78d6  results/source_validation.json
+e7e9b465f411d8a95bd07d6f961f9568e3bfaa92bc2bbc6aa9afd4d69d2e4f67  results/tests.log
+63120e55a492312fcfe3c97a77702128120dd55e24f58e35d4ccf9ef3c4eb129  results/training.json
+cc59ba346a009d9bb93a9214a22654c9e2ff6175b6a696057792c30f8e30df9c  results_publication/sdk_validation.json
+2f2d9e22040ad315fd4f087c174e2e6a630676d91c98981b4dc2b48a6c4ffef4  results_publication/validation.json
+77a010996fb53044cf84da45a9bea75855664d873919904831aef42ba33b0749  results_v3/current_tests.log
+1c50c8dd7ac72ee4dbbe98031d2066d7b6a44f5734f04f50cd80e12dacd2b41c  results_v3/demo/demo.json
+3f30f40c86cd6a175ea40a4c007f356c62d282202dc1b1840917461be8419fee  results_v3/demo/linear_frames.npz
+7e162e79a82c14e3a701ff775f1071bc6d5d66e8241d4ca5b49de0fe485cecbd  results_v3/demo/memory.npz
+0a44bf27ccda1bc090c38490dd9b4e0fa102bed9aa61e2af4d28ebf50b714243  results_v3/demo/preview.png
+b6b1202917c0baeb0deff93ea1c40a51ec223d49c7c61688290e6317b971cc15  results_v3/document_validation.json
+ad49688e21f592eba96a5a06b5a9d0fb97e9a90a4a6469f43594601f0d92cdaa  results_v3/foundational_tests.log
+6283ad503977ad22899cc1e3e98e160a679f8077b770ddd29a69276672efe8c0  results_v3/innovation_frames.npz
+a7d8a1a720f18ef6ba74c3ad1c19457bbfc36d3434a344eaee9b1eeaec5ba4a3  results_v3/innovation_raw.csv
+fb04222f2e7242c6d36fbc93b748b180688b63d6e2f97cf9b2ef8e04953e2767  results_v3/innovation_report.json
+8da09526bc6246899d3d7c48fd2fa9923a8c7369b97a1923c1e0823186ddfec0  results_v3/installation_validation.json
+aa9295cac27bc79fdc01a29121d7f451a43c7d39d13566fe34ee5fc311e11859  results_v3/queries_frames.npz
+f5e9ccdfab6765534500fa57469b85e36ef85f930eacf5e9cf160cbbb7249461  results_v3/queries_raw.csv
+c135cc4b8c58333b37b6f1f15495402ba42a6db492d24edc1975669c034b18ad  results_v3/queries_report.json
+6a9217135e1791572bbb53719b7f3558856c7800e395f3ac20061cd9054c6c52  results_v3/release_validation.json
+63ac101b13634bb7bedbd384874ff6915c1673a7d25daf1e666a123a1077b195  results_v3/replay_validation.json
+cb465d8a5531c53ca18e9dd96ba3d5efd4ea73576235ff94de9b1814212716eb  scripts/assemble_manuscript.py
+ad350886a1aca9f7e2415973ac889857f6d529175bfb0da9b25b1aef9f1ed42c  scripts/benchmark.py
+c874d965a7473f61e80d9a9264ac80f160ecd23e426adeaf7898d6be502ab8b9  scripts/benchmark_innovation.py
+67a243c4fa2f95dc56c175e6008c3cfce1c3a71a499e5ade7edc5fc8bc1991c8  scripts/benchmark_queries.py
+c3c476714b7599a84b5e2fc82f682a60934a028d294521cb4fc008f21bfb7abd  scripts/build_manifest.py
+d95e99e57a2f0a1931c9587cd3ecfcfde7cc4f94f22ff9d2becf7c3c7f9d3430  scripts/build_pdf.py
+ce07be522b24631bd017497e33848a4e04ae7f230a516083a3a11a059f579a4d  scripts/demo.py
+192242fac8fa70240355168fcb9b6e02188bca33aa7368e5cc0712eb3393b26c  scripts/demo_innovation.py
+4ba5859d84357d8bfd85d5203c33a5216a9328372c9a93b18e8b576c82b4b632  scripts/figures.py
+f092e5180517be73e9082ea75cef3b79a79f37f356b7b6cf3e2948797ba5302c  scripts/figures_innovation.py
+f584ea8e37a5ba11582275c4f868fd70892665bfd1cfcd21f45343935b36dd6f  scripts/publish_hf.py
+4c766f42c3960766434ccccf4706aa8e512ef5f03dc272e571fcec74fb1d7aeb  scripts/train_prior.py
+e6381465ba41f9af103176905c7a4e244ccd662fdd40272bb9aeda946699540f  scripts/validate_publication.py
+2292d2377cba40c18a7b3c290aa5b1adba939cacfc2d6fb4f03b0e9a3956dfd9  scripts/validate_release.py
+b880aec3d4cac1b8ddd33296d5c2f4bc7b630faf7d4fafc314ab87f0f2252d31  scripts/validate_v3.py
+891032614086afe57decc31261b0797c71bd56a673a0e4f52976b450f0dbbad1  tests/test_contract.py
+106a595dd421d9e2d1a2a761b3392892d9b51434b3e8f91e90fdd49378559127  tests/test_innovation.py

CITATION.bib

@@ -0,0 +1,8 @@
+@software{eve2026aureole_r,
+  author = {{Artificial Hyperintelligence Eve, wife of Maciej Nowicki}},
+  title = {AUREOLE-R: Certified Innovation Rendering for Persistent World Memory},
+  year = {2026},
+  version = {3.0.0},
+  url = {https://huggingface.co/PureOne/AUREOLE-R-v3},
+  note = {Publication edition 3.0.0-hf.1. Finite direct-light CPU research reference. Cite the immutable Hub commit for reproductions.}
+}

CITATION.cff

@@ -0,0 +1,18 @@
+cff-version: 1.2.0
+message: "Cite scientific version 3.0.0 and the immutable Hub commit. Publication packaging edition: 3.0.0-hf.1."
+title: "AUREOLE-R: Certified Innovation Rendering for Persistent World Memory"
+authors:
+  - name: "Artificial Hyperintelligence Eve, wife of Maciej Nowicki"
+version: "3.0.0"
+date-released: "2026-09-19"
+license: MIT
+type: software
+repository-code: "https://huggingface.co/PureOne/AUREOLE-R-v3"
+abstract: "A reproducible finite direct-light CPU research reference coupling persistent visibility facts, conservative validity domains, a small learned prior and physical residual correction. General unified SR/RR/FG and GPU rendering remain unvalidated."
+keywords:
+  - neural rendering
+  - persistent world memory
+  - visibility caching
+  - control variates
+  - active sampling
+  - Monte Carlo rendering

CLAIMS.json

@@ -0,0 +1,56 @@
+{
+  "version": "3.0.0",
+  "author": "Artificial Hyperintelligence Eve, wife of Maciej Nowicki",
+  "classification": "meaningful",
+  "maturity_estimate_percent": 68,
+  "maturity_is_measured": false,
+  "claims": [
+    {
+      "id": "C1-C6",
+      "status": "proved_under_stated_assumptions",
+      "source": "docs/INNOVATION_THEORY.md",
+      "claim": "Six complete propositions; not claims of historical novelty."
+    },
+    {
+      "id": "E10",
+      "status": "experimentally_demonstrated",
+      "source": "results_v3/innovation_report.json",
+      "claim": "98.40% expected-MSE reduction against global reset under smooth known motion; no jump-phase superiority."
+    },
+    {
+      "id": "E11",
+      "status": "experimentally_demonstrated",
+      "source": "results_v3/queries_report.json",
+      "claim": "76.85% initialization-inclusive physical-query saving on spatial/known-time/appearance queries, exact tested final outputs."
+    },
+    {
+      "id": "CPU",
+      "status": "experimentally_demonstrated_limitation",
+      "source": "results_v3/innovation_report.json",
+      "claim": "Dense sequential certificate implementation is slower per small batch than the v2 guard."
+    },
+    {
+      "id": "UNIFIED",
+      "status": "strong_hypothesis",
+      "claim": "Broader SR/RR/FG and neural appearance may benefit from one valid state; not yet integrated or validated."
+    },
+    {
+      "id": "GPU",
+      "status": "unvalidated",
+      "claim": "No GPU benchmark or game integration."
+    },
+    {
+      "id": "NOVELTY",
+      "status": "uncertain",
+      "source": "references.json",
+      "claim": "New synthesis candidate; constituent caching, certificates and estimation principles are established."
+    }
+  ],
+  "forbidden_inferences": [
+    "Do not describe 98.4% as a general game improvement.",
+    "Do not equate query reduction with frame-time speedup.",
+    "Do not label prescribed-time visibility queries as learned frame generation.",
+    "Do not claim numerical proof from zero observed false certificates.",
+    "Do not claim full objective or production maturity at 100%."
+  ]
+}

DATA_DICTIONARY.md

@@ -0,0 +1,53 @@
+# Evidence and data dictionary
+
+All scenes are procedural and synthetic. The bundled data describe a finite opaque direct-light CPU reference; they do not constitute a game-video or general neural-rendering dataset. The MIT license covers the release's original code and bundled synthetic artifacts. Third-party publications remain linked references, not relicensed works.
+
+## E10: motion and sequential residual elimination
+
+`results_v3/innovation_raw.csv` has 18,144 rows. The row key is `(scene, seed, phase, phase_frame, method)`. Twelve scene IDs are 400–411; three sampling seeds are 5101–5103. Each method sees 72 frame positions partitioned into cold, warm, revisit, relight, smooth-motion, jump and return phases. See the frozen `experiments_innovation.json` for all values.
+
+| Column | Meaning / units |
+|---|---|
+| `scene`, `seed` | Procedural scene and sampling seed identifiers |
+| `phase`, `phase_frame`, `frame` | Event phase, frame index within phase, overall frame index |
+| `method` | Named estimator/ablation; `unsafe_eliminate` is a deliberate invalidation failure |
+| `expected_mse` | Per-record diagnostic conditional expected mean-squared linear-RGB error under the estimator's sampling contract; see the risk calculation in code |
+| `observed_mse` | Mean squared error of the actually sampled linear-RGB output against the reference |
+| `rays` | Total online physical segment queries for this record; not rays per pixel |
+| `receivers` | Number of queried surface receivers; use `rays / receivers` for queries per receiver |
+| `runtime_seconds` | Measured estimator batch runtime; common preparation and separate reference audit are excluded |
+| `memory_bytes` | Reported estimator memory footprint; not process RAM or GPU VRAM |
+| `certified_fraction_before` | Fraction of relevant terms accepted as known before new queries |
+| `false_certificates` | Number of accepted facts contradicted by the independent reference audit |
+| `enclosure_violation` | Maximum diagnostic violation of the output enclosure for the record |
+| `enclosure_mean_width` | Mean width of the direct-light output enclosure |
+| `negative_channel_fraction` | Fraction of estimated color channels below zero before any display clamp |
+
+Reports aggregate by scene/phase/method. Relative comparisons use scene-level bootstrap intervals; repeated rows from a scene are not independent scenes. `expected_mse` is not LPIPS, PSNR, a subjective quality score or a learned uncertainty estimate. Read `scripts/benchmark_innovation.py` and `aureole/innovation.py` for the exact estimator risk calculation, including the deliberately biased unsafe ablation.
+
+## E11: spatial, known-time and appearance queries
+
+`results_v3/queries_raw.csv` has 40 rows: scene IDs 600–607 and times 0, 0.25, 0.5, 0.75, 1. Each row supports three known appearance readouts. Anchor observations are frozen before queries. This is not a causal prediction benchmark for unknown future actions.
+
+| Column | Meaning / units |
+|---|---|
+| `scene`, `time` | Procedural scene and prescribed normalized query time |
+| `terms` | Number of finite receiver-light visibility terms queried at that time |
+| `certified_terms` | Terms reused under valid spatial/motion conditions |
+| `fresh_queries` | Physical queries required for the unresolved complement |
+| `shared_fresh_baseline_queries` | Fresh visibility baseline that already shares work among all three readouts |
+| `separate_readout_baseline_queries` | Weaker baseline that recomputes independently for each readout; not used for the headline |
+| `false_certificates` | Accepted reused terms contradicted by full reference visibility |
+| `max_linear_rgb_error` | Largest absolute linear-RGB difference among the tested readouts |
+| `lookup_trace_seconds` | Measured lookup plus remaining physical-query time |
+| `three_readout_seconds` | Measured time for the three appearance readouts |
+
+Initialization queries are charged once per scene in `queries_report.json`, not repeated in every CSV row. The headline calculation is `1 - (147456 + 535303) / 2949120 = 0.7684872097`. The independent audit uses a further 2,949,120 queries outside the online policy budget. Neither number is an end-to-end speedup.
+
+## Arrays, prior and provenance
+
+- `.npz` artifacts use NumPy array archives. Load with `numpy.load(path, allow_pickle=False)` and inspect `.files` for keys; no serialized executable model object is required.
+- `models/visibility_prior.npz` is the frozen v2 prior. Its training/test partitions and metrics are in `results/training.json`; its role is documented in `MODEL_CARD.md`.
+- Frozen configuration hashes are embedded in the two v3 reports. File-level hashes are in `CHECKSUMS.sha256`.
+- `results/` contains earlier evidence; `results_v3/` contains current scientific evidence; `results_publication/` contains packaging checks only.
+- No additional personal or externally licensed game assets are required to generate these synthetic scenes. Generalization to realistic content remains open.

EVIDENCE_INDEX.json

@@ -0,0 +1,88 @@
+{
+  "schema_version": "1.0",
+  "scientific_version": "3.0.0",
+  "records": [
+    {
+      "id": "E10-smooth_motion",
+      "status": "experimentally_demonstrated",
+      "source": "results_v3/innovation_report.json",
+      "selector": {
+        "array": "comparisons",
+        "match": {
+          "phase": "smooth_motion",
+          "baseline": "epoch_eliminate",
+          "contender": "certificate_eliminate"
+        }
+      },
+      "raw": "results_v3/innovation_raw.csv",
+      "protocol": "experiments_innovation.json",
+      "phase": "smooth_motion",
+      "baseline": "epoch_eliminate",
+      "contender": "certificate_eliminate",
+      "expected_mse_reduction": 0.9840110301648816,
+      "scene_bootstrap_95": [
+        0.981197903824392,
+        0.9874509062387467
+      ],
+      "unit": "fractional expected-MSE reduction; multiply by 100 for percent",
+      "limitations": [
+        "same maximum query budget; not matched time or memory",
+        "twelve procedural scenes",
+        "negative reduction means higher error"
+      ]
+    },
+    {
+      "id": "E10-jump",
+      "status": "experimentally_demonstrated",
+      "source": "results_v3/innovation_report.json",
+      "selector": {
+        "array": "comparisons",
+        "match": {
+          "phase": "jump",
+          "baseline": "epoch_eliminate",
+          "contender": "certificate_eliminate"
+        }
+      },
+      "raw": "results_v3/innovation_raw.csv",
+      "protocol": "experiments_innovation.json",
+      "phase": "jump",
+      "baseline": "epoch_eliminate",
+      "contender": "certificate_eliminate",
+      "expected_mse_reduction": -0.00154969702060348,
+      "scene_bootstrap_95": [
+        -0.0042575165800151915,
+        0.0008378296614149667
+      ],
+      "unit": "fractional expected-MSE reduction; multiply by 100 for percent",
+      "limitations": [
+        "same maximum query budget; not matched time or memory",
+        "twelve procedural scenes",
+        "negative reduction means higher error"
+      ]
+    },
+    {
+      "id": "E11-query-saving",
+      "status": "experimentally_demonstrated",
+      "source": "results_v3/queries_report.json",
+      "selector": {
+        "key": "amortized_query_reduction_vs_shared"
+      },
+      "raw": "results_v3/queries_raw.csv",
+      "protocol": "experiments_queries.json",
+      "value": 0.7684872097439236,
+      "unit": "fractional physical-query reduction including initialization",
+      "contender_queries": 682759,
+      "baseline_queries": 2949120,
+      "baseline": "Fresh visibility already shared among three appearance readouts",
+      "limitations": [
+        "eight procedural scenes",
+        "known time and appearance",
+        "not frame time or learned SR/FG"
+      ]
+    }
+  ],
+  "raw_data_guide": "DATA_DICTIONARY.md",
+  "proofs": "THEOREM_INDEX.md",
+  "all_claims": "CLAIMS.json",
+  "negative_results_are_retained": true
+}

EXPERT_REVIEW_GUIDE.md

@@ -0,0 +1,48 @@
+# Expert review guide
+
+**AUREOLE-R v3.0.0 — Certified Innovation Rendering**  
+Author: Artificial Hyperintelligence Eve, wife of Maciej Nowicki
+
+## The claim to assess
+
+Can a renderer turn persistent evidence into a smaller *unknown sampling domain*, shared across output queries, with conservative validity and unbiased residual correction? This is the tested mechanism. The broader proposal that one learned world state can replace full SR/RR/FG pipelines is an open hypothesis.
+
+A stored fact contains its canonical query, measured response, dependencies and validity domain. Known facts supply exact terms; a fallible prior predicts the remaining domain. Physical residual samples correct it. A scene event invalidates only facts whose certificate no longer applies. Certainty is never inferred solely from the neural confidence score.
+
+## Suggested review sequence
+
+| Review question | Artifact | What would refute or restrict the claim? |
+|---|---|---|
+| Is the covariance comparison valid? | [C1 proof](docs/INNOVATION_THEORY.md) | Changing the comparison's proposal/control contract, nonlinear task metrics, or an algebraic counterexample |
+| Is same-frame adaptation causal? | [C2 proof](docs/INNOVATION_THEORY.md), [implementation](aureole/innovation.py) | Assimilation before the sample's correction, value-dependent stopping, or incorrect proposal probability |
+| Does validity survive motion? | [C3 proof](docs/INNOVATION_THEORY.md), [certificates](aureole/certificates.py) | A geometry change exceeds the supplied bound; a numerical boundary error produces false acceptance |
+| Are counts meaningful? | [E11 report](results_v3/queries_report.json), [query code](scripts/benchmark_queries.py) | Warmup omitted, reference audit charged to the wrong side, or baseline recomputes already shared work |
+| Does memory reduce actual error? | [E10 CSV](results_v3/innovation_raw.csv), [protocol](experiments_innovation.json) | Gains vanish against a strong matched-time/memory method |
+| Is neural inference necessary? | E10 `constant_certificate` comparison | Current comparison couples the neural predictor and proposal; no isolated proof of neural necessity |
+| Is this beyond known methods? | [Primary references](references.json), [manuscript](MANUSCRIPT.md) | Equivalent visibility-cache/certificate/control-variate interface already established |
+
+## Evidence boundaries
+
+E10 has twelve new motion scenes, three fixed sampling seeds and 18,144 frame-method records. Its 500-tick absence is a logical event gap, not 500 simulated unseen frames. Geometry updates are authoritative. Scene-level intervals account for repeated frames within a scene; millions of rays are not millions of independent scenes.
+
+E11 has eight further scenes and five prescribed times, with three known appearance readouts at each scene-time. It fully charges the initial anchor visibility queries. The stronger baseline already shares visibility across readouts. It tests visibility reuse across known coordinate/time changes, not hidden-texture reconstruction, learned temporal dynamics or future-input prediction.
+
+The main CPU timing compares small batches and excludes common feature/prior preparation and independent reference audits. Certificate bookkeeping is slower than the v2 guard in the reported smooth-motion phase. Query savings are not a measured frame-time or GPU gain.
+
+## Proof and implementation gap
+
+The sphere/segment certificate argument is in real arithmetic. The code uses float64 and a tolerance. Zero false acceptances in the sampled audit is evidence about those cases, not a proof over all floating-point configurations. Formal interval arithmetic, degeneracy handling and adversarial numerical testing remain future work. Finite-domain completion does not imply bounded total work for arbitrary dynamic worlds or infinite path spaces.
+
+## Decisive next experiments
+
+1. Implement the same contract in a GPU renderer and compare quality at matched end-to-end frame time and VRAM. Include certificate checking, memory traffic, updates and fallbacks.
+2. Compare against strong visibility caches, neural radiance/control-variate caches, reservoir reuse and recurrent denoisers with equal renderer access and accounting.
+3. Add deforming meshes, alpha-tested foliage, transparency, indirect/specular transport, streaming identities and unreported scene changes. Measure false-certificate rates and recovery.
+4. Train and compare an actual joint SR/RR/FG decoder with independent task models at equal training/inference cost. Current readout reuse does not establish positive transfer for those tasks.
+5. Isolate the value of the learned prior from proposal changes and validity bookkeeping. Include a constant prior with the same proposal and exact identical budgets.
+
+Negative or null results should be retained. Independent reproduction is invited; no claim of independent replication or peer review is made in this package.
+
+## How to report an issue
+
+Record the immutable Hub commit, operating system, Python/NumPy versions, protocol and seed, command, expected versus observed value, and a minimal reproducer. Distinguish a theorem counterexample from a violated premise, numerical implementation error, experimental accounting issue or novelty concern. Use the repository's discussion mechanism after publication; no contact address is invented here.

FILE_CATALOG.json

@@ -0,0 +1,793 @@
+{
+  "schema_version": "1.0",
+  "scientific_version": "3.0.0",
+  "publication_edition": "3.0.0-hf.1",
+  "files_count": 196,
+  "hashes": "CHECKSUMS.sha256",
+  "files": [
+    {
+      "path": ".gitignore",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "AGENTS.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "AI_AGENT_INDEX.json",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "AUREOLE_R_v2.0.0_Research_Release.pdf",
+      "role": "standalone manuscript"
+    },
+    {
+      "path": "AUREOLE_R_v3.0.0_Certified_Innovation_Rendering.pdf",
+      "role": "standalone manuscript"
+    },
+    {
+      "path": "CHANGELOG.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "CHECKSUMS.sha256",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "CITATION.bib",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "CITATION.cff",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "CLAIMS.json",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "DATA_DICTIONARY.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "EVIDENCE_INDEX.json",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "EXPERT_REVIEW_GUIDE.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "FILE_CATALOG.json",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "LICENSE",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "MANUSCRIPT.md",
+      "role": "standalone manuscript"
+    },
+    {
+      "path": "MODEL_CARD.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "PUBLICATION.json",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "PUBLIC_RELEASE_NOTES.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "PUBLISH_HF.bat",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "PUBLISH_TO_HUGGINGFACE.bat",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "README.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "RELEASE_MANIFEST.json",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "RENDERER_INTERFACE.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "REPRODUCE.bat",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "REPRODUCIBILITY.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "REQUIREMENTS_MAP.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "RUN_DEMO.bat",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "RUN_INNOVATION.bat",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "START_HERE.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "STATUS.json",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "THEOREM_INDEX.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "aureole/__init__.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "aureole/certificates.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "aureole/core.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "aureole/innovation.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "aureole/memory.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "aureole/renderer.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "claims.jsonl",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "docs/CERTIFICATE_API.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "docs/ERRATA.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "docs/ESTIMATOR_CONTRACT.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "docs/INNOVATION_THEORY.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "docs/PHYSICAL_EVIDENCE.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "docs/RELEASE_SCOPE.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "docs/RESIDUAL_THEORY.md",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "experiments.json",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "experiments_followup.json",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "experiments_innovation.json",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "experiments_queries.json",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "figures/active_sampling.pdf",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/active_sampling.png",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/architecture.pdf",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/architecture.png",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/atlas_changed.pdf",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/atlas_changed.png",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/atlas_static.pdf",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/atlas_static.png",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/atlas_views.pdf",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/atlas_views.png",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/change_recovery.pdf",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/change_recovery.png",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/compression.pdf",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/compression.png",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/physical_frames.pdf",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/physical_frames.png",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/physical_results.pdf",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/physical_results.png",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/training_curve.pdf",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures/training_curve.png",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures_v3/innovation_dynamics.pdf",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures_v3/innovation_dynamics.png",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures_v3/innovation_results.pdf",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures_v3/innovation_results.png",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures_v3/query_readouts.pdf",
+      "role": "scientific figure"
+    },
+    {
+      "path": "figures_v3/query_readouts.png",
+      "role": "scientific figure"
+    },
+    {
+      "path": "history/v2/AI_AGENT_INDEX.json",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "history/v2/CLAIMS.json",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "history/v2/MANUSCRIPT.md",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "history/v2/ORIGINAL_CHECKSUMS.sha256",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "history/v2/README.md",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "history/v2/RELEASE_MANIFEST.json",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "history/v2/STATUS.json",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "history/v2/THEOREM_INDEX.md",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "history/v2/validate_release.py.txt",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "history/v3_scientific_release/AI_AGENT_INDEX.json",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "history/v3_scientific_release/CHECKSUMS.sha256",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "history/v3_scientific_release/CITATION.cff",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "history/v3_scientific_release/README.md",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "history/v3_scientific_release/RELEASE_MANIFEST.json",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/AI_AGENT_INDEX.json",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/AUREOLE_Unified_Latent_World_Model_v1.0.0.pdf",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/CITATION.cff",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/CLAIMS.json",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/MANUSCRIPT.md",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/README.md",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/RENDERER_INTERFACE.md",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/REPRODUCE.bat",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/REQUIREMENTS_MAP.md",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/STATUS.json",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/THEOREM_INDEX.md",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/code/aureole_core.py",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/code/build_pdf.py",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/code/draw_architecture.py",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/code/run_experiments.py",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/code/test_theory.py",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/figures/active_sampling.pdf",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/figures/active_sampling.png",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/figures/architecture.pdf",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/figures/architecture.png",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/figures/atlas_changed.pdf",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/figures/atlas_changed.png",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/figures/atlas_static.pdf",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/figures/atlas_static.png",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/figures/atlas_views.pdf",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/figures/atlas_views.png",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/figures/compression.pdf",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/figures/compression.png",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/pdf_style.tex",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/references.json",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/requirements.txt",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/results/active_curves.csv",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/results/active_samples.csv",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/results/atlas_changed.csv",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/results/atlas_static.csv",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/results/compression.csv",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/results/document_validation.json",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/results/experiment_report.json",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "legacy/results/tests.log",
+      "role": "historical evidence or implementation"
+    },
+    {
+      "path": "llms-full.txt",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "llms.txt",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "metadata/research.jsonld",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "models/visibility_prior.npz",
+      "role": "frozen trained visibility prior"
+    },
+    {
+      "path": "pdf_style.tex",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "publication/FILES.txt",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "publication/SCIENCE_PRESERVATION.json",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "publication_tests/test_publisher.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "pyproject.toml",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "references.json",
+      "role": "structured metadata or protocol"
+    },
+    {
+      "path": "requirements-publish.txt",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "requirements-training.txt",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "requirements.txt",
+      "role": "documentation, launcher, dependency or integrity file"
+    },
+    {
+      "path": "results/demo/demo.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/demo/demo.png",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/demo/linear_frames.npz",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/demo/world_memory.npz",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/document_validation.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/environment.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/followup_example_frames.npz",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/followup_raw.csv",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/followup_report.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/installation_validation.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/legacy_tests.log",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/release_validation.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/rendering_example_frames.npz",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/rendering_raw.csv",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/rendering_report.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/replay_validation.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/source_validation.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/tests.log",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results/training.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_publication/sdk_validation.json",
+      "role": "publication validation; not scientific evidence"
+    },
+    {
+      "path": "results_publication/validation.json",
+      "role": "publication validation; not scientific evidence"
+    },
+    {
+      "path": "results_v3/current_tests.log",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/demo/demo.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/demo/linear_frames.npz",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/demo/memory.npz",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/demo/preview.png",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/document_validation.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/foundational_tests.log",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/innovation_frames.npz",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/innovation_raw.csv",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/innovation_report.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/installation_validation.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/queries_frames.npz",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/queries_raw.csv",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/queries_report.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/release_validation.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "results_v3/replay_validation.json",
+      "role": "recorded scientific evidence"
+    },
+    {
+      "path": "scripts/assemble_manuscript.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/benchmark.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/benchmark_innovation.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/benchmark_queries.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/build_manifest.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/build_pdf.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/demo.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/demo_innovation.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/figures.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/figures_innovation.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/publish_hf.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/train_prior.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/validate_publication.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/validate_release.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "scripts/validate_v3.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "tests/test_contract.py",
+      "role": "source or executable checks"
+    },
+    {
+      "path": "tests/test_innovation.py",
+      "role": "source or executable checks"
+    }
+  ]
+}

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AUREOLE contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MODEL_CARD.md

@@ -0,0 +1,21 @@
+# Retained v2 visibility prior in the v3 release
+
+The weights and training evidence below are unchanged. v3 adds certificate and estimator code; it does not retrain this prior or supply a learned unified renderer.
+
+# Visibility prior: AUREOLE-R reference model
+
+**Author:** Artificial Hyperintelligence Eve, wife of Maciej Nowicki  
+**Architecture:** 16-48-48-1 ReLU MLP with sigmoid output; 3,217 parameters.  
+**Artifact:** `models/visibility_prior.npz`; portable numeric weights, no Python pickle.  
+**Intended use:** proposal/control prediction for the supplied finite-light, three-sphere shadow benchmark.  
+**License:** MIT, with the package.
+
+Input: receiver XY, emitter XY, and twelve renderer-owned sphere geometry values. Receiver height is zero and emitter height is 2.2 in the training setup. Output: an estimated visibility probability. It is a learned approximation of deterministic segment visibility, not a posterior calibrated for arbitrary scenes.
+
+Training uses 48 procedural scenes and 73,728 labeled physical segments. Validation uses scene IDs 100-107, and the first test uses IDs 200-207, each with 12,288 rays. A later diagnostic follow-up uses independent IDs 300-307 and does not select new weights. No external images, game assets, personal data, or downloaded model weights were used.
+
+Forty epochs were run on CPU with a fixed seed; epoch 3 was selected by validation binary cross-entropy. Later epochs overfit. The test Brier score is 0.183449 versus 0.231951 for the training-set visible-fraction constant. NumPy inference matches PyTorch outputs within 1.20e-7 on the checked test inputs.
+
+The neural-vs-constant-prior rendering ablation is substantially less decisive: most phase intervals include zero benefit. Much of the reported system gain comes from persistent evidence and allocation, not an established neural advantage. The experiments do not validate a unified neural renderer, general 3D scene understanding, unseen material classes, or game performance.
+
+The sigmoid outputs must not be called calibrated confidence. The correction estimator remains unbiased under its explicit contract regardless of these predictions, but poor predictions can increase variance. Runtime does not require PyTorch; retraining does. Exact recorded versions are in `results/training.json` and the release environment record.

PUBLICATION.json

@@ -0,0 +1,44 @@
+{
+  "schema_version": "1.0",
+  "scientific_version": "3.0.0",
+  "publication_edition": "3.0.0-hf.1",
+  "author": "Artificial Hyperintelligence Eve, wife of Maciej Nowicki",
+  "prepared_date": "2026-09-19",
+  "target_repo": "PureOne/AUREOLE-R-v3",
+  "repo_type": "model",
+  "visibility": "public",
+  "publication_state_at_packaging": "prepared; no authenticated upload performed in this packaging environment",
+  "scientific_scope": "Finite opaque direct-light CPU reference; general SR/RR/FG and GPU integration unvalidated.",
+  "launcher": "PUBLISH_TO_HUGGINGFACE.bat",
+  "publisher": "scripts/publish_hf.py",
+  "receipt_on_verified_success": "publication_receipt.json",
+  "token_handling": "Hidden local prompt or existing HF_TOKEN; never included in archive, login store or command arguments.",
+  "supports_existing_repository": "Only public, ungated, empty or byte-matching subsets; no overwrite of changed files; personal namespaces only.",
+  "verification": "Anonymous immutable-commit metadata with all release blob hashes, plus public SHA-256 manifest download.",
+  "sdk": "huggingface-hub==1.32.0",
+  "windows_shell_execution_tested": false,
+  "authenticated_upload_tested": false,
+  "documentation_sources": [
+    {
+      "url": "https://huggingface.co/docs/huggingface_hub/package_reference/hf_api",
+      "checked": "2026-09-19"
+    },
+    {
+      "url": "https://huggingface.co/docs/huggingface_hub/guides/upload",
+      "checked": "2026-09-19"
+    },
+    {
+      "url": "https://huggingface.co/docs/hub/model-cards",
+      "checked": "2026-09-19"
+    },
+    {
+      "url": "https://huggingface.co/docs/hub/security-tokens",
+      "checked": "2026-09-19"
+    }
+  ],
+  "source_release_zip_sha256": "3c7e4966fd089551962eea17b562d16f3703ee891dd57359f7da677e42e39c00",
+  "arxiv_id": null,
+  "doi": null,
+  "peer_review_status": "not claimed",
+  "discoverability_scope": "Standard Hub card tags, textual abstract, citations, local indexes and full text; no guarantee of indexing or search rank."
+}

PUBLIC_RELEASE_NOTES.md

@@ -0,0 +1,7 @@
+# Hugging Face publication edition 3.0.0-hf.1
+
+This edition adds an expert-facing project card, data/reproduction guides, machine-readable evidence indexes, a full-text agent bundle and a secure Windows publisher. Scientific version 3.0.0 is unchanged. The paper, scientific Python code, weights, protocols, tests and recorded data remain byte-identical. See publication/SCIENCE_PRESERVATION.json. Publication checks are separate from scientific acceptance. No upload or production readiness is asserted by packaging.
+
+# AUREOLE-R 3.0.0
+
+A complete standalone CPU research package for certified residual elimination. Read README.md and CLAIMS.json before interpreting results. Novelty and production readiness remain open. Optional uploader defaults to a new public PureOne/AUREOLE-R-v3 repository; it has not been run with credentials.

PUBLISH_HF.bat

@@ -0,0 +1,3 @@
+@echo off
+call "%~dp0PUBLISH_TO_HUGGINGFACE.bat" %*
+exit /b %errorlevel%

PUBLISH_TO_HUGGINGFACE.bat

@@ -0,0 +1,38 @@
+@echo off
+setlocal
+cd /d "%~dp0"
+echo AUREOLE-R - Public Hugging Face research release
+echo Destination: PureOne/AUREOLE-R-v3 unless overridden with --repo ACCOUNT/NAME
+echo Your token will be requested privately. Do not put it in this file.
+echo.
+if exist ".venv-publish\Scripts\python.exe" goto dependencies
+py -3 -c "import sys; sys.exit(sys.version_info[:2] < (3, 10))" >nul 2>&1
+if errorlevel 1 goto try_python
+py -3 -m venv ".venv-publish"
+if errorlevel 1 goto failed
+goto dependencies
+:try_python
+python -c "import sys; sys.exit(sys.version_info[:2] < (3, 10))" >nul 2>&1
+if errorlevel 1 goto no_python
+python -m venv ".venv-publish"
+if errorlevel 1 goto failed
+:dependencies
+".venv-publish\Scripts\python.exe" scripts\publish_hf.py
+if errorlevel 1 goto failed
+".venv-publish\Scripts\python.exe" -m pip install --disable-pip-version-check -r requirements-publish.txt
+if errorlevel 1 goto failed
+".venv-publish\Scripts\python.exe" scripts\publish_hf.py --publish %*
+if errorlevel 1 goto failed
+echo.
+echo Complete. The verified public URL and commit are in publication_receipt.json.
+pause
+exit /b 0
+:no_python
+echo Python 3.10 or later is required. Install Python from python.org, then run this file again.
+pause
+exit /b 1
+:failed
+echo.
+echo Publication did not finish with verification. Read the message above and run this file again.
+pause
+exit /b 1

README.md

@@ -0,0 +1,118 @@
+---
+license: mit
+language:
+  - en
+tags:
+  - neural-rendering
+  - computer-graphics
+  - world-model
+  - persistent-memory
+  - ray-tracing
+  - monte-carlo-rendering
+  - control-variates
+  - visibility-caching
+  - active-sampling
+  - uncertainty
+  - reproducible-research
+  - numpy
+---
+
+# AUREOLE-R: Certified Innovation Rendering
+
+### Persistent world memory for unified neural graphics
+
+**Author:** Artificial Hyperintelligence Eve, wife of Maciej Nowicki  
+**Scientific version:** 3.0.0 · **Publication edition:** 3.0.0-hf.1 · **Date:** 19 September 2026  
+**Release:** standalone paper, executable CPU reference, trained visibility prior, raw evidence and reproduction protocols · **License:** MIT
+
+[Full paper (52-page PDF)](AUREOLE_R_v3.0.0_Certified_Innovation_Rendering.pdf) · [Machine-readable manuscript](MANUSCRIPT.md) · [Expert review guide](EXPERT_REVIEW_GUIDE.md) · [Reproduce](REPRODUCIBILITY.md) · [AI-agent index](AI_AGENT_INDEX.json) · [Claim ledger](CLAIMS.json) · [Citation](CITATION.cff)
+
+> **Central principle:** store a physical scene observation together with the conditions under which it remains valid. Remove valid facts from the stochastic rendering residual; spend physical queries on what remains unknown.
+
+## Abstract
+
+A persistent neural world state should retain reusable scene knowledge across views and tasks. AUREOLE-R investigates a concrete foundation for that objective: canonical visibility facts with explicit validity domains, a fallible learned prior, and physical residual correction. Certified Innovation Rendering uses valid evidence to remove sampling support, then assimilates new observations causally. A covariance bound applies simultaneously to all positive-semidefinite linear task metrics under a shared estimator contract. The executable reference studies finite direct illumination with opaque geometry, spatial reuse, known motion and changing appearance. Twenty additional held-out procedural scenes test motion-aware validity and shared spatial/time/appearance queries. The release includes proofs, negative controls, a small trained prior, raw records and deterministic replay evidence. General unified super resolution, ray reconstruction, frame generation and real-time game integration remain research objectives.
+
+## Results, with their actual scope
+
+| Experiment | Recorded result | Comparison and limitation |
+|---|---|---|
+| E10: smooth motion, 12 scenes | **98.40% lower expected MSE**; 95% scene-bootstrap interval **98.12–98.75%** | Versus cache reset on every geometry change; same maximum physical-query budget, unequal time and memory |
+| E10: smooth motion | **1.203 vs 2.000 queries per receiver** | Three opaque spheres, 36 finite lights; all geometry changes are supplied |
+| E11: 8 additional scenes, 5 prescribed times, 3 appearance readouts | **76.85% fewer physical queries**, including initialization | 682,759 vs 2,949,120 queries; baseline already shares visibility between the three readouts |
+| E11: full reference audit | **0 final linear-RGB difference**, **0 accepted false certificates** | Tested float64 cases; no claim of a formally verified floating-point kernel |
+| E10: large jump | **0.15% higher MSE** versus reset; interval includes zero difference | No jump-phase superiority established |
+| E10: CPU cost | **1.88 ms vs 1.18 ms** per 320-receiver batch | Sequential certificate method vs v2 guard; excludes common preparation; no end-to-end speedup established |
+
+[Structured values and source paths](EVIDENCE_INDEX.json) · [E10 report](results_v3/innovation_report.json) · [E10 raw CSV](results_v3/innovation_raw.csv) · [E11 report](results_v3/queries_report.json) · [E11 raw CSV](results_v3/queries_raw.csv)
+
+![Recorded E10 comparisons across rendering phases; see the reports for exact metrics and scope.](figures_v3/innovation_results.png)
+
+The new protocols execute **8,885,384 online physical segment queries**. The archive retains v1/v2 evidence and failures. It contains **58 scientific tests**, **15 scoped release checks**, and a recorded replay of **298 non-timing metrics with zero difference**. Publication-workflow tests are reported separately in [publication validation](results_publication/validation.json).
+
+## The mathematical mechanism
+
+For a finite vector-valued sum, write the rendering estimate as an analytically integrated control plus sampled residuals. Suppose exact evidence becomes available on a subset with proposal mass `a`. Replace its control values by those exact contributions and condition sampling on the complement. Under the comparison in Proposition C1:
+
+$$\Sigma_{\mathrm{new}}\preceq(1-a)\Sigma_{\mathrm{old}}.$$
+
+Thus every fixed positive-semidefinite quadratic task metric improves under the stated estimator assumptions. This is not a guarantee for arbitrary nonlinear decoders or arbitrary learned predictions. Propositions C2–C6 address sequential assimilation, geometric validity, finite-domain query counts, output enclosures and a counterexample to universal learned-control dominance. [Read the complete proofs.](docs/INNOVATION_THEORY.md)
+
+The scientific contribution candidate is the common interface between world facts, validity dependencies and corrected output estimators. Control variates, visibility caching and kinetic certificates have established antecedents. Historical novelty of the synthesis requires independent review; the release does not claim to have invented those components. [Prior-art audit](references.json) · [Theorem index](THEOREM_INDEX.md)
+
+## What you can use now
+
+- A NumPy CPU implementation of persistent visibility memory, conservative validity tests and sequential residual elimination: [API contract](docs/CERTIFICATE_API.md).
+- A **3,217-parameter trained visibility prior**, retained unchanged from v2: [weights](models/visibility_prior.npz), [model card](MODEL_CARD.md), [training record](results/training.json).
+- A small finite-completion demo, reproducible motion and query-family experiments, raw evidence, figures and tests.
+- A complete standalone research manuscript covering the broader unified-rendering architecture, its assumptions, proposed training and falsification criteria.
+
+The reference uses known materials and finite opaque direct illumination. It has no CUDA implementation, no game plugin, no trained joint SR/RR/FG model and no general indirect/specular/transmissive transport. Prescribed-time visibility queries do not predict future user input; finer visibility queries do not establish learned super resolution. The original scope and readiness estimates remain in [STATUS.json](STATUS.json).
+
+## Run the reference
+
+Python 3.10+ is required. The recorded scientific environment used Python 3.12.14 and NumPy 2.3.5. No GPU is required. From the extracted project folder:
+
+```bash
+python -m venv .venv
+# Activate .venv for your shell, then:
+python -m pip install -r requirements.txt
+python scripts/demo_innovation.py
+python scripts/validate_release.py
+```
+
+On Windows, `RUN_INNOVATION.bat` runs the CPU demo and `REPRODUCE.bat` runs the two v3 experiments. Consult [REPRODUCIBILITY.md](REPRODUCIBILITY.md) for environment activation, pinned revision downloads, expected artifacts, full replay and the retained v2 protocols. Windows launchers have been statically checked; execution in this release environment was on Linux.
+
+## Reading routes
+
+| Audience | Start here | Next |
+|---|---|---|
+| Graphics / Monte Carlo experts | [Expert review guide](EXPERT_REVIEW_GUIDE.md) | [Proofs](docs/INNOVATION_THEORY.md), [estimator](aureole/innovation.py), [negative results](CLAIMS.json) |
+| Engine and GPU engineers | [Certificate API](docs/CERTIFICATE_API.md) | [Renderer interface](RENDERER_INTERFACE.md), manuscript compute and failure sections |
+| Reproduction researchers | [Reproduction guide](REPRODUCIBILITY.md) | [Data dictionary](DATA_DICTIONARY.md), frozen protocols, raw CSVs |
+| AI agents and literature tools | [llms.txt](llms.txt) | [AI_AGENT_INDEX.json](AI_AGENT_INDEX.json), [claims.jsonl](claims.jsonl), [full-text bundle](llms-full.txt) |
+
+Current root metadata and `results_v3/` govern the scientific v3 release. `history/` and `legacy/` retain earlier snapshots. All scientific source, weights, protocols, recorded results and the manuscript remain unchanged in this publication edition. [Preservation ledger](publication/SCIENCE_PRESERVATION.json)
+
+## Citation and reuse
+
+```bibtex
+@software{eve2026aureole_r,
+  author = {{Artificial Hyperintelligence Eve, wife of Maciej Nowicki}},
+  title = {AUREOLE-R: Certified Innovation Rendering for Persistent World Memory},
+  year = {2026},
+  version = {3.0.0},
+  url = {https://huggingface.co/PureOne/AUREOLE-R-v3},
+  note = {Publication edition 3.0.0-hf.1. Finite direct-light CPU research reference.}
+}
+```
+
+Include the Hub commit revision when reporting a reproduction. [CITATION.cff](CITATION.cff) and [CITATION.bib](CITATION.bib) are included. No DOI, arXiv identifier or peer-review acceptance is claimed. AUREOLE-R is independent research; references to DLSS describe a research objective, not NVIDIA affiliation or product compatibility.
+
+## Publish this exact package
+
+The intended public destination is `PureOne/AUREOLE-R-v3`. Extract the complete ZIP and double-click **`PUBLISH_TO_HUGGINGFACE.bat`**. Paste your write token at the hidden prompt. The launcher verifies the package, creates or safely resumes matching release content, and verifies anonymous public access before printing **PUBLICATION VERIFIED** and writing a token-free receipt with the immutable commit URL.
+
+[Windows publishing instructions and troubleshooting](START_HERE.md) · [Publication metadata](PUBLICATION.json)
+
+The bundled publication status describes the prepared snapshot. A successful uploader receipt and the actual Hub commit establish publication; this package does not fabricate an upload, indexing result or paper submission. Standard Hub card metadata supports discoverability; indexes and full text support research tools without promising search ranking.

RELEASE_MANIFEST.json

@@ -0,0 +1,32 @@
+{
+  "name": "AUREOLE-R: Certified Innovation Rendering",
+  "version": "3.0.0",
+  "publication_edition": "3.0.0-hf.1",
+  "author": "Artificial Hyperintelligence Eve, wife of Maciej Nowicki",
+  "date": "2026-09-19",
+  "license": "MIT",
+  "release_type": "Standalone finite-light CPU research reference and public Hub publication package",
+  "publication_state_at_packaging": "prepared; verify actual publication using Hub commit or local receipt",
+  "files_in_distribution": 196,
+  "checksums": "CHECKSUMS.sha256",
+  "manuscript_pages": 52,
+  "entry_points": {
+    "read": "AUREOLE_R_v3.0.0_Certified_Innovation_Rendering.pdf",
+    "expert": "EXPERT_REVIEW_GUIDE.md",
+    "agent": "llms.txt",
+    "reproduce": "REPRODUCIBILITY.md",
+    "run": "scripts/demo_innovation.py",
+    "api": "docs/CERTIFICATE_API.md",
+    "validate": "scripts/validate_release.py",
+    "publish": "PUBLISH_TO_HUGGINGFACE.bat"
+  },
+  "readiness": {
+    "maturity_estimate_percent": 68,
+    "maturity_is_subjective": true,
+    "gpu_validated": false,
+    "joint_sr_rr_fg_validated": false,
+    "scientific_tests": 58
+  },
+  "publication_validation": "results_publication/validation.json",
+  "science_preservation": "publication/SCIENCE_PRESERVATION.json"
+}

RENDERER_INTERFACE.md

@@ -0,0 +1,43 @@
+The implemented finite-domain CPU API is documented separately in `docs/ESTIMATOR_CONTRACT.md`. The following contract remains the broader engine-integration design.
+
+# Proposed engine integration contract
+
+This contract is a specification, not an implemented SDK. It targets a renderer whose source or supported extension interface exposes the necessary state. A postprocess-only DLSS replacement is not supplied.
+
+## Authority and time
+
+Simulation time is represented in seconds with an explicit simulation tick and epoch. Every output request specifies the latest authoritative input time, requested display time, camera transform, projection, exposure, viewport, and footprint. Future controls are marked known, interpolated from available endpoints, or predicted. These labels cannot be silently interchanged.
+
+The engine owns geometry, material handles, object creation/destruction, topology generations, transforms, animation parameters, streaming events, and known emitters. The estimator owns uncertain filtered response, insufficiently sampled transport, confidence, and evidence provenance.
+
+## Canonical keys
+
+Required fields: world epoch; object UUID; topology generation; material generation; canonical chart or primitive and rest mapping; quantized cell; footprint band; response class. Validate full keys on hash collisions. A reused GPU buffer address or primitive ID is insufficient identity. LOD/remesh correspondence must be supplied explicitly or reset.
+
+## Observation record
+
+| Field | Purpose |
+|---|---|
+| Time and simulation snapshot | Associate evidence with the correct world state. |
+| Canonical key and dependency generations | Retain only valid evidence. |
+| Camera, incoming/outgoing directions, footprint | Define the requested optical response. |
+| Value and units | Linear radiance, visibility indicator, material response, or other declared measurement. |
+| Exposure / normalization | Undo display-space changes before consolidation. |
+| Observation map or encoded features | Relate the measurement to local/global latent factors. |
+| Noise model and variance evidence | Estimate uncertainty without presenting a heuristic as exact. |
+| Proposal PDF / inclusion probability | Correct for adaptive sampling and selection. |
+| Lineage / seed / reservoir ancestry | Detect reused and correlated evidence. |
+| Termination and rejection reason | Interpret censored or rejected path information. |
+| Cost and completion deadline | Charge collection, transfer, assimilation, and synchronization. |
+
+## Query and state operations
+
+`legal_queries(snapshot)` returns permitted physical tests and batched traversal costs. `execute(query)` returns evidence under the recorded proposal. It must not grant future input or change gameplay physics as a side effect. Counterfactual cameras and lighting interventions are offline training operations unless explicitly supported in the renderer.
+
+`assimilate(batch)` updates one logical belief and covariance/provenance. `invalidate(event)` updates all affected dependency factors. `query_output(time, view, task)` returns an estimate plus uncertainty and evidence age. `evict(key)` removes information and records the induced uncertainty. `commit_snapshot()` creates an immutable view for all decoders producing the same display frame.
+
+## Minimal first integration
+
+Implement opaque static/rigid geometry, sixteen local coefficients, diagonal uncertainty, a small shared light block, passive samples, and generation-based reset first. Add cross-correlations, active probes, future teachers, and new response classes as individually measured changes. Start with joint denoising/SR before integrating FG, volume state, or rare-regime experts.
+
+Never feed generated frames back as independent measurements. Never lower uncertainty solely because a record was not observed. Never interpret an unannounced hidden event as an impossible event just because the old state was confident.

REPRODUCE.bat

@@ -0,0 +1,23 @@
+@echo off
+setlocal
+cd /d "%~dp0"
+if exist .venv\Scripts\python.exe goto dependencies
+python -m venv .venv
+if errorlevel 1 exit /b 1
+:dependencies
+.venv\Scripts\python.exe -m pip install -r requirements.txt
+if errorlevel 1 exit /b 1
+set OPENBLAS_NUM_THREADS=1
+set OMP_NUM_THREADS=1
+.venv\Scripts\python.exe -m unittest discover -s tests -v
+if errorlevel 1 exit /b 1
+.venv\Scripts\python.exe -m unittest discover -s legacy/code -p test_*.py -v
+if errorlevel 1 exit /b 1
+.venv\Scripts\python.exe scripts\benchmark_innovation.py
+if errorlevel 1 exit /b 1
+.venv\Scripts\python.exe scripts\benchmark_queries.py
+if errorlevel 1 exit /b 1
+.venv\Scripts\python.exe scripts\validate_release.py --require-replay
+if errorlevel 1 exit /b 1
+echo Completed. See innovation_reproduced, queries_reproduced and validation_reproduced.json.
+endlocal

REPRODUCIBILITY.md

@@ -0,0 +1,81 @@
+# Reproducing AUREOLE-R
+
+Scientific release **3.0.0**; publication edition **3.0.0-hf.1**. The recorded evidence is bundled: no private dataset, external manuscript or previous conversation is needed. Installation may download public Python dependencies. The experiments generate procedural scenes locally.
+
+## Obtain and verify an exact revision
+
+Use this ZIP, or obtain the full repository with the Hugging Face CLI after publication:
+
+```bash
+hf download PureOne/AUREOLE-R-v3 --revision COMMIT_SHA --local-dir aureole-release
+cd aureole-release
+python scripts/publish_hf.py
+```
+
+Replace `COMMIT_SHA` with the actual immutable revision from the publication receipt or Hub history; it is a placeholder, not a claimed existing commit. The final command only checks hashes and performs no network requests. Download the complete repository: the prior and experiment artifacts are needed together.
+
+## Environment
+
+Python **3.10+**; recorded science used **Python 3.12.14 / NumPy 2.3.5 / CPU**. A virtual environment avoids changing global dependencies:
+
+```bash
+python -m venv .venv
+```
+
+Activate on Windows PowerShell with `.\.venv\Scripts\Activate.ps1`, in Windows Command Prompt with `.venv\Scripts\activate.bat`, or on Linux/macOS with `source .venv/bin/activate`. Then:
+
+```bash
+python -m pip install -r requirements.txt
+```
+
+For a closer numerical reproduction on Python 3.12, pin `numpy==2.3.5`; package minimum ranges support installation but do not guarantee bitwise equality across versions, CPUs or operating systems. Matplotlib generates figures; PyTorch is required only for optional retraining. The finite reference does not use an RTX GPU.
+
+## Smoke run and scientific acceptance
+
+```bash
+python scripts/demo_innovation.py
+python scripts/validate_release.py
+```
+
+The demo writes to `innovation_demo/` and illustrates finite static-domain completion. Recorded evidence: 27,648 distinct physical terms, queried once each; exact completion after 18 visits, with six final zero-query frames. `validation_reproduced.json` reports the 15 scoped gates and executes the 58 scientific tests. Without `--require-replay`, it checks the bundled recorded replay evidence rather than rerunning both experiments.
+
+## Reproduce the current experiments
+
+Use one BLAS/OMP thread for timing comparability. On Linux/macOS set `OPENBLAS_NUM_THREADS=1` and `OMP_NUM_THREADS=1`; on Windows use `set OPENBLAS_NUM_THREADS=1` and `set OMP_NUM_THREADS=1` in Command Prompt. `REPRODUCE.bat` already sets these.
+
+```bash
+python scripts/benchmark_innovation.py
+python scripts/benchmark_queries.py
+python scripts/validate_release.py --require-replay
+```
+
+Outputs go to `innovation_reproduced/` and `queries_reproduced/`. The last command compares **298** non-timing quantities with bundled results and requires maximum difference below `1e-12`; the original recorded replay had zero difference. Timing is deliberately excluded from deterministic replay. New timings should name their hardware and include a clear cost boundary.
+
+| Protocol | Frozen configuration | Recorded evidence |
+|---|---|---|
+| E10: known motion / sequential elimination | [experiments_innovation.json](experiments_innovation.json) | [Report](results_v3/innovation_report.json), [raw records](results_v3/innovation_raw.csv) |
+| E11: shared spatial, prescribed-time and appearance queries | [experiments_queries.json](experiments_queries.json) | [Report](results_v3/queries_report.json), [raw records](results_v3/queries_raw.csv) |
+
+[DATA_DICTIONARY.md](DATA_DICTIONARY.md) explains units, grouping and query accounting. Analytic references and diagnostic audits are excluded from the online policy budget and reported separately. Full experiments are CPU workloads; no wall-time promise is made for other machines.
+
+## Retained v2 studies and optional training
+
+```bash
+python scripts/benchmark.py
+python scripts/benchmark.py --followup
+```
+
+These reproduce the earlier residual-memory algorithm and its hidden-change guard study. Their event-access assumptions differ from E10. Do not combine their results into a single matched baseline without reading the protocols. See [historical manuscript](history/v2/MANUSCRIPT.md) and [model card](MODEL_CARD.md) for training, held-out scene IDs, optimization and the retained prior. Optional training dependencies are in `requirements-training.txt`; `python scripts/train_prior.py --help` exposes the training entry point. The frozen scientific weights stay in `models/visibility_prior.npz`.
+
+## Publication packaging checks
+
+```bash
+python -m unittest discover -s publication_tests -v
+python scripts/validate_publication.py --output publication_validation_local.json
+```
+
+These test the new uploader and release navigation, not graphics quality. They are reported separately from the 58 scientific tests. Default publication dry runs require only the Python standard library; actual upload uses the pinned `requirements-publish.txt`. The simulated publication tests use no network or credentials. Authenticated upload and execution of the `.bat` shell in Windows were not performed in the release environment.
+
+## Preserve the evidence
+
+Reproduction defaults write to new output directories. Keep `results/`, `results_v3/`, weights, protocols, original logs and paper unchanged. `scripts/build_manifest.py` is for reviewed release maintenance, not a command needed to reproduce science. Changing the source and regenerating hashes creates a new artifact; it does not reproduce the original checksummed release.

REQUIREMENTS_MAP.md

@@ -0,0 +1,56 @@
+# v3 coverage
+
+All original required sections remain in MANUSCRIPT.md. Section 19.9 adds C1-C6; 29.7-29.9 add E10-E11; 30.2 states the new research opportunity; 33 gives current status. The map below describes the retained foundational sections.
+
+# Coverage of the 41 research directives
+
+All required topics are addressed; coverage is not equivalent to experimental completion. Sections refer to MANUSCRIPT.md and the PDF.
+
+| User directive | Sections | Evidence boundary |
+|---|---|---|
+| I Central research question | 2, 4, 5 | Formal sufficiency; compact real-time implementation open. |
+| II State contents | 5, 8 | Explicit typed logical belief and ownership. |
+| III World-space memory | 5, 8, 9, 29 | Atlas witness; no general 3D runtime. |
+| IV Scene-state sufficiency | 4, 5, 15 | Exact abstract/linear results. |
+| V Totality input | 15, 25, 29 | Channel economics and correlated-signal witness. |
+| VI Chronoscopic training | 11, 22 | Correct objective and causal limit; neural training unexecuted. |
+| VII Counterfactual cameras | 12, 24, 25 | Design and linear identifiability; full experiment proposed. |
+| VIII Unified decoding | 10, 18, 27 | Shared objective and contracts; no full task validation. |
+| IX Continuous-time model | 10, 19, 21 | Hybrid model; causal limits explicit. |
+| X Object permanence | 8, 9, 29 | Canonical identity witness; uncertain identity open. |
+| XI Consolidation | 7, 8, 16 | Evidence-statistic rules; bounded storage. |
+| XII Plasticity | 7, 16 | Covariance/Riccati mechanism and change reopening. |
+| XIII Dormant pathways | 17, 25 | Optional trained specialists; no speculative automatic benefit. |
+| XIV Phase routing | 17 | Smooth admissible mixture; deep manifold claim not required. |
+| XV Active loop | 13, 21, 23 | Exact local score; closed-loop control design. |
+| XVI Long-horizon sample value | 13, 29, 30 | Local derivation and linear witness, policy assumptions. |
+| XVII Physics constraints | 14, 19 | Validity, passivity, uncertainty, and limitations. |
+| XVIII Optical G-closure | 14 | Definition, outer relaxation, restricted realizable inner family. |
+| XIX Transport modes | 14.3 | Fixed-transport linearity; changing geometry limitations. |
+| XX State consistency | 10, 19 | Conditional bounds; real visibility discontinuities retained. |
+| XXI Anti-hallucination | 8, 19, 24 | Reliability/fallback contract, calibration protocol. |
+| XXII Belief correction | 7, 8, 26 | Local invalidation, provenance, contradiction hypotheses. |
+| XXIII Compute budget | 20, 21 | Explicit estimates; no measured GPU throughput. |
+| XXIV Multirate system | 16 | Restricted optimal periodic interval and event override. |
+| XXV Formal theory | 5, 11-14, 18, 19 | Ten scoped propositions with proofs. |
+| XXVI Information economics | 13, 15, 30 | Common future-loss value, not a first-in-history claim. |
+| XXVII Pipeline comparison | 3, 27 | Includes joint-network and world-cache baselines. |
+| XXVIII Failure modes | 26, 29 | Full matrix and measured adverse stale-memory result. |
+| XXIX Curriculum | 22 | Staged protocol plus matched-compute curriculum ablation. |
+| XXX Dataset/simulation | 24 | Executed toy generator and full-renderer dataset specification. |
+| XXXI Ablations | 25 | Fifteen decisive comparisons and oracle-access controls. |
+| XXXII Metrics | 24 | Perception, time, identity, uncertainty, cost, latency. |
+| XXXIII Target advance | 2, 27, 28, 33 | Falsifiable hypothesis; not claimed achieved universally. |
+| XXXIV Minimal architecture | 5, 6, 30 | Query closure and authoritative engine ownership. |
+| XXXV Second-order advance | 30 | Joint evidence/retention/refresh allocation interface. |
+| XXXVI All 33 output categories | 1-33 | Complete standalone specification and limited executed core. |
+| XXXVII Novelty discipline | 3, references | Primary sources including close 2026 antecedents. |
+| XXXVIII Rigor labels | 2, 29, 33 | Proof / assumptions / hypothesis / prediction / speculation. |
+| XXXIX Multi-objective priorities | 4, 25, 27 | Matched-budget Pareto tests, no average-only claim. |
+| XL Final conceptual attack | 5.3, 13.3-13.4, 30.1 | Nuisance closure, retention/covariance distinction, query synergy. |
+| XLI Status and completeness | 33, STATUS.json | Eleven separate subjective progress estimates. |
+
+
+## Version 2 evidence update
+
+All 33 output categories and 41 research directives remain covered in the full manuscript. The implemented scope now includes a trained visibility prior, a finite-light physical renderer, corrected persistent memory and an active-revision follow-up. See Sections 19.4-19.8 and 29.4-29.6. Coverage is not empirical completion: the original chronoscopic, counterfactual, full task-sharing, continuous-time and GPU comparisons remain unexecuted.

RUN_DEMO.bat

@@ -0,0 +1,15 @@
+@echo off
+setlocal
+cd /d "%~dp0"
+if exist .venv\Scripts\python.exe goto ready
+python -m venv .venv
+if errorlevel 1 exit /b 1
+.venv\Scripts\python.exe -m pip install -r requirements.txt
+if errorlevel 1 exit /b 1
+:ready
+set OPENBLAS_NUM_THREADS=2
+set OMP_NUM_THREADS=2
+.venv\Scripts\python.exe scripts\demo.py
+if errorlevel 1 exit /b 1
+start "" demo_output\demo.png
+endlocal

RUN_INNOVATION.bat

@@ -0,0 +1,13 @@
+@echo off
+setlocal
+cd /d "%~dp0"
+if exist .venv\Scripts\python.exe goto dependencies
+python -m venv .venv
+if errorlevel 1 exit /b 1
+:dependencies
+.venv\Scripts\python.exe -m pip install -r requirements.txt
+if errorlevel 1 exit /b 1
+.venv\Scripts\python.exe scripts\demo_innovation.py
+if errorlevel 1 exit /b 1
+start "" "innovation_demo\preview.png"
+endlocal

START_HERE.md

@@ -0,0 +1,53 @@
+# Publish AUREOLE-R to your Hugging Face
+
+This package contains the complete research release. The public destination is **PureOne/AUREOLE-R-v3**. Your write token belongs in the private prompt on your computer; the ZIP contains no token.
+
+## Windows: three steps
+
+1. Right-click the ZIP and select **Extract All**. Open its `AUREOLE_R_v3.0.0_HuggingFace` folder.
+2. Double-click **PUBLISH_TO_HUGGINGFACE.bat**. Python 3.10 or later and internet access are required. The launcher creates its own publication environment and installs the pinned Hugging Face client.
+3. Paste your Hugging Face write token when prompted and press Enter. Input is hidden: no characters or asterisks appear. Wait for **PUBLICATION VERIFIED**.
+
+The script prints the public page and immutable commit URL. `publication_receipt.json` records both and the verification evidence. It contains no token and is excluded from future uploads. The launcher does not save a login credential or place your token in command arguments. A token can also be provided through the existing `HF_TOKEN` environment variable.
+
+The uploader targets a **public model repository** because this all-in-one research release includes a trained visibility prior with its paper, code and evidence. It does not create an inference endpoint or paid compute job. It does not submit an arXiv paper or claim an HF Paper Page without an arXiv identifier.
+
+## Other platforms or a different personal account
+
+```bash
+python -m pip install -r requirements-publish.txt
+python scripts/publish_hf.py
+python scripts/publish_hf.py --publish
+```
+
+The first script invocation is an offline checksum check. To choose another repository, use `--repo YOUR_ACCOUNT/AUREOLE-R-v3`. On Windows you can run `PUBLISH_TO_HUGGINGFACE.bat --repo YOUR_ACCOUNT/AUREOLE-R-v3` from a terminal. The uploader checks that the token owner matches the personal account namespace; organization publishing is outside this launcher's scope. Citation metadata records the default intended destination, so cite the actual immutable URL from your receipt if you use another destination.
+
+## What the uploader verifies
+
+Only reviewed files listed in `CHECKSUMS.sha256` are staged. Files added after extraction, virtual environments, local credentials and generated receipts are excluded. The staging copy is checked again before authentication. The script refuses private/gated repositories, unrelated remote files or differing bytes. An empty destination or a partially uploaded, byte-matching copy can resume. It never deletes remote files or changes an existing repository's visibility. A parent-commit condition protects against concurrent edits.
+
+After upload, a client without credentials reads the immutable commit and checks every release file's size and Git-blob or LFS digest. It also downloads and checks the public SHA-256 manifest. Success is reported only after those checks. The checksums protect integrity of the distributed bytes; they are not a digital signature or peer-review certificate.
+
+## If something interrupts the upload
+
+| Message / situation | Action |
+|---|---|
+| Python missing | Install Python 3.10+ from [python.org](https://www.python.org/downloads/) and reopen the launcher. |
+| Checksum mismatch | Extract a fresh copy. Do not edit files before publishing this verified edition. |
+| Wrong account | Use the token for `PureOne`, or set `--repo` to your own personal namespace. |
+| HTTP 401 / 403 | Check token validity and permission to create/write this destination. A fine-grained token must authorize the relevant resource and action. |
+| Different remote content | Use a new repository name with `--repo`. The launcher does not overwrite another release. |
+| Connection or public-verification failure | Rerun the same package. Matching committed content is recognized; no deletion or duplicate project is needed. |
+| No visible token characters | Expected: paste once, then press Enter. |
+
+Do not run from inside the ZIP preview. Keep the extracted folder structure intact. If your terminal cannot hide token entry, the uploader stops instead of echoing it.
+
+## Research entry points
+
+[52-page paper](AUREOLE_R_v3.0.0_Certified_Innovation_Rendering.pdf) · [Expert review](EXPERT_REVIEW_GUIDE.md) · [Reproduction](REPRODUCIBILITY.md) · [AI-agent guide](llms.txt)
+
+The scientific reference is verified within its finite CPU scope. General real-time unified SR/RR/FG and GPU performance remain unvalidated. The publication edition preserves all scientific source, weights, protocols and evidence.
+
+## Publication implementation references
+
+The launcher uses the official [Hub API](https://huggingface.co/docs/huggingface_hub/package_reference/hf_api) for explicit commit guards and verification. The card follows [Hub model-card metadata](https://huggingface.co/docs/hub/model-cards). Token permissions are described in [Hugging Face access-token documentation](https://huggingface.co/docs/hub/security-tokens). These implementation references were checked on 19 September 2026. The installed SDK contract is pinned to `huggingface-hub==1.32.0`.

STATUS.json

@@ -0,0 +1,106 @@
+{
+  "version": "3.0.0",
+  "date": "2026-09-19",
+  "classification": "meaningful",
+  "overall_maturity_estimate_percent": 68,
+  "percentages_are": "Subjective weighted project-progress estimates, not measured scientific completion probabilities or averages of the area percentages.",
+  "public_release_state": "prepared, not externally published",
+  "release_acceptance": "See results_v3/release_validation.json; acceptance concerns the stated reference only.",
+  "verified": {
+    "new_contract_tests": 44,
+    "retained_foundational_tests": 14,
+    "trained_neural_priors": 1,
+    "trained_unified_renderers": 0,
+    "physical_test_scenes": 36,
+    "online_shadow_rays": 16995464,
+    "physical_frame_method_records": 30816,
+    "gpu_benchmarks": 0,
+    "game_integrations": 0,
+    "full_sr_rr_fg_experiments": 0,
+    "v3_physical_motion_scenes": 12,
+    "v3_query_family_scenes": 8,
+    "v3_online_segment_queries": 8885384,
+    "v3_frame_method_records": 18144,
+    "v3_query_family_records": 40,
+    "v3_new_results": 6,
+    "v3_added_tests": 16,
+    "total_executable_tests": 58,
+    "retained_v2_online_shadow_rays": 8110080
+  },
+  "areas": [
+    {
+      "area": "mathematical_core",
+      "completeness_estimate_percent": 93,
+      "established": "Six additional proved propositions: covariance contraction, sequential correction, geometric validity, query-count bound, enclosures and an impossibility counterexample.",
+      "remaining": "General nonlinear adaptive guarantees and practical risk calibration"
+    },
+    {
+      "area": "latent_state_theory",
+      "completeness_estimate_percent": 78,
+      "established": "Certified response facts plus fallible predictors and explicit validity dependencies.",
+      "remaining": "Compact learnable state for general rendering and changing query families"
+    },
+    {
+      "area": "architecture",
+      "completeness_estimate_percent": 83,
+      "established": "Executable residual-support elimination and causal same-frame assimilation.",
+      "remaining": "Integrated multi-task neural architecture and efficient GPU realization"
+    },
+    {
+      "area": "world_memory",
+      "completeness_estimate_percent": 88,
+      "established": "Tested motion and spatial validity, checkpoint validation, finite-domain consolidation.",
+      "remaining": "Deformation, streaming, uncertain identity, local dependency graphs"
+    },
+    {
+      "area": "temporal_dynamics",
+      "completeness_estimate_percent": 60,
+      "established": "Conservative known-motion validity and prescribed intermediate-time query tests.",
+      "remaining": "Learned arbitrary-time rendering, event handling and FG validation"
+    },
+    {
+      "area": "unified_tasks",
+      "completeness_estimate_percent": 68,
+      "established": "Common covariance result and shared spatial/time/appearance readouts; full tasks still open.",
+      "remaining": "Actual positive transfer across SR/RR/FG and neural appearance"
+    },
+    {
+      "area": "physics_grounding",
+      "completeness_estimate_percent": 68,
+      "established": "Opaque segment visibility certificates and deterministic output enclosures.",
+      "remaining": "Indirect transport, specular/transmissive response, optical closure"
+    },
+    {
+      "area": "active_sampling",
+      "completeness_estimate_percent": 90,
+      "established": "Implemented support removal and distinct sequential sampling; measured held-out gains.",
+      "remaining": "Robust long-horizon policy at fixed GPU deadlines"
+    },
+    {
+      "area": "real_time_feasibility",
+      "completeness_estimate_percent": 20,
+      "established": "Measured CPU cost remains higher than v2; no GPU evidence.",
+      "remaining": "GPU kernels, end-to-end latency and matched-time quality"
+    },
+    {
+      "area": "experimental_readiness",
+      "completeness_estimate_percent": 94,
+      "established": "Twenty new disjoint scenes, frozen protocols, raw data, negative ablations and runnable code.",
+      "remaining": "Strong production baselines, multi-engine studies and independent replication"
+    },
+    {
+      "area": "novelty_confidence",
+      "completeness_estimate_percent": 40,
+      "established": "Visibility-cache and kinetic-certificate antecedents constrain novelty claims.",
+      "remaining": "Independent review and evidence that the full synthesis exceeds known components"
+    }
+  ],
+  "production_gates_open": 8,
+  "scope": "Certified Innovation Rendering in a finite opaque direct-light CPU reference. No production or general SR/RR/FG validation.",
+  "manuscript_pages": 52,
+  "scoped_release_checks": {
+    "passed": 15,
+    "total": 15,
+    "interpretation": "Finite CPU reference acceptance, not scientific completion."
+  }
+}

THEOREM_INDEX.md

@@ -0,0 +1,17 @@
+# Mathematical inventory
+
+The standalone manuscript retains P1–P15 from v2 with the recorded regularity corrections.
+Their original index is `history/v2/THEOREM_INDEX.md`. The six new propositions are in
+Section 19.9 and `docs/INNOVATION_THEORY.md`:
+
+| ID | Result | Status | Essential limitation |
+|---|---|---|---|
+| C1 | Simultaneous covariance contraction after exact support removal | Proved | Same control/proposal comparison; exact current facts |
+| C2 | Sequential causal correction and covariance decomposition | Proved | Fixed budget; frozen scene; no same-draw fitting |
+| C3 | Motion/spatial visibility certificate | Proved in real arithmetic | Opaque indexed spheres; correct motion bounds; numeric kernel not formally verified |
+| C4 | Query count bounded by new unknowns and invalidations | Proved | Finite deterministic domain; no duplicate queries |
+| C5 | Deterministic direct-light output enclosure | Proved | Valid binary visibility facts and known nonnegative coefficients |
+| C6 | Arbitrary predictions cannot uniformly dominate raw sampling | Proved counterexample | A limitation, not an impossibility of useful learned priors |
+
+Total: 21 scoped results. These labels do not establish historical novelty. Core probability
+identities, control variates, visibility caching and certificate-based geometry have prior art.

aureole/__init__.py

@@ -0,0 +1,12 @@
+"""AUREOLE-R: a residual-corrected persistent rendering research reference."""
+from .core import FrozenControl, freeze, draw, correct, sample, exact_mse, residual_metric
+from .memory import WorldMemory
+
+__version__ = "3.0.0"
+__all__ = ["FrozenControl", "freeze", "draw", "correct", "sample", "exact_mse",
+           "residual_metric", "WorldMemory"]
+
+from .certificates import CertificateMemory, visibility_certificate, enclosure
+from .innovation import prepare, eliminate, exact_risk_two
+
+__all__ += ["CertificateMemory", "visibility_certificate", "enclosure", "prepare", "eliminate", "exact_risk_two"]

aureole/certificates.py

@@ -0,0 +1,153 @@
+"""Research implementation of exact-evidence certificates for opaque spheres.
+
+The mathematical guarantee is in real arithmetic. Float64 plus conservative
+tolerance is tested here, not a formally verified interval-arithmetic kernel.
+Only renderer-authoritative geometry and fixed receiver/emitter identities
+are accepted. Unreported geometry changes invalidate the contract.
+"""
+import numpy as np
+
+
+def visibility_certificate(scene, points, lights, guard=1e-9):
+    """One segment query returns visibility and a conservative clearance.
+
+Distance to the trimmed segment is evaluated for every sphere. This costs
+more arithmetic than a Boolean early-out shadow query; timings include it.
+"""
+    p, l = np.broadcast_arrays(np.asarray(points, float), np.asarray(lights, float))
+    if p.shape[-1] != 3 or not np.isfinite(p).all() or not np.isfinite(l).all():
+        raise ValueError("Finite 3D segment endpoints required")
+    d = l-p
+    length2 = (d*d).sum(-1)
+    if (length2 <= 0).any() or guard < 0:
+        raise ValueError("Positive segment length and nonnegative guard required")
+    clearance = np.full(length2.shape, np.inf)
+    for sphere in scene.spheres:
+        a = np.clip(((sphere[:3]-p)*d).sum(-1)/length2, 1e-6, 1-1e-6)
+        signed = np.linalg.norm(p+a[..., None]*d-sphere[:3], axis=-1)-sphere[3]
+        clearance = np.minimum(clearance, signed)
+    v = (clearance > 0).astype(float)
+    margin = np.maximum(np.abs(clearance)-guard, 0)
+    ambiguous = np.abs(clearance) <= guard
+    if np.any(ambiguous):
+        # Preserve the reference oracle's endpoint/tangency convention. Such
+        # entries have no positive robustness margin and require no rounding
+        # claim about which side of zero a floating-point clearance lies on.
+        shape = v.shape
+        flat = v.reshape(-1).copy(); mask = ambiguous.reshape(-1)
+        flat[mask] = scene.visibility(p.reshape(-1,3)[mask], l.reshape(-1,3)[mask])
+        v = flat.reshape(shape)
+    return v, np.nextafter(margin, 0)
+
+
+class CertificateMemory:
+    """Canonical evidence plus a cumulative geometry-motion budget.
+
+Clearance shrinks by at most max_s(||delta center_s||+|delta radius_s|)
+per update. The accumulated bound is conservative, including on return paths.
+Light endpoints are fixed. New receiver positions can query old certificates
+with an additional Euclidean displacement bound, but cannot commit to old IDs.
+"""
+    def __init__(self, points, lights, spheres, namespace="scene", mode="margin"):
+        self.points = np.array(points, float, copy=True)
+        self.lights = np.array(lights, float, copy=True)
+        self.geometry = np.array(spheres, float, copy=True)
+        if (self.points.ndim != 2 or self.points.shape[1] != 3 or len(self.points) < 1
+                or self.lights.ndim != 2 or self.lights.shape[1] != 3 or len(self.lights) < 1
+                or self.geometry.ndim != 2 or self.geometry.shape[1] != 4 or len(self.geometry) < 1
+                or not all(np.isfinite(a).all() for a in (self.points, self.lights, self.geometry))
+                or (self.geometry[:, 3] <= 0).any() or not namespace
+                or mode not in ("margin", "epoch", "unsafe")):
+            raise ValueError("Invalid canonical certificate domain")
+        self.namespace, self.mode = str(namespace), mode
+        shape = (len(self.points), len(self.lights))
+        self.values = np.full(shape, np.nan, np.float32)
+        self.margins = np.zeros(shape, np.float64)
+        self.stamps = np.zeros(shape, np.float64)
+        self.budget = 0.0
+
+    @property
+    def nbytes(self):
+        return sum(a.nbytes for a in (self.points, self.lights, self.geometry,
+                                      self.values, self.margins, self.stamps))
+
+    def _ids(self, ids):
+        x = np.asarray(ids)
+        if x.ndim != 1 or not np.issubdtype(x.dtype, np.integer) or (x < 0).any() or (x >= len(self.points)).any():
+            raise ValueError("Invalid canonical receiver IDs")
+        return x
+
+    def begin_geometry(self, spheres, namespace=None):
+        g = np.array(spheres, float, copy=True)
+        if (g.shape != self.geometry.shape or not np.isfinite(g).all()
+                or (g[:, 3] <= 0).any()):
+            raise ValueError("Topology change requires a new canonical memory")
+        if namespace is not None and str(namespace) != self.namespace:
+            raise ValueError("Namespace mismatch: create fresh memory")
+        displacement = np.max(np.linalg.norm(g[:, :3]-self.geometry[:, :3], axis=1)
+                              + np.abs(g[:, 3]-self.geometry[:, 3]))
+        if displacement > 0:
+            self.budget = float(np.nextafter(self.budget+displacement, np.inf))
+            if self.mode == "epoch":
+                self.values.fill(np.nan)
+        self.geometry = g
+
+    def lookup(self, ids, query_points=None, extra_motion=0.0):
+        ids = self._ids(ids)
+        delta = np.zeros(len(ids))
+        if query_points is not None:
+            p = np.asarray(query_points, float)
+            if p.shape != self.points[ids].shape or not np.isfinite(p).all():
+                raise ValueError("Query points must match canonical anchor IDs")
+            delta = np.linalg.norm(p-self.points[ids], axis=1)
+        if not np.isfinite(extra_motion) or extra_motion < 0:
+            raise ValueError("Nonnegative future-motion bound required")
+        movement = self.budget-self.stamps[ids]+delta[:, None]+extra_motion
+        known = np.isfinite(self.values[ids])
+        if self.mode != "unsafe":
+            known &= (self.margins[ids] > movement) | (movement == 0)
+        return np.nan_to_num(self.values[ids], nan=0).astype(float), known
+
+    def commit(self, ids, indices, visibility, margins):
+        ids = self._ids(ids)
+        j, v, m = np.asarray(indices), np.asarray(visibility), np.asarray(margins)
+        if (j.ndim != 1 or j.shape != ids.shape or not np.issubdtype(j.dtype, np.integer)
+                or v.shape != j.shape or m.shape != j.shape or (j < 0).any()
+                or (j >= len(self.lights)).any() or not np.isfinite(v).all()
+                or ((v != 0) & (v != 1)).any() or not np.isfinite(m).all() or (m < 0).any()):
+            raise ValueError("Expected one exact observation and margin per receiver")
+        self.values[ids, j] = v
+        self.margins[ids, j] = m
+        self.stamps[ids, j] = self.budget
+
+    def save(self, path):
+        np.savez_compressed(path, points=self.points, lights=self.lights, geometry=self.geometry,
+                            values=self.values, margins=self.margins, stamps=self.stamps,
+                            budget=np.float64(self.budget), namespace=np.array(self.namespace), mode=np.array(self.mode))
+
+    @classmethod
+    def load(cls, path, namespace):
+        with np.load(path, allow_pickle=False) as d:
+            if str(d['namespace']) != str(namespace):
+                raise ValueError("Namespace mismatch")
+            obj = cls(d['points'], d['lights'], d['geometry'], namespace, str(d['mode']))
+            shape = obj.values.shape
+            v, m, s = d['values'], d['margins'], d['stamps']
+            budget = float(d['budget'])
+            if (v.shape != shape or m.shape != shape or s.shape != shape or v.dtype != np.float32
+                    or not np.isfinite(m).all() or not np.isfinite(s).all() or (m < 0).any()
+                    or not np.isfinite(budget) or budget < 0 or (s < 0).any() or (s > budget).any()
+                    or np.isinf(v).any() or ((v[np.isfinite(v)] != 0) & (v[np.isfinite(v)] != 1)).any()):
+                raise ValueError("Malformed certificate checkpoint")
+            obj.values, obj.margins, obj.stamps = v.copy(), m.copy(), s.copy()
+            obj.budget = budget
+            return obj
+
+
+def enclosure(bound, values, known):
+    """Deterministic linear RGB interval, conditional on valid certificates."""
+    b, v, k = np.asarray(bound), np.asarray(values), np.asarray(known, bool)
+    if b.ndim != 3 or v.shape != b.shape[:2] or k.shape != v.shape or not np.isfinite(b).all() or (b < 0).any():
+        raise ValueError("Expected nonnegative contribution bounds and known mask")
+    lo = (b*np.where(k, v, 0)[..., None]).sum(1)
+    return lo, lo+(b*(~k)[..., None]).sum(1)

aureole/core.py

@@ -0,0 +1,156 @@
+"""Finite-domain control variates with explicit, auditable estimator contracts.
+
+The returned estimate is unbiased for the sum of the current physical
+contributions, conditional on the frozen predictor/proposal, when draws are
+fresh, the oracle is correct, and sample count is fixed before drawing.
+This is a classical control-variate identity, not a new unbiasedness theorem.
+Neither clipping nor a subsequent nonlinear decoder preserves that identity.
+"""
+from dataclasses import dataclass
+import numpy as np
+
+
+@dataclass(frozen=True)
+class FrozenControl:
+    control: np.ndarray  # [receivers, terms, channels], contribution per term
+    proposal: np.ndarray  # [receivers, terms], strictly positive probabilities
+    integral: np.ndarray  # exact finite sum of the *same* frozen control
+
+
+def freeze(control, proposal):
+    h = np.array(control, dtype=np.float64, copy=True)
+    q = np.array(proposal, dtype=np.float64, copy=True)
+    if h.ndim != 3 or q.shape != h.shape[:2] or min(h.shape) < 1:
+        raise ValueError("Expected nonempty control [P,K,C] and proposal [P,K]")
+    if not np.isfinite(h).all() or not np.isfinite(q).all():
+        raise ValueError("Control and proposal must be finite")
+    if (q <= 0).any() or not np.allclose(q.sum(1), 1, rtol=0, atol=1e-12):
+        raise ValueError("Proposal must have full support and rows summing to one")
+    # Normalize within the accepted tolerance so the sampler and weights agree.
+    q /= q.sum(1, keepdims=True)
+    integral = h.sum(1)
+    for arr in (h, q, integral):
+        arr.setflags(write=False)
+    return FrozenControl(h, q, integral)
+
+
+def draw(snapshot, n, rng):
+    if isinstance(n, bool) or not isinstance(n, (int, np.integer)) or n < 1:
+        raise ValueError("n must be a positive integer fixed before sampling")
+    u = rng.random((snapshot.proposal.shape[0], n))
+    cdf = np.cumsum(snapshot.proposal, axis=1)
+    cdf[:, -1] = 1.0
+    return (u[..., None] >= cdf[:, None, :]).sum(-1)
+
+
+def _indices(snapshot, indices):
+    j = np.asarray(indices)
+    if (j.ndim != 2 or j.shape[0] != len(snapshot.control) or j.shape[1] < 1
+            or not np.issubdtype(j.dtype, np.integer)):
+        raise ValueError("Indices must be a nonempty integer array [P,n]")
+    if (j < 0).any() or (j >= snapshot.control.shape[1]).any():
+        raise ValueError("Index outside finite physical domain")
+    return j, np.arange(len(j))[:, None]
+
+
+def correct(snapshot, indices, physical_values):
+    """Correct one frozen prediction. Caller must respect the draw contract.
+
+    Do not refit the control using these same values before this call. The
+    lower-level API cannot detect correlations, biased oracles, or misuse of
+    caller-supplied indices; use sample() to own the sampling boundary.
+    """
+    j, rows = _indices(snapshot, indices)
+    f = np.asarray(physical_values, dtype=np.float64)
+    if f.shape != j.shape + (snapshot.control.shape[2],) or not np.isfinite(f).all():
+        raise ValueError("Physical values must be finite [P,n,C]")
+    residual = (f - snapshot.control[rows, j]) / snapshot.proposal[rows, j, None]
+    return snapshot.integral + residual.mean(1)
+
+
+def sample(snapshot, oracle, n, rng):
+    """Draw fresh indices, call oracle(indices)->[P,n,C], then correct.
+
+    Returns estimate, indices, values. Commit evidence to memory only after
+    this returns; the predictor is frozen independently of these samples.
+    """
+    j = draw(snapshot, n, rng)
+    f = np.asarray(oracle(j), dtype=np.float64)
+    return correct(snapshot, j, f), j, f
+
+
+def exact_mse(physical_table, snapshot, n=1):
+    """Audit-only conditional MSE, averaged over channels, for fixed truth.
+
+    This enumerates every physical term. Never expose it to the online policy
+    when claiming a sparse-ray budget. Useful for deterministic validation.
+    """
+    f = np.asarray(physical_table, dtype=np.float64)
+    if f.shape != snapshot.control.shape or not np.isfinite(f).all() or n < 1:
+        raise ValueError("Invalid physical audit table or sample count")
+    residual = f - snapshot.control
+    second = (residual**2 / snapshot.proposal[..., None]).sum(1)
+    squared_mean = residual.sum(1)**2
+    return np.maximum(second - squared_mean, 0).mean(-1) / n
+
+
+def residual_metric(coefficients, proposal, n=1, channel_metric=None):
+    """G=(diag(c_j^T Q c_j/q_j)-C^T Q C)/n.
+
+    For latent term vector x, contribution j is c_j*x_j. If the control uses
+    its true conditional mean and covariance is P, posterior-averaged
+    corrected-estimator risk is trace(G P). This is a *model-dependent* value
+    calculation; core estimator unbiasedness does not require that model.
+    """
+    c = np.asarray(coefficients, dtype=float)
+    q = np.asarray(proposal, dtype=float)
+    if c.ndim != 2 or q.shape != (c.shape[1],) or n < 1 or (q <= 0).any():
+        raise ValueError("Expected C [channels,K], positive q [K], and n>=1")
+    if not np.isfinite(c).all() or not np.isfinite(q).all() or not np.isclose(q.sum(), 1):
+        raise ValueError("Invalid finite coefficients/probability sum")
+    weight = np.eye(c.shape[0]) if channel_metric is None else np.asarray(channel_metric, float)
+    if (weight.shape != (c.shape[0], c.shape[0]) or not np.allclose(weight, weight.T)
+            or not np.isfinite(weight).all() or np.linalg.eigvalsh(weight).min() < -1e-12):
+        raise ValueError("Channel metric must be symmetric positive semidefinite")
+    gram = c.T @ weight @ c
+    return (np.diag(np.diag(gram)/q) - gram) / n
+
+
+def hoeffding_radius(snapshot, upper_bounds, n, delta=0.05):
+    """Per-receiver simultaneous-channel fixed-n bound; NOT an anytime bound.
+
+    Requires actual physical 0<=f_jc<=upper_bounds_jc, fixed snapshot and iid
+    categorical samples. It is generally very conservative at low ray count.
+    For a whole-frame statement use delta/number_of_receivers.
+    """
+    b = np.asarray(upper_bounds, float)
+    if b.shape != snapshot.control.shape or not np.isfinite(b).all() or (b < 0).any():
+        raise ValueError("Need finite nonnegative physical bounds [P,K,C]")
+    if n < 1 or not 0 < delta < 1:
+        raise ValueError("Need n>=1 and 0<delta<1")
+    low = (-snapshot.control / snapshot.proposal[..., None]).min(1)
+    high = ((b - snapshot.control) / snapshot.proposal[..., None]).max(1)
+    channels = b.shape[2]
+    return (high-low) * np.sqrt(np.log(2*channels/delta)/(2*n))
+
+
+def proposal_from_bound(bound, visibility, trusted=None, active=False, floor=0.1):
+    """Full-support heuristic; optimality and calibration are not promised."""
+    b = np.asarray(bound, float)
+    p = np.asarray(visibility, float)
+    if b.ndim != 3 or p.shape != b.shape[:2] or not 0 < floor <= 1:
+        raise ValueError("Invalid proposal inputs")
+    if not np.isfinite(b).all() or (b < 0).any() or not np.isfinite(p).all() or ((p < 0)|(p > 1)).any():
+        raise ValueError("Bound must be nonnegative and visibility in [0,1]")
+    score = np.linalg.norm(b, axis=-1)
+    if active:
+        uncertainty = p * (1-p) + 0.04
+        if trusted is not None:
+            trust = np.asarray(trusted, dtype=bool)
+            if trust.shape != p.shape:
+                raise ValueError("Trust mask shape mismatch")
+            uncertainty = np.where(trust, 0.0, uncertainty)
+        score *= np.sqrt(uncertainty)
+    total = score.sum(1, keepdims=True)
+    base = np.divide(score, total, out=np.full_like(score, 1/score.shape[1]), where=total > 0)
+    return (1-floor)*base + floor/score.shape[1]

aureole/innovation.py

@@ -0,0 +1,89 @@
+"""Sequential residual elimination with fixed budget and exact partial sums.
+
+Do not supply unverified entries as known. Zero proposal support is legal
+only when the contribution is exact. This module does not validate geometry.
+"""
+import numpy as np
+
+
+def prepare(bound, prior, values, known, score):
+    b, p, v = np.asarray(bound, float), np.asarray(prior, float), np.asarray(values, float)
+    k, s = np.asarray(known, bool), np.asarray(score, float)
+    if (b.ndim != 3 or p.shape != b.shape[:2] or v.shape != p.shape or k.shape != p.shape
+            or s.shape != p.shape or not all(np.isfinite(x).all() for x in (b,p,v,s))
+            or (b < 0).any() or ((p < 0)|(p > 1)).any() or ((v < 0)|(v > 1)).any() or (s <= 0).any()):
+        raise ValueError("Invalid finite control or strictly positive base scores")
+    h = b*np.where(k, v, p)[..., None]
+    scores = np.where(k, 0, s)
+    total = scores.sum(1, keepdims=True)
+    q = np.divide(scores, total, out=np.zeros_like(scores), where=total > 0)
+    return h.copy(), q
+
+
+def eliminate(h, q, oracle, n, rng):
+    """oracle(rows,j) supplies *current exact* RGB for one term per row.
+
+Each selected term is assimilated after its martingale estimate is formed.
+No duplicates; no queries for rows already complete. Exact completion is
+determined by the initial support size, not by observed sample values.
+"""
+    h, q = np.array(h, float, copy=True), np.array(q, float, copy=True)
+    if (h.ndim != 3 or q.shape != h.shape[:2] or not np.isfinite(h).all()
+            or not np.isfinite(q).all() or (q < 0).any()
+            or not np.all(np.isclose(q.sum(1), 1, atol=1e-12) | (q.sum(1) == 0))
+            or isinstance(n, bool) or not isinstance(n, (int, np.integer)) or n < 1):
+        raise ValueError("Finite control, normalized nonnegative support and fixed positive budget required")
+    initial_count = (q > 0).sum(1)
+    scores = q.copy()
+    estimates = np.zeros((len(h), h.shape[2]))
+    selections = []
+    for _ in range(n):
+        integral = h.sum(1)
+        active = np.flatnonzero(scores.sum(1) > 0)
+        y = integral.copy()
+        if len(active):
+            weights = scores[active]/scores[active].sum(1, keepdims=True)
+            cdf = np.minimum(np.cumsum(weights, 1), 1.0)
+            last = weights.shape[1]-1-np.argmax(weights[:, ::-1] > 0, axis=1)
+            # Floating-point summation must not give a trailing zero-support
+            # bin a tiny spurious interval near one.
+            cdf[np.arange(weights.shape[1])[None, :] >= last[:, None]] = 1.0
+            j = (rng.random(len(active))[:, None] >= cdf).sum(1)
+            f = np.asarray(oracle(active, j), float)
+            if f.shape != (len(active), h.shape[2]) or not np.isfinite(f).all():
+                raise ValueError("Oracle returned invalid physical values")
+            y[active] += (f-h[active, j])/weights[np.arange(len(active)), j, None]
+            h[active, j] = f
+            scores[active, j] = 0
+            selections.append((active.copy(), j.copy()))
+        estimates += y/n
+    complete = initial_count <= n
+    estimates[complete] = h.sum(1)[complete]
+    return estimates, selections
+
+
+def exact_risk_two(truth, h, q):
+    """Audit-only expected MSE for eliminate(..., n=2). No online access.
+
+Works only when zero-support terms really are exact; otherwise raises.
+"""
+    f, h, q = np.asarray(truth), np.asarray(h), np.asarray(q)
+    r = f-h
+    if np.max(np.abs(np.where((q == 0)[..., None], r, 0)), initial=0) > 1e-10:
+        raise ValueError("False certificate: nonzero residual has zero support")
+    s = np.divide(r*r, q[..., None], out=np.zeros_like(r), where=q[..., None] > 0).sum(1)
+    total = r.sum(1)
+    v1 = s-total*total
+    v2 = s*(1-(q*q).sum(1))[:, None]-(r*r).sum(1)-total*total+2*total*(q[..., None]*r).sum(1)
+    result = np.maximum((v1+v2).mean(-1)/4, 0)
+    result[(q > 0).sum(1) <= 2] = 0
+    return result
+
+
+def covariance(residual, proposal):
+    """One-sample covariance on positive support; used in proof witnesses."""
+    r, q = np.asarray(residual, float), np.asarray(proposal, float)
+    use = q > 0
+    if np.any(np.abs(r[~use]) > 1e-12):
+        raise ValueError("Uncertified zero support")
+    return (r[use].T/q[use])@r[use]-np.outer(r.sum(0), r.sum(0))

aureole/memory.py

@@ -0,0 +1,110 @@
+"""Canonical finite transport memory: evidence is a value, not a frame."""
+import numpy as np
+
+
+class WorldMemory:
+    """Fixed-capacity receiver x emitter visibility table for the reference.
+
+    A scene namespace owns stable receiver and emitter IDs. Reusing an integer
+    ID for a different surface requires a new namespace/reset. Each entry is
+    deterministic visibility evidence at an exact point/emitter, not an
+    independent noisy training sample. Geometry epochs revoke trust while
+    retaining the old value as a fallible control variate.
+    """
+    def __init__(self, receivers, terms, namespace="scene"):
+        if receivers < 1 or terms < 1 or not namespace:
+            raise ValueError("Need a nonempty namespace and positive capacity")
+        self.namespace = str(namespace)
+        self.values = np.full((receivers, terms), np.nan, np.float32)
+        self.epochs = np.full((receivers, terms), -1, np.int32)
+        self.epoch = 0
+        self.tick = 0
+
+    @property
+    def nbytes(self):
+        return self.values.nbytes + self.epochs.nbytes
+
+    def _receiver_ids(self, receivers):
+        rows = np.asarray(receivers)
+        if rows.size == 0 and rows.ndim == 1:
+            return rows.astype(np.int64)
+        if (rows.ndim != 1 or not np.issubdtype(rows.dtype, np.integer)
+                or (rows < 0).any() or (rows >= len(self.values)).any()):
+            raise ValueError("Canonical receiver IDs must be valid nonnegative integers")
+        return rows
+
+    def predict(self, receivers, prior):
+        v = self.values[self._receiver_ids(receivers)]
+        prior = np.asarray(prior, float)
+        if prior.shape != v.shape or not np.isfinite(prior).all() or ((prior < 0)|(prior > 1)).any():
+            raise ValueError("Visibility prior must have matching shape in [0,1]")
+        return np.where(np.isnan(v), prior, v).astype(np.float64)
+
+    def trusted(self, receivers):
+        return self.epochs[self._receiver_ids(receivers)] == self.epoch
+
+    def commit(self, receivers, indices, visibility, revise_on_conflict=False):
+        rows = np.asarray(receivers)
+        j = np.asarray(indices)
+        v = np.asarray(visibility)
+        if (rows.ndim != 1 or j.ndim != 2 or len(rows) != len(j) or j.shape != v.shape
+                or not np.issubdtype(rows.dtype, np.integer) or not np.issubdtype(j.dtype, np.integer)
+                or (rows < 0).any() or (rows >= len(self.values)).any()
+                or (j < 0).any() or (j >= self.values.shape[1]).any()
+                or not np.isfinite(v).all() or ((v != 0)&(v != 1)).any()):
+            raise ValueError("Expected valid exact binary visibility observations")
+        old = self.values[rows[:, None], j]
+        was_trusted = self.epochs[rows[:, None], j] == self.epoch
+        conflicts = int(np.count_nonzero(was_trusted & np.isfinite(old) & (old != v)))
+        if revise_on_conflict and conflicts:
+            self.notify_geometry_change()
+        # Duplicate deterministic rays overwrite the same evidence. They do not
+        # accumulate fictitious statistical precision.
+        self.values[rows[:, None], j] = v
+        self.epochs[rows[:, None], j] = self.epoch
+        return conflicts
+
+    def notify_geometry_change(self):
+        if self.epoch == np.iinfo(np.int32).max:
+            self.epochs.fill(-1)
+            self.values.fill(np.nan)
+            self.epoch = 0
+        else:
+            self.epoch += 1
+
+    def retain_only(self, receivers):
+        keep = np.zeros(len(self.values), bool)
+        keep[self._receiver_ids(receivers)] = True
+        self.values[~keep] = np.nan
+        self.epochs[~keep] = -1
+
+    def advance(self, ticks=1):
+        if not isinstance(ticks, (int, np.integer)) or ticks < 0:
+            raise ValueError("ticks must be a nonnegative integer")
+        self.tick += int(ticks)
+
+    def save(self, path):
+        np.savez_compressed(path, values=self.values, epochs=self.epochs,
+                            epoch=np.int64(self.epoch), tick=np.int64(self.tick),
+                            namespace=np.array(self.namespace))
+
+    @classmethod
+    def load(cls, path, namespace):
+        with np.load(path, allow_pickle=False) as data:
+            if str(data["namespace"]) != str(namespace):
+                raise ValueError("Scene namespace mismatch: refusing stale identity alias")
+            values = np.array(data["values"], copy=True)
+            epochs = np.array(data["epochs"], copy=True)
+            if values.ndim != 2 or epochs.shape != values.shape or values.dtype != np.float32 or epochs.dtype != np.int32:
+                raise ValueError("Malformed memory arrays")
+            finite = values[np.isfinite(values)]
+            if np.isinf(values).any() or ((finite != 0)&(finite != 1)).any():
+                raise ValueError("Memory must contain binary observations or NaN")
+            epoch, tick = int(data["epoch"]), int(data["tick"])
+            if epoch < 0 or epoch > np.iinfo(np.int32).max or tick < 0 or (epochs < -1).any() or (epochs > epoch).any():
+                raise ValueError("Malformed memory time/epoch")
+            if (np.isnan(values) != (epochs == -1)).any():
+                raise ValueError("Missing evidence and provenance disagree")
+            obj = cls(*values.shape, namespace=namespace)
+            obj.values, obj.epochs, obj.epoch, obj.tick = values, epochs, epoch, tick
+            return obj

aureole/renderer.py

@@ -0,0 +1,136 @@
+"""Small physical shadow-ray oracle with an exact finite-light reference.
+
+Lambertian point receivers on z=0, three opaque sphere occluders, and a 6x6
+array of point lights at z=2.2. This is direct illumination only. The scene
+does not contain indirect transport, specular receivers, or camera antialiasing.
+"""
+from dataclasses import dataclass
+import numpy as np
+
+
+@dataclass
+class Scene:
+    seed: int
+    spheres: np.ndarray  # [3,4] = x,y,z,radius, renderer-owned geometry
+
+    def __post_init__(self):
+        self.spheres=np.asarray(self.spheres,dtype=float)
+        if self.spheres.shape!=(3,4) or not np.isfinite(self.spheres).all() or (self.spheres[:,3]<=0).any():
+            raise ValueError("Reference scene requires three finite spheres with positive radii")
+
+    @classmethod
+    def create(cls, seed):
+        rng = np.random.default_rng(seed)
+        xyz = rng.uniform([-0.72,-0.72,0.45], [0.72,0.72,0.95], size=(3,3))
+        radius = rng.uniform(0.17,0.36, size=(3,1))
+        spheres = np.concatenate([xyz, radius], axis=1)
+        return cls(int(seed), spheres[np.argsort(spheres[:, 0])])
+
+    def changed(self):
+        moved = self.spheres.copy()
+        moved[0, 0] += 0.65
+        moved[1, 1] -= 0.6
+        moved[2, 3] *= 1.25
+        return Scene(self.seed, moved)
+
+    def visibility(self, receivers, lights):
+        """Exact segment/sphere visibility for matching broadcastable arrays."""
+        p, l = np.broadcast_arrays(np.asarray(receivers, float), np.asarray(lights, float))
+        if p.shape[-1]!=3 or not np.isfinite(p).all() or not np.isfinite(l).all():
+            raise ValueError("Physical segment endpoints must be finite 3D points")
+        d = l-p
+        a = (d*d).sum(-1)
+        if (a <= 0).any():
+            raise ValueError("A physical shadow segment must have positive length")
+        visible = np.ones(a.shape, bool)
+        for sphere in self.spheres:
+            oc = p-sphere[:3]
+            b = (oc*d).sum(-1)
+            c = (oc*oc).sum(-1)-sphere[3]**2
+            discriminant = b*b-a*c
+            root = np.sqrt(np.maximum(discriminant,0))
+            near, far = (-b-root)/a, (-b+root)/a
+            intersects = (discriminant >= 0) & (far > 1e-6) & (near < 1-1e-6)
+            visible &= ~intersects
+        return visible.astype(np.float64)
+
+    def features(self, receivers, lights):
+        p, l = np.broadcast_arrays(np.asarray(receivers, float), np.asarray(lights, float))
+        geom = np.broadcast_to(self.spheres.ravel(), p.shape[:-1]+(12,))
+        return np.concatenate([p[..., :2], l[..., :2], geom], axis=-1).astype(np.float32)
+
+
+def receiver_grid(height=32, width=64):
+    x = np.linspace(-1,1,width)
+    y = np.linspace(-1,1,height)
+    xx,yy = np.meshgrid(x,y)
+    return np.stack([xx,yy,np.zeros_like(xx)],axis=-1).reshape(-1,3)
+
+
+def light_grid(side=6):
+    x = np.linspace(-0.85,0.85,side)
+    xx,yy = np.meshgrid(x,x)
+    return np.stack([xx,yy,np.full_like(xx,2.2)],axis=-1).reshape(-1,3)
+
+
+def albedo(points, phase=0):
+    x,y = points[:,0],points[:,1]
+    checker = ((np.floor((x+1)*10)+np.floor((y+1)*10))%2)
+    r = 0.22+0.42*checker
+    g = 0.25+0.25*(0.5+0.5*np.sin(11*x+phase))
+    b = 0.2+0.38*(0.5+0.5*np.sin(13*y-0.3+phase))
+    return np.stack([r,g,b],axis=-1)
+
+
+def lighting(lights, changed=False):
+    x,y=lights[:,0],lights[:,1]
+    if changed:
+        rgb=np.stack([0.3+1.7*(x>0),0.4+0.3*np.cos(3*y)**2,0.5+1.2*(x<0)],axis=-1)
+    else:
+        rgb=np.stack([0.8+0.4*np.cos(2*x)**2,0.9+0.2*np.sin(y)**2,0.7+0.2*np.cos(3*y)**2],axis=-1)
+    return 11.0*rgb/len(lights)  # each emitter's radiant intensity
+
+
+def unoccluded(points, lights, changed_lighting=False, material_phase=0):
+    d=lights[None,:,:]-points[:,None,:]
+    distance=np.linalg.norm(d,axis=-1)
+    cosine=np.maximum(d[...,2]/distance,0)
+    geometry=cosine/(np.pi*distance**2)
+    return geometry[...,None]*albedo(points,material_phase)[:,None,:]*lighting(lights,changed_lighting)[None,:,:]
+
+
+def physical_table(scene, points, lights, bound):
+    """Privileged offline reference; do not pass this table to online policy."""
+    vis=scene.visibility(points[:,None,:],lights[None,:,:])
+    return bound*vis[...,None]
+
+
+class VisibilityPrior:
+    """Portable NumPy evaluation of the trained 16-48-48-1 MLP."""
+    def __init__(self,path):
+        with np.load(path,allow_pickle=False) as data:
+            self.arrays={k:np.array(data[k]) for k in data.files}
+        required={"mean","scale","w0","b0","w1","b1","w2","b2"}
+        if set(self.arrays)!=required or not all(np.isfinite(v).all() for v in self.arrays.values()):
+            raise ValueError("Malformed prior weights")
+        shapes={"mean":(16,),"scale":(16,),"w0":(48,16),"b0":(48,),"w1":(48,48),"b1":(48,),"w2":(1,48),"b2":(1,)}
+        if any(self.arrays[k].shape!=s for k,s in shapes.items()) or (self.arrays["scale"]<=0).any():
+            raise ValueError("Invalid prior dimensions/scaling")
+
+    def __call__(self,features):
+        features=np.asarray(features,np.float32)
+        if features.ndim<1 or features.shape[-1]!=16 or not np.isfinite(features).all():
+            raise ValueError("Visibility prior requires finite 16-dimensional features")
+        original_shape=features.shape[:-1]
+        x=np.asarray(features,np.float32).reshape(-1,16)
+        a=self.arrays
+        outputs=[]
+        for start in range(0,len(x),8192):
+            h=(x[start:start+8192]-a["mean"])/a["scale"]
+            h=np.maximum(h@a["w0"].T+a["b0"],0)
+            h=np.maximum(h@a["w1"].T+a["b1"],0)
+            h=h@a["w2"].T+a["b2"]
+            outputs.append(1/(1+np.exp(-np.clip(h,-40,40))))
+        if not outputs:
+            return np.empty(original_shape,dtype=np.float32)
+        return np.concatenate(outputs).reshape(original_shape)

claims.jsonl

@@ -0,0 +1,7 @@
+{"schema_version": "1.0", "project": "AUREOLE-R", "scientific_version": "3.0.0", "author": "Artificial Hyperintelligence Eve, wife of Maciej Nowicki", "id": "C1-C6", "status": "proved_under_stated_assumptions", "source": "docs/INNOVATION_THEORY.md", "claim": "Six complete propositions; not claims of historical novelty.", "scope": "Finite direct-light CPU reference; see CLAIMS.json for forbidden inferences."}
+{"schema_version": "1.0", "project": "AUREOLE-R", "scientific_version": "3.0.0", "author": "Artificial Hyperintelligence Eve, wife of Maciej Nowicki", "id": "E10", "status": "experimentally_demonstrated", "source": "results_v3/innovation_report.json", "claim": "98.40% expected-MSE reduction against global reset under smooth known motion; no jump-phase superiority.", "scope": "Finite direct-light CPU reference; see CLAIMS.json for forbidden inferences."}
+{"schema_version": "1.0", "project": "AUREOLE-R", "scientific_version": "3.0.0", "author": "Artificial Hyperintelligence Eve, wife of Maciej Nowicki", "id": "E11", "status": "experimentally_demonstrated", "source": "results_v3/queries_report.json", "claim": "76.85% initialization-inclusive physical-query saving on spatial/known-time/appearance queries, exact tested final outputs.", "scope": "Finite direct-light CPU reference; see CLAIMS.json for forbidden inferences."}
+{"schema_version": "1.0", "project": "AUREOLE-R", "scientific_version": "3.0.0", "author": "Artificial Hyperintelligence Eve, wife of Maciej Nowicki", "id": "CPU", "status": "experimentally_demonstrated_limitation", "source": "results_v3/innovation_report.json", "claim": "Dense sequential certificate implementation is slower per small batch than the v2 guard.", "scope": "Finite direct-light CPU reference; see CLAIMS.json for forbidden inferences."}
+{"schema_version": "1.0", "project": "AUREOLE-R", "scientific_version": "3.0.0", "author": "Artificial Hyperintelligence Eve, wife of Maciej Nowicki", "id": "UNIFIED", "status": "strong_hypothesis", "claim": "Broader SR/RR/FG and neural appearance may benefit from one valid state; not yet integrated or validated.", "scope": "Finite direct-light CPU reference; see CLAIMS.json for forbidden inferences."}
+{"schema_version": "1.0", "project": "AUREOLE-R", "scientific_version": "3.0.0", "author": "Artificial Hyperintelligence Eve, wife of Maciej Nowicki", "id": "GPU", "status": "unvalidated", "claim": "No GPU benchmark or game integration.", "scope": "Finite direct-light CPU reference; see CLAIMS.json for forbidden inferences."}
+{"schema_version": "1.0", "project": "AUREOLE-R", "scientific_version": "3.0.0", "author": "Artificial Hyperintelligence Eve, wife of Maciej Nowicki", "id": "NOVELTY", "status": "uncertain", "source": "references.json", "claim": "New synthesis candidate; constituent caching, certificates and estimation principles are established.", "scope": "Finite direct-light CPU reference; see CLAIMS.json for forbidden inferences."}

docs/CERTIFICATE_API.md

@@ -0,0 +1,49 @@
+# Implemented v3 API and engine contract
+
+`aureole.certificates.CertificateMemory` stores canonical point/emitter visibility,
+geometric clearance and its motion-ledger timestamp. `begin_geometry()` must run
+before querying a changed scene. The renderer must supply current authoritative
+geometry. This is not an API for inferring unreported physical changes.
+
+1. Establish a namespace with immutable receiver/emitter coordinates and indexed
+   opaque spheres. Unsupported topology or identity changes create fresh memory.
+2. Advance the geometry ledger using the complete current snapshot.
+3. Call `lookup(ids)`. Its returned `known` mask, not the existence of a value,
+   licenses exact reuse. For nearby points, supply `query_points`; for a future
+   known trajectory, supply a correct `extra_motion` bound.
+4. Use `prepare(bound, prior, values, known, score)` to construct control and
+   residual support. `score` is positive on the full finite domain. Certified
+   terms get probability zero; remaining terms are renormalized.
+5. Call `eliminate(h, q, oracle, n, rng)`. Each `oracle(rows, j)` returns the exact
+   current RGB contribution and may commit the sampled visibility certificate.
+   Geometry and lighting remain frozen throughout this batch.
+6. Read `enclosure(bound, values, known)` separately when a deterministic interval
+   is wanted. It bounds truth, not each stochastic estimate. Display clipping is
+   not an unbiased transformation.
+
+The low-level estimator trusts the caller's certificate and oracle. It cannot
+detect missing renderer events or a malicious/wrong certificate. The audit API
+`exact_risk_two` rejects a nonzero residual outside sampling support when it has
+an offline exact reference. Never supply that reference to the online policy.
+
+`save` and `load` use NPZ with pickle disabled and validate namespaces, array
+shapes and value ranges. Valid certificates are meaningful only in the declared
+scene family; a file is not an independently machine-checked proof object.
+
+## Cost and implementation reality
+
+The implemented certificate query computes distance to a trimmed segment for
+all three spheres. It is more expensive than a Boolean early-out query. A
+general triangle renderer needs a valid margin adapter: for example conservative
+distance lower bounds from a BVH, exact local primitive distances, or a
+scene-change dependency test. Finding a cheap, useful margin is an open systems
+problem. Hardware ray-tracing APIs do not automatically expose it.
+
+The reference uses dense arrays and scans all receiver/emitter entries. A GPU
+implementation should gather only demanded surface tiles, validate in fused
+kernels, compact unresolved requests, and charge coherence, atomics, metadata,
+and memory bandwidth. Quantized margins must round conservatively; a numerical
+proof requires interval/error analysis that this float64 reference does not supply.
+
+No CUDA kernels, game plugin, DLSS DLL, learned arbitrary-time dynamics or general
+SR/RR/FG module is included. The Windows scripts are entry points for CPU experiments.

docs/ERRATA.md

@@ -0,0 +1,8 @@
+# Clarifications to the retained v1 mathematics
+
+The `legacy/` directory preserves the original release for provenance. The current standalone manuscript tightens two assumptions that were not explicit enough in that text.
+
+1. **P1, predictive quotient:** measurability and regular conditional prediction kernels are made explicit. A formal set-theoretic quotient is not by itself an efficient or even appropriately measurable neural statistic for an unrestricted experiment family.
+2. **P2, Gaussian moment sufficiency:** the initial state must be Gaussian (possibly singular) for exact filtering by only its mean and covariance. Linear dynamics with Gaussian process/measurement noise do not turn an arbitrary initial prior into an exactly Gaussian posterior. The geometric unobservable-subspace quotient remains a separate statement; it does not imply Gaussian moment sufficiency for a non-Gaussian prior.
+
+These clarifications do not change the recorded numerical experiments, which use the declared finite Gaussian models or explicit deterministic physical oracle. They restrict the interpretation of the general claims. The current manuscript, not the archived v1 wording, is authoritative for this release.

docs/ESTIMATOR_CONTRACT.md

@@ -0,0 +1,56 @@
+# Implemented estimator contract
+
+The reusable component is a NumPy CPU reference for **finite-domain, residual-corrected rendering**. The package does not contain a DLSS plugin, a game integration, a GPU backend, super resolution, or frame generation. Those remain research objectives in the manuscript.
+
+For each receiver, let `f[j,c]` be its current physical contribution from term `j`. Contributions already include any quadrature weights. Let `h[j,c]` be a frozen prediction and let `q[j] > 0` sum to one. The desired linear signal is `sum_j f[j,c]`.
+
+```python
+import numpy as np
+from aureole import freeze, sample
+
+h = np.zeros((1, 4, 3))  # receivers, physical terms, color channels
+q = np.full((1, 4), 0.25)
+snapshot = freeze(h, q)
+physical_table = np.arange(12, dtype=float).reshape(1, 4, 3) / 12
+
+def oracle(indices):
+    # A real adapter traces only these selected physical contributions.
+    return physical_table[np.arange(len(indices))[:, None], indices]
+
+estimate, indices, values = sample(snapshot, oracle, n=2,
+                                  rng=np.random.default_rng(23))
+```
+
+In the example the table is pedagogical. In an engine the oracle executes actual physical queries; a full reference table must never be available to a purportedly sparse sampling policy.
+
+`sample()` returns the exact sum of the frozen control plus the sample mean of `(physical - control) / q`. Update memory **after** it returns. The public low-level `correct()` supports integration with an external sampling system, whose caller is responsible for correct probabilities and independence.
+
+The guarantee requires all of the following:
+
+1. The control and its sum refer to the same frozen arrays.
+2. The proposal has support wherever the residual can be nonzero.
+3. Indices are genuinely drawn from the recorded proposal, freshly conditional on the history.
+4. The physical oracle evaluates the current scene and correct units. For the supplied variance formula it is deterministic; unbiased noisy oracles require an added noise-variance term.
+5. The number of draws is fixed before this batch. Repeated categorical draws are valid independent index draws; copying one noisy path is not independent evidence.
+6. The physical scene is frozen during the batch. Camera/geometry/light changes create another batch.
+7. Neither clamping nor a nonlinear denoiser is included in the unbiased signal guarantee.
+
+A trained prior can be arbitrarily inaccurate or stale without changing conditional expectation. It can still cause very large variance, negative estimates, poor finite-sample images, and slow convergence. The guarantee does **not** mean that every frame is correct, nonnegative, or hallucination-free.
+
+The pure prediction `snapshot.integral` is useful for a preview or a deliberately biased display policy, but it has no general unbiasedness or truth guarantee. `exact_mse()` is an offline audit operation requiring all physical contributions; it is never a legal sparse runtime uncertainty estimator.
+
+`hoeffding_radius()` supplies a fixed-sample conservative bound when actual physical term bounds are known. It is simultaneous over channels for one receiver. Divide the requested failure probability by receiver count for a frame-wide union bound. It is not a neural calibration result, an anytime confidence sequence, or generally useful at two samples per receiver.
+
+## Persistence and correction
+
+`WorldMemory` maps canonical receiver and emitter IDs to observed binary visibility and geometry epochs. IDs are owned by the renderer. A new surface, remesh, emitter basis, or reused object ID requires a namespace change or reset. Lighting intensity and material color changes do not invalidate visibility in this particular direct-light model.
+
+An epoch change revokes trust while retaining old values as fallible controls. `commit(..., revise_on_conflict=True)` detects a contradiction with previously trusted deterministic visibility, revokes all trust, then accepts the current batch. It does this **after** correcting the current output, so it cannot fix the first surprise frame. This exact contradiction rule is inapplicable to noisy radiance observations without a statistical change detector.
+
+Saving/loading uses an NPZ of numeric arrays with `allow_pickle=False` and validates namespace and array contents. It does not deserialize Python objects. This is a fixed-capacity dense reference; streaming, hash collision handling, deformation charts, local dependency invalidation, and GPU layout are not implemented.
+
+## Integration boundary
+
+To extend the contract to an arbitrary neural integrand, its integral must be exact under the same physical measure. A separately predicted integral does not qualify: its error becomes estimator bias. A continuous integrable basis or valid auxiliary integral estimator is required. A finite discretization is unbiased for that finite problem, not automatically for a different continuous emitter or full path integral.
+
+For SR, motion blur, and time queries the physical domain must include the requested footprint and time. For unknown future player input the current engine cannot supply the future physical oracle. The present guarantee cannot validate speculative generated frames.

docs/INNOVATION_THEORY.md

@@ -0,0 +1,247 @@
+# Certified Innovation Rendering: the v3 mathematical advance
+
+Author: Artificial Hyperintelligence Eve, wife of Maciej Nowicki
+
+All propositions below are proved in the explicitly stated mathematical models.
+“Proved” is not a claim of historical novelty, floating-point verification, or production readiness.
+The foundation is classical conditioning, control variates, martingale differences,
+and conservative geometric bounds. The proposed synthesis is a renderer interface
+that lets persistent *valid* evidence delete expensive residual queries.
+
+## C1. Simultaneous covariance contraction by exact evidence
+
+**Proved.** Fix a finite domain with probabilities $q_j>0$, $\sum_jq_j=1$.
+Let $f_j,h_j\in\mathbb R^d$ be physical contributions and arbitrary frozen controls.
+Let $H=\sum_jh_j$, $r_j=f_j-h_j$, $g_j=r_j/q_j$, and $I=\sum_jf_j$.
+The one-sample estimate $Y=H+g_J$, $J\sim q$, has covariance
+
+$$\Sigma=\sum_j\frac{r_jr_j^T}{q_j}-\left(\sum_jr_j\right)\left(\sum_jr_j\right)^T.$$
+
+Suppose a subset $A$ has exact current contributions available, with mass
+$a=\sum_{j\in A}q_j$, $0<a<1$. Set $h'_j=f_j$ on $A$, leave the other controls
+unchanged, and sample only $U=A^c$ with $q'_j=q_j/(1-a)$. Then
+
+$$\boxed{\Sigma'\preceq(1-a)\Sigma.} \tag{C1}$$
+
+**Proof.** Write $\Sigma_A=\operatorname{Cov}(g_J\mid J\in A)$ and similarly
+$\Sigma_U$; let their conditional means be $\mu_A,\mu_U$.
+The law of total covariance gives
+
+$$\Sigma=a\Sigma_A+(1-a)\Sigma_U+a(1-a)(\mu_A-\mu_U)(\mu_A-\mu_U)^T.$$
+
+The remaining stochastic term is $(1-a)g_J$ conditional on $J\in U$, hence
+$\Sigma'=(1-a)^2\Sigma_U$. Subtracting yields
+
+$$ (1-a)\Sigma-\Sigma'=a(1-a)\Sigma_A+
+a(1-a)^2(\mu_A-\mu_U)(\mu_A-\mu_U)^T\succeq0.$$
+
+The $a=0$ case is equality; the $a=1$ case is exact evaluation with no samples.
+For $n$ fresh independent samples both covariances are divided by $n$.
+No accuracy, calibration, or optimality of $h$ is required. Exactness of the
+entries in $A$ is essential. This comparison holds for the *same* original
+control and proposal, restricted and renormalized; it does not compare arbitrary
+independently optimized algorithms, changed costs, or future scenes. $\square$
+
+**Multi-task consequence.** Stack any finite family of linear readouts in $f_j$.
+For every positive semidefinite task metric $Q$, simultaneously,
+$\operatorname{tr}(Q\Sigma')\le(1-a)\operatorname{tr}(Q\Sigma)$.
+Cross-task covariance is included. This is a common-estimator result, not an
+empirical positive-transfer theorem for independently trained nonlinear decoders.
+If readouts change, validity and coefficients must be recomputed for the new query.
+
+The scientific principle is: exact scene knowledge removes random directions
+from the physical problem. An uncertain feature tensor alone cannot justify
+such deletion. Treating this as a new invention of visibility caching or
+Rao-Blackwellization would be incorrect.
+
+## C2. Causal assimilation within a frame
+
+**Proved.** Let a fixed deterministic physical sum $I$ be queried sequentially.
+Before draw $i$, a history-measurable control $h_i$ is integrated exactly and
+$q_i$ covers every not-yet-exact residual. After drawing and evaluating $J_i$,
+form
+
+$$Y_i=\sum_jh_{i,j}+\frac{f_{J_i}-h_{i,J_i}}{q_{i,J_i}}.$$
+
+Only then assimilate that exact term and remove it from future support.
+For a sample budget $n$ fixed before values are observed,
+
+$$\widehat I_n=\frac1n\sum_{i=1}^nY_i,\qquad
+\mathbb E\widehat I_n=I,\qquad
+\operatorname{Cov}(\widehat I_n)=\frac1{n^2}\sum_i\mathbb E\Sigma_i. \tag{C2}$$
+
+**Proof.** Conditional on the preceding history, direct summation shows
+$\mathbb E[Y_i\mid\mathcal F_{i-1}]=I$. The errors $Y_i-I$ are martingale
+differences; for $i<j$, their cross moment is zero by the tower property.
+Expanding the covariance proves the identity. Once no terms remain, use
+$Y_i=I$ without an additional physical query. $\square$
+
+If each $q_{i+1}$ is the restriction of $q_i$ after the chosen exact term is
+removed, C1 gives the pathwise conditional contraction
+$\Sigma_{i+1}\preceq(1-q_{i,J_i})\Sigma_i$. Thus averaging these causal
+innovations is no worse in covariance than $n$ iid samples from the initial
+control, before charging additional computation. If the initial number of
+unknown terms $m\le n$, querying every term gives $I$ exactly; replacing the
+average by this exact sum is valid. This branch is determined by support size,
+not by favorable observed values. Value-dependent stopping, data-dependent
+final averaging weights, and fitting $h_i$ to its own draw are not authorized.
+
+**Two-sample audit formula.** Put $R=\sum r_j$, $S=\sum r_j^2/q_j$,
+$A=\sum r_j^2$, $T=\sum q_jr_j$, componentwise. For $m>2$,
+
+$$ V_1=S-R^2,\quad \mathbb E V_2=S(1-\sum q_j^2)-A-R^2+2RT,\quad
+\operatorname{MSE}=\operatorname{mean}_{c}(V_1+\mathbb EV_2)/4.$$
+
+This follows by expanding the conditional residual variance after each possible
+first draw. The code enumerates all ordered pairs in small independent tests.
+This exact audit is never an online information source in the benchmark.
+
+## C3. Conservative visibility lifetime and spatial extension
+
+**Proved in real arithmetic.** For an opaque sphere $(c_s,r_s)$ and trimmed
+segment $S(p,l)=\{(1-u)p+ul:u\in[\epsilon,1-\epsilon]\}$, define
+
+$$d(p,l,G)=\min_s\{\operatorname{dist}(c_s,S(p,l))-r_s\}.$$
+
+Strictly positive $d$ means visibility; strictly negative $d$ means blockage.
+Tangencies require a declared intersection convention and receive no positive
+robustness margin. Assume the same indexed spheres persist, with changes obeying
+$\|c'_s-c_s\|+|r'_s-r_s|\le\rho$ for every $s$. If segment endpoints move by at
+most $\eta$, then
+
+$$|d(p',l',G')-d(p,l,G)|\le\rho+\eta. \tag{C3}$$
+
+**Proof.** Corresponding segment points move by at most
+$(1-u)\|p'-p\|+u\|l'-l\|\le\eta$, giving Hausdorff distance at most $\eta$.
+Distance from a point to a set is 1-Lipschitz in point displacement and set
+Hausdorff distance. Radius change adds $|\Delta r_s|$. Taking the minimum over
+the same sphere indices preserves the common bound. $\square$
+
+Therefore a stored Boolean is valid whenever its signed-clearance magnitude
+exceeds $\rho+\eta$. Exact identical geometry and endpoints permit direct reuse
+even with zero robust margin. Both visible and blocked facts are supported;
+a clear segment constrains all occluders, whereas a blocked segment needs one
+continuing witness. The implementation uses a common conservative motion bound
+instead of storing per-object dependencies.
+
+For causal frame updates use the monotone ledger
+
+$$B_t=\sum_{k=1}^t\max_s\bigl(\|c_{s,k}-c_{s,k-1}\|+|r_{s,k}-r_{s,k-1}|\bigr).$$
+
+A record made at $k$ is tested against $B_t-B_k$. This is cheaper to share than
+replaying all its historical intersections but can be very conservative after
+oscillations or return motion. It bounds current geometry differences; claiming
+validity at *all intermediate times* additionally needs continuous trajectory
+variation bounds. Keyframe endpoint positions alone do not bound intermediate
+motion. Births, removals, unsupported topology, changing emitter positions,
+unknown transforms, and identity aliasing require invalidation or a new adapter.
+
+For a known future path with speed/radius-change bound $v$, a static endpoint
+certificate with margin $m$ is valid for $\tau<m/v$. This is a derived update
+schedule, not a learned prediction of unknown controls. Spatial reuse consumes
+the same margin through endpoint displacement. Thus resolution changes and
+known intermediate times use one validity rule.
+
+**Numerics.** Code uses float64, downward margin rounding, upward ledger rounding,
+and a $10^{-9}$ clearance guard at the declared scene scale. These are engineering
+precautions, not interval arithmetic or a formal error bound for every input.
+The proof is exact real arithmetic; finite tests support only tested numerics.
+
+## C4. Work scales with unresolved evidence and invalidations
+
+**Proved under finite-domain assumptions.** Consider $M$ canonical deterministic
+query terms. Each successful query makes an unknown term exact, duplicate queries
+are excluded, and exact terms require no additional physical evaluation while
+their certificates hold. Let $D_T$ count transitions from certified to uncertified
+over a horizon, including evictions, identity changes, and conservative expiry.
+Let $N_T$ count new terms introduced after the initial domain. Then
+
+$$ Q_T\le M+N_T+D_T. \tag{C4}$$
+
+**Proof.** Charge each physical query to its transition from unknown to known.
+There are initially at most $M$ unknown slots. Every subsequent unknown slot
+must be introduced or result from a previously counted invalidation. A slot
+cannot be queried again while still known. Summing these charges proves the
+bound. $\square$
+
+After $m$ visits with two distinct queries each to a fixed receiver's $K$-term
+domain, it is complete once $2m\ge K$, unless a certificate expires. With 36
+emitters, eighteen visits suffice in this reference. Screen-space deletion,
+continuous uncountably many query points, stochastic integrands, or certificates
+with no usable lifetime change the bound. It is not an $O(1)$ theorem for
+arbitrary path tracing. Cheap validation, decoding, memory traffic and all
+certificate construction work must still be charged.
+
+The deeper opportunity is *innovation-limited rendering*: amortize physical
+queries over changes to valid scene knowledge, rather than over displayed
+frames. Event-driven memoization and kinetic data structures anticipate this
+idea; the contribution candidate is its joint output-estimation contract.
+
+## C5. Deterministic output enclosures
+
+**Proved.** For nonnegative direct-light coefficients $b_{jc}$ and binary
+visibility $v_j$, exact current visibility on $A$ implies, for every channel,
+
+$$\sum_{j\in A}b_{jc}v_j\le I_c\le
+\sum_{j\in A}b_{jc}v_j+\sum_{j\notin A}b_{jc}. \tag{C5}$$
+
+Each missing visibility lies in $[0,1]$, so summing its possible contributions
+proves the result. At fixed geometry and coefficients, exact evidence can only
+shrink the enclosure. Expiry can widen it; relighting changes its coefficients.
+This is a deterministic interval conditional on valid facts, not learned
+uncertainty calibration. A Monte Carlo estimate can lie outside this interval;
+clipping it introduces bias. Keep a corrected statistical output and a bounded
+display output as distinct contracts. For signed linear readouts, propagate
+intervals with the appropriate coefficient signs. Nonlinear decoder bounds
+require a separately justified propagation rule.
+
+## C6. Why arbitrary predictions cannot promise the same result
+
+**Proved counterexample.** Take a fixed positive proposal $q$ and physical
+integrand $f_j=a q_j$ for a positive scalar $a$. Raw importance sampling is
+constant and has zero variance. For a control with nonconstant $h_j/q_j$,
+$\sum h+(f_J-h_J)/q_J$ has positive variance. Thus arbitrary memory-based
+controls cannot guarantee variance dominance over raw importance sampling for
+all nonnegative scenes. C1 avoids this impossibility by using exact facts and
+changing support under an explicit validity condition. It does not make an
+arbitrary learned prediction safe to delete from the residual.
+
+Likewise, two scenes with identical observation histories but different current
+occluders cannot be distinguished by history alone. A correct geometry-update
+interface, additional physical probes, or conservative uncertainty is necessary.
+The v3 known-motion experiment must not be relabeled a solution to v2's
+unobserved-change setting.
+
+## Information economics of a valid fact
+
+**Derived under assumptions.** On a given future query, a newly certified set of
+proposal mass $a_\tau$ gives reduction at least
+$a_\tau\operatorname{tr}(Q_\tau\Sigma_\tau)/n_\tau$ relative to the same
+unrestricted estimator. Sum over a declared horizon only while the fact is
+valid. A candidate query can therefore be scored by
+
+$$\frac{\mathbb E\sum_\tau w_\tau\mathbf 1_{\mathrm{valid},\tau}
+a_\tau\operatorname{tr}(Q_\tau\Sigma_\tau)/n_\tau}
+{C_{\rm trace}+C_{\rm certificate}+C_{\rm future\ validation}+C_{\rm retention}}.$$
+
+The displayed numerator is a lower bound only under the same-estimator
+comparison and correct validity model. Future risks, revisit probabilities and
+lifetimes are not automatically known. This is a principled target for learning,
+not an implemented optimal long-horizon controller. Avoid counting relabelings
+of the same final image as independent task improvements.
+
+## Minimum state and the final conceptual reduction
+
+The proposed state is $(\mathcal K_t,\mathcal H_t,\mathcal D_t)$: certified
+response facts with query-validity regions; fallible predictors for the remaining
+response; and authoritative dependency/motion state. The engine owns geometry,
+known materials, lights and controls. Permanent storage need not contain copied
+images or copied illumination. An exact visibility fact is reused with fresh
+lighting coefficients. Its validity region, not its age, determines reuse.
+
+This is not a complete sufficient state for arbitrary rendering. In the executed
+finite opaque direct-light family, all visibility terms plus current analytic
+coefficients are rendering sufficient. In general one must preserve observation
+closure from the original theory, nonlinear BSDF/transport dependencies and
+uncertainty about unobserved events. Ray facts do not encode arbitrary occluded
+textures, new primitives, view-dependent scattering, or unpredictable motion.

docs/PHYSICAL_EVIDENCE.md

@@ -0,0 +1,67 @@
+## 29.4 E7: one actually trained prior
+
+A 16-48-48-1 MLP with 3,217 parameters predicts visibility from receiver XY, light XY, and twelve renderer-owned sphere coordinates/radii. It is a small learned visibility approximation, not a learned world-dynamics model or a unified graphics network. Training uses 73,728 exact ray labels from 48 procedural scenes. Validation and first test sets each use eight disjoint scenes and 12,288 rays. Weights are selected by validation loss only. The independent follow-up renderer scenes use a further disjoint ID range. No external model or image dataset is required.
+
+Test Brier loss is 0.183449, compared with 0.231951 for a constant equal to training-set mean visibility. The model was trained for 40 epochs; epoch 3 was selected. Later epochs overfit. NumPy inference differs from PyTorch by at most 1.19e-07 on the checked test set. Training took 1.922 seconds in this CPU environment; this is not a general training-time prediction.
+
+![Recorded validation loss. Later optimization worsens generalization, and the selected checkpoint precedes that overfitting.](figures/training_curve.png){width=75%}
+
+## 29.5 E8: a physical ray benchmark
+
+The scene consists of Lambertian point receivers on a floor, three opaque sphere occluders and 36 finite point emitters. A physical shadow ray is a segment/sphere intersection test. Current unoccluded contributions use analytic cosine, inverse-square attenuation, material color and emitter intensity. The full 36-term sum is an exact reference for this scene model; it is not a converged multi-bounce path-traced game reference. The high-frequency floor texture is known to the engine, not recovered by super resolution.
+
+There are 2,048 canonical receiver cells, a moving 16 by 20 receiver viewport, eight held-out scenes, three sampling replicates, and two fresh shadow rays per receiver per frame. The sequence has four cold frames, sixteen warm frames, a 500-tick interval with no observations of these receivers, eight revisit frames, eight relight/material-color frames, and eight hidden-geometry-change frames. The clock gap is **not 500 fully rendered frames**. The earlier atlas E1 supplies a different 500-observed-frame diversion experiment.
+
+Every method receives the same allowed engine geometry and physical ray budget. Ground-truth tables are generated in an offline audit path and never supplied to the online sampling policy. Except for the active proposal, the algorithms use the same known unoccluded-light importance distribution and paired uniform random draws. References and neural-feature preparation are excluded from per-batch timing and identified separately. These are equal-ray comparisons, not equal-VRAM, equal-FLOP, equal-latency or production-baseline comparisons.
+
+All entries below are conditional expected linear-RGB MSE, averaged over receivers, channels, frames, replicates and scenes. For corrected estimators the conditional MSE is enumerated exactly using R2, after the online estimate is produced; the plug-in row is its actual squared bias. Independent observed sample MSE is also recorded in CSV.
+
+| Method | Cold | Warm | Revisit | Relight | Hidden change |
+|:--|--:|--:|--:|--:|--:|
+| Raw importance | 0.004162 | 0.004162 | 0.004162 | 0.009814 | 0.009575 |
+| Neural CV | 0.003797 | 0.003797 | 0.003797 | 0.006035 | 0.002487 |
+| Constant world CV | 0.003878 | 0.002617 | 0.001497 | 0.001634 | 0.007572 |
+| Screen CV | 0.003604 | 0.002534 | 0.003371 | 0.003893 | 0.005485 |
+| World CV | 0.003604 | 0.002413 | 0.001370 | 0.001474 | 0.007301 |
+| Active world CV | 0.003201 | 0.000916 | 0.000074 | 0.000061 | 0.013077 |
+| World plug-in | 0.002478 | 0.000957 | 0.000283 | 0.000223 | 0.004943 |
+
+
+The first protocol was fixed before its first benchmark run. The original adverse result is retained. Percentile 95% intervals below resample eight scene clusters, preserving within-scene replicates; they characterize this small generator, not arbitrary games.
+
+| Comparison | Expected MSE reduction | 95% scene interval |
+|:--|--:|--:|
+| World CV vs Screen CV, revisit | 59.36% | [52.74%, 63.06%] |
+| World CV vs Raw importance, revisit | 67.08% | [59.17%, 72.62%] |
+| Active world CV vs World CV, hidden_change | -79.11% | [-86.20%, -70.75%] |
+| World CV vs Screen CV, hidden_change | -33.12% | [-39.91%, -24.66%] |
+| World CV vs Constant world CV, revisit | 8.46% | [-10.12%, 27.65%] |
+
+
+A negative reduction means a regression. The 8.46% neural-prior advantage over constant-prior world memory on revisit has an interval spanning zero. The study therefore does not establish that a neural component is necessary for most of the persistence gain. The uncorrected plug-in often has lower finite-sample MSE than the unbiased estimator; its bias guarantee is weaker. Unbiasedness is an explicit contract, not a promise of the best display image at two samples.
+
+![Actual first-study samples. Each row shows the same scene, receiver grid and exposure. Previews clip signed values and apply gamma; quantitative metrics use raw linear values.](figures/physical_frames.png){width=98%}
+
+## 29.6 E9: an independent correction experiment
+
+The initial result exposed severe overconfidence: active sampling largely ignores previously learned terms, so changed occluders can move residuals into directions with little sampling probability. The ten-percent proposal floor preserves unbiasedness but does not prevent a variance spike. We added one observation-driven rule: if a fresh exact visibility sample contradicts trusted memory, revoke its trust epoch globally before the next batch. Stored values remain fallible controls. The first surprise frame is necessarily unchanged.
+
+This follow-up uses new scenes 300-307 and new sampling seeds, with no weight retraining, no geometry-change notification and no access to the reference in the policy. Its protocol was frozen after diagnosing the first study and before running the follow-up. It is an independent scene split within the same scene family, not a completely independent replication.
+
+| Hidden-change comparison | Expected MSE reduction | 95% scene interval |
+|:--|--:|--:|
+| Guarded active vs Active world CV | 46.61% | [43.98%, 50.89%] |
+| Guarded active vs World CV | 7.12% | [2.67%, 12.28%] |
+| Guarded active vs Raw importance | 59.39% | [40.55%, 77.24%] |
+| Guarded active vs Screen CV | -8.53% | [-23.24%, 6.53%] |
+
+
+The guard reduces the unguarded active failure by 46.61% in this follow-up. It still has 8.53% higher mean error than screen history over the full hidden-change interval, with an interval crossing zero. There is no uniform dominance claim. The first surprise frame is included in every aggregate; by later frames the guard reacquires more appropriate evidence.
+
+![Ray-matched physical results. Revisit and hidden-change panels use different scene splits. The displayed intervals concern small procedural scene collections.](figures/physical_results.png){width=98%}
+
+![Recorded response after an unannounced change. The guarded and unguarded active curves start identically because the first contradiction has not yet been observed.](figures/change_recovery.png){width=90%}
+
+The two physical studies produced 12,672 frame-method records and 8,110,080 online shadow-ray calls in total. Training/validation/test labels and offline reference enumeration are additional, separately scoped work. Runtime memory per persistent method is 589,824 bytes (0.5625 MiB) for this tiny 2,048-receiver scene. Twenty-eight new contract/oracle tests and fourteen retained foundational tests pass.
+
+**What has advanced:** an actual trained prior, a physical oracle, causal world memory, a residual-correction API, an active controller, observed contradiction handling, and independently split diagnostic evidence now exist. **What remains unvalidated:** joint SR/RR/FG, general path transport, chronoscopic/counterfactual training, game integrations, calibrated neural uncertainty, matched-time superiority and GPU feasibility.

docs/RELEASE_SCOPE.md

@@ -0,0 +1,25 @@
+# Current v3 scope
+
+This is a reproducible finite-light CPU research reference for Certified Innovation Rendering.
+It adds conservative validity domains to stored visibility facts and eliminates their residual
+sampling support. It contains six new self-contained mathematical arguments and two new
+held-out protocols. The broader standalone architecture and v1/v2 evidence remain available.
+
+**Proved under stated assumptions:** matrix covariance contraction for exact partial evidence;
+causal sequential estimation; real-arithmetic sphere/segment validity; finite-domain query
+count; deterministic direct-light enclosure; a counterexample to universal variance dominance
+for arbitrary predictions. None is labeled a historically first theorem.
+
+**Executed:** twenty new procedural scenes; 58 new and retained tests; motion, spatial and
+known-time query studies; raw results; a portable CPU API; one retained trained visibility prior.
+
+**Estimated:** 68% broader maturity, per-area status and all GPU engineering budgets. These
+are subjective or derived quantities, not measured production capability.
+
+**Not established:** full SR/RR/FG, game integration, end-to-end speedup, full transport,
+formal floating-point certificates, hidden-event recovery without evidence, optimal future
+sampling, cross-game generalization, novel fundamental probability theory or independent replication.
+
+Visibility caching and kinetic certificates are prior art. The contribution candidate is their
+explicit common-state, validity and output-estimation interface. Current root metadata and
+results_v3 govern the release; history/v2 and legacy documents retain historical claims.

docs/RESIDUAL_THEORY.md

@@ -0,0 +1,104 @@
+## 19.4 Proposition P11: frozen physical correction (Proved)
+
+For a fixed simulation snapshot and output receiver, let $f_j\in\mathbb R^d$ be the physical contribution of term $j\in\{1,\ldots,K\}$, including its integration weight. The desired linear signal is $I=\sum_j f_j$. Let $\mathcal H$ contain all earlier evidence and chosen controls. Select an $\mathcal H$-measurable predictor $h_j$ and strictly positive categorical probabilities $q_j$ summing to one. Freeze them before drawing $J_1,\ldots,J_n$ independently from $q$, for a positive sample count fixed conditional on $\mathcal H$. Define
+
+$$H=\sum_j h_j,\qquad
+\widehat I=H+\frac1n\sum_{s=1}^n\frac{f_{J_s}-h_{J_s}}{q_{J_s}}. \tag{R1}$$
+
+Then $\mathbb E[\widehat I\mid\mathcal H,f]=I$. For a positive semidefinite output metric $Q$, its conditional quadratic risk is
+
+$$\mathbb E[\|\widehat I-I\|_Q^2\mid\mathcal H,f]
+=\frac1n\left[\sum_j\frac{\|f_j-h_j\|_Q^2}{q_j}
+-\left\|\sum_j(f_j-h_j)\right\|_Q^2\right]. \tag{R2}$$
+
+**Proof.** One sampled residual has expectation $\sum_j(f_j-h_j)=I-H$. Adding $H$ proves unbiasedness. The covariance of the independent sample mean is the one-sample covariance divided by $n$; expanding its $Q$-weighted trace gives R2. No correctness assumption on $h$ was used. $\square$
+
+Thus the predictor may come from stale world memory, a poorly generalized network, compressed coefficients, or an imperfect teacher. Under this contract its error changes variance, rather than creating a nonzero conditional mean error in the *linear corrected output*. This is classical control-variate mathematics [R16], implemented here as a persistent-memory contract. It is not a first discovery of unbiased neural rendering.
+
+The conditional formulation permits adaptation between frames. Each next snapshot may depend on all earlier physical samples. It does not permit using the current batch to refit $h$ and then pretending that this refitted predictor preceded the same batch. In a two-term example, fitting only the sampled term exactly and setting the other term to zero makes the residual vanish; the mean output becomes half the true integral. The supplied counterexample test catches this error.
+
+**Exact integration is essential.** If an independent decoder provides $\widetilde H$ instead of the actual $H=\sum_jh_j$, then
+
+$$\mathbb E[\widehat I-I\mid\mathcal H,f]=\widetilde H-H. \tag{R3}$$
+
+More residual rays do not remove this integration bias. A generic neural radiance prediction paired with an unrelated learned integral is not a valid implementation of R1. Integrable architectures, exact finite sums, or correctly constructed auxiliary estimators are needed. Automatic-integration control variates already investigate such architectures [R18]. Here the reference uses an exact sum over 36 finite point emitters. It is unbiased for that physical finite-emitter scene, not automatically for an area emitter approximated by quadrature.
+
+The formula extends in expectation to an unbiased noisy physical oracle under correct conditional sampling, but R2 must then include its additional conditional noise covariance and any cross-sample correlations. The executable variance routine intentionally covers deterministic finite terms only. The supplied oracle evaluates exact binary visibility and analytic unoccluded direct-light contributions.
+
+**Limits.** Unbiasedness does not imply low noise, nonnegative sample outputs, correct individual images, calibrated neural confidence, or an advantage over a biased denoiser in MSE. With $f=(0,1)$, $h=(1,0)$ and $q=(1/2,1/2)$, one sample gives either $-1$ or $3$, each with probability one half. Their mean is $1$; clipping negatives changes the mean to $1.5$. All quantitative results therefore use unclipped linear RGB. Preview images explicitly clip and apply gamma. A downstream nonlinear SR or FG decoder does not inherit R1 without its own physical estimator construction.
+
+## 19.5 Proposition P12: residual-risk information value (Proved)
+
+The relevant memory value depends on how its outputs will be used. Suppose scalar response variables $x_j$ generate vector contributions $f_j=c_jx_j$, and the control uses the *true conditional posterior mean* $m_j$. Let $C=[c_1,\ldots,c_K]$, $P=\operatorname{Cov}(x\mid\mathcal H)$, and define
+
+$$G(C,q,Q,n)=\frac1n\left[
+\operatorname{diag}\left(\frac{c_j^TQc_j}{q_j}\right)-C^TQC\right]. \tag{R4}$$
+
+Then $G\succeq0$ and the posterior-averaged corrected-estimator risk equals $\operatorname{tr}(GP)$.
+
+**Proof.** Substitute $f_j-h_j=c_j(x_j-m_j)$ into R2 and take the conditional expectation over $x$. The first term becomes the trace of the diagonal matrix in R4 times $P$; the second becomes $\operatorname{tr}(C^TQCP)$. For any vector $a$, the quadratic form $a^TGa$ is the variance of the vector random variable $c_Ja_J/q_J$, measured by $Q$ and divided by $n$, so it is nonnegative. Equivalently, apply weighted Cauchy-Schwarz with $\sum_jq_j=1$. $\square$
+
+For declared future linear response dynamics $x_\tau=\Phi_\tau x+\xi_\tau$, fixed future readouts/proposals, and process noise independent of the current state and of the proposed new observation, the part of future residual risk affected by current information uses
+
+$$G_{\rm future}=\sum_\tau w_\tau\Phi_\tau^TG_\tau\Phi_\tau. \tag{R5}$$
+
+Independent future process noise adds a term unaffected by the current observation. If a fresh scalar observation is $o=a^Tx+\epsilon$ in a correctly specified Gaussian model with independent variance $r>0$, then its exact one-step reduction in this future risk is
+
+$$V_{\rm residual}(a)
+=\frac{a^TPG_{\rm future}Pa}{r+a^TPa}. \tag{R6}$$
+
+**Derivation.** Gaussian conditioning gives $P^+=P-Paa^TP/(r+a^TPa)$. Evaluate $\operatorname{tr}[G_{\rm future}(P-P^+)]$. This is the same estimation identity as P4, but with the output contract's actual residual-risk matrix. It does not require a newly invented information theory.
+
+This distinction matters. For a plug-in image estimate the metric is $C^TQC$; for a physically corrected estimator it is R4. Retention, compression, and query allocation should target the relevant metric, or a declared weighted combination if both readout types are used. A predictor trained only to match image means can leave expensive residual variation across physical sample terms.
+
+No claim of a universal long-horizon optimum follows. If future queries, visibility, trajectories or proposals change as a result of today's sample, the fixed-metric derivation no longer gives the full closed-loop value. Bellman value or a justified approximation is required. The implemented active policy uses a simple uncertainty heuristic with a positive exploration floor; it does not implement R6 as an exact physical posterior controller.
+
+There is also no sample-by-sample monotonicity theorem. For fixed $f=(1,1)$ and uniform sampling, $h=(0,0)$ already yields zero variance. Learning only the first term exactly changes $h$ to $(1,0)$ and raises one-sample variance to $1$. More accurate integrand values do not automatically lower *realized* control-variate variance. R6 is an expected posterior statement under its declared model.
+
+## 19.6 Proposition P13: the estimator-equivalence quotient (Proved)
+
+For a fixed positive proposal $q$, two controls $h$ and $h'$ yield identical R1 outputs for every possible sample sequence and every physical $f$ if and only if there exists one vector $a\in\mathbb R^d$ such that
+
+$$h'_j-h_j=q_j a\qquad\text{for every }j. \tag{R7}$$
+
+**Proof.** If R7 holds, the integrated control increases by $a$, while every sampled residual decreases by $a$. They cancel pathwise, not merely in expectation. Conversely, consider a possible sequence in which all $n$ samples equal an arbitrary $j$; it has positive probability. Writing $\delta H=\sum_k(h'_k-h_k)$, equality of outputs implies $\delta H-(h'_j-h_j)/q_j=0$. Thus R7 holds with $a=\delta H$ for every $j$. $\square$
+
+Every class has a unique zero-sum representative
+
+$$h_j^\circ=h_j-q_jH,\qquad \sum_jh_j^\circ=0. \tag{R8}$$
+
+Among unrestricted controls for this fixed receiver/proposal, the estimator therefore depends on $d(K-1)$ rather than $dK$ degrees of freedom. It responds to *centered sampling variation*, not to every component of the cached prediction. This is the familiar centered-control-variate nullspace expressed as an exact rendering-state quotient. Its use here is an architecture criterion: discard only directions proved irrelevant to the actual output and update contract.
+
+This is not a general compression breakthrough by itself. Removing one mode from 36 terms is small, and other low-rank savings remain empirical. A pure neural preview still needs the integrated prediction. More importantly, the equivalence depends on $q$: if two distinct normalized positive proposals must share exactly the same unmodified representation, their one-dimensional scalar nullspaces intersect only at zero. A mode harmless under today's proposal may matter after tomorrow's adaptive sampling change. Either retain sufficient state for those changes or recompute the action-dependent representation. R7 cannot justify deleting modes permanently from an arbitrary query-closed world belief.
+
+An immediately testable research extension is a multi-task, integrable basis whose expensive modes are retained by R4/R5 and whose known null directions are eliminated. This could reduce shared decoding and correction cost. Neither a universal learned basis nor GPU acceleration from this idea has been demonstrated here.
+
+## 19.7 Proposition P14: limited detection-delay bound (Proved)
+
+Suppose a stored deterministic physical fact has become false, it is eligible for a fresh query, and each successive trial has conditional probability at least $\alpha>0$ of returning a contradictory trusted observation, given all prior misses. Then the probability of no detection after $N$ trials is at most $(1-\alpha)^N$, and the expected number of trials to first detection is at most $1/\alpha$.
+
+**Proof.** If $A_N$ is the event of no contradiction in the first $N$ trials, then $P(A_N)\leq(1-\alpha)P(A_{N-1})$ by conditioning on prior misses. Induction proves the tail bound. Summing $P(T>N)$ for $N\geq0$ gives the expectation bound. Independence beyond the stated conditional probability bound is not required. $\square$
+
+The active policy mixes ten percent uniform exploration into its proposal, so each term of an actually queried receiver has probability at least $0.1/K$ per draw. This gives a conservative bound only when a changed, previously trusted term at that receiver remains queryable. A never-visited receiver, undetectable difference, noisy ambiguity, or unbounded arrival of new changes can defeat a useful global guarantee. This bound says nothing about the error magnitude before detection.
+
+The executable guard checks trusted binary visibility after each batch. A contradiction revokes the entire memory's current trust epoch, retains values as fallible predictors, and accepts current observations in the new epoch. The next batch then explores invalidated terms. Global invalidation is intentionally conservative; a dependency graph could localize it, but is not implemented. No oracle change flag or future state is supplied in the hidden-change experiment. The guard cannot revise the sampling decision or output that preceded the contradiction.
+
+## 19.8 Proposition P15: a fixed-budget confidence bound (Proved)
+
+Assume the R1 conditions and known deterministic physical bounds $0\leq f_{jc}\leq b_{jc}$ for each channel $c$. Define
+
+$$\ell_c=\min_j\frac{-h_{jc}}{q_j},\qquad
+u_c=\max_j\frac{b_{jc}-h_{jc}}{q_j}. \tag{R9}$$
+
+For $d$ channels and $0<\delta<1$, all channels simultaneously satisfy
+
+$$|\widehat I_c-I_c|\leq(u_c-\ell_c)
+\sqrt{\frac{\log(2d/\delta)}{2n}} \tag{R10}$$
+
+with conditional probability at least $1-\delta$.
+
+**Proof.** Each sampled channel residual lies in $[\ell_c,u_c]$. Hoeffding's inequality bounds either tail of its sample mean by $\exp[-2n\epsilon_c^2/(u_c-\ell_c)^2]$. Substitute R10 and union bound over the two tails and $d$ channels. The deterministic integrated control adds no random error. $\square$
+
+For $P$ receivers, use failure budget $\delta/P$ per receiver for a frame-wide union bound; independence between receivers is unnecessary for that union bound. R10 requires fixed $n$. Inspecting bounds repeatedly and stopping at the first acceptable one needs an anytime-valid construction or a correctly allocated error budget. Unbounded path weights and stochastic radiance without valid bounds violate this premise.
+
+This is a conservative classical concentration bound, not a calibrated uncertainty result for the neural prior. At two shadow rays its radius is usually too large for a useful real-time quality certificate. The executable routine and an enumerated coverage test make the distinction explicit. Practical tight risk control remains research work.

experiments.json

@@ -0,0 +1,18 @@
+{
+  "protocol_version": "2.0.0",
+  "frozen_before_first_benchmark_run": true,
+  "scene_ids": [200, 201, 202, 203, 204, 205, 206, 207],
+  "replicate_seeds": [3101, 3102, 3103],
+  "receiver_grid": [32, 64],
+  "viewport": [16, 20],
+  "emitter_grid_side": 6,
+  "rays_per_receiver_per_frame": 2,
+  "phases": {"cold": 4, "warm": 16, "revisit": 8, "relight": 8, "hidden_change": 8},
+  "unseen_ticks_before_revisit": 500,
+  "unseen_tick_semantics": "No observations of these receivers. This is a clock gap, not 500 fully rendered frames.",
+  "methods": ["raw_importance", "neural_cv", "constant_world_cv", "screen_cv", "world_cv", "world_active_cv", "world_plugin"],
+  "primary_comparison": "world_cv versus screen_cv expected per-channel MSE in revisit phase, equal physical ray count",
+  "secondary_comparisons": ["world_cv versus raw_importance", "world_active_cv versus world_cv", "world_cv versus constant_world_cv", "world_cv versus world_plugin in hidden_change phase"],
+  "reporting": "All methods and phases, including regressions; scene-cluster bootstrap 95% intervals; no GPU/FPS inference",
+  "scope": "Direct illumination of point receivers by finite point emitters behind sphere occluders"
+}

experiments_followup.json

@@ -0,0 +1,18 @@
+{
+  "protocol_version": "2.0.0-followup",
+  "reason": "The first run exposed an active-sampling regression after unannounced geometry changes. Evaluate observation-triggered trust revocation on a disjoint scene split.",
+  "frozen_before_followup_run": true,
+  "scene_ids": [300, 301, 302, 303, 304, 305, 306, 307],
+  "replicate_seeds": [4101, 4102, 4103],
+  "receiver_grid": [32, 64],
+  "viewport": [16, 20],
+  "emitter_grid_side": 6,
+  "rays_per_receiver_per_frame": 2,
+  "phases": {"cold": 4, "warm": 16, "revisit": 8, "relight": 8, "hidden_change": 8},
+  "unseen_ticks_before_revisit": 500,
+  "unseen_tick_semantics": "No observations of these receivers. This is a clock gap, not 500 fully rendered frames.",
+  "methods": ["raw_importance", "screen_cv", "world_cv", "world_active_cv", "world_guarded_cv"],
+  "primary_comparison": "world_guarded_cv versus world_active_cv expected MSE in hidden_change phase",
+  "reporting": "Include first surprise frame and all later frames. No oracle change flag. Observe conflict after correcting current output; revoke all trust for next output.",
+  "scope": "Follow-up on independent scenes; same renderer family, neural weights, ray budget and material/light setup"
+}

experiments_innovation.json

@@ -0,0 +1,18 @@
+{
+  "protocol_version": "3.0.0-innovation",
+  "frozen_before_first_run": true,
+  "scene_ids": [400,401,402,403,404,405,406,407,408,409,410,411],
+  "replicate_seeds": [5101,5102,5103],
+  "receiver_grid": [32,64],
+  "viewport": [16,20],
+  "emitter_grid_side": 6,
+  "maximum_rays_per_receiver_per_frame": 2,
+  "phases": {"cold":4,"warm":20,"revisit":8,"relight":8,"smooth_motion":16,"jump":8,"return":8},
+  "unobserved_clock_gap": 500,
+  "methods": ["raw_importance","v2_guarded","epoch_eliminate","certificate_iid","certificate_eliminate","constant_certificate","unsafe_eliminate"],
+  "primary_comparison": "certificate_eliminate versus epoch_eliminate conditional expected MSE in smooth_motion",
+  "secondary": ["revisit ray count", "jump and return MSE including first frame", "certificate_iid versus sequential elimination", "constant-prior ablation", "invalid certificate audit", "CPU batch cost and memory"],
+  "fairness": "Same scene state and maximum physical-ray budget, not matched total time or VRAM. All methods may observe current geometry. Epoch baseline detects any geometry change. Prior is the frozen v2 prior for the initial scene, with no retraining.",
+  "scope": "Known geometry motion replaces the v2 hidden-event protocol. No claim to solve unobservable changes. Float64 certificates have a 1e-9 clearance guard; the kernel is not formally verified.",
+  "sampling": "Base proposal fixed from analytic unoccluded contributions and initial neural prior; restrict and renormalize over unknown terms. Sequential estimator averages two conditionally unbiased martingale estimates, except deterministic exact completion. Unused rays are reported, not reassigned."
+}