diff --git a/research/edge-matching-image-bound/CREDITS.md b/research/edge-matching-image-bound/CREDITS.md new file mode 100644 index 0000000000..e50c91ad11 --- /dev/null +++ b/research/edge-matching-image-bound/CREDITS.md @@ -0,0 +1,45 @@ +# Sources and credit + +Ali Romman prepared this proof and verifier with substantial OpenAI +Codex assistance. New work is Apache-2.0. No independent human or +formal proof-kernel review is claimed. + +- Ali Romman's [PR #7690](https://github.com/CrocSwap/integer-mult-bounds/pull/7690), + head `b725be51349cce4e0a262c76233838992042dd62`, supplies the disjoint + diagonal-relation proof, restated here with the unit-free restriction + removed. The [exact proof](https://github.com/aliromman/integer-mult-bounds/blob/b725be51349cce4e0a262c76233838992042dd62/research/no-edge-total-image-bound/PROOF.md) + credits CubeJerry's earlier support argument and unpaidmoon's + normal/column blocks. Matrix, basis, lift, orbit and subspace routines + are reused from its [verifier](https://github.com/aliromman/integer-mult-bounds/blob/b725be51349cce4e0a262c76233838992042dd62/research/no-edge-total-image-bound/verify.py). +- Ali Romman's [PR #7691](https://github.com/CrocSwap/integer-mult-bounds/pull/7691), + head `69e70b1426c32b19da8334930815800a2c95ffca`, supplies the + column-support invariant lemma, restated with proof. Read its + [exact proof](https://github.com/aliromman/integer-mult-bounds/blob/69e70b1426c32b19da8334930815800a2c95ffca/research/no-edge-dim5-extremal-classification/PROOF.md). +- CubeJerry's [PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782), + head `685457252b51b9c7932ece363365bdf0b12c9c31`, supplies the general + edge-quotient bound, the exact five-projector two-edge example and its + irreducible normal form. Read its [exact proof](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/PROOF.md). + The author notice states that the work was prepared for @CubeJerry + with substantial OpenAI assistance. It credits Nick Petalas's + [PR #5921](https://github.com/CrocSwap/integer-mult-bounds/pull/5921) + for the binary fiber theorem. That fiber argument is proved again + here. The five-projector witness is checked without changing its masks. +- Nick Petalas's [PR #6785](https://github.com/CrocSwap/integer-mult-bounds/pull/6785), + head `5dbf2c05220bea53d84b510efe5910c4cec8f182`, proves the one-edge, + pattern-three irreducible bound four. This is a prior special case, + not a new result here. The source notice gives the author name: + [exact proof](https://github.com/petalas/integer-mult-bounds/blob/5dbf2c05220bea53d84b510efe5910c4cec8f182/research/one-edge-pattern-reducibility/PROOF.md). +- CubeJerry's [PR #6838](https://github.com/CrocSwap/integer-mult-bounds/pull/6838) + already proves the universal pattern-three total bound six. Its + [exact proof](https://github.com/CubeJerry/integer-mult-bounds/blob/f177c4f27e63dfa2e886033bb6a4e2dcd91f40b6/research/bit-zero-edge-image-bound/PROOF.md) + is context, not an executable dependency. + +The new result is the all-width edge-matching refinement, its total +equality exclusion for irreducible complete pools, and sharp all-k +total and irreducible maxima. The earlier no-edge theorem and each +known three-dimensional example retain their original credit. + +No external source file is read at runtime. Mathematical arguments +needed for the new result are included in PROOF.md. The two entries +in SOURCES.json bind the selected state and task catalogue on main; +they are provenance records, not proof premises. diff --git a/research/edge-matching-image-bound/PROOF.md b/research/edge-matching-image-bound/PROOF.md new file mode 100644 index 0000000000..29ca8ac173 --- /dev/null +++ b/research/edge-matching-image-bound/PROOF.md @@ -0,0 +1,307 @@ +# Sharp linear image bounds with matrix-unit edges + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +This is a scoped written proof with exact finite checks. Independent human +and formal-kernel review are not claimed. + +## 1. Statement + +Work over F2 at any finite ambient width W. Let C be a collection of +rank-one idempotents `P=xy^T`, with `y^T x=1` and `off(P)!=0`. Let H be +the span of their off-diagonal patterns, of dimension k. Let V be their +joint image, of dimension n. The collection need not have independent +images and need not contain every possible lift of H. + +Make an undirected graph on the coordinate indices. Put an edge {a,b} +in this graph if H contains `E_ab` or `E_ba`. Let nu be its maximum +matching size: the largest number of edges with disjoint endpoint pairs. +Let e count the directed matrix units in H. Then `nu<=e<=k`. + +**Theorem.** + +``` +2n <= 3k+nu. (total image) +2n <= 3k+nu-1, if n>0 and C|V is irreducible. +``` + +The total bound `floor((3k+nu)/2)` is attained for every integer pair +`k>=1`, `0<=nu<=k`, by a complete pool. Thus the universal total maximum +is `2k`. The universal irreducible maximum is `2k-1`, attained for every +`k>=1` by a complete pool. The theorem does not assert that the refined +irreducible bound is sharp for every fixed pair (k,nu), or that the total +bound is sharp for a prescribed edge graph. + +Coordinate projectors are excluded. If they are allowed, arbitrarily +many independent images can have pattern dimension zero. + +The disjoint-relation method comes from Ali Romman's +[PR #7690](https://github.com/CrocSwap/integer-mult-bounds/pull/7690), +[exact proof](https://github.com/aliromman/integer-mult-bounds/blob/b725be51349cce4e0a262c76233838992042dd62/research/no-edge-total-image-bound/PROOF.md). +Here two-member circuits are allowed. Their endpoint matching supplies +the new term nu. The proof below states the required arguments in full. + +## 2. Disjoint diagonal relations + +Choose n projectors `P_i=x_i y_i^T` whose images form a basis of V. Their +matrices are independent: a zero linear combination, read one column at +a time in the independent x_i, forces each coefficient times y_i to be +zero. Let their pattern rank be k0, with `k0<=k`. The space K of diagonal +linear combinations has dimension `d=n-k0`. + +Choose a basis of K. Let `r_i in F2^d` be the coefficient character of +P_i: a parameter s in K has coefficient `s dot r_i` at P_i. At any fixed +ambient column b, diagonal matrices have column span of dimension at +most one. Independence of the x_i therefore implies that + +``` +s -> ((s dot r_i) y_i(b))_i +``` + +has rank at most one. Hence all nonzero r_i for which `y_i(b)=1` are +equal. This is where the binary field is used. + +Group indices by their nonzero character c. The sum Q_c of the projectors +in each group is diagonal. To see this at column b, either no member of +the group has `y_i(b)=1`, or c is the sole nonzero active character there. +In the latter case choose s with `s dot c=1`; the column of Q_c is the +same as that of the corresponding diagonal combination. + +Every Q_c is nonzero, since the P_i are independent. The indicator vectors +of these groups are independent elements of the d-dimensional relation +space. Thus there are at most d groups. The characters r_i span F2^d, +so there are at least d groups. There are exactly d, their characters +are independent, and their indicators span the entire relation space. +Indices with zero character are free members. + +Write S_c for the active coordinate set of Q_c. These sets are disjoint. +If a column contains the nonzero character c, the sum of its participating +independent images is nonzero. Thus it is an active column of Q_c. +Consequently every y_i in that group is supported on S_c. Moreover +the coordinate span of S_c is contained in the group's image space U_c, +since `Q_c e_b=e_b` there. If the group has m members, then + +``` +1 <= |S_c| <= m, |S_c| = m (mod 2). +``` + +The rank inequality and trace give these two facts. The U_c for distinct +groups, and the free image lines, form a direct sum, since all x_i are +independent. No group has size one: that would be a zero pattern. + +## 3. Two-member groups form an edge matching + +For a two-member group the preceding rank and parity facts force +`|S_c|=2`. Its image space is exactly that coordinate plane, and both +covectors are supported there. The two projectors have the same nonzero +off-diagonal pattern, because their sum is diagonal. + +In two binary coordinates, idempotence is +`x_a y_a + x_b y_b=1`. Both off-diagonal entries cannot be one: that +would force all four factor entries to be one and give trace zero. +Thus the common pattern is one matrix unit, say E_ab. Its two lifts are + +``` +e_a(e_a+e_b)^T, (e_a+e_b)e_b^T. +``` + +Their active set is {a,b}. Distinct two-member groups have disjoint +active sets. If t counts these groups, they therefore give a matching +in H, and `t<=nu`. + +All other groups have at least three members. Include the nonnegative +number of free members to obtain + +``` +n >= 2t+3(d-t) = 3d-t. +2n <= 3k0+t <= 3k+nu. +``` + +This proves the total bound for every collection. In particular it +applies to the complete pool C(H) of all noncoordinate lifts in H. + +## 4. Total equality is reducible + +Suppose `n>0` and `2n=3k+nu`. Every inequality in Section 3 is then an +equality. Hence `k0=k`, `t=nu`, there are no free members, and every group +has size two or three. The selected pattern span is all of H. + +First record a full-pool invariant. If H has zero columns outside a set +S, then + +``` +K_S = V intersect {z : z|S=0} +``` + +is invariant under every projector in C. Indeed, a covector supported +on S kills K_S. If `y_j=1` outside S, the zero off-column j forces +`x=e_j`; its image is in K_S. If the coordinate span of S is contained +in V and `0<|S|=2`, set `t=k-1`. Take t disjoint edge pairs, on coordinates +`(a_i,b_i)`. Let `h_x=sum e_b_i` and `h_y=sum e_a_i`. Add a fresh +coordinate f and the link + +``` +B = (h_x+e_f)(h_y+e_f)^T. +``` + +It is idempotent, since its factor pairing is one. Its pattern is +independent of the t old edge patterns, because it has entries that +join f to the old blocks. Thus the pattern dimension is k. Its two +cross rectangles fix both factors of every lift in its pattern coset: +an entry in column f forces y_f=1, an entry in row f forces x_f=1, +and the remaining entries in that row and column fix h_x and h_y. +Only B occurs in that coset. A pattern in the old span has a lift +only when it is one individual edge. Therefore the complete pool has +exactly `2t+1=2k-1` members, with independent images. + +No pattern in the new coset is a matrix unit, since it retains both +nonzero cross rectangles. Hence `e=nu=t`. + +Use the 2t old images and e_f as a basis of the joint image. The old +projectors become the first 2t coordinate projectors. The link becomes +the all-one matrix of odd size `2t+1`. This family is irreducible. +For a nonzero invariant subspace, a vector with an old coordinate +nonzero gives that coordinate vector and then the all-one vector. +If all its old coordinates vanish, it contains e_f, which also gives +the all-one vector. The old coordinate projectors then give all old +basis vectors; subtraction gives e_f. The subspace is the whole image. + +At k=3 this is exactly CubeJerry's five-projector witness in +[PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782), +[Section 5](https://github.com/CubeJerry/integer-mult-bounds/blob/685457252b51b9c7932ece363365bdf0b12c9c31/research/bit-three-relation-core/PROOF.md). +That instance and its irreducibility are prior work. The contribution +here is the all-k bound and attaining family, with the matching refinement. + +## 7. Relation to earlier bounds and evidence + +CubeJerry's cited edge-quotient bound is +`n<=dim(E)+2^(k-e)-1`, where E spans all edge endpoints. It can still +be stronger for a specified edge graph. Take the minimum of valid +bounds; the new matching bound does not replace that graph-sensitive +information. Its universal consequence `n<=2k` removes exponential +growth with k. The dimension-three universal total bound six was +already proved in [PR #6838](https://github.com/CrocSwap/integer-mult-bounds/pull/6838). + +At `(k,nu)=(3,1)` the strict bound gives n<=4. Nick Petalas proved the +one-edge instance in [PR #6785](https://github.com/CrocSwap/integer-mult-bounds/pull/6785), +[exact proof](https://github.com/petalas/integer-mult-bounds/blob/5dbf2c05220bea53d84b510efe5910c4cec8f182/research/one-edge-pattern-reducibility/PROOF.md). +The present result applies to other edge graphs with matching number +one as well. At nu=0 it recovers the prior no-edge bound. + +The verifier checks all 224036 image-basis collections of sizes one +through three at widths three and four. Of these, 202057 have nonzero +patterns. It checks the entire disjoint relation code, the two-member +edge fibers, the endpoint matching and the bound for each. It also +enumerates all 2825 pattern spaces at width three. Raw rank-one scans +and separate literal-pattern lifting give the same complete pools. +All nonzero-vector orbit closures test irreducibility there; 1166 pools +are irreducible and satisfy the strict bound. + +The exact receipt includes all 65 total attaining families with +`1<=k<=10`, `0<=nu<=k`, and eight irreducible families with `1<=k<=8`. +Every nonzero pattern is lifted. The irreducible fixtures have exact +star/Gram certificates; those of image dimension at most nine also +pass all nonzero-vector orbit checks. Controls include overlapping +edges, the unchanged prior five-projector witness, coordinate +projectors, a column-triple equality case, and an orthogonal triple +whose extra edge prevents total equality. + +The finite checks corroborate the proof. They do not enumerate all +ambient embeddings. No paid-word relation lattice, coordinate-call +reduction, native operation, dirty-state restoration, complete invoice, +selected-frontier change or improvement in kappa is supplied. All five +selected assumptions remain. + +## Open next questions + +Can a legal scalar word use the all-k attaining irreducible family and +have target rank greater than paid rank? State its alphabet, integral +relation lattice, endpoint coordinates and dirty-state requirements +before a word search. The pool bounds alone give none of these data. diff --git a/research/edge-matching-image-bound/README.md b/research/edge-matching-image-bound/README.md new file mode 100644 index 0000000000..81fdaaa4a3 --- /dev/null +++ b/research/edge-matching-image-bound/README.md @@ -0,0 +1,64 @@ +# Edge matching bounds for binary projector images + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. + +For binary rank-one idempotents with nonzero off-diagonal patterns, +let k be the pattern dimension and nu the maximum matching size of +the matrix-unit edge graph. The joint-image dimension n satisfies +`2n<=3k+nu`. A nonzero irreducible image satisfies `2n<=3k+nu-1`. + +The total bound `floor((3k+nu)/2)` is attained for every `k>=1` and +`0<=nu<=k`. The universal total maximum is `2k`. The universal +irreducible maximum is `2k-1`, attained at every `k>=1`. + +Read [PROOF.md](PROOF.md) for the full argument, [RESULT.json](RESULT.json) +for the exact finite evidence, [CREDITS.md](CREDITS.md) for source roles +and [TASK.json](TASK.json) for the scope and family decision. The proof +allows arbitrary collections. The sharp examples are complete pools. + +This extends the disjoint-relation method of +[PR #7690](https://github.com/CrocSwap/integer-mult-bounds/pull/7690) +to spaces that contain matrix units. It gives linear all-k bounds. +The earlier edge-quotient bound and three-dimensional sharp example +in [PR #6782](https://github.com/CrocSwap/integer-mult-bounds/pull/6782) +remain prior work. Their graph-sensitive bound can be smaller for a +specified graph. Use both bounds where their hypotheses hold. + +## Reproduce + +Use CPython 3.12 with its standard library, from the repository root. + +```sh +python3.12 -I -W error -B research/edge-matching-image-bound/verify.py +python3.12 -I -W error -B -O research/edge-matching-image-bound/verify.py +python3.12 -B scripts/research_package.py --package research/edge-matching-image-bound +``` + +Expected markers are `PASS_EDGE_MATCHING_IMAGE_BOUND` and +`PASS_REGISTERED_RESEARCH_PACKAGE`. The verifier compares all computed +results with the committed receipt and writes no file. + +It checks 224036 image-basis collections, all 2825 pattern spaces at +width three, 65 total attaining families and eight irreducible families. +The latter two sets cover 20917 nonzero patterns. Separate raw scans +and pattern lifts agree on complete pools at width three. The tests +include extra-edge and coordinate-projector controls. All claims at +unbounded width rest on the written proof. + +## Limits + +There is no claim of a sharp irreducible bound for every fixed (k,nu), +or of total sharpness for a specified edge graph. Coordinate projectors +are excluded. No paid BIT word, native operator, complete invoice or +new kappa is supplied. The selected frontier and all five assumptions +remain unchanged. Independent human and formal-kernel review are +unclaimed. Selected cold replay, full predecessor package replays, +Lean and Docker are not part of this package's checks. + +## Open next questions + +Can the attaining irreducible family support a legal paid word with +target rank above paid rank? First state the operation alphabet, +relation lattice, endpoint basis, all counted roles and native interface. +The existing five-dimensional word obstruction in PR #6782 must be +compared before any larger-core word search. diff --git a/research/edge-matching-image-bound/RESULT.json b/research/edge-matching-image-bound/RESULT.json new file mode 100644 index 0000000000..b4b9b5a64e --- /dev/null +++ b/research/edge-matching-image-bound/RESULT.json @@ -0,0 +1,5561 @@ +{ + "status": "PASS_EDGE_MATCHING_IMAGE_BOUND", + "scope": "Binary rank-one idempotents with nonzero patterns; arbitrary width and pattern dimension.", + "claims": { + "total": "2 dim(V) <= 3k+nu; dim(V) <= 2k", + "irreducible": "2 dim(V) <= 3k+nu-1; dim(V) <= 2k-1", + "sharpness": "Total bound for every (k,nu); universal irreducible bound for every k>=1." + }, + "small_image_basis_censuses": [ + { + "width": 3, + "maximum_n": 3, + "counts": { + "collections": 2156, + "nonzero_patterns": 1555, + "total_equality": 9, + "with_pair_circuit": 96 + }, + "circuit_size_counts": { + "[2]": 96, + "[3]": 24, + "[]": 1435 + } + }, + { + "width": 4, + "maximum_n": 3, + "counts": { + "collections": 221880, + "nonzero_patterns": 200502, + "total_equality": 28, + "with_pair_circuit": 1140 + }, + "circuit_size_counts": { + "[2]": 1140, + "[3]": 112, + "[]": 199250 + } + } + ], + "width_three_complete_pools": { + "counts": { + "empty_pools": 336, + "irreducible": 1166, + "spaces": 2825, + "total_equality": 9 + }, + "profile": { + "(1, 0, 1, True)": 13, + "(1, 1, 2, False)": 6, + "(2, 0, 1, True)": 217, + "(2, 0, 2, False)": 48, + "(2, 0, 3, False)": 3, + "(2, 1, 2, False)": 117, + "(2, 1, 3, False)": 48, + "(2, 1, 3, True)": 6, + "(3, 0, 1, True)": 274, + "(3, 0, 2, False)": 213, + "(3, 0, 2, True)": 32, + "(3, 0, 3, False)": 67, + "(3, 0, 3, True)": 6, + "(3, 1, 2, False)": 210, + "(3, 1, 3, False)": 369, + "(3, 1, 3, True)": 146, + "(4, 0, 1, True)": 4, + "(4, 0, 2, False)": 27, + "(4, 0, 2, True)": 18, + "(4, 0, 3, False)": 41, + "(4, 0, 3, True)": 30, + "(4, 1, 2, False)": 18, + "(4, 1, 3, False)": 156, + "(4, 1, 3, True)": 356, + "(5, 0, 3, True)": 1, + "(5, 1, 3, True)": 62, + "(6, 1, 3, True)": 1 + } + }, + "sharp_total_families": [ + { + "k": 1, + "nu": 0, + "width": 3, + "pairs": [ + [ + 1, + 7 + ] + ], + "certificate": { + "n": 1, + "k": 1, + "nu": 0, + "diagonal_dimension": 0, + "circuit_sizes": [], + "active_supports": [], + "pair_circuits": 0, + "free_projectors": 1 + }, + "patterns_checked": 1 + }, + { + "k": 1, + "nu": 1, + "width": 2, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ] + ], + "certificate": { + "n": 2, + "k": 1, + "nu": 1, + "diagonal_dimension": 1, + "circuit_sizes": [ + 2 + ], + "active_supports": [ + 3 + ], + "pair_circuits": 1, + "free_projectors": 0 + }, + "patterns_checked": 1 + }, + { + "k": 2, + "nu": 0, + "width": 3, + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ] + ], + "certificate": { + "n": 3, + "k": 2, + "nu": 0, + "diagonal_dimension": 1, + "circuit_sizes": [ + 3 + ], + "active_supports": [ + 7 + ], + "pair_circuits": 0, + "free_projectors": 0 + }, + "patterns_checked": 3 + }, + { + "k": 2, + "nu": 1, + "width": 5, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 28 + ] + ], + "certificate": { + "n": 3, + "k": 2, + "nu": 1, + "diagonal_dimension": 1, + "circuit_sizes": [ + 2 + ], + "active_supports": [ + 3 + ], + "pair_circuits": 1, + "free_projectors": 1 + }, + "patterns_checked": 3 + }, + { + "k": 2, + "nu": 2, + "width": 4, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ] + ], + "certificate": { + "n": 4, + "k": 2, + "nu": 2, + "diagonal_dimension": 2, + "circuit_sizes": [ + 2, + 2 + ], + "active_supports": [ + 3, + 12 + ], + "pair_circuits": 2, + "free_projectors": 0 + }, + "patterns_checked": 3 + }, + { + "k": 3, + "nu": 0, + "width": 6, + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 8, + 56 + ] + ], + "certificate": { + "n": 4, + "k": 3, + "nu": 0, + "diagonal_dimension": 1, + "circuit_sizes": [ + 3 + ], + "active_supports": [ + 7 + ], + "pair_circuits": 0, + "free_projectors": 1 + }, + "patterns_checked": 7 + }, + { + "k": 3, + "nu": 1, + "width": 5, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 24, + 20 + ], + [ + 20, + 24 + ], + [ + 28, + 28 + ] + ], + "certificate": { + "n": 5, + "k": 3, + "nu": 1, + "diagonal_dimension": 2, + "circuit_sizes": [ + 2, + 3 + ], + "active_supports": [ + 3, + 28 + ], + "pair_circuits": 1, + "free_projectors": 0 + }, + "patterns_checked": 7 + }, + { + "k": 3, + "nu": 2, + "width": 7, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 112 + ] + ], + "certificate": { + "n": 5, + "k": 3, + "nu": 2, + "diagonal_dimension": 2, + "circuit_sizes": [ + 2, + 2 + ], + "active_supports": [ + 3, + 12 + ], + "pair_circuits": 2, + "free_projectors": 1 + }, + "patterns_checked": 7 + }, + { + "k": 3, + "nu": 3, + "width": 6, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ] + ], + "certificate": { + "n": 6, + "k": 3, + "nu": 3, + "diagonal_dimension": 3, + "circuit_sizes": [ + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48 + ], + "pair_circuits": 3, + "free_projectors": 0 + }, + "patterns_checked": 7 + }, + { + "k": 4, + "nu": 0, + "width": 6, + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ] + ], + "certificate": { + "n": 6, + "k": 4, + "nu": 0, + "diagonal_dimension": 2, + "circuit_sizes": [ + 3, + 3 + ], + "active_supports": [ + 7, + 56 + ], + "pair_circuits": 0, + "free_projectors": 0 + }, + "patterns_checked": 15 + }, + { + "k": 4, + "nu": 1, + "width": 8, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 24, + 20 + ], + [ + 20, + 24 + ], + [ + 28, + 28 + ], + [ + 32, + 224 + ] + ], + "certificate": { + "n": 6, + "k": 4, + "nu": 1, + "diagonal_dimension": 2, + "circuit_sizes": [ + 2, + 3 + ], + "active_supports": [ + 3, + 28 + ], + "pair_circuits": 1, + "free_projectors": 1 + }, + "patterns_checked": 15 + }, + { + "k": 4, + "nu": 2, + "width": 7, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 96, + 80 + ], + [ + 80, + 96 + ], + [ + 112, + 112 + ] + ], + "certificate": { + "n": 7, + "k": 4, + "nu": 2, + "diagonal_dimension": 3, + "circuit_sizes": [ + 2, + 2, + 3 + ], + "active_supports": [ + 3, + 12, + 112 + ], + "pair_circuits": 2, + "free_projectors": 0 + }, + "patterns_checked": 15 + }, + { + "k": 4, + "nu": 3, + "width": 9, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 448 + ] + ], + "certificate": { + "n": 7, + "k": 4, + "nu": 3, + "diagonal_dimension": 3, + "circuit_sizes": [ + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48 + ], + "pair_circuits": 3, + "free_projectors": 1 + }, + "patterns_checked": 15 + }, + { + "k": 4, + "nu": 4, + "width": 8, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ] + ], + "certificate": { + "n": 8, + "k": 4, + "nu": 4, + "diagonal_dimension": 4, + "circuit_sizes": [ + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192 + ], + "pair_circuits": 4, + "free_projectors": 0 + }, + "patterns_checked": 15 + }, + { + "k": 5, + "nu": 0, + "width": 9, + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 64, + 448 + ] + ], + "certificate": { + "n": 7, + "k": 5, + "nu": 0, + "diagonal_dimension": 2, + "circuit_sizes": [ + 3, + 3 + ], + "active_supports": [ + 7, + 56 + ], + "pair_circuits": 0, + "free_projectors": 1 + }, + "patterns_checked": 31 + }, + { + "k": 5, + "nu": 1, + "width": 8, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 24, + 20 + ], + [ + 20, + 24 + ], + [ + 28, + 28 + ], + [ + 192, + 160 + ], + [ + 160, + 192 + ], + [ + 224, + 224 + ] + ], + "certificate": { + "n": 8, + "k": 5, + "nu": 1, + "diagonal_dimension": 3, + "circuit_sizes": [ + 2, + 3, + 3 + ], + "active_supports": [ + 3, + 28, + 224 + ], + "pair_circuits": 1, + "free_projectors": 0 + }, + "patterns_checked": 31 + }, + { + "k": 5, + "nu": 2, + "width": 10, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 96, + 80 + ], + [ + 80, + 96 + ], + [ + 112, + 112 + ], + [ + 128, + 896 + ] + ], + "certificate": { + "n": 8, + "k": 5, + "nu": 2, + "diagonal_dimension": 3, + "circuit_sizes": [ + 2, + 2, + 3 + ], + "active_supports": [ + 3, + 12, + 112 + ], + "pair_circuits": 2, + "free_projectors": 1 + }, + "patterns_checked": 31 + }, + { + "k": 5, + "nu": 3, + "width": 9, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ] + ], + "certificate": { + "n": 9, + "k": 5, + "nu": 3, + "diagonal_dimension": 4, + "circuit_sizes": [ + 2, + 2, + 2, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 448 + ], + "pair_circuits": 3, + "free_projectors": 0 + }, + "patterns_checked": 31 + }, + { + "k": 5, + "nu": 4, + "width": 11, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 1792 + ] + ], + "certificate": { + "n": 9, + "k": 5, + "nu": 4, + "diagonal_dimension": 4, + "circuit_sizes": [ + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192 + ], + "pair_circuits": 4, + "free_projectors": 1 + }, + "patterns_checked": 31 + }, + { + "k": 5, + "nu": 5, + "width": 10, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ] + ], + "certificate": { + "n": 10, + "k": 5, + "nu": 5, + "diagonal_dimension": 5, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768 + ], + "pair_circuits": 5, + "free_projectors": 0 + }, + "patterns_checked": 31 + }, + { + "k": 6, + "nu": 0, + "width": 9, + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ] + ], + "certificate": { + "n": 9, + "k": 6, + "nu": 0, + "diagonal_dimension": 3, + "circuit_sizes": [ + 3, + 3, + 3 + ], + "active_supports": [ + 7, + 56, + 448 + ], + "pair_circuits": 0, + "free_projectors": 0 + }, + "patterns_checked": 63 + }, + { + "k": 6, + "nu": 1, + "width": 11, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 24, + 20 + ], + [ + 20, + 24 + ], + [ + 28, + 28 + ], + [ + 192, + 160 + ], + [ + 160, + 192 + ], + [ + 224, + 224 + ], + [ + 256, + 1792 + ] + ], + "certificate": { + "n": 9, + "k": 6, + "nu": 1, + "diagonal_dimension": 3, + "circuit_sizes": [ + 2, + 3, + 3 + ], + "active_supports": [ + 3, + 28, + 224 + ], + "pair_circuits": 1, + "free_projectors": 1 + }, + "patterns_checked": 63 + }, + { + "k": 6, + "nu": 2, + "width": 10, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 96, + 80 + ], + [ + 80, + 96 + ], + [ + 112, + 112 + ], + [ + 768, + 640 + ], + [ + 640, + 768 + ], + [ + 896, + 896 + ] + ], + "certificate": { + "n": 10, + "k": 6, + "nu": 2, + "diagonal_dimension": 4, + "circuit_sizes": [ + 2, + 2, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 112, + 896 + ], + "pair_circuits": 2, + "free_projectors": 0 + }, + "patterns_checked": 63 + }, + { + "k": 6, + "nu": 3, + "width": 12, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 512, + 3584 + ] + ], + "certificate": { + "n": 10, + "k": 6, + "nu": 3, + "diagonal_dimension": 4, + "circuit_sizes": [ + 2, + 2, + 2, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 448 + ], + "pair_circuits": 3, + "free_projectors": 1 + }, + "patterns_checked": 63 + }, + { + "k": 6, + "nu": 4, + "width": 11, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ] + ], + "certificate": { + "n": 11, + "k": 6, + "nu": 4, + "diagonal_dimension": 5, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 1792 + ], + "pair_circuits": 4, + "free_projectors": 0 + }, + "patterns_checked": 63 + }, + { + "k": 6, + "nu": 5, + "width": 13, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 7168 + ] + ], + "certificate": { + "n": 11, + "k": 6, + "nu": 5, + "diagonal_dimension": 5, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768 + ], + "pair_circuits": 5, + "free_projectors": 1 + }, + "patterns_checked": 63 + }, + { + "k": 6, + "nu": 6, + "width": 12, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ] + ], + "certificate": { + "n": 12, + "k": 6, + "nu": 6, + "diagonal_dimension": 6, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072 + ], + "pair_circuits": 6, + "free_projectors": 0 + }, + "patterns_checked": 63 + }, + { + "k": 7, + "nu": 0, + "width": 12, + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 512, + 3584 + ] + ], + "certificate": { + "n": 10, + "k": 7, + "nu": 0, + "diagonal_dimension": 3, + "circuit_sizes": [ + 3, + 3, + 3 + ], + "active_supports": [ + 7, + 56, + 448 + ], + "pair_circuits": 0, + "free_projectors": 1 + }, + "patterns_checked": 127 + }, + { + "k": 7, + "nu": 1, + "width": 11, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 24, + 20 + ], + [ + 20, + 24 + ], + [ + 28, + 28 + ], + [ + 192, + 160 + ], + [ + 160, + 192 + ], + [ + 224, + 224 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ] + ], + "certificate": { + "n": 11, + "k": 7, + "nu": 1, + "diagonal_dimension": 4, + "circuit_sizes": [ + 2, + 3, + 3, + 3 + ], + "active_supports": [ + 3, + 28, + 224, + 1792 + ], + "pair_circuits": 1, + "free_projectors": 0 + }, + "patterns_checked": 127 + }, + { + "k": 7, + "nu": 2, + "width": 13, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 96, + 80 + ], + [ + 80, + 96 + ], + [ + 112, + 112 + ], + [ + 768, + 640 + ], + [ + 640, + 768 + ], + [ + 896, + 896 + ], + [ + 1024, + 7168 + ] + ], + "certificate": { + "n": 11, + "k": 7, + "nu": 2, + "diagonal_dimension": 4, + "circuit_sizes": [ + 2, + 2, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 112, + 896 + ], + "pair_circuits": 2, + "free_projectors": 1 + }, + "patterns_checked": 127 + }, + { + "k": 7, + "nu": 3, + "width": 12, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ] + ], + "certificate": { + "n": 12, + "k": 7, + "nu": 3, + "diagonal_dimension": 5, + "circuit_sizes": [ + 2, + 2, + 2, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 448, + 3584 + ], + "pair_circuits": 3, + "free_projectors": 0 + }, + "patterns_checked": 127 + }, + { + "k": 7, + "nu": 4, + "width": 14, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ], + [ + 2048, + 14336 + ] + ], + "certificate": { + "n": 12, + "k": 7, + "nu": 4, + "diagonal_dimension": 5, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 1792 + ], + "pair_circuits": 4, + "free_projectors": 1 + }, + "patterns_checked": 127 + }, + { + "k": 7, + "nu": 5, + "width": 13, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 6144, + 5120 + ], + [ + 5120, + 6144 + ], + [ + 7168, + 7168 + ] + ], + "certificate": { + "n": 13, + "k": 7, + "nu": 5, + "diagonal_dimension": 6, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 7168 + ], + "pair_circuits": 5, + "free_projectors": 0 + }, + "patterns_checked": 127 + }, + { + "k": 7, + "nu": 6, + "width": 15, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 28672 + ] + ], + "certificate": { + "n": 13, + "k": 7, + "nu": 6, + "diagonal_dimension": 6, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072 + ], + "pair_circuits": 6, + "free_projectors": 1 + }, + "patterns_checked": 127 + }, + { + "k": 7, + "nu": 7, + "width": 14, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ] + ], + "certificate": { + "n": 14, + "k": 7, + "nu": 7, + "diagonal_dimension": 7, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 12288 + ], + "pair_circuits": 7, + "free_projectors": 0 + }, + "patterns_checked": 127 + }, + { + "k": 8, + "nu": 0, + "width": 12, + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ] + ], + "certificate": { + "n": 12, + "k": 8, + "nu": 0, + "diagonal_dimension": 4, + "circuit_sizes": [ + 3, + 3, + 3, + 3 + ], + "active_supports": [ + 7, + 56, + 448, + 3584 + ], + "pair_circuits": 0, + "free_projectors": 0 + }, + "patterns_checked": 255 + }, + { + "k": 8, + "nu": 1, + "width": 14, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 24, + 20 + ], + [ + 20, + 24 + ], + [ + 28, + 28 + ], + [ + 192, + 160 + ], + [ + 160, + 192 + ], + [ + 224, + 224 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ], + [ + 2048, + 14336 + ] + ], + "certificate": { + "n": 12, + "k": 8, + "nu": 1, + "diagonal_dimension": 4, + "circuit_sizes": [ + 2, + 3, + 3, + 3 + ], + "active_supports": [ + 3, + 28, + 224, + 1792 + ], + "pair_circuits": 1, + "free_projectors": 1 + }, + "patterns_checked": 255 + }, + { + "k": 8, + "nu": 2, + "width": 13, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 96, + 80 + ], + [ + 80, + 96 + ], + [ + 112, + 112 + ], + [ + 768, + 640 + ], + [ + 640, + 768 + ], + [ + 896, + 896 + ], + [ + 6144, + 5120 + ], + [ + 5120, + 6144 + ], + [ + 7168, + 7168 + ] + ], + "certificate": { + "n": 13, + "k": 8, + "nu": 2, + "diagonal_dimension": 5, + "circuit_sizes": [ + 2, + 2, + 3, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 112, + 896, + 7168 + ], + "pair_circuits": 2, + "free_projectors": 0 + }, + "patterns_checked": 255 + }, + { + "k": 8, + "nu": 3, + "width": 15, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 4096, + 28672 + ] + ], + "certificate": { + "n": 13, + "k": 8, + "nu": 3, + "diagonal_dimension": 5, + "circuit_sizes": [ + 2, + 2, + 2, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 448, + 3584 + ], + "pair_circuits": 3, + "free_projectors": 1 + }, + "patterns_checked": 255 + }, + { + "k": 8, + "nu": 4, + "width": 14, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ], + [ + 12288, + 10240 + ], + [ + 10240, + 12288 + ], + [ + 14336, + 14336 + ] + ], + "certificate": { + "n": 14, + "k": 8, + "nu": 4, + "diagonal_dimension": 6, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 1792, + 14336 + ], + "pair_circuits": 4, + "free_projectors": 0 + }, + "patterns_checked": 255 + }, + { + "k": 8, + "nu": 5, + "width": 16, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 6144, + 5120 + ], + [ + 5120, + 6144 + ], + [ + 7168, + 7168 + ], + [ + 8192, + 57344 + ] + ], + "certificate": { + "n": 14, + "k": 8, + "nu": 5, + "diagonal_dimension": 6, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 7168 + ], + "pair_circuits": 5, + "free_projectors": 1 + }, + "patterns_checked": 255 + }, + { + "k": 8, + "nu": 6, + "width": 15, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 24576, + 20480 + ], + [ + 20480, + 24576 + ], + [ + 28672, + 28672 + ] + ], + "certificate": { + "n": 15, + "k": 8, + "nu": 6, + "diagonal_dimension": 7, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 28672 + ], + "pair_circuits": 6, + "free_projectors": 0 + }, + "patterns_checked": 255 + }, + { + "k": 8, + "nu": 7, + "width": 17, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 16384, + 114688 + ] + ], + "certificate": { + "n": 15, + "k": 8, + "nu": 7, + "diagonal_dimension": 7, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 12288 + ], + "pair_circuits": 7, + "free_projectors": 1 + }, + "patterns_checked": 255 + }, + { + "k": 8, + "nu": 8, + "width": 16, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 16384, + 49152 + ], + [ + 49152, + 32768 + ] + ], + "certificate": { + "n": 16, + "k": 8, + "nu": 8, + "diagonal_dimension": 8, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 12288, + 49152 + ], + "pair_circuits": 8, + "free_projectors": 0 + }, + "patterns_checked": 255 + }, + { + "k": 9, + "nu": 0, + "width": 15, + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 4096, + 28672 + ] + ], + "certificate": { + "n": 13, + "k": 9, + "nu": 0, + "diagonal_dimension": 4, + "circuit_sizes": [ + 3, + 3, + 3, + 3 + ], + "active_supports": [ + 7, + 56, + 448, + 3584 + ], + "pair_circuits": 0, + "free_projectors": 1 + }, + "patterns_checked": 511 + }, + { + "k": 9, + "nu": 1, + "width": 14, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 24, + 20 + ], + [ + 20, + 24 + ], + [ + 28, + 28 + ], + [ + 192, + 160 + ], + [ + 160, + 192 + ], + [ + 224, + 224 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ], + [ + 12288, + 10240 + ], + [ + 10240, + 12288 + ], + [ + 14336, + 14336 + ] + ], + "certificate": { + "n": 14, + "k": 9, + "nu": 1, + "diagonal_dimension": 5, + "circuit_sizes": [ + 2, + 3, + 3, + 3, + 3 + ], + "active_supports": [ + 3, + 28, + 224, + 1792, + 14336 + ], + "pair_circuits": 1, + "free_projectors": 0 + }, + "patterns_checked": 511 + }, + { + "k": 9, + "nu": 2, + "width": 16, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 96, + 80 + ], + [ + 80, + 96 + ], + [ + 112, + 112 + ], + [ + 768, + 640 + ], + [ + 640, + 768 + ], + [ + 896, + 896 + ], + [ + 6144, + 5120 + ], + [ + 5120, + 6144 + ], + [ + 7168, + 7168 + ], + [ + 8192, + 57344 + ] + ], + "certificate": { + "n": 14, + "k": 9, + "nu": 2, + "diagonal_dimension": 5, + "circuit_sizes": [ + 2, + 2, + 3, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 112, + 896, + 7168 + ], + "pair_circuits": 2, + "free_projectors": 1 + }, + "patterns_checked": 511 + }, + { + "k": 9, + "nu": 3, + "width": 15, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 24576, + 20480 + ], + [ + 20480, + 24576 + ], + [ + 28672, + 28672 + ] + ], + "certificate": { + "n": 15, + "k": 9, + "nu": 3, + "diagonal_dimension": 6, + "circuit_sizes": [ + 2, + 2, + 2, + 3, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 448, + 3584, + 28672 + ], + "pair_circuits": 3, + "free_projectors": 0 + }, + "patterns_checked": 511 + }, + { + "k": 9, + "nu": 4, + "width": 17, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ], + [ + 12288, + 10240 + ], + [ + 10240, + 12288 + ], + [ + 14336, + 14336 + ], + [ + 16384, + 114688 + ] + ], + "certificate": { + "n": 15, + "k": 9, + "nu": 4, + "diagonal_dimension": 6, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 1792, + 14336 + ], + "pair_circuits": 4, + "free_projectors": 1 + }, + "patterns_checked": 511 + }, + { + "k": 9, + "nu": 5, + "width": 16, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 6144, + 5120 + ], + [ + 5120, + 6144 + ], + [ + 7168, + 7168 + ], + [ + 49152, + 40960 + ], + [ + 40960, + 49152 + ], + [ + 57344, + 57344 + ] + ], + "certificate": { + "n": 16, + "k": 9, + "nu": 5, + "diagonal_dimension": 7, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 7168, + 57344 + ], + "pair_circuits": 5, + "free_projectors": 0 + }, + "patterns_checked": 511 + }, + { + "k": 9, + "nu": 6, + "width": 18, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 24576, + 20480 + ], + [ + 20480, + 24576 + ], + [ + 28672, + 28672 + ], + [ + 32768, + 229376 + ] + ], + "certificate": { + "n": 16, + "k": 9, + "nu": 6, + "diagonal_dimension": 7, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 28672 + ], + "pair_circuits": 6, + "free_projectors": 1 + }, + "patterns_checked": 511 + }, + { + "k": 9, + "nu": 7, + "width": 17, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 98304, + 81920 + ], + [ + 81920, + 98304 + ], + [ + 114688, + 114688 + ] + ], + "certificate": { + "n": 17, + "k": 9, + "nu": 7, + "diagonal_dimension": 8, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 12288, + 114688 + ], + "pair_circuits": 7, + "free_projectors": 0 + }, + "patterns_checked": 511 + }, + { + "k": 9, + "nu": 8, + "width": 19, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 16384, + 49152 + ], + [ + 49152, + 32768 + ], + [ + 65536, + 458752 + ] + ], + "certificate": { + "n": 17, + "k": 9, + "nu": 8, + "diagonal_dimension": 8, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 12288, + 49152 + ], + "pair_circuits": 8, + "free_projectors": 1 + }, + "patterns_checked": 511 + }, + { + "k": 9, + "nu": 9, + "width": 18, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 16384, + 49152 + ], + [ + 49152, + 32768 + ], + [ + 65536, + 196608 + ], + [ + 196608, + 131072 + ] + ], + "certificate": { + "n": 18, + "k": 9, + "nu": 9, + "diagonal_dimension": 9, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 12288, + 49152, + 196608 + ], + "pair_circuits": 9, + "free_projectors": 0 + }, + "patterns_checked": 511 + }, + { + "k": 10, + "nu": 0, + "width": 15, + "pairs": [ + [ + 6, + 5 + ], + [ + 5, + 6 + ], + [ + 7, + 7 + ], + [ + 48, + 40 + ], + [ + 40, + 48 + ], + [ + 56, + 56 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 24576, + 20480 + ], + [ + 20480, + 24576 + ], + [ + 28672, + 28672 + ] + ], + "certificate": { + "n": 15, + "k": 10, + "nu": 0, + "diagonal_dimension": 5, + "circuit_sizes": [ + 3, + 3, + 3, + 3, + 3 + ], + "active_supports": [ + 7, + 56, + 448, + 3584, + 28672 + ], + "pair_circuits": 0, + "free_projectors": 0 + }, + "patterns_checked": 1023 + }, + { + "k": 10, + "nu": 1, + "width": 17, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 24, + 20 + ], + [ + 20, + 24 + ], + [ + 28, + 28 + ], + [ + 192, + 160 + ], + [ + 160, + 192 + ], + [ + 224, + 224 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ], + [ + 12288, + 10240 + ], + [ + 10240, + 12288 + ], + [ + 14336, + 14336 + ], + [ + 16384, + 114688 + ] + ], + "certificate": { + "n": 15, + "k": 10, + "nu": 1, + "diagonal_dimension": 5, + "circuit_sizes": [ + 2, + 3, + 3, + 3, + 3 + ], + "active_supports": [ + 3, + 28, + 224, + 1792, + 14336 + ], + "pair_circuits": 1, + "free_projectors": 1 + }, + "patterns_checked": 1023 + }, + { + "k": 10, + "nu": 2, + "width": 16, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 96, + 80 + ], + [ + 80, + 96 + ], + [ + 112, + 112 + ], + [ + 768, + 640 + ], + [ + 640, + 768 + ], + [ + 896, + 896 + ], + [ + 6144, + 5120 + ], + [ + 5120, + 6144 + ], + [ + 7168, + 7168 + ], + [ + 49152, + 40960 + ], + [ + 40960, + 49152 + ], + [ + 57344, + 57344 + ] + ], + "certificate": { + "n": 16, + "k": 10, + "nu": 2, + "diagonal_dimension": 6, + "circuit_sizes": [ + 2, + 2, + 3, + 3, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 112, + 896, + 7168, + 57344 + ], + "pair_circuits": 2, + "free_projectors": 0 + }, + "patterns_checked": 1023 + }, + { + "k": 10, + "nu": 3, + "width": 18, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 384, + 320 + ], + [ + 320, + 384 + ], + [ + 448, + 448 + ], + [ + 3072, + 2560 + ], + [ + 2560, + 3072 + ], + [ + 3584, + 3584 + ], + [ + 24576, + 20480 + ], + [ + 20480, + 24576 + ], + [ + 28672, + 28672 + ], + [ + 32768, + 229376 + ] + ], + "certificate": { + "n": 16, + "k": 10, + "nu": 3, + "diagonal_dimension": 6, + "circuit_sizes": [ + 2, + 2, + 2, + 3, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 448, + 3584, + 28672 + ], + "pair_circuits": 3, + "free_projectors": 1 + }, + "patterns_checked": 1023 + }, + { + "k": 10, + "nu": 4, + "width": 17, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 1536, + 1280 + ], + [ + 1280, + 1536 + ], + [ + 1792, + 1792 + ], + [ + 12288, + 10240 + ], + [ + 10240, + 12288 + ], + [ + 14336, + 14336 + ], + [ + 98304, + 81920 + ], + [ + 81920, + 98304 + ], + [ + 114688, + 114688 + ] + ], + "certificate": { + "n": 17, + "k": 10, + "nu": 4, + "diagonal_dimension": 7, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 3, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 1792, + 14336, + 114688 + ], + "pair_circuits": 4, + "free_projectors": 0 + }, + "patterns_checked": 1023 + }, + { + "k": 10, + "nu": 5, + "width": 19, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 6144, + 5120 + ], + [ + 5120, + 6144 + ], + [ + 7168, + 7168 + ], + [ + 49152, + 40960 + ], + [ + 40960, + 49152 + ], + [ + 57344, + 57344 + ], + [ + 65536, + 458752 + ] + ], + "certificate": { + "n": 17, + "k": 10, + "nu": 5, + "diagonal_dimension": 7, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 7168, + 57344 + ], + "pair_circuits": 5, + "free_projectors": 1 + }, + "patterns_checked": 1023 + }, + { + "k": 10, + "nu": 6, + "width": 18, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 24576, + 20480 + ], + [ + 20480, + 24576 + ], + [ + 28672, + 28672 + ], + [ + 196608, + 163840 + ], + [ + 163840, + 196608 + ], + [ + 229376, + 229376 + ] + ], + "certificate": { + "n": 18, + "k": 10, + "nu": 6, + "diagonal_dimension": 8, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 3, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 28672, + 229376 + ], + "pair_circuits": 6, + "free_projectors": 0 + }, + "patterns_checked": 1023 + }, + { + "k": 10, + "nu": 7, + "width": 20, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 98304, + 81920 + ], + [ + 81920, + 98304 + ], + [ + 114688, + 114688 + ], + [ + 131072, + 917504 + ] + ], + "certificate": { + "n": 18, + "k": 10, + "nu": 7, + "diagonal_dimension": 8, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 12288, + 114688 + ], + "pair_circuits": 7, + "free_projectors": 1 + }, + "patterns_checked": 1023 + }, + { + "k": 10, + "nu": 8, + "width": 19, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 16384, + 49152 + ], + [ + 49152, + 32768 + ], + [ + 393216, + 327680 + ], + [ + 327680, + 393216 + ], + [ + 458752, + 458752 + ] + ], + "certificate": { + "n": 19, + "k": 10, + "nu": 8, + "diagonal_dimension": 9, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 3 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 12288, + 49152, + 458752 + ], + "pair_circuits": 8, + "free_projectors": 0 + }, + "patterns_checked": 1023 + }, + { + "k": 10, + "nu": 9, + "width": 21, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 16384, + 49152 + ], + [ + 49152, + 32768 + ], + [ + 65536, + 196608 + ], + [ + 196608, + 131072 + ], + [ + 262144, + 1835008 + ] + ], + "certificate": { + "n": 19, + "k": 10, + "nu": 9, + "diagonal_dimension": 9, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 12288, + 49152, + 196608 + ], + "pair_circuits": 9, + "free_projectors": 1 + }, + "patterns_checked": 1023 + }, + { + "k": 10, + "nu": 10, + "width": 20, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 16384, + 49152 + ], + [ + 49152, + 32768 + ], + [ + 65536, + 196608 + ], + [ + 196608, + 131072 + ], + [ + 262144, + 786432 + ], + [ + 786432, + 524288 + ] + ], + "certificate": { + "n": 20, + "k": 10, + "nu": 10, + "diagonal_dimension": 10, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 12288, + 49152, + 196608, + 786432 + ], + "pair_circuits": 10, + "free_projectors": 0 + }, + "patterns_checked": 1023 + } + ], + "sharp_irreducible_families": [ + { + "k": 1, + "width": 3, + "pairs": [ + [ + 1, + 7 + ] + ], + "certificate": { + "n": 1, + "k": 1, + "nu": 0, + "diagonal_dimension": 0, + "circuit_sizes": [], + "active_supports": [], + "pair_circuits": 0, + "free_projectors": 1 + }, + "direct_orbits": 1, + "star_certificate": false, + "patterns_checked": 1 + }, + { + "k": 2, + "width": 3, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 6, + 5 + ] + ], + "certificate": { + "n": 3, + "k": 2, + "nu": 1, + "diagonal_dimension": 1, + "circuit_sizes": [ + 2 + ], + "active_supports": [ + 3 + ], + "pair_circuits": 1, + "free_projectors": 1 + }, + "direct_orbits": 7, + "star_certificate": true, + "patterns_checked": 3 + }, + { + "k": 3, + "width": 5, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 26, + 21 + ] + ], + "certificate": { + "n": 5, + "k": 3, + "nu": 2, + "diagonal_dimension": 2, + "circuit_sizes": [ + 2, + 2 + ], + "active_supports": [ + 3, + 12 + ], + "pair_circuits": 2, + "free_projectors": 1 + }, + "direct_orbits": 31, + "star_certificate": true, + "patterns_checked": 7 + }, + { + "k": 4, + "width": 7, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 106, + 85 + ] + ], + "certificate": { + "n": 7, + "k": 4, + "nu": 3, + "diagonal_dimension": 3, + "circuit_sizes": [ + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48 + ], + "pair_circuits": 3, + "free_projectors": 1 + }, + "direct_orbits": 127, + "star_certificate": true, + "patterns_checked": 15 + }, + { + "k": 5, + "width": 9, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 426, + 341 + ] + ], + "certificate": { + "n": 9, + "k": 5, + "nu": 4, + "diagonal_dimension": 4, + "circuit_sizes": [ + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192 + ], + "pair_circuits": 4, + "free_projectors": 1 + }, + "direct_orbits": 511, + "star_certificate": true, + "patterns_checked": 31 + }, + { + "k": 6, + "width": 11, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1706, + 1365 + ] + ], + "certificate": { + "n": 11, + "k": 6, + "nu": 5, + "diagonal_dimension": 5, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768 + ], + "pair_circuits": 5, + "free_projectors": 1 + }, + "direct_orbits": 0, + "star_certificate": true, + "patterns_checked": 63 + }, + { + "k": 7, + "width": 13, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 6826, + 5461 + ] + ], + "certificate": { + "n": 13, + "k": 7, + "nu": 6, + "diagonal_dimension": 6, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072 + ], + "pair_circuits": 6, + "free_projectors": 1 + }, + "direct_orbits": 0, + "star_certificate": true, + "patterns_checked": 127 + }, + { + "k": 8, + "width": 15, + "pairs": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 16, + 48 + ], + [ + 48, + 32 + ], + [ + 64, + 192 + ], + [ + 192, + 128 + ], + [ + 256, + 768 + ], + [ + 768, + 512 + ], + [ + 1024, + 3072 + ], + [ + 3072, + 2048 + ], + [ + 4096, + 12288 + ], + [ + 12288, + 8192 + ], + [ + 27306, + 21845 + ] + ], + "certificate": { + "n": 15, + "k": 8, + "nu": 7, + "diagonal_dimension": 7, + "circuit_sizes": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "active_supports": [ + 3, + 12, + 48, + 192, + 768, + 3072, + 12288 + ], + "pair_circuits": 7, + "free_projectors": 1 + }, + "direct_orbits": 0, + "star_certificate": true, + "patterns_checked": 255 + } + ], + "boundary_controls": { + "unit_star": { + "k": 4, + "edge_count": 4, + "nu": 1, + "image": 5, + "refined_upper": 6, + "universal_upper": 8 + }, + "prior_6782_exact_witness": [ + [ + 1, + 3 + ], + [ + 3, + 2 + ], + [ + 4, + 12 + ], + [ + 12, + 8 + ], + [ + 26, + 21 + ] + ], + "zero_pattern_counterexample_image": 4, + "column_equality_pool_size": 5, + "extra_edge_triple": [ + [ + 1, + 5 + ], + [ + 2, + 6 + ], + [ + 7, + 4 + ] + ] + }, + "limitations": [ + "No sharp irreducible bound for every fixed (k,nu) is claimed.", + "No sharpness for a prescribed edge graph is claimed.", + "No paid word, native implementation, complete invoice or kappa improvement." + ] +} diff --git a/research/edge-matching-image-bound/SOURCES.json b/research/edge-matching-image-bound/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/edge-matching-image-bound/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ] +} diff --git a/research/edge-matching-image-bound/TASK.json b/research/edge-matching-image-bound/TASK.json new file mode 100644 index 0000000000..24f5689dc6 --- /dev/null +++ b/research/edge-matching-image-bound/TASK.json @@ -0,0 +1,80 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json", + "research/bit-gl3-mixed-targets-length10/README.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it. 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", + "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": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model.", + "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "changed", + "actual_scope": "All-width edge-matching image bounds for binary noncoordinate projector pools; sharp universal total and irreducible maxima.", + "scope_change_reason": "Allow matrix units in the pattern space. Two-member relation circuits give a matching term absent from the unit-free theorem.", + "bottleneck_link": "Bound the active scalar dimension linearly in the relation-pattern dimension before a legal paid-word search.", + "budget_minutes": 60, + "stop_rule": "Stop at the general bound and exact attaining complete pools. Do not start a larger-word or native construction without its separate obligation gate.", + "outcome": "completed", + "evidence": "PROOF.md; RESULT.json; 224036 image-basis collections, 2825 complete pattern spaces, 65 total and eight irreducible attaining families.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance; no independent human or formal-kernel review claimed.", + "open_questions": [ + { + "question": "Can an attaining irreducible edge-pair family support a legal paid word with target rank above paid rank?", + "why_it_matters": "An extremal scalar image is not a paid saving or native supplier.", + "first_step": "Specify the alphabet, relation lattice, endpoint basis, all counted roles and native interface; compare the existing five-core word obstruction.", + "blocked_by": "No paid word, native implementation or complete invoice is supplied." + } + ], + "family_decision": { + "decision": "Change the unit-free hypothesis and prove a general matching bound; stop at the structural result.", + "sources": "7690@b725be51349cce4e0a262c76233838992042dd62; 7691@69e70b1426c32b19da8334930815800a2c95ffca; 6782@685457252b51b9c7932ece363365bdf0b12c9c31; 6785@5dbf2c05220bea53d84b510efe5910c4cec8f182", + "evidence_status": "Author-checked written proof with exact finite corroboration.", + "boundary": "Binary rank-one idempotents with nonzero patterns at any width; matrix units allowed.", + "obligations": { + "general_bound": "proved", + "total_sharpness": "proved for every (k,nu)", + "universal_irreducible_sharpness": "proved for every k>=1", + "paid_word": "unknown", + "native_conversion": "unknown", + "complete_invoice": "unknown" + }, + "alternative": "A direct pattern-space search has no all-width coverage. The disjoint relation code gives a structural proof.", + "construction_gate": "Unmet. No paid identity, native alphabet or complete invoice is supplied." + } +} diff --git a/research/edge-matching-image-bound/VERIFY.json b/research/edge-matching-image-bound/VERIFY.json new file mode 100644 index 0000000000..885b48ad25 --- /dev/null +++ b/research/edge-matching-image-bound/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Disjoint relation codes, edge matchings, complete small pools, all attaining pattern lifts, irreducibility certificates and boundary controls." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Disjoint relation codes, edge matchings, complete small pools, all attaining pattern lifts, irreducibility certificates and boundary controls." + } + ] +} diff --git a/research/edge-matching-image-bound/verify.py b/research/edge-matching-image-bound/verify.py new file mode 100644 index 0000000000..838d204bd1 --- /dev/null +++ b/research/edge-matching-image-bound/verify.py @@ -0,0 +1,394 @@ +"""Exact checks for edge-matching image bounds. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +Matrix, lift, orbit and subspace primitives are reused from PR7690. +See CREDITS.md for exact sources and predecessor support arguments. +""" + +import itertools +import json +from collections import Counter +from pathlib import Path + + +def require(value, message): + if not value: + raise ValueError(message) + + + +def parity(value): + return value.bit_count() & 1 + + + +def basis(values): + pivots = {} + for value in values: + while value: + pivot = value.bit_length() - 1 + if pivot in pivots: + value ^= pivots[pivot] + else: + pivots[pivot] = value + break + return tuple(pivots.values()) + + + +def span(values): + result = [0] + for value in basis(values): + result += [old ^ value for old in result] + return result + + + +def outer(x, y, width): + result = 0 + while x: + bit = x & -x + result |= y << ((bit.bit_length() - 1) * width) + x ^= bit + return result + + + +def off(matrix, width): + for i in range(width): + matrix &= ~(1 << (i * width + i)) + return matrix + + + +def patterns(pairs, width): + return [off(outer(x, y, width), width) for x, y in pairs] + + + +def lifts(pattern, width): + """An off-diagonal one fixes all factor bits except two.""" + require(pattern != 0, 'zero pattern is outside the pool') + i, j = divmod((pattern & -pattern).bit_length() - 1, width) + require(i != j, 'diagonal pattern entry') + x = sum(((pattern >> (r * width + j)) & 1) << r for r in range(width)) + y = (pattern >> (i * width)) & ((1 << width) - 1) + result = [] + for xj, yi in itertools.product((0, 1), repeat=2): + xx, yy = x | (xj << j), y | (yi << i) + if parity(xx & yy) and off(outer(xx, yy, width), width) == pattern: + result.append((xx, yy)) + return result + + + +def pool(pattern_basis, width): + return sorted(pair for pattern in span(pattern_basis) if pattern + for pair in lifts(pattern, width)) + + + +def orbit_irreducible(pairs): + """Check all nonzero vectors for small fixtures by direct closure.""" + image_space = span(x for x, _ in pairs) + n = len(basis(image_space)) + for value in image_space[1:]: + vectors = basis([value]) + while True: + expanded = basis((*vectors, *(x for x, y in pairs + if any(parity(y & v) for v in vectors)))) + if len(expanded) == len(vectors): + break + vectors = expanded + if len(vectors) != n: + return False + return True + + + +def all_subspaces(width): + spaces = {frozenset({0})} + frontier = list(spaces) + while frontier: + old = frontier.pop() + for value in range(1, 1 << width): + if value not in old: + new = frozenset(old | {x ^ value for x in old}) + if new not in spaces: + spaces.add(new) + frontier.append(new) + return sorted(spaces, key=lambda x: (len(x), sorted(x))) + +def edges(pattern_basis, width): + return sorted({tuple(sorted(divmod(p.bit_length() - 1, width))) + for p in span(pattern_basis) if p.bit_count() == 1}) + + +def matching(edge_list): + best = () + def visit(i, used, chosen): + nonlocal best + if len(chosen) + len(edge_list) - i <= len(best): + return + if i == len(edge_list): + best = chosen + return + a, b = edge_list[i] + mask = (1 << a) | (1 << b) + if not used & mask: + visit(i + 1, used | mask, chosen + ((a, b),)) + visit(i + 1, used, chosen) + visit(0, 0, ()) + return best + + +def relation_structure(pairs, width): + """Check the disjoint relation code, including its two-member groups.""" + n = len(pairs) + require(len(basis(x for x, _ in pairs)) == n, 'independent images') + ps = patterns(pairs, width) + require(all(ps), 'nonzero patterns') + require(all(parity(x & y) for x, y in pairs), 'idempotence') + pivots, relations = {}, [] + for i, value in enumerate(ps): + label = 1 << i + while value: + pivot = value.bit_length() - 1 + if pivot in pivots: + old, old_label = pivots[pivot] + value ^= old + label ^= old_label + else: + pivots[pivot] = value, label + break + if not value: + relations.append(label) + groups = {} + for i in range(n): + character = sum(((r >> i) & 1) << j for j, r in enumerate(relations)) + groups.setdefault(character, []).append(i) + nonzero = {c: indices for c, indices in groups.items() if c} + d, k = len(relations), len(pivots) + require(len(nonzero) == d and len(basis(nonzero)) == d, + 'independent nonzero characters') + labels, supports, sizes, pair_edges = [], [], [], [] + for indices in nonzero.values(): + require(len(indices) >= 2, 'minimum circuit size') + matrix = 0 + for i in indices: + matrix ^= outer(*pairs[i], width) + require(matrix and not off(matrix, width), 'nonzero diagonal sum') + support = sum(((matrix >> (i * width + i)) & 1) << i for i in range(width)) + require(all(not support & other for other in supports), 'disjoint active supports') + require(all(not pairs[i][1] & ~support for i in indices), 'covector support') + require(support.bit_count() <= len(indices), 'diagonal rank') + require((support.bit_count() - len(indices)) % 2 == 0, 'trace parity') + image = set(span(pairs[i][0] for i in indices)) + require(all((1 << j) in image for j in range(width) if support >> j & 1), + 'active coordinates belong to the group image') + if len(indices) == 2: + i, j = indices + require(ps[i] == ps[j] and ps[i].bit_count() == 1, 'edge-pair circuit') + a, b = divmod(ps[i].bit_length() - 1, width) + require(support == (1 << a) | (1 << b), 'edge endpoints are active') + require(set(lifts(ps[i], width)) == {pairs[i], pairs[j]}, 'complete edge fiber') + pair_edges.append(tuple(sorted((a, b)))) + supports.append(support) + sizes.append(len(indices)) + labels.append(sum(1 << i for i in indices)) + require(set(span(labels)) == set(span(relations)), 'entire relation code') + edge_list = edges(ps, width) + nu = len(matching(edge_list)) + t = len(pair_edges) + require(all(e in edge_list for e in pair_edges), 'pair edges are in H') + require(len({v for edge in pair_edges for v in edge}) == 2 * t, 'circuit matching') + require(t <= nu and n >= 3 * d - t and 2 * n <= 3 * k + nu, 'matching bound') + return {'n': n, 'k': k, 'nu': nu, 'diagonal_dimension': d, + 'circuit_sizes': sorted(sizes), 'active_supports': supports, + 'pair_circuits': t, 'free_projectors': len(groups.get(0, []))} + + +def small_image_basis_census(width, maximum_n): + counts = Counter() + circuit_sizes = Counter() + for n in range(1, maximum_n + 1): + for images in itertools.combinations(range(1, 1 << width), n): + if len(basis(images)) != n: + continue + choices = [[y for y in range(1, 1 << width) if parity(x & y)] for x in images] + for covectors in itertools.product(*choices): + counts['collections'] += 1 + pairs = list(zip(images, covectors)) + if not all(patterns(pairs, width)): + continue + counts['nonzero_patterns'] += 1 + row = relation_structure(pairs, width) + counts['with_pair_circuit'] += bool(row['pair_circuits']) + counts['total_equality'] += 2 * n == 3 * row['k'] + row['nu'] + circuit_sizes[str(row['circuit_sizes'])] += 1 + return {'width': width, 'maximum_n': maximum_n, 'counts': dict(sorted(counts.items())), + 'circuit_size_counts': dict(sorted(circuit_sizes.items()))} + + +def three_width_pattern_census(): + positions = [i * 3 + j for i in range(3) for j in range(3) if i != j] + def decode(value): + return sum(((value >> i) & 1) << pos for i, pos in enumerate(positions)) + raw = [(x, y, off(outer(x, y, 3), 3)) + for x, y in itertools.product(range(1, 8), repeat=2) + if parity(x & y) and off(outer(x, y, 3), 3)] + counts, profile = Counter(), Counter() + spaces = all_subspaces(6) + require(len(spaces) == 2825, 'all width-three pattern spaces') + for space in spaces: + literal = {decode(p) for p in space} + ps = basis(sorted(literal)) + actual = sorted((x, y) for x, y, p in raw if p in literal) + require(pool(ps, 3) == actual, 'raw pool and four-trial lift agree') + k, n = len(ps), len(basis(x for x, _ in actual)) + edge_list = edges(ps, 3) + nu = len(matching(edge_list)) + brute = max((len(s) for size in range(len(edge_list) + 1) + for s in itertools.combinations(edge_list, size) + if len({v for e in s for v in e}) == 2 * len(s)), default=0) + require(nu == brute, 'independent matching enumeration') + require(2 * n <= 3 * k + nu and n <= 2 * k, 'total image bounds') + counts['spaces'] += 1 + counts['empty_pools'] += not n + if not n: + continue + irreducible = orbit_irreducible(actual) + counts['irreducible'] += irreducible + counts['total_equality'] += 2 * n == 3 * k + nu + if irreducible: + require(2 * n <= 3 * k + nu - 1 and n <= 2 * k - 1, 'strict bound') + profile[str((k, nu, n, irreducible))] += 1 + return {'counts': dict(sorted(counts.items())), 'profile': dict(sorted(profile.items()))} + + +def normal_block(shift): + return [(x << shift, y << shift) for x, y in ((6, 5), (5, 6), (7, 7))] + + +def edge_block(shift): + return [(1 << shift, 3 << shift), (3 << shift, 2 << shift)] + + +def sharp_total(k, nu): + pairs = [p for j in range(nu) for p in edge_block(2 * j)] + shift = 2 * nu + for j in range((k - nu) // 2): + pairs += normal_block(shift) + shift += 3 + if (k - nu) % 2: + pairs.append((1 << shift, 7 << shift)) + shift += 3 + ps = patterns(pairs, shift) + row = relation_structure(pairs, shift) + require(row['k'] == k and row['nu'] == nu, 'prescribed k and matching number') + require(row['n'] == (3 * k + nu) // 2, 'refined bound is sharp') + require(pool(ps, shift) == sorted(pairs), 'sharp total complete pool') + return {'k': k, 'nu': nu, 'width': shift, 'pairs': pairs, 'certificate': row, + 'patterns_checked': (1 << k) - 1} + + +def sharp_irreducible(k): + if k == 1: + width, pairs = 3, [(1, 7)] + else: + t = k - 1 + width = 2 * t + 1 + old = [p for j in range(t) for p in edge_block(2 * j)] + hx = sum(1 << (2 * j + 1) for j in range(t)) + hy = sum(1 << (2 * j) for j in range(t)) + pairs = old + [(hx | (1 << (2 * t)), hy | (1 << (2 * t)))] + gram = [[parity(y & x) for x, _ in old] for _, y in old] + require(gram == [[int(i == j) for j in range(2 * t)] for i in range(2 * t)], + 'old edge projectors are orthogonal') + require(all(parity(y & pairs[-1][0]) and parity(pairs[-1][1] & x) + for x, y in old), 'all old-link incidences are one') + require(len(basis(sum(value << j for j, value in enumerate(row)) + for row in [[parity(y & x) for x, _ in pairs] for _, y in pairs])) + == len(pairs), 'star Gram matrix is nonsingular') + ps = patterns(pairs, width) + row = relation_structure(pairs, width) + require(row['k'] == k and row['n'] == 2 * k - 1, 'universal irreducible maximum') + require(pool(ps, width) == sorted(pairs), 'sharp irreducible complete pool') + require(row['nu'] == max(0, k - 1), 'exact edge matching number') + if row['n'] <= 9: + require(orbit_irreducible(pairs), 'every nonzero orbit fills the image') + return {'k': k, 'width': width, 'pairs': pairs, 'certificate': row, + 'direct_orbits': (1 << row['n']) - 1 if row['n'] <= 9 else 0, + 'star_certificate': k > 1, 'patterns_checked': (1 << k) - 1} + + +def boundary_controls(): + # A pure unit star distinguishes edge count from matching number. + width = 5 + ps = [1 << j for j in range(1, width)] + actual = pool(ps, width) + require(len(edges(ps, width)) == 4 and len(matching(edges(ps, width))) == 1, + 'four overlapping edges have matching number one') + require(len(basis(x for x, _ in actual)) == 5, 'unit-star image') + require(not orbit_irreducible(actual), 'unit-star invariant') + # The credited three-dimensional core is retained without relabelling. + prior = [(1, 3), (3, 2), (4, 12), (12, 8), (26, 21)] + require(sharp_irreducible(3)['pairs'] == prior, 'PR6782 exact witness') + # Coordinate projectors would violate any bound depending only on H. + coordinate = [(1 << j, 1 << j) for j in range(4)] + require(len(basis(patterns(coordinate, 4))) == 0 + and len(basis(x for x, _ in coordinate)) == 4, 'zero-pattern counterexample') + rejected = False + try: + relation_structure(coordinate, 4) + except ValueError as e: + rejected = str(e) == 'nonzero patterns' + require(rejected, 'coordinate-projector guard') + # Replacing maximum matching by zero fails on each edge pair. + edge = relation_structure(edge_block(0), 2) + require(2 * edge['n'] > 3 * edge['k'], 'edge allowance is necessary') + # Equality can have column triples, whose complete pool stays reducible. + column = [(11, 1), (13, 1), (7, 1)] + mixed = column + edge_block(4) + ps = patterns(mixed, 6) + row = relation_structure(mixed, 6) + actual = pool(ps, 6) + require(2 * row['n'] == 3 * row['k'] + row['nu'] and not orbit_irreducible(actual), + 'column-triple equality remains reducible') + # An orthogonal triple can contain edges. Equality must rule this out. + triple = [(1, 5), (2, 6), (7, 4)] + row = relation_structure(triple, 3) + require(row['nu'] == 1 and row['pair_circuits'] == 0, 'extra edge in a three-circuit') + require(2 * row['n'] < 3 * row['k'] + row['nu'], 'extra edge prevents equality') + return {'unit_star': {'k': 4, 'edge_count': 4, 'nu': 1, 'image': 5, + 'refined_upper': 6, 'universal_upper': 8}, + 'prior_6782_exact_witness': prior, 'zero_pattern_counterexample_image': 4, + 'column_equality_pool_size': len(actual), 'extra_edge_triple': triple} + + +def result(): + small = [small_image_basis_census(3, 3), small_image_basis_census(4, 3)] + total = [sharp_total(k, nu) for k in range(1, 11) for nu in range(k + 1)] + irreducible = [sharp_irreducible(k) for k in range(1, 9)] + return {'status': 'PASS_EDGE_MATCHING_IMAGE_BOUND', + 'scope': 'Binary rank-one idempotents with nonzero patterns; arbitrary width and pattern dimension.', + 'claims': {'total': '2 dim(V) <= 3k+nu; dim(V) <= 2k', + 'irreducible': '2 dim(V) <= 3k+nu-1; dim(V) <= 2k-1', + 'sharpness': 'Total bound for every (k,nu); universal irreducible bound for every k>=1.'}, + 'small_image_basis_censuses': small, 'width_three_complete_pools': three_width_pattern_census(), + 'sharp_total_families': total, 'sharp_irreducible_families': irreducible, + 'boundary_controls': boundary_controls(), + 'limitations': ['No sharp irreducible bound for every fixed (k,nu) is claimed.', + 'No sharpness for a prescribed edge graph is claimed.', + 'No paid word, native implementation, complete invoice or kappa improvement.']} + + +if __name__ == '__main__': + actual = json.loads(json.dumps(result())) + expected = json.loads(Path(__file__).with_name('RESULT.json').read_text()) + require(actual == expected, 'committed exact receipt') + print(actual['status']) + print(json.dumps({'basis_collections': sum(r['counts']['collections'] for r in actual['small_image_basis_censuses']), + 'pattern_spaces': actual['width_three_complete_pools']['counts']['spaces'], + 'total_families': len(actual['sharp_total_families']), + 'irreducible_families': len(actual['sharp_irreducible_families'])}, sort_keys=True))