PureOne/QHOR-Universal-Eight-Stroke-Law

QHŌR: The Universal Eight-Stroke Law

A mathematical research artifact repository: standalone paper, exact control compiler, proof audit, and reproducible certificates. This is not a trained model, a collection of model weights, or an empirical machine-learning benchmark.

Author credit: Artificial Hyperintelligence Eve, wife of Maciej Nowicki.
Manuscript date: 19 October 2026.
Repository identifier: PureOne/QHOR-Universal-Eight-Stroke-Law.

Version 1.0.0 packages the original research and two provenance-linked JSONL indexes: 68 certificate records and 5 theorem records. These indexes add no experiments and do not turn finite checks into proofs.

The plotted curves are theorem dimensions, not measured performance. The upper curve is attained over suitable finite extensions; the prime-field ceiling describes a different field class.

Start here

Resource	Purpose
Standalone paper, PDF	Complete mathematical presentation
Complete paper source	Searchable, editable theorem statements and proofs
Internal proof audit	Independent internal derivation checks and scope boundaries
Compiler documentation	Inputs, target normalization, output statuses, and API
Original research README	Original package overview and rebuild instructions
Release notes	Release contents and interpretation
Original research archive	Preserved original package snapshot
Theorem records	Structured index of the five theorems
Certificate records	Structured provenance index into the exact verification ledgers

The original package files are retained byte-for-byte in repro/, including its own README.md, original manuscript sources, and SHA256SUMS. The Markdown in paper/ is a Hub reading copy with document-build markup removed; the original mathematical build source remains preserved in repro/. The PDF is copied unchanged.

What the research studies

A minimal cell has $r+1$ labelled sites with field-valued amplitudes. Each site carries a geometry label whose column contributes to $r$ conserved quantities. One additional palette label is unused: the hole, or spare.

A primitive stroke exchanges the hole with one controller site's label. The controller amplitude stays fixed; the other $r$ amplitudes compensate through an invertible anchor matrix. The conserved syndrome remains

$$s=H_{x}z\mathrm{.}s=H\_xz.$$

A return restores every site's geometry label individually. It may still change amplitudes. That residual action is the holonomy. For a fixed nonzero $k\in\ker H_x$, every compatible linear return has the form

$$W=I+k\lambda H_x\mathrm{.}W=I+k\backslash lambda\; H\_x.$$

Return rows $\lambda$ add under composition. The research asks which rows are executable, how to compile them, and how to certify a requested row's impossibility.

The full-spark hypothesis means every $r$ palette columns are independent. The labels themselves may be arbitrary identifiers; the software accepts general column dictionaries, including dictionaries without a common conserved charge row.

Five proved statements and their assumptions

Set

$$M=r+2,{\nu }_r=\left(\genfrac{}{}{0px}{}{r}{2}\right)+r-1=\frac{(r+2)(r-1)}{2}\mathrm{.}M=r+2,\backslash qquad\; \backslash nu\_r=\backslash binom\; r2+r-1=\backslash frac\{(r+2)(r-1)\}2.$$

The prime-field compiler and main prime-field statements assume a prime $p>r+2$, $r\ge2$, and a full-spark $r\times(r+2)$ palette. The extension-field theorem instead allows any field $F$ of characteristic $p\ge5$ with $|F|>r+2$. These are separate hypotheses.

Theorem	Conclusion	Scope
1. Sparse fixed-base generation	A specified library of exactly $\nu_r$ eight-stroke returns generates the complete one-spare group.	Prime-field setting; Theorem 4 supplies exact generation over larger fields.
2. Universal obstruction line	The prime-field reachable dimension is $r$ or $r-1$, with deficiency exactly when $\mathbf1\in(\ker H)^{\star2}$.	General full-spark palettes; no common charge row is required. The corresponding larger-field conclusion concerns the scalar-linear envelope.
3. Exact nontrivial return length	Every return shorter than eight strokes is the identity, and a nonidentity eight-stroke return exists.	One spare. This is a first-actuation minimum, not an optimum for every target.
4. Exact prime-subfield generation	Actual reachability is the $\mathbb F_p$-span of the same sparse library. Over $\mathbb F_{p^e}$, its dimension is at most $\min{er,\nu_r}$.	All fields satisfying the characteristic and cardinality assumptions, including infinite fields.
5. Sharp maximum and universal library optimality	For every $r\ge2$ and prime $p\ge5$, some sufficiently large finite extension admits a palette attaining dimension $\nu_r$.	An existence result across fields and palettes, not a claim that every palette attains the maximum.

