diff --git a/docs/research/standalone-history-scalar-ceiling/EVIDENCE-INDEX.md b/docs/research/standalone-history-scalar-ceiling/EVIDENCE-INDEX.md new file mode 100644 index 0000000000..3f173af9d9 --- /dev/null +++ b/docs/research/standalone-history-scalar-ceiling/EVIDENCE-INDEX.md @@ -0,0 +1,57 @@ +# Written-proof evidence and original-label remap + +The twelve payloads below are unchanged LOCAL proof, acceptance, review and conditional-source snapshots. [SOURCE-MANIFEST.json](SOURCE-MANIFEST.json) records exact hashes, byte lengths and original labels. They are not registered executable inputs or claims that private source programs have been bundled or newly validated. The four new navigation/provenance documents are README, this index, the manifest and handoff. + +## Current written-review status + +| Result | Exact proof | Additive acceptance | Independent AI static review | +| --- | --- | --- | --- | +| Fixed-word central Laurent extension | [Lemma](proofs/central-lemma-v1.md), e4ead15d… | [Report](acceptance/central-report.md), 7508cb57…; [decision](acceptance/central-decision.json) | [Report](reviews/central-report.md), 6438f2df…; [decision](reviews/central-decision.json), 5a53ed0e… | +| Eventual pointwise extension | [Lemma](proofs/pointwise-lemma-v1.md), ac2a5a7c… | [Report](acceptance/pointwise-report.md), c4451f41…; [decision](acceptance/pointwise-decision.json), 9c6b9514… | [Report](reviews/pointwise-report.md), c49f6c25…; [decision](reviews/pointwise-decision.json), 1177ef15… | + +The original PROPOSED headings and old pending-review statements in the exact lemmas remain historical. Acceptance is additive and the independent decisions require no mathematical correction. The pointwise guard is each f≥2p−1 for a fixed finite projective ordinary family; it is not a practical-width result. Both variants exclude free correlated nonordinary paid history initially. + +## Direct predecessor and the added scope + +The direct public predecessor is [#5425's standalone ordinary-module history argument](https://github.com/Clear1nsight/integer-mult-bounds/tree/00005c8c5e81c7f27b5769f9309ff88758e26f51/research/fanout-optimality-support), at head `00005c8c5e81c7f27b5769f9309ff88758e26f51`. Its cached body declares module-proof SHA256 `cfa9f3df855f96a3e73bcb8042a750a3aa41d18ec098d6a34268370f3e84d782` and explicitly allows feedback/overwrites with ordinary initial history, fixed capacity and a finite columnwise ordinary group. The monitor supplied the immutable package-tree locator and declared proof hash; no new predecessor proof fetch or scientific replay is claimed here. + +This note extends that principle to fixed central c·2^(n f) normalizers and to arbitrary exterior c(f) with nonuniform finite words and N(f) at each f≥2p−1. Its conditional 120-coordinate nomination is separate from the predecessor's 112-output specialization. It is an extension/application of an existing history argument, not a new general history principle. + +## Source nomination and link remap + +The [source report](source/standalone-local-report.md), 6dc97b31…, supplies the ordered T=A Jbar A^-1 nomination, 120 distinct input coordinates, nonmonomial support and surjectivity arguments, and the conditional signed-profile inequality. The [conversion obligation](source/conversion-obligation.md), 70230e2b…, makes the exact standalone resource contract explicit. These documents do not make this note a physical BC implementation or admitted supplier. + +The following original labels inside frozen appendices resolve to the copied artifacts here. A reference to a source program or another audit not listed below remains an inherited source premise, not a new public dependency or execution claim. + +| Original LOCAL label suffix | Public copy | +| --- | --- | +| `coded-canonical-conversion-ceiling-20261024/REPORT.md` | [Source report](source/standalone-local-report.md) | +| `CONVERSION-OBLIGATION.md` | [Conversion obligation](source/conversion-obligation.md) | +| `central-scalar-extension/PROPOSED-LEMMA-v1.md` | [Central proof](proofs/central-lemma-v1.md) | +| `central-scalar-extension/REPORT.md` / `DECISION.json` | [Acceptance](acceptance/central-report.md) / [decision](acceptance/central-decision.json) | +| `central-scalar-independent/REPORT.md` / `DECISION.json` | [Review](reviews/central-report.md) / [decision](reviews/central-decision.json) | +| `pointwise-scalar-extension/PROPOSED-LEMMA-v1.md` | [Pointwise proof](proofs/pointwise-lemma-v1.md) | +| `pointwise-scalar-extension/REPORT.md` / `DECISION.json` | [Acceptance](acceptance/pointwise-report.md) / [decision](acceptance/pointwise-decision.json) | +| `pointwise-scalar-independent/REPORT.md` / `DECISION.json` | [Review](reviews/pointwise-report.md) / [decision](reviews/pointwise-decision.json) | + +No raw native word, provider kernel, helper census, source scan, scientific checker or constructor is imported. Original source-path labels and old publication-status statements are preserved as evidence history. The top-level narrative links to the copies above rather than to workspace paths. + +## Primary-reference attribution + +Anthony Chefles, *Unambiguous Discrimination Between Linearly Dependent States With Multiple Copies*, Physical Review A 64, 062305 (2001), [DOI](https://doi.org/10.1103/PhysRevA.64.062305), [inspected manuscript version](https://arxiv.org/abs/quant-ph/0105016v3). The sole literature worker's LOCAL fit note is SHA256 `bf92eaf26ae87303e6f1f8a893a33db48009b93b5c3ec269b2d426f2c2ad3562`; its retained inspected manuscript hash is `38f5efd58c5c4f902e40cfb6283c804650bf1d5ebd2678a89ffe7710e44ecdb9`. This note neither repeats that paper review nor claims the classical tensor observation as new. + +Peter Kropholler and Karl Lorensen, *Group-graded rings satisfying the strong rank condition*, Journal of Algebra 539 (2019), 326–338, [DOI](https://doi.org/10.1016/j.jalgebra.2019.08.014), [inspected manuscript version](https://arxiv.org/abs/1901.10001v2). The sole literature worker's LOCAL fit note is `170e3c9923f0c9b7543f7775b00aeda953691012d82e84ecea43ed861827e5fb`; its inspected manuscript hash is `9ed6eaa9ed0a459da9411dc4739152ff93d72f27d0d38c0b70f109e168df51f1`. The central proof is self-contained; the published theorem provides corroboration. + +Only short factual attribution, URLs and hashes are retained here. No third-party paper PDF/text, full bibliography or raw agent/chat coordination log is included. + +## Scope of inspection and overlap + +The retained reports record written reasoning, source-text inspection and byte hashes. No native, phase, rank, operator, calibration, numerical-power, price, Lean or other proof engine was run for this documentation note. Independent AI static review is separate from human review, formal verification, hosted tooling checks and supplier admission. + +The sole monitor's checkpoint 1347 was captured at 2026-10-24 13:47:44 UTC, with current all-author/all-state PR metadata coverage through 13:33:40 UTC and selective body/source review. At exact cached [PR5436 head](https://github.com/CrocSwap/integer-mult-bounds/commit/4c31fd7d4eee61ff9fd59533549a67ef1a25b449) `4c31fd7d4eee61ff9fd59533549a67ef1a25b449`, zxv's moving-support statement and four-control 2705-source corollary supplied the prompt. Their proof, count, calibration and execution claims are not independently adopted here. This bounded overlap context is not universal novelty coverage. + +The supplied prepublication receipt is SHA256 `3f68e99596c99eb0597baaedcc69d40b11748153f2a31df3c9a2eaf75b74ca48`, recorded at 2026-10-24 16:52:00 UTC with current metadata/body coverage through 16:50:42 UTC and a subsequent static locator addendum. It covers 100 recent all-state records, reports no changed nearby exact-scope claim in that incremental pass, and leaves main/guidance/selected unchanged. It does not exhaust Discussion history or unpublished work. The cached #5425 body is `b84a70a51002eeb5aa54c74e1e78865a79f276dee6d0defb852a68d20d0cd1ab`. + +Adjacent exact heads are [#5441](https://github.com/CrocSwap/integer-mult-bounds/commit/11fedb46fa199283f78282187c10aea432d8b0bb), for fixed physical transfer-table endpoint/cut bounds, and [#5442](https://github.com/CrocSwap/integer-mult-bounds/commit/19e8f0452c09cbfe99511ea697fa239c1f457314), for a finite-group all-width lifting lemma and a separately claimed complete-body certificate. The latter claim is [challenged by review comment 6385984727](https://github.com/CrocSwap/integer-mult-bounds/pull/5442#issuecomment-6385984727). This note adopts neither that executable certificate nor its body-closure claim; neither is a dependency of the conditional LOCAL nomination. A finite-width affine diagnostic for a different family supplies no replacement for this note's ordinary-group/target-coset separation. No such calibration is imported or executed here. + +The [handoff](HANDOFF.md) distinguishes the current local assembly from any later commit, public readback or hosted CI result. diff --git a/docs/research/standalone-history-scalar-ceiling/HANDOFF.md b/docs/research/standalone-history-scalar-ceiling/HANDOFF.md new file mode 100644 index 0000000000..503db7d4bd --- /dev/null +++ b/docs/research/standalone-history-scalar-ceiling/HANDOFF.md @@ -0,0 +1,22 @@ +HANDOFF + +Research discussion / PR / artifact: +[Standalone paid-return histories with scalar extensions](README.md), with the [immutable proof/review snapshot](https://github.com/Clear1nsight/integer-mult-bounds/blob/56c52a79f7663bc59ad3a5013c242a113039a701/docs/research/standalone-history-scalar-ceiling/README.md). The upstream PR is the canonical investigation thread for this documentation contribution. The note is unregistered written mathematics with independent AI static reviews, not an executable research capsule. + +Exact commit: +Proof/review snapshot: 56c52a79f7663bc59ad3a5013c242a113039a701; authenticated canonical base: 32890bc5de034ab8fc93ac88ead7279a6a416d04. A later metadata-only commit pins this handoff; the upstream PR and public handoff identify its publication head separately. The twelve original proof/review/source payloads retain their exact LOCAL byte hashes in [SOURCE-MANIFEST.json](SOURCE-MANIFEST.json); they are not fabricated canonical source roots. The canonical CI-navigation repair is already present and has no duplicate delta here. + +What is established: +The ordinary-module paid-history principle is retained from [#5425 at exact head 00005c8c…](https://github.com/Clear1nsight/integer-mult-bounds/tree/00005c8c5e81c7f27b5769f9309ff88758e26f51/research/fanout-optimality-support), including feedback/overwrites, ordinary initial span and fixed capacity. This note adds the fixed-word central c·2^(n f) variant at all positive widths or a consecutive infinite tail, and the eventual pointwise arbitrary-c(f) variant with nonuniform finite words and N(f), only at each f≥2p−1 for one fixed finite ordinary G and geometry. Both yield at least q actual new returns for the stated q independent invertible target coordinates. No new history principle or transfer of the predecessor's 112-output application is claimed. The pointwise threshold may be astronomical. Independent AI reviews accept the exact scalar-extension proofs without a required correction; acceptance reports preserve the original PROPOSED headings. The q=120 source example remains a conditional LOCAL mathematical nomination, with its ordered target, nonmonomial and independent-input arguments copied for inspection. The supplied sole-monitor refresh covers current PR metadata/body records through 2026-10-24 16:50:42 UTC, bounded rather than exhaustive; main/guidance/selected are unchanged. + +What remains uncertain: +The written proofs and documentation scope have separate independent AI static reviews. Independent human or formal-kernel review and a source-specific application remain open. Public readback and hosted tooling status are recorded on the upstream PR; neither supplies physical or scientific admission. The supplied prepublication refresh does not approve future byte changes. Neither theorem establishes an additional paid-call charge at an actual parent cut with cached/native/paid observations. No practical-width application, physical BC ABI/implementation, admitted supplier, new productive target, uniform recursive cost/precision/stock contract or new kappa follows. Adjacent #5441 concerns transfer endpoints/cut dimensions; #5442's claimed complete-body closure is challenged and is not a dependency here. No small-width affine corollary replaces this note's large fixed ordinary-group/target-coset separation. A shallow/shared base checkout does not prove full source history or corpus availability. The copied source premises are not freshly replayed. + +Smallest useful next task: +The next distinct research question is the actual cut's versioned available-history module and target containment, including ownership, retention and opportunity costs. That question remains outside this note and with its owner. A source-specific smaller width threshold also needs a separate justified argument. + +Reproduction command and expected runtime: +None for a scientific replay. Read the [two proofs and their independent reviews](EVIDENCE-INDEX.md). There is no VERIFY.json, verifier, numerical RESULT or registered command. Assembly checks are limited to copied-byte hashes, local navigation and Git diff/metadata; their results cannot certify the theorem or a supplier. No paper PDF/text, raw agent/chat log, peer-owned helper census or constructor is included. + +Predecessor credit: +The #5425 finite ordinary-module proof/reviewer directly, including its feedback/overwrites argument; Anthony Chefles for classical tensor/projective independence; Peter Kropholler and Karl Lorensen and their credited strong-rank predecessors; zxv for the #5436 support-width prompt; scalar/source authors, root's localization and paid-history application question, independent reviewers and sole literature worker; and the BC/native/Clifford/product/compiler/precision/analytic lineage. Preserve Ali Romman, Dillon Amburgey/dillona, Cao Yifan, Cinna Davis, zxv, Dugongue, Jacob Alan Sussman, Chris R/Clear1nsight and the retained notices. Substantial OpenAI Codex assistance. No independent human or formal-kernel verification is claimed. diff --git a/docs/research/standalone-history-scalar-ceiling/README.md b/docs/research/standalone-history-scalar-ceiling/README.md new file mode 100644 index 0000000000..dbc883134c --- /dev/null +++ b/docs/research/standalone-history-scalar-ceiling/README.md @@ -0,0 +1,87 @@ +# Standalone paid-return histories with scalar extensions + +For an exact standalone linear program, q invertible target rows on distinct independent input coordinates can require at least q new paid whole-field returns, even when paid calls use earlier responses. This note gives two precise versions of that history-dimension statement. Both start with **ordinary initial history only**, keep one fixed field capacity, and count one actual new output row per paid call. + +The paid-history principle is inherited from [the standalone finite ordinary-module argument in #5425](https://github.com/Clear1nsight/integer-mult-bounds/tree/00005c8c5e81c7f27b5769f9309ff88758e26f51/research/fanout-optimality-support), at exact head `00005c8c5e81c7f27b5769f9309ff88758e26f51`. That predecessor permits finite feedback and overwritten rows within its fixed-word, fixed-capacity, ordinary-initial-history contract. The additions here are the central c·2^(n f) scalar extension, the eventual pointwise arbitrary-c(f) extension with nonuniform finite words and N(f), and the separate conditional q=120 nomination. The predecessor's 112-output application is not transferred, and no new paid-history principle is claimed. + +The first version permits fixed exterior powers-of-two normalizers in a fixed finite word. The second permits arbitrary width-dependent exterior scalars and nonuniform finite words, but applies only at each sufficiently large width **f ≥ 2p−1**, where p is the number of actual projective classes of one fixed finite ordinary group. That threshold can be astronomical. Neither version establishes a new-call charge at a parent cut already holding paid/native/cached observations, a practical-width certificate, a physical supplier or a new κ. + +## General statement and the two width domains + +Let K=Q(i), let V be a fixed nonzero finite-dimensional one-column space, and let G be a fixed finite group of actual invertible ordinary matrices on V. A width-f field is V tensor-powered f times, up to one prescribed common layout conjugation. Whole-field ADD, COPY and CLEAR and the declared ordinary address lifts are allowed. The program is exact and linear on its full independent current-input space; its choices and coefficients are independent of input values. + +The q targets have fixed invertible one-column maps h_i on **distinct** input coordinates v_i, possibly plus ordinary initial backgrounds. Different h_i need not occupy different ordinary cosets. Each paid call transforms one actual current whole-field row and returns one new row at the same capacity. Keeping a copy of its old input does not create a second paid return. No commutation or ordinary-module linearity of the paid operator is assumed. + +| Statement | Allowed scalar/program dependence | Width requirement | Target exclusion | +| --- | --- | --- | --- | +| [Central Laurent](proofs/central-lemma-v1.md) | One fixed finite columnwise word; exterior c·2^(n f), with c in K and integer n fixed per instruction independently of f; paid one-column operators fixed | Exactness at every positive width, or throughout a consecutive infinite tail | h_i is outside `<2I>G` | +| [Eventual pointwise](proofs/pointwise-lemma-v1.md) | Arbitrary exterior c(f) in K; finite ordinary words, their lengths and finite independent dirty-input counts may vary arbitrarily with f; ordinary G and geometry remain fixed | **Each integer f ≥ 2p−1**, with p=\|G/(G∩K×I)\| | h_i is outside `K×G` | + +Under the respective hypotheses, the program needs at least q paid returns. The pointwise statement needs neither a common word across widths nor exactness at consecutive widths once its guard is met. It does not assert a bound at arbitrary smaller widths. For the conservative fourth-root monomial enlargement on a d-dimensional V, p=4^(d−1)d!; in the nominated source geometry d=2^625. These are symbolic finiteness bounds, not a computation of a usable cutoff. No application at f=1, f=2 or f=1024 is certified. + +## Why actual returned rows give the bound + +At one eligible pointwise width, the actual ordinary image algebra + +``` +R_f = span_K {g^(tensor f) : g in G} +``` + +has dimension p after exact proportional phases are merged. Classical tensor separation applied to the 2p projective classes in G and G h_i gives `R_f ∩ R_f h_i^(tensor f) = {0}`. Only G and one target coset are separated at a time; distinct input coordinates supply the separation among targets. + +Retain every actual paid output row t_j conceptually, including overwritten or cleared rows. Starting with N independent inputs, the history is contained in + +``` +M = R_f^N + R_f t_1 + ... + R_f t_m. +``` + +Each actual return contributes at most p dimensions. The q target rows require q additional p-dimensional summands on distinct input coordinates. Thus `(N+q)p ≤ dim_K M ≤ (N+m)p`, so m≥q. A finite N(f) cancels separately at each eligible width. This analysis does not grant the paid operation for free on every earlier row. + +For the central variant, fixed Laurent support is first expanded and exact all-width/consecutive-tail identities are promoted to formal row identities. Central localization then replaces K by K(τ), leaving an ordinary algebra of dimension |G| over that field. The analogous dimension comparison gives the same paid-return count. Localization is a proof device; it grants no physical division by a rational function of 2^f. The two self-contained proofs and their exact hypotheses are retained unchanged in the appendices. + +## Conditional nominated example: 120 target coordinates + +The [LOCAL source report](source/standalone-local-report.md) and [conversion obligation](source/conversion-obligation.md) nominate a particular canonical-conversion interface, rather than an upstream-admitted BC supplier. After the specified ordinary entrance and reciprocal typed source rule, its current output is `w=A Jbar^-1 z` and its required semantic output is `A z`. The uniquely required post-map on the full current-input space is therefore + +``` +T = A Jbar A^-1. +``` + +On each of 120 distinct v-owner coordinates, the nominated one-column block contains `h=Q J Q^-1`, with the stated factorwise lift and ordinary aliases. The retained source identity `Phi581=L2 h Q² R1` has four nonzero entries per row; multiplication by the monomial units and tensoring with invertible factors preserve nonmonomial support. Consequently each nominated h_i is invertible and outside every scalar-monomial ordinary class. + +The source-owner argument uses invertible genuine-original prefixes, disjoint original banks, the unchanged-owner no-write interval and invertible normalization to make these current coordinates simultaneously arbitrary. The copied source documents state that argument and its premises. This note does **not** freshly validate the physical ABI, native implementation, source phases, owner scan or compiler application. Under those inherited nominated premises, q=120 specializes the general statement, subject to its exact width/scalar contract. + +The optional fixed-profile comparison is also conditional. Hold exactly + +``` +P = {1:2201, 2:412, 3:510, 4:127, 5:40}, +T = {4:28, 7:7, 8:159, 9:438}. +``` + +T generously includes the unadmitted 120H8+120H9 main grant and the retained helpers. If this standalone converter is added without changing any other calls or genuine targets, its positive-rank paid returns cost at least 120 in a rank moment. The copied source proof gives `F(t)=T_t−P_t−120`, `F(1)=−8`, and `F(t)/6^t<−4/3` for 0 x G, finite G with trivial intersection with <2I>", + "ordinary_algebra": "Q(i)[tau,tau^-1][G]", + "counting_field": "Q(i)(tau)", + "localization_is_physical_primitive": false, + "full_localized_algebra_asserted_untwisted_group_algebra": false, + "paid_operator_R_linearity_assumed": false, + "paid_group_amenability_assumed": false, + "width_scope": "Every positive width or a consecutive infinite tail", + "history_scope": "Ordinary span of arbitrary independent current inputs only; no free correlated paid/native/cached rows", + "target_condition": "Distinct input coordinates and invertible h_i outside <2I>G", + "source_targets_satisfy_condition": "Retained nonmonomial 120-v-owner natural canonical conversion under existing source premises", + "standalone_total_new_Gaussian_field_calls_lower_bound": 120, + "sealed_symbolic_signed_profile_stop_reused": true, + "signed_profile_interval": "All real 0. Since finite G has no infinite-order scalar, S intersects G trivially and the ordinary group is O=S×G. Put + +``` +Lambda = Q(i)[tau,tau^-1], tau=[sigma], +R = Lambda[G], F=Q(i)(tau). +``` + +Each finite use of c*2^(n f) is represented as c tau^n. Expanding the finite word gives finite group-algebra support with constant coefficients; the original all-width/consecutive-tail Vandermonde proof applies before localization. + +For the actual matrix group Gamma containing ordinary, paid and target operators, choosing representatives of Gamma/S makes Q(i)[Gamma] free over Lambda. Hence no nonzero Laurent polynomial annihilates a nonzero row. Central localization is injective and the ordinary algebra becomes F[G], of finite F-dimension |G|. The representative basis can have twisted multiplication; no claim that the full localized algebra equals the untwisted group algebra F[Gamma/S] is used. + +Each paid call adds only its one actual returned row to history. It does not act freely on every prior row and is not assumed R-linear. The initial N independent rows plus m paid returns therefore span at most (N+m)|G| dimensions over F. + +The required 120 conversion rows have distinct input coordinates and unit operators h_i outside O. Their ordinary multiples contribute 120 free, independent F[G] summands beyond initial ordinary history. Thus + +``` +(N+120)|G| <= dim_F(history) <= (N+m)|G|, +m >= 120. +``` + +Localization does not erase these rows: their S-coset supports remain disjoint from ordinary support. No arbitrary nonzero element of the ordinary group algebra is cancelled. Fractions such as 1/(tau-2) exist only in the proof's dimension comparison; they are never evaluated at a physical width or granted as a program operation. + +The strengthened target condition matters. For h=2g with g in G, the target h^(tensor f) is now ordinary despite h being outside G, so zero paid calls suffice. The actual source-bound h_i are nonmonomial and therefore outside every scalar-monomial class 2^nG. They satisfy the stronger condition. + +## Source application and unchanged boundary + +The retained natural conversion is T=A Jbar A^-1 after the ordinary entrance and actual reciprocal source rule. Its 120 independent v owners have nonmonomial blocks from h=QJQ^-1. The exact source equality Phi581=L2 h Q²R1 gives four nonzeros per row. The earlier source-owner argument supplies full joint current-input surjectivity; this extension does not redo a native, rank or phase census. + +The geometry remains the actual 625-axis grid. The rank-one child action and J overlap on the canonical U row within active V columns; they are not operators on independent tensor factors that can be commuted. No private-axis construction is supplied here. + +With the original conditional target grant and paid histogram held fixed, every added positive-rank call costs at least 1 in the 0=2p-1, m(f)>=120 under the retained source and standalone interface premises", + "p": "Number of actual projective classes of one fixed finite ordinary one-column group G", + "coefficient_field": "Q(i)", + "target_condition": "Invertible fixed h_i outside K^times G on 120 distinct fully independent current-input coordinates", + "initial_history": "Ordinary span only; independent dirt and zero scratch allowed, correlated paid/native/cached observations excluded", + "arbitrary_width_dependent_exterior_coefficients_allowed": true, + "input_dependent_coefficients_or_nonlinear_choices_allowed": false, + "nonuniform_finite_ordinary_words_and_finite_Nf_allowed": true, + "G_and_one_column_geometry_fixed": true, + "same_word_or_consecutive_widths_required": false, + "each_paid_call_returns_one_new_actual_linear_row": true, + "paid_operator_Rf_linearity_assumed": false, + "threshold_can_be_enormous": true, + "small_width_or_practical_width_application_certified": false, + "actual_parent_incremental_paid_history_bound": false, + "new_uniform_recursive_cost_theorem": false, + "old_symbolic_invoice_reused_only_at_eligible_width_under_same_complete_PT": true, + "new_Gaussian_main_target_admission": false, + "new_kappa": null, + "classical_tensor_independence_claimed_new": false, + "PR5436_four_control_2705_result_adopted_or_replayed": false, + "proposed_files_and_earlier_accepted_artifacts_modified": false, + "scientific_execution_or_calibration": false, + "new_agents_or_literature_feed": false, + "external_publication": false +} diff --git a/docs/research/standalone-history-scalar-ceiling/acceptance/pointwise-report.md b/docs/research/standalone-history-scalar-ceiling/acceptance/pointwise-report.md new file mode 100644 index 0000000000..9fc6a2b27b --- /dev/null +++ b/docs/research/standalone-history-scalar-ceiling/acceptance/pointwise-report.md @@ -0,0 +1,65 @@ +# Accepted eventual pointwise standalone history bound + +Decision: **PASS_SCOPED_EVENTUAL_POINTWISE_HISTORY_BOUND.** At **each integer width f>=2|PG|-1**, the retained natural canonical conversion requires at least **120 new paid whole-field returns**, subject to its source/geometry/ownership premises and full independent current inputs. Here PG is the set of actual projective classes of **one fixed finite ordinary one-column matrix group G**. Initial resources are its ordinary span only; previously paid/native/cached correlated observations are excluded. + +The explicit threshold can be enormous. This is **not a bound at every small width, a practical-width certificate, or an incremental charge at the actual parent cut**. No f=1, f=2 or f=1024 application is certified by this package. No κ, funding, compiler closure or newly admitted Gaussian main target is claimed. + +The advance is precise: arbitrary width-dependent exterior coefficients in Q(i), arbitrary input-independent finite ordinary word lengths, and finite independent dirty-input counts N(f) are now admitted at every eligible width. No common word or coefficient sequence across widths is required. G, its one-column geometry and the fixed target maps remain unchanged. + +## Sealed proof and independent acceptance + +The exact proof is `PROPOSED-LEMMA-v1.md`, SHA256 `ac2a5a7c2e98b9dc3b19fbe0112003b37edf94dc13c0dc1411805cf52200c1e4`. The proposed decision, original handoff and original manifests remain unchanged, including their historical pending-review status. This report, `DECISION.json`, `HANDOFF-ACCEPTED.md` and the accepted manifests add the final status without replacing that history. + +The independent review is `../pointwise-scalar-independent/REPORT.md`, SHA256 `c49f6c25f65ba81d66d24601467496cebf7bc1ad8b4014975474fc01a9b6b88e`. Its decision, SHA256 `1177ef15931bae8c60b54591cf950378f1cbcfd2a4181ed66fbbf1de5bb701cc`, accepts the exact statement with **no required correction**. This is independent AI static mathematical review, not formal-kernel, source-execution or independent human validation. + +## Why arbitrary exterior scalars and long ordinary words are covered + +At one eligible width define the actual image algebra + +``` +R_f = span_K {g^(tensor f) : g in G}, K=Q(i), +p = |PG| = |G/(G intersect K^times I)|. +``` + +Projectively equal matrices are merged with their exact lifted phase: if g=lambda g_j, then g^(tensor f)=lambda^f g_j^(tensor f). The relevant dimension is p, not |G|. Arbitrary exterior scalar values at this width are ordinary K coefficients. Arbitrarily long but finite products remain in G, and their sums remain in R_f. + +Classical tensor separating functionals make s pairwise nonproportional matrix vectors independent after tensoring f times whenever f>=s-1. For each required invertible target h_i **outside K^times G**, the combined set G union G h_i has exactly 2p projective classes. Thus, at f>=2p-1, + +``` +dim_K R_f = p, +R_f intersect R_f h_i^(tensor f) = {0}, +dim_K(R_f h_i^(tensor f)) = p. +``` + +The ordinary image algebra may contain zero divisors and width-dependent phase factors in its multiplication. Neither harms this vector-space dimension argument. The target dimension uses right multiplication by an invertible actual matrix, not cancellation of an arbitrary ordinary element. + +For N(f) independent current inputs, retain their ordinary span and each actual paid return as conceptual history, including rows later overwritten or cleared. One paid call adds only one actual row, hence at most p dimensions. Its action need not commute with R_f or be R_f-linear. The 120 required targets occupy distinct input coordinates and contribute 120 additional independent p-dimensional spaces. Therefore, at each eligible width, + +``` +(N(f)+120)p <= dim_K history <= (N(f)+m(f))p, +m(f) >= 120. +``` + +Finite N(f) cancels independently at each width; zero scratch adds no independent row. The proof uses no relation between widths, so exactness on a consecutive tail is not required for the pointwise conclusion. It does not promote width-dependent coefficients into a formal all-width identity and uses no localization. + +## Source application and remaining limits + +The earlier source-bound report supplies T=A Jbar A^-1, full joint current-input surjectivity on the selected 120 v owners, and fixed invertible nonmonomial target blocks. The source identity Phi581=L2(QJQ^-1)Q²R1 gives four nonzeros per row for the central factor; the nominated factorwise lift and ordinary aliases preserve nonmonomial support. Therefore these h_i are outside every scalar-monomial class K^times G. The 625 binary-axis grid and its overlapping child/matcher action remain unchanged. No native, phase, rank or ownership replay was performed here. + +The projective exclusion is essential. If h=lambda g, then its target is already ordinary by applying g^(tensor f) and exterior lambda^f. At small widths a nonmonomial h can also lie in the ordinary span: Q=((1+i)I+(1-i)X)/2 is such an example at f=1 for G={I,X}. These examples are consistent with the explicitly guarded theorem. + +For the conservative full monomial enlargement on a d-dimensional one-column space, p=4^(d-1)d!, with d=2^625 in the retained geometry. These are symbolic cardinalities, not an evaluated or optimized cutoff. A particular bounded-width caller must separately satisfy the guard. A family with unbounded eligible widths eventually enters this mathematical range, but that does not establish uniform recursion, ordinary costs, stock or precision bounds. + +The theorem does not cover a silently growing ordinary projective family, changed one-column geometry, general cross-column ordinary maps, data-dependent nonlinear choices, approximate endpoints, dependent or partial targets, changed capacity or multiple new paid outputs. Initial paid/native/cached history remains a distinct boundary: already available target rows can make the additional call count zero. Surjectivity of current inputs does not remove that correlated information. Separate local bounds cannot be added automatically across shared conversions. + +At an eligible width, each of the 120 positive-rank Gaussian calls costs at least 1 in a 0G required here. + +## 2. Central scalar group and its exact coefficient representation + +Set sigma=2I_V and S=. The group S is infinite cyclic: 2^n I=I only when n=0. Every scalar matrix is central in GL(V,K). Since G is finite, S intersects G only at I. Indeed sigma^n in G has some finite order d, so 2^(nd)=1 and n=0. Thus the ordinary matrix group is the internal direct product + +``` +O = S G = S x G. +``` + +In particular, existing fourth-root phase matrices cause no intersection problem. A nontrivial power of 2 cannot equal i^j. Phase matrices in G and exterior coefficients in K remain distinct formal data. + +Let Gamma be the actual matrix subgroup generated by O, all paid operators and their inverses, and the target h_i and their inverses. It can be infinite. The ambient algebra is the formal group algebra A0=K[Gamma], with basis symbols [a] for actual distinct matrices a in Gamma. Set + +``` +Lambda = K[tau,tau^-1], tau maps to [sigma], +R = K[O] = Lambda[G]. +``` + +Lambda embeds centrally into A0. A nonzero Laurent polynomial in [sigma] is nonzero because the matrices sigma^n are distinct group-basis elements. Also the presentation R=Lambda[G] is faithful because sigma^n g has a unique pair (n,g). + +Although sigma is the scalar matrix 2I on V, the formal element [sigma] is not the exterior coefficient 2[I]. Its width-f evaluation is 2^f I, whereas 2[I] evaluates as 2I. The ordinary instruction c*2^(n f) is represented by c tau^n; it is not treated as a coefficient sequence external to the algebra. + +This distinction is essential. For example [sigma]-tau[I] is identically zero by the definition of tau, while [sigma]-2[I] is a nonzero formal element that happens to evaluate to zero at f=1. No width-one matrix relation is substituted for an all-width formal relation. + +## 3. All-width faithfulness survives the enlarged finite-word grammar + +For every f>=1 define the K-algebra homomorphism + +``` +Phi_f : A0 -> End_K(V^(tensor f)), +Phi_f([a]) = a^(tensor f). +``` + +Products are preserved because tensor powers preserve composition. In particular + +``` +Phi_f(c tau^n [g]) = c*2^(n f)*g^(tensor f). +``` + +Every actual row reached by a fixed finite word has finite support in A0 after expanding its finitely many Laurent coefficients. Its exterior coefficients then belong to K and are fixed independently of f. This remains true with negative exponents, overwritten fields and finite feedback. + +The family Phi_f, over all f in any consecutive infinite tail, is injective. To prove it, take distinct nonzero matrices a_1,...,a_s and suppose + +``` +sum_j c_j a_j^(tensor f) = 0 for every integer f>=f0, +``` + +with fixed c_j in K. Since K is infinite, choose a K-linear functional ell on End_K(V) such that lambda_j=ell(a_j) are nonzero and pairwise distinct. The excluded choices form a finite union of proper hyperplanes. Apply ell^(tensor f) to the equality for f=f0,...,f0+s-1. The resulting Vandermonde determinant is, up to sign, + +``` +(product_j lambda_j^f0) * product_{aA is injective by the torsion calculation. The same chosen S-coset representatives form an F-basis of A. The ordinary subalgebra R_F embeds and has finite F-dimension |G|; distinct g in G represent distinct S cosets because S intersects G trivially. + +All actual group elements [a] remain units in A, with inverse [a^-1]. No unproved cancellation in a group ring is used. R_F itself may have zero divisors—for an involution u, (1-[u])(1+[u])=0—and no part of the proof cancels those factors. + +Localization is an algebraic counting device **after** the all-width endpoint identities have been promoted. It is not an operation available to the physical program. For example 1/(tau-2) exists in F but has no evaluation at f=1 under tau=2^f. The proof never evaluates this denominator at width one, never inserts division by 2^f-2 into the program and never changes its all-positive-width requirement. No pole issue arises because only identities in A0 are evaluated physically; A is used for a dimension comparison. If desired, an equality in A can always be compared after clearing a common nonzero Laurent denominator, with injectivity justified above. + +## 5. History upper bound, including paid feedback + +Let N count the arbitrary independent initial current fields, including independent dirty ancillas. Known-zero scratch adds zero rows. Regard their initial rows e_1,...,e_N as elements of A0^N. Every ordinary operation has coefficients in R. After m paid calls let t_1,...,t_m be their actual output rows, retaining them conceptually after overwrites and CLEARs. The ordinary history module is + +``` +M_m = R e_1 + ... + R e_N + R t_1 + ... + R t_m. +``` + +All current rows belong to M_m. Ordinary operations form R-linear combinations. A paid call applies its actual [a] on the left to its actual current input row and creates one new row t_j; that row alone is adjoined. The proof does not assert that [a] commutes with G, that paid action is R-linear, or that an entire earlier history module can be transformed for the charge of one row. Central powers of sigma commute with [a], so localization is compatible, but no broader commutativity is required. + +Inside A^N take the corresponding localized span + +``` +Mhat_m = R_F e_1 + ... + R_F e_N + R_F t_1 + ... + R_F t_m. +``` + +Each R_F generator contributes at most |G| to F-dimension. Therefore + +``` +dim_F Mhat_m <= (N+m)|G|. (U) +``` + +The image of each cyclic module can be smaller than |G|, which only strengthens this upper bound. No freeness of M_m or its quotients is needed. Equivalently one may localize the surjection R^(N+m)->M_m; the displayed span and its direct dimension bound avoid needing a separate general exactness assertion. + +## 6. The required target modules survive and remain independent + +By the all-width endpoint proof, each required target row [h_i]e_vi lies in M_m after subtracting its ordinary initial background. Thus it also lies in Mhat_m. Set + +``` +I_F = R_F^N, +W_i = R_F [h_i] e_vi. +``` + +Right multiplication by the unit [h_i] gives an injection R_F->W_i, so dim_F W_i=|G|. Concretely the elements [g h_i]e_vi for g in G are independent because g h_i and g' h_i occupy the same S coset only if g= sigma^n g', which forces n=0 and g=g'. + +Their S-coset supports are disjoint from those of I_F in coordinate vi. Otherwise g h_i = sigma^n g' for some g,g' in G, implying h_i in S G=O, contrary to the target assumption. Different W_i occupy different input coordinates, so they are mutually independent even when the h_i are identical or lie in the same O coset. It follows that + +``` +I_F + sum_i W_i = I_F direct-sum W_1 direct-sum ... direct-sum W_kappa, +dim_F Mhat_m >= (N+kappa)|G|. (L) +``` + +This proves directly that localization has not erased or merged the target modules. Combining (U) and (L), with finite positive |G|, gives m>=kappa. Arbitrary independent dirt raises N on both sides; zero scratch does not raise N. This completes the proposed proof. + +## 7. Application to the already nominated conversion, and limits + +The sealed source argument identifies the required standalone post-map as T=A Jbar A^-1. On each of the 120 independent v owners, after the fixed role aliases, its one-column operator is a tensor product of nine copies of h=Q J Q^-1, with identity spectators. The actual source equation Phi581=L2 h Q²R1 gives four nonzeros per row for h. Hence each full h_i is nonmonomial and cannot belong to O, all of whose matrices are scalar multiples of monomials. Scalar powers of two cannot alter this support test. No new target classification is needed. + +The rectangular geometry is the grid of 625 binary axis groups (u_a,v_b) per fiber column. For the source rank-one demand, the child Gaussian acts on the canonical U row; J acts across the U coordinates within each active V column and overlaps that row. These are not independent Hilbert-space factors on which A and J automatically commute. Applying the child to every U row would change the source demand. This lemma retains exactly the frozen factorwise conversion and supplies no changed physical construction. + +Subject to the retained source, ownership, surjectivity and all-width premises, the bound of 120 new standalone Gaussian field calls therefore survives the added finite-word scalars c*2^(k f). The earlier exact signed-profile argument is unchanged: every positive-rank call costs at least 1 for 0=2p-1**, even when exterior coefficients, the ordinary instruction sequence, its finite length, and the finite number of independent dirty inputs vary arbitrarily with f. The ordinary operators must remain columnwise lifts from this one fixed G. The target operators and one-column field geometry remain fixed. + +This is a pointwise history-dimension application of classical tensor-power independence. It does not duplicate PR5436's four-control/support corollary, classify its 2705 source count, or claim a new tensor-separation theorem. It does not extend the actual parent cut's available paid-history contract. All earlier standalone and central-Laurent artifacts remain unchanged. + +## 1. Fixed geometry and pointwise program contract + +Let K=Q(i), let V be a nonzero finite-dimensional K-vector space, and let G be a fixed finite subgroup of GL(V,K). Let + +``` +Z = G intersect {lambda I : lambda in K, lambda != 0}, +PG = G/Z, p = |PG|. +``` + +Equivalently, p is the number of equivalence classes under g~g' if g=lambda g' for some nonzero lambda in K. Z is central. In the source's permitted enlargement, G is the finite group of computational-basis monomial matrices with fourth-root entries. This is a group of actual matrices, not formal word labels. A fixed-width field is U_f=V^(tensor f), up to the declared common layout conjugation. + +At any particular f, allow an arbitrary finite exact linear straight-line program with these resources: + +* Ordinary address operators g^(tensor f), g in G; arbitrary exterior coefficients c(f) in K; whole-field ADD, COPY and CLEAR. The coefficients and gate choices can depend arbitrarily on f, but not on input values. There is no uniform bound on the finite ordinary word length. +* N=N(f) arbitrary independent initial current fields, including any finite number of independent dirty inputs. Fixed-width initial ordinary combinations and zero scratch are allowed. Correlated nonordinary observations from earlier paid work are excluded from this standalone initial history. +* Paid calls on one actual current field, each returning one new K-linear transformed whole-field row at the same capacity. Their inputs may use earlier responses. The history proof needs neither commutation with ordinary operators nor a uniform choice of the paid operators across widths. In the source application these are the allowed positive-rank Gaussian calls. A preserved old input is not a second new paid return. + +The fixed target has q distinct current-input coordinates v_i and invertible one-column maps h_i satisfying + +``` +h_i notin K^times G = {lambda g : lambda != 0, g in G}. +``` + +The program must supply the q rows h_i^(tensor f) w_vi, possibly with an ordinary initial background added. It must be correct on the full independent current-input space at the particular width under consideration. Different h_i need not occupy different projective G cosets. The same target input coordinate cannot be counted twice. + +**Proposed theorem:** For every integer f>=2p-1, any such exact program uses m(f)>=q paid returns. Thus q=120 gives the desired eventual pointwise standalone bound. The theorem is about each eligible width separately; it requires neither a common word across widths nor exactness on consecutive widths. It asserts no bound for an arbitrary smaller width. + +## 2. Classical separation lemma, with a direct proof of the needed cutoff + +Let a_1,...,a_s be nonzero vectors in a finite-dimensional K-space E, no two proportional. For each index j and each l!=j, there is a K-linear form ell_(j,l) with + +``` +ell_(j,l)(a_l)=0, ell_(j,l)(a_j)!=0. +``` + +Such a form exists because a_j and a_l are linearly independent. Choose also a linear form eta_j with eta_j(a_j)!=0. For f>=s-1, apply the tensor functional consisting of the s-1 forms ell_(j,l), followed by f-(s-1) copies of eta_j, to a_k^(tensor f). Its value is zero if k!=j and nonzero if k=j. Applying these functionals to any proposed linear relation proves that + +``` +a_1^(tensor f),...,a_s^(tensor f) are linearly independent for f>=s-1. +``` + +For s=1 the claim follows directly from nonzeroness at every positive width. In the application below s=2p>=2, so f>=2p-1 is positive. Tensor factors of these functionals need not be equal; their evaluation on a pure power is just the product of scalar evaluations. No numerical rank calculation, norm bound, or all-width constant-coefficient inference is used. + +This conservative cutoff is a standard consequence of multi-copy/projective tensor independence. Anthony Chefles, *Unambiguous Discrimination Between Linearly Dependent States With Multiple Copies*, Physical Review A 64, 062305 (2001), DOI [10.1103/PhysRevA.64.062305](https://doi.org/10.1103/PhysRevA.64.062305), Section II, Eq. (2.3), gives the stronger rank-refined complex-state sufficient condition C>=N-D+1 for N distinct rays spanning dimension D. The sole literature worker inspected that theorem, its proof and the appendix lemma in [quant-ph/0105016v3](https://arxiv.org/abs/quant-ph/0105016). The elementary K-linear argument above proves exactly the weaker cutoff used here, without computing any source span rank or presenting the paper as a generic-field theorem. Its classical attribution is retained. + +## 3. Projective phases and the actual ordinary algebra + +Fix f>=2p-1 and choose one representative g_1,...,g_p of PG. A group element g=lambda g_j has lift + +``` +g^(tensor f)=lambda^f g_j^(tensor f). +``` + +At this fixed f, lambda^f is an ordinary scalar in K. Thus scalar phases are merged with their exact lifted factors. In particular iI contributes i^f I and is not counted as an additional independent direction. The formal group-algebra dimension |G| from the earlier all-width proof is deliberately not used here. + +Define the actual matrix algebra + +``` +R_f = span_K {g^(tensor f) : g in G} subset End_K(U_f). +``` + +It contains I and is closed under multiplication because G is a group and tensor lifts preserve composition. Any number of ordinary operations at this width remains in this algebra. The p chosen lifts span it. They are linearly independent once f>=p-1, by Section 2; our chosen threshold is at least that large. Therefore + +``` +dim_K R_f = p. +``` + +This is an image algebra, not an assertion that it is the untwisted group algebra K[PG]. Multiplication among chosen representatives may carry width-dependent scalar phase factors. Their exact coefficients do not affect the dimension conclusion. + +For a target h_i, right multiplication by its inverse shows that G h_i has exactly p projective classes. No class of G h_i meets a class of G: an equality g h_i=lambda g' would imply h_i=lambda g^-1 g' in K^times G. Consequently the combined set G union G h_i has exactly 2p projectively distinct representatives. + +Identify End_K(V)^(tensor f) with End_K(U_f). Section 2 applied to these 2p representatives gives linear independence at the single width f>=2p-1. With H_i=h_i^(tensor f), it follows that + +``` +R_f intersect R_f H_i = {0}. (SEPARATION) +``` + +Right multiplication by the invertible H_i is a K-linear isomorphism on the matrix space, so dim_K(R_f H_i)=p. This cancels a genuine invertible matrix, not an arbitrary nonzero ordinary algebra element. R_f may contain zero divisors. + +The same cutoff works for all q target owners. It is not multiplied by q: each separation is between G and one G h_i, while different owner coordinates will supply the other direct-sum separation. No independence across all combined target cosets is required. + +## 4. Actual paid history at this width + +Represent each current field as a row in End_K(U_f)^N acting on the N independent current inputs. This representation and the target row equations are valid because correctness holds on the full input space at this width. Put + +``` +I_f = R_f e_1 + ... + R_f e_N = R_f^N. +``` + +Retain conceptually every initial row and each actual paid output row t_j, even after physical overwrite or CLEAR. After m calls set + +``` +M_m = I_f + R_f t_1 + ... + R_f t_m. +``` + +Ordinary operations preserve this span, regardless of their number or arbitrary fixed-width coefficients. A paid call applies its actual K-linear operator to its actual current input and creates one new row, which is then adjoined. It is not assumed to be R_f-linear and is not allowed to transform all prior ordinary combinations for one charge. The paid operators need not themselves belong to a fixed finite matrix group for this history argument. + +Each cyclic contribution R_f t_j is the image of the p-dimensional K-space R_f. Therefore + +``` +dim_K M_m <= (N+m)p. (UPPER) +``` + +Every target H_i e_vi lies in M_m after subtraction of its ordinary initial background. Define W_i=R_f H_i e_vi. Each W_i has dimension p by target invertibility. Equation (SEPARATION) makes its intersection with I_f zero in coordinate vi; the distinct coordinates make the W_i mutually independent. Hence + +``` +I_f + sum_i W_i = I_f direct-sum W_1 direct-sum ... direct-sum W_q, +dim_K M_m >= (N+q)p. (LOWER) +``` + +Since p is finite and positive, UPPER and LOWER imply m>=q. This argument applies independently for each f>=2p-1. A finite N(f) that grows with f cancels at each width; known-zero scratch contributes no independent input row. No localization, formal group-algebra faithfulness, common coefficient sequence, uniform program length or uniform paid-history support bound is used. + +## 5. Source application and exact scope of the advance + +The sealed canonical-conversion report `../REPORT.md`, SHA256 `6dc97b31c69d7ca4ff49f649fc55d85c1e01e46cdbf7923f880811220f2e80d9`, supplies the natural T=A Jbar A^-1 output map, 120 independent full-current-input v coordinates, and invertible nonmonomial target blocks h_i. Its source equation Phi581=L2(QJQ^-1)Q²R1 gives four nonzero entries per row for the central factor; the specified factorwise lift and monomial aliases preserve nonmonomial support. These are retained source/ownership/surjectivity premises, not freshly executed classifications. + +Every element of K^times G is monomial, so the source h_i satisfy the strengthened target exclusion. The 625 binary-axis grid is fixed per column, with amplitude dimension 2^625. The child and matcher overlap on their actual canonical U row; no disjoint-factor commutation is introduced. A common prescribed layout conjugation does not change matrix independence or the history dimensions. + +It follows that, subject to those retained premises and the stated ordinary group, every exact standalone implementation at f>=2|PG|-1 needs at least 120 new paid returns, even with arbitrary exterior c(f), width-dependent ordinary gate choices and finite word lengths, and finite N(f). This closes those particular uniformity exceptions **eventually in width**, while keeping the same finite one-column ordinary group and full input interface. + +The threshold is explicit and finite, but may be enormous. No practical-width cutoff or source-optimal threshold is asserted. For the conservative all-monomial enlargement on a d-dimensional one-column space, |G|=4^d d! and p=4^(d-1)d!, with d=2^625 here; this is a symbolic finiteness bound, not a numerical computation or proposed census. A smaller known finite ordinary subgroup could give a smaller sufficient cutoff. No subgroup/class/rank search was performed. + +For positive-rank Gaussian calls, the count again supplies a charge of at least 120 at every eligible width in any 0G; ordinary initial backgrounds only", + "proof_steps_independently_accepted": [ + "S=<2I> central infinite cyclic and S intersects finite G trivially", + "Finite Laurent expansion before constant-coefficient all-width Vandermonde faithfulness", + "K[Gamma] free over central Laurent ring via Gamma/S representative basis, with possible twisted multiplication", + "Torsion-free injection into central fraction-field localization", + "Ordinary F[G] has finite F-dimension |G|", + "One actual paid output row adds at most |G| dimensions, without paid R-linearity", + "Target cyclic modules free and disjoint modulo S and across input coordinates", + "Dimension comparison gives m>=k" + ], + "source_application": "Retained nonmonomial 120-v-owner standalone conversion satisfies stronger h_i exclusion, subject to unchanged source/all-width/ownership/surjectivity premises", + "actual_parent_incremental_bound_established": false, + "cached_paid_history_excluded_from_initial_resources": true, + "arbitrary_width_dependent_scalars_admitted": false, + "rational_function_division_primitive_admitted": false, + "new_112_fanout_classification_or_generalization": false, + "scientific_execution_or_publication": false, + "funded_kappa": null +} diff --git a/docs/research/standalone-history-scalar-ceiling/reviews/central-report.md b/docs/research/standalone-history-scalar-ceiling/reviews/central-report.md new file mode 100644 index 0000000000..4e328de2a0 --- /dev/null +++ b/docs/research/standalone-history-scalar-ceiling/reviews/central-report.md @@ -0,0 +1,108 @@ +# Independent static review of the central powers-of-two extension + +**Decision: PASS_SCOPED_CENTRAL_LAURENT_EXTENSION. No mathematical correction is required for the sealed statement.** The proposed lemma at SHA256 `e4ead15d013be43c17ef18c80e8bb5b35b8c583615dc88fb68bca00eaba3aca6` proves at least k paid whole-field calls for k independently required nonordinary coordinate outputs in its enlarged, precisely stated standalone grammar. It soundly admits fixed finite-word exterior factors `c*2^(n f)` with c in K=Q(i) and integer n fixed independently of width f. + +For the retained canonical-conversion target, the earlier source premises supply k=120 and nonmonomial target units. Under those same premises, the 120-call standalone bound and its previously sealed signed-profile stop survive this scalar extension. This does not establish an incremental charge at an actual parent cut, reject cached/paid side information, or generalize the 112-fanout source classification. + +This review used written mathematics and source-text/hash inspection only. No mathematical checker, source evaluator, scientific engine, group/rank/tableau/phase classifier, native program, price/Powers/log/exp routine, solver, emitter, Lean, publication, feed or new agent was executed. Only this independent-review directory was written. The original theorem, scalar clarification and proposed lemma remain unchanged. + +## Exact statement accepted + +The reviewed file is `outputs/coded-canonical-conversion-ceiling-20261024/central-scalar-extension/PROPOSED-LEMMA-v1.md`. Its hypotheses require: + +- Fixed nonzero finite-dimensional one-column V over K and fixed finite ordinary group G. The source may enlarge G to all computational-basis monomials with fourth-root entries. +- One fixed finite exact linear straight-line word at a fixed whole-field capacity. Its coefficients, scalar exponents, field owners, scratch count and paid one-column operators do not vary with f. +- Ordinary columnwise G lifts, ADD/COPY/CLEAR, and exterior `c*2^(n f)` operations. Each instruction has fixed c and fixed integer n; finite sums arise through the finite word. +- Exact endpoints on arbitrary independent initial whole fields at every positive width, or at every width in a consecutive infinite tail. A common prescribed layout conjugation may be removed. +- One transformed actual whole-field output row per charged paid call. Later inputs may depend on earlier responses; a paid operator need not commute with G. +- k required outputs `h_i^(tensor f) w_vi`, with distinct independent input coordinates vi and invertible h_i **outside** `O=<2I>G`. Ordinary initial backgrounds may be subtracted conceptually. Initial accessible history contains no free correlated nonordinary observations. + +Nonzero V is the source case (dimension2^625, not625). For a zero-dimensional V no nonordinary target satisfying these assumptions exists; it supplies no counterexample to the positive-k application. + +## 1. Central scalar representation and phases + +Let sigma=2I and S=. Since K has characteristic zero and V is nonzero, sigma has infinite order. If sigma^n belongs to finite G, a finite order d gives2^(nd)=1, forcing n=0. Thus S intersects G trivially and the ordinary matrix subgroup is the internal direct product S×G. + +This establishes the faithful central inclusion `Lambda=K[tau,tau^-1] -> A0=K[Gamma]`, with tau mapped to the group-basis element [sigma]. The representation `R=K[SG]=Lambda[G]` is valid: every sigma^n g has a unique pair of indices. Gamma may be infinite and may contain paid/target operators and inverses solely as formal units; their presence does not grant any uncharged implementation. + +The scalar and phase distinctions are correct. [sigma] evaluates at width f as2^f I, whereas the exterior coefficient2[I] evaluates as2I. Likewise [iI] evaluates as i^f I, whereas exterior i[I] evaluates as iI. Finite-order phase elements in G do not intersect the infinite scalar subgroup S. No projective identification or width-one matrix relation is being substituted into the group algebra. + +## 2. All-width faithfulness is used at the right stage + +A fixed finite word expands into finitely supported rows in A0^N after its finitely many Laurent coefficients are expanded. The remaining exterior coefficients are constants in K, independent of f. Negative scalar exponents, feedback, overwrite and CLEAR do not change that finite-support fact. + +For finitely many distinct actual invertible matrices a_j, an infinite-field argument supplies a K-linear functional ell with nonzero pairwise distinct values lambda_j=ell(a_j): only finitely many proper hyperplanes are forbidden. Finite-dimensionality gives the natural tensor identification needed to apply ell tensor-powered f to the operator identities. Consecutive widths f0,...,f0+s−1 then produce a Vandermonde determinant + +``` +(product lambda_j^f0) * product_(a