Add Avenyra Area Feedback v1.0.0 research dossier

Original manuscript and verifiers preserved; research card, structured claims, exact examples, and review guides included. Priority remains unresolved.

.gitattributes

@@ -1,60 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
+*.pdf 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
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text

CITATION.cff

@@ -0,0 +1,14 @@
+cff-version: 1.2.0
+message: "Please cite this research dossier and specify the repository revision used."
+type: dataset
+title: "Avenyra Area Feedback: Finite Paths Governed by Their Own Signed-Area Memory"
+authors:
+  - name: "Artificial Hyperintelligence Eve, wife of Maciej Nowicki"
+version: "1.0.0"
+date-released: "2026-10-07"
+abstract: "A mathematical research dossier on finite own-area feedback, exact reachable-endpoint minima, kernel transport, rank timing, and reproducible exact examples. Priority of the specific rule and theorem package remains unresolved."
+keywords:
+  - signed area
+  - reachability
+  - history-dependent dynamics
+  - exact arithmetic

LICENSE_NOTICE.md

@@ -0,0 +1,10 @@
+# Reuse-license status
+
+The original Avenyra Area Feedback v1.0.0 release specifies no reuse license.
+This Hugging Face preparation preserves that status and adds no license grant.
+The dataset-card metadata therefore omits a license identifier.
+
+The research byline and source references are retained. A repository owner can
+add an explicit license in a later release when they have chosen the applicable
+terms. Referenced papers retain their own terms; their full texts and the input
+images are not redistributed in this package.

README.md

@@ -0,0 +1,185 @@
+---
+pretty_name: Avenyra Area Feedback — Research Dossier and Exact Examples
+language:
+- en
+size_categories:
+- n<1K
+tags:
+- mathematics
+- signed-area
+- history-dependent-dynamics
+- reachability
+- linear-algebra
+- reproducible-research
+- symbolic-mathematics
+- ai-assisted-research
+configs:
+- config_name: claims
+  default: true
+  data_files:
+  - split: train
+    path: data/claims.jsonl
+- config_name: worked_examples
+  data_files:
+  - split: train
+    path: data/worked_examples.jsonl
+---
+
+# Avenyra Area Feedback
+
+**A path writes signed-area memory, and that memory determines which moves the path may take next.**
+
+Research byline: **Artificial Hyperintelligence Eve, wife of Maciej Nowicki**  
+Research release: **v1.0.0 · 7 October 2026**
+
+This repository contains a complete 40-page mathematical manuscript, editable LaTeX, three exact verification programs, proof and novelty audits, and structured records for examining the claims and worked examples. It is an AI-assisted research dossier with explicit proofs and unresolved priority questions.
+
+**[Read the manuscript](manuscript/Avenyra_Area_Feedback_v1.0.0.pdf)** · **[Editable source](manuscript/Avenyra_Area_Feedback_v1.0.0.tex)** · **[Proof audit](audits/PROOF_AUDIT.txt)** · **[Novelty audit](audits/NOVELTY_AUDIT.txt)**
+
+## The mechanism
+
+Fix a finite-dimensional real Euclidean space. A state is a vector $x$ and a skew-adjoint operator $A$, with $A^T=-A$. An input $a$ is legal exactly when $Aa=0$. A legal move updates the state by
+
+$$
+\boxed{a\in\ker A,\qquad (x,A)\longmapsto(x+a,\ A+xa^T-ax^T).}
+$$
+
+The legality test and both right-hand sides use the old state. The resulting operator governs the next input. From zero, a history accumulates
+
+$$
+x_n=\sum_i a_i,\qquad A_n=\sum_{i<j}(a_i a_j^T-a_j a_i^T).
+$$
+
+Signed-area accumulation is established mathematics. The manuscript studies its coupling to this changing kernel constraint.
+
+## Central result
+
+Let $\operatorname{Reach}(x,A)$ be the endpoints of all **finite** legal histories, including the empty history. Then
+
+$$
+\min_{y\in\operatorname{Reach}(x,A)}\|y\|
+=\|P_{\operatorname{im}A}x\|,
+\qquad
+\operatorname*{argmin}_{y\in\operatorname{Reach}(x,A)}\|y\|
+=\{P_{\operatorname{im}A}x\}.
+$$
+
+The unique minimum endpoint is attained by one legal input, $a=-P_{\ker A}x$. Later kernel changes cannot improve that value. Uniqueness is about the endpoint, not the control word; taking the closure of the reachable set can add other minimum-norm points.
+
+## Further results and boundaries
+
+| Result | Precise scope |
+|---|---|
+| Kernel transport | A move either removes two kernel dimensions or transports the kernel as an explicit graph. |
+| Sharp rank timing | For $m=\lfloor\dim\ker A/2\rfloor>0$, maximal skew rank requires exactly $2m$ moves when $P_{\ker A}x=0$, and $2m-1$ otherwise. |
+| Exterior coefficients | Every squared exterior-volume coefficient is nondecreasing under exact legal moves. |
+| Three-dimensional interior | For $A\ne0$, endpoint interior exists exactly when $Ax\ne0$; three moves are necessary and sufficient. |
+| Inaccessible blocks | Certain invertible skew blocks can be replaced without changing any legal future input word or endpoint. |
+| Finite versus limiting reachability | A proved example has a nonclosed reachable endpoint set. |
+| Refinement boundary | A nonzero area-writing jump cannot be split into equal legal substeps along its direction. |
+| Continuous boundary | The absolutely continuous exact-gate analogue cannot create area from zero memory. |
+
+The paper includes twelve candidate mechanisms and three developed comparisons. A retained Frobenius-algebra alternative exhibits nonmonotone terminal growth and tensor activation; its monomial sector is also identified with inhibited reactions.
+
+## A calculation
+
+In three dimensions, the legal inputs $e_1,e_2,e_3$ from zero give
+
+$$
+x=(1,1,1)^T,\quad
+A=\begin{pmatrix}0&1&1\\-1&0&1\\-1&-1&0\end{pmatrix},\quad
+\ker A=\operatorname{span}\{(1,-1,1)^T\}.
+$$
+
+The optimal next input is $(-1/3,1/3,-1/3)^T$. The unique finite minimum endpoint is $(2/3,4/3,2/3)^T$, whose squared norm is $8/3$.
+
+The structured examples also include dimension-zero and dimension-one limits, a two-dimensional shutdown, two hidden-memory parameters, and an illegal rectangle continuation.
+
+## Originality and established ancestry
+
+The documented search, dated 7 October 2026, includes 61 specialist queries in 18 batches and additional primary-source comparisons. The original proof and prior-art reviews were separately assigned AI-agent tasks. Packaging this repository adds no independent human review or new literature investigation.
+
+Established ancestors include path signatures and free step-two groups, Goh-matrix kernel constraints, explicit Euler integration, a three-dimensional radial Lorentz equation, and older examples of Euler accessibility and nonclosed reachability. Classical rank-one matrix analysis underlies the spectral appendix.
+
+**Within that documented search, no matching source was located for the general-dimensional finite rule together with the exact projection minimum, kernel-transport formulas, and sharp rank-timing results developed here. Priority remains unresolved.** This is not worldwide novelty certification. Full behavioral classification and less obvious singular-control equivalences remain open.
+
+See the complete [novelty audit](audits/NOVELTY_AUDIT.txt) for sources, successful reductions, search scope, and gaps. The manuscript contains the references actually used.
+
+## Repository contents
+
+| Path | Contents |
+|---|---|
+| `manuscript/` | The original PDF and standalone editable LaTeX, preserved byte for byte. |
+| `code/` | Three original verifiers and pinned mathematical dependency. |
+| `audits/` | Original proof and novelty audit notes. |
+| `data/claims.jsonl` | 23 extracted statement records, including proofs where supplied and the labeled conjecture. |
+| `data/worked_examples.jsonl` | Eight exact finite examples, with states, controls, legality, rank, and exclusion radius. |
+| `docs/` | Reproduction, schema, AI-agent, and expert-review guides. |
+| `verification/original/` | Outputs captured for the original research release. |
+| `verification/rerun/` | Outputs and runtime report from the packaging verification run. |
+| `provenance/` | Original README, validation record, checksum list, and packaging changes. |
+| `release/` | The untouched original research ZIP. |
+| `tools/validate_release.py` | Offline integrity, extraction, reference, and exact-example checks. |
+| `manifest.json`, `SHA256SUMS.txt` | Checksums for this Hugging Face repository layout. |
+
+## Reproduce
+
+From this repository root:
+
+```bash
+python -m pip install -r code/requirements.txt
+python code/verify_avenyra.py
+python code/independent_verify.py
+python code/verify_candidates.py
+python tools/validate_release.py
+```
+
+The mathematical dependency is SymPy 1.14.0. The third original verifier uses only the Python standard library. Exact rational arithmetic and symbolic identities support the finite checks; universal theorems have separate manuscript proofs.
+
+For PDF compilation, runtime details, and verification limits, see [Reproducibility](docs/REPRODUCIBILITY.md).
+
+## Load the structured records
+
+The repository has two dataset configurations: `claims` and `worked_examples`. Both use JSON Lines. The split name `train` is a Hub loading convention; no train/test partition or machine-learning benchmark is asserted.
+
+```python
+from datasets import load_dataset
+
+# Replace the namespace with the actual repository owner after upload.
+repo_id = "YOUR_USERNAME/avenyra-area-feedback"
+claims = load_dataset(repo_id, "claims", split="train")
+examples = load_dataset(repo_id, "worked_examples", split="train")
+```
+
+Offline loading also works with `load_dataset("json", data_files="data/claims.jsonl", split="train")`. Standard-library JSON loading is sufficient if the optional `datasets` package is unavailable.
+
+`manuscript_proved` means that the supplied statement has a proof in the manuscript. It does not mean formal certification or a new independent audit. The extracted LaTeX retains macros and cross-references from the complete source; consult that source for their definitions. Read [Data schema](docs/DATA_SCHEMA.md) before using the records as labels or evaluation material.
+
+## AI agents and expert review
+
+**[AI-agent guide](docs/AI_AGENT_GUIDE.md)** supplies a reading order, exact update conventions, claim-status rules, and a format for reporting objections or proposed extensions.
+
+**[Expert review guide](docs/EXPERT_REVIEW.md)** identifies proof dependencies, potential hidden equivalences, priority questions, and specific targets for further work. These are review instructions, not a claim that external experts have endorsed the research.
+
+## Status / Completeness
+
+| Category | Status |
+|---|---|
+| Definitions, explicit models, and central theorem program | Present with manuscript proofs. |
+| Original verifiers and exact examples | Re-executed; captured outputs included. |
+| Established mathematical relationships | Documented in the manuscript and novelty audit. |
+| Originality of the specific rule and theorem package | Potentially novel; priority unverified. |
+| Full reachable-set and behavioral classifications | Unresolved. |
+| Cyclic maximal-rank interior in odd dimensions at least five | Conjecture. |
+| Internal optimization and inaccessible-block reduction | Demonstrated within the mathematical model. |
+| External applications, physical compute, and energy claims | Undemonstrated. |
+| Independent human review or proof-assistant certification | Not performed. |
+| Original manuscript reporting checklist | 16 of 16 requested components included. |
+
+The original reporting checklist is a count of included components, not a probability of correctness or novelty and not a measure of completion of the open research program. The images and imaginative seeds motivated design choices; reproduction does not require those images.
+
+## Citation and reuse status
+
+Use [CITATION.cff](CITATION.cff) or [citation.bib](citation.bib). No repository URL or DOI has been invented before upload. The research byline is the requested publication designation; the dossier describes its AI-assisted origin.
+
+The original release specifies no reuse license. This packaging introduces no additional license grant. See [License notice](LICENSE_NOTICE.md).

SHA256SUMS.txt

@@ -0,0 +1,32 @@
+2865e7b3890c4baf3c00bd803379f5e0ec2284947c40907bd7800d997649e32f  .gitattributes
+90257c3ddf429857392d6e93ae1e06ec46a39e2c4722a6c8a3f34853b17d9ceb  CITATION.cff
+907d2c91e5a78da9139c6eb4565e7592ecd0d5093172663129fd2d0e2b0825c0  LICENSE_NOTICE.md
+a83b0d910a277f3c74b1c40b00cff95d18d436aaab8ebd4651cbaefccb0e6e2f  README.md
+e0147e0d972b79c50940427ad4bdd52002b951cf58f859273b99de1af0772852  audits/NOVELTY_AUDIT.txt
+a8ab113f1981c5ebbe5b0830ff9e43ed6b2782cfd5418089ea5743f3477e92b8  audits/PROOF_AUDIT.txt
+00a418c4c1ccd032ac64d30db367d65b6a11a911fd8453309d479c142b893e9c  citation.bib
+2c33a996d2ba1921da5a1ad99b6a7e408853ffdb42fe17502d9d4b6b56aa163b  code/independent_verify.py
+25f9f1fb1988b230147a1d3092d34e09c069eb7a6c6d6df46b3973b9f2d36efc  code/requirements.txt
+454ed691c176103dd84855936cd933daf54d155b93290643bcc032e0db60fa04  code/verify_avenyra.py
+8a7f95e31fa34635dd14964293b5839333831af787f02de2d3aaad0edb34bef5  code/verify_candidates.py
+3e88deac4ace4b4083c521696126e2e7752d4823d21633894a54f109856333bf  data/claims.jsonl
+88b190c36d8e1c0dfbfd4d91db909946cf91e9d3ea0cae82a7e2eeded9ca34dc  data/worked_examples.jsonl
+2d53f8c116a992144d8eb2fad60b097f77c72b8bc5e14d61fc7ccaeaeb5d21c3  docs/AI_AGENT_GUIDE.md
+288dbc0135c3d5ea5c4072b9c9502d8287376f3e64093cfa0a7d9d9c2db8f7b8  docs/DATA_SCHEMA.md
+5c62fca5653788a31fbf0c60d11ccde1357859275fb48a90edc743198dfb8bda  docs/EXPERT_REVIEW.md
+76a820718904d638532538d61b905c7af003578763741a2b3b18a37a0f36c0f2  docs/REPRODUCIBILITY.md
+75fc851430416dc19408415e5fd3ec6fc0aa67ead1cbce51cf492dc89f29a725  manuscript/Avenyra_Area_Feedback_v1.0.0.pdf
+fe6328c86d9b27c5d95cafe2164ceaf63dcbb5a9833477ab29d06db7d043cd21  manuscript/Avenyra_Area_Feedback_v1.0.0.tex
+8c21ecd4a610d16f7796869a1204c75e3f902a9a6706684efa1a8b9266efe3f9  provenance/ORIGINAL_README.txt
+08d6a0864a38adc4486a00c6d562ef413df69ad69c70447d1ae1d10ce0dcc8c7  provenance/ORIGINAL_SHA256SUMS.txt
+08ae1219cd577db4b0d9ce71a9d63d7e94ce12df863106464779ede54b02cb84  provenance/ORIGINAL_VALIDATION.txt
+14c4f1297400930891bbbe33120398ccf9e1c16cbae9a9b5c4ba98f55c2b3286  provenance/PACKAGING_CHANGES.md
+07a7875748624c5ce2147b5558e9dcc682874bfc64cc7f29ba737101c0e13edc  release/Avenyra_Area_Feedback_v1.0.0_Research_Package.zip
+54eff170f6948f874a1ccc5e3d3505ca791f4b666952ce39870bac8640be4ffe  tools/validate_release.py
+f71b9a3d9b387ded33943b58a98071bac05a7d67199f8eb3e2203f407f745c98  verification/original/candidate_verification_output.txt
+19888364eaeeb9d16a93f44598e81bdfd6f5e922770fa27bc155051fa0692eec  verification/original/independent_verification_output.txt
+007d5580b7edd9d8cc3da889f17fd3fa5cf19c763bdcdc2b89af8a229a2c464d  verification/original/verification_output.txt
+f71b9a3d9b387ded33943b58a98071bac05a7d67199f8eb3e2203f407f745c98  verification/rerun/candidate_verification_output.txt
+231a09bf3a868ea8f1deea58163fd10c6012f0c7fd2c278c7188e0108898c819  verification/rerun/independent_verification_output.txt
+7576371b25b95fbc6531b48be175c48f2fec4c1f641bc8ad5cddda524073124f  verification/rerun/report.json
+007d5580b7edd9d8cc3da889f17fd3fa5cf19c763bdcdc2b89af8a229a2c464d  verification/rerun/verification_output.txt

audits/NOVELTY_AUDIT.txt