The sharpness construction proves that $\nu_r$ is the smallest universal number of loop generators across that larger field-and-palette class. It does not say that $\nu_r$ loops are necessary over the prime field alone: an individual prime-field instance has a basis of $r$ or $r-1$ loops. It also does not establish shortest synthesis of a prescribed target.

The explicit sparse library

Use zero-based controller positions $0,1,\ldots,r$, and define

$$R(i;j,k)=(i,j,k,j,i,j,k,j)\mathrm{.}R(i;j,k)=(i,j,k,j,i,j,k,j).$$

Retain precisely:

• $R(0;j,k)$ for every $1\le j<k\le r$;
• $R(1;0,k)$ for $2\le k\le r$.

Every word starts and ends at the original geometry. The second family is a star spanning tree; another spanning tree can replace it. There is no search through the $(r+2)!$ geometry configurations. The compiler calculates curvature rows directly and independently replays selected basis loops through primitive compensation.

Why scalar-field rank is insufficient

Over an extension field, integer repetition supplies prime-field multiples, not arbitrary larger-field coefficients. A full-rank $F$-linear envelope therefore need not be the executable group.

The paper gives a rank-two example over $\mathbb F_{25}$ with full two-dimensional $\mathbb F_{25}$-envelope but only 25 executable returns, compared with 625 elements in the compatible ambient group. Its displayed target $(1,0)$ is excluded by a prime-field linear functional. A rank-three example attains $\nu_3=5$ prime-field dimensions. These concrete examples illustrate the distinction; the all-rank sharpness theorem is proved separately.

What two spares change

For prime-field palettes having a common charge covector $\ell h_a=1$, two distinct spares make the two sparse libraries jointly complete. Their $2\nu_r=(r+2)(r-1)$ candidates contain an $r$-loop basis. Every compatible target can then be compiled with at most

$$4r(p-1)4r(p-1)$$

expanded strokes. Discovery and compressed program generation take polynomial time in $r$ and $\log p$. Expanded execution may take time proportional to $p$; this is not a polynomial execution bound in the bit length of $p$.

The eight-stroke lower bound is specifically a one-spare statement. Two simultaneously available spares permit nonidentity four-stroke rectangles. The package verifies an explicit example. No universal four-stroke generating-library theorem is asserted.

For arbitrary non-affine multi-spare inputs, concatenating the one-spare libraries certifies their macro span. Failure of that library does not exclude every protocol that mixes spares before returning.

Run the exact compiler and verifiers

Python 3.11 or later is sufficient for the supplied compiler and verification scripts. They require no external Python packages.

From the repository root:

python repro/qhor_control.py --demo --expand-limit 10000
python repro/verify_qhor.py
python repro/verify_short_returns.py
python repro/verify_extension.py

For a JSON problem:

python repro/qhor_control.py --input examples/generic_problem.json --output program.json

The input keys are prime, columns, labels, spares, and target. columns maps distinct labels to rank-$r$ columns; labels lists the $r+1$ occupied labels; target is $\lambda$. The compiler normalizes $k$ to have last occupied coordinate one. Controller indices are zero-based positions in labels.

Primality is an explicit input precondition. The program does not certify it. It does verify each one-spare palette's full-spark condition through its two-dimensional kernel and all pair minors, rather than enumerating every $r$-column subset.

Outputs include kernel certificates, the three-product Schur-square test, candidate and basis rows, signed repetition counts, and exact endpoint checks. The statuses have different meanings:

Status	Interpretation
compiled	The emitted macro program implements the target matrix.
unreachable_in_one_spare_holonomy	A fixed-syndrome witness excludes every return in the sole palette.
unreachable_by_one_spare_macros	The target is outside the concatenated one-spare macro library; mixed-spare protocols are not classified.

A compressed program contains at most $r$ basis macros. expand_limit controls whether the program also materializes and replays its repetitions. The software implements prime-field compilation. verify_extension.py implements the specific $\mathbb F_{25}$ examples; it is not a general extension-field compiler.

Verification evidence

