diff --git a/research/resonant-oblique-section/INDEPENDENT.json b/research/resonant-oblique-section/INDEPENDENT.json new file mode 100644 index 0000000000..327dafd1e4 --- /dev/null +++ b/research/resonant-oblique-section/INDEPENDENT.json @@ -0,0 +1,24 @@ +{ + "decoder_terms": 1920, + "full_width_two_columns": 64, + "independent_representation": "packed column action; literal Gaussian integer tensors", + "nonhermitian_witness": { + "E_entry": [ + "1/2", + "0" + ], + "E_transposed_entry": [ + "0", + "0" + ], + "column": 0, + "row": 9 + }, + "odd_literal_widths": [ + 1, + 3 + ], + "quarter_phase_mutation_rejected": true, + "status": "PASS_INDEPENDENT_OBLIQUE_TENSORS", + "width_four_dirty_coordinates": 4096 +} diff --git a/research/resonant-oblique-section/PROOF.md b/research/resonant-oblique-section/PROOF.md new file mode 100644 index 0000000000..7f4d9f5ca4 --- /dev/null +++ b/research/resonant-oblique-section/PROOF.md @@ -0,0 +1,156 @@ +# A uniform dyadic section with a changed output contract + +Let A be exactly the 256-term target coefficient in JoyboyBrian's PR #4797, +with each actual monomial evaluated columnwise as g_f = g tensor ... tensor g. +Scalar coefficients are retained outside this tensor power. All fourth-root +phases, including the actual central word iI, are retained. + +## Theorem + +The 30-term signed-double-coset recipe in SECTION.json emits a fixed sum B +of 1,920 free monomials with coefficients in (1/2048) Z. For every positive +integer f, + + A_f B_f A_f = A_f, ||B_f||_2 <= 113/32. + +Consequently E_f = B_f A_f is an idempotent with exactly the kernel of A_f. +It retains all information in the source channel: A_f x = A_f y if and only +if E_f x = E_f y. For every attainable observation z, B_f z is a representative +with A_f(B_f z)=z. The original observation can remain intact. + +E is not required to be the orthogonal projection. The literal width-two +oracle supplies a non-Hermitian entry witness. Thus this changes the output +contract of PR #4980; it does not contradict that theorem's necessary primes +3,5,7 for the canonical orthogonal input projection. No choice of independent +canonical Gaussian jobs, complete target, or paid saving follows from a section. + +## Exact finite certificate + +The actual source has equal coefficients on g and (-I)g. This is checked for +every source term. Therefore A_f=0 at odd f. For even f, work in the finite +monomial algebra quotient by precisely [-I]=[I]. Normalization subtracts either +zero or two from all eight phase exponents so that the first is zero or one. +It does not discard iI. Multiplication is actual monomial composition followed +by this normalization, so it is associative and respects all even evaluations. + +In this quotient the paired coefficients of A are +/-1/8. Let a be the +lexicographically first quotient monomial, explicitly retained as the recipe +anchor. Define C = 8 a^-1 A. C has 128 distinct coefficients +/-1. + +The verifier derives the full signed left and right stabilizers of C: + + L = {(l,s): l C=s C}, R = {(r,t): C r=t C}, + +where s,t are +/-1. Their sizes are 32 and 16. This computation is complete: +if c0 is any support word, a stabilizer must send c0 to another support word, +so its candidate lies in support(C) c0^-1 on the left, or c0^-1 support(C) +on the right. Every candidate is tested against the entire coefficient table. + +For a recipe representative g, form + + T_g = sum_(r,t in R; l,s in L) t s [r g l]. + +Equal words are collected. The certificate checks that their nonzero absolute +multiplicities are one common positive integer m_g. Put U_g=T_g/m_g; U_g +has coefficients +/-1. With the 30 integer numerators n_g in SECTION.json, set + + D = (1/16384) sum_g n_g U_g. + +The emitted D has 1,920 terms, numerators bounded by eight, and the verifier +checks the complete integer identity + + C (16384 D) C = 16384 C. + +Both convolutions are coefficientwise, with no modular rank, floating point, +sampled tensor width or discovery solver in this certificate. The intermediate +table (16384 D)C has 5,408 terms; the final table has exactly the 128 prescribed +terms and their prescribed integer coefficients. It follows that C D C=C. + +Define the actual decoder B=8 D a^-1. It follows, in the stated order, that + + A B A = (a C/8) (8 D a^-1) (a C/8) + = a C D C /8 = a C/8 = A. + +Every emitted monomial is independently checked to have invertible affine +binary permutation and a mod-four phase polynomial of degree at most two, +with even quadratic terms. This is the constructive free alphabet used by +the source: affine address maps, coordinate S phases and conjugate parity-S +implement the even quadratic terms. No general monomial is silently granted +free. The even evaluation homomorphism proves the identity at every even f. +At odd f it holds because A_f=0, irrespective of the chosen lifts of B. + +Since B's 1,920 reduced coefficients have common denominator 2048 and integer +numerators with absolute sum 7,232, their l1 norm is 7,232/2048=113/32. +Each g_f is unitary, proving the uniform bound. Finally E^2=B(ABA)=BA=E. +If A x=0 then E x=0; if E x=0 then A x=A E x=0. These implications give +the kernel equality and exact information equivalence without a rank formula. + +## Independent literal checks + +independent_tensor.py uses packed column actions, independently reconstructs +the signed stabilizers and recipe, and applies the resulting actual words +without a sign quotient when evaluating tensors. It checks every one of the +64 width-two input columns of ABA=A and E^2=E, and a non-Hermitian entry of E. +It verifies literal cancellation at odd widths one and three. A dense dirty +Gaussian-integer input of length 4,096 checks the actual width-four ABA identity. +These are independent implementation checks, not the universal proof: the +full finite-algebra identity above is the reason the result holds at all widths. + +## Arithmetic and complete obligation ledger + +For N=8^f components the displayed decoder uses 1,920 monomial applications +and at most 1,920 scaled accumulation passes in the inherited linear-array +interface. Every coefficient is an integer of absolute value at most eight, +divided by 2048. Its integer numerator needs at most two additions/subtractions +and three fixed shifts; its denominator is an exact eleven-bit dyadic shift. +Retain one read-only observation array and use one owned zero accumulator and +one owned temporary monomial array; initializations and erasures are real +linear scans. This is an explicit logical buffer plan, not a physical tape +compiler or a claim that source address applications have unit physical cost. + +If real and imaginary parts of the input lie in 2^-P Z and are bounded by M, +every term and every partial sum can be kept exactly in 2^-(P+11) Z. +Every emitted scalar has only one nonzero real or imaginary part; hence the +same bound 113 M/32 < 4M applies componentwise to partial sums. Two extra +integer magnitude bits suffice, apart from the chosen sign representation. +The input lattice widening and integer growth are independent of f. Stored +input errors bounded componentwise by epsilon are amplified by at most +113 epsilon/32 in each real/imaginary component. No rounding need occur +inside the decoder at the stated widened grid. + +| Obligation | Status | +|---|---| +| Exact fixed-word section, all tensor widths, all phases | Proved by full coefficient identity | +| Same accessible information, changed oblique representative | Proved by kernel equality | +| Extra paid Gaussian children in this formal linear decoder | Zero | +| Dyadic scalars, 1,920 logical monomial/accumulation passes | Constructively bounded | +| Exact input/output grid, uniform magnitude and error factors | Proved above | +| Logical read-only input plus two owned buffers; initialize/erase scans | Constructively specified | +| Legal physical reads, routing, tape head motion, precise time invoice | Unknown | +| Returning arbitrary original owners in a completed paid producer/consumer | Unknown | +| Encoding useful canonical independent Gaussian jobs in this image | Unknown | +| Missing complementary target coordinates and eventual buffer funding | Unknown | +| Source-uniform native compiler, stock, outer contracts and new kappa | Unknown | + +The opportunity is removal of odd scalar divisions from this changed recovery +module. Its 1,920 passes may be too expensive in a completed consumer. This +does not justify a downstream optimization campaign while that consumer and +complete invoice remain missing. The family decision is NARROW to this section. + +## Discovery and credit + +Discovery used the signed-stabilizer double-coset corner of the finite even +group: 164 nonzero source-corner basis elements and an exact linear system of +rank 51. Rational elimination gave the 30 dyadic recipe coefficients. The +discovery system is not needed or trusted by replay; the final integer identity +directly certifies the resulting section. No random seed or rank extrapolation +is a premise. Nick Petalas's PR #4825 dyadic width-four minor was an existing +positive control, not a new contribution of this package. + +Credit JoyboyBrian #4797 for the resonant channel, Dugongue #4885 for its +all-width rank/projector and explicit rational recovery, JoyboyBrian #4980 for +the orthogonal scalar criterion and explicit oblique open question; retain +Yiyang/Lyy-iiis #4710, lee-phys #4688, Jacob Alan Sussman #4628 with eumemic +and Swapnil Jain and the source lineage. Prepared for JoyboyBrian with substantial +OpenAI Codex assistance. Exact automatic checks are not independent human or +proof-assistant acceptance. Apache-2.0. diff --git a/research/resonant-oblique-section/README.md b/research/resonant-oblique-section/README.md new file mode 100644 index 0000000000..2d99953f24 --- /dev/null +++ b/research/resonant-oblique-section/README.md @@ -0,0 +1,90 @@ +# A dyadic oblique section for the resonant channel + +The frozen resonant coefficient A from [PR #4797](https://github.com/CrocSwap/integer-mult-bounds/pull/4797) +has a fixed dyadic decoder B with **A_f B_f A_f=A_f at every positive tensor +width**. It uses 1,920 free monomials, denominator 2048 and a uniform operator +norm upper bound 113/32. No odd scalar division is required in this module. + +Given a channel observation z, B_f z is an exact representative of its input +coset. The idempotent E_f=B_f A_f has exactly the kernel of A_f, so the changed +representative retains all accessible information. It is genuinely oblique: +at width two E(9,0)=1/2 while E(0,9)=0. It is not the canonical orthogonal +projection whose recovery requires primes 3,5,7 in [PR #4980](https://github.com/CrocSwap/integer-mult-bounds/pull/4980). +That output contract is essential to the predecessor theorem; the new section +answers its explicit oblique-recovery question without contradicting it. + +This is an exact linear interface result, not a complete consumer, restored +paid supplier, call saving or new kappa. The 1,920 passes may be unaffordable +in a complete consumer. No selected record or frozen predecessor is modified. + +## Certificate and reproduction + +[PROOF.md](PROOF.md) derives the result from a finite integer identity. +[SECTION.json](SECTION.json) has 30 signed-double-coset recipe terms. +The checker reconstructs the 128-term even target quotient, its signed +stabilizers (sizes 32 and 16), and the 1,920-term section. It checks the entire +coefficient table of C D C=C, with A=a C/8 and B=8 D a^-1. Actual central +quarter phases are retained; only [-I]=[I] is used at even widths. The source +itself proves odd-width cancellation. All output words are checked against +the source's affine/quadratic free alphabet. + +From the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/resonant-oblique-section +python3.12 -B scripts/check_research_commit.py --package research/resonant-oblique-section --check-source-history +``` + +Direct normal and optimized replay use `verify.py` and +`independent_tensor.py` in this package. The latter uses a separate packed +column-action engine: all 64 width-two columns, a non-Hermitian projection +witness, literal odd-width cancellation and a 4,096-coordinate width-four +Gaussian-integer dirty input. It rejects loss of actual central quarter phases. Explicit +checks reject a changed section coefficient, a wrong denominator, loss of the +central quarter phase and an inadmissible cubic phase. These are deterministic +exact checks with no solver, network, dependency, Lean or Docker requirement. + +The logical decoder retains its observation and uses an owned accumulator and +one owned monomial temporary. Initialization and erasure scans are required. +It has 1,920 logical monomial/accumulation passes; every scalar is dyadic with +eleven extra fractional bits and at most two extra integer magnitude bits. +The full physical read/routing/tape cost remains unknown. The complete +[obligation ledger](PROOF.md#arithmetic-and-complete-obligation-ledger) marks +the missing canonical jobs, complement, original-owner restoration, compiler, +stock and outer costs explicitly. Unknown costs are not zero. + +## Open next questions + +1. Can a chronological complete consumer use these changed representatives + to encode named independent Gaussian jobs? First bind a canonical encoder, + the missing target complement, arbitrary owners and the eventual restored + outputs. No useful paid moment is inferred from image rank or this section. +2. Does the resulting completed consumer afford all 1,920 monomial passes, + dyadic arithmetic, two owned buffers, legal reads, routing, initialization, + erasure, precision, compiler and outer reserve? Price that complete invoice + before extending the mechanism or optimizing the section. + +The family decision is **NARROW** to this changed output contract. It removes +odd division from one explicit formal module. A missing physical consumer is +not an invitation to treat its cost as zero or to launch a chain of local +optimizations. + +## Sources and credit + +Scientific base: canonical main `bee95ce88f9f19802f0613f92838895cd0e14a1f`, +priority revision 7. The source TARGET is byte-pinned by SHA256 and Git blob in +[SOURCES.json](SOURCES.json). The selected result remains conditional +kappa 0.00302015. Overlap at 06:08 UTC covered 310 open PRs (06:05:59), +4,096 Discussion records (06:06:48), and all 6,690 tracked local notes. +The oblique match was the predecessor's explicit open question. No novelty +guarantee follows; arbitrary diffs and unpublished work are outside coverage. + +Credit JoyboyBrian #4797 for the channel; Dugongue #4885 for all-width rank, +orthogonal projection and rational recovery; JoyboyBrian #4980 for the scalar +criterion and oblique open question; Nick Petalas #4825 for the existing +width-four dyadic minor. Retain Yiyang/Lyy-iiis #4710, lee-phys #4688, +Jacob Alan Sussman #4628 with eumemic and Swapnil Jain and the source lineage. +Signed stabilizer averaging, generalized inverses and oblique projections are +standard algebra; no literature-priority claim is made. Prepared for +JoyboyBrian with substantial OpenAI Codex assistance. Exact automated checks +are not independent human or proof-assistant acceptance. Apache-2.0. diff --git a/research/resonant-oblique-section/RESULT.json b/research/resonant-oblique-section/RESULT.json new file mode 100644 index 0000000000..a8b71e1636 --- /dev/null +++ b/research/resonant-oblique-section/RESULT.json @@ -0,0 +1,43 @@ +{ + "D_denominator": 16384, + "actual_target_terms": 256, + "complete_supplier": false, + "controls": [ + "changed_section_coefficient", + "changed_denominator", + "retain_quarter_phase", + "reject_nonfree_cubic_phase", + "reject_boolean_address" + ], + "decoder_common_denominator": 2048, + "decoder_norm_upper_bound": "113/32", + "decoder_numerator_histogram": { + "-1": 32, + "-2": 256, + "-3": 128, + "-4": 352, + "-5": 32, + "-6": 64, + "-7": 32, + "-8": 64, + "1": 32, + "2": 256, + "3": 128, + "4": 352, + "5": 32, + "6": 64, + "7": 32, + "8": 64 + }, + "decoder_terms": 1920, + "even_target_terms": 128, + "identity": "A_f B_f A_f = A_f for every positive integer f", + "left_signed_stabilizer": 32, + "new_kappa": false, + "nonzero_corner_terms": 30, + "oblique_projector_terms": 5408, + "operator_claim": "B_f A_f is idempotent with kernel equal to kernel(A_f)", + "right_signed_stabilizer": 16, + "source_sha256": "e7df852b5c641f326ac67cd35cea8da6cfdd059fa12df1cf6fb758bb4206d684", + "status": "PASS_RESONANT_OBLIQUE_SECTION" +} diff --git a/research/resonant-oblique-section/SECTION.json b/research/resonant-oblique-section/SECTION.json new file mode 100644 index 0000000000..3c8f5b6905 --- /dev/null +++ b/research/resonant-oblique-section/SECTION.json @@ -0,0 +1,718 @@ +{ + "D_denominator": 16384, + "anchor": { + "permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "phase_i": [ + 1, + 1, + 1, + 1, + 1, + 3, + 1, + 3 + ] + }, + "corners": [ + { + "numerator": 2, + "permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "phase_i": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "numerator": -3, + "permutation": [ + 0, + 1, + 2, + 3, + 5, + 4, + 7, + 6 + ], + "phase_i": [ + 0, + 0, + 0, + 0, + 1, + 3, + 3, + 1 + ] + }, + { + "numerator": 3, + "permutation": [ + 0, + 1, + 3, + 2, + 5, + 4, + 6, + 7 + ], + "phase_i": [ + 0, + 0, + 1, + 3, + 1, + 3, + 0, + 0 + ] + }, + { + "numerator": -4, + "permutation": [ + 0, + 1, + 3, + 2, + 6, + 7, + 5, + 4 + ], + "phase_i": [ + 0, + 0, + 1, + 3, + 1, + 3, + 0, + 0 + ] + }, + { + "numerator": 4, + "permutation": [ + 0, + 1, + 4, + 5, + 6, + 7, + 2, + 3 + ], + "phase_i": [ + 0, + 0, + 0, + 0, + 1, + 3, + 3, + 1 + ] + }, + { + "numerator": -3, + "permutation": [ + 0, + 1, + 6, + 7, + 2, + 3, + 4, + 5 + ], + "phase_i": [ + 0, + 0, + 1, + 3, + 0, + 0, + 3, + 1 + ] + }, + { + "numerator": -4, + "permutation": [ + 0, + 1, + 6, + 7, + 5, + 4, + 3, + 2 + ], + "phase_i": [ + 0, + 0, + 1, + 3, + 1, + 3, + 0, + 0 + ] + }, + { + "numerator": -2, + "permutation": [ + 0, + 1, + 7, + 6, + 4, + 5, + 3, + 2 + ], + "phase_i": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "numerator": 2, + "permutation": [ + 0, + 2, + 1, + 3, + 4, + 6, + 5, + 7 + ], + "phase_i": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "numerator": 4, + "permutation": [ + 0, + 2, + 1, + 3, + 5, + 7, + 4, + 6 + ], + "phase_i": [ + 0, + 0, + 0, + 0, + 1, + 3, + 3, + 1 + ] + }, + { + "numerator": 4, + "permutation": [ + 0, + 2, + 3, + 1, + 4, + 6, + 7, + 5 + ], + "phase_i": [ + 0, + 0, + 1, + 3, + 0, + 0, + 3, + 1 + ] + }, + { + "numerator": -2, + "permutation": [ + 0, + 2, + 3, + 1, + 5, + 7, + 6, + 4 + ], + "phase_i": [ + 0, + 0, + 1, + 3, + 1, + 3, + 0, + 0 + ] + }, + { + "numerator": -8, + "permutation": [ + 0, + 2, + 4, + 6, + 1, + 3, + 5, + 7 + ], + "phase_i": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "numerator": 2, + "permutation": [ + 0, + 2, + 4, + 6, + 3, + 1, + 7, + 5 + ], + "phase_i": [ + 0, + 0, + 0, + 0, + 1, + 3, + 3, + 1 + ] + }, + { + "numerator": 6, + "permutation": [ + 0, + 2, + 4, + 6, + 5, + 7, + 1, + 3 + ], + "phase_i": [ + 0, + 0, + 0, + 0, + 1, + 3, + 3, + 1 + ] + }, + { + "numerator": 2, + "permutation": [ + 0, + 2, + 5, + 7, + 3, + 1, + 6, + 4 + ], + "phase_i": [ + 0, + 0, + 1, + 3, + 1, + 3, + 0, + 0 + ] + }, + { + "numerator": 4, + "permutation": [ + 0, + 2, + 5, + 7, + 4, + 6, + 1, + 3 + ], + "phase_i": [ + 0, + 0, + 1, + 3, + 0, + 0, + 3, + 1 + ] + }, + { + "numerator": 2, + "permutation": [ + 0, + 2, + 5, + 7, + 6, + 4, + 3, + 1 + ], + "phase_i": [ + 0, + 0, + 1, + 3, + 1, + 3, + 0, + 0 + ] + }, + { + "numerator": 3, + "permutation": [ + 0, + 3, + 1, + 2, + 4, + 7, + 5, + 6 + ], + "phase_i": [ + 0, + 1, + 0, + 3, + 0, + 3, + 0, + 1 + ] + }, + { + "numerator": 2, + "permutation": [ + 0, + 3, + 1, + 2, + 7, + 4, + 6, + 5 + ], + "phase_i": [ + 0, + 1, + 0, + 3, + 0, + 3, + 0, + 1 + ] + }, + { + "numerator": -7, + "permutation": [ + 0, + 3, + 2, + 1, + 4, + 7, + 6, + 5 + ], + "phase_i": [ + 0, + 1, + 0, + 3, + 0, + 3, + 0, + 1 + ] + }, + { + "numerator": -4, + "permutation": [ + 0, + 3, + 4, + 7, + 2, + 1, + 6, + 5 + ], + "phase_i": [ + 0, + 1, + 0, + 3, + 0, + 3, + 0, + 1 + ] + }, + { + "numerator": 1, + "permutation": [ + 0, + 3, + 5, + 6, + 4, + 7, + 1, + 2 + ], + "phase_i": [ + 0, + 1, + 1, + 0, + 0, + 3, + 3, + 0 + ] + }, + { + "numerator": -6, + "permutation": [ + 0, + 3, + 5, + 6, + 7, + 4, + 2, + 1 + ], + "phase_i": [ + 0, + 1, + 1, + 0, + 0, + 3, + 3, + 0 + ] + }, + { + "numerator": -5, + "permutation": [ + 0, + 3, + 6, + 5, + 4, + 7, + 2, + 1 + ], + "phase_i": [ + 0, + 1, + 1, + 0, + 0, + 3, + 3, + 0 + ] + }, + { + "numerator": 8, + "permutation": [ + 0, + 4, + 1, + 5, + 2, + 6, + 3, + 7 + ], + "phase_i": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "numerator": -4, + "permutation": [ + 0, + 4, + 1, + 5, + 3, + 7, + 2, + 6 + ], + "phase_i": [ + 0, + 0, + 0, + 0, + 1, + 3, + 3, + 1 + ] + }, + { + "numerator": -4, + "permutation": [ + 0, + 4, + 2, + 6, + 5, + 1, + 7, + 3 + ], + "phase_i": [ + 0, + 0, + 0, + 0, + 1, + 3, + 3, + 1 + ] + }, + { + "numerator": -4, + "permutation": [ + 0, + 4, + 3, + 7, + 1, + 5, + 2, + 6 + ], + "phase_i": [ + 0, + 0, + 1, + 3, + 0, + 0, + 3, + 1 + ] + }, + { + "numerator": -4, + "permutation": [ + 0, + 4, + 5, + 1, + 7, + 3, + 2, + 6 + ], + "phase_i": [ + 0, + 0, + 1, + 3, + 0, + 0, + 3, + 1 + ] + } + ], + "schema_version": 1 +} diff --git a/research/resonant-oblique-section/SOURCES.json b/research/resonant-oblique-section/SOURCES.json new file mode 100644 index 0000000000..5a105fbf4b --- /dev/null +++ b/research/resonant-oblique-section/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "bee95ce88f9f19802f0613f92838895cd0e14a1f", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/resonant-all-width-projector/TARGET.json", + "usage": "input", + "git_blob": "e40739b7d5fb91c1a0473b6bb5b3f449fc9d60ae", + "sha256": "e7df852b5c641f326ac67cd35cea8da6cfdd059fa12df1cf6fb758bb4206d684" + }, + { + "path": "research/resonant-recovery-scalars/README.md", + "usage": "provenance", + "git_blob": "9ddb799d470cd7069b72bfc9bc28517c263403d0", + "sha256": "5f9ce10be3c297d32dee3ebcb40c946fb01f531623d8cfcd3b4738ef29bf1a94" + } + ] +} diff --git a/research/resonant-oblique-section/TASK.json b/research/resonant-oblique-section/TASK.json new file mode 100644 index 0000000000..e535d76b6f --- /dev/null +++ b/research/resonant-oblique-section/TASK.json @@ -0,0 +1,72 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 7, + "base_commit": "bee95ce88f9f19802f0613f92838895cd0e14a1f", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "changed", + "actual_scope": "Construct a uniform dyadic oblique exact section of the frozen resonant channel, changing the canonical orthogonal output contract.", + "scope_change_reason": "PR4980 leaves oblique accessible-coordinate recovery open. The new explicit output representative may avoid its odd scalar primes without repeating the known rank theorem or claiming a complete supplier.", + "bottleneck_link": "Removes odd division from an explicit information-preserving linear recovery module; a complete chronological Gaussian consumer and its physical invoice remain unknown.", + "budget_minutes": 60, + "stop_rule": "Stop at one fully checked all-width section ABA=A or a precise obstruction. No additional tensor-rank census or downstream optimization campaign. Reserve the final quarter for independent review and committed cold replay.", + "outcome": "completed", + "evidence": "PROOF.md and verify.py reconstruct the signed-stabilizer recipe and certify the full integer convolution identity. The emitted 1920-term decoder is dyadic and uniformly bounded by113/32. Source and mathematical failure controls are explicit. A separate packed monomial engine checks all64 literalwidth2 columns, nonHermitian output, actualwidth4 dirty inputs, oddwidth cancellation and centralphase loss. Typed address and receipt boundaries reject bool/int conflation.", + "author": "JoyboyBrian", + "ai_assistance": "Substantial OpenAI Codex assistance for exact algebra, implementation, proof and source review. No independent human or proof-assistant acceptance claimed.", + "open_questions": [ + { + "question": "Can a complete chronological consumer encode named independent Gaussian jobs using the oblique representatives?", + "why_it_matters": "A section preserves accessible information but does not supply missing independent coordinates or a useful paid supplier.", + "first_step": "Specify one canonical encoder and all original owners, complement, outputs and eventual restoration.", + "blocked_by": "No complete canonical consumer or paid moment is provided." + }, + { + "question": "Can that complete consumer afford all decoder, storage and physical costs?", + "why_it_matters": "The1920 monomial passes and logical buffer plan are not free physical operations.", + "first_step": "Price legal reads, routing, initialization, erasure, all dyadic passes, precision, stock, native compiler and outer reserve.", + "blocked_by": "Physical caller and complete supplier invoice remain unknown." + } + ] +} diff --git a/research/resonant-oblique-section/VERIFY.json b/research/resonant-oblique-section/VERIFY.json new file mode 100644 index 0000000000..0ad89b63a3 --- /dev/null +++ b/research/resonant-oblique-section/VERIFY.json @@ -0,0 +1,53 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/resonant-all-width-projector/TARGET.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Full finite group-algebra dyadic section, free alphabet, uniform norm and semantic failure controls" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Same exact identity with assertions disabled" + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/independent_tensor.py" + ], + "timeout_seconds": 90, + "checks": "Independent actual tensor columns, oblique witness, absolute phases and dirty width-four section" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/independent_tensor.py" + ], + "timeout_seconds": 90, + "checks": "Independent actual tensor columns, oblique witness, absolute phases and dirty width-four section optimized" + } + ] +} diff --git a/research/resonant-oblique-section/independent_tensor.py b/research/resonant-oblique-section/independent_tensor.py new file mode 100644 index 0000000000..1cdc9a9483 --- /dev/null +++ b/research/resonant-oblique-section/independent_tensor.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python3 +"""Literal tensor oracle, using a separate packed monomial implementation.""" +import argparse +from collections import defaultdict +from fractions import Fraction +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +SOURCE = HERE.parent.parent / 'research/resonant-all-width-projector/TARGET.json' +PIN = 'e7df852b5c641f326ac67cd35cea8da6cfdd059fa12df1cf6fb758bb4206d684' +UNITS = ((1, 0), (0, 1), (-1, 0), (0, -1)) + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def compose(left, right): + return tuple((left[v % 8] % 8) + 8 * ((v // 8 + left[v % 8] // 8) % 4) for v in right) + + +def invert(g): + result = [0] * 8 + for j, v in enumerate(g): + result[v % 8] = j + 8 * ((-(v // 8)) % 4) + return tuple(result) + + +def signs(g): + return tuple(v ^ 16 for v in g) if g[0] >= 16 else g + + +def word(record): + return tuple(p + 8 * q for p, q in zip(record['permutation'], record['phase_i'])) + + +def decoder(records, recipe): + anchor = word(recipe['anchor']) + c = defaultdict(int) + for record in records: + c[signs(compose(invert(anchor), word(record)))] += 1 if record['coefficient'] == '1/16' else -1 + require(set(c.values()) == {-2, 2}, 'source quotient coefficient') + c = {g: v // 2 for g, v in c.items()} + first = next(iter(c)) + stabs = [] + for left in (True, False): + out = [] + candidates = {signs(compose(g, invert(first)) if left else compose(invert(first), g)) for g in c} + for h in candidates: + translated = {signs(compose(h, g) if left else compose(g, h)): v for g, v in c.items()} + if translated == c: + out.append((h, 1)) + elif translated == {g: -v for g, v in c.items()}: + out.append((h, -1)) + stabs.append(out) + require(tuple(map(len, stabs)) == (32, 16), 'independent signed stabilizers') + out = defaultdict(int) + for record in recipe['corners']: + g = word(record) + orbit = defaultdict(int) + for r, x in stabs[1]: + for l, y in stabs[0]: + orbit[signs(compose(compose(r, g), l))] += x * y + scale = abs(next(iter(orbit.values()))) + require(scale and all(abs(v) == scale for v in orbit.values()), 'signed orbit multiplicity') + for h, value in orbit.items(): + out[signs(compose(h, invert(anchor)))] += record['numerator'] * value // scale + return {g: v for g, v in out.items() if v} + + +def plus(a, b): + return a[0] + b[0], a[1] + b[1] + + +def product(a, b): + return a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0] + + +def literal_matrix(terms, width): + matrix = {} + for j in range(8 ** width): + digits = [(j >> (3 * h)) & 7 for h in range(width)] + column = defaultdict(lambda: (0, 0)) + for g, value in terms.items(): + k = sum((g[d] % 8) << (3 * h) for h, d in enumerate(digits)) + phase = sum(g[d] // 8 for d in digits) % 4 + u = UNITS[phase] + column[k] = plus(column[k], (value * u[0], value * u[1])) + for k, value in column.items(): + if value != (0, 0): + matrix[k, j] = value + return matrix + + +def matrix_product(a, b): + columns = defaultdict(list) + for (i, j), value in a.items(): + columns[j].append((i, value)) + out = defaultdict(lambda: (0, 0)) + for (k, j), value in b.items(): + for i, coefficient in columns[k]: + out[i, j] = plus(out[i, j], product(coefficient, value)) + return {k: v for k, v in out.items() if v != (0, 0)} + + +def scale(matrix, value): + return {k: (a * value, b * value) for k, (a, b) in matrix.items()} + + +def apply_literal(terms, width, data): + out = [(0, 0)] * len(data) + for j, value in enumerate(data): + digits = [(j >> (3 * h)) & 7 for h in range(width)] + for g, coefficient in terms.items(): + k = sum((g[d] % 8) << (3 * h) for h, d in enumerate(digits)) + phase = sum(g[d] // 8 for d in digits) % 4 + term = product(UNITS[phase], value) + out[k] = plus(out[k], (coefficient * term[0], coefficient * term[1])) + return out + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + args = parser.parse_args() + raw = SOURCE.read_bytes() + require(hashlib.sha256(raw).hexdigest() == PIN, 'independent source hash') + records = json.loads(raw) + recipe = json.loads((HERE / 'SECTION.json').read_text()) + require(recipe['D_denominator'] == 16384, 'independent denominator') + a = {word(r): 1 if r['coefficient'] == '1/16' else -1 for r in records} + b = decoder(records, recipe) + require(len(b) == 1920, 'independent decoder term count') + m = literal_matrix(a, 2) + n = literal_matrix(b, 2) + mn = matrix_product(m, n) + nm = matrix_product(n, m) + require(matrix_product(mn, m) == scale(m, 32768), 'all 64 columns of A2 B2 A2') + require(matrix_product(nm, nm) == scale(nm, 32768), 'all 64 columns of E2 squared') + nonhermitian = [(i, j) for (i, j), (x, y) in nm.items() + if nm.get((j, i), (0, 0)) != (x, -y)] + require(bool(nonhermitian), 'the section must be genuinely oblique') + i, j = min(nonhermitian) + witness = {'row': i, 'column': j, + 'E_entry': [str(Fraction(v, 32768)) for v in nm.get((i, j), (0, 0))], + 'E_transposed_entry': [str(Fraction(v, 32768)) for v in nm.get((j, i), (0, 0))]} + require(not literal_matrix(a, 1) and not literal_matrix(a, 3), 'literal odd-width cancellation') + collapsed = {} + for g, value in a.items(): + h = tuple((v % 8) + 8 * ((v // 8 - g[0] // 8) % 4) for v in g) + collapsed[h] = collapsed.get(h, 0) + value + require(literal_matrix(collapsed, 2) != m, 'quarter-phase loss must alter actual tensor action') + dirty = [(j % 11 - 5, (7 * j) % 13 - 6) for j in range(4096)] + z = apply_literal(a, 4, dirty) + y = apply_literal(b, 4, z) + returned = apply_literal(a, 4, y) + require(returned == [(32768 * x, 32768 * y) for x, y in z], 'actual width-four dirty ABA') + result = {'status': 'PASS_INDEPENDENT_OBLIQUE_TENSORS', 'full_width_two_columns': 64, + 'odd_literal_widths': [1, 3], 'width_four_dirty_coordinates': 4096, + 'decoder_terms': len(b), 'quarter_phase_mutation_rejected': True, 'nonhermitian_witness': witness, + 'independent_representation': 'packed column action; literal Gaussian integer tensors'} + expected = HERE / 'INDEPENDENT.json' + if not args.write: + require(json.dumps(json.loads(expected.read_text()), sort_keys=True) == json.dumps(result, sort_keys=True), 'typed independent receipt') + else: + expected.write_text(json.dumps(result, sort_keys=True, indent=2) + '\n') + print(result['status']) + + +if __name__ == '__main__': + main() diff --git a/research/resonant-oblique-section/verify.py b/research/resonant-oblique-section/verify.py new file mode 100644 index 0000000000..7bce40de87 --- /dev/null +++ b/research/resonant-oblique-section/verify.py @@ -0,0 +1,197 @@ +#!/usr/bin/env python3 +"""Exact dyadic oblique section of the frozen resonant channel.""" +import argparse +from collections import Counter, defaultdict +from fractions import Fraction +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent +SOURCE = 'research/resonant-all-width-projector/TARGET.json' +PIN = 'e7df852b5c641f326ac67cd35cea8da6cfdd059fa12df1cf6fb758bb4206d684' +IDENTITY = (tuple(range(8)), (0,) * 8) + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def even(word): + p, q = word + shift = 2 * (q[0] // 2) + return p, tuple((x - shift) % 4 for x in q) + + +def multiply(a, b): + p, q = a + r, s = b + return even((tuple(p[j] for j in r), tuple((s[j] + q[r[j]]) % 4 for j in range(8)))) + + +def inverse(a): + p, q = a + r, s = [0] * 8, [0] * 8 + for j, k in enumerate(p): + r[k], s[k] = j, -q[j] % 4 + return even((tuple(r), tuple(s))) + + +def convolution(a, b): + out = defaultdict(int) + for g, x in a.items(): + for h, y in b.items(): + out[multiply(g, h)] += x * y + return {g: x for g, x in out.items() if x} + + +def free_word(word): + p, q = word + if len(p) != 8 or len(q) != 8 or any(type(x) is not int for x in p) or sorted(p) != list(range(8)) or any(type(x) is not int or not 0 <= x < 4 for x in q): + return False + shift = p[0] + columns = [p[1 << k] ^ shift for k in range(3)] + if any(p[j] != shift ^ columns[0] * (j & 1) ^ columns[1] * ((j >> 1) & 1) + ^ columns[2] * ((j >> 2) & 1) for j in range(8)): + return False + coefficients = list(q) + for bit in (1, 2, 4): + for j in range(8): + if j & bit: + coefficients[j] = (coefficients[j] - coefficients[j ^ bit]) % 4 + return coefficients[7] == 0 and all(coefficients[j] % 2 == 0 for j in (3, 5, 6)) + + +def load_channel(): + raw = (ROOT / SOURCE).read_bytes() + need(hashlib.sha256(raw).hexdigest() == PIN, 'source hash mismatch') + records = json.loads(raw) + actual = {} + for record in records: + g = tuple(record['permutation']), tuple(record['phase_i']) + need(g not in actual and free_word(g), 'source free monomial') + need(record['coefficient'] in ('1/16', '-1/16'), 'source scalar') + actual[g] = 1 if record['coefficient'] == '1/16' else -1 + need(len(actual) == 256, 'source support') + # Equal actual signs prove that the channel vanishes at every odd width. + for (p, q), value in actual.items(): + need(actual.get((p, tuple((s + 2) % 4 for s in q))) == value, 'odd cancellation') + quotient = defaultdict(int) + for g, value in actual.items(): + quotient[even(g)] += value + need(len(quotient) == 128 and set(quotient.values()) == {-2, 2}, 'even target quotient') + a = min(quotient) + channel = {multiply(inverse(a), g): value // 2 for g, value in quotient.items()} + need(len(channel) == 128, 'normalized channel support') + return records, a, channel + + +def stabilizer(channel, left): + first = min(channel) + candidates = {multiply(g, inverse(first)) if left else multiply(inverse(first), g) for g in channel} + opposite = {g: -v for g, v in channel.items()} + result = [] + for h in sorted(candidates): + translated = {multiply(h, g) if left else multiply(g, h): v for g, v in channel.items()} + if translated == channel: + result.append((h, 1)) + elif translated == opposite: + result.append((h, -1)) + return result + + +def expand_section(channel, recipe): + left, right = stabilizer(channel, True), stabilizer(channel, False) + need((len(left), len(right)) == (32, 16), 'signed stabilizer sizes') + denominator = recipe['D_denominator'] + need(type(denominator) is int and denominator == 16384, 'section denominator') + need(len(recipe['corners']) == 30, 'corner recipe size') + result = defaultdict(int) + for record in recipe['corners']: + g = tuple(record['permutation']), tuple(record['phase_i']) + value = record['numerator'] + need(type(value) is int and value != 0 and free_word(g) and even(g) == g, 'corner coefficient/word') + orbit = defaultdict(int) + for r, x in right: + rg = multiply(r, g) + for l, y in left: + orbit[multiply(rg, l)] += x * y + multiplicities = set(abs(v) for v in orbit.values()) + need(len(multiplicities) == 1 and 0 not in multiplicities, 'signed corner cancellation') + multiplicity = multiplicities.pop() + for h, v in orbit.items(): + result[h] += value * (v // multiplicity) + result = {g: v for g, v in result.items() if v} + need(all(free_word(g) for g in result), 'emitted monomial outside free alphabet') + return result, denominator + + +def check_identity(channel, section, denominator): + dc = convolution(section, channel) + need(convolution(channel, dc) == {g: denominator * v for g, v in channel.items()}, + 'coefficientwise C D C = C failed') + return dc + + +def reject(call, label): + try: + call() + except ValueError: + return label + raise ValueError('mutation accepted: ' + label) + + +def verify(): + records, a, channel = load_channel() + recipe = json.loads((HERE / 'SECTION.json').read_text()) + anchor = tuple(recipe['anchor']['permutation']), tuple(recipe['anchor']['phase_i']) + need(free_word(anchor) and anchor == a, 'source anchor') + section, denominator = expand_section(channel, recipe) + dc = check_identity(channel, section, denominator) + need(len(section) == 1920 and len(dc) == 5408, 'section/projector support') + b = {multiply(g, inverse(a)): v for g, v in section.items()} + need(len(b) == 1920 and all(free_word(g) for g in b), 'actual decoder words') + need(max(map(abs, b.values())) == 8 and any(abs(v) == 1 for v in b.values()), 'primitive dyadic numerator') + norm = Fraction(sum(map(abs, b.values())), 2048) + need(norm == Fraction(113, 32), 'all-width decoder norm bound') + changed = dict(section) + changed[next(iter(changed))] += 1 + controls = [reject(lambda: check_identity(channel, changed, denominator), 'changed_section_coefficient'), + reject(lambda: check_identity(channel, section, denominator + 1), 'changed_denominator')] + quarter = tuple(range(8)), (1,) * 8 + minus = tuple(range(8)), (2,) * 8 + need(even(quarter) != IDENTITY and even(minus) == IDENTITY, 'central quotient scope') + controls.append('retain_quarter_phase') + need(not free_word((tuple(range(8)), (0, 0, 0, 0, 0, 0, 0, 1))), 'cubic phase rejection') + controls.append('reject_nonfree_cubic_phase') + need(not free_word(((False, 1, 2, 3, 4, 5, 6, 7), (0,) * 8)), 'typed address rejection') + controls.append('reject_boolean_address') + return {'status': 'PASS_RESONANT_OBLIQUE_SECTION', 'source_sha256': PIN, + 'actual_target_terms': len(records), 'even_target_terms': len(channel), + 'left_signed_stabilizer': 32, 'right_signed_stabilizer': 16, + 'nonzero_corner_terms': len(recipe['corners']), 'D_denominator': denominator, + 'decoder_terms': len(b), 'decoder_common_denominator': 2048, + 'decoder_numerator_histogram': {str(k): v for k, v in sorted(Counter(b.values()).items())}, + 'decoder_norm_upper_bound': str(norm), 'oblique_projector_terms': len(dc), + 'identity': 'A_f B_f A_f = A_f for every positive integer f', + 'operator_claim': 'B_f A_f is idempotent with kernel equal to kernel(A_f)', + 'controls': controls, 'new_kappa': False, 'complete_supplier': False} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + args = parser.parse_args() + result = verify() + path = HERE / 'RESULT.json' + if args.write: + path.write_text(json.dumps(result, indent=2, sort_keys=True) + '\n') + else: + need(json.dumps(json.loads(path.read_text()), sort_keys=True) == json.dumps(result, sort_keys=True), 'typed receipt mismatch') + print(result['status']) + + +if __name__ == '__main__': + main()