Uniform rounded prime-power cyclic inversion (no κ claim)

[chafreaky]

Supplies a rounded inverse for the prime-power cyclic kernels of PR621. Stable first-order factors use two scans, including the periodic closure. The full neighboring-shift inverse uses O(r) array passes and p+O(r^4) precision, independent of cyclic length. The proof charges approximate factor preparation, coefficient verification and unit-phase approximation. The extension to independently varying unit phases at every position has the same length-independent precision bound, with every phase oracle charged.

The standard bit-model bound is soft-O((Lr+r^3)(p+r^4)). Its preparation argument uses the cited Pan factorization and fast elementary-function algorithms. The reference root finder only nominates candidates; exact coefficient enclosures, factor products and rounding budgets certify them. Those worst-case preparation algorithms are not implemented here.

A separate inverse-shear construction now restores the source and ceil(log2(r-1)) borrowed dirty arrays exactly. Causal integer lifts implement each stable factor; balanced commutators compose them. It uses O(r^2) factor calls and O(p+log(D+1)+r^5) precision for initial magnitude bound D, independent of cyclic length. It permits charged clean scalar arithmetic and read-only phase access; reversible bit arithmetic and a common-label word are not supplied. The rounded target increment may depend on the initial dirt within the proved error bound.

Arbitrary strides have an explicit two-sort reduction, with O(L(B+log L)log L) routing cost. That can become O(Lp^2), so the package exposes the remaining layout requirement. Scheduling the borrowed arrays in the complete transform, full-transform composition, normalization, bit compilation and the multiplication reduction remain open. No new integer κ, complex b, BIT c, practical speedup or literature-priority claim.

Validation:

• Fresh macOS/Python 3.14 and Linux aarch64/Python 3.12 replays passed in 164.74s and 163.67s. All nine deterministic certificates are byte-identical across platforms.
• 108 generic scan cases; 480 mixed-factor cases, including 240 independent dense solves; 345 precision-budget cases; 8384 stride mappings and 43 routed executions; 116 varying-coefficient/phase cases with 72 additional dense comparisons; 36 dirty-factor cases, 120 dense dirty compositions, 24 actual-kernel dirty cases, 1035 dirty precision budgets; 48 rejection controls, including eight instruction mutations.
• Ten kernel/embedding certificates through radix 16 cover inner and outer factors, exact rational phases and a certified approximation of exp(2πi/7), each with an all-length 2^-128 error bound.
• Complete receipts, stage logs and hash verification are included. Every staged blob was checked against the source/evidence manifests. A Python 3.11/3.14 CI workflow replays the package.

The package is standalone and uses the Python standard library. Kernel, mathematical-source and substantial OpenAI Codex assistance credits are recorded in NOTICE.md and SOURCE.json.

[Mister-Meeseeks]

Thank you @chafreaky. This contribution is now retained on main in the scoped 100-PR review and contributor credits.

Contribution: Rounded prime-power cyclic inversion and dirty restoration.

Review and limits: Written all-length precision bounds retain the charged preparation/oracle contracts. Dense finite tests do not supply reversible bit arithmetic, a common-label word or a new kappa.

The complete original source, notices and relevant execution evidence are retained through the pinned source archive. The review distinguishes fresh local runs, source-bound historical Linux CI and prior exact-head review; it does not claim 100 fresh full mathematical audits. Closing this historical PR as reconciled. This preserves parallel and cumulative credit without replacing the selected frontier or promoting priced research targets to completed constructions.

Reviewed head: 0768f97d06c623b8211e651543c66135796b62bf. Publication: 64039f1bd3b6a523b96083fd858ad040a75e3030.