diff --git a/research/two-capacity-completion-count/.gitattributes b/research/two-capacity-completion-count/.gitattributes new file mode 100644 index 0000000000..8abeb4295b --- /dev/null +++ b/research/two-capacity-completion-count/.gitattributes @@ -0,0 +1 @@ +inputs/** -text diff --git a/research/two-capacity-completion-count/NOTICE b/research/two-capacity-completion-count/NOTICE new file mode 100644 index 0000000000..50762aa4f8 --- /dev/null +++ b/research/two-capacity-completion-count/NOTICE @@ -0,0 +1,4 @@ +New count and checks: Ali Romman with substantial OpenAI Codex assistance. +Apache-2.0. No subagents. +ToikY retains PR6535's quotient theorem. Nick Petalas retains PR6489's nested count. +Read inputs/pr6535-NOTICE and inputs/pr6533-completion.py for full retained credit. diff --git a/research/two-capacity-completion-count/PROOF.md b/research/two-capacity-completion-count/PROOF.md new file mode 100644 index 0000000000..0a835ca8de --- /dev/null +++ b/research/two-capacity-completion-count/PROOF.md @@ -0,0 +1,210 @@ +# Exact finite-field count for two simultaneous capacities + +## Contract and prior theorem + +Let V and W have dimension n over F_q. Let h:U→W be an injection, with +u=dim U and E=h(U). Require an isomorphism g:V→W such that + +`g|U=h`, `g(A)⊂C`, `g(B)⊂D`. + +All inclusions allow equality. A and B need not be nested. C and D need not +be nested. ToikY's PR6535 gives the exact feasibility criterion and its +quotient proof. Nick Petalas's PR6489 gives the prior nested count. +Ali Romman's PR6533 counts arbitrary finite capacity families by an +exponential kernel lattice. Here we count every completion for exactly two +capacities by a sum with at most n+1 terms. These prior results retain credit. + +Set UA=U∩A, UB=U∩B, U0=U∩(A+B), and Z=(E∩C)+(E∩D). First require + +`h(UA)⊂C`, `h(UB)⊂D`, `h(U0)⊂C+D`. + +If any test fails, the count is zero. Define + +| Symbol | Dimension | +| --- | --- | +| a,b | dim A-dim UA, dim B-dim UB | +| s | dim(A+B)-dim U0 | +| c,d | dim C-dim(E∩C), dim D-dim(E∩D) | +| t | dim(C+D)-dim(E∩(C+D)) | +| j | a+b-s | +| tau | c+d-t | +| ell | dim(C∩D)-dim(E∩C∩D) | +| k | dim(A∩B)+dim(h(U0)∩Z)-dim UA-dim UB | +| eC,eD,eCD | dim(E∩C), dim(E∩D), dim(E∩C∩D) | + +If `a>c`, `b>d`, `s>t` or `k>ell`, the count is zero. For the remaining +case put `alpha=a-j`, `beta=b-j`, and `H=tau-j`. For a valid contract the +prior exact sequence also gives `0≤j-k≤tau-ell`, hence H≥0. + +Write + +`Inj(m,r) = product_(i=0)^(r-1) (q^m-q^i)` + +for the number of injections from a fixed r-dimensional space into a fixed +m-dimensional space. It is zero if r<0 or r>m. Empty products are one. +Write `[m choose r]_q` for the Gaussian binomial coefficient, with value zero +outside 0≤r≤m. + +## Closed formula + +Define + +```text +S = sum_i [H choose i]_q [c-tau choose alpha-i]_q + q^((H-i)(alpha-i)) Inj(alpha,alpha) + Inj(d-j-i,beta) q^(i beta), + +max(0,alpha-c+tau) <= i <= min(alpha,H). +``` + +Then the exact number of completions is + +```text +Inj(ell,k) q^(ell(j-k)) + * q^(j(alpha+beta)) S + * q^(eCD*j+eC*alpha+eD*beta) + * product_(i=u+s)^(n-1) (q^n-q^i). +``` + +This integer formula holds over every finite field, including nonprime fields. +The first factor uses ker(delta), not the whole common source quotient. That +distinction is required by the nonzero-delta example below. + +The formula uses at most n+1 summands and O(n^2) integer multiplications and +exact divisions with direct Gaussian products. This statement concerns the +formula arithmetic, not bit complexity, field-order validation or input basis +reduction. The API checks prime-power orders; its simple trial-division check +is not claimed optimal in log q. No subspace lattice is enumerated by the +counting routine. + +## 1. Count the injective common lifts + +Use the source theorem's quotients + +`Abar=(A+U)/U`, `Bbar=(B+U)/U`, `J=Abar∩Bbar`, +`Cbar=(C+E)/E`, `Dbar=(D+E)/E`, `T=Cbar∩Dbar`. + +There is an exact sequence + +`0→H0→T --rho--> (E∩(C+D))/Z →0`, + +where H0 is the image of C∩D modulo E. Its dimension is ell. The prescribed +map induces delta:J→(E∩(C+D))/Z, with dim J=j and dim ker(delta)=k. +Any quotient completion restricts to an injective j0:J→T satisfying +`rho j0=delta`. + +Choose a fixed complement of ker(delta) in J and a fixed section of rho. +There are Inj(ell,k) choices for j0 on ker(delta). On its j-k dimensional +complement, each prescribed quotient vector has q^ell lifts. All those +choices are independent. They remain independent from j0(ker(delta)), since +delta is injective on that complement. Thus there are + +`Inj(ell,k) q^(ell(j-k))` + +injective common lifts. No basis choice is counted twice: the source basis +and complements are fixed during this count. + +## 2. Extend the quotient map inside the two capacities + +Fix one j0 and write L=j0(J). Quotient the target capacities by L. Their +dimensions are c-j and d-j, and their intersection has dimension H=tau-j. +The remaining source parts have dimensions alpha and beta and have zero +intersection. Choose the image P of the alpha-dimensional source part in +Cbar/L, and put i=dim(P∩(T/L)). + +The number of such P is the classical subspace-intersection count + +`[H choose i]_q [c-tau choose alpha-i]_q q^((H-i)(alpha-i))`. + +Indeed choose its intersection in T/L, choose its projection in a fixed +complement of T/L in Cbar/L, and choose the graph map from that projection +to (T/L)/(P∩T/L). The graph has (H-i)(alpha-i) free field entries. +There are Inj(alpha,alpha) isomorphisms from the fixed first source part to P. + +The second source part must map into Dbar/L with image disjoint from P. +The intersection of P with Dbar/L has dimension i. An injection modulo that +intersection has Inj(d-j-i,beta) choices. Its beta vectors have q^(i beta) +independent lifts. Summing over i gives S. + +These choices specify the quotient map modulo L. Lifting the alpha+beta +source basis vectors back through L gives q^(j(alpha+beta)) choices. This +count depends only on dim L=j, so it is the same for every j0 in step1. + +## 3. Lift back through the fixed image E + +Fix a quotient map on (U+A+B)/U. The source theorem proves that compatible +lifts exist; its common-lift condition is exactly what removes the paired +representative discrepancy. The set of such lifts is an affine space. +Differences between two lifts vanish on U and map Abar into E∩C and Bbar +into E∩D. Their common J values must agree, so they lie in E∩C∩D. +Choose fixed complements of J in Abar and Bbar. The independent free entries +have dimension + +`eCD*j+eC*alpha+eD*beta`. + +Therefore this step has exactly the third power-of-q factor. Every resulting +map on U+A+B is injective: its quotient is injective, and its kernel on U is +zero because h is injective. + +## 4. Complete the ambient basis + +The fixed domain U+A+B now has dimension u+s and has an injective image. +For each remaining domain basis vector, choose its image outside the span +of all preceding image vectors. This gives the last product. Multiplying +the four independent counts proves the formula. + +In particular, the formula is symmetric under exchange of (A,C) and (B,D), +although the displayed sum treats the first source part first. This is also +checked directly in every positive finite census case. + +## Discriminating examples + +For the source oblique example in dimension3, + +```text +U=E=, h=identity, +A=, B=, C=, D=, +``` + +one has k=1 and ell=0. The count is zero. Each separate capacity can be +satisfied, so separate counts cannot be multiplied. + +For `U=`, h=identity, `A=C=` and `B=D=` in dimension2, +delta has rank1, while k=ell=0. There is exactly one completion, the identity. +Replacing k by j would incorrectly give zero. + +With no capacities the formula is the ordinary fixed-injection extension +product. With two complementary source blocks of size r and target blocks +of size r, each enlarged by E, the count is +`q^(2ur) |GL_r(F_q)|^2`. With r coupled differences fixed between two target +blocks, the constraints force the identity on both blocks; only the remaining +ambient basis extension is free. These independent product formulas also +check the large-dimensional cases in the receipt. + +## Evidence and limits + +The independent literal engine enumerates vector sets and complete GL actions. +It uses the polynomial x^2+x+1 for F4 and ordinary arithmetic for prime fields. +The full normalized census covers all fixed ranks in F2 dimensions0–3 and +F3/F4/F5 dimension2: 287,431 contracts, including 64,525 positive counts. +This is a count census, not just agreement of zero/nonzero decisions. +Independent changes of source and target bases put every prescribed injection +of a given rank in this normalized form. + +Seventy-eight further contracts with arbitrary prescribed images agree with +PR6533's affine kernel-lattice rank count. Six named controls preserve the +oblique and nonzero-delta cases over F2/F3/F5. Sixteen dimension120 formulas +over field orders2,3,4,9 agree with separate product counts. Two literal +48-dimensional vector contracts agree as well. Four omitted-factor controls, +seven invalid inputs and three actual source-byte corruptions are rejected. + +The proof is the all-field result. Finite checks corroborate it; they do not +replace it. The executable basis extractor uses prime fields. The scalar +formula accepts every prime-power order, with F4 checked independently. +The routine counts invertible completions only. It does not count every +singular rank, sample completions, or emit a native operator. + +All spaces here are unrestricted linear spaces. Symplectic form, signed phase, +causal access, dirty restoration, physical routing, scalar/basis cost, precision, +stock, tape, compiler and outer costs remain separate. No actual selected +contact, supplier admission, new kappa or selected-frontier change follows. diff --git a/research/two-capacity-completion-count/README.md b/research/two-capacity-completion-count/README.md new file mode 100644 index 0000000000..52431f5f64 --- /dev/null +++ b/research/two-capacity-completion-count/README.md @@ -0,0 +1,64 @@ +# Closed count for two nonnested capacities + +A prescribed injection and two simultaneous capacity constraints admit an +exact finite-field completion count with at most n+1 summands. This replaces +the general exponential kernel-lattice count for this two-capacity case. +The formula retains the coupled prescribed-image condition; separate capacity +counts cannot be multiplied. + +Read [PROOF.md](PROOF.md), [count.py](count.py) and [RESULT.json](RESULT.json). +ToikY's [PR6535](https://github.com/CrocSwap/integer-mult-bounds/pull/6535) +provides the prior feasibility theorem and quotient construction. Ali Romman's +[PR6533](https://github.com/CrocSwap/integer-mult-bounds/pull/6533) provides the +prior general all-rank count. Neither result is claimed as new here. + +## Scope and evidence + +The formula is proved for all finite fields and dimensions. The basis extractor +uses prime fields. Literal GL enumeration checks all 287,431 normalized +contracts over F2 through dimension3 and F3/F4/F5 in dimension2, including +64,525 positive counts. The F4 oracle uses its actual field multiplication. +Seventy-eight arbitrary-image cases agree with the retained kernel-lattice +checker. Sixteen dimension120 formulas and two actual dimension48 contracts +match separate product counts. Named obstruction, nonzero-delta, factor +omission, invalid-input and source-corruption controls are retained. + +This is unrestricted GL counting. It does not supply a native/symplectic map, +signed phase, actual selected contact, sampler, physical cost or new kappa. +The source heads and exact files are pinned in [SOURCES.json](SOURCES.json). +The proof and notice from PR6535 are inert retained evidence. Only PR6533's +exact linear algebra and bounded independent count are executed. + +## Reproduce + +```sh +python3.12 -I -Werror -B research/two-capacity-completion-count/verify.py +python3.12 -I -O -Werror -B research/two-capacity-completion-count/verify.py +python3.12 -B scripts/research_package.py --package research/two-capacity-completion-count +``` + +The standard library is sufficient. There are no external runtime files. +Large exact counts are stored as hexadecimal integers, so decimal conversion +limits do not affect the receipt. This is not a runtime benchmark. + +## Open next questions + +Can these counted choices give an exact uniform sampler with a polynomial +random-bit and arithmetic bill? Start by sampling each weighted intersection +term and each independent lift. A rejection or sampling bias must be charged. +No sampler is included here. + +Can an actual shared native contact reduce to these two capacities? Extract +its fixed images and both target subspaces, then check the signed/symplectic +constraints and the complete physical invoice. A positive GL count is only +a necessary interface step for such a consumer. + +## Credit + +New count, proof and executable checks: Ali Romman with substantial OpenAI +Codex assistance; no subagents. Credit ToikY PR6535, Nick Petalas PR6489/4919, +Ali Romman PR6533, Brian/JoyboyBrian PR5020, Cao Yifan/intqwq PR4610, +codyw912 PR4735, Cinna Davis, Dugongue, zxv, Jacob Alan Sussman and the +retained native/compiler authors. The original PR6535 notice is retained. +Gaussian coefficients, subspace graph counts and basis extension are classical. +New work is Apache-2.0. Independent scientific review remains open. diff --git a/research/two-capacity-completion-count/RESULT.json b/research/two-capacity-completion-count/RESULT.json new file mode 100644 index 0000000000..355b077f88 --- /dev/null +++ b/research/two-capacity-completion-count/RESULT.json @@ -0,0 +1,787 @@ +{ + "census": [ + { + "contracts": 1, + "count_sum": 1, + "fixed_rank": 0, + "gl_maps": 1, + "n": 0, + "positive": 1, + "q": 2, + "sha256": "e9586b616536950f82cad86972b68f4f99d3fb3cdf4013c0d1a0a09394ca96b5" + }, + { + "contracts": 16, + "count_sum": 9, + "fixed_rank": 0, + "gl_maps": 1, + "n": 1, + "positive": 9, + "q": 2, + "sha256": "a0fddb8fcbf6ec03adfc8892ab648bddc887a02101a71c18065ceeec363ffc84" + }, + { + "contracts": 16, + "count_sum": 9, + "fixed_rank": 1, + "gl_maps": 1, + "n": 1, + "positive": 9, + "q": 2, + "sha256": "a0fddb8fcbf6ec03adfc8892ab648bddc887a02101a71c18065ceeec363ffc84" + }, + { + "contracts": 625, + "count_sum": 864, + "fixed_rank": 0, + "gl_maps": 6, + "n": 2, + "positive": 288, + "q": 2, + "sha256": "78428b89af4e62b5bc7d3a8d2475f0b5bc341971eb67ae2924c5dadeea8f067c" + }, + { + "contracts": 625, + "count_sum": 288, + "fixed_rank": 1, + "gl_maps": 2, + "n": 2, + "positive": 188, + "q": 2, + "sha256": "777fddf4fbfb2f962722ac8aab2b0b927e7f2ceed59a15ad91eed87eab2d0626" + }, + { + "contracts": 625, + "count_sum": 144, + "fixed_rank": 2, + "gl_maps": 1, + "n": 2, + "positive": 144, + "q": 2, + "sha256": "6782a14a10c36224bb1186715b8df283dd55cf992af7e470fe6213afee936b30" + }, + { + "contracts": 65536, + "count_sum": 731808, + "fixed_rank": 0, + "gl_maps": 168, + "n": 3, + "positive": 27372, + "q": 2, + "sha256": "dbf6956cbb971c75cc1c9d20c113bff6f0c70d396ffc563561b6237416af512d" + }, + { + "contracts": 65536, + "count_sum": 104544, + "fixed_rank": 1, + "gl_maps": 24, + "n": 3, + "positive": 16128, + "q": 2, + "sha256": "fb497978f5a52753e910b4d26287c5fe9ef6427b0af353e787a84a92fdf24688" + }, + { + "contracts": 65536, + "count_sum": 17424, + "fixed_rank": 2, + "gl_maps": 4, + "n": 3, + "positive": 8232, + "q": 2, + "sha256": "cc6324e81e3d9a095ddcce5f4e11bbad5963467aa5fe6d6619d423020e42ef49" + }, + { + "contracts": 65536, + "count_sum": 4356, + "fixed_rank": 3, + "gl_maps": 1, + "n": 3, + "positive": 4356, + "q": 2, + "sha256": "693fde386596f072ce3f15d6392d379a6cfc3d67a5d538464ba9ba3cf7f375c3" + }, + { + "contracts": 1296, + "count_sum": 10800, + "fixed_rank": 0, + "gl_maps": 48, + "n": 2, + "positive": 633, + "q": 3, + "sha256": "db4571423c85981b20544d361cd45388b95b9e99413406216d5dd022b05cbc38" + }, + { + "contracts": 1296, + "count_sum": 1350, + "fixed_rank": 1, + "gl_maps": 6, + "n": 2, + "positive": 405, + "q": 3, + "sha256": "f60476a765c3d3ea1b40eafad1640628ad2a770b98ef601eb7798a47e4a55265" + }, + { + "contracts": 1296, + "count_sum": 225, + "fixed_rank": 2, + "gl_maps": 1, + "n": 2, + "positive": 225, + "q": 3, + "sha256": "c387629a37acdae13b743db04e7dd701e461b400fbf64c4144abd44784a62305" + }, + { + "contracts": 2401, + "count_sum": 58320, + "fixed_rank": 0, + "gl_maps": 180, + "n": 2, + "positive": 1244, + "q": 4, + "sha256": "34e4fbef19ae0aa77b2aa8645c409f185f3d46e3fad40d2795a4bc5408188fa8" + }, + { + "contracts": 2401, + "count_sum": 3888, + "fixed_rank": 1, + "gl_maps": 12, + "n": 2, + "positive": 804, + "q": 4, + "sha256": "b600c9ddd36920a78a6f678ab419ef843c8ce3fc9ca7f7d66a11d05777c1e605" + }, + { + "contracts": 2401, + "count_sum": 324, + "fixed_rank": 2, + "gl_maps": 1, + "n": 2, + "positive": 324, + "q": 4, + "sha256": "324ded7afa752ce3526c4b904cac6a8fa14b357062931c10d8f4ddd5fde22b3e" + }, + { + "contracts": 4096, + "count_sum": 211680, + "fixed_rank": 0, + "gl_maps": 480, + "n": 2, + "positive": 2241, + "q": 5, + "sha256": "0304aad50b12eb8eb4d6d323a36e5b432be98db7009b0eea76d2d5f0d987b622" + }, + { + "contracts": 4096, + "count_sum": 8820, + "fixed_rank": 1, + "gl_maps": 20, + "n": 2, + "positive": 1481, + "q": 5, + "sha256": "6b8e156e7b618199b30b1bb7a146edbe56d18c458787c5137fbc451a9fc78cb3" + }, + { + "contracts": 4096, + "count_sum": 441, + "fixed_rank": 2, + "gl_maps": 1, + "n": 2, + "positive": 441, + "q": 5, + "sha256": "85a2fbd7218993371032209d1bd404a51771e46e845d55dea9f42f3fc7131d6e" + } + ], + "contracts": 287431, + "distinct_positive_profiles": 862, + "invalid_controls": 7, + "kernel_oracle_checks": 78, + "large_formulas": [ + { + "bits": 11999, + "count_hex": "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", + "field": 2, + "name": "free", + "profile": [ + 120, + 20, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "bits": 11999, + "count_hex": "0x49ee043fdf00207ffbf80010149ed83ffdf08227ffbe7fe1013188dbea94b0c2455295556014714426391e3017616ddb79c3fce6a0952a986c1916d1b442cc1f4941c06f10826feb84d6c1e8659e3c758e91cb8331ec1c0a3ac3e773bd1ee09e7e59a17ab7effb898a44c95efe1f86019e8df20b7531abce4a343abd2a6f6d54a737d147a3484bb4ee91b1808aa2ad4807d5389992897033c94132f8309071a11e48a5afd4cb79d66dc78d8e18b38de9f89485d48bb42a2b1bc45f5f3ad669a66bea59f27789833e15ccdd06bf83b5f3a3033933cb7eee8a38a67132376486321abc8307f636ceeb2cc8d83daefb3a8f52eac3560b9dec67babd30c7bf124c825df756bc322d3a6a30f4fd9303286fba243b9e8797ff1d614d6550d938661ca68e2aa471e973dc273dc6d45737b33ffc6401c0aa44ffaba2aafedb21bd8b0a41dddc754765a6b2e7e80e2eaec218979fc2383031ca88fdec724e474d3adfbb7297f13064131d46e7bae50fb755d7c683424fe0e7d22778560611f308cc5c77c07f4b8d0796310344c34329b8e8b01bd60417b706e5ec5aeac67a0cbc1dbc6fc07b8ca9e2ba969701c559025e109b963985b56472e64f27478fd1c7ac194dd89c76649785c1faf86e640c17e713e94f961e3d87b4e45fec2369ce3560b286f158cb3fe9d8ce7ad2745740ef5ad49fd2e94cecf368ff5d1a388a3f18ff772177c5b4c4ef518960c532bde71aa4a2b7fb318c3627f73a4ab2564c229983cbd00e35f80b2ac3a476d1bde05d5537bf7728c5189b698a09752cda3e92527e450ef63aab80bae7f09e9adb898697f7fb78c9c54cd805b5529551c27a52ae2626887f7e00c1fff1c0883fcdfc7b2c03fff7f00081ffbe010fdc26c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "field": 2, + "name": "unrestricted-capacities", + "profile": [ + 120, + 20, + 40, + 40, + 60, + 100, + 100, + 100, + 20, + 100, + 20, + 20, + 20 + ] + }, + { + "bits": 6997, + "count_hex": "0x15599bb85402d059bedd52a76e1c1cbd6f7e9551752033dcec6126e0dd4a0df133bb02c7de05bcccdb5135e0be2982e4405052ef15ff344bf5ec4830bb78f8d88c4e910d1ce136f4d8974ec58156170f11669ae01e0f32b515853ac25c4ac796fa0d9ac5962bf7ebbb1c36f8a9c33cf3e16fd3572d33505e7a4f40071afefab377f02dae737232364b3ef7ec2f9129498fa566151a74a53f9fb5a467a6c68709b7ab2df44b3b0be634857325f5f69a6c700275f683cfb66f32b35b257a0cc2d487060aebf8ba06032da702258ffd795b822008bcce371f739b56f586b32b48d73fe344f6fe22573fdd7c8e59ab617386b2f516609b1905dfd12ffd53fc87f877b56797da65698dff7f7d5a9a5f08f58135e3c255708bf327c14dcfbb238e38ce81c29f6106ae995c2d02366776ed140f179701eb6f9d4355672e35d747f76400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "field": 2, + "name": "two-block", + "profile": [ + 120, + 20, + 50, + 50, + 100, + 50, + 50, + 100, + 0, + 0, + 20, + 20, + 20 + ] + }, + { + "bits": 9599, + "count_hex": "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", + "field": 2, + "name": "nonzero-delta", + "profile": [ + 120, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "bits": 19019, + "count_hex": "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", + "field": 3, + "name": "free", + "profile": [ + 120, + 20, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "bits": 19019, + "count_hex": "0x68f84ca88b4f1e35566efb83307ddbfaad0f0a79b7d5642b66ebc47a2eeda4dbc733a6df174da1c854afe7215c20fdc83c1e6d2299a9ba61eb48dda0ecdc513772058ae16e3117781159fcb1d47d88d8a2dbaf0a066b53fbefdf3f88d088ef617398d677ed6329dbcc753c6f5867e885f782055711d3e8d9dc0283ce2cdcc4cb707cfbe6dd72a90d67ae51a36a09e9cbad871ce907b377733ffdf5858e6d2439aa4df60603b6e02b53e571173c54ffe0d91b726cf8363e62ce87adabff45864f7349965ed2fc44209984cac57beea0608eaf36dcc256b5f36f5fb9974abafb27b5688f4e8c72d65ae3a941ab3e9c5d9b010d812df7861579b248294619b776196bfa9b5b48f36748251a7f26dfa4c611d5c3c758b204e3fa91d4a4de9e5055c06c6ce912188d12492002328324aed21290681045f7c28f7549b5ed409dc40efc476692e776db39e1778de39c4bfb860f7931609f45d2ad9c49754c67b58936586041e56100310139290186421139bc328bc45345f981e421a6f9d62290cea1f0b1578b3f0ae0cbbf58e6ac63dba46f371eb62a4317fb2155c0f4346d37a55229294a98914d78a514097269df9ebb459458b71a17f76d160806b0e1c563360734d96c067e327a6f3f41aade79008902cd2f1d83e9b3949eb95bfe56feb48635a81ed1ccf7252dc18dc3a498f20d2d0b6d0b2b35592016a2a58caf6eca3478d16aae95cad32dc374aec3f1a4a91c3bd1c9042b611b0f63fb01204a698e1231145f709de3e77cbd459c62d2cdf776e4e50b9dd0e8007789d8da9d01e32b004abbbfc08fb9ff61b19def945bce8695aa7985d34037727a2471f40513193ed5aaec558244d9dfd797f42f15be6543038a370d7bee7d6b3197968b922681c8800c01e35456e778209e1e33b65927763c97657868bc884d9fede360907aad5e78b1d41e3d4c0a91e5c00703612550a679ff7752e5b048fb43c90dc2ee4ce1f7297bb6fa8f227ec93a84a9465e77ffbe558877e5fd7bb52b13a31b39637c1e362935b70098855dc5d5693821563c2d0e0216fedecb9069b5aaba5f0b3a3ed675be02513d94ec9e1735b41f1d492f9c8782333d256001a8d0defff2e17424b19871180c49a667266be75fa4b31b15813878997d2fcf62a967083a41ce39343035284d12407c9e94fc49d817a30feb2b94be6e6b8ce3cf4cd368e14a41fca6387bebdc0f3190f0f08611aa0c8c95fa8aefb2d9c23b689d1bd4167f8e11716da40fe91cafd0ee85f36abbf03cba82434e2cdc0f541ba1c1f13a1584b0c4f0a537930d0803160f662a224f81a030f81b7cb6b26a544ceab76b2b11efb9fe1b6e9abbde2c47b15dcebb066c75c7a5348da8e27924fe29936b07ef43f3e6b20992561b8522ffb2ce7e1eb958239788dd0168e7daf6b57253b935aa03672d44eca20f0af293f7d59cb1f924b8037eed4bf3fcb9b5360562a65027dc1519eae190f13b863f55dfdefdd63544b9beed4d0d69192b289f336e7ce2480cd1328c6f0052d822dca3b09b2479e72b43e53a9ce5b47b1bc2063c56ccd35fceb886f78e068504a57c80ed55b4bd3ebe732d46a59e2cef993de4db56d3cfb0b55aab7bc528f0885b2fe6d180418aa774f20931ecfa3fa1b30e085ece6055b3edc2fa0ea3431d4784b75b4047856f6a938e2db43c1e1f7ebf6781c6b2b64c111a640c49eb2849d2cf640c3173f3ba90f1b79d6a5abe742502bdbbc4fb8db0edd922baaeb0e278bea5cf5592a243e56e466dbb8e4de89c60d59e92c420f14ea2ece5ea906a42a4b06013bbb2fb624a515de024f2f47f5a5c19b64743adc2292be19306db7888fcec927406ac0db9159b01cf4ba6d859a445e3858c00b36d67c714a31549726558578c9ff8aee4afa224a1d86a64c8bbca55641b08562d2ead106b00ad117ff1db85c8a7d95c50a1ed7a5a09c0cbe2c20aa2dda7a3e7c4cc376e2e363711535589c1470bee840eb5b803597549188a1cb47b788634fe7844668f147ab41b94e72f79269c2266c5c5f648322b157dba80a6a6eda11282affc22f61e36151eb21748ab40c4f2e905c6a5b72e767dec569c1a0c535cfb852e454b49f9c1264a44d763e80f3a118392240fb2957ae96380299e49b8272c1fea4bee73e8c0574cbc80afa27baab892e6c9a6b21b53ec260ab0d4f16424ee26968d0e7d4f5735ac816a1a8981b47385f4a2289fd0c6698e45ddc8dd4b99aad9495dfcd66bf3fed7bcb011505162181ab6edcd2d48af30bd0e148a0e890f4153d62cde6d9dc18889af607cf85a78128b31dd5d95157b37bf9f61520217acb4098d060d1e09f6bc78a4a371d377e46634332ea0512af76a3e45f38d67b08f9329711863309c592953c5519fa42aaddcfa9dc033cf3227841b1df7486b265b6e533d8f3f60ae2b8d63bbbe3cbf2dc48b0ec4f38bc9b9cc7dc37885af2573edf3f85e408cee9a87c07b907c48bc87d3ce2e10fe7f1bba0783e44caa18df3b488fa1b6ab2324bd39ef0b0a535f005b2fdf72989d20e3d51bb17e037fc6633eb20562fc423f92a8bee7f4eb58ed794d6b00b286b3ee54bf66172fb725f49253dd6b4517026190723f62dcfcd624d9fcbbf6454916aa7891173f059f2787d55bf4f76f8834439dfe1eb8575397978d554b615779b2f4eb6525eb9316f4bc6e046210aa8ca994e8069cdadfed9e56a30b2b45e7980dea5a44aeba96d77358da92cd492525825c7811a83b472680a9d7c8d7db640cece1ab637679c98bf0004426e31721479207e0dc2ffb472967874d805eefc947ebcf4d87a621f4d623e383c7449c7ed5f7506de9e1d227a3dea272f11275b71d08705d14eff6a42c0e86e96d93ae4ea7bbb847b6d9f74614cda1e690c9ec3f9e2a28189977334caf89f927d086d36d4a430728465ccf1bf12f6c9eb0adbe791ffb1dffa7006548b879a747c299b4884629287d93ebb8f5485c714735f42f9a692d1ab89cd48ae69524f6718f41bed86ad822a50db67a349aa6c7fd02203626d3ea2f2b6d2d26567510a7a4aaf8a7e45e034f442ce47cfd0c6cdf815d258273fd54b4b9c2c677d3cee1731f744fdd7356760ccf8e49e4e0bafcd55d131ee55e5e6262064b2158597c69c1d2431c315b55578bbebd1241854fe449e3f8fa81b2170b644602cc575188d8ddce4ff57abb2b3342423cb5bd25c47bbb06a489a4333ceb31776233c4d4526d325ca2f4bf5af4b38578e6d646c9de26667aae7a0c59c5e0e0c0bea936789192450244ee7f82a2a731dca271b331f61d06b3a52c74dd28391b9746d095804b716bb80000000000000000000000000000000000000000000000000000000000000", + "field": 3, + "name": "unrestricted-capacities", + "profile": [ + 120, + 20, + 40, + 40, + 60, + 100, + 100, + 100, + 20, + 100, + 20, + 20, + 20 + ] + }, + { + "bits": 11094, + "count_hex": "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", + "field": 3, + "name": "two-block", + "profile": [ + 120, + 20, + 50, + 50, + 100, + 50, + 50, + 100, + 0, + 0, + 20, + 20, + 20 + ] + }, + { + "bits": 15215, + "count_hex": "0x6fba0a3a47132d8e2e103732eebf7cb91cbdd62939a111000f929afbb28190bb5ed7319e03d430a89cb4e0ab2de07feb04b520bf55436e54f73a02c6b8a1276509537f244a6cf5b9a643cc12e3198992a7dd6e6531b46b8456faba3bc743f917cd6a2526108c26f1dfa63462983fe0d5ed7f7356baf5affc98960d36601f4afa280afbcb80bb0a209b10060dc6464dfc0cd2c2c4a59b8fa4530a9ee00fdb61b4cc471bf4df1867ec19acc570c1d778b90d0a3bc991bf8013e3ca0953c01719d0465e2e40fb06da282dfe92e7710ac899113511f759b83b03d1e193ca067dc90b2e1afa402fceff8d3c5eacefb4d9726b183764589906bf67a58255254c11ae039dbc5c4759f2ae154c0fd3e16685f9e9b072e06beca012e1c1a250ea6de46af120aece33c1391f8e021f14843740c771d996cca5535b9fbeaf9e2484bda828e19dd1ec13dedd82ae3fc91a1ce1455cf540c04d74eef581c21270db7413131e873b94d86e2de26fd1771ba0d5a98fbc7ab3830a7e6a3866c8a410c5496570ea2764139ab3ef902963df69cbc2499817e4d0f476b995c387426eb6b0b63943fe65ff821d1549f731d4f42d4fb28a76ad8c078cea77d9e6a36cbf40b8da3411970db12812e9f3fd23b2402000524d1160903ac3ed61e34a14ae6d971bf3e8a9bb810e4ec586cf4e4d74f58bdce1ad90b879e4351ffd60f570d656ef68f9e1c9aaed8ec95504ecefc682a43d2083240b05dbe39597cf420a600fe441785a9905f1bc440cc00b3192e730e8180359bf18ca7b690a88c6fb64ca9cceab23f40efbf8164dcc07195b52531fa229dd72764f7c3c79fba0bcda7b6f1b327546d7d683435c178771c0f0d47b01d60c9e5da503c808214225054ffcaf3b853f38061349f27aa4dcdbfda2517e8a7ed00649942b389217ad1f9f0f3bb059c2117a2193d57ceaff8a0d1dcfec96243fc9ed623c9aba849aa3599c92f3adc9e0dabf28c78b9fbb35e9ef2ae2be8533814f18865b169dbeb51a2829579fd96e393aa53bb9ed2f787c9f4045dc966d2fd1dcb48e6d55a5a9f799aca651ffaf0f28fcea96aa6de463eda1c170ae3c0be998ed0e6f67fcc12af1de146e28e2dff6895a078428ac76845c7363cb995bdb73f4e120e3451518e5894fb3e47003bc10efef80eda7e2b4d4dbe067b6337e8e729b3e964842eb9f3b250c5c9fd6ae61444caafaf262d927a264abfc9329fbdc907813f2412faef90f081d2923af71e3f2edabe5b6e9d195ca13e170f7f379e9522a6707234e82afb9c51a89172feb0844614f65da7abd279eb2a1654ca2b7fca2655cf81e04d4f2ead388a6ac61b8bd7b26f707b45a3f8515492d3f12fc1a136ff3548d5b8331abe5d805c04a2cb43e3b871686cb180aeb963ca066718d2f7b096f9fd14c4d64dce1dee8fad34910d2a33e50c49b679044c8a2c34d40dc566c699a47f4f89e9be96e8240957ab26f7eeacf58ffecae1270df1748193e0e19bbf06ba8fef9450d02aedc8c03f7b538b53fedf1dd2a5869c25aa81e1599b2c82bbf2799849780f0f15703ca76311dd69c1d5b8b87140434ea25c976045706695d063235e4e69c79062331db4f8d7342e2dd7bcc5123f6d667362bfc1f77393ac929aa88b5c94b6a51322f09189700bd9c00bf024b958d44347c0adfd576ad31776e465a98bad120f00b3882b017ffc1dad9c9a32e7699d275dac651b77925fda5cf59ff80fd7aece9c3a733a71708b3ddcea76c39405235e5c0e997ce94a80a2041ac1336b3f36f576e0d7dd9b325686367d6465849f7aec9ea5952a3894133d294d81e6ce792ac2081658013d80c0e9a369a094ba7de81eaeb0286b5812e53535dc38a84b360d13fbc54cf057239d10654bc6a36c625aafd19929760bfb03bcf8619c14a9bdc91635ec356c9ae9ec40b52834e61082b4e25bb656d02d3be14f25bc0c2a4a2195b3410de565ca8beb266936b42b7e2123ea8dc23242d8ae48a3893837146647f5422739272eab5a8f9de3c43ef736458fcbee96c443df7592a680bf9b7d2c3d991637076d9677b68b3d3eddca2ab0f7254095f0d33c5b0128ad5c1a5252d4d8da9ff45d50ee7bbca7b763c8d926ff1863b7efc04497b9767d5307da77c22d25f46cbb4bea7a9871e85b0404d26f38e3393d18f7fb1267c8a9f8cdc1be415b0d7c6e25abc2913912715254bd144ed0d2192cbb462f16fd1bfda5104cdf208a09903ede461a7c7f44a05ef047e4ec9e44b8fa552edec419b2c8c4ac292890fd3750b6775406d26df92ff6c5dfd0ff39a94a3fb1de50f82a34a2ade50e711584fbbf5c500b13a7c16ba7fe2b5e02e9889fddddbc05e970eb167891c3778e1313cc4a30a5671e2f501417970bd32373e871e84390f5526229557dacdbb30e09a8850b9e3d85a88358b516354361e49c2fa25f6cff39f106e4438d2617ce55fc33c981da3bc6da8f70ac385c5edfaf10650503372688b6d8aaad94d0caa405864626d1c3af931b0984fc67453149ffb66eeba12cc42db7e1440df19d305009bd21a7d12c81ef563e914a68eb5e74978d0717d3c933121f96d39698afeab9bc9c1b792c7594b032c1056ad7d4ed623182110a6fa615894c4d610604ed606a0690a3e7d2c34a85320fed0bd40000000000000000000000000000000000000000000000000", + "field": 3, + "name": "nonzero-delta", + "profile": [ + 120, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "bits": 24000, + "count_hex": "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", + "field": 4, + "name": "free", + "profile": [ + 120, + 20, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "bits": 24000, + "count_hex": "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", + "field": 4, + "name": "unrestricted-capacities", + "profile": [ + 120, + 20, + 40, + 40, + 60, + 100, + 100, + 100, + 20, + 100, + 20, + 20, + 20 + ] + }, + { + "bits": 13999, + "count_hex": "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", + "field": 4, + "name": "two-block", + "profile": [ + 120, + 20, + 50, + 50, + 100, + 50, + 50, + 100, + 0, + 0, + 20, + 20, + 20 + ] + }, + { + "bits": 19200, + "count_hex": "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", + "field": 4, + "name": "nonzero-delta", + "profile": [ + 120, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "bits": 38039, + "count_hex": "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", + "field": 9, + "name": "free", + "profile": [ + 120, + 20, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "bits": 38039, + "count_hex": "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", + "field": 9, + "name": "unrestricted-capacities", + "profile": [ + 120, + 20, + 40, + 40, + 60, + 100, + 100, + 100, + 20, + 100, + 20, + 20, + 20 + ] + }, + { + "bits": 22190, + "count_hex": "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", + "field": 9, + "name": "two-block", + "profile": [ + 120, + 20, + 50, + 50, + 100, + 50, + 50, + 100, + 0, + 0, + 20, + 20, + 20 + ] + }, + { + "bits": 30432, + "count_hex": "0x883bcfd4bdcba39c462cbd0e277b6fe5ee2486d3df30690a875b7af04a4bb0efcd371398d23b266fa81a98209507e0b5412eadba14cb45512f56cd0219495aa34ef1eb2e634e7da38d66bd372b01d82c92464a2b014cf38801406d2c807e9d806c1bef3b2223396656a57a579a4f27c0f6ae050a8e57178994cf7e36c7edcfa9f305d0186a9d5b775ee1d0bee32c4b0c84f8da2ba0f39ef712cd9cf9fc9153fd5be664ee7db16e983de8feb7a6f0332b563083f26fbbe0a72d2f3991999de4e4982d2e1cce1adbd43a2f2ff5994b69eace8c2c00bb013b14bef52c5b1204b0e58f7f508c3dd3b4e7be9ef04111ed615dc0c746760fd3b3f0814a5746bb9baee085a931dca053f0fc585480f1ea50f10d6a23352ec3d5e682dccfe2b73c9bffeaec9b0bfb69d91fe06edb740a699da2d37ce8c0bb2f642b4c9afe37cecd987a02d6df1c87301df29e58446ca2bd00618105ce56354afa29a1153dcae45e921daf3fc921b27b2de088150eaf589c7377269f559a12a6905aa4f13c993ba56262a3b4ef435e50882335aec3e0a620d2a318b7fe3e8d52723ca2afd0b7b172be63cf11b6590841ccb5d77f679c8522a2edceb3bf8afa2efd96b582d8fd9571ae20337cf9acdc2d36023077b4888fa9830a0cbdc76cff8f29dc53622264a3dcc89d884ae510155c94f50ad524ff730fcde54087c15c83571997986e3911889c4701f5f90df63dfd4b8bf3e4ffe666dc70427e3dce08b819db0994652b8b998a4e0a38b4157dba7700953bb640e965a39eb3130d8e61ebd39aaa803613a5beaa148b7e1164733409b974d2505d5aaa125f0bc75ab5e23033ffd2206429a8b36788aa13c1d04ab06412946ee39343c3f53704b3bc89196bae0d6a38bee505639b6f958b5c9fdf35df0783a47798c8a9211f4a140cb6ebc9f171cd838097d06575f2a8cc95c3302303fd6685d5c46f22c6f4fdb8bd6d4731130d8ec794dfe78ae4b0b6a2ddb6279017d0d82f484740c3472b82e71873fa2e8db1c2fb6070d827a436fbad384dc618329197943fc10eb135d24287baffa3686ccc676dc3a4c43d4ef7369f05fd195bdc6ad5166811f46655375c52cf479e12a37238a7690b162fde073dfba6f8ceac55e7257bd07729f4a21ada74299b07b481ebc9dd4c49fa9148e4d1326ef7522e5089a11b807042a4908bc22e3b93e3987987683c95a56546e9268b5d78ec956e85fa379819104768a690f569d744d9a3b35be8a8ddf95cb6acdff87e2e70f00100856e5caffe1e9868c773215835d7a72c6ad4fc6202810d09655cdaa4e64f40b55b695463ecd7226b189fc3c8b18a14548acb75acd9cb0a706e47af94561adff8bc6d493c250b4492046e9f96c741914519c1f64125209c8a36ba3d498ebea35d432720093391c0971544c873ba73cdfc1d2d96bb001160ba69f96037b8e1706d1421e7f4d3e9419350a51c2269aa45d66dc5d242a5e19b8c767bad5120f09b449583eb3ee8a31017d108c17f65896a501bc3ae68478b62d9a6da660b7729c57ee13cb5a816ad1694d27a08e99335d51a73d7dfe75e2b8da65288b39355d830d0357a6f80f4ac8d773663651f06d6dfc997192aba0bb442d72dc25b7d8caa2a8e640af4300fef188bff3fc34799d1960e45b88d2d9f77ff23ad09939ca1bacca5be48d8f2c0c5cf4b73def1bf79ebcf8bfd813211b508c5042f9983477827ee0ac3555bc9a89cdd6ea4d1fdef79e3af534e9ca727913096b26254a95231d7e74c692b1fc3ecc905a7a17913629f5f9c4b9b8efbb1df3596b18e0623fbe323976435a8316384d29640efb5829b32f514d8c6c0080d7941643a8b2364d3ef2a3cbd22db4ec71371a51554dd6adc654966c04a44a87a61df0d9227647a5be5c300b34552945c71fed78f851e714bae3ac85f5f542c315a848058a2c3c75f2a39a4197ef9a41502d89ecd0635628e3fb39c6baf0ae14a1039504f809e6c5e734e600c4fd836fc1685efca5905dfa47f38c83ceafb259b48c7ccaaf33ea5d3b50c3fb72f059734b8f195ca936c2db99b9eb1a6cf730f8b867024660dfcd2f4f6c3eb15cf0cb1039461b9b2e783d86d0a4f3112ab1807a06b4a9780f00b03ab4daa955d47644500381d9e39dcf1a1961c629bd1f3653c3caf364c27e889eddca1d44aabb60b2494e131914e0fec3a9ab6b48773976be6d939cd3b9b8c7944093df7d4c30e0a2e303c2d9f863ed66ef1c152223a538bb547b7fc92f3f8d276ae04d4dc11669b39fb63a665b1da8486a6ea270e78198de84c808b156fea39950d9fe91f5e9281a8a6e9685af71c23f2c436465bcdc8059fe84b61efb49b7d5194a7ecc07bccf7d558fca17deba848427add259b30d05bdfab1878dbac3e9b62b35e4276234899b412804de312f0bd34c0494267885a912742118bf60a48d15dc5f00910715fb282ec343d53bcfbd17607180b20e41fe84e1879b9a7f9baf283a85cb749189c40b85418552ffde3087e6542522fef3ad98f2ce34ae36c400658e49a44da4bcc0530d90f8bf84a25a39e25296eb9327827cefdca56132e91bf2f87730dcbaf154e3127d99975e285aac4f1e415e3ca0b9edf6883c786c90bf4abde0d7cbd17706a5f42be945a7197acc080537e654fe299902a65a65aac89dbad193935ad76191b63a2a9f13b692df07415cf4309bd1618228bd71e20e801f02d83051b783e3da799fe2b3bf7d861586ccf90297434a93d4dbbae5b5fa1a21a039ee23f98af650d1d7385758f7372dfc9f83e926f3dc205b49b224e692a190bfaa0674848d7511c314791da7a3574c4d569e9f3ec01f0d2122b348b725ba6da9d798169bb5a58dfbc35c1cb1c1cf333ebcd5529939d6293feb582773109046b6a1a72f240b26c55ce6f4c3007e332f47280187937af2ab26eccc15cbcead8343ec47a329ce4dc1801aaf4e899aa13ea5c51377eb75f2825a8216bdefce5d134bd2b0e893f97a32a5d27b7ab3a12ca84676a14461703a26c66b5310d269288072fbde69c9c48b99d1a29e99f17f618ec20a50b453484515b58dcdc0c8b5f961db4db8cffb765954d5089c7af6d6e3595164a8becf6ad448103dde313f82a7e1e64d633af0b705c9512c4d41dfa9787e8fb7afc2e56c4f60d61134d632b7bb2702acd5a7d4e4300e7b294dad7debfcdd026b7f487b1858df62b1b8868f3d4a8662d7b617e6d4ec538cae7227ab3d66263b9001add518540db3e2b9accf186b94eb2bc7804dd3a0d3ca86656ddc17cf3b592e17917a5a48a9c6bc02476377029faa30c3e67f79469bd6be2167832f10862c0225036ad576d5ab02afc29db6d97adff30fc67d97a6d38600636addd23a23a7cf9ed429823a256978e775f5189e43bf39b157fb3409f039c38dcd6528faf7f38106833e4be5fc2d040621930bbdae4fc0a2b98be9f0b4ab778928920695a23a2a0255935796ff530fdb78ecea33367d9bfe475abe098fc7abe69568909fc11294bc535c49e698baee9c5364105f4f03dded683fa24823c7a7d79be862e1a25150ba6557ab0fd0e7b38ec84bec61cfd13c4f15c9a49f3f06a0c16974268c4b2291ceced5f5727d4d896f4321adc969cf80b6db3c6fa9fe52be36dd0d96a35f18902a4a50ac89adfe5f8d0edbaea1288e5fcad14a9d1169c91dc031af9823fe5c8cbd651315fea45599a4551402720c29da6301e8f9dc7f1bf94be6221a26e24fb9638b264bc1b94278e5056575fc056260d4f70d040ed2bc26d7df4f2e34833618791b1f356662c2be087085387214de7241c1f8ab5228caa64a2fc54dacb27cba6041d08ab1e4850a4232ba067f88cc2a5a03c970bea9c4d1feedfd45ccbdbdfd7c5dd42f0fc46c6ce439b017b67665c1476115576b18f7a54d129c3e9e713f669af04592e6dacfb6b35889afb28f3561162043737c25533979385f712b07c2ebab8e42c88a5bb63cf014eeb36cd4738749abba7efc6463450ac9bacd4c82693bff78adbf3ec6dcd2db1c00289567b909517fcb87a93f882dbb9ff175e06dd615b263e469155ed68f023731f62178e42cf5dccc2cd5062e704c037a24b53598b205ad2cc682bcbca1fc4267657ebfbecd6fb7ebdcb4be35c958db2934246bb90a04b2b7992615a6e7b93f8e4231e4167076eab8f4998c31103b6416474d8d18314fb7a11f2e7522eabbf738d19d2df7ee99578ad46e5c9d99372872ff0db0e023de1597d22317bead857b8f86ecdb38f74c43cfa6e74e3c42dc14229d52b2e8f9f7e944854ebc8c0859579ea41912a6c725bce0956ba6b5690b12ae228ca8617e5d9d376d48f3b4834e31b6303b3650f11850ecea3e29ee43a944682bd8595383897aecadd746722364c17bcd723850dc31953d17b021dac97b40df1f6e95299d9b16a72d103e4bafe1a62c3bcdceec2ffd3926e49d496f15572cdb37596ce83d7d5ef1a9428ce9b84213d5f63bf32aa6fa6918c5e4e92741b876524e193dc0e0d1a41ce79b8f7a791703fee4b6122d1874a9132997fa95edff9f1dc0816e0b0cae6d22be96b9881a74f5ad455736a35748cc457c1a8e11ec85fa201d29f23b39b6ee56fba52d1fb9926058f50232f0b8b06202be2471026ff3b9dfabf1add64f0638521d6c27983d12eb8db7670cbc466ef7d245c517de81487d9079436f8e994e48704ac5da47d4ddaf660726a40e76e57f207e65d9507ff9e5da37edac09d02f6694f4e6037c16851f8585ca58c7bb54e86f282b1ec6d67dfdac25d452d044b2d317ab8e8aa00ee883be9047ecce614d3616cb9555eab6ca20341b1d308b2c8af7830c317fabeb17c1ec8637abe785f07a4c4eeb13f563e235cd420fa418f14805c0e5df5d8c348ba9dcdfaae6a3e71861a981ae46bfb236ccf83f41429a0844afdab97932c495fbd683eb9e8cf829ede2b439d6b09e8fb5f064fba578b74413a36114aa1204d1d3a08b77b34a7bbae8398e675bb220cb0dbee872a0f001177ace3fd0c203c7c3cb7d16eb4d649c55aa0cc8d3b5cdf0bb8ebf34faea704372268abf526ab44992bc5b692230cdc397967d4114720478377fa2abf3c1dbeb22ba98dc482044a8c277e64f20b10c558b7b50cbd29f0c00bf662757d9dbaaf1d162b2f8edb15d7811085924858c15e7557f2874ddad3a1554b2c6aca2c406eed8167be589618eec9c2dadf7fb851369acd0de8ac683836de7b9195086a54a83c021e1a1c06a61eb90a843dbe40f9e0ce5e4888b4639853dcbce4a5cfc2ddd379bae559f04dc3136ba38c34faedf8d00d5174d2d19aac7f9ba4bd47a926e86cc679f8eb8140000000000000000000000000000000000000000000000000000000000000000000000000000000", + "field": 9, + "name": "nonzero-delta", + "profile": [ + 120, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 0, + 0, + 0, + 0, + 0 + ] + } + ], + "large_vector_contracts": [ + { + "count_hex": "0x15599e6387aba14618e19d252f8a270fa1e410bfcb7029be6297464a5fb55fb615ad5932c21baf99d81abf0bc9cd3530dff91fdd90000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "dimension": 48, + "field": 2, + "profile": { + "a": 20, + "b": 20, + "c": 20, + "d": 20, + "ec": 8, + "ecd": 8, + "ed": 8, + "ell": 0, + "k": 0, + "n": 48, + "s": 40, + "t": 40, + "u": 8 + } + }, + { + "count_hex": "0x2cce8e8fdf81d1958c3dfcddfe2ec8512cec09e69135aa15c024878084266ebd6eb8b5c063f2618138ace86b1a0cedaef68cee3921a77d84eecdff0c29e8925aa6a01d4d8726c55be852efc4771b7d74fe7645e75913af33ccb3bcb0d6b876e4e5875e2e345e3d7e96db069ef87467fb0dc55e475e064effa31776f376b88b7cf833cc95b3acaf9fe3a1ca592e7151f51ff92057b65647d685d547b854ea9dc9864af9a29961bab2c8721619d7904be075962167ded9ec4bfabb7307cab9e98058d991b2d3d7be41a03940d59761737be371000000000000000000000000", + "dimension": 48, + "field": 3, + "profile": { + "a": 20, + "b": 20, + "c": 20, + "d": 20, + "ec": 8, + "ecd": 8, + "ed": 8, + "ell": 0, + "k": 0, + "n": 48, + "s": 40, + "t": 40, + "u": 8 + } + } + ], + "named_controls": [ + { + "count": 0, + "field": 2, + "name": "oblique", + "profile": { + "a": 1, + "b": 1, + "c": 1, + "d": 1, + "ec": 1, + "ecd": 1, + "ed": 1, + "ell": 0, + "k": 1, + "n": 3, + "s": 1, + "t": 1, + "u": 2 + } + }, + { + "count": 1, + "field": 2, + "name": "nonzero-delta", + "profile": { + "a": 1, + "b": 1, + "c": 1, + "d": 1, + "ec": 0, + "ecd": 0, + "ed": 0, + "ell": 0, + "k": 0, + "n": 2, + "s": 1, + "t": 1, + "u": 1 + } + }, + { + "count": 0, + "field": 3, + "name": "oblique", + "profile": { + "a": 1, + "b": 1, + "c": 1, + "d": 1, + "ec": 1, + "ecd": 1, + "ed": 1, + "ell": 0, + "k": 1, + "n": 3, + "s": 1, + "t": 1, + "u": 2 + } + }, + { + "count": 1, + "field": 3, + "name": "nonzero-delta", + "profile": { + "a": 1, + "b": 1, + "c": 1, + "d": 1, + "ec": 0, + "ecd": 0, + "ed": 0, + "ell": 0, + "k": 0, + "n": 2, + "s": 1, + "t": 1, + "u": 1 + } + }, + { + "count": 0, + "field": 5, + "name": "oblique", + "profile": { + "a": 1, + "b": 1, + "c": 1, + "d": 1, + "ec": 1, + "ecd": 1, + "ed": 1, + "ell": 0, + "k": 1, + "n": 3, + "s": 1, + "t": 1, + "u": 2 + } + }, + { + "count": 1, + "field": 5, + "name": "nonzero-delta", + "profile": { + "a": 1, + "b": 1, + "c": 1, + "d": 1, + "ec": 0, + "ecd": 0, + "ed": 0, + "ell": 0, + "k": 0, + "n": 2, + "s": 1, + "t": 1, + "u": 1 + } + } + ], + "nonzero_fixed_maps": 70, + "omitted_factor_controls": { + "ambient_extension": { + "count": 6, + "mutant": 1, + "profile": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "common_lift": { + "count": 8, + "mutant": 4, + "profile": [ + 2, + 3, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 0, + 1, + 0, + 0, + 0 + ] + }, + "fixed_image_lift": { + "count": 2, + "mutant": 1, + "profile": [ + 2, + 2, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 0 + ] + }, + "quotient_lift": { + "count": 2, + "mutant": 1, + "profile": [ + 2, + 2, + 0, + 1, + 2, + 2, + 1, + 2, + 2, + 1, + 1, + 0, + 0, + 0 + ] + } + }, + "positive": 64525, + "scope": "All-finite-field two-capacity count; executable prime-field extraction and literal F4 corroboration. No native or kappa claim.", + "source_corruptions": 3, + "status": "PASS_TWO_CAPACITY_COMPLETION_COUNT" +} diff --git a/research/two-capacity-completion-count/SOURCES.json b/research/two-capacity-completion-count/SOURCES.json new file mode 100644 index 0000000000..8e67210d68 --- /dev/null +++ b/research/two-capacity-completion-count/SOURCES.json @@ -0,0 +1,41 @@ +{ + "schema_version": 1, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a", + "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ], + "retained_predecessors": [ + { + "commit": "efa89adc2c71f1ef57228111639e1c8fc48393e3", + "path": "research/nonnested-capacity-rank-count/completion.py", + "local": "inputs/pr6533-completion.py", + "git_blob": "75c4d75c210de593624242c186cf56878ad8c7fe", + "sha256": "c2f9059f88264974188bacb266fb8acf6a2b2fb5af31d6ce39b9cc597707b812" + }, + { + "commit": "3b3275bce5f051464392d15fdd4d61dbf76eda58", + "path": "research/two-capacity-prescribed-completion/PROOF.md", + "local": "inputs/pr6535-PROOF.md", + "git_blob": "673fc2d9327e280fd9ff1867b5517c1bea53e9ce", + "sha256": "1362ff964b67a3e8bfa8897d2b85cd976e0c15e563d445fb41232da19794d43b" + }, + { + "commit": "3b3275bce5f051464392d15fdd4d61dbf76eda58", + "path": "research/two-capacity-prescribed-completion/NOTICE", + "local": "inputs/pr6535-NOTICE", + "git_blob": "13cbd683d01b050349636c1ef5dd319887ca688c", + "sha256": "f0410595d346ed5edb37f4c249c8c1ddef0b2c65832e8073f570f1fbbcb70eb5" + } + ] +} diff --git a/research/two-capacity-completion-count/TASK.json b/research/two-capacity-completion-count/TASK.json new file mode 100644 index 0000000000..46413dd4ab --- /dev/null +++ b/research/two-capacity-completion-count/TASK.json @@ -0,0 +1,102 @@ +{ + "schema_version": 1, + "task_id": "formal-interface-lemma", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "formal-interface-lemma", + "question": "Can one uncovered interface implication be formalized with exact caller and certificate bindings?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/gate-operand-parity-lean/README.md", + "research/staged544-certified-endpoint/README.md", + "research/unconditional-batched-crt/README.md" + ], + "methods": [ + "Formalize a missing boundary lemma identified by the selected review.", + "Audit a formal theorem-to-certificate binding independently." + ], + "acceptance_gate": "State the exact formalized proposition and remaining assumptions; avoid duplicate arithmetic formalizations already present.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Write one missing statement with quantified hypotheses, actual caller and existing coverage. A compact-switch lemma is a candidate only after its mathematical contract is reviewed. Establish a bounded proof plan before a separately budgeted proof-assistant build; do not rerun large Lean jobs as orientation.", + "bottleneck_link": "A missing interface proof can reduce the conditional gap even if it does not change kappa.", + "allowed_variations": [ + "Narrow to one formal lemma or one theorem-to-certificate binding." + ], + "scope_change_triggers": [ + "Formalizing already-covered arithmetic and claiming the full multiplication theorem." + ], + "overlap_terms": [ + "hyperplane end", + "formal interface", + "Lean binding", + "3807", + "3857", + "4100", + "gate-operand-parity-lean", + "staged544-certified-endpoint", + "unconditional-batched-crt" + ], + "existing_checks": [ + { + "scope": "PR #3807: scoped gate-operand parity formalization.", + "evidence": "research/gate-operand-parity-lean/README.md", + "remaining": "Exact theorem-to-caller binding and genuinely uncovered interface lemmas.", + "status": "author-checked", + "source_commit": "4c3530f42a6abcc48e7a6bcffd6c901911dc8269", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3857: certified real-power moment/endpoint arithmetic.", + "evidence": "research/staged544-certified-endpoint/README.md", + "remaining": "Uniform algorithmic implications, not another endpoint digit.", + "status": "author-checked", + "source_commit": "ef4315b8caa605e47a2515004845eb2d2ed71a86", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4100: compact-switch formalization proposed as future validation.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Audit the statement and assumptions before a formal proof campaign.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Closed all-finite-field count of invertible extensions with a prescribed injection and exactly two arbitrary capacities.", + "scope_change_reason": "Take the released PR6535 counting question. PR6533 already counts general families by an exponential kernel lattice.", + "bottleneck_link": "Replace an exponential exact GL feasibility/counting subproblem by a dimension formula for two shared contacts, while retaining the prescribed-image coupling.", + "budget_minutes": 90, + "stop_rule": "Finish the closed proof, complete finite count census and independent controls. Do not infer native or physical admission.", + "outcome": "completed", + "evidence": "PROOF.md, count.py, literal.py and RESULT.json. 287431 exact contract counts,78 kernel comparisons and dimension120 product checks.", + "author": "Ali Romman with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance for proof, code, verification and prose. No subagents.", + "open_questions": [ + { + "question": "Can the count give an exact uniform sampler with a full resource bill?", + "why_it_matters": "A sampled completion can support native-map search.", + "first_step": "Sample the intersection term by its exact weight and then each lift.", + "blocked_by": "Sampling and random-bit complexity are not supplied." + }, + { + "question": "Does an actual native shared map fit this two-capacity contract?", + "why_it_matters": "GL counting alone does not supply signed/symplectic native work.", + "first_step": "Extract one exact caller fixed map and both capacities.", + "blocked_by": "No selected contact or complete physical invoice is bound here." + } + ], + "coordination": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19365878" +} diff --git a/research/two-capacity-completion-count/VERIFY.json b/research/two-capacity-completion-count/VERIFY.json new file mode 100644 index 0000000000..e3cdb38b15 --- /dev/null +++ b/research/two-capacity-completion-count/VERIFY.json @@ -0,0 +1,32 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-Werror", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "All normalized finite contract counts, F4 arithmetic, independent kernel counts, large product formulas and corruption controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-Werror", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "All normalized finite contract counts, F4 arithmetic, independent kernel counts, large product formulas and corruption controls." + } + ] +} diff --git a/research/two-capacity-completion-count/count.py b/research/two-capacity-completion-count/count.py new file mode 100644 index 0000000000..f82d2e9638 --- /dev/null +++ b/research/two-capacity-completion-count/count.py @@ -0,0 +1,112 @@ +"""Count two-capacity completions from exact quotient dimensions. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +The quotient criterion is by ToikY, PR6535. The counting factors are classical. +""" +from functools import lru_cache +from math import isqrt, prod + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def prime_power(q): + if type(q) is not int or q < 2: + return False + p = next((p for p in range(2, isqrt(q)+1) if q % p == 0), q) + while q % p == 0: + q //= p + return q == 1 + + +@lru_cache(maxsize=None) +def gaussian(n, k, q): + if k < 0 or k > n: + return 0 + k = min(k, n-k) + numerator = prod(q**(n-i)-1 for i in range(k)) + denominator = prod(q**(k-i)-1 for i in range(k)) + need(numerator % denominator == 0, 'Integral Gaussian coefficient') + return numerator // denominator + + +def injections(n, k, q): + return prod(q**n-q**i for i in range(k)) if 0 <= k <= n else 0 + + +def count_profile(q, n, u, a, b, s, c, d, t, k, ell, ec, ed, ecd, compatible=True): + """Use dimensions of an actual contract, with all three image tests recorded.""" + need(prime_power(q), 'Finite-field order') + need(all(type(x) is int and x >= 0 for x in (n,u,a,b,s,c,d,t,k,ell,ec,ed,ecd)), 'Nonnegative dimensions') + need(type(compatible) is bool and 0 <= u <= n, 'Fixed rank and compatibility flag') + j, tau = a+b-s, c+d-t + need(0 <= j <= min(a,b) and s <= n-u and 0 <= tau <= min(c,d) and t <= n-u, 'Quotient dimensions') + need(0 <= k <= j and 0 <= ell <= tau and 0 <= ecd <= min(ec,ed) + and max(ec,ed) <= u and ec+ed-ecd <= u, 'Kernel and fixed-image dimensions') + if not compatible or a > c or b > d or s > t or k > ell: + return 0 + need(j-k <= tau-ell, 'Rank of the prescribed common quotient') + h, alpha, beta = tau-j, a-j, b-j + common = injections(ell,k,q)*q**(ell*(j-k)) + extensions = 0 + for i in range(max(0,alpha-(c-tau)), min(alpha,h)+1): + extensions += (gaussian(h,i,q)*gaussian(c-tau,alpha-i,q) + * q**((h-i)*(alpha-i))*injections(alpha,alpha,q) + * injections(d-j-i,beta,q)*q**(i*beta)) + quotient = common * q**(j*(alpha+beta)) * extensions + lifts = q**(ecd*j+ec*alpha+ed*beta) + final = prod(q**n-q**i for i in range(u+s,n)) + return quotient*lifts*final + + +def contract(n, p, fixed, capacities, linear): + """Extract a profile over a prime field with the retained exact row reducer.""" + need(type(n) is int and n >= 0 and type(p) is int and p >= 2 + and all(p % d for d in range(2,isqrt(p)+1)), 'Prime-field contract') + need(len(capacities) == 2, 'Exactly two capacities') + def validate(rows): + need(all(len(r) == n and all(type(x) is int and 0 <= x < p for x in r) for r in rows), 'Canonical field vectors') + for pair in fixed: + need(len(pair) == 2, 'Fixed image pair') + validate(pair) + for pair in capacities: + need(len(pair) == 2, 'Capacity pair') + for rows in pair: + validate(rows) + def basis(rows): + z = linear['reduce_system'](n,[tuple(r)+(0,) for r in rows],p) + return tuple(r[:n] for r in z[0]) + def join(a,b): + return basis(a+b) + def meet(a,b): + return linear['annihilator'](n,linear['annihilator'](n,a,p)+linear['annihilator'](n,b,p),p) + def inside(a,b): + return len(join(a,b)) == len(b) + U = basis(tuple(x for x,y in fixed)); E = basis(tuple(y for x,y in fixed)) + need(len(U) == len(E) == len(fixed), 'Independent fixed injection basis') + def image(rows): + out=[] + for v in rows: + system = [tuple(x[i] for x,y in fixed)+(v[i],) for i in range(n)] + reduced = linear['reduce_system'](len(fixed),system,p) + need(reduced is not None, 'Vector belongs to fixed domain') + coeff=[0]*len(fixed) + for r,j in zip(*reduced): + coeff[j]=r[-1] + out.append(tuple(sum(coeff[j]*fixed[j][1][i] for j in range(len(fixed)))%p for i in range(n))) + return basis(tuple(out)) + (A,C),(B,D) = [(basis(tuple(a)),basis(tuple(b))) for a,b in capacities] + UA,UB,U0=meet(U,A),meet(U,B),meet(U,join(A,B)) + EC,ED=meet(E,C),meet(E,D);ECD=meet(EC,ED);Z=join(EC,ED) + compat=inside(image(UA),C) and inside(image(UB),D) and inside(image(U0),join(C,D)) + if not compat: + return 0, {'compatible':False} + a,b=len(A)-len(UA),len(B)-len(UB) + s=len(join(A,B))-len(U0);c,d=len(C)-len(EC),len(D)-len(ED) + t=len(join(C,D))-len(meet(E,join(C,D))) + k=len(meet(A,B))+len(meet(image(U0),Z))-len(UA)-len(UB) + ell=len(meet(C,D))-len(ECD) + values=[n,len(U),a,b,s,c,d,t,k,ell,len(EC),len(ED),len(ECD)] + return count_profile(p,*values),dict(zip(('n','u','a','b','s','c','d','t','k','ell','ec','ed','ecd'),values)) diff --git a/research/two-capacity-completion-count/inputs/pr6533-completion.py b/research/two-capacity-completion-count/inputs/pr6533-completion.py new file mode 100644 index 0000000000..75c4d75c21 --- /dev/null +++ b/research/two-capacity-completion-count/inputs/pr6533-completion.py @@ -0,0 +1,246 @@ +"""Exact joint capacity rank counts over small prime fields. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The kernel-subspace inversion is classical. +""" +from itertools import combinations, product +from functools import lru_cache + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def reduce_system(width, equations, p): + rows = [list(row) for row in equations] + pivots = [] + r = 0 + for j in range(width): + k = next((k for k in range(r, len(rows)) if rows[k][j] % p), None) + if k is None: + continue + rows[k], rows[r] = rows[r], rows[k] + scale = pow(rows[r][j] % p, -1, p) + rows[r] = [x*scale % p for x in rows[r]] + for k in range(len(rows)): + if k != r and rows[k][j] % p: + c = rows[k][j] % p + rows[k] = [(x-c*y) % p for x, y in zip(rows[k], rows[r])] + pivots.append(j) + r += 1 + if any(not any(row[:width]) and row[width] % p for row in rows): + return None + return tuple(tuple(row) for row in rows[:r]), tuple(pivots) + + +def rank(rows, p, width=None): + if width is None: + width = len(rows[0]) if rows else 0 + return len(reduce_system(width, [tuple(row)+(0,) for row in rows], p)[0]) + + +@lru_cache(maxsize=15) +def subspaces(n, p): + spaces = [] + for k in range(n+1): + for pivots in combinations(range(n), k): + free = [(i,j) for i in range(k) for j in range(pivots[i]+1,n) if j not in pivots] + for values in product(range(p), repeat=len(free)): + rows = [[int(j == pivots[i]) for j in range(n)] for i in range(k)] + for (i,j), x in zip(free, values): + rows[i][j] = x + spaces.append(tuple(tuple(row) for row in rows)) + return tuple(spaces) + + +@lru_cache(maxsize=None) +def gaussian(n, j, p): + if j < 0 or j > n: + return 0 + if j in (0,n): + return 1 + return gaussian(n-1,j-1,p)+p**j*gaussian(n-1,j,p) + + +def validate(n, p, equations): + require(type(n) is int and 0 <= n <= 4, 'dimension outside bounded API') + require(type(p) is int and p in (2,3,5), 'unsupported prime field') + require(type(equations) is tuple and all(type(row) is tuple and len(row) == n*n+1 + and all(type(x) is int and 0 <= x < p for x in row) for row in equations), + 'invalid affine equations') + + +def block_counts(rows, m, p, equations): + """Count the rank of the last m rows of a rows-by-m affine matrix.""" + width = rows*m + base = reduce_system(width,equations,p) + if base is None: + return {'rank_counts':[0]*(m+1),'kernel_incidence':[0]*(m+1)} + base = base[0] + incidence = [0]*(m+1) + for space in subspaces(m,p): + extra = [] + for vector in space: + for i in range(rows-m,rows): + row = [0]*(width+1) + row[i*m:(i+1)*m] = vector + extra.append(tuple(row)) + reduced = reduce_system(width,base+tuple(extra),p) + if reduced is not None: + incidence[len(space)] += p**(width-len(reduced[0])) + nullities = [0]*(m+1) + for j in range(m,-1,-1): + nullities[j] = incidence[j]-sum(gaussian(t,j,p)*nullities[t] for t in range(j+1,m+1)) + require(nullities[j] >= 0, 'negative rank count') + require(sum(nullities) == p**(width-len(base)), 'rank partition fails') + return {'rank_counts':list(reversed(nullities)), 'kernel_incidence':incidence} + + +def rank_counts(n, p, equations): + validate(n,p,equations) + return block_counts(n,n,p,equations) + + +def annihilator(n, vectors, p): + rows, pivots = reduce_system(n,[tuple(v)+(0,) for v in vectors],p) + free = [j for j in range(n) if j not in pivots] + basis = [] + for j in free: + v = [0]*n + v[j] = 1 + for row, pivot in zip(rows,pivots): + v[pivot] = -row[j] % p + basis.append(tuple(v)) + return tuple(basis) + + +def capacity_equations(n,p,fixed=(),capacities=()): + validate(n,p,()) + def vector(v): + require(type(v) is tuple and len(v) == n and all(type(x) is int and 0 <= x < p for x in v), + 'invalid vector') + require(type(fixed) is tuple and type(capacities) is tuple,'immutable contract required') + equations = [] + for pair in fixed: + require(type(pair) is tuple and len(pair) == 2,'invalid fixed pair') + source, target = pair + vector(source); vector(target) + for i in range(n): + row = [0]*(n*n)+[target[i]] + row[i*n:(i+1)*n] = source + equations.append(tuple(row)) + for pair in capacities: + require(type(pair) is tuple and len(pair) == 2,'invalid capacity pair') + sources, targets = pair + require(type(sources) is tuple and type(targets) is tuple,'immutable subspaces required') + for v in sources+targets: + vector(v) + for a in sources: + for b in annihilator(n,targets,p): + equations.append(tuple(b[i]*a[j] % p for i in range(n) for j in range(n))+(0,)) + return tuple(equations) + + +def construct_block(rows,m,p,equations,target_rank=None): + counts = block_counts(rows,m,p,equations)['rank_counts'] + if target_rank is not None: + require(type(target_rank) is int and 0 <= target_rank <= m,'invalid target rank') + if not any(counts): + return None + if target_rank is None: + target_rank = max(i for i,c in enumerate(counts) if c) + if counts[target_rank] == 0: + return None + current = equations + entries = [] + for j in range(rows*m): + for value in range(p): + row = tuple(int(i == j) for i in range(rows*m))+(value,) + candidate = current+(row,) + if block_counts(rows,m,p,candidate)['rank_counts'][target_rank]: + current = candidate + entries.append(value) + break + else: + raise ValueError('positive fiber has no next entry') + matrix = tuple(tuple(entries[i*m:(i+1)*m]) for i in range(rows)) + require(rank(matrix[rows-m:],p,m) == target_rank,'constructor rank mismatch') + require(all((sum(x*y for x,y in zip(row[:-1],entries))-row[-1]) % p == 0 + for row in equations),'constructor violates affine equations') + return matrix + + +def construct(n,p,equations,target_rank=None): + validate(n,p,equations) + return construct_block(n,n,p,equations,target_rank) + + +def apply(matrix,vector,p): + return tuple(sum(x*y for x,y in zip(row,vector)) % p for row in matrix) + + +def inverse(matrix,p): + n=len(matrix) + columns=[] + for j in range(n): + result=reduce_system(n,[tuple(row)+(int(i==j),) for i,row in enumerate(matrix)],p) + require(result is not None and len(result[0])==n,'singular chart') + columns.append(tuple(row[-1] for row in result[0])) + return tuple(tuple(columns[j][i] for j in range(n)) for i in range(n)) + + +def prepare_fixed(n,p,fixed,capacities): + require(type(n) is int and 0 <= n <= 12,'ambient dimension outside bounded API') + require(type(p) is int and p in (2,3,5),'unsupported prime field') + require(type(fixed) is tuple and type(capacities) is tuple,'immutable contract required') + def vector(v): + require(type(v) is tuple and len(v)==n and all(type(x) is int and 0 <= x < p for x in v),'invalid vector') + for pair in fixed: + require(type(pair) is tuple and len(pair)==2,'invalid fixed pair') + vector(pair[0]);vector(pair[1]) + source=tuple(pair[0] for pair in fixed);target=tuple(pair[1] for pair in fixed) + u=len(fixed);m=n-u + require(rank(source,p,n)==u and rank(target,p,n)==u,'fixed data must be an injection on a basis') + require(0 <= m <= 4,'unfixed dimension exceeds four') + def extend(basis): + basis=list(basis) + for j in range(n): + e=tuple(int(i==j) for i in range(n)) + if rank(basis+[e],p,n)>len(basis):basis.append(e) + return tuple(tuple(basis[j][i] for j in range(n)) for i in range(n)) + P,Q=extend(source),extend(target);Pi=inverse(P,p) + equations=[] + for pair in capacities: + require(type(pair) is tuple and len(pair)==2,'invalid capacity pair') + A,B=pair + require(type(A) is tuple and type(B) is tuple,'immutable subspaces required') + for v in A+B:vector(v) + for a in A: + x=apply(Pi,a,p) + for b in annihilator(n,B,p): + y=tuple(sum(b[i]*Q[i][j] for i in range(n))%p for j in range(n)) + rhs=-sum(y[i]*x[i] for i in range(u))%p + equations.append(tuple(y[i]*x[u+j]%p for i in range(n) for j in range(m))+(rhs,)) + return u,m,Q,Pi,tuple(equations) + + +def fixed_rank_counts(n,p,fixed,capacities=()): + u,m,_,_,eq=prepare_fixed(n,p,fixed,capacities) + result=block_counts(n,m,p,eq) + return {'rank_counts':[0]*u+result['rank_counts'], 'fixed_dimension':u, + 'quotient_dimension':m, 'kernel_incidence':result['kernel_incidence']} + + +def fixed_construct(n,p,fixed,capacities=(),target_rank=None): + u,m,Q,Pi,eq=prepare_fixed(n,p,fixed,capacities) + if target_rank is not None: + require(type(target_rank) is int and 0 <= target_rank <= n,'invalid target rank') + if target_rank R → 0. + +For v∈T choose c0∈C,d0∈D with π(c0)=π(d0)=v and define +rho(v)=[c0−d0]. This difference lies in E∩(C+D). Changing either representative +changes it by an element of Z, so rho is well-defined and linear. Every +member e∈E∩(C+D) can be written c0−d0, so rho is onto. If c0−d0=zC+zD with +zC∈E∩C,zD∈E∩D, then c0−zC=d0+zD lies in C∩D and has coset v. Thus ker rho=H. + +In V/U put Abar=(A+U)/U, Bbar=(B+U)/U and J=Abar∩Bbar. Under the three +compatibilities in the criterion, define + + delta:J→R, delta(a0+U=b0+U)=[h(a0−b0)], a0∈A,b0∈B. + +The difference belongs to U0. Replacing a0 by another representative in A +changes it by UA, and similarly for B and UB. Their prescribed images lie in +E∩C and E∩D, hence in Z; delta is therefore well-defined and linear. + +Its image is precisely the image of h(U0) in R. Indeed every u∈U0 has a +representation a0−b0 with a0∈A,b0∈B, and these define a member of J. Therefore + + rank delta = dim U0−dim X, + dim J = a+b−s = dim I+dim U0−dim UA−dim UB, + dim ker delta = k, dim H = ell. + +These formulas also show k is nonnegative under the stated compatibilities. +No characteristic restriction or finite-field genericity is used. + +## Necessity + +If g exists, its restriction to UA, UB and U0 gives the three compatibility +conditions. It induces an injective quotient map from V/U to W/E. This map +sends Abar into Cbar, Bbar into Dbar and their sum into Cbar+Dbar, giving the +three dimension capacities. + +Restrict that quotient injection to J, calling it j0:J→T. For representatives +as above, g(a0)−g(b0)=h(a0−b0), so rho∘j0=delta. In particular j0 maps +ker delta injectively into H=ker rho. Consequently k≤ell. This proves every +condition is necessary. + +## An injective common lift + +Conversely assume all seven conditions. Split J=ker delta⊕J1. Inject +ker delta into H, which is possible because k≤ell. Since rho is onto, +lift delta(J1) through a linear section of rho. On J1 the map delta is +injective, so these lifted vectors are independent modulo H. Together these +two choices give an injective map j0:J→T with rho∘j0=delta. Write L=j0(J) +and j=dim J. In particular j≤dim T. + +We next extend j0 to an injection fbar:Abar+Bbar→Cbar+Dbar respecting both +capacities. Let tau=dim T. Choose complements of T in Cbar and Dbar. Their +images in (Cbar+Dbar)/T are disjoint, of dimensions c−tau and d−tau. +After fixing L, the unused common space has dimension tau−j. The additional +source dimensions are a−j and b−j. Their minimum requirements on this common +space are + + rA=max(0,a−j−c+tau), rB=max(0,b−j−d+tau). + +The three capacity inequalities imply rA+rB≤tau−j. If both are positive, +this is exactly a+b−j≤c+d−tau, namely s≤t. If only one is positive, its bound +follows from a≤c or b≤d. Assign disjoint basis slices of T/L of sizes rA,rB, +and use the separate complements for the rest. Lifting these choices gives +fbar. This is an ordinary basis construction over every field, including +small finite fields; it does not require a generic choice to exist. + +## Lift and glue with the prescribed map + +Choose paired representatives a_j∈A,b_j∈B for a basis of J, so a_j−b_j∈U. +Choose representatives c_j∈C,d_j∈D of fbar(j). The equality +rho(fbar(j))=delta(j) says + + c_j−d_j−h(a_j−b_j) ∈ Z. + +Write that discrepancy as zC+zD with zC∈E∩C,zD∈E∩D. Replace c_j by c_j−zC +and d_j by d_j+zD. Their quotient images stay unchanged and now +c_j−d_j=h(a_j−b_j) exactly. + +Choose complements to UA in A and UB in B whose images split into the common +J basis and separate quotient complements. On U use h, on each paired +representative use the adjusted c_j,d_j, and on the separate complements use +arbitrary lifts in C or D of the corresponding fbar vectors. The displayed +relations ensure the definitions agree on U+A+B; all cross-relations modulo +U occur in J, while the relations already in U are prescribed by h. Thus this +defines a linear map f:U+A+B→W with f|U=h, f(A)⊆C, f(B)⊆D. + +Its quotient map is fbar. If f(v)=0, quotient injectivity forces v∈U, and +injectivity of h then forces v=0. Finally extend the domain and image bases +to bases of V and W. The resulting isomorphism is the requested g. This +proves sufficiency and describes a constructive basis procedure. The finite +software below checks the criterion; it is not a production general-field +implementation of this construction. + +## An oblique three-dimensional obstruction + +Over any field take V=W=F³, U=E=, h=identity, and + + A=, B=, + C=, D=. + +The individual, sum and ordinary source-intersection dimensions pass, as do +all three prescribed-image compatibilities and the naive common quotient +capacity dim J≤dim T. Here a=b=s=c=d=t=1, dim J=dim T=1. But +Z=, h(U0)=, delta=0 and H=0. Hence k=1>ell=0. + +Directly, any joint completion would send e3 to D, while e1+e3 must go to C +and e1 is fixed. Thus g(e3) lies in C∩D=⊆E, contradicting injectivity +because e3 is outside U. Each individual request is feasible: choose the +image of e3 outside E in the corresponding plane. The failure is genuinely +the coupled prescribed-map condition, not the earlier flag obstruction. + +The opposite calibration is also useful. In F² take U=, h=identity, +A=C=, B=D=. The identity is a completion. Here dim J=1 and H=0, +but delta has rank1, so ker delta=0 and the correct test passes. Requiring +all of J to fit in H would incorrectly reject this case. + +## Reuse checks and finite evidence scope + +For U=0 the criterion reduces to the individual, sum and intersection +dimension conditions for two subspace capacities. For C⊆D, rho=0 and +H=T=πC; the kernel condition follows from a≤c, and the remaining tests are +exactly the two-stage nested cumulative-source tests of PR6489. If D=W, +the criterion reduces to the one-capacity prescribed-map contract of PR5020. +These are algebraic sanity checks, not new predecessor results. + +Every injective h of rank r can be put into the standard identity on the +first r coordinates by independent domain and codomain basis changes. The +finite checks fix that canonical h and vary ALL FOUR subspaces. This covers +all instances in each stated finite domain up to those basis changes; it is +not a census counting every differently labelled prescribed h. + +The primary uses row reduction and precomputed subspace sums/intersections. +The separate checker uses literal vector sets and complete invertible-matrix +enumeration, with no primary or predecessor executable imports. Their finite +agreements corroborate the algebra; the all-field conclusion rests on the +proof above. Exact finite census sizes and controls are retained in the receipts. + +## Attribution and limits + +Nick Petalas/6489 supplied the nested theorem and explicit two-nonnested-target +question. Brian/JoyboyBrian/5020 supplied the one-capacity question; Cao Yifan/ +intqwq/4610 supplied the native-map caller context. Retain Nick Petalas/4919, +codyw912/4735, Cinna Davis, Dugongue, zxv, Jacob Alan Sussman and the source +native/compiler lineage. Quotients, linear lifting and basis extension are +classical; no general literature-priority claim is made. + +This is unrestricted GL feasibility. It supplies neither a symplectic/native +operator nor an absolute phase, causal access, dirty restoration, basis +preparation, delivery, productive debit or complete paid invoice. Precision, +stock, tapes, compiler, outer admission and all five framework assumptions +remain open. There is no new kappa or selected-frontier change, human acceptance +or formal proof-kernel certification. diff --git a/research/two-capacity-completion-count/literal.py b/research/two-capacity-completion-count/literal.py new file mode 100644 index 0000000000..7a8f7f1351 --- /dev/null +++ b/research/two-capacity-completion-count/literal.py @@ -0,0 +1,85 @@ +"""Enumerate literal vector sets and GL actions, independently of the formula. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +""" +from itertools import product + + +def universe(n,q): + vec=list(product(range(q),repeat=n));ids={x:i for i,x in enumerate(vec)} + def plus(a,b): + return a^b if q==4 else (a+b)%q + def times(a,b): + if q!=4: + return a*b%q + z=0 + while b: + if b&1:z^=a + b>>=1;a<<=1 + if a&4:a^=7 + return z + add=[[ids[tuple(plus(a,b) for a,b in zip(x,y))] for y in vec] for x in vec] + scale=[[ids[tuple(times(c,a) for a in x)] for x in vec] for c in range(q)] + zero=ids[(0,)*n];unit=[ids[tuple(int(i==j) for j in range(n))] for i in range(n)] + def span(basis): + s={zero} + for v in basis: + s={add[x][scale[c][v]] for x in s for c in range(q)} + return frozenset(s) + spaces={frozenset([zero]):()};queue=[frozenset([zero])] + for s in queue: + for v in range(q**n): + if v not in s: + b=spaces[s]+(v,);t=span(b) + if t not in spaces:spaces[t]=b;queue.append(t) + sets=sorted(spaces,key=lambda x:(len(x),sorted(x))) + basis=[spaces[x] for x in sets];index={x:i for i,x in enumerate(sets)} + masks=[sum(1<1 and name not in factor_witnesses: + value=C['count_profile'](*vals);need(value%factor==0 and value//factor!=value,'Omitted factor changes exact count') + factor_witnesses[name]=dict(profile=list(vals),count=value,mutant=value//factor) + need(len(factor_witnesses)==4,'All lift and extension omission controls') + bad=[lambda:C['count_profile'](6,1,0,0,0,0,0,0,0,0,0,0,0,0), + lambda:C['count_profile'](2,-1,0,0,0,0,0,0,0,0,0,0,0,0), + lambda:C['count_profile'](2,1,0,1,1,0,1,1,1,0,0,0,0,0), + lambda:C['contract'](2,4,(),(((),()),((),())),R), + lambda:C['contract'](2,2,(((1,0),(0,0)),),(((),()),((),())),R), + lambda:C['contract'](2,2,(),(((),()),),R), + lambda:C['contract'](2,2,(),((((2,0),),()),((),())),R)] + for f in bad:reject(f) + return dict(status='PASS_TWO_CAPACITY_COMPLETION_COUNT',census=census,contracts=total,positive=positive, + distinct_positive_profiles=len(profile_controls),kernel_oracle_checks=kernel_checks,nonzero_fixed_maps=arbitrary_maps, + named_controls=named,large_formulas=large,large_vector_contracts=large_vectors, + omitted_factor_controls=factor_witnesses,invalid_controls=len(bad),source_corruptions=len(pins), + scope='All-finite-field two-capacity count; executable prime-field extraction and literal F4 corroboration. No native or kappa claim.') + + +if __name__=='__main__': + value=run() + if '--write-result' in sys.argv:(P/'RESULT.json').write_text(json.dumps(value,sort_keys=True,indent=2)+'\n') + else:need(value==json.loads((P/'RESULT.json').read_text()),'Exact result receipt') + print(json.dumps({k:value[k] for k in ('status','contracts','positive','distinct_positive_profiles','kernel_oracle_checks','invalid_controls')},sort_keys=True))