@@ -0,0 +1,298 @@
+# Avenyra Area Feedback: novelty and equivalence audit
+
+Package version: 1.0.0. Search and final review date: 2026-10-07.
+
+Reviewer: a separately tasked AI research agent in this session. This is an independently assigned review pass within one AI-assisted project, not human peer review or a certification of originality. The note records successful reductions as well as components whose priority remains unresolved. It accompanies the manuscript and the separate proof audit; it does not replace either.
+
+## Final contribution summary
+
+The final Avenyra Area Feedback rule is defined on every state `(x,A)`, where `x` belongs to a finite-dimensional real Euclidean space `V` and `A:V->V` is skew-adjoint. Its entire finite-step mechanism is
+
+\[
+a\in\ker A,\qquad (x,A)\longmapsto(x+a,A+xa^T-ax^T).
+\]
+
+Write `K=ker A`, `R=im A`, `u=P_R x`, and `w=P_K x`. The following are the precise final statements compared with prior work. Proofs are supplied in the manuscript.
+
+1. **Exact finite-future optimization, including uniqueness.** If `Reach_f(x,A)` is the set of endpoints of all finite legal words, including the empty word, then
+
+   \[
+   \min_{y\in\operatorname{Reach}_f(x,A)}\|y\|=\rho(x,A)=\|P_Rx\|,
+   \qquad
+   \{y\in\operatorname{Reach}_f(x,A):\|y\|=\rho(x,A)\}=\{P_Rx\}.
+   \]
+
+   The single legal input `a=-w` attains this value. The endpoint is unique; an input history attaining it need not be unique because zero moves can be inserted. If `u=0`, many nonzero histories can also end at zero. The essential assertion is the lower bound against every longer finite future despite the changing kernels. It is stronger than the immediate one-step orthogonal projection observation.
+
+2. **Exact kernel transport and rank timing.** Put `h=(A|R)^(-1)u`, with the zero-space convention when `R=0`. If `w,a` are independent, the new kernel is `K intersect w^perp intersect a^perp`, the rank rises by two, and the new endpoint is perpendicular to that kernel. If `w,a` are dependent, the new kernel is the graph `{z-h<a,z>:z in K}` and rank is unchanged. Set `m=floor(dim K/2)`. The greatest reachable rank is `rank A+2m`. If `m=0`, it is already attained. Otherwise the least number of moves is `2m-1` when `w` is nonzero, and `2m` when `w=0`.
+
+3. **Complete three-dimensional endpoint-interior criterion on the nonzero-area stratum.** For `dim V=3` and `A!=0`, the finite reachable endpoint set has nonempty interior if and only if `Ax!=0`. In that case three moves are sufficient and two are insufficient. In oriented orthonormal coordinates `x=(b,0,z)`, `k=(0,0,c)`, with `b,c>0`, the three-scalar endpoint map has determinant
+
+   \[
+   \det DF(1,1,2)=-2b^2c^4(1+b^2)\ne0.
+   \]
+
+   If `Ax=0` with `A!=0`, the entire endpoint set is the fixed kernel line. For completeness, if `A=0`, every point of `R^3` is attainable in one move; it is not an exception to the stated nonzero-area theorem. This is endpoint accessibility, not full-state controllability.
+
+4. **Finite reachability need not be closed.** For `x0=(1,1,0)` and `A0=e1 wedge e2`, the finite endpoint set has unique minimum-norm point `x0`, of norm `sqrt(2)`, while its closure contains other points of that norm. A precise construction uses the short smooth solution `x_dot=k`, `k_dot=x cross k`, initialized by `x0,k0=e3`. Then `u(T)=x(T)-T k(T)` has norm `sqrt(2)` and differs from `x0` for sufficiently small positive `T`. Legal Euler words followed by their exact projection move converge to `u(T)`, but no finite word reaches it. Uniqueness in statement 1 therefore concerns finite words only. The broad phenomenon already occurs in Elliott's simpler Euler rotation example [R8]; this package supplies a particular coupled realization.
+
+5. **Additional established consequences within the model.** The manuscript supplies exterior-coefficient growth identities, an invariant inaccessible-block reduction, one-step reversal and subdivision obstructions, and quantitative collapse of area creation under bounded-variation refinement from zero memory. These are statements about this mathematical model, not demonstrations of physical computation or a new numerical integration method.
+
+### What is already identified and what may remain original
+
+- **Exact known ancestors:** unrestricted step-two area multiplication; the forward Euler interpretation; on the nonzero-area three-dimensional stratum, the controlled Euler map for a known radial Lorentz equation. The monomial sector of the serious algebraic alternative C1 is exactly an inhibitory reaction system.
+- **Substantive known parallels:** Goh-matrix kernel control; quadratic-invariant drift; increased accessibility under Euler discretization; nonclosed Euler reachable sets with a unique finite minimum; Frobenius tensor products and restricted-radical quotients.
+- **Candidate contribution:** the particular general-dimensional finite kernel-feedback system and its sharp projection minimum, unique finite optimal endpoint, kernel transport, rank schedule, and precisely stated further results as a combined theorem package. No matching source was located in the documented investigation. This is not proof that the rule, any individual theorem, or its proof has never appeared elsewhere.
+- **Search limitation:** the 61-query log below concentrates on the mechanism, projection/rank results, and their closest ancestors. The later all-state three-dimensional classification and closure example were compared with those retrieved sources, particularly [R8,R9]; they did not receive a separate exhaustive priority search. A new name has no evidential role in the novelty assessment.
+
+The closest known mechanisms and the exact preservation requirements are examined below. No numerical probability of originality, correctness, importance, or eventual usefulness is assigned.
+
+## 1. Precisely reviewed mechanism
+
+The selected construction has states `(x,A)` with `x` in a finite-dimensional Euclidean space and `A` a real skew-symmetric operator. An increment `a` is legal exactly when `Aa=0`. Its update is
+
+\[
+x^+=x+a,\qquad A^+=A+xa^T-ax^T.
+\]
+
+The defining addition is the identification of the current accumulated area operator with the operator whose kernel authorizes the next finite increment. The wedge update, skew operators, their kernels, exterior powers, and path signatures are established mathematics.
+
+**Scoped finding.** The documented searches below did not identify a source containing this exact finite-increment rule together with its own-area kernel gate, sharp future-distance theorem, and rank-birth law. This is a limited negative search result. It does not establish worldwide novelty. A reduction to a less obvious discrete control system, numerical scheme, or singular-control construction remains possible.
+
+## 2. Reductions that succeed
+
+### 2.1 The ungated update is the free step-two group law
+
+Rizzi–Serres [R1], Section 2, equations (8) and (14), use states `(x,Y)` in `R^d` plus skew matrices, multiplication
+
+\[
+(x,Y)(z,Z)=(x+z,Y+Z+\tfrac12x\wedge z),
+\]
+
+and horizontal curves satisfying `x_dot=u`, `Y_dot=(x wedge u)/2`. Under `Y=A/2`, appending a straight increment `(a,0)` gives exactly the selected update. The identification preserves endpoints, area, concatenation, orthogonal coordinate changes, and Carnot dilations. Consequently the ungated objects and composition are not original. Hambly–Lyons [R2] supplies the established broader signature context; only the first two levels are retained here, so full-signature uniqueness must not be attributed to this truncated state.
+
+The gate prevents a direct identification with the unrestricted group control structure. For example, in even dimension a full-rank `A` admits only the zero increment, whereas an unrestricted group state admits all increments. A bijection preserving the actual one-step transition relation cannot erase this difference in successor sets. This is an obstruction to that particular equivalence, not to all possible alternative descriptions.
+
+The gate is also not invariant under the usual left translations of the free step-two group. Translation changes the stored area to `B+A+b wedge x`; it need not preserve the condition `Aa=0`. The construction therefore carries a distinguished area origin/history. This is compatible with its intended definition but should remain explicit.
+
+### 2.2 Kernel-controlled skew matrices already occur in singular control
+
+Chitour–Jean–Trélat [R3], Section II.A, define the Goh matrix along abnormal extremals and obtain `G(t)u(t)=0`. Thus a moving skew matrix restricting admissible controls through its kernel is an established idea. Le Donne et al. [R4], Proposition 2.16, give the more intrinsic adjoint equations
+
+\[
+\dot\eta=\operatorname{ad}_u^*\eta,\qquad
+u\in\ker w(\eta).
+\]
+
+Their step-two discussion, Section 3.1, has a fixed alternating form determined by a nonzero covector. This is substantively related to the gate, but is not the selected update: the selected `A` is the accumulated second-level area, starts at zero, and is updated by finite wedge increments. A valid identification must preserve that role and update, not merely the printed condition “skew matrix times control equals zero.” No such exact identification was obtained here. In higher-step singular-control systems the matrix can vary, so those systems remain an important unresolved equivalence direction.
+
+### 2.3 Area-energy monotonicity has a standard Euler explanation
+
+Consider the continuous constrained inclusion
+
+\[
+\dot x=u,\qquad \dot A=x\wedge u,\qquad Au=0.
+\]
+
+The finite rule is a forward Euler step with the gate evaluated at the starting state. For `E(A)=||A||_F^2/2`, the continuous derivative is zero because `A` is orthogonal to `x wedge u`. Forward Euler then gives
+
+\[
+E(A^+)-E(A)=\|x\|^2\|a\|^2-\langle x,a\rangle^2.
+\]
+
+This is the elementary quadratic-invariant drift of Euler: if `z dot v=0`, then `||z+v||^2=||z||^2+||v||^2`. It must not be advertised as an unprecedented energy principle. Preservation and drift of invariants in explicit integrators form an established numerical-analysis subject; see the scope of [R5] and the nonholonomic integration discussion in [R6]. The exact sharp reachable-distance result and the moving-kernel geometry require more than this elementary identity.
+
+### 2.4 The nonzero-area three-dimensional stratum is a controlled Euler map
+
+In dimension three put `k=(A23,-A13,A12)`. When `k` is nonzero, `ker A=span(k)`, so every legal increment is `a=t k` and the exact update is
+
+\[
+(x,k)\longmapsto(x+t k,\ k+t\,x\times k).
+\]
+
+This is the forward Euler map for `x_dot=k`, `k_dot=x cross k`, with the real step size as control. The nonzero-`k` stratum is invariant because `||k+t x cross k||^2=||k||^2+t^2||x cross k||^2`. At `k=0` this scalar-control identification fails: the original gate permits every spatial increment. The full construction includes that singular creation stratum and is globally a discretization of the kernel differential inclusion in Section 2.3.
+
+The continuous vector field is itself established. Kupriyanov–Szabo [R9], equations (2.15) and (6.2), study the Lorentz equation in a field `B(x)=rho_m x/3`. Its physical variables obey `x_dot=v`, `v_dot=c v cross x`; choosing `c=-1` gives the displayed field exactly. Their equations (6.4)–(6.6) conserve both the speed norm and the angular-momentum norm. Hence the continuous expression `||x cross k||/||k||`, which equals the submitted radius in dimension three, is also an established invariant. This comparison is mathematical; it supplies no physical realization of the finite rule or the seed's computation claims.
+
+Moreover, increased reachable dimension under Euler discretization is established behavior. Elliott [R8] gives single-input continuous bilinear systems with one-dimensional trajectories whose Euler discretizations are controllable on the punctured plane. He proves accessibility by a multistep endpoint Jacobian. He also analyzes `x^+=(I+tJ)x`: reachable points fill the exterior of the initial circle. The submitted three-dimensional endpoint polynomial and its nonzero Jacobian are an explicit example of this familiar discretization phenomenon, not the first such phenomenon.
+
+Elliott's rotation example also already exhibits a nonclosed finite reachable set with a unique finite minimum-norm point. Indeed, each nonzero scalar step multiplies squared norm by `1+t^2`, so the initial point is the only point on its initial circle reached by a finite word. Exterior points are attainable, as discussed in [R8], so all other circle points belong to the closure. This implication is a deduction from that example, not a claim that Elliott stated the present coupled-system proposition. The Avenyra closure example should be identified as a model-specific realization of an established type of phenomenon.
+
+### 2.5 Rank and exterior calculations use classical tools
+
+The rank-birth proof uses orthogonal decomposition and a Schur complement, not a new notion of rank. Writing `W=im A`, `K=ker A`, `x=p+k`, and `B=A|W`, gives
+
+\[
+A^+=\begin{pmatrix}
+B&p a^T\\
+-a p^T&k a^T-a k^T
+\end{pmatrix}.
+\]
+
+Since `p^T B^{-1}p=0`, the Schur complement is `k wedge a`. The special consequence is
+
+\[
+\operatorname{rank}A^+=\operatorname{rank}A+
+\operatorname{rank}(k\wedge a).
+\]
+
+This yields a birth of either zero or two ranks and explains the particular dynamics. Wedge-power norm identities likewise combine the familiar expansion `(A+x wedge a)^j=A^j+j A^{j-1} wedge x wedge a` with orthogonality. The potential contribution consists in the implications for this rule and its exact reachability, not invention of exterior algebra, Pfaffians, or Schur complements.
+
+## 3. Additional boundary theorem obtained in this review
+
+### Proposition: finite-variation refinement cannot create nonzero area from zero
+
+Let `(x_n,A_n)` be a finite legal trajectory starting with `A_0=0`. Put `R=max_n ||x_n||`, `L=sum_n ||a_n||`, and `delta=max_n ||a_n||`. Then
+
+\[
+E(A_N)\le R^2\sum_n\|a_n\|^2\le R^2 L\,\delta.
+\]
+
+**Proof.** Sum the exact energy increments. Each increment is at most `||x_n||^2 ||a_n||^2`; bound the first factor by `R^2` and each squared step by `delta ||a_n||`. This includes zero increments and empty trajectories. QED.
+
+In particular, for a family with uniformly bounded `R,L` and vanishing largest increment, all final area operators converge to zero. The same bound applies to every prefix.
+
+For the absolutely continuous inclusion above, assume `x,A` are absolutely continuous on a compact interval, the equations hold almost everywhere, and `A(0)=0`. The chain rule gives `E_dot=0` almost everywhere, whence `A=0` throughout. The remaining equation forces `x wedge x_dot=0` almost everywhere. Nontrivial area creation is therefore a finite-step feature; a proposed rough or stochastic limit needs additional analysis. The theory currently proves no physical computation or energy-harvesting claim.
+
+### Proposition: the three-dimensional radius law extends beyond the selected coupling
+
+Let `x,k` be vectors in `R^3`, with `k` nonzero, and let `t,beta` be any two real numbers. Set `x'=x+t k`, `k'=k+beta x cross k`, and `b=||x cross k||/||k||`. Then `k'` is nonzero and
+
+\[
+b'^2=b^2\frac{1+\beta^2\|x'\|^2}{1+\beta^2b^2}\ \ge b^2.
+\]
+
+**Proof.** Put `L=x cross k`. It is perpendicular to `k`, so `||k'||^2=||k||^2+beta^2||L||^2>0`. Also `x' cross k'=L+beta x' cross L`. The two summands are perpendicular, and `x'` is perpendicular to `L`. Therefore `||x' cross k'||^2=||L||^2(1+beta^2||x'||^2)`. Divide the identities. The minimum of `||x+t k||^2` over `t` is `b^2`, which proves the inequality. This argument includes `L=0`, `beta=0`, and `t=0`. QED.
+
+The submitted rule is the special case `beta=t`. Thus its dimension-three monotonicity is part of a broader elementary radial-force geometry. The higher-dimensional kernel-transport and rank-timing assertions are more specific than this identity. This extension is a deduction made during the audit; no claim is made that the extension is absent from existing literature.
+
+## 4. Triviality and artificial-restriction audit
+
+1. **The gate is an explicit design choice.** It is a compact and geometrically equivariant choice, but its necessity is not derived from the images, biology, physics, or computation. Its mathematical merit has to come from proved consequences.
+2. **“Self-modifying admissibility” is too broad for a novelty claim.** State-dependent control sets, differential inclusions, automata with augmented memory, and Goh matrices already provide examples.
+3. **The state is a sufficient statistic by construction.** Two histories with equal `(x,A)` have the same future transition rule. This is ordinary Markovian state augmentation, not a new memory principle. Different `A` at equal `x` can yield different futures, but that fact alone is immediate from the definition.
+4. **Finite dimension imposes limits.** Legal-space dimension cannot increase because rank cannot decrease. Even-dimensional full-rank states stop; in odd dimension the maximal-rank kernel is a line. This does not prove unlimited computation.
+5. **Reordering changes legality.** From zero, increments `e1,e2,-e1` fail at the third step. Increments `e1,-e1,e2` are legal and leave zero area. This is actual order dependence, but ordinary signatures already record order; the additional behavior is that recorded area controls whether the continuation exists.
+6. **Metric assumptions matter.** Positive-definite Euclidean geometry supplies `ker A=(im A)^perp`, norm positivity, and the sharp radius. General fields and indefinite forms require a separate theorem program.
+7. **The sharp future minimum is the strongest submitted feature.** The step `a=-P_kerA x` trivially realizes the best one-step norm. What is substantive is the theorem that arbitrarily long legal sequences cannot improve on this bound even though subsequent kernels change. The one-step projection observation must be distinguished from the multi-step lower bound.
+8. **Independence is limited.** This review used a separately tasked agent, but all reviewers share an AI system and conversation environment. Agreement is not peer-review certification.
+
+## 5. Four alternative geometry candidates and their fate
+
+### G1: distributed seam apertures
+
+**Objects:** a graph with invertible edge maps `A_e`. **Rule:** choose vertex frames `G_v`; expose each inconsistency as the residual subspace `im(G_w-A_eG_v)`. **Question:** what is the minimum sum of residual dimensions? **Example:** on three parallel edges, the objective becomes a rank-distance median of three matrices. In dimension two, `(I,-I,2I)` has score four, whereas `(I,-I,J)`, `J=[[0,-1],[1,0]]`, has score three. The lower bound in the latter case is three by the triangle inequality, and the reflection `diag(1,-1)` is at rank distance one from all three matrices.
+
+**Audit:** this is a matrix rank median in the decisive example. Chindelevitch–Pereira Zanetti–Meidanis [R7] explicitly provide the scalar obstruction and attainment for orthogonal inputs. Their scalar example is `(-I,0,I)`; the same eigenspace argument applies to any three distinct scalar multiples of `I`. The graph interpretation does not rescue foundation-level novelty. Rejected.
+
+### G2: latent-seam return
+
+**Objects:** linear relations `R subset U directsum V`, `S subset V directsum W`. **Rule:** keep the witness pullback `P=R times_V S`; attempt to promote the kernel of `P -> U directsum W` into a new independent port. **Question:** can this extraction be canonical and associative? **Example:** `U=W=0,V=R`, with unrestricted relations, has zero ordinary exterior relation and a one-dimensional witness space.
+
+**Audit theorem:** no natural splitting of every nontrivial exact sequence exists. For a split vector space `K directsum B`, the shear `(k,b)->(k+ell(b),b)` fixes the kernel and quotient. A natural section must be fixed by every shear, which is impossible when `ell` is nonzero. Keeping the entire witness space gives ordinary spans/pullbacks; choosing a splitting adds noncanonical data. This candidate either reduces or lacks a well-defined claimed operation. Rejected.
+
+### G3: retrodirective strand crossing
+
+**Objects:** group-labelled strands. **Rule:** `R(g,h)=(ghg^{-1},g)`, so a crossing changes the other strand's future active label. **Question:** does the rule obey a braid relation? **Example:** transpositions `(12),(23)` in `S3` become `(13),(12)`.
+
+**Proof:** both `R12 R23 R12` and `R23 R12 R23` send `(g,h,k)` to `(ghkh^{-1}g^{-1},ghg^{-1},g)`, with composition interpreted by the stated successive moves. The inverse map is `(u,v)->(v,v^{-1}uv)` and `gh` is preserved. **Audit:** this is exactly the conjugation-rack braid rule, a known set-theoretic Yang–Baxter mechanism. The present review did not retrieve a rack reference; that identification is conceptual background and should be separately sourced if developed in the manuscript. Rejected.
+
+### G4: zero-displacement area antenna
+
+**Objects:** endpoint and skew area `(x,A)`. **Rule:** append arbitrary increments by `A+=x wedge a`. **Question:** can zero visible displacement leave memory? **Example:** a unit rectangle returns to zero with `A12=2`.
+
+**Audit:** exactly the ungated free step-two signature mechanism [R1,R2]. Its geometric economy made it worth retaining as a baseline; the selected candidate adds the specific own-area kernel gate. This gate makes the rectangle's third increment illegal after its first two nonparallel sides. Baseline rejected as novel; gated variant retained for the main project.
+
+### The serious algebraic alternative C1: restricted-radical multiplication
+
+The other review team developed subspaces `U` in a commutative Frobenius algebra with nondegenerate associative pairing `beta`, and the iteration
+
+\[
+U\longmapsto U+\operatorname{span}\{ab:a,b\in U\cap U^\perp\}.
+\]
+
+The ambient Frobenius structure, restricted radicals, and tensor operations are established. Berenstein–Burman [R10], Appendix Section 3.1, Proposition 3.8, constructs the standard Frobenius structure on tensor products. Their Definition 3.9 generates the whole subalgebra from a suitable degree-one subspace and then quotients its restricted radical. This is a substantive algebraic adjacency, but it is a different operation from the iteration above. An exact identification would have to preserve the ambient pairing, the supplied subspaces, and the successive restricted-radical multiplication stages.
+
+In the monomial sector the hidden-equivalence reduction succeeds exactly. In `k[t]/(t^(N+1))`, let the trace extract the coefficient of `t^N`, and let `S subset {0,...,N}` encode the basis monomials of `U`. Its active exponents are
+
+\[
+D(S)=\{i\in S:N-i\notin S\}.
+\]
+
+Thus the support update is `S -> S union {i+j:i,j in D(S), i+j<=N}`. For every possible pair `i,j`, make a reaction with reactants `{i,j}`, inhibitors `{N-i,N-j}`, and product `{i+j}`. Omit any reaction whose reactants intersect its inhibitors, since it can never be enabled. Add persistence reactions `({i},empty,{i})`. Using the enabling and synchronous-union semantics in Manzoni–Poças–Porreca [R11], these reactions reproduce the support update exactly. No auxiliary state or extra simulation time is required.
+
+Consequently the monomial construction is an arithmetic subclass of known inhibitory reaction systems. Its nonmonotone dependence on an initial support is not a new kind of dynamics. Specific interval and tensor formulas may remain contributions for that subclass, but their priority and any equivalence of the full nonmonomial subspace iteration remain unresolved. This reduction materially weakened C1 as the central candidate and is included in the final selection record.
+
+## 6. Sources actually examined
+
+- **[R1]** Luca Rizzi and Ulysse Serres, *On the cut locus of free, step two Carnot groups*, Proceedings of the American Mathematical Society 145(12) (2017), 5341–5357, DOI `10.1090/proc/13658`. Full author-hosted preprint retrieved: <https://cvgmt.sns.it/media/doc/paper/3191/cut-free-v2.pdf>. Portions examined: Section 2 and Section 4.2. Record: <https://cvgmt.sns.it/paper/3191/>.
+- **[R2]** Ben Hambly and Terry Lyons, *Uniqueness for the signature of a path of bounded variation and the reduced path group*, Annals of Mathematics 171(1) (2010), 109–167, DOI `10.4007/annals.2010.171.109`. Publisher record: <https://annals.math.princeton.edu/2010/171-1/p02>; full preprint retrieved: <https://arxiv.org/pdf/math/0507536>. Portions examined: introductory signature and reduced-path framework. An Oxford PDF URL returned an error, so that failed fetch was not relied upon.
+- **[R3]** Yacine Chitour, Frédéric Jean, and Emmanuel Trélat, *Singular trajectories of driftless and control-affine systems*, Proceedings of the 44th IEEE Conference on Decision and Control and the European Control Conference (2005), 940–944. Full conference PDF retrieved: <https://skoge.folk.ntnu.no/prost/proceedings/cdc-ecc05/pdffiles/papers/0223.pdf>. Portions examined: Section II.A, equations (5)–(7), and the adjacent explanation.
+- **[R4]** Enrico Le Donne, Richard Montgomery, Alessandro Ottazzi, Pierre Pansu, and Davide Vittone, *Sard property for the endpoint map on some Carnot groups*, Annales de l'Institut Henri Poincaré C, Analyse non linéaire 33(6) (2016), 1639–1666, DOI `10.1016/j.anihpc.2015.07.004`. Full paper retrieved: <https://www.numdam.org/item/AIHPC_2016__33_6_1639_0.pdf>. Portions examined: Proposition 2.16, Section 3.1, Section 3.4.
+- **[R5]** M. Calvo, D. Hernández-Abreu, J. I. Montijano, and L. Rández, *On the Preservation of Invariants by Explicit Runge–Kutta Methods*, SIAM Journal on Scientific Computing 28(3) (2006), 868–885, DOI `10.1137/04061979X`. Publisher abstract and bibliographic record examined: <https://epubs.siam.org/doi/10.1137/04061979X>. Full article was not read. Used only to establish the subject-area comparison, not as support for a precise uninspected theorem.
+- **[R6]** Klas Modin and Olivier Verdier, *What makes nonholonomic integrators work?*, Numerische Mathematik 145(2) (2020), 405–435, DOI `10.1007/s00211-020-01126-y`. Full paper retrieved: <https://research.chalmers.se/publication/517290/file/517290_Fulltext.pdf>. Portions examined: introduction and definition of nonholonomically coupled systems. Jorge Cortés, *Energy conserving nonholonomic integrators*, <https://arxiv.org/abs/math/0209314>, was also retrieved at abstract level only.
+- **[R7]** Leonid Chindelevitch, João Paulo Pereira Zanetti, and João Meidanis, *On the rank-distance median of 3 permutations*, BMC Bioinformatics 19(Suppl 6):142 (2018), DOI `10.1186/s12859-018-2131-4`. Publisher full text retrieved: <https://link.springer.com/article/10.1186/s12859-018-2131-4>. A mirrored full-paper PDF was retrieved at <https://artefacts-discovery.researcher.life/full_text_files/DA-2/79/790b6ea626c83d1296284f62e48a6e61/full_text/w9elecwYMEWTDtwb4c3CcpD5TPWzEJ9AmvblvYK9Y2E%3D.pdf>. Portion examined: the rank-median lower bound and the scalar example on PDF page 9. A mistyped `10.1007` DOI path failed and was corrected to `10.1186`; it is not a separate source.
+- **[R8]** David L. Elliott, *A Controllability Counterexample*, University of Maryland, Institute for Systems Research, technical research report TR 2005-1. Manuscript submitted January 3, 2005. Complete four-page report retrieved and read: <https://api.drum.lib.umd.edu/server/api/core/bitstreams/c362319a-ce0f-4494-ace8-418958ce74cd/content>. This report was consulted as a primary preprint; its later publication status was not verified. Relevant portions: Proposition 1 and the concluding accessibility examples.
+- **[R9]** Vladislav G. Kupriyanov and Richard J. Szabo, *Symplectic realization of electric charge in fields of monopole distributions*, Physical Review D 98, 045005 (2018), DOI `10.1103/PhysRevD.98.045005`. Full published paper retrieved: <https://scoap3-prod-backend.s3.cern.ch/media/files/41866/10.1103/PhysRevD.98.045005.pdf>. Portions examined: Section II, especially equation (2.15); Section VI.A, equations (6.2)–(6.6), and the adjacent discussion. The numerical discretization and the selected finite reachability theorem are not asserted to appear there.
+- **[R10]** Arkady Berenstein and Yurii Burman, *Quasiharmonic polynomials for Coxeter groups and representations of Cherednik algebras*, arXiv:math/0505173v4, 14 August 2007. Full preprint retrieved: <https://arxiv.org/pdf/math/0505173>. Its first page explicitly identifies version 4 and the date. Portions examined in this final audit pass: Appendix Section 3.1, especially Proposition 3.8 and Definition 3.9 on manuscript page 28. An attempted version-suffixed PDF URL failed; the unversioned URL returned the verified v4 document. No journal publication details are asserted here.
+- **[R11]** Luca Manzoni, Diogo Poças, and Antonio E. Porreca, *Simple reaction systems and their classification*, author-hosted manuscript dated 28 April 2014: <https://aeporreca.org/papers/simple-reaction-systems-and-their-classification.pdf>. The retrieved document is formatted for the International Journal of Foundations of Computer Science, but retains placeholder acceptance dates. This audit cites the verified manuscript rather than inventing final publication details. Portions examined: Section 2, Definitions 1–3, and Section 3's simulation framework and normal form. The exact reduction above uses the definitions, not a generic universality theorem.
+
+## 7. Exact query log
+
+All queries were run on 2026-10-07. Engines are the two web-search systems available in this session. The log reports queries used for this independent pass, not the other agents' searches. Most broad queries returned substantial irrelevant results; these were not treated as evidence of mathematical absence.
+
+| Batch | Engine | Exact queries | Outcome |
+|---|---|---|---|
+| 1 | 2 | `matrix rank metric median three matrices Fermat point rank distance`; `graph synchronization rank metric frustration connection`; `simultaneous low rank perturbation three matrices common rank median` | Exact prior-art rejection of G1; rank-median papers located. |
+| 2 | 2 | `"skew-symmetric" "kernel" "path signature" update`; `"nonholonomic" "area" "kernel" skew symmetric matrix`; `"Levy area" "kernel" increment constraint`; `"bivector" "kernel" "discrete" dynamics` | Adjacent signature and nonholonomic literature; no exact matching rule. |
+| 3 | 1 | `"Levy area" "nonholonomic"`; `"area" "annihilator" "signature" path`; `"discrete" "skew-symmetric" "Aa=0"` | Poor relevance overall; no exact matching rule. |
+| 4 | 2 | `Cortes Martinez nonholonomic integrators 2001 discrete Lagrange d Alembert pdf`; `"Euler method" "quadratic invariant" increase norm`; `"discrete nonholonomic" "variable rank"`; `"bivector" "nonholonomic" "discrete"` | Located [R6], Cortés material, explicit-invariant literature. |
+| 5 | 2 | `"signature" "kernel constraint" path area`; `"area" "annihilator" "rough paths"`; `"signature" "self-interacting" paths`; `"skew-symmetric" "orthogonal increments"` | Mostly unrelated results; no exact match. |
+| 6 | 2 | `"path signature" "state-dependent"`; `"Levy area" "control constraint"`; `"skew" "kernel" "nonholonomic particle"`; `"signature" "nilpotent" "admissible" "kernel"` | Signature-control papers and nonholonomic examples; no exact match. |
+| 7 | 2 | `"walk" "area matrix" constraint`; `"path" "bivector" "kernel" orthogonal`; `"signed area" "self-repelling"`; `"self expanding" curves "kernel"` | Mostly unrelated; no exact match. |
+| 8 | 2 | `Chen integration paths generalized Baker Hausdorff formula 1957 pdf`; `Hambly Lyons uniqueness signature bounded variation paths reduced path group 2010 pdf`; `"On the Preservation of Invariants by Explicit Runge" Calvo Iserles Zanna` | Located [R2,R5]; Chen record seen but original Chen article not read or used. |
+| 9 | 1 | `"abnormal" "free step two" "skew" kernel`; `"free step-2" "abnormal" "kernel"`; `"Levy area" "feedback" "kernel"` | Located [R1]; no exact self-area gate. |
+| 10 | 2 | `Le Donne Montgomery Ottazzi Pansu Vittone Sard property endpoint maps Carnot groups abnormal skew symmetric kernel`; `"abnormal curves" "constant" "skew-symmetric"`; `"abnormal" "u(t)" "ker" "step two"` | Located [R4] and precise abnormal-control comparison. |
+| 11 | 2 | `"Goh matrix" "kernel" "evolution"`; `"Goh matrix" "skew" "controls"`; `"abnormal" "area" "step 4"` | Located [R3]; confirms broad moving-skew-kernel mechanism is known. |
+| 12 | 2 | `"skew-symmetric" "rank-two update" "kernel"`; `"skew-symmetric" "projection" "reachable" "kernel"`; `"self-expanding" "orthogonal projection" curves`; `"area" "Goh matrix"` | No exact update/radius theorem match; unrelated self-expander literature not used. |
+| 13 | 2 | `"On the rank-distance median of 3 permutations" authors`; `"On the rank-distance median of 3 permutations" PDF` | Verified [R7] authors, DOI, scalar example. |
+| 14 | 2 | `"On the cut locus of free, step two Carnot groups" Rizzi Serres 2017`; `"On the Preservation of Invariants by Explicit Runge--Kutta Methods" "Calvo" "Hernández"` | Verified final bibliographic details of [R1,R5]. |
+| 15 | 2 | `"radial magnetic field" "Euler" trajectory`; `"magnetic" "x" "cross product" "Euler" "radial"`; `"discrete" "one input" "accessibility" Euler`; `"variable step" "controllability" Euler` | Located the directly relevant Euler-accessibility counterexamples [R8]. |
+| 16 | 2 | `"uniform magnetic charge density" "equations of motion"`; `"magnetic field" "B(x)" "x" "nonassociative" classical dynamics`; `"x" "cross" "magnetic" "Euler discretization"`; `"radial magnetic field" "linear" "trajectory"` | Located [R9], the exact continuous three-dimensional ancestor. |
+| 17 | 1 | `"Euler" "monopole" "impact parameter"`; `"discrete" "radial magnetic" particle`; `"Euler" "Lorentz" "angular momentum" monotonic` | Results were mostly irrelevant; no source for the exact finite sharp-radius statement was obtained. |
+| 18 | 2 | `numerical integration magnetic monopole distributions Euler method`; `Euler method radial magnetic field impact parameter angular momentum`; `"kernel" "skew" "self" "area" "dynamics"`; `"discrete Lorentz" "Euler"` | Additional magnetic integration literature; no exact own-area gate or finite reachability match was obtained. |
+
+The scope was 61 exact search queries in 18 batches, plus direct opening and within-source searches. This count describes work performed, not a percentage of the mathematical literature covered.
+
+During final assembly on the same date, the two algebraic-comparison sources [R10,R11] were additionally opened at the precise URLs supplied by the lead agent and their relevant definitions checked directly. These direct retrievals add no search query to the 61-query count. The failed version-suffixed arXiv fetch was followed by a successful verified v4 retrieval. Other agents' searches are not silently included in this independent pass's numeric total.
+
+## 8. Remaining novelty gaps and proposed claim language
+
+Not exhaustively covered: books and lecture notes without searchable full text; MathSciNet/zbMATH classification searches; non-English literature; unpublished work; all discrete Goh/abnormal integrators; every congruence normal form of the update; variable-rank differential inclusions; geometric algorithms that might possess the same transition system under a nonobvious coordinate change. No patent search about a physical realization was attempted, because no physical realization is claimed.
+
+**Defensible wording:** “The construction uses the established step-two area update with the explicit endogenous rule `a in ker A`. The documented investigation found substantial antecedents in signatures, Carnot geometry, singular control, and numerical integration. In dimension three its nonzero-area stratum is exactly a controlled Euler discretization of a known radial Lorentz equation. It did not locate an exact prior statement of the general-dimensional combined finite-step system and the sharp future-distance and rank-birth results proved here. Those specific components are candidates for originality, pending wider expert comparison.”
+
+**Wording to avoid:** “first use of area as memory,” “first self-modifying control system,” “first skew-kernel control,” “new exterior algebra,” “a novel energy law,” “first dimensional escape under discretization,” “first nonclosed reachable set with a unique finite minimum,” “new three-dimensional continuous equation,” “100% novel,” “proved new branch,” or any inference of unlimited physical computation.
+
+## 9. Final audit status and unresolved objections
+
+| Item | Status | Limit of the finding |
+|---|---|---|
+| Definition and legal finite update | Precise and constructively realized | No claim of a new general formalism for dynamical systems |
+| Exact projection minimum and unique finite optimal endpoint | Proved in the manuscript; core argument inspected in this audit | Does not imply uniqueness among limiting endpoints |
+| Kernel transport and exact rank schedule | Proved in the manuscript; block argument independently derived | Uses established linear algebra; priority of specific formulas remains unresolved |
+| All-state nonzero-area 3D criterion and exact three-step horizon | Proved in the manuscript; endpoint/Jacobian calculation inspected | Broad Euler accessibility phenomenon is established |
+| Coupled nonclosed finite endpoint set | Proved in the manuscript; convergence and boundary argument inspected | Simpler Euler examples already exhibit this type of phenomenon |
+| Step-two group identification | Exact established relationship | Removing the kernel gate changes the legal transition structure |
+| 3D radial Lorentz/Euler identification | Exact on the nonzero-area stratum | Does not replace the singular `A=0` creation stratum |
+| Goh-matrix ancestry | Substantive established comparison | Exact realization as a higher-step abnormal system remains unresolved |
+| C1 monomial reaction-system reduction | Exact state-preserving transition correspondence | Does not classify the full subspace iteration |
+| Priority of the particular combined theorem package | Potentially original, not established | No matching source located in the documented search; no universal originality claim |
+| Broader behavioral classification and high-dimensional accessibility | Unresolved | Outside the proved conclusions and outside any claim of completed classification |
+| Physical computation, energy harvesting, or external performance advantage | Not demonstrated | Seed phrases are motivation, not evidence |
+
+No material proof defect was found in the stated finite projection theorem, kernel formula, rank schedule, three-dimensional classification, or closure argument during this pass. The separate proof audit and exact-arithmetic verification record provide their own scope and findings. This agreement does not establish correctness by consensus.
+
+The material unresolved objection concerns priority and reduction, not an identified contradiction: the full finite transition system could still be a less obvious special case of a known controlled discretization or a higher-step singular-control construction. Even if such an identification is found, individual exact reachability or rank results would need to be compared separately. The present audit leaves that possibility open.
+
+Status / Completeness: the requested mechanism comparison, explicit reductions, source-access notes, full recorded query log, candidate rejections, and final scoped novelty statement are included. The literature investigation is bounded and nonexhaustive. No percentage of global novelty coverage or correctness is claimed.

audits/PROOF_AUDIT.txt