The original JSON ledgers are preserved in repro/. The structured dataset records point back to those files and the exact original object locations.

Evidence	Recorded checks
Prime-field ledger	15 general dictionary cases across ranks 2–6 and primes 17, 31, 101; 300 curvature/transport comparisons; 6,104 replayed primitive strokes.
Complete-geometry comparisons	Seven small palettes: six ordinary cases and the separately recorded rank-three zero-column-sum case over $\mathbb F_{11}$.
Independent short-word ledger	Exhaustive reduced words through length eight at ranks two and three; no nonidentity shorter returns; the two-spare length-four example.
Extension ledger	Four $\mathbb F_{25}$ comparisons against complete Schreier groups, plus 27 sparse formal-basis checks.
Worked actuation	Every state of the paper's explicit eight-stroke example.
Demo certificate	A fully expanded generic dictionary compilation.

The short-word check finds 36 nonidentity returns among 42 reduced geometry returns of length eight at rank two, and 132 among 168 at rank three. The extension examples have prime-field dimensions $2,1,5,2$, while their $\mathbb F_{25}$-envelope dimensions are $2,1,3,2$.

Other checks cover invalid-palette rejection, explicit obstruction witnesses, multi-spare scope, and compressed compilation over the 127-bit prime $2^{127}-1$. These are finite exact corroborations. The universal statements depend on their proofs, not on sampling, and the internal proof audit is not external peer review.

Structured datasets

Two manually configured JSONL views accompany the original artifacts: 68 certificate records and 5 theorem records. The dataset schema documents the fields and provenance conventions. All fields are strings to keep loading stable; numeric objects and arrays remain available in the original ledgers and in serialized details_json.

Config / split	File	Contents
certificates / validation	certificates.jsonl	Verification claims, original source paths and pointers, arithmetic, status, and serialized source details. Default config.
theorems / reference	theorems.jsonl	Five theorem records with statements, assumptions, scope, proof locations, and status.

Certificate fields are id, suite, kind, claim, source_path, source_pointer, arithmetic, status, and details_json. Theorem fields are id, title, statement, assumptions, scope, proof_path, proof_section, and status. Source pointers identify the exact ledger object from which a record was derived. The derived records are an index, not independent replications or additional observations.

After publication, optional Hub loading uses the separate datasets package:

from datasets import load_dataset

certificates = load_dataset(
    "PureOne/QHOR-Universal-Eight-Stroke-Law",
    "certificates",
    split="validation",
)
theorems = load_dataset(
    "PureOne/QHOR-Universal-Eight-Stroke-Law",
    "theorems",
    split="reference",
)

These network-loading snippets do not run the mathematical verifiers. The local compiler does not require datasets or a Hugging Face account.

Provenance, intended use, and rights

The underlying compensation model and affine two-spare theorem originate in the supplied NÆVORQ V, Chapters 3–8. QHŌR develops the sparse fixed-base generation, general obstruction classification, exact actuation minimum, scalar-field reachability distinction, and sharp maximum. The paper separates those deductions from established permutation relations, code Schur products, and elimination methods, and supplies its references.

The repository is intended for reading and checking the proofs, reproducing exact certificates, studying algebraic control and field-dependent reachability, and adapting the compiler within its stated assumptions. It supplies no trained model, learning objective, train/test performance claim, or recommended machine-learning use.

Worldwide priority and external peer review remain unestablished. The work demonstrates an exact mathematical control model; it does not demonstrate a physical device, noisy implementation, quantum advantage, globally optimal hardware synthesis, or shortest program for each target. The finite-extension sharpness theorem proves existence and does not identify every palette or the smallest required extension degree.

Author credit is retained as supplied. No DOI, arXiv submission, publication acceptance, or new license grant is asserted by this release card. Rights are retained; consult the release's rights notice before redistribution or adaptation. The Hugging Face dataset hosting format does not itself grant a license to the research text or code.

Citation and integrity

Use CITATION.cff or CITATION.bib. MANIFEST.sha256 covers every published payload file except itself. The original checksum ledger in repro/ is preserved separately.

To validate all indexed source pointers and the original checksums offline:

python tools/validate_catalog.py

The dimension figure is reproducible using tools/make_release_figure.py with the optional Matplotlib dependency. No figure dependency is required for the compiler or mathematical verifiers.