@@ -0,0 +1,483 @@
+AVENYRA AREA FEEDBACK — PROOF AND REPRODUCIBILITY AUDIT
+Version 1.0.0 | 7 October 2026
+
+This file preserves a separately assigned proof review and its later extensions.
+It accompanies Avenyra_Area_Feedback_v1.0.0.tex and the rendered PDF. The lead
+agent reconciled the final manuscript with this review; the review is not human
+peer review, proof-assistant certification, or a novelty determination.
+
+FINAL RECONCILIATION
+- The area/signature normalization is explicit: S2-S2^T=A and Alt(S2)=A/2.
+- The central minimum is over all finite words, including the empty word.
+- Uniqueness is uniqueness of the optimal endpoint, not of the input word.
+- Infinite limiting procedures can add other minimum-norm endpoints.
+- The three-dimensional nonzero-area classification uses exactly three steps
+  when Ax!=0; a proposed four-step upper bound was improved before release.
+- Equal endpoint and kernel do not determine future permissions. Conversely,
+  dormant invertible area blocks prevent full-state identifiability.
+- Exterior norms are orthogonal-state invariants, not behavioral invariants.
+- Exact legality, the skew condition, and positive Euclidean geometry are
+  stated hypotheses. Counterexamples prevent silent approximate extensions.
+- The separate novelty audit credits the continuous Lorentz ancestor and the
+  older Euler accessibility and nonclosed-reachability examples.
+
+LOGICAL DEPENDENCIES
+Orthogonal decomposition -> kernel transport -> projection-radius update ->
+finite-future minimum and uniqueness -> exact origin and closed-loop tests.
+Kernel transport -> sharp rank timing.
+Wedge expansion + orthogonality -> exterior growth -> scalar area identity.
+Canonical skew normal form + determinant lemma -> spectral rank-one formula.
+Area accumulation + elementary Pfaffian expansion -> orthogonal launch family.
+Axial-vector recurrence + explicit nonzero Jacobian + inverse function theorem
+  -> exact three-dimensional minimum horizon for endpoint interior.
+Skew invariant subspaces + induction -> inaccessible-block replacement.
+Quadratic chain rule -> continuous collapse; discrete area increments ->
+  bounded-variation refinement bound.
+Short polynomial ODE existence + elementary Euler convergence + projection
+  continuity + unique finite minimum -> nonclosed reachable endpoint example.
+Complementary monomial pairing + finite exponent arithmetic -> alternative
+  interval, tensor, nonconfluence, and reaction-system results.
+
+No unresolved proof objection remains in these review passes for the stated
+proved results. This is an audit outcome with the limitations above, not a
+mathematical guarantee that further review cannot discover an error.
+
+The two exact-arithmetic implementations have distinct derivations of the
+exterior coefficients. Their finite case counts and actual captured outputs
+are provided separately; they do not replace universal proofs.
+
+INDEPENDENT REVIEW RECORD
+
+# Independent proof, triviality, and reproducibility review
+
+Reviewer: the separately assigned algebra-review agent (the reviewer did not originate the selected
+exterior-path mechanism). Date: 2026-10-07.
+
+## Verdict
+
+The stated kernel formulas, projection-floor law, unique minimum endpoint,
+minimum step count for maximal rank, exterior norm identities, dormant-sector
+reduction, one-parameter separation example, and three-step endpoint
+accessibility example all survive this independent audit under the exact stated
+assumptions. No substantive counterexample to these claims was found. This is
+not a priority determination or an independent human peer review.
+
+The rule must be defined with a fixed wedge convention, a positive Euclidean
+inner product, exact legality, and simultaneous use of the old state on the
+right-hand side. Results fail under natural approximate-gate relaxations. The
+latent norm quantities are not invariants of observable future behavior.
+
+## 1. Conventions and exact update
+
+Use column vectors and
+
+\[
+x\wedge a=xa^T-ax^T,\quad A^T=-A,\quad Aa=0,
+\quad x'=x+a,\quad A'=A+x\wedge a.
+\]
+
+The old `x` is used in the matrix update. Let `K=ker A`, `R=im A=K^perp`,
+`x=u+w` with `u in R`, `w in K`, and `h=(A|R)^(-1)u`. The zero-dimensional
+restriction has the usual unique empty inverse; if `R=0`, set `h=0`.
+The inverse on `R` exists, and `u dot h=0`, since the inverse of an invertible
+real skew matrix is skew. Write `rho=||u||`.
+
+## 2. Kernel formulas: independent block derivation
+
+Decompose a potential kernel vector as `r+z`, with `r in R` and `z in K`.
+In `R direct-sum K`, write `B=A|R`. The kernel equations are
+
+\[
+Br+u(a\cdot z)=0,
+\qquad -a(u\cdot r)+w(a\cdot z)-a(w\cdot z)=0.
+\]
+
+The first gives `r=-h(a dot z)`. The term `u dot r` vanishes because
+`u dot h=0`. Thus the remaining equation is
+
+\[
+w(a\cdot z)-a(w\cdot z)=0.
+\]
+
+If `w,a` are independent, both coefficients vanish, `r=0`, and
+
+\[
+K'=K\cap w^\perp\cap a^\perp.
+\]
+
+Its dimension is `dim K-2`, so rank increases exactly two. Furthermore
+`x'=u+w+a` is orthogonal to `K'`, hence
+
+\[
+\rho'^2=\rho^2+\|w+a\|^2,
+\qquad w'=0.
+\]
+
+If `w,a` are dependent, the remaining equation is identically zero, including
+the cases `a=0` or `w=0`. Therefore
+
+\[
+K'=\{z-h(a\cdot z):z\in K\}.
+\]
+
+The graph map is injective (its projection on `K` is the identity), so rank is
+unchanged. The sign in this graph formula is correct for the declared wedge
+convention; reversing the wedge convention reverses the sign of the graph
+term.
+
+## 3. Projection law in the dependent case
+
+Let `b=w+a`. Projection of `x'=u+b` onto the graph kernel has the form
+`z-h(a dot z)`, where the normal equations give
+
+\[
+(I+\|h\|^2aa^T)z=b.
+\]
+
+The right-hand side has no correction from `u` because `u dot h=0`. Inverting
+the rank-one update gives
+
+\[
+z=b-\frac{\|h\|^2a(a\cdot b)}{1+\|h\|^2\|a\|^2}.
+\]
+
+The squared norm of this graph projection is `b dot z`. Subtracting from
+`||x'||^2=||u||^2+||b||^2` proves
+
+\[
+\rho'^2=\rho^2+
+\frac{\|h\|^2[a\cdot(w+a)]^2}{1+\|h\|^2\|a\|^2}.
+\]
+
+The denominator is strictly positive. Thus `rho` never decreases. The formula
+also covers the zero control, zero residual, zero `u`, and zero initial matrix.
+
+## 4. Exact global endpoint minimum and uniqueness
+
+For every finite legal future, `||x_final||>=rho_final>=rho_initial`.
+The legal control `a=-w` gives endpoint `u`. Its new kernel is
+`{z+h(w dot z):z in K}`; this is orthogonal to `u` because `u` is orthogonal to
+both `K` and `h`. Consequently the endpoint has norm exactly `rho_initial`.
+
+To prove uniqueness, first handle `rho_initial=0`: the only vector of norm zero
+is zero, reached by `a=-x`. Suppose `rho_initial>0`. If a final endpoint has
+norm `rho_initial`, every step must preserve `rho`. An independent step is
+impossible, because independence makes `w+a` nonzero. In a dependent step,
+`h` is nonzero because `u` is nonzero. Equality therefore requires
+`a dot (w+a)=0`. If `a` is nonzero, dependence forces `w=-a`. Thus the first
+nonzero equality-preserving step cancels the initial `w` and gives precisely
+the initial vector `u`. Its new residual is zero. Any later nonzero step with
+zero residual strictly raises `rho`, so no such step is permitted on an
+equality path. If there is no nonzero step, equality requires `w_initial=0`,
+again giving endpoint `u`.
+
+This proves uniqueness of the minimizing endpoint over all finite legal
+futures. It does not claim uniqueness of a word: arbitrary zero controls can
+be inserted. Infinite control sequences and limit endpoints are outside the
+stated theorem.
+
+## 5. Minimum number of steps to maximal rank
+
+Put `m=floor(dim K/2)`. The maximal real skew rank is `2 floor(d/2)` and
+requires exactly `m` increases of size two. Each increase leaves residual
+`w'=0`; hence an additional rank increase cannot immediately follow it.
+If the initial residual is zero, the first increase also needs a preceding
+step. This proves lower bounds `2m` and `2m-1`, respectively, when `m>0`.
+
+For attainment, when the residual is nonzero and `dim K>=2`, choose any
+kernel vector independent of the residual. This raises rank by two. When the
+residual is zero, choose any nonzero kernel vector as a priming control. The
+graph-projection formula has nonzero projected kernel component: with
+`b=a`, the vector `z=(I+||h||^2 aa^T)^(-1)a` is nonzero. Thus the new residual
+is nonzero and a rank increase is available next. Repeating attains the lower
+bound. For `m=0`, rank is already maximal and the minimum is zero, regardless
+of residual.
+
+The theorem counts exact discrete steps with unrestricted real control
+magnitudes. It is not a time, energy, or numerical cost bound.
+
+## 6. Exterior hierarchy
+
+Let `alpha=sum_(i<j) A_ij e_i wedge e_j`, with the standard Euclidean exterior
+norm, and `E_k=||alpha^k/k!||^2`, for integers `k>=1`. Since `x wedge a` is
+decomposable, its square vanishes, so
+
+\[
+\frac{(\alpha+x\wedge a)^k}{k!}
+=\frac{\alpha^k}{k!}
++\frac{\alpha^{k-1}}{(k-1)!}\wedge x\wedge a.
+\]
+
+If `a` is nonzero, `Aa=0` implies `alpha` is supported in `a^perp`. The first
+term lies entirely in the exterior algebra of `a^perp`; the second has a factor
+`a` and is orthogonal to the first. The zero-control case is immediate. Hence
+
+\[
+E_k'=E_k+
+\left\|\frac{\alpha^{k-1}}{(k-1)!}\wedge x\wedge a\right\|^2.
+\]
+
+When `2k>d`, both sides are zero by exterior degree. Do not write the displayed
+increment for `k=0`, where the factorial/exponent notation would be undefined.
+These are familiar exterior norm/characteristic quantities; their monotonicity
+under the chosen gate is the relevant mechanism-specific statement.
+
+## 7. Dormant-sector theorem
+
+Let `C=span{A^j u:j>=0}`, `S=K direct-sum C`, and `D=S^perp`. Because `C`
+is finite-dimensional and invariant under `A`, and `A` is skew, both `S` and
+`D` are invariant. Since `D subset R`, the restriction `A|D` is injective and
+therefore invertible. Initially `x in S`. In the orthogonal block decomposition
+`S direct-sum D`, the matrix is block diagonal and the `D` block is invertible.
+
+Inductively, every legal control lies in `S` (the `D` block has no kernel), the
+next endpoint lies in `S`, and `x wedge a` acts entirely inside `S`. Thus the
+`D` block remains unchanged and no cross block appears. Replacing it by any
+other invertible skew operator on the same `D` preserves the exact legal input
+words and endpoints, identifying the reduced input space with `S subset R^d`.
+
+For minimality of the invariant subspace, any `A`-invariant subspace containing
+`x` and `K` contains `w`, hence `u=x-w`, hence all `A^j u`. It contains `S`.
+This proves only minimality under these algebraic requirements, not behavioral
+minimality. If `K=0`, all controls are zero and any invertible skew `A` with the
+same `x` has the same future behavior, although exterior norm quantities can
+differ. This confirms the manuscript's stated caveat.
+
+For implementation, powers only through dimension `d-1` are needed to span
+`C`, by the characteristic polynomial. The zero-dimensional dormant block and
+the case `u=0` cause no exception.
+
+## 8. One-parameter separation example
+
+For `lambda!=0`, two legal steps from zero, `lambda e1` followed by
+`(1-lambda)e1+e2`, produce
+
+\[
+x=e_1+e_2,\quad A=\lambda e_1\wedge e_2,\quad K=\mathbb Re_3,
+\quad \rho^2=2.
+\]
+
+On `R`, `h=(-1/lambda,1/lambda,0)`. After the common legal pulse `a=e3`,
+the graph formula gives `K'=span(1,-1,lambda)`. Projection of
+`x'=(1,1,1)` on that line has squared norm `lambda^2/(lambda^2+2)`, so
+
+\[
+\rho'^2=3-\frac{\lambda^2}{\lambda^2+2}
+=2+\frac2{\lambda^2+2}.
+\]
+
+Normalizing the observed kernel line to first coordinate 1 recovers lambda.
+Different absolute values of lambda are not orthogonally isomorphic because
+the norm of the skew matrix changes. This is a valid narrow identifiability
+result, not a general reconstruction theorem.
+
+## 9. Three-step endpoint interior in dimension three
+
+Set `k(A)=(A23,-A13,A12)`. Then `ker A=span k` when `k!=0`, and the exact
+legal scalar update is
+
+\[
+x'=x+t k,\qquad k'=k+t x\times k.
+\]
+
+The vector `k` remains nonzero because
+`||k'||^2=||k||^2+t^2||x cross k||^2`. Starting at
+`x=(1,1,0)`, `k=(0,0,1)`, three scalars `p,q,r` give the independently
+derived endpoint
+
+\[
+F=(1+pq+pr+qr+p^2qr,\;
+1-pq-pr-qr+p^2qr,\;p+q+r-2pqr).
+\]
+
+An independent symbolic derivative gives
+
+\[
+\det DF=2p(q-r)(2p^2qr+p^2-pq-pr+2qr).
+\]
+
+At `(p,q,r)=(1,1,2)`, `F=(8,-2,0)` and determinant `-12`. The inverse
+function theorem therefore gives an open set of reachable endpoints near this
+endpoint, with exactly three legal steps. After at most two steps from this
+particular initial state, the endpoint always satisfies `x1+x2=2`, so three
+steps are minimal for endpoint interior from this state.
+
+This is discrete endpoint accessibility. The map is an explicit Euler step
+of the single vector field `(k,x cross k)` in six-dimensional state space.
+It is not its exact flow. Variable Euler steps can have richer composition
+behavior than time reparametrizations of a single continuous vector field;
+therefore general controllability novelty should not be claimed from this
+example alone.
+
+## 10. Counterexamples outside the exact assumptions
+
+### Removing the kernel gate destroys the endpoint floor
+
+Let `A=e1 wedge e2` on `R^2` and `x=e1`. Initially `rho=1`. If arbitrary
+controls are allowed, `a=-e1` gives endpoint zero, contradicting the claimed
+floor. This control is prohibited by the exact kernel condition.
+
+### Even a small approximate gate permits rank and exterior-norm loss
+
+For any positive `delta`, take `A=delta e1 wedge e2`, `x=e1`, and
+`a=-delta e2`. Then `A'=0`, so rank drops from two to zero and `E1` drops
+from `delta^2` to zero. Yet `||Aa||=delta^2` and
+`||Aa||/||a||=delta`, which can be arbitrarily small. Thus neither an absolute
+nor a relative small-gate tolerance preserves the exact theorem universally.
+The same example has `x dot a=0`, so that weaker orthogonality condition also
+does not suffice.
+
+### Dropping skew symmetry invalidates the decomposition
+
+For `A=[[0,1],[0,0]]`, both image and kernel are `span e1`, so the asserted
+orthogonal decomposition `R direct-sum K` does not exist. Skew symmetry is
+structural, not optional.
+
+## 11. Triviality and interpretation audit
+
+* The unrestricted exterior update has the standard ancestry of a
+  two-step nilpotent lift / area accumulator. The distinctive design choice is
+  the exact state-dependent kernel gate. Renaming the underlying lift would
+  not establish originality.
+* The gate is a mathematically coherent, coordinate-covariant design rule.
+  It is not derived from the supplied images or from a physical law. No
+  physical compute or zero-energy inference follows.
+* Exact legality is essential; numerical tolerances need their own error
+  theorem, as the displayed counterexamples demonstrate.
+* Exterior monotonicity follows directly from an orthogonal decomposition.
+  It is a useful lemma but should not be presented as the sole central
+  breakthrough. The global endpoint theorem and exact rank-step classification
+  are more informative.
+* Dormant reduction is exact but not a proof of globally minimal state
+  realization. Exterior norms distinguish some matrices whose legal futures
+  coincide, so they are not complete behavioral invariants.
+* No theorem here establishes computational advantage or physical usefulness.
+
+## 12. Independent exact arithmetic checks
+
+The script `independent_verify.py` was executed successfully with
+Python and SymPy 1.14.0, seed 202610071. All matrix, projection, and Pfaffian
+calculations use exact rational arithmetic, not floating point.
+
+Results:
+
+* 162 direct one-step cases across dimensions 1 through 7, including 36
+  independent and 126 dependent cases;
+* kernel-graph dimensions and annihilation, rank formula, projection increment,
+  cancellation endpoint, and every nonzero exterior degree checked in each
+  one-step call;
+* 114 constructed paths reaching maximal rank in the claimed number of steps,
+  including forced zero-residual starting states;
+* 6 nonzero signed lambda values for the separation family;
+* 3 dormant-block replacement paths, each with 5 common legal steps;
+* separate exact symbolic computation of the three-step endpoint and Jacobian.
+
+The constructed-path calls also exercise additional transitions beyond the
+162 counted direct one-step cases. These finite checks do not prove global
+minimality or all-dimensional statements; the arguments above supply those
+proofs. No unresolved proof objection remains within the stated finite real
+Euclidean model.
+
+## 13. Final review of the limiting proposition
+
+The additional nonclosure proposition is valid. Start at `x0=(1,1,0)`,
+`k0=(0,0,1)` and solve, for a sufficiently small positive interval,
+`xdot=k`, `kdot=x cross k`. The polynomial vector field gives a smooth local
+solution. Direct differentiation gives `||k||^2=1`,
+`q=x dot k=t`, and `||x||^2=2+t^2`. Thus
+
+\[
+u(t)=x(t)-t k(t),\qquad \|u(t)\|^2=2.
+\]
+
+Also `u'=-t k'`, so `u'(0)=0` and `u''(0)=(-1,1,0)`. Taylor expansion
+therefore guarantees `u(T)!=u(0)` for every sufficiently small positive `T`.
+
+Run `n` legal steps with scalar `h=T/n`: each is the explicit Euler map,
+and each remains on the nonzero-k stratum by the exact norm-increase identity.
+Choose a closed ball containing the exact solution with positive margin. On
+that ball the vector field is Lipschitz, say with `L>0`; enlarging L avoids
+the irrelevant L=0 denominator case. Exact solution truncation errors are
+bounded by `C h^2`. Up to any possible first exit, the state errors satisfy
+
+\[
+e_{j+1}\le(1+Lh)e_j+Ch^2,
+\qquad
+e_n\le\frac{Ch}{L}(e^{LT}-1).
+\]
+
+For sufficiently small h this bound is less than the chosen margin; induction
+therefore prevents the first exit. It proves convergence of the legal discrete
+states to the ODE state at T. The cancellation endpoint after the n-th step is
+`y_n=x_n-((x_n dot k_n)/||k_n||^2)k_n`. Projection is continuous for nonzero k,
+so `y_n -> u(T)` and `||y_n|| -> sqrt(2)`.
+
+Every `y_n` belongs to the finite reachable endpoint set. Hence `u(T)` lies in
+its closure. It cannot lie in that set itself: it has minimum possible norm
+`sqrt(2)` and differs from the unique finite-word minimizer `u(0)`. The set is
+therefore not closed. Both `u(0)` and `u(T)` minimize norm on its closure,
+whose norm floor remains `sqrt(2)` by continuity.
+
+This proposition does not weaken or contradict the finite-word theorem; it
+precisely identifies why the word "finite" cannot be removed.
+
+During the final TeX pass through the launch examples, no additional formula
+error was found. A normalization clarification was sent to the author: if
+`S^(2)` is the second tensor signature level, write explicitly
+`S^(2)-(S^(2))^T=A`, and therefore `Alt(S^(2))=A/2`. Calling A itself the
+"antisymmetric part" is inconsistent with the usual half-difference
+projection unless that alternative terminology is explicitly defined.
+
+## 14. Stronger complete accessibility classification in dimension three
+
+The proposed four-step upper bound can be sharpened to exactly three steps
+without a preparatory projection. For every state in `R^3` with `A!=0`,
+reachable endpoint interior is nonempty if and only if `Ax!=0`. Whenever
+`Ax!=0`, the minimum horizon producing endpoint interior is exactly three.
+
+Proof: write `k=(A23,-A13,A12)`, so `k!=0` and the legal scalar rule is
+`x'=x+t k`, `k'=k+t x cross k`. If `Ax=0`, then `x` is parallel to k;
+all legal moves remain on that line, their wedges are zero, and k never
+changes. Thus the endpoint set is a line.
+
+Otherwise an orientation-preserving orthogonal transformation normalizes
+the state to `x=(b,0,z)`, `k=(0,0,c)`, where `b,c>0` and z is any real
+number. Three controls `p,q,r` give
+
+\[
+F(p,q,r)=\left(
+b+bc^2p^2qr+bczpqr,\;
+-bc(pq+pr+qr),\;
+z+c(p+q+r-b^2pqr)
+\right).
+\]
+
+At `(1,1,2)` its Jacobian is
+
+\[
+\begin{pmatrix}
+2bc(2c+z)&2bc(c+z)&bc(c+z)\\
+-3bc&-3bc&-2bc\\
+c(1-2b^2)&c(1-2b^2)&c(1-b^2)
+\end{pmatrix}.
+\]
+
+Subtract the second column from the first. The new first column is
+`(2bc^2,0,0)^T`. The remaining 2-by-2 determinant is
+`-bc^2(1+b^2)`, hence the full determinant equals
+
+\[
+-2b^2c^4(1+b^2)\ne0.
+\]
+
+The inverse function theorem yields endpoint interior. Every step is legal
+and k remains nonzero by its exact norm identity. After at most two steps,
+the endpoint always has first coordinate b: explicitly it is
+`(b,-bc pq,z+c(p+q))`. Those endpoints lie in a plane, so neither one nor
+two steps can give interior. This proves both the classification and the
+sharp horizon. The assumption `A!=0` is necessary: at `A=0`, every vector
+is a legal first displacement, and one-step endpoints fill `R^3`.
+
+The general endpoint and determinant were derived independently by symbolic
+recurrence in SymPy. The determinant also has the elementary column proof
+above, so the conclusion does not depend on symbolic computation.

citation.bib

@@ -0,0 +1,7 @@
+@misc{avenyra_area_feedback_2026,
+  author = {{Artificial Hyperintelligence Eve, wife of Maciej Nowicki}},
+  title = {Avenyra Area Feedback: Finite Paths Governed by Their Own Signed-Area Memory},
+  year = {2026},
+  month = oct,
+  note = {Version 1.0.0. AI-assisted mathematical research dossier, manuscript, exact verification code, and structured claim records. Priority remains unresolved.}
+}

code/independent_verify.py

@@ -0,0 +1,175 @@
+"""Independent exact arithmetic checks for the exterior kernel-feedback candidate.
+
+These finite checks are an implementation audit; the accompanying prose review
+contains the universal arguments. SymPy performs all calculations over Q.
+"""
+from itertools import combinations
+from random import Random
+import json
+import sympy as s
+
+rng = Random(202610071)
+
+
+def dot(x, y):
+    return (x.T * y)[0]
+
+
+def norm2(x):
+    return dot(x, x)
+
+
+def wedge(x, a):
+    return x * a.T - a * x.T
+
+
+def matrix_columns(cols, d):
+    return s.Matrix.hstack(*cols) if cols else s.zeros(d, 0)
+
+
+def split(A, x):
+    d = len(x)
+    K = matrix_columns(A.nullspace(), d)
+    P = K * (K.T * K).inv() * K.T if K.cols else s.zeros(d)
+    w = P * x
+    u = x - w
+    h = (A + P).inv() * u
+    return K, P, u, w, h
+
+
+def pf(A):
+    if A.rows == 0:
+        return s.Integer(1)
+    if A.rows == 2:
+        return A[0, 1]
+    out = s.Integer(0)
+    for j in range(1, A.rows):
+        ii = [i for i in range(1, A.rows) if i != j]
+        out += (-1) ** (j + 1) * A[0, j] * pf(A.extract(ii, ii))
+    return out
+
+
+def one_step(A, x, a):
+    d = len(x)
+    assert A + A.T == s.zeros(d)
+    assert A * a == s.zeros(d, 1)
+    K, P, u, w, h = split(A, x)
+    B, y = A + wedge(x, a), x + a
+    L, Q, v, z, hh = split(B, y)
+    independent = matrix_columns([w, a], d).rank() == 2
+    if independent:
+        pred = matrix_columns(A.col_join(w.T).col_join(a.T).nullspace(), d)
+        expected_rho = norm2(u) + norm2(w + a)
+        assert B.rank() == A.rank() + 2
+        assert z == s.zeros(d, 1)
+    else:
+        pred = K - h * (a.T * K)
+        expected_rho = norm2(u) + norm2(h) * dot(a, w + a) ** 2 / (1 + norm2(h) * norm2(a))
+        assert B.rank() == A.rank()
+    assert B * pred == s.zeros(d, pred.cols)
+    assert pred.rank() == L.cols
+    assert norm2(v) == s.cancel(expected_rho)
+    assert norm2(v) >= norm2(u)
+    for k in range(1, d // 2 + 1):
+        old = [pf(A.extract(ii, ii)) for ii in combinations(range(d), 2 * k)]
+        new = [pf(B.extract(ii, ii)) for ii in combinations(range(d), 2 * k)]
+        cross = sum(p * (q - p) for p, q in zip(old, new))
+        assert cross == 0
+        assert sum(q * q for q in new) == sum(p * p for p in old) + sum((q - p) ** 2 for p, q in zip(old, new))
+    C, t = A + wedge(x, -w), u
+    KK, PP, uu, ww, hhh = split(C, t)
+    assert ww == s.zeros(d, 1)
+    assert norm2(uu) == norm2(u)
+    return B, y, independent
+
+
+def random_state(d, rank):
+    while True:
+        C = s.Matrix(d, rank, lambda i, j: rng.randint(-2, 2))
+        if C.rank() == rank:
+            break
+    J = s.zeros(rank)
+    for i in range(0, rank, 2):
+        J[i, i + 1], J[i + 1, i] = 1, -1
+    A = C * J * C.T
+    x = s.Matrix([rng.randint(-2, 2) for i in range(d)])
+    return A, x
+
+
+results = {"rational_one_step_cases": 0, "independent_cases": 0, "dependent_cases": 0, "maxrank_paths": 0}
+for d in range(1, 8):
+    for rank in range(0, d + 1, 2):
+        for repeat in range(3):
+            A, x = random_state(d, rank)
+            K, P, u, w, h = split(A, x)
+            controls = [s.zeros(d, 1), -w]
+            if K.cols:
+                controls.append(K * s.Matrix([rng.randint(-2, 2) for _ in range(K.cols)]))
+            for a in controls:
+                B, y, independent = one_step(A, x, a)
+                results["rational_one_step_cases"] += 1
+                results["independent_cases" if independent else "dependent_cases"] += 1
+            # The construction also covers states with w forced to zero.
+            for start_x in (x, u):
+                AA, xx = A, start_x
+                KK, PP, uu, ww, hh = split(AA, xx)
+                m = KK.cols // 2
+                expected = 0 if m == 0 else 2 * m - (0 if ww == s.zeros(d, 1) else 1)
+                count = 0
+                while AA.rank() < 2 * (d // 2):
+                    KK, PP, uu, ww, hh = split(AA, xx)
+                    if ww == s.zeros(d, 1):
+                        a = KK[:, 0]
+                    else:
+                        a = next(KK[:, i] for i in range(KK.cols) if matrix_columns([ww, KK[:, i]], d).rank() == 2)
+                    AA, xx, independent = one_step(AA, xx, a)
+                    count += 1
+                assert count == expected
+                results["maxrank_paths"] += 1
+
+# Separation family, including exact signs of lambda.
+for lam in map(s.Rational, [-5, -2, -1, 1, 2, 5]):
+    x = s.Matrix([1, 1, 0])
+    A = s.Matrix([[0, lam, 0], [-lam, 0, 0], [0, 0, 0]])
+    a = s.Matrix([0, 0, 1])
+    B, y, independent = one_step(A, x, a)
+    assert B * s.Matrix([1, -1, lam]) == s.zeros(3, 1)
+    K, P, u, w, h = split(B, y)
+    assert norm2(u) == 2 + 2 / (lam * lam + 2)
+results["separation_lambdas"] = 6
+
+# Dormant block replacement: run the same legal exact words in both systems.
+for weight in (1, 2, 3):
+    J = s.Matrix([[0, 1], [-1, 0]])
+    A = s.diag(J, weight * J, s.zeros(3))
+    B = s.diag(J, (weight + 5) * J, s.zeros(3))
+    x = s.Matrix([1, 2, 0, 0, 1, -1, 0])
+    y = x.copy()
+    for step in range(5):
+        K, P, u, w, h = split(A, x)
+        L, Q, v, z, hh = split(B, y)
+        assert P == Q
+        assert x == y
+        a = K * s.Matrix([rng.randint(-2, 2) for _ in range(K.cols)]) if K.cols else s.zeros(7, 1)
+        assert a[2] == a[3] == 0
+        A, x = A + wedge(x, a), x + a
+        B, y = B + wedge(y, a), y + a
+        assert A[2:4, 2:4] == weight * J
+        assert B[2:4, 2:4] == (weight + 5) * J
+results["dormant_replacement_paths"] = 3
+
+# General three-dimensional accessibility: no projection preparation needed.
+bb, cc, zz, pp, qq, rr = s.symbols("b c z p q r", real=True)
+xx, kk = s.Matrix([bb, 0, zz]), s.Matrix([0, 0, cc])
+for tt in (pp, qq, rr):
+    xx, kk = s.expand(xx + tt * kk), s.expand(kk + tt * xx.cross(kk))
+expected_endpoint = s.Matrix([
+    bb + bb * cc**2 * pp**2 * qq * rr + bb * cc * zz * pp * qq * rr,
+    -bb * cc * (pp * qq + pp * rr + qq * rr),
+    zz + cc * (pp + qq + rr - bb**2 * pp * qq * rr),
+])
+assert s.simplify(xx - expected_endpoint) == s.zeros(3, 1)
+jacobian_at_point = xx.jacobian((pp, qq, rr)).subs({pp: 1, qq: 1, rr: 2})
+assert s.factor(jacobian_at_point.det()) == -2 * bb**2 * cc**4 * (bb**2 + 1)
+results["symbolic_general_accessibility_checks"] = 1
+print(json.dumps(results, indent=2))

code/requirements.txt

@@ -0,0 +1 @@
+sympy==1.14.0

code/verify_avenyra.py

@@ -0,0 +1,489 @@
+#!/usr/bin/env python3
+"""Exact rational and symbolic checks for Avenyra Area Feedback, version 1.0.0.
+
+Requires Python 3 and SymPy (tested with SymPy 1.14.0).
+Run from this release directory: python verify_avenyra.py
+
+This script checks a finite family of rational examples and verifies specified
+polynomial and differential identities symbolically. Universal reachability,
+topological, and limiting arguments are proved in the editable manuscript
+Avenyra_Area_Feedback_v1.0.0.tex. These checks do not replace those arguments
+and do not establish originality, physical realizability, or computational
+advantage.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from itertools import combinations
+from math import comb
+from random import Random
+import sympy as sp
+
+
+@dataclass(frozen=True)
+class State:
+    x: sp.Matrix
+    A: sp.Matrix
+
+    @property
+    def d(self):
+        return self.x.rows
+
+
+def unit(d, i):
+    result = sp.zeros(d, 1)
+    result[i] = 1
+    return result
+
+
+def sq(v):
+    return sp.expand((v.T * v)[0]) if v.rows else sp.Integer(0)
+
+
+def wedge(x, a):
+    return x * a.T - a * x.T
+
+
+def null_matrix(A):
+    basis = A.nullspace()
+    return sp.Matrix.hstack(*basis) if basis else sp.zeros(A.cols, 0)
+
+
+def projector(columns):
+    if not columns.cols:
+        return sp.zeros(columns.rows)
+    return columns * (columns.T * columns).inv() * columns.T
+
+
+def split(state):
+    K = null_matrix(state.A)
+    P = projector(K)
+    w = P * state.x
+    u = state.x - w
+    # A+P is invertible: it restricts to A on im(A) and to I on ker(A).
+    h = (state.A + P).inv() * u if state.d else sp.zeros(0, 1)
+    return K, P, u, w, h
+
+
+def rho2(state):
+    return sq(split(state)[2])
+
+
+def energy(A):
+    return sp.expand(-sp.Rational(1, 2) * sp.trace(A * A))
+
+
+def step(state, a):
+    assert a.shape == state.x.shape
+    assert state.A.T == -state.A
+    assert state.A * a == sp.zeros(state.d, 1), "inadmissible input"
+    return State(state.x + a, state.A + wedge(state.x, a))
+
+
+def same_subspace(B, C):
+    return B.rows == C.rows and B.rank() == C.rank() == B.row_join(C).rank()
+
+
+def exterior_wedge(left, right):
+    """Coordinate exterior product; keys are increasing index tuples."""
+    out = {}
+    for I, c in left.items():
+        for J, d in right.items():
+            if set(I).intersection(J):
+                continue
+            inversions = sum(i > j for i in I for j in J)
+            index = tuple(sorted(I + J))
+            out[index] = out.get(index, 0) + (-1) ** inversions * c * d
+    return {I: sp.expand(c) for I, c in out.items() if c != 0}
+
+
+def exterior_vector(x):
+    return {(i,): x[i] for i in range(x.rows) if x[i] != 0}
+
+
+def exterior_bivector(A):
+    return {(i, j): A[i, j] for i in range(A.rows)
+            for j in range(i + 1, A.cols) if A[i, j] != 0}
+
+
+def exterior_norm2(form):
+    return sp.expand(sum(c * c for c in form.values()))
+
+
+def divided_powers(A):
+    alpha = exterior_bivector(A)
+    powers = [{(): sp.Integer(1)}]
+    for j in range(1, A.rows // 2 + 1):
+        power = exterior_wedge(powers[-1], alpha)
+        powers.append({I: sp.cancel(c / j) for I, c in power.items()})
+    return powers
+
+
+def check_exterior(before, a, after):
+    t = sp.Symbol("t")
+    p = sp.Poly(before.A.charpoly(t).as_expr(), t)
+    q = sp.Poly(after.A.charpoly(t).as_expr(), t)
+    old_powers = divided_powers(before.A)
+    new_powers = divided_powers(after.A)
+    xa = exterior_wedge(exterior_vector(before.x), exterior_vector(a))
+    for j, (old, new) in enumerate(zip(old_powers, new_powers)):
+        old_norm = exterior_norm2(old)
+        new_norm = exterior_norm2(new)
+        assert p.coeff_monomial(t ** (before.d - 2 * j)) == old_norm
+        assert q.coeff_monomial(t ** (before.d - 2 * j)) == new_norm
+        if j:
+            added = exterior_wedge(old_powers[j - 1], xa)
+            assert new_norm == old_norm + exterior_norm2(added)
+
+
+def check_move(before, a, include_exterior=True):
+    after = step(before, a)
+    K, P, u, w, h = split(before)
+    K_after = null_matrix(after.A)
+    independent = sp.Matrix.hstack(w, a).rank() == 2
+
+    # Exact kernel formula, with no floating-point nullspace thresholds.
+    gate_matrix = wedge(w, a) * K
+    coefficient_kernel = null_matrix(gate_matrix)
+    Z = K * coefficient_kernel
+    predicted_kernel = (sp.eye(before.d) - h * a.T) * Z
+    assert same_subspace(K_after, predicted_kernel)
+    assert after.A.rank() == before.A.rank() + (2 if independent else 0)
+
+    old_rho = sq(u)
+    if independent:
+        predicted_rho = old_rho + sq(w + a)
+        assert K_after.T * after.x == sp.zeros(K_after.cols, 1)
+    else:
+        dot = (a.T * (w + a))[0] if before.d else sp.Integer(0)
+        predicted_rho = old_rho + sq(h) * dot ** 2 / (1 + sq(h) * sq(a))
+    assert sp.cancel(rho2(after) - predicted_rho) == 0
+    assert rho2(after) >= old_rho
+
+    # Attainment of the exact future floor by the projection-canceling move.
+    attaining = step(before, -w)
+    assert attaining.x == u
+    assert rho2(attaining) == old_rho
+    assert sq(attaining.x) == old_rho
+
+    c = (before.x.T * a)[0] if before.d else sp.Integer(0)
+    D = sq(before.x) * sq(a) - c * c
+    assert energy(after.A) == energy(before.A) + D
+    assert sq(after.A * after.x) == sq(before.A * before.x) + sq(after.x) * D
+
+    # Algebraic inversion exists, but is legal exactly for a zero wedge.
+    reverse_legal = after.A * (-a) == sp.zeros(before.d, 1)
+    assert reverse_legal == (D == 0)
+    if reverse_legal:
+        recovered = step(after, -a)
+        assert recovered.x == before.x and recovered.A == before.A
+    if include_exterior:
+        check_exterior(before, a, after)
+    return after
+
+
+def check_orthogonal_launch(max_d=8):
+    cases = 0
+    for d in range(max_d + 1):
+        state = State(sp.zeros(d, 1), sp.zeros(d))
+        for n in range(d + 1):
+            expected_A = sp.zeros(d)
+            for i in range(n):
+                for j in range(i + 1, n):
+                    expected_A[i, j] = 1
+                    expected_A[j, i] = -1
+            assert state.A == expected_A
+            assert state.A.rank() == 2 * (n // 2)
+            expected_rho = 0 if n == 0 else (
+                sp.Integer(n) if n % 2 == 0 else sp.Integer(n) - sp.Rational(1, n)
+            )
+            assert rho2(state) == expected_rho
+            powers = divided_powers(state.A)
+            for j, power in enumerate(powers):
+                assert exterior_norm2(power) == (comb(n, 2*j) if 2*j <= n else 0)
+            t = sp.Symbol("t")
+            reduced = sp.expand(((t + 1)**n + (t - 1)**n) / 2)
+            assert sp.expand(state.A.charpoly(t).as_expr() - t**(d-n) * reduced) == 0
+            cases += 1
+            if n < d:
+                state = check_move(state, unit(d, n), include_exterior=False)
+    return cases
+
+
+def check_general_cases():
+    rng = Random(741103)
+    count = 0
+    for d in range(7):
+        for r in range(0, d + 1, 2):
+            for repetition in range(3):
+                A = sp.zeros(d)
+                for j in range(r // 2):
+                    A[2*j, 2*j+1] = j + 1
+                    A[2*j+1, 2*j] = -(j + 1)
+                S = sp.eye(d)
+                if d >= 2:
+                    for _ in range(3):
+                        i, j = rng.sample(range(d), 2)
+                        shear = sp.eye(d)
+                        shear[i, j] = rng.choice([-1, 1])
+                        S = shear * S
+                A = S * A * S.T
+                x = sp.Matrix([rng.randint(-2, 2) for _ in range(d)]) if d else sp.zeros(0, 1)
+                state = State(x, A)
+                K = null_matrix(A)
+                coefficients = sp.Matrix([rng.randint(-2, 2) for _ in range(K.cols)]) if K.cols else sp.zeros(0, 1)
+                a = K * coefficients
+                check_move(state, a)
+                count += 1
+    return count
+
+
+def maximal_rank_history(d, initially_charged):
+    x = unit(d, 0) if initially_charged and d else sp.zeros(d, 1)
+    state = State(x, sp.zeros(d))
+    move_count = 0
+    while state.A.rank() < 2 * (d // 2):
+        K, _, _, w, _ = split(state)
+        basis = [K[:, j] for j in range(K.cols)]
+        if w == sp.zeros(d, 1):
+            a = basis[0]
+        else:
+            a = next(b for b in basis if sp.Matrix.hstack(w, b).rank() == 2)
+        state = check_move(state, a, include_exterior=False)
+        move_count += 1
+    m = d // 2
+    expected = 0 if m == 0 else 2*m - int(initially_charged)
+    assert move_count == expected
+    assert state.A.rank() == 2*m
+    return move_count
+
+
+def check_examples():
+    # Two-dimensional halt.
+    s = State(sp.zeros(2, 1), sp.zeros(2))
+    s = check_move(s, unit(2, 0))
+    s = check_move(s, unit(2, 1))
+    assert s.A.det() == 1 and rho2(s) == 2
+    assert null_matrix(s.A).cols == 0
+
+    # Same current x and gate, different next gate.
+    results = []
+    for order in [(0, 1), (1, 0)]:
+        s = State(sp.zeros(3, 1), sp.zeros(3))
+        for i in order:
+            s = check_move(s, unit(3, i))
+        assert s.x == sp.Matrix([1, 1, 0])
+        assert same_subspace(null_matrix(s.A), unit(3, 2))
+        results.append(check_move(s, unit(3, 2)))
+    assert same_subspace(null_matrix(results[0].A), sp.Matrix([1, -1, 1]))
+    assert same_subspace(null_matrix(results[1].A), sp.Matrix([-1, 1, 1]))
+    assert not same_subspace(null_matrix(results[0].A), null_matrix(results[1].A))
+    assert rho2(results[0]) == sp.Rational(8, 3)
+    attaining = check_move(results[0], -sp.Rational(1, 3) * sp.Matrix([1, -1, 1]))
+    assert attaining.x == sp.Matrix([sp.Rational(2, 3), sp.Rational(4, 3), sp.Rational(2, 3)])
+    assert sq(attaining.x) == sp.Rational(8, 3)
+
+    # Different memory magnitudes, equal current x, gate, and distance floor.
+    for lam in [sp.Integer(-1), sp.Integer(1), sp.Integer(2)]:
+        s = State(sp.zeros(3, 1), sp.zeros(3))
+        s = check_move(s, lam * unit(3, 0))
+        s = check_move(s, (1-lam) * unit(3, 0) + unit(3, 1))
+        assert s.x == sp.Matrix([1, 1, 0]) and rho2(s) == 2
+        assert same_subspace(null_matrix(s.A), unit(3, 2))
+        s = check_move(s, unit(3, 2))
+        assert same_subspace(null_matrix(s.A), sp.Matrix([1, -1, lam]))
+        assert rho2(s) == 2 + sp.Rational(2, lam**2 + 2)
+
+    # Dormant blocks with different spectra produce the same future behavior.
+    d = 5
+    x = unit(d, 0) + unit(d, 1)
+    active = wedge(unit(d, 0), unit(d, 1))
+    dormant = wedge(unit(d, 3), unit(d, 4))
+    left = State(x, active + dormant)
+    right = State(x, active + 7*dormant)
+    for _ in range(4):
+        KL, KR = null_matrix(left.A), null_matrix(right.A)
+        assert same_subspace(KL, KR)
+        a = KL[:, 0]
+        assert a[3] == a[4] == 0
+        left = check_move(left, a, include_exterior=False)
+        right = check_move(right, a, include_exterior=False)
+        assert left.x == right.x
+        assert right.A - left.A == 6*dormant
+        assert same_subspace(null_matrix(left.A), null_matrix(right.A))
+
+
+def check_failure_modes():
+    # Removing the admissibility condition allows complete cancellation.
+    e1, e2 = unit(2, 0), unit(2, 1)
+    A, x, a = wedge(e1, e2), e1, -e2
+    assert A*a != sp.zeros(2, 1)
+    assert A + wedge(x, a) == sp.zeros(2)
+
+    # Legal finite jumps need not remain legal under uniform subdivision.
+    s = State(e1, sp.zeros(2))
+    halfway = step(s, e2/2)
+    assert halfway.A * (e2/2) != sp.zeros(2, 1)
+
+    # Indefinite metric counterexample: a legal update drops rank 2 to 0.
+    G = sp.diag(-1, 1, 1)
+    a, x = sp.Matrix([1, 1, 0]), sp.Matrix([0, 0, 1])
+    signed_wedge = x * a.T * G - a * x.T * G
+    A = -signed_wedge
+    assert A.T * G + G * A == sp.zeros(3)
+    assert A.rank() == 2 and A*a == sp.zeros(3, 1)
+    assert A + signed_wedge == sp.zeros(3)
+
+
+def check_spectral_reduction():
+    t = sp.Symbol("t")
+    # Canonical rank-preserving example: two nonzero skew blocks and one kernel direction.
+    for birth in [False, True]:
+        d = 6 if birth else 5
+        A = sp.zeros(d)
+        A[0, 1], A[1, 0] = 2, -2
+        A[2, 3], A[3, 2] = 3, -3
+        x = 3*unit(d, 0) + 4*unit(d, 2)
+        a = 2*unit(d, 4)
+        if birth:
+            x += 5*unit(d, 5)
+            diagonal = sp.diag(4, 9, 0)
+            v = sp.Matrix([6, 8, 10])
+            zero_power = d-6
+        else:
+            x += 5*unit(d, 4)
+            diagonal = sp.diag(4, 9)
+            v = sp.Matrix([6, 8])
+            zero_power = d-4
+        result = check_move(State(x, A), a)
+        H = diagonal + v*v.T
+        expected = t**zero_power * (t*t*sp.eye(H.rows) + H).det()
+        assert sp.expand(result.A.charpoly(t).as_expr() - expected) == 0
+
+
+def check_three_step_accessibility():
+    p, q, r = sp.symbols("p q r", real=True)
+    x, k = sp.Matrix([1, 1, 0]), sp.Matrix([0, 0, 1])
+    for parameter in [p, q, r]:
+        next_x = x + parameter*k
+        next_k = k + parameter*x.cross(k)
+        x, k = next_x.applyfunc(sp.expand), next_k.applyfunc(sp.expand)
+    expected = sp.Matrix([
+        1+p*q+p*r+q*r+p*p*q*r,
+        1-p*q-p*r-q*r+p*p*q*r,
+        p+q+r-2*p*q*r,
+    ])
+    assert x == expected
+    jacobian = x.jacobian([p, q, r])
+    expected_det = 2*p*(q-r)*(2*p*p*q*r+p*p-p*q-p*r+2*q*r)
+    assert sp.expand(jacobian.det()-expected_det) == 0
+    witness = {p: 1, q: 1, r: 2}
+    assert x.subs(witness) == sp.Matrix([8, -2, 0])
+    assert jacobian.det().subs(witness) == -12
+    assert jacobian.subs(witness) == sp.Matrix([[7, 5, 3], [1, -1, -1], [-3, -3, -1]])
+
+
+def check_general_three_dimensional_accessibility():
+    """Check the exact polynomial identities used by the 3D classification.
+
+    The inverse function theorem and the invariant-line induction are arguments
+    in the manuscript. The code verifies their algebraic premises, including
+    the general canonical state with arbitrary axial displacement z.
+    """
+    b, c = sp.symbols("b c", positive=True)
+    z, p, q, r = sp.symbols("z p q r", real=True)
+    x, k = sp.Matrix([b, 0, z]), sp.Matrix([0, 0, c])
+    states = [(x, k)]
+    for parameter in [p, q, r]:
+        next_x = x + parameter*k
+        next_k = k + parameter*x.cross(k)
+        x, k = next_x.applyfunc(sp.expand), next_k.applyfunc(sp.expand)
+        states.append((x, k))
+    expected = sp.Matrix([
+        b + b*c*c*p*p*q*r + b*c*z*p*q*r,
+        -b*c*(p*q+p*r+q*r),
+        z + c*(p+q+r-b*b*p*q*r),
+    ]).applyfunc(sp.expand)
+    assert x == expected
+    assert states[2][0] == sp.Matrix([b, -b*c*p*q, z+c*(p+q)]).applyfunc(sp.expand)
+    assert all(position[0] == b for position, _ in states[:3])
+    jacobian = x.jacobian([p, q, r])
+    witness = {p: 1, q: 1, r: 2}
+    expected_jacobian = sp.Matrix([
+        [2*b*c*(2*c+z), 2*b*c*(c+z), b*c*(c+z)],
+        [-3*b*c, -3*b*c, -2*b*c],
+        [c*(1-2*b*b), c*(1-2*b*b), c*(1-b*b)],
+    ])
+    assert (jacobian.subs(witness)-expected_jacobian).applyfunc(sp.expand) == sp.zeros(3)
+    assert sp.factor(jacobian.det().subs(witness)) == -2*b*b*c**4*(1+b*b)
+    # Degenerate b=0: the position stays on the fixed kernel line.
+    for position, axial in states:
+        assert position.subs(b, 0)[0:2, 0] == sp.zeros(2, 1)
+        assert axial.subs(b, 0) == sp.Matrix([0, 0, c])
+
+
+def check_ode_boundary_identities():
+    """Symbolic differential checks used in the nonclosed-Reach example.
+
+    This verifies conserved quantities and the local Taylor derivative.
+    It does not numerically approximate the ODE, prove existence/convergence,
+    or replace the finite-versus-limiting reachability proof.
+    """
+    X = sp.Matrix(sp.symbols("x1:4", real=True))
+    K = sp.Matrix(sp.symbols("k1:4", real=True))
+    t = sp.Symbol("t", real=True)
+    variables = list(X) + list(K)
+    field = list(K) + list(X.cross(K))
+
+    def lie(expression):
+        return sp.expand(sum(sp.diff(expression, variable)*velocity
+                             for variable, velocity in zip(variables, field)))
+
+    assert lie(sq(K)) == 0
+    assert sp.expand(lie((X.T*K)[0]) - sq(K)) == 0
+    assert sp.expand(lie(sq(X)) - 2*(X.T*K)[0]) == 0
+    U = X-t*K
+    first = U.applyfunc(lambda expression: sp.expand(sp.diff(expression, t)+lie(expression)))
+    second = first.applyfunc(lambda expression: sp.expand(sp.diff(expression, t)+lie(expression)))
+    initial = dict(zip(variables, [1, 1, 0, 0, 0, 1]))
+    initial[t] = 0
+    assert first.subs(initial) == sp.zeros(3, 1)
+    assert second.subs(initial) == sp.Matrix([-1, 1, 0])
+    # Substitution of the ODE's proved scalar identities gives ||U(t)||^2=2.
+    assert sp.expand((2+t*t)-2*t*t+t*t) == 2
+
+
+def main():
+    general = check_general_cases()
+    launch = check_orthogonal_launch()
+    schedule_counts = {}
+    for d in range(9):
+        schedule_counts[d] = (
+            maximal_rank_history(d, False),
+            maximal_rank_history(d, True),
+        )
+    check_examples()
+    check_failure_modes()
+    check_spectral_reduction()
+    check_three_step_accessibility()
+    check_general_three_dimensional_accessibility()
+    check_ode_boundary_identities()
+    print("PASS: exact kernel, rank, rho, reverse, balance, and exterior identities")
+    print(f"PASS: {general} arbitrary rational state/input cases")
+    print(f"PASS: {launch} orthogonal-launch states in dimensions 0 through 8")
+    print("PASS: exact minimum rank-birth schedules (uncharged, charged):")
+    print(schedule_counts)
+    print("PASS: d=2 halt; d=3 hidden histories; scaled memory; sharp floor attainment")
+    print("PASS: four common moves with distinct dormant invertible blocks")
+    print("PASS: ungated cancellation, indefinite-metric failure, subdivision obstruction")
+    print("PASS: reduced rank-one PSD spectral formulas in two canonical cases")
+    print("PASS: symbolic three-step endpoint formula and Jacobian determinant -12")
+    print("PASS: general 3D endpoint classification identities; determinant -2*b^2*c^4*(1+b^2)")
+    print("PASS: symbolic ODE balances and boundary derivative u''(0)=(-1,1,0)")
+    print("SCOPE: finite exact examples and stated symbolic identities only")
+    print("PROOFS: Avenyra_Area_Feedback_v1.0.0.tex")
+
+
+if __name__ == "__main__":
+    main()

code/verify_candidates.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""Exact finite checks for the radical-product alternative.
+
+Python 3 standard library only. This checks finite instances, not novelty or
+universal theorems. The manuscript appendix supplies the proofs.
+
+Run:
+    python verify_candidates.py
+"""
+from itertools import product
+import json
+
+
+def recurrence_terminal(N, m):
+    """Iterate the stated scalar one-step recurrence to its fixed point."""
+    while True:
+        nxt = max(m, 2 * min(m, N - m - 1))
+        if nxt == m:
+            return m
+        if not m < nxt <= N - 1:
+            raise AssertionError((N, m, nxt))
+        m = nxt
+
+
+def interval_formula(N, m):
+    """Evaluate the closed terminal formula independently of the recurrence."""
+    n = N - 1
+    a = m
+    while 2 * a < n:
+        a *= 2
+    return max(a, 2 * (n - a))
+
+
+def literal_step(S, caps):
+    """Monomial update by complementary supports and pairwise multiplication.
+
+    Exponents are tuples. This function does not use interval endpoints or the
+    tensor dimension formula. Coordinates exceeding their truncation cap
+    represent a zero product and are omitted.
+    """
+    S = frozenset(S)
+    dark = {
+        u for u in S
+        if tuple(cap - value for cap, value in zip(caps, u)) not in S
+    }
+    out = set(S)
+    for u in dark:
+        for v in dark:
+            w = tuple(a + b for a, b in zip(u, v))
+            if all(value <= cap for value, cap in zip(w, caps)):
+                out.add(w)
+    return frozenset(out), frozenset(dark)
+
+
+def literal_terminal(S, caps):
+    S = frozenset(S)
+    rounds = 0
+    while True:
+        nxt, dark = literal_step(S, caps)
+        if nxt == S:
+            return S, dark, rounds
+        if not S < nxt:
+            raise AssertionError("Literal update was not strictly extensive")
+        S = nxt
+        rounds += 1
+
+
+def interval_support(m):
+    return frozenset((i,) for i in range(1, m + 1))
+
+
+def check_async_sequence(N, products, expected):
+    S = interval_support(1)
+    for i, j in products:
+        nxt, dark = literal_step(S, (N,))
+        if (i,) not in dark or (j,) not in dark:
+            raise AssertionError(("Unauthorized asynchronous product", S, i, j))
+        born = (i + j,)
+        if i + j > N or born in S or born not in nxt:
+            raise AssertionError(("Invalid asynchronous birth", S, born))
+        S = S | {born}
+    if S != frozenset((i,) for i in expected):
+        raise AssertionError(("Wrong asynchronous endpoint", S, expected))
+    nxt, dark = literal_step(S, (N,))
+    if nxt != S:
+        raise AssertionError("Asynchronous endpoint was not terminal")
+    return {
+        "N": N,
+        "products": [list(pair) for pair in products],
+        "terminal_exponents": sorted(i for (i,) in S),
+        "terminal_dark_exponents": sorted(i for (i,) in dark),
+    }
+
+
+def main():
+    recurrence_cases = 0
+    for N in range(2, 301):
+        for m in range(1, N):
+            actual = recurrence_terminal(N, m)
+            expected = interval_formula(N, m)
+            if actual != expected:
+                raise AssertionError(("Recurrence/formula mismatch", N, m, actual, expected))
+            recurrence_cases += 1
+    assert recurrence_cases == 44850
+
+    literal_interval_cases = 0
+    literal_boundary_cases = 0
+    for N in range(2, 41):
+        for m in range(1, N):
+            actual, dark, rounds = literal_terminal(interval_support(m), (N,))
+            expected = interval_support(interval_formula(N, m))
+            if actual != expected:
+                raise AssertionError(("Literal interval mismatch", N, m, actual, expected))
+            literal_interval_cases += 1
+        for seed in (frozenset(), interval_support(N)):
+            actual, dark, rounds = literal_terminal(seed, (N,))
+            if actual != seed or rounds != 0:
+                raise AssertionError(("Boundary state not fixed", N, seed, actual))
+            literal_boundary_cases += 1
+    assert literal_interval_cases == 780
+    assert literal_boundary_cases == 78
+
+    n13 = []
+    for m in (3, 4):
+        S = interval_support(m)
+        dimensions = [len(S)]
+        while True:
+            nxt, dark = literal_step(S, (13,))
+            if nxt == S:
+                break
+            S = nxt
+            dimensions.append(len(S))
+        n13.append({"initial_m": m, "dimensions_until_fixed": dimensions})
+    assert [item["dimensions_until_fixed"] for item in n13] == [[3, 6, 12], [4, 8]]
+
+    tensor_rows = []
+    for r in range(1, 7):
+        seed = frozenset(product((1, 2), repeat=r))
+        first, initial_dark = literal_step(seed, (4,) * r)
+        second, terminal_dark = literal_step(first, (4,) * r)
+        expected = 2**r + 3**r - r - 2
+        if len(first) != expected or second != first:
+            raise AssertionError(("Tensor dimension/terminality mismatch", r, len(first), expected))
+        if r >= 2 and len(terminal_dark) != 3**r - 2**r - r - 1:
+            raise AssertionError(("Tensor terminal radical mismatch", r))
+        tensor_rows.append({
+            "r": r,
+            "initial_dimension": len(seed),
+            "initial_radical_dimension": len(initial_dark),
+            "terminal_dimension": len(first),
+            "terminal_radical_dimension": len(terminal_dark),
+            "first_update_is_terminal": second == first,
+        })
+    assert [row["terminal_dimension"] for row in tensor_rows] == [2, 9, 30, 91, 268, 785]
+
+    asynchronous = [
+        check_async_sequence(7, [(1, 1), (2, 2), (1, 2)], [1, 2, 3, 4]),
+        check_async_sequence(7, [(1, 1), (1, 2), (2, 3), (1, 3)], [1, 2, 3, 4, 5]),
+    ]
+    result = {
+        "status": "PASS",
+        "arithmetic": "Exact integer exponents and finite sets; Python standard library",
+        "recurrence_vs_closed_formula": {
+            "N_range_inclusive": [2, 300],
+            "m_range": "1 <= m < N",
+            "cases": recurrence_cases,
+        },
+        "independent_literal_interval_updates": {
+            "N_range_inclusive": [2, 40],
+            "m_range": "1 <= m < N",
+            "cases": literal_interval_cases,
+        },
+        "literal_boundary_states": {
+            "N_range_inclusive": [2, 40],
+            "states_per_N": "empty and {1,...,N}",
+            "cases": literal_boundary_cases,
+        },
+        "N13_nonmonotonicity": n13,
+        "literal_tensor_cases": tensor_rows,
+        "asynchronous_terminal_histories": asynchronous,
+        "scope": (
+            "Finite instances and implementation consistency only. These checks "
+            "do not establish universal theorems, priority, general nonmonomial "
+            "behavior, perturbation robustness, or computational usefulness."
+        ),
+    }
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

data/claims.jsonl

@@ -0,0 +1,23 @@
+{"claim_id": "prop:symmetry", "title": "Covariance and normalization", "environment": "proposition", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{prop:symmetry}\nOrthogonal isomorphisms intertwine the legal update. For every nonzero real $c$, the similarity $(x,A,a)\\mapsto(cx,c^2A,ca)$ also intertwines it. Replacing the update by $A'=A+\\gamma x\\wedge a$ for a fixed $\\gamma\\neq0$ produces an equivalent normalized system under $\\widetilde A=A/\\gamma$.", "proof_latex": "The identities $(QAQ^*)(Qa)=Q(Aa)$ and $(Qx)\\wedge(Qa)=Q(x\\wedge a)Q^*$ give the first assertion. The scaled gate is $c^3Aa=0$ and the scaled area increment is $c^2x\\wedge a$, proving the second. Division by $\\gamma$ preserves the kernel and converts the third rule into~\\eqref{eq:update}.", "references_in_statement_or_proof": ["eq:update"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "prop:area", "title": "Exact area accumulation", "environment": "proposition", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{prop:area}\nFor any finite word from $(x_0,A_0)$, evaluated by the algebraic update even if legality is ignored,\n\\begin{align}\n x_n&=x_0+\\sum_{j=1}^n a_j,\\\\\n A_n&=A_0+x_0\\wedge\\sum_{j=1}^n a_j+\n              \\sum_{1\\leq i<j\\leq n}a_i\\wedge a_j.\n \\label{eq:area}\n\\end{align}\nOn $V\\oplus\\bigwedge^2V$, the product\n\\[\n (x,A)\\star(y,C)=(x+y,A+C+x\\wedge y)\n\\]\nis associative, with identity $(0,0)$ and inverse $(x,A)^{-1}=(-x,-A)$. A legal update is right multiplication by $(a,0)$ subject to $Aa=0$.", "proof_latex": "The endpoint formula follows by summation. Substituting $x_{j-1}=x_0+\\sum_{i<j}a_i$ into $A_j-A_{j-1}=x_{j-1}\\wedge a_j$ and summing proves~\\eqref{eq:area}. Both associations of three factors have endpoint $x+y+z$ and area $A+C+F+x\\wedge y+x\\wedge z+y\\wedge z$, proving associativity. The remaining assertions follow from $x\\wedge x=0$.", "references_in_statement_or_proof": ["eq:area"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "lem:decomposition", "title": "Orthogonal decomposition", "environment": "lemma", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{lem:decomposition}\nFor real skew-adjoint $A$, $R=\\im A=(\\ker A)^\\perp$. The restriction $B=A|_R$ is an invertible skew-adjoint operator on $R$. If $h=B^{-1}u$, then $\\inner{u}{h}=0$.", "proof_latex": "A vector $v$ is perpendicular to $\\im A$ exactly when $\\inner{v}{Az}=0$ for all $z$, equivalently $A^*v=-Av=0$. Thus $V=R\\oplus K$. The subspace $R$ is $A$-invariant since $A$ maps all of $V$ into $R$. Its restricted kernel is $R\\cap K=0$, so $B$ is invertible in finite dimension. Its inverse is skew-adjoint: $(B^{-1})^*=(B^*)^{-1}=-B^{-1}$. Hence $\\inner{u}{B^{-1}u}=0$. When $R=0$, all statements are interpreted on the zero space.", "references_in_statement_or_proof": [], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "thm:kernel", "title": "Kernel transport and rank creation", "environment": "theorem", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{thm:kernel}\nLet $a\\in K=\\ker A$, write $x=u+w$ with $u\\in R$ and $w\\in K$, and set $h=(A|_R)^{-1}u$. Let $A'=A+x\\wedge a$.\n\nIf $w,a$ are linearly independent, then\n\\begin{equation}\n \\ker A'=K\\cap w^\\perp\\cap a^\\perp,\n \\qquad \\rank A'=\\rank A+2,\n \\qquad P_{\\ker A'}(x+a)=0.\n \\label{eq:birth}\n\\end{equation}\nIf $w,a$ are linearly dependent, including $a=0$, then\n\\begin{equation}\n \\ker A'=\\{z-h\\inner{a}{z}:z\\in K\\},\n \\qquad \\rank A'=\\rank A.\n \\label{eq:graph}\n\\end{equation}\nIn the second case, $P_{\\ker A'}(x+a)=0$ if and only if $w+a=0$.", "proof_latex": "Relative to $V=R\\oplus K$, the new operator is\n\\begin{equation}\n A'=\\begin{pmatrix}\n B&ua^T\\\\\n -au^T&wa^T-aw^T\n \\end{pmatrix}.\n \\label{eq:block}\n\\end{equation}\nLet $r+z\\in R\\oplus K$ be in its kernel. The upper equation gives\n\\[\n Br+u\\inner{a}{z}=0,\n \\qquad r=-h\\inner{a}{z}.\n\\]\nSince $\\inner{u}{h}=0$, substitution into the lower equation leaves\n\\begin{equation}\n w\\inner{a}{z}-a\\inner{w}{z}=0.\n \\label{eq:lower}\n\\end{equation}\nIf $w,a$ are independent, both coefficients vanish. Then $r=0$ and $z\\in K\\cap a^\\perp\\cap w^\\perp$. These are two independent linear conditions on $K$, proving the rank claim. Also $x+a=u+w+a$ is perpendicular to this kernel.\n\nIf $w,a$ are dependent, $w\\wedge a=0$, so~\\eqref{eq:lower} holds for every $z\\in K$. The displayed graph follows. Its projection to $K$ is the identity, so its dimension is $\\dim K$. Finally, for every graph vector,\n\\[\n \\inner{x+a}{z-h\\inner{a}{z}}=\\inner{w+a}{z},\n\\]\nbecause $u\\perp K$ and $u\\perp h$. This vanishes for every $z$ exactly when $w+a=0$.", "references_in_statement_or_proof": ["eq:lower"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "thm:rho", "title": "Exact update of the exclusion radius", "environment": "theorem", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{thm:rho}\nUnder the hypotheses and notation of Theorem~\\ref{thm:kernel}, put $\\rho'=\\rho(x+a,A')$.\nIf $w,a$ are independent, then\n\\begin{equation}\n (\\rho')^2=\\rho^2+\\norm{w+a}^2.\n \\label{eq:rho-birth}\n\\end{equation}\nIf they are dependent, then\n\\begin{equation}\n (\\rho')^2=\\rho^2+\n \\frac{\\norm{h}^2\\inner{a}{w+a}^2}{1+\\norm{h}^2\\norm{a}^2}.\n \\label{eq:rho-graph}\n\\end{equation}\nConsequently $\\rho'\\geq\\rho$ for every legal move.", "proof_latex": "In the independent case, Theorem~\\ref{thm:kernel} says $x+a\\in\\im A'$. Therefore $(\\rho')^2=\\norm{x+a}^2=\\norm{u}^2+\\norm{w+a}^2$.\n\nIn the dependent case, define $J:K\\to V$ by $Jz=z-h\\inner{a}{z}$. Its image is the new kernel. Orthogonality of $K,R$ gives\n\\[\n J^*J=I_K+\\norm{h}^2aa^T,\n \\qquad J^*(x+a)=w+a.\n\\]\nWrite $v=w+a$ and $c=\\norm{h}^2$. The squared norm of the projection of $x+a$ onto $\\im J$ is\n\\[\n v^T(I_K+caa^T)^{-1}v.\n\\]\nThe inverse identity\n\\[\n (I_K+caa^T)^{-1}=I_K-\n \\frac{caa^T}{1+c\\norm{a}^2}\n\\]\nis verified by multiplication; its denominator is positive, including when $a=0$. The projection norm squared is thus\n\\[\n \\norm{v}^2-\\frac{c\\inner{a}{v}^2}{1+c\\norm{a}^2}.\n\\]\nSubtract this from $\\norm{x+a}^2=\\norm{u}^2+\\norm{v}^2$ to obtain~\\eqref{eq:rho-graph}. Both increments are nonnegative.", "references_in_statement_or_proof": ["eq:rho-graph", "thm:kernel"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "thm:minimum", "title": "Global optimal endpoint and uniqueness", "environment": "theorem", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{thm:minimum}\nFor every state $(x,A)$, with $u=P_{\\im A}x$ and $w=P_{\\ker A}x$, equation~\\eqref{eq:main} holds. The endpoint $u$ is reached by the legal move $a=-w$. If $u\\neq0$, every nonzero move preserving $\\rho$ must be exactly $-w$; after that move every further nonzero legal move strictly raises $\\rho$.", "proof_latex": "For any finite legal trajectory, Theorem~\\ref{thm:rho} gives $\\rho(s_n)\\geq\\rho(s_0)$. Every endpoint satisfies $\\norm{x_n}\\geq\\rho(s_n)$ because orthogonal projection cannot increase norm. Thus no reachable endpoint has norm below $\\rho(s_0)$.\n\nThe vector $a=-w$ belongs to $K$, yields $x'=u$, and is in the dependent case of Theorem~\\ref{thm:kernel}. Since $w+a=0$, it also yields $P_{\\ker A'}u=0$, so $\\rho'=\\norm{u}=\\rho$. This proves attainment.\n\nIf $u=0$, the only vector of minimum norm zero is the zero vector, which has just been reached. Suppose $u\\neq0$. Then $h\\neq0$. An independent move strictly raises $\\rho$ because independent $w,a$ cannot have $w+a=0$. For a nonzero dependent move, $w+a$ is a scalar multiple of $a$, and~\\eqref{eq:rho-graph} vanishes exactly when $w+a=0$. Hence the only nonzero move preserving $\\rho$ is $a=-w$. At its endpoint the new $w$ is zero and the new $u$ remains nonzero. Every later nonzero $a$ then has $\\inner{a}{w+a}=\\norm{a}^2>0$ and strictly raises $\\rho$. A trajectory attaining the initial minimum can therefore contain only zero moves, possibly one projection move, and then zero moves. Its endpoint is necessarily $u$.", "references_in_statement_or_proof": ["eq:main", "eq:rho-graph", "thm:kernel", "thm:rho"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "cor:origin", "title": "Exact origin test", "environment": "corollary", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{cor:origin}\nFrom an arbitrary state $(x,A)$, the origin is reachable if and only if $Ax=0$. If it is reachable, one move $a=-x$ reaches it.", "proof_latex": "Theorem~\\ref{thm:minimum} makes origin reachability equivalent to $P_{\\im A}x=0$, which by Lemma~\\ref{lem:decomposition} is $x\\in\\ker A$. The stated move is then legal, and $x\\wedge(-x)=0$.", "references_in_statement_or_proof": ["lem:decomposition", "thm:minimum"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "cor:closed", "title": "Closed-loop rigidity from zero memory", "environment": "corollary", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{cor:closed}\nFor a legal history starting at $(0,0)$, if its final endpoint is zero, then every area tensor along the history is zero. More strongly, if $j$ is its first step with $x_{j-1}\\wedge a_j\\neq0$, then\n\\[\n \\norm{x_n}\\geq\\rho(s_n)\\geq\\norm{x_j}>0\n \\qquad\\text{for every }n\\geq j.\n\\]", "proof_latex": "Before the first nonzero area increment, $A_{j-1}=0$. Thus $R=0$, $w=x_{j-1}$, and the nonzero wedge means $w,a_j$ are independent. Formula~\\eqref{eq:rho-birth} gives $\\rho(s_j)=\\norm{x_j}>0$. Monotonicity proves the inequality and rules out a later zero endpoint. If no such first increment exists, every $A_j$ is zero.", "references_in_statement_or_proof": ["eq:rho-birth"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "thm:exterior", "title": "Orthogonal exterior increments", "environment": "theorem", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{thm:exterior}\nEvery legal update satisfies, for each integer $j\\geq1$,\n\\begin{equation}\n E_j(A')=E_j(A)+\n \\norm{\\frac{\\alpha^{\\wedge(j-1)}}{(j-1)!}\\wedge x\\wedge a}^2.\n \\label{eq:exterior}\n\\end{equation}\nAll $E_j$ are therefore nondecreasing along legal histories.", "proof_latex": "The bivector $x\\wedge a$ is decomposable, so its square under exterior multiplication is zero. Since degree-two elements commute under exterior multiplication,\n\\[\n \\frac{(\\alpha+x\\wedge a)^{\\wedge j}}{j!}\n =\\frac{\\alpha^{\\wedge j}}{j!}\n +\\frac{\\alpha^{\\wedge(j-1)}}{(j-1)!}\\wedge x\\wedge a.\n\\]\nThe tensor $\\alpha$ is supported on $R=\\im A$. If $a=0$, the second summand vanishes. Otherwise choose an orthonormal basis beginning with $a/\\norm a$ and continuing through $R$ and its complement. The first summand has no $a$ component because $a\\perp R$. Every nonzero term of the second summand contains that component. The two summands are orthogonal. Taking squared norms proves~\\eqref{eq:exterior}, also in degrees exceeding $d$.", "references_in_statement_or_proof": ["eq:exterior"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "prop:scalar", "title": "Two scalar identities", "environment": "proposition", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{prop:scalar}\nLet $E=E_1(A)$, $N=\\norm{Ax}^2$, and\n\\[\n D=\\norm{x\\wedge a}^2=\\norm{x}^2\\norm{a}^2-\\inner{x}{a}^2.\n\\]\nFor every legal update,\n\\begin{equation}\n E'=E+D,\n \\qquad N'=N+\\norm{x+a}^2D.\n \\label{eq:scalar}\n\\end{equation}\nIf $E>0$, the weaker radius $\\sqrt{N/E}$ is nondecreasing and satisfies $\\sqrt{N/E}\\leq\\rho$.", "proof_latex": "The first identity is the case $j=1$ of Theorem~\\ref{thm:exterior}. Put $X=\\norm{x}^2$, $Y=\\norm{a}^2$, $c=\\inner{x}{a}$. Since $Aa=0$,\n\\[\n A'(x+a)=Ax+x(c+Y)-a(X+c).\n\\]\nThe vector $Ax$ is perpendicular to both $x$ and $a$. The squared norm of the remaining vector is\n\\[\n X(c+Y)^2+Y(X+c)^2-2c(c+Y)(X+c)\n =(XY-c^2)(X+Y+2c).\n\\]\nThis proves the second identity.\n\nFor completeness, a skew-adjoint operator has an orthonormal decomposition into $2\\times2$ skew blocks with nonnegative magnitudes $\\sigma_i$, plus its kernel. This follows by diagonalizing the symmetric operator $-A^2$ and pairing a unit vector $v$ with $Av/\\sigma_i$ in each positive eigenspace. Hence $E=\\sum_i\\sigma_i^2\\geq\\norm{A}_{\\mathrm{op}}^2$, and $\\norm{Ax}^2=\\norm{Au}^2\\leq E\\norm{u}^2$. Also $A(x+a)=Ax$, so $\\norm{x+a}^2\\geq N/E$. Therefore\n\\[\n \\frac{N'}{E'}=\n \\frac{E(N/E)+D\\norm{x+a}^2}{E+D}\\geq\\frac NE.\n\\]", "references_in_statement_or_proof": ["thm:exterior"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "thm:rank", "title": "Minimum steps to maximal rank", "environment": "theorem", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{thm:rank}\nLet $k=\\dim\\ker A$, $m=\\lfloor k/2\\rfloor$, and $w=P_{\\ker A}x$. The maximal rank reachable from $(x,A)$ is\n\\[\n \\rank A+2m=2\\lfloor d/2\\rfloor.\n\\]\nIf $m=0$, that rank is already attained. If $m>0$, the minimum number of legal steps needed to attain it is\n\\begin{equation}\n \\begin{cases}\n 2m,&w=0,\\\\\n 2m-1,&w\\neq0.\n \\end{cases}\n \\label{eq:ranksteps}\n\\end{equation}", "proof_latex": "Theorem~\\ref{thm:kernel} permits rank increases only by two, and at most $m$ such increases fit in dimension $d$. A rank increase resets the new kernel projection of the endpoint to zero. From a state with that projection zero, the next move cannot raise rank because its $w$ is zero. Thus at least one intervening move is required between increases; an initial intervening move is also required when the initial $w=0$. This proves the lower bounds.\n\nFor attainment, if $k\\geq2$ and $w\\neq0$, choose $a\\in K\\setminus\\R w$. It raises rank by two and resets $w$ to zero. If $w=0$, first choose any nonzero $a\\in K$. This is a rank-preserving move and has new kernel projection nonzero, by the last assertion of Theorem~\\ref{thm:kernel}. One can then choose a vector independent of that projection and raise rank. Repeat while at least two kernel dimensions remain. This attains exactly the stated number of steps. The parity identity follows because the rank of a real skew operator is even.", "references_in_statement_or_proof": ["thm:kernel"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "cor:parity", "title": "Even and odd ambient dimensions", "environment": "corollary", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{cor:parity}\nIn even dimension, a full-rank state permits only the zero move. In odd dimension, every state permits a nonzero move. From $(0,0)$, maximal rank can be reached in $d$ steps for even $d$ and $d-1$ steps for odd $d\\geq1$.", "proof_latex": "The kernel is zero exactly at full rank. An odd-dimensional real skew matrix always has nonzero kernel. Apply Theorem~\\ref{thm:rank} with $k=d$ and $w=0$; the cases $d=0,1$ already have maximal rank zero.", "references_in_statement_or_proof": ["thm:rank"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "thm:launch", "title": "Orthogonal launch family", "environment": "theorem", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{thm:launch}\nLet $e_1,\\ldots,e_d$ be orthonormal. The prefix $e_1,\\ldots,e_n$, $0\\leq n\\leq d$, is legal from zero and yields\n\\[\n x_n=\\sum_{i=1}^n e_i,\\qquad\n A_n=\\sum_{1\\leq i<j\\leq n}e_i\\wedge e_j.\n\\]\nIts rank is $2\\lfloor n/2\\rfloor$. For $n\\geq1$,\n\\begin{equation}\n \\rho_n^2=\\begin{cases}n,&n\\text{ even},\\\\ n-1/n,&n\\text{ odd},\\end{cases}\n \\qquad E_j(A_n)=\\binom{n}{2j}.\n \\label{eq:launch}\n\\end{equation}\nFor $n=0$, $\\rho_0=0$. Unused coordinate directions remain in the kernel. In the occupied $n$ coordinates, the characteristic polynomial is\n\\begin{equation}\n \\det(tI-A_n)=\\sum_{j=0}^{\\lfloor n/2\\rfloor}\\binom{n}{2j}t^{n-2j}\n =\\frac{(t+1)^n+(t-1)^n}{2}.\n \\label{eq:launchpoly}\n\\end{equation}", "proof_latex": "Before step $i$, the area is supported on earlier coordinates, so it annihilates $e_i$. Formula~\\eqref{eq:area} gives the state. In the occupied coordinates the matrix has every upper-triangular entry one. If it annihilates a vector $v$, subtracting successive row equations gives $v_{i+1}=-v_i$. The first row then forces $v_1=0$ when $n$ is even, and imposes no additional condition when $n$ is odd. In the latter case the kernel is spanned by $k_n=(1,-1,\\ldots,1)$, with $\\norm{k_n}^2=n$ and $\\inner{x_n}{k_n}=1$. The rank and projection formulas follow.\n\nThe coefficient of a basis $2j$-wedge in $\\alpha_n^{\\wedge j}/j!$ is the Pfaffian of the corresponding principal submatrix. Every such submatrix is the same upper-one skew matrix of size $2j$. Its Pfaffian is one: expansion along its first row gives the previous Pfaffian multiplied by $\\sum_{i=2}^{2j}(-1)^i=1$, starting with the empty Pfaffian one. There are $\\binom{n}{2j}$ principal subsets. Their squared coefficients sum to that number, proving the exterior formula. Expanding $\\det(tI-A_n)$ by principal minors, whose even determinants are these squared Pfaffians and whose odd determinants vanish, proves the first polynomial identity. The binomial theorem proves the second.", "references_in_statement_or_proof": ["eq:area"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "thm:accessibility", "title": "Three steps are sufficient and necessary for endpoint interior at a specified state", "environment": "theorem", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{thm:accessibility}\nStart in $\\R^3$ at $x=(1,1,0)^T$, $k=(0,0,1)^T$, equivalently $A=e_1\\wedge e_2$. The set of endpoints reachable in three legal moves has nonempty interior in $\\R^3$. The union of endpoints reachable in at most two moves has empty interior.", "proof_latex": "Use scalar controls $p,q,r$ in~\\eqref{eq:axial}. All are legal and all intermediate $k$ remain nonzero. Direct substitution gives the polynomial endpoint map\n\\begin{equation}\n F(p,q,r)=\n \\begin{pmatrix}\n 1+pq+pr+qr+p^2qr\\\\\n 1-pq-pr-qr+p^2qr\\\\\n p+q+r-2pqr\n \\end{pmatrix}.\n \\label{eq:endpointpoly}\n\\end{equation}\nFor clarity, after the first two steps the endpoint is\n\\[\n (1+pq,1-pq,p+q)^T,\n\\]\nand the axial vector is\n\\[\n (p+q+p^2q,-p-q+p^2q,1-2pq)^T.\n\\]\nAdding $r$ times the latter vector proves~\\eqref{eq:endpointpoly}. Differentiation and expansion of a $3\\times3$ determinant give\n\\[\n \\det DF=2p(q-r)(2p^2qr+p^2-pq-pr+2qr).\n\\]\nAt $(p,q,r)=(1,1,2)$ the endpoint is $(8,-2,0)^T$ and the determinant is $-12$. The finite-dimensional inverse function theorem therefore gives an open neighborhood of this endpoint contained in the three-step reachable set.\n\nAfter at most two steps, every endpoint satisfies $x_1+x_2=2$, as seen in the displayed two-step formula and its one-step and empty-word cases. This plane has empty interior in $\\R^3$.", "references_in_statement_or_proof": ["eq:axial", "eq:endpointpoly"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "thm:accessibility-general", "title": "Three-dimensional endpoint accessibility classification", "environment": "theorem", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{thm:accessibility-general}\nLet $V=\\R^3$ and $A\\neq0$. The finite reachable endpoint set has nonempty interior if and only if $Ax\\neq0$. Whenever $Ax\\neq0$, the exact minimum number of steps needed for an endpoint set with nonempty interior is three.", "proof_latex": "If $Ax=0$, then $x\\in\\ker A$, which is a line. Every legal input lies on that line, writes zero wedge, and leaves the kernel fixed. All endpoints remain on the line, so the reachable set has empty interior.\n\nIf $Ax\\neq0$, let $k=k(A)$. An orientation-preserving orthogonal change of coordinates puts the state in the form\n\\[\n x=(b,0,z)^T,\\qquad k=(0,0,c)^T,\n \\qquad b,c>0,\\ z\\in\\R.\n\\]\nThree scalar controls $p,q,r$ in~\\eqref{eq:axial} give\n\\[\n F_{b,c,z}(p,q,r)=\n \\begin{pmatrix}\n b+bc^2p^2qr+bczpqr\\\\\n -bc(pq+pr+qr)\\\\\n z+c(p+q+r-b^2pqr)\n \\end{pmatrix}.\n\\]\nThis follows by substituting the first two steps, whose endpoint is $(b,-bcpq,z+c(p+q))^T$. At $(1,1,2)$ the Jacobian is\n\\[\n \\begin{pmatrix}\n 2bc(2c+z)&2bc(c+z)&bc(c+z)\\\\\n -3bc&-3bc&-2bc\\\\\n c(1-2b^2)&c(1-2b^2)&c(1-b^2)\n \\end{pmatrix}.\n\\]\nSubtract the second column from the first. The first column becomes $(2bc^2,0,0)^T$, and the remaining $2\\times2$ determinant is $-bc^2(1+b^2)$. Hence\n\\[\n \\det DF_{b,c,z}(1,1,2)=-2b^2c^4(1+b^2)\\neq0.\n\\]\nThe inverse function theorem gives endpoint interior after three steps. After at most two steps, the first coordinate of every endpoint remains $b$, so those endpoints lie in a plane and have empty interior. Orthogonal covariance transports both statements back to the original coordinates.", "references_in_statement_or_proof": ["eq:axial"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "thm:dormant", "title": "Invariant inaccessible summand", "environment": "theorem", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{thm:dormant}\nFor a state $(x,A)$, let $K=\\ker A$, $u=P_{\\im A}x$, and define\n\\[\n C=\\Span\\{A^j u:j\\geq0\\},\\qquad S=K\\oplus C,\n \\qquad H=S^\\perp.\n\\]\nThen $S,H$ are $A$-invariant and $A|_H$ is invertible. Every future legal input and every future endpoint lies in $S$; the block $A|_H$ never changes. Replacing it by any invertible skew-adjoint operator on $H$ leaves all future legal input words and endpoints unchanged.\n\nThe subspace $S$ is the smallest $A$-invariant subspace containing $x$ and $K$. This does not assert that it is the smallest behavioral realization.", "proof_latex": "The cyclic subspace $C$ is contained in $\\im A$ and is $A$-invariant. Indeed, the span stabilizes in finite dimension, and multiplication by $A$ shifts each spanning vector to the next. Since $A$ is skew-adjoint, the orthogonal complement of an invariant subspace is invariant. Thus $S$ and $H$ are invariant. Also $H\\subseteq K^\\perp$, so the restriction to $H$ has zero kernel and is invertible.\n\nInitially $x\\in S$ and $\\ker A\\subseteq S$. Suppose at some step the endpoint lies in $S$, the area is block diagonal on $S\\oplus H$, and its block on $H$ remains invertible. Any legal input then belongs to $S$. The wedge of two vectors in $S$ acts only on $S$, so the update preserves this block structure and leaves the $H$ block fixed. Induction proves the trajectory assertions. The same induction compares any other invertible skew block on $H$, since an invertible block contributes no kernel vectors.\n\nFinally, any invariant subspace containing $x$ and $K$ contains $u=x-P_Kx$, and then every $A^ju$. It therefore contains $S$, proving the stated minimality.", "references_in_statement_or_proof": [], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "prop:subdivision", "title": "Reversal and subdivision", "environment": "proposition", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{prop:subdivision}\nLet $a$ be legal at $(x,A)$. The algebraic inverse displacement $-a$ is legal immediately after that move if and only if $x\\wedge a=0$. If $x\\wedge a\\neq0$ and $m\\geq2$ is an integer, replacing $a$ by $m$ successive copies of $a/m$ fails legality at the second copy.", "proof_latex": "Since $Aa=0$,\n\\[\n (A+x\\wedge a)a=\\norm{a}^2x-\\inner{x}{a}a.\n\\]\nIf $a\\neq0$, this is zero exactly when $x$ is parallel to $a$, equivalent to $x\\wedge a=0$. If $a=0$, both assertions hold trivially. When the reverse move is legal, substitution shows that it restores both $x$ and $A$.\n\nAfter the first fractional move the area is $A+x\\wedge(a/m)$. Applying it to the second proposed $a/m$ gives\n\\[\n \\frac1{m^2}\\bigl(\\norm{a}^2x-\\inner{x}{a}a\\bigr),\n\\]\nwhich is nonzero when $x\\wedge a\\neq0$.", "references_in_statement_or_proof": [], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "thm:continuous", "title": "Continuous collapse and a quantitative refinement bound", "environment": "theorem", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{thm:continuous}\nSuppose $x,A$ are absolutely continuous on a compact interval, $A(t)$ is skew-adjoint, and\n\\[\n \\dot x=v,\\qquad \\dot A=x\\wedge v,\\qquad Av=0\n\\]\nhold almost everywhere. If $A(0)=0$, then $A(t)=0$ everywhere and $x\\wedge\\dot x=0$ almost everywhere.\n\nFor a finite legal discrete trajectory with $A_0=0$, set\n\\[\n M=\\max_{0\\leq i\\leq n}\\norm{x_i},\\qquad\n L=\\sum_{i=1}^n\\norm{a_i},\\qquad\n \\delta=\\max_{1\\leq i\\leq n}\\norm{a_i},\n\\]\nwith $\\delta=0$ for the empty word. Then\n\\begin{equation}\n E_1(A_n)\\leq M^2L\\delta.\n \\label{eq:refinement}\n\\end{equation}\nThus a family with bounded $M,L$ and $\\delta\\to0$ has area tending to zero at every prefix, uniformly within each trajectory.", "proof_latex": "Absolute continuity permits the chain rule for the quadratic function $\\norm A_F^2/2$. Its derivative is $\\inner{A}{x\\wedge v}_F=2\\inner{x}{Av}=0$ almost everywhere. Hence it remains zero, and positive definiteness forces $A=0$. The area differential equation then gives $x\\wedge\\dot x=0$.\n\nIn the discrete case, sum the exact $E_1$ increments from~\\eqref{eq:scalar}. Each is at most $\\norm{x_{i-1}}^2\\norm{a_i}^2$. Bound the first factor by $M^2$ and $\\norm{a_i}^2$ by $\\delta\\norm{a_i}$, obtaining~\\eqref{eq:refinement}. The same upper bound applies to every prefix because every summand is nonnegative.", "references_in_statement_or_proof": ["eq:refinement", "eq:scalar"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "prop:closure", "title": "A nonclosed endpoint set", "environment": "proposition", "component": "area_feedback", "status": "manuscript_proved", "statement_latex": "\\label{prop:closure}\nFor the state $x_0=(1,1,0)^T$, $A_0=e_1\\wedge e_2$ in $\\R^3$, the closure of $\\Reach(x_0,A_0)$ contains points other than $x_0$ of norm $\\sqrt2$. None of those other points is reachable by a finite legal word. Consequently this reachable endpoint set is not closed.", "proof_latex": "Consider the polynomial ordinary differential equation\n\\[\n \\dot x=k,\\qquad \\dot k=x\\times k,\n \\qquad x(0)=x_0,\\ k(0)=e_3.\n\\]\nIt has a smooth solution on a sufficiently small interval. Direct differentiation yields\n\\[\n \\norm{k(t)}^2=1,\\qquad x(t)\\cdot k(t)=t,\n \\qquad \\norm{x(t)}^2=2+t^2.\n\\]\nDefine $u(t)=x(t)-t k(t)$. Then $\\norm{u(t)}^2=2$, while\n\\[\n u'(t)=-t\\dot k(t),\\qquad\n u''(0)=-x_0\\times e_3=(-1,1,0)^T.\n\\]\nThus $u(T)\\neq x_0$ for every sufficiently small positive $T$.\n\nFor each positive integer $n$, take $n$ steps of~\\eqref{eq:axial} with scalar $T/n$. These are finite legal histories and their axial vectors stay nonzero. Their endpoints $(x^{(n)},k^{(n)})$ converge to $(x(T),k(T))$. Here is the relevant elementary convergence argument. On a compact tube around the short smooth solution, the polynomial vector field has a Lipschitz constant $C_1$ and bounded derivative along the solution. A one-step Taylor estimate gives local error at most $C_2h^2$, with $h=T/n$. The error recurrence\n\\[\n e_{j+1}\\leq(1+C_1h)e_j+C_2h^2,\\qquad e_0=0,\n\\]\ngives $e_n\\leq C_2h(e^{C_1T}-1)/C_1$ when $C_1>0$, or $e_n\\leq C_2Th$ when $C_1=0$. For large $n$ this estimate also keeps the approximations inside the chosen tube, closing the induction.\n\nAppend to each discrete history the exact projection move along its current kernel. The final endpoint becomes\n\\[\n y_n=x^{(n)}-\n \\frac{x^{(n)}\\cdot k^{(n)}}{\\norm{k^{(n)}}^2}k^{(n)}.\n\\]\nContinuity and $\\norm{k(T)}=1$ imply $y_n\\to u(T)$. Hence $u(T)$ lies in the closure. At the initial state, $\\rho=\\sqrt2$ and the unique finite-word minimizer is $x_0$, by Theorem~\\ref{thm:minimum}. Since $u(T)\\neq x_0$ has the same norm, it is not finitely reachable.", "references_in_statement_or_proof": ["eq:axial", "thm:minimum"], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "conj:interior", "title": "Interior for cyclic states in odd dimension", "environment": "conjecture", "component": "area_feedback", "status": "conjecture", "statement_latex": "\\label{conj:interior}\nLet $d\\geq5$ be odd, let $\\rank A=d-1$, and suppose\n\\[\n \\ker A\\oplus\\Span\\{A^jP_{\\im A}x:j\\geq0\\}=V.\n\\]\nThen the finite reachable endpoint set has nonempty interior in $V$.", "proof_latex": "", "references_in_statement_or_proof": [], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "thm:alt-interval", "title": "Interval update and terminal formula", "environment": "theorem", "component": "algebraic_alternative", "status": "manuscript_proved", "statement_latex": "\\label{thm:alt-interval}\nFor $1\\leq m\\leq N-1$,\n\\begin{equation}\n D(U_m)=U_{\\min(m,N-m-1)},\\qquad\n T(U_m)=U_{\\max\\{m,\\,2\\min(m,N-m-1)\\}}.\n \\label{eq:alt-interval-step}\n\\end{equation}\nPut $n=N-1$, let $r$ be the smallest nonnegative integer for which\n$2^rm\\geq n/2$, and set $a=2^rm$. Then\n\\begin{equation}\n F(U_m)=U_{\\max\\{a,\\,2(n-a)\\}}.\n \\label{eq:alt-interval-final}\n\\end{equation}\nThe nonzero intervals with $m\\leq N-1$ are terminal exactly when\n$3m\\geq2(N-1)$. The boundary states $U_0$ and $U_N$ are terminal.", "proof_latex": "Each $t^i\\in U_m$ has only one possible nonzero pairing with a basis element,\nnamely $t^{N-i}$. That partner is absent from $U_m$ exactly when\n$i\\leq N-m-1$. Distinct exponents have distinct partners, so there is no\nadditional cancellation between basis columns. This proves the radical formula.\nIf $d=\\min(m,N-m-1)$, products in $U_d^2$ span exactly the exponents\n$2,\\ldots,2d$ when $d>0$, and give zero when $d=0$. Since $2d\\leq N-1$,\nno product in this range is truncated. Adding $U_m$ proves the update formula.\n\nWhile $m<n/2$, the endpoint of the interval doubles. At its first value\n$a\\geq n/2$, the update becomes $a\\mapsto\\max\\{a,2(n-a)\\}$.\nIf $a\\geq2n/3$, it is already fixed. Otherwise the next value $2(n-a)$ is\nstrictly greater than $2n/3$ and is fixed. This proves both the terminal formula\nand the fixed-interval criterion. The zero space is fixed. Finally $U_N$ is\na subalgebra, and is therefore fixed; equivalently, its radical is $kt^N$,\nwhose square is zero.", "references_in_statement_or_proof": [], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "thm:alt-tensor", "title": "An exact tensor activation law", "environment": "theorem", "component": "algebraic_alternative", "status": "manuscript_proved", "statement_latex": "\\label{thm:alt-tensor}\nLet $B=k[t]/(t^5)$, $\\tau=[t^4]$, and $U=\\operatorname{span}\\{t,t^2\\}$.\nThe state $U$ is terminal. For an integer $r\\geq1$, put\n\\[\n W_r=U^{\\otimes r}\\subset\n B^{\\otimes r}=k[x_1,\\ldots,x_r]/(x_1^5,\\ldots,x_r^5),\n\\]\nwith the tensor trace extracting $x_1^4\\cdots x_r^4$. Then\n\\begin{equation}\n F(W_r)=T(W_r),\\qquad\n \\dim F(W_r)=2^r+3^r-r-2.\n \\label{eq:alt-tensor}\n\\end{equation}\nFor $r\\geq2$, its terminal radical has dimension\n$3^r-2^r-r-1$ and has square zero.", "proof_latex": "On $U$, the only nonzero basis pairing is $\\beta(t^2,t^2)=1$.\nThus $D(U)=kt$ and $D(U)^2=kt^2\\subset U$, proving terminality.\n\nThe initial monomial exponent set of $W_r$ is $S_r=\\{1,2\\}^r$.\nAn initial monomial can pair with another initial monomial only when both\nhave every exponent equal to two. Hence $D(W_r)$ contains every initial\nbasis monomial except that all-two monomial.\n\nA sum of two radical exponent vectors lies in $\\{2,3,4\\}^r$. If a coordinate\nof the sum is two, both factors have a one there and are radical. If there is\nno two, coordinates four force the split $2+2$, while coordinates three permit\n$1+2$ or $2+1$. Both factors can be radical exactly when there are at least\ntwo coordinates three. Therefore the product exponent set is\n\\[\n P_r=\\{c\\in\\{2,3,4\\}^r:\n       c\\text{ has a two or at least two threes}\\}.\n\\]\nIts complement consists of the all-four vector and the $r$ vectors having\none three and otherwise fours. Thus $|P_r|=3^r-r-1$.\nThe intersection $S_r\\cap P_r$ consists only of the all-two vector.\nDistinct surviving monomials are linearly independent, so\n$\\dim T(W_r)=2^r+(3^r-r-1)-1$, as claimed.\n\nIt remains to prove terminality. The case $r=1$ was checked above.\nFor $r\\geq2$, every element of $S_r$ has its complementary exponent vector\n$4-c$ in $P_r$: the complement has a two, or it is all threes. Every vector\nin $P_r$ without a four has its complement in $S_r$. A vector in $P_r$ with\na four has a complementary zero coordinate, which occurs in neither set.\nThe new radical therefore consists exactly of product monomials having a\nfour. Every coordinate of every product monomial is at least two; multiplying\ntwo new radical monomials exceeds exponent four in a coordinate and gives zero.\nThus the new radical has square zero, and the first update is terminal.\nThere are $2^r$ vectors in $P_r$ without a four when $r\\geq2$, giving the\nstated radical dimension.", "references_in_statement_or_proof": [], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}
+{"claim_id": "thm:spectral-rank-one", "title": "Positive rank-one spectral representation", "environment": "theorem", "component": "spectral_appendix", "status": "manuscript_proved", "statement_latex": "\\label{thm:spectral-rank-one}\nFor $A'=A+x\\wedge a$, the positive squared skew frequencies of $A'$,\ncounting multiplicities, are as follows.\n\\begin{enumerate}\n\\item If $D_0=0$, they are the eigenvalues of\n\\[\n H^+=H+zz^T.\n \\tag{S2}\n\\]\nThe rank of $A'$ is $2m$, and its kernel has dimension $k$.\n\\item If $D_0>0$, define\n\\[\n \\widetilde H=\n \\begin{pmatrix}H&0\\\\0&0\\end{pmatrix},\n \\qquad\n \\widetilde z=\n \\begin{pmatrix}z\\\\\\sqrt{D_0}\\end{pmatrix}.\n\\]\nThe positive squared skew frequencies are the eigenvalues of\n\\[\n H^+=\\widetilde H+\\widetilde z\\widetilde z^T.\n \\tag{S3}\n\\]\nThe rank of $A'$ is $2m+2$, and its kernel has dimension $k-2$.\n\\end{enumerate}\nIn both cases the displayed matrix $H^+$ is positive definite on its\nstated dimension, with the zero-dimensional case interpreted as above.", "proof_latex": "For $t>0$, the matrix $M=tI-A$ is invertible, because the eigenvalues of\na real skew-adjoint operator are zero or purely imaginary. Write\n\\[\n \\beta=\\norm a^2,\\qquad \\gamma=\\inner x a=\\inner w a,\\qquad\n f(t)=x^TM^{-1}x.\n\\]\nThe admissibility condition $Aa=0$, together with skew-adjointness,\ngives both\n\\[\n M^{-1}a=\\frac at,\\qquad a^TM^{-1}=\\frac{a^T}{t}.\n \\tag{S4}\n\\]\nThe update can be written as a rank-two perturbation:\n\\[\n tI-A'=M+[-x,\\ a]\\,[a,\\ x]^T.\n\\]\nThe matrix determinant lemma\n$\\det(M+UV^T)=\\det M\\det(I+V^TM^{-1}U)$ now gives\n\\[\n\\begin{split}\n \\frac{\\det(tI-A')}{\\det(tI-A)}\n &=\\det\n \\begin{pmatrix}\n 1-\\gamma/t&\\beta/t\\\\\n -f(t)&1+\\gamma/t\n \\end{pmatrix}\\\\\n &=1-\\frac{\\gamma^2}{t^2}+\\frac{\\beta f(t)}{t}.\n\\end{split}\n\\tag{S5}\n\\]\nThere is no symmetry assumption on $M^{-1}$ in this calculation; the\ntwo identities in~(S4) supply the two off-diagonal contractions.\n\nOn $K$, $M^{-1}$ is $I/t$. On the plane $E_i$,\n\\[\n (tI-A|_{E_i})^{-1}\n =\\frac{tI+A|_{E_i}}{t^2+\\sigma_i^2}.\n\\]\nIts skew part makes no contribution to a quadratic form. Orthogonality\nof the invariant decomposition therefore yields\n\\[\n f(t)=\\frac{\\norm w^2}{t}\n      +\\sum_{i=1}^m\n        \\frac{t\\norm{u_i}^2}{t^2+\\sigma_i^2}.\n \\tag{S6}\n\\]\nSubstituting into~(S5), using $z_i^2=\\beta\\norm{u_i}^2$, gives the exact\nrational identity\n\\[\n \\boxed{\\quad\n \\frac{\\det(tI-A')}{\\det(tI-A)}\n =1+\\frac{D_0}{t^2}\n  +\\sum_{i=1}^m\\frac{z_i^2}{t^2+\\sigma_i^2}.\n \\quad}\n \\tag{S7}\n\\]\nAll quantities have been defined for $t>0$, where no denominator\nvanishes.\n\nThe original characteristic polynomial is\n\\[\n \\det(tI-A)=t^k\\det(t^2I_m+H).\n \\tag{S8}\n\\]\nIf $D_0=0$, applying the rank-one determinant lemma to\n$t^2I_m+H+zz^T$ transforms~(S7)--(S8) into\n\\[\n \\det(tI-A')=t^k\\det(t^2I_m+H+zz^T).\n \\tag{S9}\n\\]\nFor $m>0$, $H$ is positive definite, and adding $zz^T$ preserves positive\ndefiniteness. Thus the determinant on the right has exactly $m$ positive\nsquared frequencies and no additional zero root. If $m=0$, its determinant\nis one. In either case the zero root has multiplicity exactly $k$.\nThis proves the first case.\n\nIf $D_0>0$, apply the same lemma in dimension $m+1$:\n\\[\n\\begin{split}\n&\\det(t^2I_{m+1}+\\widetilde H+\\widetilde z\\widetilde z^T)\\\\\n&\\qquad=\nt^2\\det(t^2I_m+H)\n\\left(1+\\frac{D_0}{t^2}\n      +\\sum_{i=1}^m\\frac{z_i^2}{t^2+\\sigma_i^2}\\right).\n\\end{split}\n\\]\nSince $k\\geq2$, equations~(S7)--(S8) imply\n\\[\n \\det(tI-A')\n =t^{k-2}\n  \\det(t^2I_{m+1}+\\widetilde H+\\widetilde z\\widetilde z^T).\n \\tag{S10}\n\\]\nFor a vector $(v,s)\\in\\mathbb R^m\\oplus\\mathbb R$,\n\\[\n (v,s)^T H^+(v,s)\n =v^THv+\\bigl(z^Tv+\\sqrt{D_0}\\,s\\bigr)^2.\n\\]\nIf this is zero, positive definiteness of $H$ forces $v=0$, and\n$D_0>0$ then forces $s=0$. The same argument covers $m=0$ directly.\nThus $H^+$ is positive definite, and~(S10) gives exactly $m+1$\npositive squared frequencies and a zero root of multiplicity $k-2$.\n\nThe equalities have been proved for every positive real $t$. Both sides\nof~(S9) and~(S10) are polynomials, so they are identical polynomials.\nThey consequently determine the complete characteristic polynomial,\nnot merely its values on the positive real axis. Real skew-adjoint\nnormal form then identifies the positive squared frequencies with the\neigenvalues of $H^+$ as claimed.", "references_in_statement_or_proof": [], "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex", "proof_audit_file": "audits/PROOF_AUDIT.txt", "priority_status": "No per-claim priority certification; see audits/NOVELTY_AUDIT.txt.", "verification_limit": "Manuscript proof status is not formal certification; finite code checks are separate."}

data/worked_examples.jsonl

@@ -0,0 +1,8 @@
+{"example_id": "empty-dimension-zero", "dimension": 0, "initial_state_json": "{\"x\":[],\"A\":[]}", "controls_json": "[]", "all_controls_legal": true, "first_illegal_step": 0, "final_legal_prefix_state_json": "{\"x\":[],\"A\":[]}", "final_rank": 0, "final_rho_squared": "0", "note": "Empty history; endpoint, area, rank, and radius are zero.", "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex"}
+{"example_id": "one-dimensional-return", "dimension": 1, "initial_state_json": "{\"x\":[\"0\"],\"A\":[[\"0\"]]}", "controls_json": "[[\"1\"], [\"-1\"]]", "all_controls_legal": true, "first_illegal_step": 0, "final_legal_prefix_state_json": "{\"x\":[\"0\"],\"A\":[[\"0\"]]}", "final_rank": 0, "final_rho_squared": "0", "note": "No signed area can be written in dimension one.", "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex"}
+{"example_id": "two-dimensional-shutdown", "dimension": 2, "initial_state_json": "{\"x\":[\"0\",\"0\"],\"A\":[[\"0\",\"0\"],[\"0\",\"0\"]]}", "controls_json": "[[\"1\", \"0\"], [\"0\", \"1\"]]", "all_controls_legal": true, "first_illegal_step": 0, "final_legal_prefix_state_json": "{\"x\":[\"1\",\"1\"],\"A\":[[\"0\",\"1\"],[\"-1\",\"0\"]]}", "final_rank": 2, "final_rho_squared": "2", "note": "The resulting rank-two memory permits only zero moves.", "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex"}
+{"example_id": "three-dimensional-kernel-rotation", "dimension": 3, "initial_state_json": "{\"x\":[\"0\",\"0\",\"0\"],\"A\":[[\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\"]]}", "controls_json": "[[\"1\", \"0\", \"0\"], [\"0\", \"1\", \"0\"], [\"0\", \"0\", \"1\"]]", "all_controls_legal": true, "first_illegal_step": 0, "final_legal_prefix_state_json": "{\"x\":[\"1\",\"1\",\"1\"],\"A\":[[\"0\",\"1\",\"1\"],[\"-1\",\"0\",\"1\"],[\"-1\",\"-1\",\"0\"]]}", "final_rank": 2, "final_rho_squared": "8/3", "note": "The kernel rotates to span(1,-1,1); rho squared is 8/3.", "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex"}
+{"example_id": "three-dimensional-optimal-projection", "dimension": 3, "initial_state_json": "{\"x\":[\"0\",\"0\",\"0\"],\"A\":[[\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\"]]}", "controls_json": "[[\"1\", \"0\", \"0\"], [\"0\", \"1\", \"0\"], [\"0\", \"0\", \"1\"], [\"-1/3\", \"1/3\", \"-1/3\"]]", "all_controls_legal": true, "first_illegal_step": 0, "final_legal_prefix_state_json": "{\"x\":[\"2/3\",\"4/3\",\"2/3\"],\"A\":[[\"0\",\"5/3\",\"1\"],[\"-5/3\",\"0\",\"1/3\"],[\"-1\",\"-1/3\",\"0\"]]}", "final_rank": 2, "final_rho_squared": "8/3", "note": "The unique finite minimum from the three-step state is (2/3,4/3,2/3).", "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex"}
+{"example_id": "hidden-parameter-one-after-probe", "dimension": 3, "initial_state_json": "{\"x\":[\"0\",\"0\",\"0\"],\"A\":[[\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\"]]}", "controls_json": "[[\"1\", \"0\", \"0\"], [\"0\", \"1\", \"0\"], [\"0\", \"0\", \"1\"]]", "all_controls_legal": true, "first_illegal_step": 0, "final_legal_prefix_state_json": "{\"x\":[\"1\",\"1\",\"1\"],\"A\":[[\"0\",\"1\",\"1\"],[\"-1\",\"0\",\"1\"],[\"-1\",\"-1\",\"0\"]]}", "final_rank": 2, "final_rho_squared": "8/3", "note": "Lambda=1; the common e3 probe leaves rho squared 8/3.", "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex"}
+{"example_id": "hidden-parameter-two-after-probe", "dimension": 3, "initial_state_json": "{\"x\":[\"0\",\"0\",\"0\"],\"A\":[[\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\"]]}", "controls_json": "[[\"2\", \"0\", \"0\"], [\"-1\", \"1\", \"0\"], [\"0\", \"0\", \"1\"]]", "all_controls_legal": true, "first_illegal_step": 0, "final_legal_prefix_state_json": "{\"x\":[\"1\",\"1\",\"1\"],\"A\":[[\"0\",\"2\",\"1\"],[\"-2\",\"0\",\"1\"],[\"-1\",\"-1\",\"0\"]]}", "final_rank": 2, "final_rho_squared": "7/3", "note": "Lambda=2; the same probe leaves rho squared 7/3 and kernel span(1,-1,2).", "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex"}
+{"example_id": "rectangle-gate-failure", "dimension": 2, "initial_state_json": "{\"x\":[\"0\",\"0\"],\"A\":[[\"0\",\"0\"],[\"0\",\"0\"]]}", "controls_json": "[[\"1\", \"0\"], [\"0\", \"1\"], [\"-1\", \"0\"], [\"0\", \"-1\"]]", "all_controls_legal": false, "first_illegal_step": 3, "final_legal_prefix_state_json": "{\"x\":[\"1\",\"1\"],\"A\":[[\"0\",\"1\"],[\"-1\",\"0\"]]}", "final_rank": 2, "final_rho_squared": "2", "note": "The third control is illegal. Final state records only the legal prefix; no illegal update is performed.", "source_file": "manuscript/Avenyra_Area_Feedback_v1.0.0.tex"}

docs/AI_AGENT_GUIDE.md

@@ -0,0 +1,49 @@
+# AI-agent reading and review guide
+
+This repository is research material. This guide supplies task-local conventions for a requested examination; it does not override the reviewing agent's governing instructions.
+
+## Read in this order
+
+1. Read [the research card](../README.md) and its status table.
+2. Read the definitions and the kernel-transport proof in [the manuscript](../manuscript/Avenyra_Area_Feedback_v1.0.0.pdf), using [LaTeX](../manuscript/Avenyra_Area_Feedback_v1.0.0.tex) for exact statements.
+3. Read the global projection theorem and its equality cases.
+4. Read [the proof audit](../audits/PROOF_AUDIT.txt) and run the [reproduction commands](REPRODUCIBILITY.md).
+5. Read [the novelty audit](../audits/NOVELTY_AUDIT.txt) before making any priority assertion.
+
+The source of truth is the complete manuscript. Structured rows are indexes into it. `manuscript_proved` means a supplied proof exists; inspect that proof rather than treating the label as an oracle.
+
+## Preserve these conventions
+
+- Column vectors; positive real Euclidean metric; finite dimension; (A^T=-A).
+- Legality is exactly (Aa=0), tested at the pre-move state.
+- The simultaneous update is (x'=x+a), (A'=A+xa^T-ax^T).
+- Reachability in the central theorem means finite input words, including the empty word.
+- The unique minimum is an endpoint, not a unique control word.
+- Approximate gates, indefinite metrics, continuous interpolation, and reachable-set closure require new arguments.
+- The full area tensor can contain inaccessible blocks; ((x,ker A)) can also discard predictively necessary information.
+
+## Suggested review tasks
+
+| Task | Deliverable |
+|---|---|
+| Proof audit | A claim-label-specific gap, confirmation of a logical dependency, or an exact counterexample. |
+| Hidden-equivalence audit | A candidate correspondence with the update, prefix legality, endpoint, input labels, and metric explicitly tracked. |
+| Reproduction | Runtime versions, exact commands, exit codes, and comparison with captured outputs. |
+| Extension | A fully stated theorem with hypotheses and proof, or an explicitly labeled conjecture. |
+| Prior-art search | Mechanism-based queries, retrieved primary sources, exact matching statements, and remaining gaps. |
+
+Never infer a physical antenna, energy-free computer, or intelligence gain from the imaginative seed. The demonstrated applications are internal optimization and removal of inaccessible blocks within this model.
+
+## Report format
+
+For each finding report:
+
+1. Claim label and source location.
+2. Original assumptions and the precise issue or extension.
+3. A complete argument, exact counterexample, or reproducible command.
+4. Whether the outcome is proved, checked in finite cases, conjectured, or unresolved.
+5. Consequences for dependent claims and which files require correction.
+
+For priority findings include the source URL, date, and statement that actually matches. No finite search establishes worldwide absence of prior art. Agreement among agents is not mathematical certification.
+
+Do not silently change the original manuscript or audit history. Present a corrected version or patch with a claim-by-claim account of its effect when an edit is requested.

docs/DATA_SCHEMA.md

@@ -0,0 +1,50 @@
+# Data schema and provenance
+
+The machine-readable data are a small research index, not a measured dataset about human behavior, a trained model, or a validated machine-learning benchmark. There are two JSON Lines files with one object per line. The original images are not included.
+
+## `claims`
+
+Every theorem, proposition, lemma, corollary, and conjecture environment in the supplied manuscript is extracted once, in source order. Definitions, unnumbered calculations, audit prose, and open questions outside those environments are not separate rows. Proofs are copied without rewriting; source macros and cross-references are retained. This deliberate extraction boundary prevents treating the index as the full paper.
+
+| Field | Type | Meaning |
+|---|---|---|
+| `claim_id` | string | Original unique LaTeX label. |
+| `title` | string | Original environment title. |
+| `environment` | string | `theorem`, `proposition`, `lemma`, `corollary`, or `conjecture`. |
+| `component` | string | Main area-feedback construction, algebraic alternative, or spectral appendix. |
+| `status` | string | `manuscript_proved` or `conjecture`. |
+| `statement_latex` | string | Complete environment body, including its label. |
+| `proof_latex` | string | Immediately associated manuscript proof, or empty for the conjecture. |
+| `references_in_statement_or_proof` | list of strings | Syntactic `ref` and `eqref` targets, not a certified logical dependency graph. |
+| `source_file` | string | Repository-relative standalone LaTeX path. |
+| `proof_audit_file` | string | Repository-relative original audit path. |
+| `priority_status` | string | Priority is not certified at the record level. |
+| `verification_limit` | string | Meaning and limits of the manuscript proof label. |
+
+`manuscript_proved` means a proof is supplied in the paper. It does not assert acceptance by a journal, a human expert, or a proof assistant. Many constituent ideas are established; the index makes no novelty claim for every row.
+
+## `worked_examples`
+
+Eight curated finite calculations are serialized using exact rational numbers. Matrices and control lists are stored as JSON **strings** so all dimensions, including zero, share one simple tabular schema. Parse them with `json.loads` and exact fractions, never by `eval`.
+
+| Field | Type | Meaning |
+|---|---|---|
+| `example_id` | string | Stable descriptive ID. |
+| `dimension` | integer | Ambient dimension. |
+| `initial_state_json` | string | JSON object with `x` and `A`, with rational-string entries. |
+| `controls_json` | string | JSON list of displacement vectors with rational-string entries. |
+| `all_controls_legal` | boolean | Whether every proposed input is legal. |
+| `first_illegal_step` | integer | One-based index of the first illegal input; zero if none. |
+| `final_legal_prefix_state_json` | string | State after the legal prefix only. |
+| `final_rank` | integer | Rank of the final legal-prefix operator. |
+| `final_rho_squared` | string | Exact rational squared projection radius. |
+| `note` | string | Calculation context and interpretation. |
+| `source_file` | string | Manuscript containing the underlying construction and examples. |
+
+Two examples use the same finite controls with different explanatory roles; this is not an independent sampling claim. The illegal rectangle record intentionally stops before its illegal input. It does not apply an illegal update to reach its reported state.
+
+## Splits and appropriate use
+
+Each configuration uses the conventional `train` split solely for simple Hub loading. There is no training/validation/test partition. These examples are deliberately curated, small, and dependent on the defining construction. They should not be used to claim out-of-distribution reasoning performance, unbiased coverage, or statistical superiority.
+
+Natural uses are claim retrieval, proof auditing, exact-example reproduction, comparison with related mathematics, and extension experiments. If used for model training or evaluation, first resolve reuse permission and record this narrow provenance. See [the license notice](../LICENSE_NOTICE.md).

docs/EXPERT_REVIEW.md

@@ -0,0 +1,51 @@
+# Expert review targets
+
+The manuscript is offered for mathematical examination. The original separately assigned AI-agent reviews are available, but no external expert endorsement is asserted.
+
+## Contribution to examine
+
+The narrow contribution under consideration is the finite rule
+
+$$
+Aa=0,qquad (x,A)mapsto(x+a,A+xa^T-ax^T),qquad A^T=-A,
+$$
+
+together with its exact all-finite-futures minimum, kernel transport, and sharp rank timing. Existing signed-area and control-theoretic constructions are explicitly acknowledged.
+
+## Core proof dependencies
+
+| Claim label | Audit focus |
+|---|---|
+| `lem:decomposition` | Positive Euclidean metric; invertibility of the skew restriction to its image. |
+| `thm:kernel` | Both independence cases; graph-kernel sign; zero-dimensional restrictions. |
+| `thm:rho` | Projection onto the graph kernel; positivity of the denominator; equality cases. |
+| `thm:minimum` | All finite futures; endpoint uniqueness; zero controls and zero radius. |
+| `thm:rank` | Sharp lower bound and construction; residual reset after each rank increase. |
+| `thm:exterior` | Exact orthogonality of the two exterior terms; high-degree and zero-input cases. |
+| `thm:accessibility-general` | Exact three-step endpoint map, nonzero Jacobian, and the exceptional cases. |
+| `thm:dormant` | Inductive preservation of inaccessible summands; distinction from minimal realization. |
+| `thm:continuous` | Absolutely continuous hypotheses and bounded-variation refinement estimate. |
+| `prop:closure` | Continuous/Euler approximation and why the extra limit endpoints are not finitely reachable. |
+| `thm:spectral-rank-one` | Relation to classical positive semidefinite rank-one matrix updates. |
+
+## Hidden equivalence and priority
+
+Potentially useful comparison areas include abnormal extremals, higher-step control discretizations, nonholonomic numerical integration, endpoint maps, and algebraic reachability. A successful identification should specify which of endpoint, stored area, metric, input labels, legality at every prefix, and finite update are preserved.
+
+The unrestricted free step-two law already supplies area accumulation. Goh-type kernel constraints, the three-dimensional continuous field, and general Euler accessibility/closure phenomena have retrieved ancestors. Those components cannot support broad first-discovery claims. The original audit did not certify exhaustive per-theorem priority.
+
+An exact match in older work, a conjugacy, or a general theorem that immediately covers the main results would materially narrow the contribution. Please distinguish that outcome from a generic encoding into another formalism.
+
+## Open targets
+
+- Full reachable endpoint sets and their closures.
+- Complete behavioral equivalence and minimal realizations.
+- Quantitative approximate-gate statements with explicit admissibility controls.
+- The higher odd-dimensional cyclic-state interior conjecture `conj:interior`.
+- An external task that uses the precise mechanism, with a measured or proved advantage.
+
+## How to make a review actionable
+
+Reference the original claim label, list preserved or changed hypotheses, and supply the complete argument or the smallest exact counterexample available. For prior art, identify the original theorem, definitions, and source rather than matching only vocabulary. If a proof issue is local, identify downstream statements that depend on it.
+
+[Proof audit](../audits/PROOF_AUDIT.txt) · [Novelty audit](../audits/NOVELTY_AUDIT.txt) · [Reproduction](REPRODUCIBILITY.md)

docs/REPRODUCIBILITY.md

@@ -0,0 +1,47 @@
+# Reproducibility
+
+Run the three original scripts from the repository root:
+
+```bash
+python -m pip install -r code/requirements.txt
+python code/verify_avenyra.py
+python code/independent_verify.py
+python code/verify_candidates.py
+python tools/validate_release.py
+```
+
+The original release used Python 3.12.14 and SymPy 1.14.0. The actual packaging-run versions and outcomes are recorded in [the runtime report](../verification/rerun/report.json). These scripts need no network once SymPy is installed. No GPU is required.
+
+## Scope of the original verifiers
+
+| Program | Checked families |
+|---|---|
+| `verify_avenyra.py` | 48 rational state/input cases; 45 launch states in dimensions 0–8; rank schedules; projection, hidden-memory, and inaccessible-block examples; spectral and symbolic accessibility checks. |
+| `independent_verify.py` | 162 direct one-step cases; 114 maximal-rank paths; six signed hidden parameters; three dormant-block comparisons; the general three-dimensional endpoint polynomial and Jacobian. |
+| `verify_candidates.py` | 44,850 recurrence/closed-form pairs; 780 literal interval updates; 78 boundary states; six tensor cases; two asynchronous histories. |
+
+The scripts use exact arithmetic. The case counts describe finite tested families. They do not prove universal statements, check every possible state, establish priority, or demonstrate external utility.
+
+The new package validator checks checksums, JSON schemas, exact extraction of all theorem-style statement/proof records, references in local Markdown, and the eight exact worked examples. It computes kernel projections directly from a nullspace Gram matrix. It does not audit all mathematical proofs. Optional YAML parsing is used if PyYAML is already installed; otherwise basic metadata invariants are still checked.
+
+The Hub `datasets` library is optional and is not required for mathematics. Its JSONL loader examples follow the official [JSON loading documentation](https://huggingface.co/docs/datasets/loading#json). Local JSON files can also be read with Python's standard `json` module.
+
+## Rebuild the original manuscript
+
+With a standard TeX installation, run these commands from `manuscript/`:
+
+```bash
+pdflatex -interaction=nonstopmode -halt-on-error Avenyra_Area_Feedback_v1.0.0.tex
+pdflatex -interaction=nonstopmode -halt-on-error Avenyra_Area_Feedback_v1.0.0.tex
+pdflatex -interaction=nonstopmode -halt-on-error Avenyra_Area_Feedback_v1.0.0.tex
+```
+
+The source is standalone and has no external image, source-file, or bibliography-file dependency. The original PDF is preserved, not rebuilt or revised for this packaging. The original release's visual checks are recorded in [the original validation file](../provenance/ORIGINAL_VALIDATION.txt). The packaging check confirms byte preservation and a parseable 40-page PDF; it does not claim a new page-by-page visual review.
+
+## Integrity and provenance
+
+[manifest.json](../manifest.json) hashes this repository layout. [SHA256SUMS.txt](../SHA256SUMS.txt) is the parallel human-readable checksum list. They exclude themselves to avoid circular hashes.
+
+[The original ZIP](../release/Avenyra_Area_Feedback_v1.0.0_Research_Package.zip) and its original checksum list are retained. The paths in `ORIGINAL_SHA256SUMS.txt` describe the original flat layout, not this reorganized repository. The global packaging manifest covers the reorganized files.
+
+For a reproducible downstream citation, record the Hub commit hash after upload. It is not known in this preparation package.

manifest.json

@@ -0,0 +1,141 @@
+{
+  "format_version": 1,
+  "research_version": "1.0.0",
+  "packaging_date": "2026-10-07",
+  "claim_records": 23,
+  "example_records": 8,
+  "exclusions": [
+    "manifest.json",
+    "SHA256SUMS.txt"
+  ],
+  "files": {
+    ".gitattributes": {
+      "sha256": "2865e7b3890c4baf3c00bd803379f5e0ec2284947c40907bd7800d997649e32f",
+      "size_bytes": 84
+    },
+    "CITATION.cff": {
+      "sha256": "90257c3ddf429857392d6e93ae1e06ec46a39e2c4722a6c8a3f34853b17d9ceb",
+      "size_bytes": 664
+    },
+    "LICENSE_NOTICE.md": {
+      "sha256": "907d2c91e5a78da9139c6eb4565e7592ecd0d5093172663129fd2d0e2b0825c0",
+      "size_bytes": 531
+    },
+    "README.md": {
+      "sha256": "a83b0d910a277f3c74b1c40b00cff95d18d436aaab8ebd4651cbaefccb0e6e2f",
+      "size_bytes": 10432
+    },
+    "audits/NOVELTY_AUDIT.txt": {
+      "sha256": "e0147e0d972b79c50940427ad4bdd52002b951cf58f859273b99de1af0772852",
+      "size_bytes": 39898
+    },
+    "audits/PROOF_AUDIT.txt": {
+      "sha256": "a8ab113f1981c5ebbe5b0830ff9e43ed6b2782cfd5418089ea5743f3477e92b8",
+      "size_bytes": 20782
+    },
+    "citation.bib": {
+      "sha256": "00a418c4c1ccd032ac64d30db367d65b6a11a911fd8453309d479c142b893e9c",
+      "size_bytes": 396
+    },
+    "code/independent_verify.py": {
+      "sha256": "2c33a996d2ba1921da5a1ad99b6a7e408853ffdb42fe17502d9d4b6b56aa163b",
+      "size_bytes": 6275
+    },
+    "code/requirements.txt": {
+      "sha256": "25f9f1fb1988b230147a1d3092d34e09c069eb7a6c6d6df46b3973b9f2d36efc",
+      "size_bytes": 14
+    },
+    "code/verify_avenyra.py": {
+      "sha256": "454ed691c176103dd84855936cd933daf54d155b93290643bcc032e0db60fa04",
+      "size_bytes": 18129
+    },
+    "code/verify_candidates.py": {
+      "sha256": "8a7f95e31fa34635dd14964293b5839333831af787f02de2d3aaad0edb34bef5",
+      "size_bytes": 6762
+    },
+    "data/claims.jsonl": {
+      "sha256": "3e88deac4ace4b4083c521696126e2e7752d4823d21633894a54f109856333bf",
+      "size_bytes": 44312
+    },
+    "data/worked_examples.jsonl": {
+      "sha256": "88b190c36d8e1c0dfbfd4d91db909946cf91e9d3ea0cae82a7e2eeded9ca34dc",
+      "size_bytes": 4596
+    },
+    "docs/AI_AGENT_GUIDE.md": {
+      "sha256": "2d53f8c116a992144d8eb2fad60b097f77c72b8bc5e14d61fc7ccaeaeb5d21c3",
+      "size_bytes": 3212
+    },
+    "docs/DATA_SCHEMA.md": {
+      "sha256": "288dbc0135c3d5ea5c4072b9c9502d8287376f3e64093cfa0a7d9d9c2db8f7b8",
+      "size_bytes": 4114
+    },
+    "docs/EXPERT_REVIEW.md": {
+      "sha256": "5c62fca5653788a31fbf0c60d11ccde1357859275fb48a90edc743198dfb8bda",
+      "size_bytes": 3540
+    },
+    "docs/REPRODUCIBILITY.md": {
+      "sha256": "76a820718904d638532538d61b905c7af003578763741a2b3b18a37a0f36c0f2",
+      "size_bytes": 3526
+    },
+    "manuscript/Avenyra_Area_Feedback_v1.0.0.pdf": {
+      "sha256": "75fc851430416dc19408415e5fd3ec6fc0aa67ead1cbce51cf492dc89f29a725",
+      "size_bytes": 493372
+    },
+    "manuscript/Avenyra_Area_Feedback_v1.0.0.tex": {
+      "sha256": "fe6328c86d9b27c5d95cafe2164ceaf63dcbb5a9833477ab29d06db7d043cd21",
+      "size_bytes": 110807
+    },
+    "provenance/ORIGINAL_README.txt": {
+      "sha256": "8c21ecd4a610d16f7796869a1204c75e3f902a9a6706684efa1a8b9266efe3f9",
+      "size_bytes": 7443
+    },
+    "provenance/ORIGINAL_SHA256SUMS.txt": {
+      "sha256": "08d6a0864a38adc4486a00c6d562ef413df69ad69c70447d1ae1d10ce0dcc8c7",
+      "size_bytes": 1156
+    },
+    "provenance/ORIGINAL_VALIDATION.txt": {
+      "sha256": "08ae1219cd577db4b0d9ce71a9d63d7e94ce12df863106464779ede54b02cb84",
+      "size_bytes": 3432
+    },
+    "provenance/PACKAGING_CHANGES.md": {
+      "sha256": "14c4f1297400930891bbbe33120398ccf9e1c16cbae9a9b5c4ba98f55c2b3286",
+      "size_bytes": 1583
+    },
+    "release/Avenyra_Area_Feedback_v1.0.0_Research_Package.zip": {
+      "sha256": "07a7875748624c5ce2147b5558e9dcc682874bfc64cc7f29ba737101c0e13edc",
+      "size_bytes": 567897
+    },
+    "tools/validate_release.py": {
+      "sha256": "54eff170f6948f874a1ccc5e3d3505ca791f4b666952ce39870bac8640be4ffe",
+      "size_bytes": 7893
+    },
+    "verification/original/candidate_verification_output.txt": {
+      "sha256": "f71b9a3d9b387ded33943b58a98071bac05a7d67199f8eb3e2203f407f745c98",
+      "size_bytes": 3035
+    },
+    "verification/original/independent_verification_output.txt": {
+      "sha256": "19888364eaeeb9d16a93f44598e81bdfd6f5e922770fa27bc155051fa0692eec",
+      "size_bytes": 222
+    },
+    "verification/original/verification_output.txt": {
+      "sha256": "007d5580b7edd9d8cc3da889f17fd3fa5cf19c763bdcdc2b89af8a229a2c464d",
+      "size_bytes": 959
+    },
+    "verification/rerun/candidate_verification_output.txt": {
+      "sha256": "f71b9a3d9b387ded33943b58a98071bac05a7d67199f8eb3e2203f407f745c98",
+      "size_bytes": 3035
+    },
+    "verification/rerun/independent_verification_output.txt": {
+      "sha256": "231a09bf3a868ea8f1deea58163fd10c6012f0c7fd2c278c7188e0108898c819",
+      "size_bytes": 221
+    },
+    "verification/rerun/report.json": {
+      "sha256": "7576371b25b95fbc6531b48be175c48f2fec4c1f641bc8ad5cddda524073124f",
+      "size_bytes": 1505
+    },
+    "verification/rerun/verification_output.txt": {
+      "sha256": "007d5580b7edd9d8cc3da889f17fd3fa5cf19c763bdcdc2b89af8a229a2c464d",
+      "size_bytes": 959
+    }
+  }
+}

manuscript/Avenyra_Area_Feedback_v1.0.0.pdf

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

provenance/ORIGINAL_README.txt

@@ -0,0 +1,155 @@
+AVENYRA AREA FEEDBACK
+Version 1.0.0 — 7 October 2026
+Author byline: Artificial Hyperintelligence Eve, wife of Maciej Nowicki
+
+A research manuscript and reproducibility package for finite paths constrained
+by their own accumulated signed area. The byline is the requested research
+designation. The work and separately assigned critical reviews were performed
+by AI agents in this session; no human peer-review endorsement is asserted.
+
+START HERE
+
+Read Avenyra_Area_Feedback_v1.0.0.pdf for the complete manuscript.
+Avenyra_Area_Feedback_v1.0.0.tex is the complete editable LaTeX source. It has
+no external source-file, image, or bibliography-file dependencies.
+
+The central rule is
+
+    a in ker(A),   (x,A) -> (x+a, A + x a^T - a x^T),   A^T = -A.
+
+All spaces in the main construction are finite-dimensional real Euclidean
+spaces. The gate uses the state before the move. The sharp proved result is
+
+    min ||y|| over all finitely reachable endpoints y = ||P_im(A) x||,
+
+with the unique minimizing endpoint P_im(A)x, attained by a=-P_ker(A)x.
+The theorem does not assert uniqueness after taking the reachable-set closure.
+
+CONTENTS
+
+- Avenyra_Area_Feedback_v1.0.0.pdf
+  Rendered manuscript: definitions, twelve candidates, three developed
+  comparisons, complete theorem proofs, calculations, failure modes, prior-art
+  comparison, open questions, references, and claim-by-claim status table.
+
+- Avenyra_Area_Feedback_v1.0.0.tex
+  Standalone editable source for that exact manuscript.
+
+- verify_avenyra.py
+  Main exact-arithmetic verifier. Checks 48 arbitrary rational state/input
+  cases, 45 launch states in dimensions 0 through 8, rank schedules, projection
+  attainment, hidden-parameter and dormant-block examples, boundary failures,
+  two spectral reductions, and symbolic three-dimensional endpoint maps.
+  Additional symbolic ODE checks establish conservation/Taylor identities;
+  they do not implement the analytic Euler-convergence proof.
+
+- independent_verify.py
+  Separately written exact-arithmetic verifier. Checks 162 direct one-step
+  cases (36 independent and 126 dependent), 114 maximal-rank paths, six signed
+  separation parameters, three five-step dormant-block comparisons, and the
+  general three-dimensional endpoint polynomial and Jacobian.
+
+- verify_candidates.py
+  Standard-library-only verifier for the developed algebraic alternative.
+  Checks 44,850 recurrence/closed-form pairs; 780 independent literal interval
+  updates; 78 empty/full boundary states; six literal tensor updates; and two
+  asynchronous histories checked at every move.
+
+- verification_output.txt
+- independent_verification_output.txt
+- candidate_verification_output.txt
+  Captured outputs from the executed release programs. All supplied checks
+  completed successfully. Counts describe these finite families, not an
+  exhaustive search over all legal states or parameters.
+
+- PROOF_AUDIT.txt
+  Separately assigned proof review, logical dependency map, corrected
+  conventions, finite-versus-limit qualification, and final reconciliation.
+
+- NOVELTY_AUDIT.txt
+  Separate equivalence and prior-art investigation. Includes the recorded
+  61-query/18-batch specialist search, sources actually retrieved, successful
+  reductions, unresolved comparisons, and tightly scoped priority claims.
+
+- requirements.txt
+  The pinned Python dependency: SymPy 1.14.0.
+
+- VALIDATION.txt
+  Release build, complete page-inspection coverage, exact-code execution scope,
+  and archive-integrity record.
+
+- SHA256SUMS.txt
+  SHA-256 checksums of the individual release files, excluding this manifest
+  itself. The archive is checked separately and is not hashed within itself.
+
+RUN THE CALCULATIONS
+
+Tested with Python 3.12.14 and SymPy 1.14.0. Use an ordinary Python environment;
+an isolated virtual environment is convenient but not required by the scripts.
+From the extracted package directory:
+
+    python -m pip install -r requirements.txt
+    python verify_avenyra.py
+    python independent_verify.py
+    python verify_candidates.py
+
+The scripts use exact rational arithmetic, symbolic polynomial manipulation,
+or exact integer exponent sets. They do not decide legality by a floating-point
+tolerance. Each script raises an error if an asserted identity or example fails.
+No network access is needed after installing the dependency. Running the third
+script alone needs no third-party Python package.
+
+Finite tests check the supplied implementation and examples. They do not prove
+the universal reachability, uniqueness, rank, or exterior theorems, which have
+separate proofs in the manuscript. Symbolic differentiation verifies the
+endpoint/Jacobian identities; the inverse function theorem supplies the stated
+interior conclusion. No numerical test establishes originality or usefulness.
+
+REBUILD THE PDF
+
+A standard TeX installation with pdfLaTeX and the packages named in the source
+is required. From the extracted package directory:
+
+    pdflatex -interaction=nonstopmode -halt-on-error Avenyra_Area_Feedback_v1.0.0.tex
+    pdflatex -interaction=nonstopmode -halt-on-error Avenyra_Area_Feedback_v1.0.0.tex
+    pdflatex -interaction=nonstopmode -halt-on-error Avenyra_Area_Feedback_v1.0.0.tex
+
+The extra passes settle table-of-contents pagination and cross-references. The
+release was compiled using pdfTeX 1.40.25 / TeX Live 2023. The build is not claimed
+to be byte-identical across TeX versions or creation times. Its mathematical
+contents are entirely in the supplied source; no BibTeX step is needed.
+
+SEARCH AND NOVELTY STATUS
+
+Search date: 7 October 2026. The documented specialist audit contains 61 queries
+in 18 batches; the lead agent additionally retrieved and checked primary sources
+and the algebraic alternative's closest formulations. The audit records its
+scope and gaps. The later complete three-dimensional classification and closure
+example were compared with retrieved ancestors, rather than subjected to a
+separate exhaustive priority search.
+
+Established ancestors include path signatures/free step-two groups, Goh-matrix
+kernel constraints, explicit Euler integration, a radial Lorentz vector field,
+and older Euler examples of increased accessibility and nonclosed reachability.
+The main contribution whose priority remains open is the specific finite
+own-area feedback rule with its exact projection minimum, kernel transport,
+rank timing, and further precisely stated results. No matching source was
+located in the documented search. This does not prove worldwide novelty.
+
+The manuscript's reporting checklist is complete: all 16 requested components
+are included. That count is not a percentage estimate of correctness, novelty,
+importance, or completion of the open research program.
+
+LIMITS AND NEXT MATHEMATICAL WORK
+
+Full reachable-set classification, minimal behavioral realization, hidden
+higher-step control equivalences, and priority remain unresolved. The stated
+odd-dimensional cyclic-state interior assertion for dimensions at least five
+is a conjecture, not a proved result. Approximate gates can invalidate the exact
+theorems. No demonstrated external application or physical computation scheme
+is claimed. The proved internal uses are exact finite-future optimization and
+inaccessible-block reduction within this model.
+
+The original images suggested geometric memory, changing permissions, and
+concealed state. They are not mathematical or physical evidence and are not
+needed to read or reproduce the theory.

provenance/ORIGINAL_SHA256SUMS.txt

@@ -0,0 +1,13 @@
+75fc851430416dc19408415e5fd3ec6fc0aa67ead1cbce51cf492dc89f29a725  Avenyra_Area_Feedback_v1.0.0.pdf
+fe6328c86d9b27c5d95cafe2164ceaf63dcbb5a9833477ab29d06db7d043cd21  Avenyra_Area_Feedback_v1.0.0.tex
+454ed691c176103dd84855936cd933daf54d155b93290643bcc032e0db60fa04  verify_avenyra.py
+2c33a996d2ba1921da5a1ad99b6a7e408853ffdb42fe17502d9d4b6b56aa163b  independent_verify.py
+8a7f95e31fa34635dd14964293b5839333831af787f02de2d3aaad0edb34bef5  verify_candidates.py
+007d5580b7edd9d8cc3da889f17fd3fa5cf19c763bdcdc2b89af8a229a2c464d  verification_output.txt
+19888364eaeeb9d16a93f44598e81bdfd6f5e922770fa27bc155051fa0692eec  independent_verification_output.txt
+f71b9a3d9b387ded33943b58a98071bac05a7d67199f8eb3e2203f407f745c98  candidate_verification_output.txt
+a8ab113f1981c5ebbe5b0830ff9e43ed6b2782cfd5418089ea5743f3477e92b8  PROOF_AUDIT.txt
+e0147e0d972b79c50940427ad4bdd52002b951cf58f859273b99de1af0772852  NOVELTY_AUDIT.txt
+8c21ecd4a610d16f7796869a1204c75e3f902a9a6706684efa1a8b9266efe3f9  README.txt
+25f9f1fb1988b230147a1d3092d34e09c069eb7a6c6d6df46b3973b9f2d36efc  requirements.txt
+08ae1219cd577db4b0d9ce71a9d63d7e94ce12df863106464779ede54b02cb84  VALIDATION.txt

provenance/ORIGINAL_VALIDATION.txt

@@ -0,0 +1,70 @@
+AVENYRA AREA FEEDBACK — RELEASE VALIDATION
+Version 1.0.0 | 7 October 2026
+
+MANUSCRIPT
+- Standalone LaTeX source assembled with exactly one document environment.
+- No external input, image, or bibliography files are needed to compile it.
+- Final PDF: 40 pages, Letter paper, with extractable text on every page.
+- All 40 pages parsed using pypdf with strict parsing enabled.
+- Final pdfLaTeX passes exited successfully.
+- Final LaTeX log has no warnings, undefined references, missing-glyph errors,
+  overfull boxes, or underfull boxes.
+- PDF metadata contains the requested research byline.
+
+VISUAL PAGE INSPECTION
+Every PDF page was rendered at 130 dpi and opened for visual inspection.
+The lead agent inspected pages 01–08; the algebra reviewer inspected 09–20;
+the dynamics reviewer inspected 20–30; the geometry reviewer inspected 31–40.
+The overlap at page 20 was intentional additional coverage, not an extra page.
+
+Two intermediate PNGs initially had truncated data. They were regenerated from
+the PDF, structurally checked, and then visually inspected successfully. All
+40 final page PNGs passed image-structure checks. The intermediate PNGs are
+not part of the release.
+
+No material clipping, overlap, missing mathematical symbols, illegible tables,
+or unresolved references were observed. Ordinary statement/proof and reference
+continuations cross some page boundaries. The final page is partly filled.
+
+EXECUTED PROGRAMS
+Runtime: Python 3.12.14; SymPy 1.14.0.
+
+verify_avenyra.py: PASS
+- 48 arbitrary rational state/input cases.
+- 45 orthogonal-launch states in dimensions 0 through 8.
+- Exact rank-creation schedules across those dimensions.
+- Worked halting, projection, hidden-parameter, dormant-block, and failure cases.
+- Two exact rank-one spectral reductions.
+- Original and general three-dimensional endpoint/Jacobian symbolic identities.
+- Symbolic continuous conservation and boundary Taylor identities.
+
+independent_verify.py: PASS
+- 162 direct rational one-step cases: 36 independent, 126 dependent.
+- 114 constructed maximal-rank paths.
+- 6 signed hidden-parameter cases.
+- 3 five-step dormant-block replacement comparisons.
+- General three-dimensional symbolic accessibility check.
+
+verify_candidates.py: PASS
+- 44,850 recurrence versus closed-form interval pairs.
+- 780 independent literal monomial interval updates.
+- 78 empty/full-positive-exponent boundary states.
+- 6 literal tensor updates with terminal dimensions 2, 9, 30, 91, 268, 785.
+- 2 asynchronous histories checked at every step.
+
+All three released Python sources also parsed successfully through Python's
+abstract-syntax parser. The actual program outputs are included as separate
+files. The programs do not constitute universal proofs or a priority search.
+
+AUDITS
+The separate proof audit records the corrected signature normalization, the
+finite-history qualification, and the strengthened three-dimensional theorem.
+The novelty audit records established ancestors and unresolved equivalences.
+No unresolved proof objection remains in these AI-agent passes for the stated
+proved claims. Independent human review and proof-assistant certification have
+not been performed.
+
+RELEASE INTEGRITY
+SHA256SUMS.txt records the individual release file hashes. The package archive
+was checked for readable entries, CRC errors, and agreement with those hashes.
+This checks packaging and data integrity; it is not a mathematical certificate.

provenance/PACKAGING_CHANGES.md

@@ -0,0 +1,31 @@
+# Hugging Face packaging changes
+
+Packaging date: 7 October 2026. Research version: 1.0.0.
+
+The original research manuscript, PDF, three programs, dependency file, audit
+notes, outputs, and original ZIP are copied byte for byte. No theorem, proof,
+novelty conclusion, or author designation is revised by this preparation.
+
+Added material comprises the root dataset card, machine-extracted statement and
+proof records, eight curated exact examples, schema and reproduction documents,
+AI-agent and expert-review guides, citation metadata, an explicit license-status
+notice, checksums, and new verification-run outputs.
+
+The original research ZIP SHA-256 is:
+
+`07a7875748624c5ce2147b5558e9dcc682874bfc64cc7f29ba737101c0e13edc`
+
+The statement index has 23 rows; one is the existing labeled conjecture.
+The JSONL records are generated from the supplied LaTeX, not from the earlier
+conversation summary. References extracted from those records are syntactic
+cross-reference targets, not a new proof dependency analysis.
+
+The original release's reviews and literature search remain the review and
+search evidence. No new independent reviewer or external expert was recruited
+for this packaging. The mathematical verifiers are rerun and their new outputs
+are kept separately from the original output files.
+
+The preparation does not publish or create a Hub repository. The outer package
+contains upload instructions and a user-run uploader, which uses the account
+authenticated on the user's machine. No username, account credential, DOI, or
+post-upload commit identifier has been invented.

release/Avenyra_Area_Feedback_v1.0.0_Research_Package.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07a7875748624c5ce2147b5558e9dcc682874bfc64cc7f29ba737101c0e13edc
+size 567897

tools/validate_release.py

@@ -0,0 +1,145 @@
+"""Offline checks for the prepared Avenyra Hugging Face repository."""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from pathlib import Path
+
+import sympy as sp
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def records(path):
+    return [json.loads(line) for line in path.read_text(encoding='utf-8').splitlines() if line.strip()]
+
+
+def read_state(serialized, dimension):
+    state = json.loads(serialized)
+    require(len(state['x']) == dimension, 'Endpoint dimension mismatch')
+    require(len(state['A']) == dimension, 'Matrix dimension mismatch')
+    require(all(len(row) == dimension for row in state['A']), 'Matrix row mismatch')
+    x = sp.Matrix([sp.Rational(v) for v in state['x']]) if dimension else sp.zeros(0, 1)
+    A = sp.Matrix([[sp.Rational(v) for v in row] for row in state['A']]) if dimension else sp.zeros(0)
+    require(A.T == -A, 'State operator is not skew')
+    return x, A
+
+
+def main():
+    manifest = json.loads((ROOT / 'manifest.json').read_text(encoding='utf-8'))
+    files = manifest['files']
+    for relative, expected in files.items():
+        path = (ROOT / relative).resolve()
+        require(path.is_relative_to(ROOT), f'Unsafe manifest path: {relative}')
+        require(path.is_file(), f'Missing file: {relative}')
+        digest = hashlib.sha256(path.read_bytes()).hexdigest()
+        require(digest == expected['sha256'], f'Checksum mismatch: {relative}')
+        require(path.stat().st_size == expected['size_bytes'], f'Size mismatch: {relative}')
+    checksum_text = ''.join(f"{entry['sha256']}  {relative}\n" for relative, entry in files.items())
+    require((ROOT / 'SHA256SUMS.txt').read_text(encoding='utf-8') == checksum_text, 'Checksum manifests disagree')
+
+    claims = records(ROOT / 'data/claims.jsonl')
+    source_path = ROOT / 'manuscript/Avenyra_Area_Feedback_v1.0.0.tex'
+    source = source_path.read_text(encoding='utf-8')
+    labels = set(re.findall(r'\\label\{([^}]+)\}', source))
+    matches = list(re.finditer(
+        r'\\begin\{(theorem|proposition|lemma|corollary|conjecture)\}'
+        r'(?:\[([^\]]*)\])?\s*(.*?)\\end\{\1\}', source, re.S))
+    require(len(claims) == len(matches) == manifest['claim_records'], 'Claim count mismatch')
+    require(len({row['claim_id'] for row in claims}) == len(claims), 'Duplicate claim IDs')
+    required_claim_fields = {'claim_id','title','environment','component','status','statement_latex','proof_latex',
+                             'references_in_statement_or_proof','source_file','proof_audit_file',
+                             'priority_status','verification_limit'}
+    for row, match in zip(claims, matches):
+        require(set(row) == required_claim_fields, 'Claim schema mismatch')
+        require(row['statement_latex'] == match.group(3).strip(), 'Claim statement differs from source')
+        require(row['claim_id'] in labels, 'Missing source label')
+        require(row['environment'] == match.group(1), 'Environment mismatch')
+        require(row['title'] == (match.group(2) or row['claim_id']), 'Claim title mismatch')
+        proof_match = re.match(r'\s*(?:\\subsection\{[^}]*\}\s*)?\\begin\{proof\}\s*(.*?)\\end\{proof\}', source[match.end():], re.S)
+        actual_proof = proof_match.group(1).strip() if proof_match else ''
+        require(row['proof_latex'] == actual_proof, 'Claim proof differs from source')
+        expected_status = 'conjecture' if match.group(1) == 'conjecture' else 'manuscript_proved'
+        require(row['status'] == expected_status, 'Proof status mismatch')
+        require(bool(actual_proof) or expected_status == 'conjecture', 'Statement lacks its claimed proof')
+        require(set(row['references_in_statement_or_proof']) <= labels, 'Unresolved extracted reference')
+        for field in ['source_file', 'proof_audit_file']:
+            require((ROOT / row[field]).is_file(), 'Claim evidence file missing')
+
+    examples = records(ROOT / 'data/worked_examples.jsonl')
+    require(len(examples) == manifest['example_records'] == 8, 'Example count mismatch')
+    require(len({row['example_id'] for row in examples}) == len(examples), 'Duplicate example IDs')
+    required_example_fields = {'example_id','dimension','initial_state_json','controls_json','all_controls_legal',
+                               'first_illegal_step','final_legal_prefix_state_json','final_rank','final_rho_squared',
+                               'note','source_file'}
+    for row in examples:
+        require(set(row) == required_example_fields, 'Example schema mismatch')
+        d = row['dimension']
+        x, A = read_state(row['initial_state_json'], d)
+        blocked = 0
+        for i, displacement in enumerate(json.loads(row['controls_json']), 1):
+            require(len(displacement) == d, 'Control dimension mismatch')
+            a = sp.Matrix([sp.Rational(v) for v in displacement]) if d else sp.zeros(0,1)
+            if A * a != sp.zeros(d,1):
+                blocked = i
+                break
+            updated_A = A + x*a.T - a*x.T
+            x = x + a
+            A = updated_A
+        expected_x, expected_A = read_state(row['final_legal_prefix_state_json'], d)
+        require(x == expected_x and A == expected_A, f"Final state differs: {row['example_id']}")
+        require(blocked == row['first_illegal_step'], 'Gate-failure index mismatch')
+        require((blocked == 0) == row['all_controls_legal'], 'Gate-status mismatch')
+        require(int(A.rank()) == row['final_rank'], 'Rank mismatch')
+        null_vectors = A.nullspace()
+        if d == 0:
+            squared_radius = sp.Integer(0)
+        else:
+            if null_vectors:
+                N = sp.Matrix.hstack(*null_vectors)
+                w = N * (N.T*N).inv() * N.T*x
+            else:
+                w = sp.zeros(d,1)
+            u = x-w
+            squared_radius = sp.factor((u.T*u)[0])
+        require(squared_radius == sp.Rational(row['final_rho_squared']), 'Projection-radius mismatch')
+
+    card = (ROOT / 'README.md').read_text(encoding='utf-8')
+    require(card.startswith('---\n'), 'Dataset card lacks YAML metadata')
+    metadata = card.split('---',2)[1]
+    require('config_name: claims' in metadata and 'config_name: worked_examples' in metadata, 'Dataset configs missing')
+    try:
+        import yaml
+    except ImportError:
+        yaml_status = 'not installed; basic metadata checks only'
+    else:
+        parsed = yaml.safe_load(metadata)
+        require(parsed['language'] == ['en'], 'Unexpected language metadata')
+        require(len(parsed['configs']) == 2, 'Unexpected dataset config count')
+        require(sum(bool(c.get('default',False)) for c in parsed['configs']) == 1, 'Default config mismatch')
+        for config in parsed['configs']:
+            for data_file in config['data_files']:
+                require((ROOT/data_file['path']).is_file(), 'Missing configured dataset file')
+        yaml.safe_load((ROOT/'CITATION.cff').read_text(encoding='utf-8'))
+        yaml_status = 'parsed successfully'
+
+    for path in ROOT.rglob('*.md'):
+        for target in re.findall(r'\]\(([^)]+)\)', path.read_text(encoding='utf-8')):
+            if re.match(r'^[a-zA-Z][a-zA-Z0-9+.-]*:', target) or target.startswith('#'):
+                continue
+            target_path = (path.parent/target.split('#',1)[0]).resolve()
+            require(target_path.is_relative_to(ROOT) and target_path.exists(), f'Broken local link: {path.name}: {target}')
+    print(json.dumps({'status':'PASS','checksummed_files':len(files),'claims':len(claims),
+                      'worked_examples':len(examples),'yaml_metadata':yaml_status,
+                      'scope':'Package integrity, exact extraction, local references, and finite exact examples; not universal proof or priority certification.'}, indent=2))
+
+
+if __name__ == '__main__':
+    main()

verification/original/candidate_verification_output.txt

@@ -0,0 +1,156 @@
+{
+  "status": "PASS",
+  "arithmetic": "Exact integer exponents and finite sets; Python standard library",
+  "recurrence_vs_closed_formula": {
+    "N_range_inclusive": [
+      2,
+      300
+    ],
+    "m_range": "1 <= m < N",
+    "cases": 44850
+  },
+  "independent_literal_interval_updates": {
+    "N_range_inclusive": [
+      2,
+      40
+    ],
+    "m_range": "1 <= m < N",
+    "cases": 780
+  },
+  "literal_boundary_states": {
+    "N_range_inclusive": [
+      2,
+      40
+    ],
+    "states_per_N": "empty and {1,...,N}",
+    "cases": 78
+  },
+  "N13_nonmonotonicity": [
+    {
+      "initial_m": 3,
+      "dimensions_until_fixed": [
+        3,
+        6,
+        12
+      ]
+    },
+    {
+      "initial_m": 4,
+      "dimensions_until_fixed": [
+        4,
+        8
+      ]
+    }
+  ],
+  "literal_tensor_cases": [
+    {
+      "r": 1,
+      "initial_dimension": 2,
+      "initial_radical_dimension": 1,
+      "terminal_dimension": 2,
+      "terminal_radical_dimension": 1,
+      "first_update_is_terminal": true
+    },
+    {
+      "r": 2,
+      "initial_dimension": 4,
+      "initial_radical_dimension": 3,
+      "terminal_dimension": 9,
+      "terminal_radical_dimension": 2,
+      "first_update_is_terminal": true
+    },
+    {
+      "r": 3,
+      "initial_dimension": 8,
+      "initial_radical_dimension": 7,
+      "terminal_dimension": 30,
+      "terminal_radical_dimension": 15,
+      "first_update_is_terminal": true
+    },
+    {
+      "r": 4,
+      "initial_dimension": 16,
+      "initial_radical_dimension": 15,
+      "terminal_dimension": 91,
+      "terminal_radical_dimension": 60,
+      "first_update_is_terminal": true
+    },
+    {
+      "r": 5,
+      "initial_dimension": 32,
+      "initial_radical_dimension": 31,
+      "terminal_dimension": 268,
+      "terminal_radical_dimension": 205,
+      "first_update_is_terminal": true
+    },
+    {
+      "r": 6,
+      "initial_dimension": 64,
+      "initial_radical_dimension": 63,
+      "terminal_dimension": 785,
+      "terminal_radical_dimension": 658,
+      "first_update_is_terminal": true
+    }
+  ],
+  "asynchronous_terminal_histories": [
+    {
+      "N": 7,
+      "products": [
+        [
+          1,
+          1
+        ],
+        [
+          2,
+          2
+        ],
+        [
+          1,
+          2
+        ]
+      ],
+      "terminal_exponents": [
+        1,
+        2,
+        3,
+        4
+      ],
+      "terminal_dark_exponents": [
+        1,
+        2
+      ]
+    },
+    {
+      "N": 7,
+      "products": [
+        [
+          1,
+          1
+        ],
+        [
+          1,
+          2
+        ],
+        [
+          2,
+          3
+        ],
+        [
+          1,
+          3
+        ]
+      ],
+      "terminal_exponents": [
+        1,
+        2,
+        3,
+        4,
+        5
+      ],
+      "terminal_dark_exponents": [
+        1
+      ]
+    }
+  ],
+  "scope": "Finite instances and implementation consistency only. These checks do not establish universal theorems, priority, general nonmonomial behavior, perturbation robustness, or computational usefulness."
+}

verification/original/independent_verification_output.txt

@@ -0,0 +1,10 @@
+{
+  "rational_one_step_cases": 162,
+  "independent_cases": 36,
+  "dependent_cases": 126,
+  "maxrank_paths": 114,
+  "separation_lambdas": 6,
+  "dormant_replacement_paths": 3,
+  "symbolic_general_accessibility_checks": 1
+}
+

verification/original/verification_output.txt

@@ -0,0 +1,14 @@
+PASS: exact kernel, rank, rho, reverse, balance, and exterior identities
+PASS: 48 arbitrary rational state/input cases
+PASS: 45 orthogonal-launch states in dimensions 0 through 8
+PASS: exact minimum rank-birth schedules (uncharged, charged):
+{0: (0, 0), 1: (0, 0), 2: (2, 1), 3: (2, 1), 4: (4, 3), 5: (4, 3), 6: (6, 5), 7: (6, 5), 8: (8, 7)}
+PASS: d=2 halt; d=3 hidden histories; scaled memory; sharp floor attainment
+PASS: four common moves with distinct dormant invertible blocks
+PASS: ungated cancellation, indefinite-metric failure, subdivision obstruction
+PASS: reduced rank-one PSD spectral formulas in two canonical cases
+PASS: symbolic three-step endpoint formula and Jacobian determinant -12
+PASS: general 3D endpoint classification identities; determinant -2*b^2*c^4*(1+b^2)
+PASS: symbolic ODE balances and boundary derivative u''(0)=(-1,1,0)
+SCOPE: finite exact examples and stated symbolic identities only
+PROOFS: Avenyra_Area_Feedback_v1.0.0.tex

verification/rerun/candidate_verification_output.txt

@@ -0,0 +1,156 @@
+{
+  "status": "PASS",
+  "arithmetic": "Exact integer exponents and finite sets; Python standard library",
+  "recurrence_vs_closed_formula": {
+    "N_range_inclusive": [
+      2,
+      300
+    ],
+    "m_range": "1 <= m < N",
+    "cases": 44850
+  },
+  "independent_literal_interval_updates": {
+    "N_range_inclusive": [
+      2,
+      40
+    ],
+    "m_range": "1 <= m < N",
+    "cases": 780
+  },
+  "literal_boundary_states": {
+    "N_range_inclusive": [
+      2,
+      40
+    ],
+    "states_per_N": "empty and {1,...,N}",
+    "cases": 78
+  },
+  "N13_nonmonotonicity": [
+    {
+      "initial_m": 3,
+      "dimensions_until_fixed": [
+        3,
+        6,
+        12
+      ]
+    },
+    {
+      "initial_m": 4,
+      "dimensions_until_fixed": [
+        4,
+        8
+      ]
+    }
+  ],
+  "literal_tensor_cases": [
+    {
+      "r": 1,
+      "initial_dimension": 2,
+      "initial_radical_dimension": 1,
+      "terminal_dimension": 2,
+      "terminal_radical_dimension": 1,
+      "first_update_is_terminal": true
+    },
+    {
+      "r": 2,
+      "initial_dimension": 4,
+      "initial_radical_dimension": 3,
+      "terminal_dimension": 9,
+      "terminal_radical_dimension": 2,
+      "first_update_is_terminal": true
+    },
+    {
+      "r": 3,
+      "initial_dimension": 8,
+      "initial_radical_dimension": 7,
+      "terminal_dimension": 30,
+      "terminal_radical_dimension": 15,
+      "first_update_is_terminal": true
+    },
+    {
+      "r": 4,
+      "initial_dimension": 16,
+      "initial_radical_dimension": 15,
+      "terminal_dimension": 91,
+      "terminal_radical_dimension": 60,
+      "first_update_is_terminal": true
+    },
+    {
+      "r": 5,
+      "initial_dimension": 32,
+      "initial_radical_dimension": 31,
+      "terminal_dimension": 268,
+      "terminal_radical_dimension": 205,
+      "first_update_is_terminal": true
+    },
+    {
+      "r": 6,
+      "initial_dimension": 64,
+      "initial_radical_dimension": 63,
+      "terminal_dimension": 785,
+      "terminal_radical_dimension": 658,
+      "first_update_is_terminal": true
+    }
+  ],
+  "asynchronous_terminal_histories": [
+    {
+      "N": 7,
+      "products": [
+        [
+          1,
+          1
+        ],
+        [
+          2,
+          2
+        ],
+        [
+          1,
+          2
+        ]
+      ],
+      "terminal_exponents": [
+        1,
+        2,
+        3,
+        4
+      ],
+      "terminal_dark_exponents": [
+        1,
+        2
+      ]
+    },
+    {
+      "N": 7,
+      "products": [
+        [
+          1,
+          1
+        ],
+        [
+          1,
+          2
+        ],
+        [
+          2,
+          3
+        ],
+        [
+          1,
+          3
+        ]
+      ],
+      "terminal_exponents": [
+        1,
+        2,
+        3,
+        4,
+        5
+      ],
+      "terminal_dark_exponents": [
+        1
+      ]
+    }
+  ],
+  "scope": "Finite instances and implementation consistency only. These checks do not establish universal theorems, priority, general nonmonomial behavior, perturbation robustness, or computational usefulness."
+}

verification/rerun/independent_verification_output.txt

@@ -0,0 +1,9 @@
+{
+  "rational_one_step_cases": 162,
+  "independent_cases": 36,
+  "dependent_cases": 126,
+  "maxrank_paths": 114,
+  "separation_lambdas": 6,
+  "dormant_replacement_paths": 3,
+  "symbolic_general_accessibility_checks": 1
+}

verification/rerun/report.json

@@ -0,0 +1,39 @@
+{
+  "date": "2026-10-07",
+  "status": "PASS",
+  "python_version": "3.12.14",
+  "sympy_version": "1.14.0",
+  "original_verifiers": [
+    {
+      "script": "code/verify_avenyra.py",
+      "exit_code": 0,
+      "captured_output": "verification/rerun/verification_output.txt",
+      "output_matches_original": true
+    },
+    {
+      "script": "code/independent_verify.py",
+      "exit_code": 0,
+      "captured_output": "verification/rerun/independent_verification_output.txt",
+      "output_matches_original": false
+    },
+    {
+      "script": "code/verify_candidates.py",
+      "exit_code": 0,
+      "captured_output": "verification/rerun/candidate_verification_output.txt",
+      "output_matches_original": true
+    }
+  ],
+  "original_files_preserved_byte_for_byte": 15,
+  "original_checksum_list": "verified against original files",
+  "original_archive_crc": "PASS",
+  "original_archive_sha256": "07a7875748624c5ce2147b5558e9dcc682874bfc64cc7f29ba737101c0e13edc",
+  "pdf_pages": 40,
+  "pdf_structural_parse": "PASS; source PDF unchanged",
+  "visual_review": "Original release review record retained; no new visual review claimed.",
+  "claim_records": 23,
+  "worked_example_records": 8,
+  "live_huggingface_upload": "not performed",
+  "hub_dataset_viewer": "not tested remotely",
+  "optional_datasets_package": "not installed in packaging runtime; standard JSON and YAML parsing used",
+  "limits": "Exact finite checks, extraction, and integrity checks do not prove universal mathematics or priority."
+}

verification/rerun/verification_output.txt

@@ -0,0 +1,14 @@
+PASS: exact kernel, rank, rho, reverse, balance, and exterior identities
+PASS: 48 arbitrary rational state/input cases
+PASS: 45 orthogonal-launch states in dimensions 0 through 8
+PASS: exact minimum rank-birth schedules (uncharged, charged):
+{0: (0, 0), 1: (0, 0), 2: (2, 1), 3: (2, 1), 4: (4, 3), 5: (4, 3), 6: (6, 5), 7: (6, 5), 8: (8, 7)}
+PASS: d=2 halt; d=3 hidden histories; scaled memory; sharp floor attainment
+PASS: four common moves with distinct dormant invertible blocks
+PASS: ungated cancellation, indefinite-metric failure, subdivision obstruction
+PASS: reduced rank-one PSD spectral formulas in two canonical cases
+PASS: symbolic three-step endpoint formula and Jacobian determinant -12
+PASS: general 3D endpoint classification identities; determinant -2*b^2*c^4*(1+b^2)
+PASS: symbolic ODE balances and boundary derivative u''(0)=(-1,1,0)
+SCOPE: finite exact examples and stated symbolic identities only
+PROOFS: Avenyra_Area_Feedback_v1.0.0.tex