From d543ba1afe052a36682d2c1723c8a07281c28950 Mon Sep 17 00:00:00 2001 From: Light Chain Date: Sat, 12 Sep 2026 21:02:11 +0800 Subject: [PATCH] All-p width-four visible spectrum and diamond rank-two onset theorems MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit From the #708 509-class certificate: common weighted quotient 3->35->94, then three nonnegative local blocks B5, B15, B16 in t=p/(1-p) give (1+t)^{4m} P0 = tr(B5^m)-tr(B16^m)+2 t^{2m} and likewise P2 with B15, hence M=(tr(B15^m)-tr(B5^m))/(1+t)^{4m} for all p and all m>=2. Generic scalar orders P0=17, P2=23, M=16; p=1/2 drops to 15, p=2/3 to 14. A slower shared B16 mode (~0.774) cancels in M; visible decay ~0.252. Cylinder crossing q4 matches Jacobsen 2015 Table 2 n=4; every finite matching root lies below q4. Thermal m λ^m at the crossing is semisimple. Two-cycle-core lemma: axis onset 2L-1 with L^2 crosses; diamond onset 3L-1 with 4L^2 minimizers. Replaces the invalid #692 union-size bound. Stacked on #708. Additive. Do not merge. Full-repo CI not run. --- notes/completed-636-673-handoff-20260912.md | 56 + notes/crossline-next-results-20260912-zh.md | 80 + notes/two-cycle-core-onsets-20260912.md | 184 + ...h4-parametric-visible-spectrum-20260912.md | 244 + .../two-cycle-core-onsets.json | 258 + .../width4-cylinder-rational-certificate.json | 173 + .../width4-parametric-definition.json | 451 + .../width4-parametric-traces.json | 9992 +++++++++++++++++ scripts/rank_two_onset.py | 114 + scripts/width4_cylinder_certificate.py | 158 + scripts/width4_parametric_traces.py | 333 + tests/test_two_cycle_core_onsets.py | 38 + tests/test_width4_cylinder_certificate.py | 19 + tests/test_width4_parametric_traces.py | 64 + 14 files changed, 12164 insertions(+) create mode 100644 notes/completed-636-673-handoff-20260912.md create mode 100644 notes/crossline-next-results-20260912-zh.md create mode 100644 notes/two-cycle-core-onsets-20260912.md create mode 100644 notes/width4-parametric-visible-spectrum-20260912.md create mode 100644 results/research-control-20260912/two-cycle-core-onsets.json create mode 100644 results/research-control-20260912/width4-cylinder-rational-certificate.json create mode 100644 results/research-control-20260912/width4-parametric-definition.json create mode 100644 results/research-control-20260912/width4-parametric-traces.json create mode 100644 scripts/rank_two_onset.py create mode 100644 scripts/width4_cylinder_certificate.py create mode 100644 scripts/width4_parametric_traces.py create mode 100644 tests/test_two_cycle_core_onsets.py create mode 100644 tests/test_width4_cylinder_certificate.py create mode 100644 tests/test_width4_parametric_traces.py diff --git a/notes/completed-636-673-handoff-20260912.md b/notes/completed-636-673-handoff-20260912.md new file mode 100644 index 00000000..05f5a35b --- /dev/null +++ b/notes/completed-636-673-handoff-20260912.md @@ -0,0 +1,56 @@ +# Updates for existing #636 / #673; no duplicate task + +## #636 — the all-p width-four task is completed + +Starting from #708's fixed input certificate, a 94-state common weighted +quotient and three explicit nonnegative local blocks of sizes 5,15,16 give +all-length polynomial identities: + +``` +P0 numerator = tr(B5^m)-tr(B16^m)+2t^(2m) +P2 numerator = tr(B15^m)-tr(B16^m)+2t^(2m) +M numerator = tr(B15^m)-tr(B5^m) +``` + +Normalize by (1+t)^(4m), t=p/(1-p). The result is proved for all p, all m>=2 +using 126 exact polynomial zero moments, a coefficient-bounded Kronecker +certificate and Cayley-Hamilton, not a parameter scan. Generic minimum scalar +orders are P0=17, P2=23, M=16; special p=1/2 gives 15, p=2/3 gives 14. + +The leading Perron weights near the unique cylinder crossing are one on both +sides. The crossing has a degree-17 defining polynomial and agrees with the +already-published n=4 value q4=.59141717085313848.... A slower shared 0.773935 +relative mode cancels identically from M; its visible relative decay is +0.251749755, with coefficient two. Rational certificates prove every finite +root lies below q4 and the fixed-width displacement formula in the note. + +Do not re-dispatch this same visible-spectrum task or buy another width engine. +The genuinely larger question is an all-width closure/observable-weight theorem +and width-uniform bounds, not a list of more roots. No new hardware or scan is +commissioned by this comment. The thermal-derivative m*lambda^m control can be +cross-linked to #275 without changing that issue's candidate contract. + +## #673 / #692 — rank-two onset and equality classification completed + +The old shared-vertex union lower-bound argument is invalid, but its axis +conclusion is correct. Replace it with the two-cycle-core lemma. A minimal +ambient-rank-two core is a wedge or theta; a dumbbell is excluded by the +intersection form. Systolic lengths yield the axis onset 2L-1 and L^2 crosses. +For the diamond, all three theta cycle lengths are at least2L, yielding +3L-1 vertices; equality and period arithmetic force a full2L line with one +straight transverse L-1-site plug. There are exactly4L^2 minimizers for every +L>=2. Diamond L5 k14,count100 is a theorem, not a task needing2^50 enumeration. + +Read `notes/two-cycle-core-onsets-20260912.md`; preserve the original note and +result history but remove the invalid proof dependency. No additional census +or new duplicate issue is needed. This does not classify every higher-mass +wrapping cell. + +## Validation and integration boundary + +Ten new local mathematical tests passed. The all-p proof, resultant, Hankel +minors and rational root inequalities were actually executed. A clean patch +application check is included in VALIDATION.json. Full repository CI has not +been run for this addition. No remote branch or issue was modified by the +analysis session. The parametric scripts use #708's existing certificate; +the onset proof/script is independent of #708 and may be integrated separately. diff --git a/notes/crossline-next-results-20260912-zh.md b/notes/crossline-next-results-20260912-zh.md new file mode 100644 index 00000000..bf51d9fe --- /dev/null +++ b/notes/crossline-next-results-20260912-zh.md @@ -0,0 +1,80 @@ +# Matching One：两条研究线的实质推进 + +日期：2026-09-12。本轮读取了 #708、#636 的已有闭合资产，另读 #692 的起点证明、#275 最新三条实质评论与 Jacobsen 2015 原文。远端分支、历史结果、冻结记录均未修改；本包供提交处理，不是已经合入的 PR。 + +## 一、全参数的宽度四可见谱已经完成 + +原 #708 只给出 p=1/2 的 15 阶标量递推。本轮先在原 509 个确定性续接类上构造对所有行占据权重同时有效的强可合并划分，得到 `3→35→94→94`。94 不是任意正实现的最小维数，而是这张状态表及其指定读出上的共同强合并结果。 + +设 t=p/(1-p)，每行权重 t^k。三个非负局部块 B5、B15、B16 满足，对所有 m≥2、所有 p： + +``` +(1+t)^(4m) P0 = tr(B5^m) - tr(B16^m) + 2 t^(2m) +(1+t)^(4m) P2 = tr(B15^m) - tr(B16^m) + 2 t^(2m) +(1+t)^(4m) M = tr(B15^m) - tr(B5^m) +``` + +这不是几个 p 点上的数值吻合。标准库验证器用有严格系数界的整数 Kronecker 编码，证明了前 126 项为多项式恒等式；94+15+16+1 的有限实现上界与 Cayley–Hamilton 将其推广到所有长度。三个小块的特征多项式又由直接矩阵乘法的前 5、15、16 个迹独立核对。 + +全参数的一般最小递推阶数为：P0=17，P2=23，M=16。正是共同模式抵消让差值更低阶。精确 Hankel 子式给出下界，完整迹分解给出上界。p=1/2 时阶数降为15；p=2/3 时另一对反号模式碰合并抵消，降为14。单点阶数不能代替一般阶数。 + +完整块矩阵、分解、94 态合并、递推及整数行列式均在 JSON 中；不要求读者信任文字结论。 + +## 二、精确得到宽度四的圆柱根与有限长度位移 + +B5、B15 的 Perron 根分别由一个二次因子和一个五次因子承担，正的可合并商对此给出证明。其 resultant 是 t^10(t+1)^2 乘一个17次整系数多项式。后者只有一次 Descartes 符号变化；Perron 分支的端点顺序交换，故正交点唯一。 + +``` +q4 = 0.591417170853138481798834101735923177964270443... +``` + +它与 Jacobsen 2015 Table 2 的已发表 n=4 数值一致，绝不是无限方格 p_c 的新值。 + +共同 B16 模式在交点的相对衰减率约为0.7739350472，但它在 P0 和 P2 中权重相同，在 M 中精确抵消。M 真正可见的领先修正率为 + +``` +rho = 0.25174975499192538... +h'(q4) = 2.4643526094735922... +``` + +两侧领先权重在交点邻域均为1；完整余谱没有消失。已用有理数根区间、复根对的 Vieta 界和正 Collatz 向量核对相关不等式。结论是所有有限 m≥2 的根均严格小于 q4，而且 + +``` +p_(4,m)-q4 = -2 rho^m/[m h'(q4)] × [1+O(0.674^m)+O(rho^m)]. +``` + +这是固定宽度定理，不给出宽度一致界，也不证明固定长宽比的 L^-4 规律。 + +一个和 #275 有关的进一步结论：热导数在交点自动产生 m*lambda^m 项，即使相交的两个领先 Perron 分支在块对角表示中完全半单。因此，导数响应中的长度多项式因子本身不能识别 Jordan 机制。原始匹配函数的普通迹分解更说明：每个固定 p 下它都是纯特征值幂之和；底层算子可能有不可见的非对角化部分。这里改变的是读出与求导，不是发现了一个新场。 + +## 三、横向解决 #673 / #692 的菱形起点猜想 + +#692 以“两个周期共有至少一个顶点”推出联合顶点数至少2L-1，集合大小不等式方向不对。数值结论可以保留，但证明必须换掉。 + +替换工具是一个可复用的双周期核心引理：任意环境同调秩为二的嵌入图，均含图圈秩恰为二且环境同调映射单射的核心。去叶、压缩二度顶点后，只可能是两圈共一点的楔形或三条内部不交路径组成的 theta；哑铃形因两个不交周期不能有独立环面同调而排除。 + +轴向环面中，theta 必含同时具有两个非零绕行坐标的简单周期，需要至少2L个顶点；楔形至少2L-1，等号恰为一整行与一整列。于是起点2L-1、计数L²得到正确证明。 + +菱形环面周期为(L,L)、(L,-L)，每个非平凡周期至少2L条边。theta 的三个两两路径圈各至少2L，推出三路径总长至少3L、顶点至少3L-1。等号时三路径长度皆L。进一步利用提升位移的 l1 三角等号及模L的坐标同余，证明三条路径必须是三条直的坐标轴方向臂，不能有额外弯曲的等号情况。 + +因此，对所有整数 L≥2： + +``` +菱形 rank-2 起点 = 3L-1 +最小配置 = 一条完整2L点直线 + 垂直方向长度L的直路径的L-1个内部点 +最小配置总数 = 4L² +``` + +菱形 L=5 的 k=14、100个配置现在由证明给出，无须枚举2^50个配置。新证明也修复了 #692 对2L点 spiral 起点的另一处不正确共有顶点论证。每个方向有L条完整线（两族共2L），不是每族2L；高质量端点反例须使用L点NNN链，而不是2L点NN直线。 + +## 四、实际执行与下一步取舍 + +全参数标准库证书运行约1.4秒。对旧小尺寸轴向L=2,3,4和菱形L=2,3，在起点及以下核对了133,711个配置；没有新增大尺寸全枚举。另对4×2、4×3的全部配置独立核对概率系数。L=2,…,8只生成并核对定理给出的最小配置，不是额外的全空间 census。所有10项本地数学测试通过；完整项目CI尚未运行。 + +#636 本次指定的“Q(p) 可见谱、分别处理P0/P2/M”已有完成结果，不应再派同一单。所有宽度的规范闭合与宽度一致谱界仍是更大问题，不能自动变成宽度5、6、…扫描。 + +#673 的菱形起点及 plug 分类可以按本证明结案，#692 应修正文义后再整合；无需为菱形L5开计算任务。 + +#275 保持其原始候选前向映射要求。新热导数对照可以作为防止误读的精确控制，但不是给旧模型增加第三候选或改动冻结评分的许可。 + +本轮没有触及需要大规模CPU/GPU或广泛文献检索的任务，因此没有新增工单或启动外部机器。证明、脚本、整数结果、更新文字均已完成并装入提交包。 diff --git a/notes/two-cycle-core-onsets-20260912.md b/notes/two-cycle-core-onsets-20260912.md new file mode 100644 index 00000000..8fcf4e97 --- /dev/null +++ b/notes/two-cycle-core-onsets-20260912.md @@ -0,0 +1,184 @@ +# Two-cycle cores settle the axis and diamond rank-two onsets + +Date: 2026-09-12. Direct completion of the remaining geometric question in +#673 / draft #692. This is a proof, with small existing-size checks, not a +proposal to enumerate another torus. No novelty claim is made. + +## Result and conventions + +On the nearest-neighbour square-site graph with period lattice + +* axis: `Lambda = <(L,0),(0,L)>`, +* diamond: `Lambda = <(L,L),(L,-L)>`, + +let `r(B)` be the rank over Q of the occupied graph's image in torus H1. +For every integer `L >= 2` (parallel lifted edges at period two retained), + +| Geometry | Least occupied mass with r=2 | All minimizers | Number | +|---|---:|---|---:| +| axis | 2L-1 | a full physical horizontal row union a full vertical column | L^2 | +| diamond | 3L-1 | a full physical horizontal/vertical line of 2L vertices, plus the L-1 internal vertices of one straight transverse length-L arc | 4L^2 | + +The existing digital-Alexander theorem identifies these as the `b x n` +(exclusive cross) cell: black rank two forces complementary matching rank +zero. It is NOT the rank-one spiral / `both x both` cell. + +In the `(u,v)=(x+y,y-x)` convention of #692, a physical horizontal or vertical +line is a straight diagonal line. A physical transverse arc is the straight +plug described empirically there. Thus this theorem addresses exactly the +existing conjecture, not a different lattice or event. + +## 1. The reusable two-cycle-core lemma + +If a graph embedded in a torus has ambient rank two, it contains a connected +subgraph of cycle rank two whose two graph-homology generators have independent +ambient images. Indeed, different connected components cannot carry independent +ambient classes: their disjoint embedded cycles have intersection number zero, +whereas independent classes in H1(T^2;Q) have nonzero intersection. In a component +carrying rank two choose a spanning tree and two off-tree edges whose fundamental +cycles have independent ambient images. Retain the tree and those two edges, +then prune leaves. The graph cycle rank is two and the ambient map is injective. + +After suppressing degree-two vertices, the connected core is either a wedge +of two circles, a theta (three internally disjoint paths between two vertices), +or a dumbbell (two circles connected by a path). This classification follows +from `sum(deg(v)-2)=2` after leaves are removed. A dumbbell is impossible: its +two disjoint circles would have independent ambient images. Thus only wedge +and theta remain. All their simple cycles have nonzero ambient class; for a +theta the three classes are, up to signs, `a,b,a-b`, with a,b independent. + +This lemma concerns a SUBGRAPH of the occupied induced graph. Extra occupied +edges cause no problem: a lower bound on this core is already a lower bound +on occupied vertices. At equality there can be no additional occupied vertex. + +## 2. Axis proof, including the missing inequality in #692 + +A simple cycle of class `(a,b)` has at least `L(|a|+|b|)` edges, by its physical +integer displacement. For a simple cycle the edge count equals its number of +vertices, including a two-edge periodic circle. + +A wedge has two essential circles, each of length at least L, meeting in +one vertex; hence it has at least `2L-1` vertices. Equality forces both circles +to have length L. Independence forces one horizontal and one vertical, and +geodesic equality forces each to be straight. This gives precisely a row-column +cross. + +For a theta, among `a,b,a-b` at least one class has both coordinates nonzero. +Otherwise the independent a,b would have to lie on the two different axes, +and a-b would be mixed. That simple circle has at least 2L vertices. A theta +therefore cannot occur at occupied mass `2L-1` or below. + +The L horizontal rows and L vertical columns give L^2 different crosses, +each with rank two. This proves the onset, equality classification and count. + +The original #692 inference, “the two cycles share at least one vertex, so +union size >= 2L-1”, has its inequality in the wrong direction: a lower bound +on intersection size gives an UPPER bound on a union when sizes are fixed. +The core lemma repairs the proof without invalidating the observed onset. +It also avoids assuming that every rank-two graph contains separately chosen +simple cycles in the two prescribed coordinate classes. + +## 3. Diamond lower bound + +For `Lambda=<(L,L),(L,-L)>`, a period vector is + + L(a+b, a-b), + +whose l1 length is `2L max(|a|,|b|)`. Every nontrivial simple cycle therefore +has at least 2L edges. + +A wedge consequently needs at least `4L-1` vertices. In a theta let the three +path lengths be `l1,l2,l3`. Each pair is an essential simple circle, so + + l1+l2 >= 2L, l1+l3 >= 2L, l2+l3 >= 2L. + +Adding gives `E=l1+l2+l3 >= 3L`. A connected theta has `V=E-1`, hence +`V >= 3L-1`. This proves the lower bound on every occupied configuration. + +At equality the core must be a theta and all three pair bounds are equalities, +so `l1=l2=l3=L`. The remaining issue is whether bent geodesic paths create +additional equality cases. The period arithmetic rules them out. + +## 4. Diamond equality: three straight arms, not arbitrary bent plugs + +Orient the three length-L paths from the same branch vertex u to v. Lift them +from the same lattice representative of u and write their physical displacement +vectors as d1,d2,d3. Their pairwise differences are nonzero period vectors, +so + + 2L <= ||di-dj||_1 <= ||di||_1+||dj||_1 <= 2L. + +Every inequality is an equality. Thus `||di||_1=L`, and no two displacement +vectors use the same coordinate with the same nonzero sign: otherwise the +triangle inequality for their difference would be strict. + +There are only four signed coordinate slots: x+, x-, y+, y-. Three nonzero +vectors cannot each use two slots without overlap. At least one vector uses +only one coordinate and hence equals `(+-L,0)` or `(0,+-L)`. All di are congruent +coordinatewise modulo L, because their differences lie in Lambda. Therefore +all their coordinates are multiples of L. With l1 norm L, EACH di must be +one of these four axial vectors. They are distinct, so exactly two are an +opposite pair and the third is perpendicular. + +A nearest-neighbour path of length L with displacement `(L,0)`, for example, +uses L positive horizontal steps; there is no room for a detour. All three +paths are straight. The opposite pair forms a full line of 2L vertices; the +remaining arm contributes exactly L-1 internal vertices of a transverse plug. + +Conversely, every such line-plus-plug is a theta with independent essential +cycles, so it has rank two. This proves the full equality classification. + +## 5. Exact count 4L^2 + +There are two physical line directions and L disjoint full lines of each +direction. For a given full line, choose one endpoint on its 2L vertices and +one of two transverse directions. Reversing the same length-L arc counts it +twice, so there are `(2L*2)/2=2L` distinct plugs per full line. + +No occupied minimizer is counted under two full lines. Parallel full lines +are disjoint. A horizontal and a vertical full line on the diamond quotient +meet in two vertices; their union has `4L-2 > 3L-1` vertices for L>=2. The full +line in a minimizer is therefore unique. The count is + + 2 * L * 2L = 4L^2. + +In particular the previously proposed diamond L=5 onset is now a theorem: +`k=14`, count 100. No `2^50` enumeration, or even a new low-k census, is needed. + +## 6. Other #692 statements that the proof repairs or narrows + +At diamond mass 2L, rank two is impossible by the new bound. A rank-one cycle +with both generator coordinates nonzero must attain the systolic bound with +both `(u,v)` displacements of magnitude 2L. Every step then has the same +sign pattern, forcing one of the 2L full straight diagonal lines. The +`both x both` spiral count 2L at this mass follows, using the existing exact +rank-one label map for the complementary graph. This replaces #692's other +use of the incorrect shared-vertex union argument. + +Two local wording errors in its high-k proof should also be corrected: +there are L lines PER diagonal family (2L total), not 2L per family. For the +sharpness example with exactly L white sites on the diamond, use an NNN +chain with physical steps `(1,1)` (or `(1,-1)`) closing after L steps, not a +full NN straight line of 2L sites. The high-k conclusion itself survives. + +This note does not assert a general classification of all higher-mass cells, +Galois properties of matching polynomials, or any critical scaling exponent. + +## 7. Executed checks and source trail + +`python scripts/rank_two_onset.py` exhaustively checks all occupied subsets +AT OR BELOW the predicted onset on axis L=2,3,4 and diamond L=2,3: 133,711 +configurations total. A direct physical integer-lift graph traversal finds +zero rank-two configurations below the bound and exactly the predicted sets +at equality. Counts are 4/9/16 on the axis and 16/36 on the diamond. + +Every predicted minimizer at L=2,...,8 was also constructed and its rank +checked, without enumerating the surrounding configuration space. These are +checks of the proof and constructor, not new stochastic evidence. + +Source read through the connector: draft #692, +`notes/wrapping-five-cell-onset-proofs-20260908.md`, blob +`6a3ac9dcf6e1c7f8bbef853379a0e02ea8ef4cad`, especially sections 3b and 5c. +The geometry there agrees with the physical periods used here. The cell +translation uses merged #702, not the superseded #690 directional conjecture. +Full repository CI for this new file has not been run. diff --git a/notes/width4-parametric-visible-spectrum-20260912.md b/notes/width4-parametric-visible-spectrum-20260912.md new file mode 100644 index 00000000..d52a937d --- /dev/null +++ b/notes/width4-parametric-visible-spectrum-20260912.md @@ -0,0 +1,244 @@ +# Width four: exact all-p sector traces, visible cancellations, and a cylinder crossing + +Date: 2026-09-12. Completed continuation of #636 / draft #708. No new engine, +width scan, Monte Carlo or GPU work. No novelty claim for the published crossing +value or for the general linear-algebra tools. + +## 1. The missing all-parameter identity is now established + +Use #708's exact rank-future automaton for the axis square-site torus +`(4,0),(0,m)`, physical length m>=2. Let `t=p/(1-p)` be SITE fugacity. +Each row mask s has weight `t^popcount(s)`. An entire configuration with m +rows is normalized by `(1+t)^(4m)`, not `(1+t)^(4(m-1))`. + +From its 509-state quotient, three explicit nonnegative local submatrices +B5(t), B15(t), B16(t) of sizes 5, 15 and 16 give + + (1+t)^(4m) P0 = tr(B5^m) - tr(B16^m) + 2 t^(2m), + (1+t)^(4m) P2 = tr(B15^m) - tr(B16^m) + 2 t^(2m), + +and consequently + + (1+t)^(4m) M = tr(B15^m) - tr(B5^m). (1) + +These are exact polynomial identities for EVERY m>=2 and every p in [0,1] +(endpoints by polynomial continuity). A block trace alone is not a probability; +P0 and P2 require the common subtraction and restoration terms displayed above. +The signed trace is NOT just the difference of two leading eigenvalue powers. + +The matrices are fully specified by sparse polynomial rows in +`results/research-control-20260912/width4-parametric-traces.json`. The selector +indices in the upstream 509-state table are: + +* B5: `[0,16,17,18,19]`; +* B15: `[15,139,140,141,142,143,144,145,146,147,148,149,150,151,152]`; +* B16: `[1,21,22,23,24,25,153,154,155,156,157,158,160,161,163,481]`. + +Precisely, `(Bd)ij` is the sum of `t^popcount(s)` over row masks whose +upstream successor of selector i is selector j; transitions leaving the set +are omitted. This is a concrete local operator, not a diagonal list of all +configurations. The entire construction is reproducible from the pinned source +blob `50b7297deefe7c50215aea2ed534ca5810461af3` at #708 head +`f782061c1a592ed2f9fd0e9dabaa45f0e54bc4e7`. + +For example, putting a=1+4t+6t^2, b=1+4t+5t^2, + + B5 = [[a,t^3,t^3,t^3,t^3], + [b,t^2+t^3,t^3,0,t^3], + [b,t^3,t^2+t^3,t^3,0], + [b,0,t^3,t^2+t^3,t^3], + [b,t^3,0,t^3,t^2+t^3]]. + +This is not an all-width intertwiner with Jacobsen's pTL representation. It +settles the finite width-four probability/closure question in its own explicit +representation. + +## 2. Why finitely many calculations prove (1) for all m and t + +First, common coefficientwise strong lumping of the 509 states gives +`3 -> 35 -> 94 -> 94` blocks. Rates into each block agree separately for every +row occupation count k=0,...,4, on ALL 509 source states. Hence this quotient +preserves P0 and P2 for every fugacity, including a prescribed varying fugacity +from row to row. It is not claimed minimal among arbitrary positive realizations; +it differs from #708's deterministic 509-class rank language. + +The 94-state scalar sector sequence has a linear realization of dimension 94 +over Q(t). The sequence `tr(Bd^m)` has recurrence order at most d by +Cayley-Hamilton. The monomial `t^(2m)` has order one. Thus a difference between +the proposed P0 formula and the actual sequence has order at most +`94+5+16+1=116`; for P2 the bound is `94+15+16+1=126`. + +The verifier proves the first 126 differences identically zero as INTEGER +POLYNOMIALS, not at a fitted grid of parameter values. It uses radix +`T=2^512`. At length m each polynomial has degree at most 4m; an l1 coefficient +bound on the P2 difference is `34*16^m` (24 for P0). For m<=126 this is below +T. If an integer polynomial with all coefficients strictly between -T and T +evaluates to zero at T, its constant coefficient is a multiple of T and must +be zero; divide by T and repeat. Evaluation is injective under this proved +bound. This is exact Kronecker arithmetic, not numerical interpolation. + +The 126 polynomial zero identities then imply every subsequent identity by +the finite-dimensional recurrence over Q(t). Matrices and weights are polynomial, +so the identities extend to all parameter specializations, including ones where +a generic minimal realization degenerates. + +Small-block characteristic factors are independently checked against raw matrix +traces through orders 5,15,16; Newton identities determine their characteristic +polynomials. The factor-coefficient bounds are also below the same radix, so +these checks are polynomial identities. No assumption about numerical rank or +nearby parameter samples enters the proof. + +## 3. Complete generic visible spectrum + +All monic factors, with coefficients in Z[t], are in +`width4-parametric-definition.json`. Denote the quadratic factor of B5 by C2, +the two cubics and quintic of B15 by O3a,O3b,O5, and the cubic/two quartics of +B16 by S3,S4a,S4b. Exact factorizations are + + char(B5) = (x-t^2(1+t))^2 (x-t^2(1-t)) C2, + char(B15) = (x+t^2) O3a^2 O3b O5, + char(B16) = (x+t^2) S3 S4a S4b^2. + +For a monic f let tau_f(m) be its root power sum, multiplicities included. +Then the all-p matching spectrum is + + (1+t)^(4m) M = (-t^2)^m - 2[t^2(1+t)]^m - [t^2(1-t)]^m + - tau_C2(m) + 2 tau_O3a(m) + tau_O3b(m) + tau_O5(m). (2) + +Every visible weight is explicit. Repetition in a characteristic polynomial is +not a license to add a Jordan-polynomial term to this trace formula. + +The generic minimal scalar recurrence orders over Q(t) are + + P0: 17, P2: 23, M=P2-P0: 16. + +Upper bounds follow from (2) and the analogous sector factor lists; nonzero +17x17, 23x23, 16x16 physical-tail Hankel determinants at t=3 prove matching +lower bounds. Their integers are saved. The generic M recurrence is squarefree, +certified by a squarefree specialization at t=3 of its monic polynomial. + +In fact the ordinary-trace formula has a stronger fixed-parameter implication: +for EVERY fixed interior p, the undifferentiated scalar tail is a finite sum +of pure eigenvalue powers. Even a defective block contributes only its +algebraic multiplicity times lambda^m to an ordinary trace; its nilpotent +part has zero trace. Thus no m*lambda^m term is required by this scalar law +at any fixed p. This does NOT imply that the 509-state operator, or even +every matrix block, is diagonalizable. It is an observable statement. + +Specializations matter. At t=1 (p=1/2), `t^2(1-t)=0`, whose contribution vanishes +on physical lengths, leaving order 15, exactly #708's result. At t=2 (p=2/3), +`t^2(1-t)=-t^2`; two opposite-weight terms cancel and the order is 14. Explicit +nonzero Hankel minors prove both specialized lower bounds. A single p value +therefore does not determine the generic visible order. These are changes of +observability/cancellation, not changes of microscopic state number. + +## 4. Perron crossing and its defining degree-17 polynomial + +All three nonnegative blocks are irreducible and aperiodic for t>0. Positive +equitable quotients of sizes 2,5,4 respectively retain their Perron roots. +Every coefficientwise quotient identity is verified. The relevant closed +quadratic and open quintic are thus C2 and O5, not arbitrarily selected factors. + +Write their Perron eigenvalues alpha_c(t), alpha_o(t). At t=0, +alpha_c -> 1 and alpha_o -> 0. At large t, alpha_o >= t^4 from its full-row +self-loop, while alpha_c <= 1+4t+6t^2+4t^3, so they must cross. +An exact 7x7 Sylvester determinant yields + + Res_x(O5,C2) = t^10 (t+1)^2 R17(t), + +where, descending, + + R17 = 9t^17+198t^16+1305t^15+5205t^14+12915t^13+16534t^12+1795t^11 + -28383t^10-51259t^9-52627t^8-39092t^7-23218t^6-11396t^5 + -4503t^4-1344t^3-278t^2-35t-2. + +There is exactly one positive root by Descartes' rule and endpoint signs. +The existing Perron crossing must be that root, and is unique. In physical p, + + q4 = 0.591417170853138481798834101735923177964270443192880... + +It matches the ALREADY PUBLISHED width-four entry of Jacobsen 2015 Table 2. +This is neither a new infinite-square pc nor a certified interval for pc. +A rational bracket for t (160 bisections) and its p image are in the companion +certificate. Polynomial irreducibility/minimality is not asserted. + +Near q4 the shared block's Perron root is strictly below both alpha_o and +alpha_c. This is certified by a positive rational Collatz vector, not inferred +from printed eigenvalues. Thus the leading weights of P0 and P2 are both +exactly one near this crossing. Equal leading weights still leave all the +subleading terms in (2). + +## 5. Cancellation makes the observable relaxation rate different + +At q4 the shared B16 Perron root divided by the common leading root is +approximately 0.773935047152260. It appears in BOTH P0 and P2 with coefficient +-1 and cancels from M IDENTICALLY for all t, not only at the crossing. + +The largest remaining subleading root in M is the positive O3a root mu, +with coefficient two. Its ratio at q4 is + + rho = 0.2517497549919253805536005833510364513603... . + +An estimate based on the slower common 0.774 mode would therefore give the +wrong finite-length rate for the signed observable. This is a concrete +square-site example of why the complete operator or either probability's +slowest correction is not automatically the relevant observable correction. + +Let h(p)=log(alpha_o/alpha_c), accounting for t=p/(1-p). The common probability +normalizer cancels in this ratio. Rational intervals prove h'(q4)>0, with +numerical diagnostic `2.4643526094735922165...`. All other visible subleading +root moduli divided by mu are below theta=674/1000. Complex pairs are bounded +by rational Vieta product/discriminant intervals; they are not discarded. + +After the leading cancellation at q4, the remaining trace sum is bounded below +by `mu^m [2-16 theta^m] > 0` for m>=6. Lengths 2,...,5 are checked by exact +polynomial interval signs. Hence + + M_(4,m)(q4)>0, and p_(4,m)=2. + +The latter uses strict monotonicity of finite expected rank, not a fitted root +sequence. Taylor expansion of the locally separated eigenvalues gives + + p_(4,m)-q4 = -2 rho^m/[m h'(q4)] * [1+O(theta^m)+O(rho^m)]. (3) + +This is a fixed-width result. It provides NO bound uniform in width and no +fixed-aspect L^-4 theorem. + +## 6. A useful thermal-jet warning for #275 + +Differentiating the leading difference at the crossing gives + + partial_p M_(4,m)(q4) + = m lambda_*^m h'(q4) + partial_p R_m(q4), + +where lambda_*=alpha_o/(1+t)^4=alpha_c/(1+t)^4 is the normalized leading root. +The factor m comes from differentiating two crossing simple Perron branches. +The leading eigenspace of `diag(B15,B5)` is SEMISIMPLE: each block has a simple +Perron root and the blocks are uncoupled. Thus a polynomial-in-length factor +in a thermally differentiated trace can arise without a defective leading +operator. + +A transparent control is `diag(lambda+e,lambda-e)` with weighted trace +`(lambda+e)^m-(lambda-e)^m`: its derivative at e=0 is +`2m lambda^(m-1)`, although the matrix is diagonal for every e, including zero. +This does not refute an LCFT mechanism. It says that a candidate-specific map +through normalization, differentiation and moving-root evaluation is needed +before such a polynomial factor can distinguish mechanisms. It strengthens +#275's existing map requirement; it does not reopen that issue with a third +post-hoc model or a new sampling order. + +## Sources, execution, and boundaries + +Repository source: #708 head f782061c, exact state-certificate blob stated +above. Earlier #705/#707 provide width-two/three controls; none was rerun as +a new campaign. The primary external comparison is Jacobsen, +*Critical points of Potts and O(N) models from eigenvalue identities in periodic +Temperley-Lieb algebras*, arXiv:1507.03027v1, sections 4 and 6.1, Table 2: +https://arxiv.org/html/1507.03027v1 . PRIMARY_TEXT_READ on 2026-09-12. +The published eigenvalue value and limit order are attributed to that source. + +`width4_parametric_traces.py` verifies the full polynomial identities with only +the Python standard library. `width4_cylinder_certificate.py` uses mpmath to +propose root bands, then checks every load-bearing sign and inequality with +Fraction arithmetic. Actual execution times and local test results are in the +handoff validation file. No full-repository CI was run for these additions. diff --git a/results/research-control-20260912/two-cycle-core-onsets.json b/results/research-control-20260912/two-cycle-core-onsets.json new file mode 100644 index 00000000..094ebbe7 --- /dev/null +++ b/results/research-control-20260912/two-cycle-core-onsets.json @@ -0,0 +1,258 @@ +{ + "schema": "matching-one.two-cycle-core-onsets.v1", + "theorems": { + "axis": { + "minimum_mass": "2*L-1", + "minimizer_count": "L^2", + "structure": "one full physical row plus one full physical column" + }, + "diamond": { + "minimum_mass": "3*L-1", + "minimizer_count": "4*L^2", + "structure": "one full physical row/column of 2L vertices plus L-1 internal vertices of a straight transverse length-L arc" + } + }, + "scope": "NN square site, honest axis/diamond quotients, L>=2; rank2 only", + "small_existing_size_checks": [ + { + "L": 2, + "geometry": "axis", + "sites": 4, + "onset": 3, + "configurations_checked": 15, + "rank2_below_onset": 0, + "minimizers": 4, + "all_minimizers_match_classification": true, + "minimum_configuration_masks": [ + 7, + 11, + 13, + 14 + ] + }, + { + "L": 3, + "geometry": "axis", + "sites": 9, + "onset": 5, + "configurations_checked": 382, + "rank2_below_onset": 0, + "minimizers": 9, + "all_minimizers_match_classification": true, + "minimum_configuration_masks": [ + 79, + 121, + 151, + 186, + 295, + 316, + 457, + 466, + 484 + ] + }, + { + "L": 4, + "geometry": "axis", + "sites": 16, + "onset": 7, + "configurations_checked": 26333, + "rank2_below_onset": 0, + "minimizers": 16, + "all_minimizers_match_classification": true, + "minimum_configuration_masks": [ + 4383, + 4593, + 7953, + 8751, + 8946, + 12066, + 17487, + 17652, + 20292, + 34959, + 35064, + 36744, + 61713, + 61986, + 62532, + 63624 + ] + }, + { + "L": 2, + "geometry": "diamond", + "sites": 8, + "onset": 5, + "configurations_checked": 219, + "rank2_below_onset": 0, + "minimizers": 16, + "all_minimizers_match_classification": true, + "minimum_configuration_masks": [ + 31, + 47, + 79, + 87, + 93, + 117, + 143, + 171, + 174, + 186, + 213, + 234, + 241, + 242, + 244, + 248 + ] + }, + { + "L": 3, + "geometry": "diamond", + "sites": 18, + "onset": 8, + "configurations_checked": 106762, + "rank2_below_onset": 0, + "minimizers": 36, + "all_minimizers_match_classification": true, + "minimum_configuration_masks": [ + 4223, + 8136, + 8383, + 12240, + 16703, + 20448, + 33343, + 36801, + 37455, + 37497, + 37833, + 40521, + 62025, + 66623, + 69570, + 74910, + 74931, + 75666, + 77010, + 124050, + 133183, + 135108, + 149799, + 149820, + 149988, + 151332, + 162084, + 210066, + 234057, + 248100, + 258113, + 258178, + 258308, + 258568, + 259088, + 260128 + ] + } + ], + "total_configurations_checked": 133711, + "construction_checks": [ + { + "L": 2, + "geometry": "axis", + "constructed_configurations": 4, + "mass": 3 + }, + { + "L": 2, + "geometry": "diamond", + "constructed_configurations": 16, + "mass": 5 + }, + { + "L": 3, + "geometry": "axis", + "constructed_configurations": 9, + "mass": 5 + }, + { + "L": 3, + "geometry": "diamond", + "constructed_configurations": 36, + "mass": 8 + }, + { + "L": 4, + "geometry": "axis", + "constructed_configurations": 16, + "mass": 7 + }, + { + "L": 4, + "geometry": "diamond", + "constructed_configurations": 64, + "mass": 11 + }, + { + "L": 5, + "geometry": "axis", + "constructed_configurations": 25, + "mass": 9 + }, + { + "L": 5, + "geometry": "diamond", + "constructed_configurations": 100, + "mass": 14 + }, + { + "L": 6, + "geometry": "axis", + "constructed_configurations": 36, + "mass": 11 + }, + { + "L": 6, + "geometry": "diamond", + "constructed_configurations": 144, + "mass": 17 + }, + { + "L": 7, + "geometry": "axis", + "constructed_configurations": 49, + "mass": 13 + }, + { + "L": 7, + "geometry": "diamond", + "constructed_configurations": 196, + "mass": 20 + }, + { + "L": 8, + "geometry": "axis", + "constructed_configurations": 64, + "mass": 15 + }, + { + "L": 8, + "geometry": "diamond", + "constructed_configurations": 256, + "mass": 23 + } + ], + "diamond_L5_onset_prediction": { + "mass": 14, + "count": 100, + "enumerated": false + }, + "proof_not_enumeration": "two independent cycles reduce to a wedge or theta; systolic bounds and equality cases", + "seconds": 0.5535173930001065, + "limits": [ + "no new diamond L4/L5 enumeration", + "does not classify every higher-mass wrapping cell", + "no threshold exponent or continuum field claim" + ] +} diff --git a/results/research-control-20260912/width4-cylinder-rational-certificate.json b/results/research-control-20260912/width4-cylinder-rational-certificate.json new file mode 100644 index 00000000..205d0a23 --- /dev/null +++ b/results/research-control-20260912/width4-cylinder-rational-certificate.json @@ -0,0 +1,173 @@ +{ + "schema": "matching-one.width4-cylinder-rational-certificate.v1", + "root_t_interval": [ + "2115500461319647468452697173804392156435888609193/1461501637330902918203684832716283019655932542976", + "1057750230659823734226348586902196078217944304597/730750818665451459101842416358141509827966271488" + ], + "root_p_interval": [ + "2115500461319647468452697173804392156435888609193/3577002098650550386656382006520675176091821152170", + "2115500461319647468452697173804392156435888609194/3577002098650550386656382006520675176091821152169" + ], + "one_positive_root_Descartes": true, + "q4_diagnostic": "0.591417170853138481798834101735923177964270443192880060835546", + "matches_Jacobsen_2015_table2_n4_within_1e_minus40": true, + "real_root_intervals": { + "closed_2": [ + [ + "1212604803069/40000000000", + "15157560038363/500000000000" + ], + [ + "239640634889/1000000000000", + "23964063489/100000000000" + ] + ], + "open_3a": [ + [ + "3815912025933/500000000000", + "7631824051867/1000000000000" + ], + [ + "-2982810849757/1000000000000", + "-745702712439/250000000000" + ], + [ + "494445852579/500000000000", + "988891705159/1000000000000" + ] + ], + "open_3b": [ + [ + "1165037546481/250000000000", + "186406007437/40000000000" + ] + ], + "open_5": [ + [ + "1212604803069/40000000000", + "15157560038363/500000000000" + ], + [ + "-89807118917/31250000000", + "-2873827805343/1000000000000" + ], + [ + "-109627596967/200000000000", + "-274068992417/500000000000" + ] + ] + }, + "real_root_diagnostics": { + "closed_2": [ + "30.31512007672517722290414508827443495933", + "0.2396406348892579307894248369901426651694" + ], + "open_3a": [ + "7.631824051866361510106240422781711121435", + "-2.982810849756027858456880714510796681084", + "0.9888917051580872301803753892988188254901" + ], + "open_3b": [ + "4.66015018592407740656392641032145244635" + ], + "open_5": [ + "30.31512007672517722290414508827443495933", + "-2.87382780534384618983039047424322956414", + "-0.5481379848343955514082228829410180111188" + ] + }, + "complex_pair_controls": { + "open_3b": { + "sum": [ + "10197614302246137534819689739160923008646731550373038896531945454729459346078866985012456430391383495689/10429624198832568761694441924656016184583518175569593603257039100694432254788283935658994565120000000000", + "63735089389103544743865764424516359066071172291287981384726213827226403479391724545340918105283456482057/65185151242703554760590262029100101153646988597309960020356494379340201592426774597868716032000000000000" + ], + "modulus_squared": [ + "3131107543871291827992721575079501512553169994965441431262305171106110445980358989454115533004575113991097503447755305747042929391675687949639010725516575258948326234321832754898575766183774043883204838333692533107389481518881409256050596529278502652646372640513211652256683107333184540206994696023916871146446535286144579708379489152237119140625/648179214611573706651331920461824142950988560653676836279825341529660188502254532776697499138275702421155047579827562739663631251833664568637797207007208197872669039496901309765540216608338461811725732469252894790289016049720735620765499477868060063476017935486004260167914700752168959565219910718861160106655021203836560513787963350275558735872", + "611544442162361685154828432632715139170541014643593212612572882347548708943661346340283952987225505540207890301592180951769042569326602246199280537625699257203384055221988313983715991890934008410655900272389165473519103179164565713323525516573627856144569452511630150291398009254776088569155741979070102772001613077829295505076153097647705078125/126597502853795823609757277998214480891547767917099187208964752126516785173452032171093645463470062344965430109250473691064645284106812533610983297133653040050320070519294765536583260775652540094314352761439422339407271000858055579059217356857998770575595346863848655544581199592687810147073875580031402037580184461557393295051314010745206734848" + ], + "discriminant": [ + "-55435896209981433415563700424075207415269587381507601377497862157740242902496863788275079395051490754591852005132482156246165230896366659309546752389402553358720712781192515481199105183158792113845161854222101770351001969821319382340415873863811941291772641754798511181070230601439534531179804218892698252052381356597154529404909308055110809059439912865405917/3018319674820800390476161909060823461807913015296439819549673846400184277855206302907315384470702704071174385768186418797126896002455056515001852444020582200296403658850068224348622817412675382955416506801591452107602858563853635288696702882242173447027095481487480534185914983575053456951949014187607813777451144732413132072718477505331200000000000000000000", + "-177394867871919717987786660695265909725306362573315852683855515395169341319592429272241938735331140708959826817387306828611340994123711950270764286480558434477825288545514501458948868655974959973894158871624539779778161386587791811718237609959508959491639299434317284618102856468735300754094968854098582237163157264230917887815541116298679778355374868951678425777/9658622959428633848597584969726564630135723362172794882652541123772564359042861055980585502658422327356860750613027255828136671361828812489476758346068981258163884870661814656340185055260933366592611856300426941965356708313833707880459718076408804408848552934616867604373614501240386956411896805746274592081532198247858293559967925403648000000000000000000000000" + ] + }, + "open_5": { + "sum": [ + "1728095172132431346996927921812230978350733471673873824252224512283550464858003072274588886221841416926441223462734708387731752133912903238880753809438033550715707950985092235610929489240540375483015281/1113877103911668754551067286547922686741510866027480451801560673315252726369306002564920119950530126899082595110740822097336109551117050292542153642510306198303709637294986560078826707091456000000000000", + "108005948258485811144291433004742761263148577485893774829794141690208995306971730848095291963089907639839395501283107802270557336325559789405400624994984866349772489587175168987737871409518674309618689/69617318994479297159441705409245167921344429126717528237597542082203295398081625160307507496908132931192662194421301381083506846944815643283884602656894137393981852330936660004926669193216000000000000" + ], + "modulus_squared": [ + "83642468061344052676367867533010307750329377220331794541775210122283706199759725975320200230016510619330038889531323759648713502121393401000259887495317685655515655953493585835608993983716626926511544443901713330259779592636809611558557837578761667158853225855205105310145327578319200872285335258500773713324835626680331221406102696879945740679725777979584244220195505561114457582143449391242343374920458130328147025987435330043422564828327058644893438066501622002624804114585584474729173962042076846198313918287748175500655287891367346189356455754727724612477757384564034793484374051738343769329132619667656344853292145095568176475353538990020751953125/19290836798378244908642337266856865586230345632215353078291425692833039259457303699469134683295293360375023305491788670554780725280767353351187225130180748602267450644428399220112802219286224234223446142524214752538817458961227912293171043854854273589737774827985235614886700786818357512375109198830535859655276726474946675579081950660515125593194380361282449200114896995653393902219223653857922648431204689395002221845743749129164361347970479935739341033841475191755337541152494139165865145798369331254044519436220619472346228013316804469960222439730243848711105125645898486674888982303651028122351498588294834700177652720868905422352567464411023802368", + "2042052442903907536044137390942634466560775811055410958688740364092350643382201376099769261849258163282836433093022667945354502330464002430595390948525248591108160161035497556916801891001011829899097996463779758553194084743215141575159560382573970193940353234677022436345621664822452550465565815164366422236165580994073629882210492550809517661660829946339369148959981024497457105500061572902343998067025297557105707971122498169978236298766444789087163068719249732504949853870072960307836417188944468161025944847404848925672836236217684413473257425319505028270523201575225192627037879437971521118402653101917731219515418322107871063053607940673828125/470967695271867738682496036706649893301780403249526444510483881905752715006697640076745309880291914509548575612493566584568030230762861613864470780845903343748229569390327787789076057114609338119079363166004605546439642865692429684076141931930489542112980927353860693361822242547001139869219871527615718310669417644013403317809686499902488402084560541549557027433882561392183423228540834072479144183508791234006932853725130539588069106726295429986969446572289822253893048582267766151422744241397462954643062410158150437479009560119404842878166135264823347978368695089850782454569574860781424808458091283544648307309099435261955466735033657950470144" + ], + "discriminant": [ + "-104824163687052887572602781821223929757242200174992453465464753060004974462004400105739392261905012956278611380978707214041874567991249404081341057058496098218184329904762103065819968589662142163822050008373091350046559138090038019380645763290925418692325343608974998397202155369473912408346053139063496838863189362013932357236532634937576647033143793643245363268146756691915710703852551443109583752947672501267353901904289528431177546521026062619464355391175793830402223744750196998202007422865388412965330337245827070180256540203799792218924610681757035440111301206521755996991639959643280881274952548249981351976751918699726796244261301294266150227752063692832829/7017965544341023842729569028417019446220701981328821845508871702935587093333864809226174799804268993579575056023799875148654434543294632641441684675900687929216467878078338321880639450469752224073996591061422311461562557007259572805108754812635325522914244642166207631853554286763088999229965679759021376232347155273160387841011382637955075533458002530776814035086073896172395694681120426542746188990902770072325063552336849862159328262899747937723538973514584038464621433351453634372692469379268034616754388960572338662728809716096592588397355903160919963991175518778723216869973761748990786201627422624001626779274634052246145408377552896000000000000000000000000", + "-4293597744617484664137316157922911673060733151970392654266507863073745694449563710786970922619458872100597662442323846032287120005003271729200728479056420996245916143280238695363871734853543602828812472427800764338409927797700861673700778382324054702414517937958870810200116792763521518688969102202839149087276295104030410494507606529222306856557820345068771946245202677257978589499326322637271622563379596452533900476895810453833049341257966059776053601239832983747135043086176574627108630908336420290564751748564377971994740890892257154113951301598224853096044452811002512087121857743213748251421148976607994406977895813191998106611590112913631396890582367109783657733/287455868696842266747986335558546566758011961463322536323836828661457289151211138061719159533013304477557887218770215966623734314453115364181805031451296040449551502532190072836172613788935903224698396660748343952578566356915651444989011345131013893928196651160497004015545558733021579867230492812850115592111300326510469251559405783720539891618406479973829525710864320332607536050963754264383355504739354392811689106311555938857262750684775113101889804509900140639474057274348946499315874960994263459057279220763156108146104634006571836321953273411545810829268472278802074293418064449781939806377164998476130287351871322406365058159121386176512000000000000000000000000" + ] + } + }, + "shared_Perron_Collatz": { + "vector": [ + "1", + "14779945921/10000000000", + "15086051803/10000000000", + "2715215261/2000000000" + ], + "lower": "732422580956299276655945843927485375485824688577289335001162181494692895777853095599983330980443603356404954240568749747121833927330437250009366315735224521/31217485503159922313815972297931663057485981426649711508591569596253717388197656201203061030634919711598269311214066228954479756792882853062901760000000000", + "upper": "138117062477154188478938376859066145622748022884167810868241689569903532060401242928591221198317176122232976725681340583541077700774957900475043897250061245/5886857543250901352746042258692625232989686034359167406920221231227042190620896278181669620379112109373966384426506649403501751748653398287717164610748416", + "ratio_to_leading_diagnostic": "0.77393504715226000328599293838" + }, + "leading_prefactors": { + "P0": 1, + "P2": 1, + "M_open": 1, + "M_closed": -1 + }, + "hprime_p_interval": [ + "22538000383444220457804087884667807449839817440172910732202465287565780155940670418276006446390969814131886391789042001365994078842320848762329190424780687720415982432823643614795312182036243080395589145973220971000889324518585004069984014304196132612385504170245162354675320392500988566771275255041683689552947950372293675156012153347057218687292469374090200328902679595824609721116989157652633067389686834752300002617665099054291345400050582186973286690180409557069791533432646243524303455247505096312238730045520577407431959620260232720080681987246109014383549491746609366614857656792084225174336184030462908398803766348229536958057322069678401218130702773941073307988922290858835118598495840067217219733055333725210141420358630923429536465308535672928081592361171370536564443882151724038488685493268287347595007491918123242427397025226138893256036249642580803122802734375/9145606962587260428531394344526809795411250690624789820970659282380787458338791932989613886345286652118673199272988749282541474288558326899714910217915872771161403459365204784720498669747830896208228704023189740907958178822190127556510303568823781224880554026204973874619354227724238903836249253966151496593990239014124772937143510269419954357594019585913938818882271411294069479786742314277402359252553384085011272364031530500920446344940131980562813384793265069985749028889089493185364445760089262228273914578024537027752488047427538949043418994429250389343091815538882817104766583009550026512676337940073745187227656711842230645753314802689127758648791199349751924007936973651994465474029398563459325276004083090558713132550174264977865376457224688588767563391164405209228901655543648237450233969478664825296556019382311955585289183734433011437954140786499987887014019072", + "270456004601842059730759466651399179295072691953297656408520867540477016783133082443599205439729136613270888078137431330242892568020003504295453750075611751429368240332541574847237946628214856057366506922523995124539006814305016940981044942767544290053217302057925689956586610580088963382261697661403238129844433290225101222335728967241770524383919512032816530404983653374889169244813034615729817895487837957994079680397640558266180930370358841645612625343407538657002928985251480362799374297597007507581221690087314522002247457189235303324908050204393720436859012411137047872013449058442429976480496241267512021984955893588478780931207783861769141710893614994091229222909687032120265302936554478713764010257610660771498005416872453991079260959762423879371889119522652213394189678898722632693911480131535517275440567796587970818189633757165603851491373466183305890613/109747283551022279917086220878698501772948938338584265348396553857197465294954474720041140680258546299132335981072060251116926116413947783913817795227694419392132049014085241061164807502390986943560131391855589001201619885386974539096663837042928211879866204096755142063049300966888594173452413908693070653640068616371793109270664037727219493333561077293589426664608818106989627070847972000002843506664508533705143785415579523209194799508866131026370099849787953430419696068715432536879428176856675558459071945858439861762675264059977504575011952120301254255416823233506438531221030673012330934242990246523794682999347011975450938208972046992102073818105813565280834166250593364240233442424976498183206226713896597717182545769409100078238466076976303003966335869980560660744624792694385399037424871027997316567506908086955259745323297692445210944238488538344062976000" + ], + "hprime_p_diagnostic": "2.4643526094735922165361435647888775610171547", + "rho_diagnostic": "0.251749754991925380553600583351036451360319778", + "relative_remainder_ratio_upper": "337/500", + "all_m_root_sign": { + "m2_to_5": [ + { + "m": 2, + "positive_unnormalized_M_interval": [ + "2131683717600446447976543214430520266024747555909946519807106639485473632429486831785552740688150416397696314397917781493821310356229627109078242403732475835385721451532503487558666746731673921133872732114663882091968348480383102092486286373359505599077150462083397413277113062673923833117116633127055338078845282491211128002455266284677861480617629253106802718708333990980483567893748801/20815864389328798163850480654728171077230524494533409610638224700807216119346720596024478883464648369684843227908562015582767132496646929816279813211354641525848259018778440691546366699323167100945918841095379622423387354295096957733925002768876520583464697770622321657076833170056511209332449663781837603694136444406281042053396870977465916057756101739472373801429441421111406337458176", + "8326889521876743937408371931369219789159170140326568980695287750218748056145463340286074008612377235977173602935681467428297809084313998762403305098591398935365912234120031280358228126601219261037207272450848785890985423684991805830219702391415195486426714870639565913818461681056627001078864456301191385177837888373672718264571661297966362187989864290121323272923808490340795876994657/81311970270815617827540940057531918270431736306771131291555565237528187966198127328220620638533782694081418859017820373370184111315027069594843020356854068460344761792103283951352994919231121488069995473028826650091356852715222491148144542065923908529158975666493443972956379570533246911454881499147803139430220485962035320521081527255726234600609772419813960161833755551216431005696" + ] + }, + { + "m": 3, + "positive_unnormalized_M_interval": [ + "57687970737121350560699446440151449671377990711942143853516428294848363282489790326879933175730258561137107437383072377914161556909940913856694516852703411247525231073652570162594059868096933312285667154181785733246227869342274619819800809540986760218326789847078142652432149085412415011292921606953912103879190701752396820867885146311885964325322932419515450946892042414266483445778886216825463771527246387398276905512699824764742227471631491119848434248991838645231686358396606477608582739388895775122666123913123195814356740938276057415904114072862816030878921646396269129642081/94971145180789141405469863695884969990692470634685116742800956330585166286696033875105787408321105016172948848387979899381078776548058719274153038481919330076987462588432197778346974895637755344856609332899271782077461008182119361693275785914457910967149403472811089067095457018656127063791202559391107981952290497413671516189054715030212151457729925746607341068107450556036691253445520158175442766273106804460580598760425795931407058821363012979657287013264796313022267140908229491284859997425339970007394059640858536497878915778164024704513828250590897948604589281308443672576", + "14083977230742517226733263291052600017426267264232108302588175299505312059426685481103592018673773349223255831597247109221055540603084544988420291190241539387449462616524906951706820838103430595329847770193825400597284314558520256287021285870739805762388679643067346345660403278115559353412637708147257275561411856585591129543861351047194311614270853230449917966550874849931259829083814234774826239618527728161978175856806278225107699545080085836233077349809371480758130239162785637212299309551477625076829638997168374188316252720650974592853474025524456832015039605581509274385/23186314741403598975944790941378166501633903963546171079785389729146769112962898895289498878984644779339098839938471655122333685680678398260291269160624836444577017233503954535729241917880311363490383137914861274921255128950712734788397408670521950919714209832229269791771351811195343521433399062351344722156320922220134647507093436286672888539484845152980307877955920545907395325548222694867051456609645215932758935244244579084816176470059329340736642337222850662358951938698298215645717772808920891115086440342006478637177469672403326343875446350241918444483542305006944256" + ] + }, + { + "m": 4, + "positive_unnormalized_M_interval": [ + "2665368202770715192253866589523432361548830892372654511524610846385148319062255472403365448697360350358154229946546380736473576336841909275880583199159902276509970013840572584039513893247340288026279460262422569218457102833516424336652735070513539658046676813867855388423603373411179297642417179736528505084855716596368407859668922190169427656189375652382438575832109953813925515728336884375908292865968683406657442783687187206127495101568899175318406311832383528610788390678666250470158195913210597804758515554252091307339741933336302548874003955850715251521336614160733095704761938788714294775890129003118712372279431665960485326639894880556628246364324466487096730616758784650783986694900865714803425418025174306720260942915187554721875249701684716952995246155228627748993/433300210274926779301235722995130529126851924312253566276831366547097655953268278873591999368453759375352459120642109169274240110620843517970102311224458427564046616227161115801662152359395451958893835480905010246703239443701925453743683726938789767940577524555724362397039358587448248740993955708382317083531851133758531532844694304737183093418571190053292997716413815714417740434254315670267335553209606545389900958653541702218767662872949109999460596999125719155768466778443229719919179735890978537026576050107500869340314188887101095263339865901080787145771915722368720844521851040375582291274824574444462419841916186875058374404329003250698574832235855871168399140082282900718430116575617097058691735266917705341386171618452673063526784039252631042036988932549246976", + "40670291179973071170865884239554326805859846386616546944884098508361821583515088860902925793348880538432935836479277937616349331809623028699034160548303830773262884446347856377723029752582500182358997635012611376555660782412357675269632262388936843127995066288836188460676072247288798132143913654705136121401368424270376743586162624674136749930021944823688085258409552206310194508154742983224172660908410441380117197766700548040625933152086703865905254025840409605289545183270253839193659133167048027862942082339741570379280145056757703469147911138487534452756473476098237852817787077091694525477935133471126339248612706217419671785812040925198109883611058676078459918245211768384545714679535057038930328615735761770514316085371710744141933481374367302462907746438709441/6611636509322002857990047042772377458600645817752892551831533303025782103779118024804565420050869131093634935312532183369052736062940117156526219348517737237000223025927141049219698369741751891462613456434707797953845816706877524623774470931072841918038597481624212072708730447196170787673857966741673539482602708950172905469431980968279771322915209809162795985663052607947048041294163752292897576190332131124723830545860926852703363996474443206778878738389979845516486614661304164427477718137984901993203369905204786214299227735704057239736020903031628221828795100744151624214505783697137180958172982398139380185576113691330846777409805347453286359134458249987310777894321943675513154854974626114787166370649989400350741144080393570915630859973947617218581984444416" + ] + }, + { + "m": 5, + "positive_unnormalized_M_interval": [ + "91624128600781791815799212507255460003806905563442216725629921846746658071778494675309724958046046328940838450248618494894087416298834781581609831956554822782058024660340900235791532506609834496093832344565121755315473814094383119156708978528767818966474304047505036156862032750541463570375617305522313569224886172195414063001371961531214176473885801868943083555545087384466799364216465328284087478176853988501771315411117387645745226070780023628679216526281530405478830618733744333735298841773201360046873862027144437961445217706201353284848648821507138551172165854995877747848616814943071282972356401514900482371197761521326997953908397778751071096880859403758830124018702621594353505981106225343704797800435160031174852681573671323135778453569302653719483257541034117703800480798384272737823107922747984411554584990103740542918547093063830451823060322837213072077990430181094958298548758715598412561771450724526869774116256266815084374182951035206178960931305350305/1976906478982563993654226439837963340315390682625773828918265710158340601093951126756295848974613063099294244703164628428967968057547050608904859234600159014229329102195101574081057061661948106884800321129818693914608845281661462333814326544389741164009367602548103882724187831587394954463183137735657307019637359169290834318700453890617892714561362370427388384101316010134426924662084888461376218489653794242999053891151382465888482003300085676110173467997003494159830094271947506024974271953414706038068210170338961663202839203641120865263292248718692924915189291455200665479606951612257868495299167071771306894428954788679149900427954823300393640007649397742106635573828425752730305375232721339803871889299281134208211131341001135605446809477409979279627213188610112867929569789492640465736633925065052540962862027736312499143902692033755536952046162410311395501619568814547777271031259247973250866583116853615908352881305587297178183145388745781297002238181376", + "87379578209668914619254314906363925937468438754137326120881968065849994952345790010867284042539775257171081175926779349931095704941120122835433815049330559785954232901088406457257229011995005172502530636219422707287041071065717275028494133319774362810885828854490828484765025306714121631338078320724904903290134915558593755787849170632688856047026108646286691372776939790874589984744745337133235260094423718932827208811272466415628796473537051029043823052656054693824950409258583856744759660958178572792372061984453824325858598708804404674725805731793057193375885519411861457201449146664467559949037712174930611250085508135583721339620126814874849671979849562563778999401919965888690280476471996455822512068009808215769882882206478238639736113564513294504114899531522078291550450747619089236509558675738744017515878504207614646816594693661899603813051624788309273498488203132093661529476948137959451415976048479491943370647932618911536999833573514635093020909425/1885324934942783349661089362943614330592528040529035405081048689039555169195128561741157387709248602961820835784115436963050811822459269150643214449501189245442704298205472539979035436307857615361023255472010320582016797334348165830435110611333600200662009813831428415989101249301333384001906526313454920787465438050547441786480382814996617044984209413936031707860294351705958294546208275281311243524221224062918714419509298768890840533542714763746427028653148168716268629333446031594251892045416551626270494623507463134005393222466584077132503746718113827624501506285858788947684241878755444045352141448756510633877711094550275707653002570438760414130830190412623057912662912132959657073242875423244354142474442609985552913037301192861029443242464045791270459354982483737878389157765045610176690983834316769564497020469963549751188938173060929252668535623847384931201523603961732169181117294286013475974194387069614746934228503510645087380779977589890482176" + ] + } + ], + "m_at_least6": "2 - 16*(674/1000)^m > 0", + "conclusion": "M_(4,m)(q4)>0 and p_(4,m)=2" + }, + "asymptotic": "p_(4,m)-q4 = -2*rho^m/(m*hprime_p)*(1+O(theta^m)+O(rho^m)) at fixed width four", + "limits": [ + "not a new infinite-square pc", + "width-specific, not a uniform-width estimate", + "numerical roots propose bands; rational inequalities certify all load-bearing signs" + ] +} diff --git a/results/research-control-20260912/width4-parametric-definition.json b/results/research-control-20260912/width4-parametric-definition.json new file mode 100644 index 00000000..3658e500 --- /dev/null +++ b/results/research-control-20260912/width4-parametric-definition.json @@ -0,0 +1,451 @@ +{ + "schema": "matching-one.width4-parametric-definition.v1", + "source_pr": 708, + "source_head": "f782061c1a592ed2f9fd0e9dabaa45f0e54bc4e7", + "source_blob": "50b7297deefe7c50215aea2ed534ca5810461af3", + "source_path": "results/research-control-20260912/width4-rank-closure-certificate.json", + "variable": "t=p/(1-p), normalization (1+t)^(4*m)", + "blocks": { + "5": { + "quotient_state_indices": [ + 0, + 16, + 17, + 18, + 19 + ], + "factorization": [ + [ + "closed_b", + 1 + ], + [ + "closed_a", + 2 + ], + [ + "closed_2", + 1 + ] + ] + }, + "15": { + "quotient_state_indices": [ + 15, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152 + ], + "factorization": [ + [ + "negative_square", + 1 + ], + [ + "open_3b", + 1 + ], + [ + "open_3a", + 2 + ], + [ + "open_5", + 1 + ] + ] + }, + "16": { + "quotient_state_indices": [ + 1, + 21, + 22, + 23, + 24, + 25, + 153, + 154, + 155, + 156, + 157, + 158, + 160, + 161, + 163, + 481 + ], + "factorization": [ + [ + "negative_square", + 1 + ], + [ + "shared_3", + 1 + ], + [ + "shared_4a", + 1 + ], + [ + "shared_4b", + 2 + ] + ] + } + }, + "factors": { + "closed_b": { + "coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + 0, + 0, + -1, + 1 + ] + ], + "formula": "t**3 - t**2 + x", + "degree_x": 1 + }, + "closed_a": { + "coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + 0, + 0, + -1, + -1 + ] + ], + "formula": "-t**3 - t**2 + x", + "degree_x": 1 + }, + "closed_2": { + "coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + -1, + -4, + -7, + -3 + ], + [ + 0, + 0, + 1, + 3, + 2, + -2 + ] + ], + "formula": "-2*t**5 + 2*t**4 - 3*t**3*x + 3*t**3 - 7*t**2*x + t**2 - 4*t*x + x**2 - x", + "degree_x": 2 + }, + "negative_square": { + "coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + 0, + 0, + 1 + ] + ], + "formula": "t**2 + x", + "degree_x": 1 + }, + "open_3b": { + "coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + 0, + -1, + -2 + ], + [ + 0, + 0, + 0, + 1, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1 + ] + ], + "formula": "-t**7 - t**6 + t**5*x + t**3*x - 2*t**2*x**2 - t*x**2 + x**3", + "degree_x": 3 + }, + "open_3a": { + "coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + 0, + -1, + -2 + ], + [ + 0, + 0, + 0, + -1, + -2, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ] + ], + "formula": "t**7 + t**6 - t**5*x - 2*t**4*x - t**3*x - 2*t**2*x**2 - t*x**2 + x**3", + "degree_x": 3 + }, + "open_5": { + "coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + 0, + -1, + -5, + -4, + -1 + ], + [ + 0, + 0, + 0, + 0, + -2, + -6, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 3, + 2, + -2, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -4, + -3, + -2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1 + ] + ], + "formula": "-t**13 - t**12 - 2*t**11*x - 3*t**10*x - t**9*x**2 - 4*t**9*x - 2*t**8*x**2 - t**8*x + 2*t**7*x**2 - t**6*x**3 + 3*t**6*x**2 - 6*t**5*x**3 + t**5*x**2 - t**4*x**4 - 2*t**4*x**3 - 4*t**3*x**4 - 5*t**2*x**4 - t*x**4 + x**5", + "degree_x": 5 + }, + "shared_3": { + "coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + 0, + -1, + -2, + 1 + ], + [ + 0, + 0, + 0, + 1, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1 + ] + ], + "formula": "-t**7 - t**6 - t**4*x + t**3*x**2 + t**3*x - 2*t**2*x**2 - t*x**2 + x**3", + "degree_x": 3 + }, + "shared_4a": { + "coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + 0, + -1, + -5, + -3 + ], + [ + 0, + 0, + 0, + 0, + -3, + -7 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 2, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1 + ] + ], + "formula": "-t**9 - t**8 - t**7*x + 2*t**6*x - 7*t**5*x**2 + t**5*x - 3*t**4*x**2 - 3*t**3*x**3 - 5*t**2*x**3 - t*x**3 + x**4", + "degree_x": 4 + }, + "shared_4b": { + "coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + 0, + -1, + -3, + -1 + ], + [ + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 4, + 3 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1 + ] + ], + "formula": "-t**9 - t**8 + 3*t**7*x + 4*t**6*x + t**5*x**2 + t**5*x + t**4*x**2 - t**3*x**3 - 3*t**2*x**3 - t*x**3 + x**4", + "degree_x": 4 + } + }, + "crossing_polynomial_ascending_t": [ + -2, + -35, + -278, + -1344, + -4503, + -11396, + -23218, + -39092, + -52627, + -51259, + -28383, + 1795, + 16534, + 12915, + 5205, + 1305, + 198, + 9 + ], + "crossing_polynomial_formula": "9*t**17 + 198*t**16 + 1305*t**15 + 5205*t**14 + 12915*t**13 + 16534*t**12 + 1795*t**11 - 28383*t**10 - 51259*t**9 - 52627*t**8 - 39092*t**7 - 23218*t**6 - 11396*t**5 - 4503*t**4 - 1344*t**3 - 278*t**2 - 35*t - 2" +} \ No newline at end of file diff --git a/results/research-control-20260912/width4-parametric-traces.json b/results/research-control-20260912/width4-parametric-traces.json new file mode 100644 index 00000000..bbddd72c --- /dev/null +++ b/results/research-control-20260912/width4-parametric-traces.json @@ -0,0 +1,9992 @@ +{ + "schema": "matching-one.width4-parametric-traces.v1", + "source_head": "f782061c1a592ed2f9fd0e9dabaa45f0e54bc4e7", + "source_blob": "50b7297deefe7c50215aea2ed534ca5810461af3", + "weighted_quotient": { + "labels": [ + 0, + 1, + 1, + 2, + 1, + 3, + 2, + 4, + 1, + 2, + 3, + 4, + 2, + 4, + 4, + 5, + 6, + 6, + 6, + 6, + 7, + 8, + 9, + 8, + 10, + 9, + 11, + 8, + 8, + 10, + 9, + 9, + 11, + 12, + 12, + 13, + 14, + 13, + 14, + 15, + 15, + 16, + 8, + 9, + 8, + 9, + 10, + 11, + 17, + 17, + 18, + 12, + 13, + 12, + 14, + 15, + 13, + 15, + 14, + 16, + 19, + 20, + 21, + 22, + 20, + 23, + 22, + 24, + 25, + 24, + 26, + 25, + 27, + 8, + 9, + 8, + 10, + 9, + 11, + 12, + 13, + 15, + 12, + 14, + 13, + 14, + 15, + 16, + 17, + 17, + 18, + 19, + 21, + 20, + 22, + 24, + 25, + 20, + 22, + 23, + 24, + 25, + 26, + 27, + 12, + 13, + 15, + 12, + 13, + 15, + 14, + 14, + 16, + 19, + 20, + 24, + 20, + 23, + 24, + 26, + 21, + 22, + 25, + 22, + 25, + 27, + 19, + 20, + 24, + 21, + 22, + 25, + 20, + 24, + 23, + 26, + 22, + 25, + 27, + 28, + 28, + 29, + 28, + 30, + 29, + 31, + 28, + 29, + 30, + 31, + 29, + 31, + 31, + 32, + 33, + 34, + 35, + 36, + 33, + 37, + 32, + 38, + 39, + 36, + 37, + 40, + 41, + 42, + 43, + 44, + 45, + 41, + 42, + 46, + 47, + 45, + 32, + 33, + 34, + 32, + 33, + 38, + 39, + 35, + 36, + 37, + 36, + 37, + 41, + 40, + 42, + 41, + 46, + 42, + 47, + 43, + 45, + 44, + 45, + 48, + 49, + 50, + 51, + 48, + 50, + 51, + 52, + 53, + 52, + 53, + 54, + 54, + 55, + 56, + 57, + 58, + 56, + 58, + 57, + 59, + 32, + 33, + 34, + 35, + 36, + 33, + 37, + 32, + 36, + 37, + 38, + 39, + 43, + 41, + 45, + 40, + 44, + 42, + 41, + 45, + 46, + 42, + 47, + 60, + 61, + 62, + 60, + 63, + 62, + 64, + 65, + 64, + 66, + 65, + 60, + 64, + 60, + 63, + 64, + 66, + 61, + 62, + 65, + 62, + 65, + 67, + 68, + 69, + 67, + 70, + 69, + 68, + 69, + 71, + 72, + 69, + 72, + 48, + 49, + 50, + 51, + 48, + 52, + 53, + 52, + 53, + 50, + 51, + 56, + 54, + 58, + 54, + 57, + 55, + 56, + 59, + 57, + 58, + 73, + 74, + 75, + 74, + 76, + 77, + 78, + 79, + 80, + 81, + 80, + 82, + 81, + 83, + 84, + 85, + 79, + 85, + 78, + 86, + 87, + 32, + 33, + 34, + 35, + 33, + 36, + 37, + 32, + 38, + 39, + 36, + 37, + 41, + 43, + 45, + 41, + 46, + 45, + 40, + 42, + 44, + 42, + 47, + 48, + 49, + 48, + 52, + 53, + 50, + 51, + 50, + 51, + 52, + 53, + 54, + 56, + 58, + 56, + 57, + 59, + 54, + 55, + 57, + 58, + 61, + 60, + 62, + 64, + 65, + 60, + 62, + 63, + 64, + 65, + 66, + 60, + 64, + 61, + 62, + 65, + 60, + 64, + 63, + 66, + 62, + 65, + 68, + 67, + 69, + 68, + 71, + 69, + 72, + 67, + 69, + 70, + 69, + 72, + 74, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 78, + 79, + 80, + 81, + 84, + 85, + 80, + 81, + 82, + 83, + 85, + 86, + 87, + 48, + 49, + 48, + 52, + 53, + 52, + 53, + 50, + 51, + 50, + 51, + 56, + 56, + 59, + 54, + 57, + 58, + 54, + 58, + 57, + 55, + 75, + 74, + 73, + 74, + 76, + 77, + 80, + 84, + 85, + 80, + 82, + 85, + 81, + 79, + 81, + 83, + 79, + 78, + 78, + 86, + 87, + 74, + 75, + 74, + 73, + 76, + 77, + 78, + 79, + 84, + 80, + 85, + 81, + 79, + 80, + 85, + 82, + 81, + 83, + 78, + 86, + 87, + 88, + 88, + 88, + 89, + 90, + 91, + 91, + 89, + 90, + 91, + 91, + 92, + 88, + 89, + 90, + 91, + 91, + 89, + 90, + 91, + 91, + 92, + 92, + 92, + 93, + 93, + 93, + 93 + ], + "reps": [ + 0, + 1, + 3, + 5, + 7, + 15, + 16, + 20, + 21, + 22, + 24, + 26, + 33, + 35, + 36, + 39, + 41, + 48, + 50, + 60, + 61, + 62, + 63, + 65, + 67, + 68, + 70, + 72, + 139, + 141, + 143, + 145, + 153, + 154, + 155, + 156, + 157, + 159, + 161, + 162, + 165, + 166, + 167, + 168, + 169, + 170, + 173, + 174, + 199, + 200, + 201, + 202, + 206, + 207, + 210, + 212, + 213, + 214, + 215, + 219, + 243, + 244, + 245, + 247, + 249, + 250, + 252, + 265, + 266, + 267, + 269, + 273, + 274, + 298, + 299, + 300, + 302, + 303, + 304, + 305, + 306, + 307, + 309, + 311, + 312, + 313, + 317, + 318, + 481, + 484, + 485, + 486, + 492, + 505 + ], + "rows": [ + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 4 + ], + [ + 2, + 0, + 6 + ], + [ + 3, + 6, + 4 + ], + [ + 4, + 7, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 3 + ], + [ + 1, + 1, + 1 + ], + [ + 2, + 0, + 3 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 8, + 2 + ], + [ + 3, + 6, + 1 + ], + [ + 3, + 9, + 2 + ], + [ + 3, + 10, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 2 + ], + [ + 1, + 12, + 2 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 2, + 1 + ], + [ + 2, + 12, + 2 + ], + [ + 2, + 13, + 2 + ], + [ + 3, + 14, + 2 + ], + [ + 3, + 15, + 2 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 2 + ], + [ + 1, + 1, + 2 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 8, + 4 + ], + [ + 3, + 10, + 2 + ], + [ + 3, + 17, + 2 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 1 + ], + [ + 1, + 20, + 2 + ], + [ + 1, + 21, + 1 + ], + [ + 2, + 21, + 1 + ], + [ + 2, + 22, + 2 + ], + [ + 2, + 23, + 1 + ], + [ + 2, + 24, + 2 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 25, + 2 + ], + [ + 3, + 26, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 28, + 4 + ], + [ + 2, + 29, + 4 + ], + [ + 2, + 30, + 2 + ], + [ + 3, + 31, + 4 + ], + [ + 4, + 5, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 4 + ], + [ + 2, + 0, + 5 + ], + [ + 2, + 6, + 1 + ], + [ + 3, + 6, + 3 + ], + [ + 3, + 7, + 1 + ], + [ + 4, + 7, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 4 + ], + [ + 2, + 7, + 6 + ], + [ + 3, + 7, + 4 + ], + [ + 4, + 7, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 2 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 32, + 1 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 8, + 2 + ], + [ + 2, + 32, + 1 + ], + [ + 2, + 33, + 1 + ], + [ + 3, + 9, + 2 + ], + [ + 3, + 10, + 1 + ], + [ + 3, + 34, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 32, + 1 + ], + [ + 1, + 35, + 1 + ], + [ + 2, + 8, + 2 + ], + [ + 2, + 32, + 1 + ], + [ + 2, + 33, + 2 + ], + [ + 2, + 36, + 1 + ], + [ + 3, + 9, + 1 + ], + [ + 3, + 10, + 1 + ], + [ + 3, + 34, + 1 + ], + [ + 3, + 37, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 32, + 2 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 8, + 2 + ], + [ + 2, + 33, + 2 + ], + [ + 2, + 38, + 1 + ], + [ + 3, + 9, + 2 + ], + [ + 3, + 10, + 1 + ], + [ + 3, + 39, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 40, + 1 + ], + [ + 1, + 41, + 2 + ], + [ + 1, + 43, + 1 + ], + [ + 2, + 42, + 2 + ], + [ + 2, + 44, + 1 + ], + [ + 2, + 45, + 2 + ], + [ + 2, + 46, + 1 + ], + [ + 3, + 37, + 2 + ], + [ + 3, + 39, + 1 + ], + [ + 3, + 47, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 3 + ], + [ + 1, + 12, + 1 + ], + [ + 2, + 0, + 3 + ], + [ + 2, + 2, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 2, + 13, + 1 + ], + [ + 3, + 6, + 1 + ], + [ + 3, + 14, + 2 + ], + [ + 3, + 15, + 1 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 2 + ], + [ + 1, + 12, + 1 + ], + [ + 1, + 48, + 1 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 2, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 2, + 13, + 1 + ], + [ + 2, + 48, + 1 + ], + [ + 2, + 49, + 1 + ], + [ + 3, + 14, + 2 + ], + [ + 3, + 15, + 2 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 12, + 2 + ], + [ + 1, + 48, + 1 + ], + [ + 2, + 2, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 2, + 13, + 2 + ], + [ + 2, + 49, + 1 + ], + [ + 2, + 50, + 1 + ], + [ + 3, + 14, + 2 + ], + [ + 3, + 15, + 1 + ], + [ + 3, + 51, + 1 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 12, + 1 + ], + [ + 1, + 48, + 2 + ], + [ + 2, + 2, + 1 + ], + [ + 2, + 13, + 2 + ], + [ + 2, + 48, + 1 + ], + [ + 2, + 49, + 1 + ], + [ + 2, + 52, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 3, + 15, + 2 + ], + [ + 3, + 53, + 1 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 54, + 2 + ], + [ + 1, + 56, + 2 + ], + [ + 2, + 55, + 1 + ], + [ + 2, + 57, + 2 + ], + [ + 2, + 58, + 2 + ], + [ + 2, + 59, + 1 + ], + [ + 3, + 51, + 2 + ], + [ + 3, + 53, + 2 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 1 + ], + [ + 1, + 60, + 2 + ], + [ + 1, + 61, + 1 + ], + [ + 2, + 61, + 1 + ], + [ + 2, + 62, + 2 + ], + [ + 2, + 63, + 1 + ], + [ + 2, + 64, + 2 + ], + [ + 3, + 17, + 1 + ], + [ + 3, + 65, + 2 + ], + [ + 3, + 66, + 1 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 67, + 2 + ], + [ + 1, + 68, + 2 + ], + [ + 2, + 69, + 4 + ], + [ + 2, + 70, + 1 + ], + [ + 2, + 71, + 1 + ], + [ + 3, + 66, + 2 + ], + [ + 3, + 72, + 2 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 4 + ], + [ + 2, + 19, + 6 + ], + [ + 3, + 73, + 1 + ], + [ + 3, + 74, + 2 + ], + [ + 3, + 75, + 1 + ], + [ + 4, + 7, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 3 + ], + [ + 1, + 20, + 1 + ], + [ + 2, + 19, + 3 + ], + [ + 2, + 20, + 1 + ], + [ + 2, + 22, + 1 + ], + [ + 2, + 24, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 25, + 1 + ], + [ + 3, + 74, + 1 + ], + [ + 3, + 76, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 3 + ], + [ + 1, + 21, + 1 + ], + [ + 2, + 19, + 3 + ], + [ + 2, + 21, + 1 + ], + [ + 2, + 22, + 2 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 25, + 2 + ], + [ + 3, + 75, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 2 + ], + [ + 1, + 20, + 1 + ], + [ + 1, + 21, + 1 + ], + [ + 2, + 19, + 1 + ], + [ + 2, + 20, + 1 + ], + [ + 2, + 21, + 1 + ], + [ + 2, + 22, + 2 + ], + [ + 2, + 24, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 25, + 2 + ], + [ + 3, + 76, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 2 + ], + [ + 1, + 20, + 2 + ], + [ + 2, + 19, + 1 + ], + [ + 2, + 22, + 2 + ], + [ + 2, + 23, + 1 + ], + [ + 2, + 24, + 2 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 25, + 2 + ], + [ + 3, + 26, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 2 + ], + [ + 1, + 20, + 1 + ], + [ + 1, + 77, + 1 + ], + [ + 2, + 19, + 1 + ], + [ + 2, + 20, + 1 + ], + [ + 2, + 22, + 1 + ], + [ + 2, + 24, + 2 + ], + [ + 2, + 77, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 25, + 2 + ], + [ + 3, + 76, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 1 + ], + [ + 1, + 20, + 1 + ], + [ + 1, + 21, + 1 + ], + [ + 1, + 77, + 1 + ], + [ + 2, + 20, + 1 + ], + [ + 2, + 22, + 2 + ], + [ + 2, + 24, + 2 + ], + [ + 2, + 78, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 25, + 1 + ], + [ + 3, + 76, + 1 + ], + [ + 3, + 79, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 80, + 2 + ], + [ + 1, + 84, + 1 + ], + [ + 2, + 81, + 2 + ], + [ + 2, + 82, + 1 + ], + [ + 2, + 84, + 1 + ], + [ + 2, + 85, + 2 + ], + [ + 3, + 26, + 1 + ], + [ + 3, + 79, + 2 + ], + [ + 3, + 83, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 80, + 2 + ], + [ + 1, + 84, + 1 + ], + [ + 1, + 86, + 1 + ], + [ + 2, + 81, + 2 + ], + [ + 2, + 82, + 1 + ], + [ + 2, + 85, + 2 + ], + [ + 2, + 87, + 1 + ], + [ + 3, + 26, + 1 + ], + [ + 3, + 79, + 2 + ], + [ + 3, + 83, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 3 + ], + [ + 1, + 28, + 1 + ], + [ + 2, + 7, + 3 + ], + [ + 2, + 28, + 1 + ], + [ + 2, + 29, + 2 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 31, + 3 + ], + [ + 4, + 5, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 28, + 2 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 28, + 2 + ], + [ + 2, + 29, + 3 + ], + [ + 3, + 31, + 4 + ], + [ + 4, + 5, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 28, + 2 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 29, + 4 + ], + [ + 2, + 30, + 1 + ], + [ + 3, + 31, + 4 + ], + [ + 4, + 5, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 28, + 3 + ], + [ + 2, + 28, + 1 + ], + [ + 2, + 29, + 4 + ], + [ + 2, + 30, + 1 + ], + [ + 3, + 31, + 4 + ], + [ + 4, + 5, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 3 + ], + [ + 1, + 32, + 1 + ], + [ + 2, + 0, + 3 + ], + [ + 2, + 8, + 1 + ], + [ + 2, + 32, + 1 + ], + [ + 2, + 33, + 1 + ], + [ + 3, + 6, + 1 + ], + [ + 3, + 9, + 1 + ], + [ + 3, + 10, + 1 + ], + [ + 3, + 34, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 2 + ], + [ + 1, + 32, + 1 + ], + [ + 1, + 35, + 1 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 8, + 1 + ], + [ + 2, + 32, + 1 + ], + [ + 2, + 33, + 2 + ], + [ + 2, + 35, + 1 + ], + [ + 3, + 9, + 2 + ], + [ + 3, + 10, + 1 + ], + [ + 3, + 34, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 1 + ], + [ + 1, + 32, + 2 + ], + [ + 1, + 35, + 1 + ], + [ + 2, + 8, + 2 + ], + [ + 2, + 33, + 2 + ], + [ + 2, + 35, + 1 + ], + [ + 2, + 88, + 1 + ], + [ + 3, + 9, + 2 + ], + [ + 3, + 34, + 1 + ], + [ + 3, + 47, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 3 + ], + [ + 1, + 35, + 1 + ], + [ + 2, + 0, + 3 + ], + [ + 2, + 33, + 2 + ], + [ + 2, + 35, + 1 + ], + [ + 3, + 6, + 1 + ], + [ + 3, + 9, + 2 + ], + [ + 3, + 34, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 2 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 35, + 1 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 8, + 2 + ], + [ + 2, + 33, + 2 + ], + [ + 2, + 36, + 1 + ], + [ + 3, + 9, + 1 + ], + [ + 3, + 10, + 1 + ], + [ + 3, + 34, + 1 + ], + [ + 3, + 37, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 40, + 1 + ], + [ + 1, + 41, + 1 + ], + [ + 1, + 43, + 1 + ], + [ + 2, + 41, + 1 + ], + [ + 2, + 42, + 2 + ], + [ + 2, + 44, + 1 + ], + [ + 2, + 45, + 2 + ], + [ + 3, + 37, + 2 + ], + [ + 3, + 39, + 1 + ], + [ + 3, + 47, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 2 + ], + [ + 1, + 32, + 2 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 8, + 2 + ], + [ + 2, + 33, + 2 + ], + [ + 2, + 38, + 1 + ], + [ + 3, + 9, + 2 + ], + [ + 3, + 10, + 1 + ], + [ + 3, + 39, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 41, + 2 + ], + [ + 1, + 43, + 1 + ], + [ + 2, + 42, + 2 + ], + [ + 2, + 43, + 1 + ], + [ + 2, + 45, + 2 + ], + [ + 2, + 46, + 1 + ], + [ + 3, + 37, + 2 + ], + [ + 3, + 39, + 1 + ], + [ + 3, + 47, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 3 + ], + [ + 1, + 40, + 1 + ], + [ + 2, + 7, + 3 + ], + [ + 2, + 40, + 1 + ], + [ + 2, + 42, + 2 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 37, + 2 + ], + [ + 3, + 47, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 3 + ], + [ + 1, + 41, + 1 + ], + [ + 2, + 7, + 3 + ], + [ + 2, + 41, + 1 + ], + [ + 2, + 42, + 1 + ], + [ + 2, + 45, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 37, + 1 + ], + [ + 3, + 39, + 1 + ], + [ + 3, + 47, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 40, + 1 + ], + [ + 1, + 41, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 40, + 1 + ], + [ + 2, + 41, + 1 + ], + [ + 2, + 42, + 2 + ], + [ + 2, + 45, + 1 + ], + [ + 3, + 37, + 2 + ], + [ + 3, + 39, + 1 + ], + [ + 3, + 47, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 3 + ], + [ + 1, + 43, + 1 + ], + [ + 2, + 7, + 3 + ], + [ + 2, + 43, + 1 + ], + [ + 2, + 45, + 2 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 37, + 2 + ], + [ + 3, + 39, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 40, + 1 + ], + [ + 1, + 43, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 42, + 2 + ], + [ + 2, + 44, + 1 + ], + [ + 2, + 45, + 2 + ], + [ + 3, + 37, + 2 + ], + [ + 3, + 39, + 1 + ], + [ + 3, + 47, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 41, + 1 + ], + [ + 1, + 43, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 41, + 1 + ], + [ + 2, + 42, + 1 + ], + [ + 2, + 43, + 1 + ], + [ + 2, + 45, + 2 + ], + [ + 3, + 37, + 2 + ], + [ + 3, + 39, + 1 + ], + [ + 3, + 47, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 41, + 2 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 42, + 2 + ], + [ + 2, + 45, + 2 + ], + [ + 2, + 46, + 1 + ], + [ + 3, + 37, + 2 + ], + [ + 3, + 39, + 1 + ], + [ + 3, + 47, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 40, + 1 + ], + [ + 1, + 41, + 2 + ], + [ + 2, + 40, + 1 + ], + [ + 2, + 42, + 2 + ], + [ + 2, + 45, + 2 + ], + [ + 2, + 46, + 1 + ], + [ + 3, + 37, + 2 + ], + [ + 3, + 39, + 1 + ], + [ + 3, + 47, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 3 + ], + [ + 1, + 48, + 1 + ], + [ + 2, + 0, + 3 + ], + [ + 2, + 13, + 1 + ], + [ + 2, + 48, + 1 + ], + [ + 2, + 49, + 1 + ], + [ + 3, + 6, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 3, + 15, + 2 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 2 + ], + [ + 1, + 48, + 2 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 13, + 2 + ], + [ + 2, + 48, + 2 + ], + [ + 2, + 49, + 1 + ], + [ + 3, + 14, + 2 + ], + [ + 3, + 15, + 2 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 2 + ], + [ + 1, + 12, + 1 + ], + [ + 1, + 48, + 1 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 2, + 1 + ], + [ + 2, + 13, + 2 + ], + [ + 2, + 49, + 1 + ], + [ + 2, + 50, + 1 + ], + [ + 3, + 14, + 2 + ], + [ + 3, + 15, + 1 + ], + [ + 3, + 51, + 1 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 54, + 1 + ], + [ + 1, + 56, + 2 + ], + [ + 2, + 55, + 1 + ], + [ + 2, + 56, + 1 + ], + [ + 2, + 57, + 1 + ], + [ + 2, + 58, + 2 + ], + [ + 2, + 59, + 1 + ], + [ + 3, + 51, + 2 + ], + [ + 3, + 53, + 2 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 2 + ], + [ + 1, + 12, + 1 + ], + [ + 1, + 48, + 1 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 2, + 1 + ], + [ + 2, + 13, + 2 + ], + [ + 2, + 49, + 1 + ], + [ + 2, + 52, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 3, + 15, + 2 + ], + [ + 3, + 53, + 1 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 54, + 2 + ], + [ + 1, + 56, + 1 + ], + [ + 2, + 54, + 1 + ], + [ + 2, + 55, + 1 + ], + [ + 2, + 57, + 1 + ], + [ + 2, + 58, + 2 + ], + [ + 2, + 59, + 1 + ], + [ + 3, + 51, + 2 + ], + [ + 3, + 53, + 2 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 3 + ], + [ + 1, + 54, + 1 + ], + [ + 2, + 7, + 3 + ], + [ + 2, + 54, + 1 + ], + [ + 2, + 55, + 1 + ], + [ + 2, + 58, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 51, + 1 + ], + [ + 3, + 53, + 2 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 54, + 2 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 54, + 2 + ], + [ + 2, + 55, + 1 + ], + [ + 2, + 58, + 2 + ], + [ + 3, + 51, + 2 + ], + [ + 3, + 53, + 2 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 3 + ], + [ + 1, + 56, + 1 + ], + [ + 2, + 7, + 3 + ], + [ + 2, + 56, + 1 + ], + [ + 2, + 58, + 1 + ], + [ + 2, + 59, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 51, + 2 + ], + [ + 3, + 53, + 1 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 54, + 1 + ], + [ + 1, + 56, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 55, + 1 + ], + [ + 2, + 57, + 1 + ], + [ + 2, + 58, + 2 + ], + [ + 2, + 59, + 1 + ], + [ + 3, + 51, + 2 + ], + [ + 3, + 53, + 2 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 54, + 1 + ], + [ + 1, + 56, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 54, + 1 + ], + [ + 2, + 55, + 1 + ], + [ + 2, + 56, + 1 + ], + [ + 2, + 58, + 1 + ], + [ + 2, + 59, + 1 + ], + [ + 3, + 51, + 2 + ], + [ + 3, + 53, + 2 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 56, + 2 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 56, + 2 + ], + [ + 2, + 58, + 2 + ], + [ + 2, + 59, + 1 + ], + [ + 3, + 51, + 2 + ], + [ + 3, + 53, + 2 + ], + [ + 4, + 16, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 3 + ], + [ + 1, + 60, + 1 + ], + [ + 2, + 19, + 3 + ], + [ + 2, + 60, + 1 + ], + [ + 2, + 62, + 1 + ], + [ + 2, + 64, + 1 + ], + [ + 3, + 17, + 1 + ], + [ + 3, + 65, + 1 + ], + [ + 3, + 74, + 1 + ], + [ + 3, + 89, + 1 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 3 + ], + [ + 1, + 61, + 1 + ], + [ + 2, + 19, + 3 + ], + [ + 2, + 61, + 1 + ], + [ + 2, + 62, + 2 + ], + [ + 3, + 17, + 1 + ], + [ + 3, + 65, + 2 + ], + [ + 3, + 75, + 1 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 2 + ], + [ + 1, + 60, + 1 + ], + [ + 1, + 61, + 1 + ], + [ + 2, + 19, + 1 + ], + [ + 2, + 60, + 1 + ], + [ + 2, + 61, + 1 + ], + [ + 2, + 62, + 2 + ], + [ + 2, + 64, + 1 + ], + [ + 3, + 17, + 1 + ], + [ + 3, + 65, + 2 + ], + [ + 3, + 89, + 1 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 2 + ], + [ + 1, + 60, + 2 + ], + [ + 2, + 19, + 1 + ], + [ + 2, + 62, + 2 + ], + [ + 2, + 63, + 1 + ], + [ + 2, + 64, + 2 + ], + [ + 3, + 17, + 1 + ], + [ + 3, + 65, + 2 + ], + [ + 3, + 66, + 1 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 2 + ], + [ + 1, + 60, + 1 + ], + [ + 1, + 90, + 1 + ], + [ + 2, + 19, + 1 + ], + [ + 2, + 60, + 1 + ], + [ + 2, + 62, + 1 + ], + [ + 2, + 64, + 2 + ], + [ + 2, + 90, + 1 + ], + [ + 3, + 17, + 1 + ], + [ + 3, + 65, + 2 + ], + [ + 3, + 89, + 1 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 1 + ], + [ + 1, + 60, + 1 + ], + [ + 1, + 61, + 1 + ], + [ + 1, + 90, + 1 + ], + [ + 2, + 60, + 1 + ], + [ + 2, + 62, + 2 + ], + [ + 2, + 64, + 2 + ], + [ + 2, + 91, + 1 + ], + [ + 3, + 17, + 1 + ], + [ + 3, + 65, + 1 + ], + [ + 3, + 72, + 1 + ], + [ + 3, + 89, + 1 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 67, + 2 + ], + [ + 1, + 68, + 1 + ], + [ + 2, + 68, + 1 + ], + [ + 2, + 69, + 4 + ], + [ + 2, + 70, + 1 + ], + [ + 3, + 66, + 2 + ], + [ + 3, + 72, + 2 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 3 + ], + [ + 1, + 67, + 1 + ], + [ + 2, + 7, + 3 + ], + [ + 2, + 67, + 1 + ], + [ + 2, + 69, + 2 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 66, + 2 + ], + [ + 3, + 72, + 1 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 3 + ], + [ + 1, + 68, + 1 + ], + [ + 2, + 7, + 3 + ], + [ + 2, + 68, + 1 + ], + [ + 2, + 69, + 2 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 66, + 1 + ], + [ + 3, + 72, + 2 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 67, + 1 + ], + [ + 1, + 68, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 67, + 1 + ], + [ + 2, + 68, + 1 + ], + [ + 2, + 69, + 3 + ], + [ + 3, + 66, + 2 + ], + [ + 3, + 72, + 2 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 67, + 2 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 69, + 4 + ], + [ + 2, + 70, + 1 + ], + [ + 3, + 66, + 2 + ], + [ + 3, + 72, + 2 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 68, + 2 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 69, + 4 + ], + [ + 2, + 71, + 1 + ], + [ + 3, + 66, + 2 + ], + [ + 3, + 72, + 2 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 67, + 1 + ], + [ + 1, + 68, + 2 + ], + [ + 2, + 67, + 1 + ], + [ + 2, + 69, + 4 + ], + [ + 2, + 71, + 1 + ], + [ + 3, + 66, + 2 + ], + [ + 3, + 72, + 2 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 4 + ], + [ + 2, + 19, + 5 + ], + [ + 2, + 73, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 73, + 1 + ], + [ + 3, + 74, + 2 + ], + [ + 4, + 7, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 4 + ], + [ + 2, + 19, + 5 + ], + [ + 2, + 74, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 73, + 1 + ], + [ + 3, + 74, + 1 + ], + [ + 3, + 75, + 1 + ], + [ + 4, + 7, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 4 + ], + [ + 2, + 19, + 5 + ], + [ + 2, + 75, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 74, + 2 + ], + [ + 3, + 75, + 1 + ], + [ + 4, + 7, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 1 + ], + [ + 1, + 20, + 2 + ], + [ + 1, + 77, + 1 + ], + [ + 2, + 22, + 2 + ], + [ + 2, + 24, + 2 + ], + [ + 2, + 77, + 1 + ], + [ + 2, + 92, + 1 + ], + [ + 3, + 25, + 2 + ], + [ + 3, + 76, + 1 + ], + [ + 3, + 83, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 3 + ], + [ + 1, + 77, + 1 + ], + [ + 2, + 19, + 3 + ], + [ + 2, + 24, + 2 + ], + [ + 2, + 77, + 1 + ], + [ + 3, + 25, + 2 + ], + [ + 3, + 73, + 1 + ], + [ + 3, + 76, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 2 + ], + [ + 1, + 21, + 1 + ], + [ + 1, + 77, + 1 + ], + [ + 2, + 19, + 1 + ], + [ + 2, + 22, + 2 + ], + [ + 2, + 24, + 2 + ], + [ + 2, + 78, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 25, + 1 + ], + [ + 3, + 76, + 1 + ], + [ + 3, + 79, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 80, + 1 + ], + [ + 1, + 84, + 1 + ], + [ + 1, + 86, + 1 + ], + [ + 2, + 80, + 1 + ], + [ + 2, + 81, + 2 + ], + [ + 2, + 85, + 2 + ], + [ + 2, + 87, + 1 + ], + [ + 3, + 26, + 1 + ], + [ + 3, + 79, + 2 + ], + [ + 3, + 83, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 3 + ], + [ + 1, + 80, + 1 + ], + [ + 2, + 7, + 3 + ], + [ + 2, + 80, + 1 + ], + [ + 2, + 81, + 1 + ], + [ + 2, + 85, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 26, + 1 + ], + [ + 3, + 79, + 1 + ], + [ + 3, + 83, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 80, + 1 + ], + [ + 1, + 86, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 80, + 1 + ], + [ + 2, + 81, + 2 + ], + [ + 2, + 85, + 1 + ], + [ + 2, + 86, + 1 + ], + [ + 3, + 26, + 1 + ], + [ + 3, + 79, + 2 + ], + [ + 3, + 83, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 80, + 2 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 81, + 2 + ], + [ + 2, + 82, + 1 + ], + [ + 2, + 85, + 2 + ], + [ + 3, + 26, + 1 + ], + [ + 3, + 79, + 2 + ], + [ + 3, + 83, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 1 + ], + [ + 1, + 80, + 2 + ], + [ + 1, + 86, + 1 + ], + [ + 2, + 81, + 2 + ], + [ + 2, + 82, + 1 + ], + [ + 2, + 85, + 2 + ], + [ + 2, + 86, + 1 + ], + [ + 3, + 26, + 1 + ], + [ + 3, + 79, + 2 + ], + [ + 3, + 83, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 3 + ], + [ + 1, + 84, + 1 + ], + [ + 2, + 7, + 3 + ], + [ + 2, + 84, + 1 + ], + [ + 2, + 85, + 2 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 26, + 1 + ], + [ + 3, + 79, + 2 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 80, + 1 + ], + [ + 1, + 84, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 80, + 1 + ], + [ + 2, + 81, + 1 + ], + [ + 2, + 84, + 1 + ], + [ + 2, + 85, + 2 + ], + [ + 3, + 26, + 1 + ], + [ + 3, + 79, + 2 + ], + [ + 3, + 83, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 3 + ], + [ + 1, + 86, + 1 + ], + [ + 2, + 7, + 3 + ], + [ + 2, + 81, + 2 + ], + [ + 2, + 86, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 79, + 2 + ], + [ + 3, + 83, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 7, + 1 + ], + [ + 1, + 7, + 2 + ], + [ + 1, + 84, + 1 + ], + [ + 1, + 86, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 81, + 2 + ], + [ + 2, + 85, + 2 + ], + [ + 2, + 87, + 1 + ], + [ + 3, + 26, + 1 + ], + [ + 3, + 79, + 2 + ], + [ + 3, + 83, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 2 + ], + [ + 1, + 32, + 2 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 8, + 2 + ], + [ + 2, + 33, + 2 + ], + [ + 2, + 88, + 1 + ], + [ + 3, + 9, + 2 + ], + [ + 3, + 34, + 1 + ], + [ + 3, + 47, + 1 + ], + [ + 4, + 11, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 1 + ], + [ + 1, + 60, + 2 + ], + [ + 1, + 90, + 1 + ], + [ + 2, + 62, + 2 + ], + [ + 2, + 64, + 2 + ], + [ + 2, + 90, + 1 + ], + [ + 2, + 93, + 1 + ], + [ + 3, + 65, + 2 + ], + [ + 3, + 66, + 1 + ], + [ + 3, + 89, + 1 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 3 + ], + [ + 1, + 90, + 1 + ], + [ + 2, + 19, + 3 + ], + [ + 2, + 64, + 2 + ], + [ + 2, + 90, + 1 + ], + [ + 3, + 65, + 2 + ], + [ + 3, + 73, + 1 + ], + [ + 3, + 89, + 1 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 2 + ], + [ + 1, + 61, + 1 + ], + [ + 1, + 90, + 1 + ], + [ + 2, + 19, + 1 + ], + [ + 2, + 62, + 2 + ], + [ + 2, + 64, + 2 + ], + [ + 2, + 91, + 1 + ], + [ + 3, + 17, + 1 + ], + [ + 3, + 65, + 1 + ], + [ + 3, + 72, + 1 + ], + [ + 3, + 89, + 1 + ], + [ + 4, + 18, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 2 + ], + [ + 1, + 20, + 2 + ], + [ + 2, + 19, + 1 + ], + [ + 2, + 22, + 2 + ], + [ + 2, + 24, + 2 + ], + [ + 2, + 92, + 1 + ], + [ + 3, + 25, + 2 + ], + [ + 3, + 76, + 1 + ], + [ + 3, + 83, + 1 + ], + [ + 4, + 27, + 1 + ] + ], + [ + [ + 0, + 19, + 1 + ], + [ + 1, + 19, + 2 + ], + [ + 1, + 60, + 2 + ], + [ + 2, + 19, + 1 + ], + [ + 2, + 62, + 2 + ], + [ + 2, + 64, + 2 + ], + [ + 2, + 93, + 1 + ], + [ + 3, + 65, + 2 + ], + [ + 3, + 66, + 1 + ], + [ + 3, + 89, + 1 + ], + [ + 4, + 18, + 1 + ] + ] + ], + "output": [ + 0, + 1, + 1, + 1, + 1, + 2, + 0, + 1, + 1, + 1, + 1, + 2, + 1, + 1, + 1, + 1, + 2, + 1, + 2, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 1, + 2, + 0, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 1, + 2, + 0, + 0, + 1, + 2, + 1, + 2, + 2, + 2, + 1, + 2, + 2, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 2, + 2, + 1, + 2, + 2, + 1, + 2, + 0, + 0, + 1, + 2, + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 1, + 2, + 2, + 2, + 0, + 2, + 0, + 0, + 2, + 2 + ], + "initial": [ + 0, + 1, + 1, + 2, + 1, + 3, + 2, + 4, + 1, + 2, + 3, + 4, + 2, + 4, + 4, + 5 + ], + "counts": [ + 3, + 35, + 94, + 94 + ] + }, + "blocks": { + "5": { + "state_indices": [ + 0, + 16, + 17, + 18, + 19 + ], + "rows": [ + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 4 + ], + [ + 2, + 0, + 6 + ], + [ + 3, + 1, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 3, + 1 + ], + [ + 3, + 4, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 4 + ], + [ + 2, + 0, + 5 + ], + [ + 2, + 1, + 1 + ], + [ + 3, + 1, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 4, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 4 + ], + [ + 2, + 0, + 5 + ], + [ + 2, + 2, + 1 + ], + [ + 3, + 1, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 3, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 4 + ], + [ + 2, + 0, + 5 + ], + [ + 2, + 3, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 3, + 1 + ], + [ + 3, + 4, + 1 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 4 + ], + [ + 2, + 0, + 5 + ], + [ + 2, + 4, + 1 + ], + [ + 3, + 1, + 1 + ], + [ + 3, + 3, + 1 + ], + [ + 3, + 4, + 1 + ] + ] + ], + "perron_quotient": { + "labels": [ + 0, + 1, + 1, + 1, + 1 + ], + "rows": [ + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 4 + ], + [ + 2, + 0, + 6 + ], + [ + 3, + 1, + 4 + ] + ], + [ + [ + 0, + 0, + 1 + ], + [ + 1, + 0, + 4 + ], + [ + 2, + 0, + 5 + ], + [ + 2, + 1, + 1 + ], + [ + 3, + 1, + 3 + ] + ] + ], + "factor_name": "closed_2" + }, + "characteristic_coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + -1, + -4, + -10, + -4 + ], + [ + 0, + 0, + 4, + 16, + 30, + 16, + 2 + ], + [ + 0, + 0, + 0, + 0, + -6, + -24, + -38, + -16, + 4, + 4 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 16, + 21, + 0, + -14, + -8, + -3 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -4, + -4, + 4, + 7, + 0, + -2 + ] + ], + "direct_trace_checks": 5, + "irreducible_and_aperiodic_for_positive_t": true + }, + "15": { + "state_indices": [ + 15, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152 + ], + "rows": [ + [ + [ + 1, + 1, + 1 + ], + [ + 1, + 2, + 1 + ], + [ + 1, + 4, + 1 + ], + [ + 1, + 8, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 5, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 10, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 1, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 2, + 1 + ], + [ + 2, + 2, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 1, + 1 + ], + [ + 1, + 2, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 2, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 4, + 1 + ], + [ + 2, + 4, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 1, + 1 + ], + [ + 1, + 4, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 5, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 2, + 1 + ], + [ + 1, + 4, + 1 + ], + [ + 2, + 2, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 4, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 1, + 1 + ], + [ + 1, + 2, + 1 + ], + [ + 1, + 4, + 1 + ], + [ + 2, + 2, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 5, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 8, + 1 + ], + [ + 2, + 8, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 1, + 1 + ], + [ + 1, + 8, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 8, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 2, + 1 + ], + [ + 1, + 8, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 10, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 1, + 1 + ], + [ + 1, + 2, + 1 + ], + [ + 1, + 8, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 10, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 4, + 1 + ], + [ + 1, + 8, + 1 + ], + [ + 2, + 4, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 8, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 1, + 1 + ], + [ + 1, + 4, + 1 + ], + [ + 1, + 8, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 5, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 8, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 2, + 1 + ], + [ + 1, + 4, + 1 + ], + [ + 1, + 8, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 4, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 10, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 7, + 1 + ], + [ + 3, + 11, + 1 + ], + [ + 3, + 13, + 1 + ], + [ + 3, + 14, + 1 + ], + [ + 4, + 0, + 1 + ] + ] + ], + "perron_quotient": { + "labels": [ + 0, + 1, + 1, + 2, + 1, + 3, + 2, + 4, + 1, + 2, + 3, + 4, + 2, + 4, + 4 + ], + "rows": [ + [ + [ + 1, + 1, + 4 + ], + [ + 2, + 2, + 4 + ], + [ + 2, + 3, + 2 + ], + [ + 3, + 4, + 4 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 1, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 2, + 2 + ], + [ + 3, + 4, + 3 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 1, + 2 + ], + [ + 2, + 1, + 2 + ], + [ + 2, + 2, + 3 + ], + [ + 3, + 4, + 4 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 1, + 2 + ], + [ + 2, + 2, + 4 + ], + [ + 2, + 3, + 1 + ], + [ + 3, + 4, + 4 + ], + [ + 4, + 0, + 1 + ] + ], + [ + [ + 1, + 1, + 3 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 2, + 4 + ], + [ + 2, + 3, + 1 + ], + [ + 3, + 4, + 4 + ], + [ + 4, + 0, + 1 + ] + ] + ], + "factor_name": "open_5" + }, + "characteristic_coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + 0, + -4, + -10, + -4, + -1 + ], + [ + 0, + 0, + 6, + 28, + 37, + 16, + 4 + ], + [ + 0, + 0, + 0, + -4, + -24, + -36, + 6, + 28, + 5, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 4, + -24, + -140, + -232, + -136, + -22, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 28, + 115, + 184, + 84, + -32, + -4, + 12, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 8, + 94, + 296, + 396, + 200, + -8, + -24, + -4 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -4, + -32, + -89, + -104, + -54, + -52, + -104, + -76, + -12, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -12, + -30, + 8, + 128, + 228, + 202, + 80, + 9, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 12, + 49, + 152, + 290, + 336, + 248, + 108, + 8, + -8, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -20, + -68, + -130, + -172, + -146, + -68, + -13, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -4, + -19, + -28, + -4, + 40, + 70, + 64, + 42, + 20, + 3 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6, + 36, + 87, + 116, + 92, + 40, + 7, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -4, + -24, + -60, + -87, + -80, + -46, + -16, + -3 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 4, + 6, + 4, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 4, + 6, + 4, + 1 + ] + ], + "direct_trace_checks": 15, + "irreducible_and_aperiodic_for_positive_t": true + }, + "16": { + "state_indices": [ + 1, + 21, + 22, + 23, + 24, + 25, + 153, + 154, + 155, + 156, + 157, + 158, + 160, + 161, + 163, + 481 + ], + "rows": [ + [ + [ + 1, + 0, + 1 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 5, + 1 + ] + ], + [ + [ + 1, + 0, + 1 + ], + [ + 1, + 6, + 1 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 5, + 1 + ], + [ + 3, + 8, + 1 + ] + ], + [ + [ + 1, + 0, + 1 + ], + [ + 1, + 6, + 1 + ], + [ + 1, + 9, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 10, + 1 + ], + [ + 2, + 11, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 8, + 1 + ] + ], + [ + [ + 1, + 0, + 1 + ], + [ + 1, + 12, + 1 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 11, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 5, + 1 + ], + [ + 3, + 8, + 1 + ] + ], + [ + [ + 1, + 0, + 1 + ], + [ + 1, + 6, + 1 + ], + [ + 1, + 12, + 1 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 11, + 1 + ], + [ + 2, + 13, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 5, + 1 + ] + ], + [ + [ + 1, + 0, + 1 + ], + [ + 1, + 9, + 1 + ], + [ + 1, + 12, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 11, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 2, + 14, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 5, + 1 + ], + [ + 3, + 8, + 1 + ] + ], + [ + [ + 1, + 6, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 8, + 1 + ] + ], + [ + [ + 1, + 6, + 1 + ], + [ + 1, + 9, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 6, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 11, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 5, + 1 + ], + [ + 3, + 8, + 1 + ] + ], + [ + [ + 1, + 6, + 1 + ], + [ + 1, + 9, + 1 + ], + [ + 1, + 12, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 11, + 1 + ], + [ + 2, + 15, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 5, + 1 + ], + [ + 3, + 8, + 1 + ] + ], + [ + [ + 1, + 9, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 11, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 5, + 1 + ], + [ + 3, + 8, + 1 + ] + ], + [ + [ + 1, + 0, + 1 + ], + [ + 1, + 9, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 10, + 1 + ], + [ + 2, + 11, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 8, + 1 + ] + ], + [ + [ + 1, + 9, + 1 + ], + [ + 1, + 12, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 9, + 1 + ], + [ + 2, + 11, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 5, + 1 + ], + [ + 3, + 8, + 1 + ] + ], + [ + [ + 1, + 12, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 11, + 1 + ], + [ + 2, + 12, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 5, + 1 + ], + [ + 3, + 8, + 1 + ] + ], + [ + [ + 1, + 6, + 1 + ], + [ + 1, + 12, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 11, + 1 + ], + [ + 2, + 13, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 5, + 1 + ] + ], + [ + [ + 1, + 0, + 1 + ], + [ + 1, + 9, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 11, + 1 + ], + [ + 2, + 14, + 1 + ], + [ + 3, + 4, + 1 + ], + [ + 3, + 5, + 1 + ], + [ + 3, + 8, + 1 + ] + ], + [ + [ + 1, + 6, + 1 + ], + [ + 1, + 12, + 1 + ], + [ + 2, + 1, + 1 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 7, + 1 + ], + [ + 2, + 11, + 1 + ], + [ + 2, + 15, + 1 + ], + [ + 3, + 2, + 1 + ], + [ + 3, + 5, + 1 + ], + [ + 3, + 8, + 1 + ] + ] + ], + "perron_quotient": { + "labels": [ + 0, + 1, + 2, + 1, + 2, + 2, + 0, + 1, + 2, + 0, + 3, + 1, + 0, + 3, + 3, + 3 + ], + "rows": [ + [ + [ + 1, + 0, + 1 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 1, + 2 + ], + [ + 3, + 2, + 3 + ] + ], + [ + [ + 1, + 0, + 2 + ], + [ + 2, + 0, + 2 + ], + [ + 2, + 1, + 3 + ], + [ + 3, + 2, + 4 + ] + ], + [ + [ + 1, + 0, + 3 + ], + [ + 2, + 0, + 1 + ], + [ + 2, + 1, + 4 + ], + [ + 2, + 3, + 1 + ], + [ + 3, + 2, + 3 + ] + ], + [ + [ + 1, + 0, + 2 + ], + [ + 2, + 1, + 4 + ], + [ + 2, + 3, + 1 + ], + [ + 3, + 2, + 3 + ] + ] + ], + "factor_name": "shared_4a" + }, + "characteristic_coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + 0, + -4, + -12, + -4 + ], + [ + 0, + 0, + 6, + 36, + 58, + 24, + 2 + ], + [ + 0, + 0, + 0, + -4, + -36, + -96, + -84, + -20, + 0, + 4 + ], + [ + 0, + 0, + 0, + 0, + 1, + 12, + 30, + -32, + -175, + -152, + -48, + -8, + -3 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16, + 136, + 416, + 548, + 288, + 24, + -32, + -4 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -4, + -44, + -164, + -228, + 24, + 308, + 246, + 84, + 30 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -20, + -168, + -580, + -952, + -648, + -64, + 116, + 44 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6, + 60, + 242, + 428, + 167, + -432, + -586, + -308, + -85 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 44, + 192, + 388, + 268, + -144, + -320, + -144 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -4, + -36, + -136, + -236, + -38, + 532, + 766, + 376, + 48 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8, + 52, + 144, + 276, + 484, + 616, + 428, + 120 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 8, + 16, + -4, + -48, + -92, + -88, + -24, + 7 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -4, + -28, + -68, + -72, + -40, + -32, + -32, + -12 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6, + 36, + 82, + 96, + 62, + 20, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -4, + -20, + -40, + -40, + -20, + -4 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 4, + 6, + 4, + 1 + ] + ], + "direct_trace_checks": 16, + "irreducible_and_aperiodic_for_positive_t": true + } + }, + "identities": { + "P0": "tr(B5^m)-tr(B16^m)+2*t^(2m)", + "P2": "tr(B15^m)-tr(B16^m)+2*t^(2m)", + "M": "tr(B15^m)-tr(B5^m)" + }, + "normalization": "divide by (1+t)^(4*m); t=p/(1-p); endpoints by continuity", + "trace_factor_weights": { + "P0": { + "closed_b": 1, + "closed_a": 2, + "closed_2": 1, + "negative_square": -1, + "shared_3": -1, + "shared_4a": -1, + "shared_4b": -2, + "positive_square": 2 + }, + "P2": { + "open_3b": 1, + "open_3a": 2, + "open_5": 1, + "shared_3": -1, + "shared_4a": -1, + "shared_4b": -2, + "positive_square": 2 + }, + "M": { + "closed_b": -1, + "closed_a": -2, + "closed_2": -1, + "negative_square": 1, + "open_3b": 1, + "open_3a": 2, + "open_5": 1 + } + }, + "certificate": { + "common_weighted_lumping_counts": [ + 3, + 35, + 94, + 94 + ], + "all_509_rows_checked": true, + "zero_polynomials_checked_each": 126, + "P0_sufficient_moments": 116, + "P2_sufficient_moments": 126, + "radix_bits": 512, + "difference_coefficient_bound": "34*16^m < radix", + "method": "exact Kronecker evaluation with proved coefficient bound, then finite-dimensional Cayley-Hamilton", + "small_block_raw_matrix_trace_checks": 36, + "resultant_sylvester_identity": true + }, + "generic_minimum_orders": { + "P0": 17, + "P2": 23, + "M": 16 + }, + "minimality": [ + { + "fugacity": 1, + "probability": "1/2", + "channel": "M", + "minimum_scalar_order": 15, + "hankel_start_length": 2, + "determinant": "-1480741158238721640945362024307471335089774150588805816471254212544678061868790579200000" + }, + { + "fugacity": 2, + "probability": "2/3", + "channel": "M", + "minimum_scalar_order": 14, + "hankel_start_length": 2, + "determinant": "-1256323951503673828912281020666158048090144310363433305185769712647782265616257798358465235491980795064856854341600457200379918501168158151581567930673034353100188897399104856270386362607258696188945707469941292578059059200" + }, + { + "fugacity": 3, + "probability": "3/4", + "channel": "M", + "minimum_scalar_order": 16, + "hankel_start_length": 2, + "determinant": "5878482235272791444286795204334253835176032770952232814426459953948229176739932618183139501173207998203187591468347925101805802719619063050813112629790123816765883673816873611206074787604583419279102061210605998613571595706887689934314182066858434770961455264607260022143408031491791324101823798121524260283798390468710663263168452647426316753053020036848478837199933534986266958517847982080000000" + }, + { + "fugacity": 3, + "probability": "3/4", + "channel": "P0", + "minimum_scalar_order": 17, + "hankel_start_length": 2, + "determinant": "1035366868494620196511836131134094725949347486989806574555518176836860481051488969216515047246632215559645208866720626564429988092452194125596562085853938536927663777732005691623352946978400691772791252422523083728144812592655694761169219688965175868902884580306873210456138465043736705960776213287794463712436175695556669713509324394427051032386621858428440238536706700723141245956003696217121034887542121416585742831845376000000000" + }, + { + "fugacity": 3, + "probability": "3/4", + "channel": "P2", + "minimum_scalar_order": 23, + "hankel_start_length": 2, + "determinant": "-69526340898558562249019959730951170417651638221700568670842287247103707903056098130105728993996817503523801165701004029173332365129600306525643380534051757915173797115285706655922024569092006056628137598926623897125480637189464123042374499137090339091408101522961991909361990314047077313952410829820116531943746523457974165600966947364493967380303217459261879987941753854472204012900137326513433078771479771901851008639549020170799022105141322423839360107532257011707361401056363283969428643927159183734894200260390698361698630251572254067925495836986771589989634630800807910104209814614065292606526522553792057389774039304784232579188878482565367417872939032208309658225155823698240564415116366851510974508443119434411507869164325602764377765439965998612480000" + } + ], + "generic_M_recurrence_coefficients_desc_x_ascending_t": [ + [ + 1 + ], + [ + -1, + -7, + -17, + -7, + -1 + ], + [ + 0, + 3, + 26, + 89, + 134, + 76, + 22, + 3 + ], + [ + 0, + 0, + -3, + -37, + -172, + -390, + -427, + -212, + -57, + -4, + 1 + ], + [ + 0, + 0, + 0, + 1, + 19, + 120, + 345, + 453, + 143, + -172, + -137, + -54, + -18, + -3 + ], + [ + 0, + 0, + 0, + 0, + 0, + -2, + -18, + -30, + 179, + 875, + 1535, + 1218, + 451, + 91, + 23, + 5 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + -43, + -309, + -1080, + -2015, + -1928, + -739, + 80, + 184, + 68, + 2, + -3 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6, + 69, + 305, + 622, + 439, + -436, + -926, + -533, + -122, + 18, + 7, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15, + 156, + 676, + 1520, + 1813, + 981, + 86, + -26, + 128, + 137, + 45, + 3 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -6, + -69, + -341, + -947, + -1620, + -1822, + -1566, + -1300, + -891, + -305, + 20, + 32, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 23, + 117, + 351, + 698, + 947, + 758, + -4, + -809, + -836, + -350, + -40, + 12, + 3 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 18, + 72, + 179, + 342, + 570, + 792, + 755, + 325, + -133, + -187, + -44, + 20, + 5 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -14, + -84, + -291, + -647, + -946, + -881, + -488, + -172, + -133, + -182, + -120, + -29, + -4 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 31, + 139, + 354, + 564, + 565, + 308, + -8, + -160, + -159, + -104, + -43, + -10 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -3, + -27, + -98, + -181, + -157, + 12, + 178, + 194, + 110, + 43, + 10, + -1 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 7, + 17, + 8, + -39, + -79, + -52, + 10, + 36, + 22, + 5 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 6, + 13, + 8, + -11, + -18, + -5, + 4, + 2 + ] + ], + "generic_recurrence_squarefree_over_Q_t": true, + "small_integer_sector_polynomials": [ + { + "length": 1, + "rank0_coefficients": [ + 1, + 0, + 0, + 0, + 0 + ], + "rank2_coefficients": [ + 0, + 0, + 0, + 0, + 1 + ] + }, + { + "length": 2, + "rank0_coefficients": [ + 1, + 8, + 24, + 32, + 14, + 0, + 0, + 0, + 0 + ], + "rank2_coefficients": [ + 0, + 0, + 0, + 0, + 0, + 8, + 16, + 8, + 1 + ] + }, + { + "length": 3, + "rank0_coefficients": [ + 1, + 12, + 66, + 216, + 456, + 624, + 510, + 180, + 0, + 0, + 0, + 0, + 0 + ], + "rank2_coefficients": [ + 0, + 0, + 0, + 0, + 0, + 0, + 12, + 96, + 222, + 192, + 66, + 12, + 1 + ] + }, + { + "length": 4, + "rank0_coefficients": [ + 1, + 16, + 120, + 560, + 1812, + 4272, + 7448, + 9440, + 8082, + 3984, + 792, + 32, + 0, + 0, + 0, + 0, + 0 + ], + "rank2_coefficients": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16, + 208, + 1088, + 2512, + 2864, + 1660, + 560, + 120, + 16, + 1 + ] + }, + { + "length": 5, + "rank0_coefficients": [ + 1, + 20, + 190, + 1140, + 4840, + 15420, + 38080, + 74020, + 113300, + 134000, + 116530, + 67900, + 22680, + 3440, + 120, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "rank2_coefficients": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20, + 360, + 2760, + 11400, + 26390, + 35400, + 28010, + 14000, + 4750, + 1140, + 190, + 20, + 1 + ] + }, + { + "length": 6, + "rank0_coefficients": [ + 1, + 24, + 276, + 2024, + 10620, + 42384, + 133428, + 338808, + 702828, + 1196768, + 1666440, + 1867872, + 1629362, + 1043088, + 447648, + 113160, + 13572, + 480, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "rank2_coefficients": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24, + 552, + 5592, + 32544, + 117600, + 270348, + 400712, + 387864, + 253848, + 117832, + 40536, + 10512, + 2024, + 276, + 24, + 1 + ] + } + ], + "seconds": 1.3151530979999961, + "limits": [ + "width four only, physical m>=2", + "small-block traces are NOT individual probabilities", + "generic rank is not uniform at exceptional parameters", + "not a continuum operator identification or all-width pTL intertwiner" + ] +} diff --git a/scripts/rank_two_onset.py b/scripts/rank_two_onset.py new file mode 100644 index 00000000..20a12971 --- /dev/null +++ b/scripts/rank_two_onset.py @@ -0,0 +1,114 @@ +#!/usr/bin/env python3 +"""Small controls for the all-L two-cycle-core onset proof (no new large census). + +Axis periods (L,0),(0,L); diamond periods (L,L),(L,-L). +The theorem is in the companion note. Enumeration is only an existing-size +check, not the proof. Physical integer lift traversal is independent of #708. +""" +from __future__ import annotations +import argparse +from itertools import combinations +import json +from pathlib import Path +import time + + +def geometry(L, diamond): + if type(L) is not int or L<2:raise ValueError('L>=2 required') + width=2*L if diamond else L + def canonical(x,y): + if diamond:x-=(y//L)*L + return (x%width,y%L) + sites=[(x,y) for y in range(L) for x in range(width)] + index={xy:i for i,xy in enumerate(sites)} + adj=[] + for x,y in sites: + adj.append([(index[canonical(x+dx,y+dy)],dx,dy) + for dx,dy in ((1,0),(-1,0),(0,1),(0,-1))]) + return sites,index,canonical,adj + + +def rank(mask,adj): + positions={};first=None + for root in range(len(adj)): + if not (mask>>root)&1 or root in positions:continue + positions[root]=(0,0);todo=[root] + while todo: + i=todo.pop();x,y=positions[i] + for j,dx,dy in adj[i]: + if not (mask>>j)&1:continue + proposed=(x+dx,y+dy) + if j not in positions:positions[j]=proposed;todo.append(j) + else: + v=(proposed[0]-positions[j][0],proposed[1]-positions[j][1]) + if v!=(0,0): + if first is None:first=v + elif first[0]*v[1]-first[1]*v[0]:return 2 + return int(first is not None) + + +def predicted_minimizers(L,diamond): + sites,index,canonical,_=geometry(L,diamond);out=set() + def encode(points):return sum(1<=2; rank2 only', + 'small_existing_size_checks':cases,'total_configurations_checked':sum(c['configurations_checked'] for c in cases), + 'construction_checks':constructions,'diamond_L5_onset_prediction':{'mass':14,'count':100,'enumerated':False}, + 'proof_not_enumeration':'two independent cycles reduce to a wedge or theta; systolic bounds and equality cases', + 'seconds':time.perf_counter()-started, + 'limits':['no new diamond L4/L5 enumeration','does not classify every higher-mass wrapping cell','no threshold exponent or continuum field claim']} + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--out',type=Path);args=ap.parse_args() + text=json.dumps(report(),indent=2,allow_nan=False)+'\n' + if args.out: + with args.out.open('x',encoding='utf-8') as f:f.write(text) + else:print(text,end='') diff --git a/scripts/width4_cylinder_certificate.py b/scripts/width4_cylinder_certificate.py new file mode 100644 index 00000000..56b01a6f --- /dev/null +++ b/scripts/width4_cylinder_certificate.py @@ -0,0 +1,158 @@ +#!/usr/bin/env python3 +"""Rational interval certificate for the width-four crossing and all-m root sign. + +mpmath supplies diagnostic approximations and proposes isolating bands. Every +load-bearing band/sign/inequality is checked afterward using fractions.Fraction. +""" +from __future__ import annotations +import argparse +from fractions import Fraction as F +import json +from pathlib import Path +from mpmath import mp +from width4_parametric_traces import polynomial_value, RESULTS + +class Interval: + def __init__(self,lo,hi=None): + self.lo=F(lo);self.hi=F(hi if hi is not None else lo) + if self.lo>self.hi:raise ValueError('reversed interval') + @staticmethod + def of(x):return x if isinstance(x,Interval) else Interval(x) + def __add__(self,other): + o=self.of(other);return Interval(self.lo+o.lo,self.hi+o.hi) + __radd__=__add__ + def __neg__(self):return Interval(-self.hi,-self.lo) + def __sub__(self,other):return self+-self.of(other) + def __rsub__(self,other):return self.of(other)+-self + def __mul__(self,other): + o=self.of(other);v=[self.lo*o.lo,self.lo*o.hi,self.hi*o.lo,self.hi*o.hi] + return Interval(min(v),max(v)) + __rmul__=__mul__ + def __truediv__(self,other): + o=self.of(other) + if o.lo<=0<=o.hi:raise ValueError('interval division through zero') + return self*Interval(1/o.hi,1/o.lo) + def __rtruediv__(self,other):return self.of(other)/self + def __pow__(self,n): + if not isinstance(n,int) or n<0:raise ValueError('nonnegative integer power required') + out=Interval(1) + for _ in range(n):out=out*self + return out + def positive(self):return self.lo>0 + def negative(self):return self.hi<0 + def json(self):return [str(self.lo),str(self.hi)] + + +def evaluate_x(coeff,t,x): + out=0 + for c in coeff:out=out*x+polynomial_value(c,t) + return out + + +def certificate(): + definition=json.loads((RESULTS/'width4-parametric-definition.json').read_text()) + result=json.loads((RESULTS/'width4-parametric-traces.json').read_text()) + R=definition['crossing_polynomial_ascending_t'] + signs=[1 if c>0 else -1 for c in reversed(R) if c] + changes=sum(a!=b for a,b in zip(signs,signs[1:])) + if changes!=1:raise AssertionError('Descartes count is not one') + lo,hi=F(1),F(2) + for _ in range(160): + mid=(lo+hi)/2 + if polynomial_value(R,mid)<0:lo=mid + else:hi=mid + if not polynomial_value(R,lo)<0=F('5.13')**2: + raise AssertionError('complex-pair enclosure failed') + complex_controls[name]={'sum':total.json(),'modulus_squared':product.json(),'discriminant':discr.json()} + lam=bands['closed_2'][0];mu=bands['open_3a'][0] + # Equality of the Perron roots follows from the unique resultant root, + # positive equitable quotients and an endpoint sign change, not decimals. + other=bands['closed_2'][1:]+bands['open_3a'][1:]+bands['open_3b']+bands['open_5'][1:] + other += [ti*ti*(1+ti),ti*ti*(1-ti),-ti*ti] + if max(max(abs(v.lo),abs(v.hi)) for v in other)>=F('5.13'): + raise AssertionError('other-root modulus bound failed') + theta=F(674,1000) + if F('5.13')/mu.lo>=theta or 16*theta**6>=2:raise AssertionError('all-m positivity bound failed') + def derivative_t(coeff):return [[j*c[j] for j in range(1,len(c))] or [0] for c in coeff] + def derivative_x(coeff):return [[(len(coeff)-1-i)*v for v in c] for i,c in enumerate(coeff[:-1])] + derivatives={} + for name in ('closed_2','open_5'): + co=factors[name]['coefficients_desc_x_ascending_t'] + derivatives[name]=-evaluate_x(derivative_t(co),ti,lam)/evaluate_x(derivative_x(co),ti,lam) + hp=(derivatives['open_5']-derivatives['closed_2'])/lam/(1-pi)**2 + if not hp.positive():raise AssertionError('crossing slope not positive') + # The shared sector's Perron root is rigorously smaller at the crossing. + rows=result['blocks']['16']['perron_quotient']['rows'];n=len(rows) + A=mp.zeros(n) + for i,row in enumerate(rows): + for k,j,c in row:A[i,j]+=c*tn**k + eig,vec=mp.eig(A,left=False,right=True);idx=max(range(n),key=lambda i:mp.re(eig[i]));v=[mp.re(vec[i,idx]/vec[0,idx]) for i in range(n)] + vf=[F(int(mp.nint(a*10**10)),10**10) for a in v] + if not all(v>0 for v in vf):raise AssertionError('Collatz vector not positive') + ratios=[sum(c*ti**k*vf[j] for k,j,c in row)/vf[i] for i,row in enumerate(rows)] + lower=min(v.lo for v in ratios);upper=max(v.hi for v in ratios) + if upper>=lam.lo:raise AssertionError('shared sector not strictly below leading') + finite_checks=[] + for row in result['small_integer_sector_polynomials']: + m=row['length'] + if 2<=m<=5: + coefficients=[b-a for a,b in zip(row['rank0_coefficients'],row['rank2_coefficients'])] + value=polynomial_value(coefficients,ti) + if not value.positive():raise AssertionError(('finite root sign failed',m)) + finite_checks.append({'m':m,'positive_unnormalized_M_interval':value.json()}) + # Diagnostic numbers use the same implicit derivatives with mp arithmetic. + ln=mp.findroot(lambda x:evaluate_x(factors['closed_2']['coefficients_desc_x_ascending_t'],tn,x),30) + mn=mp.findroot(lambda x:evaluate_x(factors['open_3a']['coefficients_desc_x_ascending_t'],tn,x),7.6) + def dp(name): + co=factors[name]['coefficients_desc_x_ascending_t'] + return -evaluate_x(derivative_t(co),tn,ln)/evaluate_x(derivative_x(co),tn,ln) + hpn=(dp('open_5')-dp('closed_2'))/ln/(1-pn)**2 + pub=mp.mpf('0.5914171708531384817988341017359231779642') + return {'schema':'matching-one.width4-cylinder-rational-certificate.v1', + 'root_t_interval':ti.json(),'root_p_interval':pi.json(),'one_positive_root_Descartes':True, + 'q4_diagnostic':mp.nstr(pn,60),'matches_Jacobsen_2015_table2_n4_within_1e_minus40':abs(pn-pub) 0', + 'conclusion':'M_(4,m)(q4)>0 and p_(4,m)=2'}, + 'asymptotic':'p_(4,m)-q4 = -2*rho^m/(m*hprime_p)*(1+O(theta^m)+O(rho^m)) at fixed width four', + 'limits':['not a new infinite-square pc','width-specific, not a uniform-width estimate','numerical roots propose bands; rational inequalities certify all load-bearing signs']} + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--out',type=Path);args=ap.parse_args() + data=certificate();text=json.dumps(data,indent=2,allow_nan=False)+'\n' + if args.out: + with args.out.open('x',encoding='utf-8') as f:f.write(text) + else:print(text,end='') diff --git a/scripts/width4_parametric_traces.py b/scripts/width4_parametric_traces.py new file mode 100644 index 00000000..0d51f915 --- /dev/null +++ b/scripts/width4_parametric_traces.py @@ -0,0 +1,333 @@ +#!/usr/bin/env python3 +"""Exact all-fugacity sector identities from PR #708's rank automaton. + +Standard library only. No Monte Carlo, numerical rank, or interpolation guess. +The large-radix evaluation is injective by the coefficient bound checked below. +All physical claims concern width four and lengths m >= 2. +""" +from __future__ import annotations +import argparse +from collections import Counter +from fractions import Fraction +import hashlib +import json +from math import factorial +from pathlib import Path +import time + +ROOT = Path(__file__).resolve().parents[1] +RESULTS = ROOT / 'results/research-control-20260912' +DEFINITION = RESULTS / 'width4-parametric-definition.json' +SOURCE = RESULTS / 'width4-rank-closure-certificate.json' + + +def poly_add(a, b): + c = [0] * max(len(a), len(b)) + for i, v in enumerate(a): c[i] += v + for i, v in enumerate(b): c[i] += v + return c + + +def poly_mul(a, b): + c = [0] * (len(a) + len(b) - 1) + for i, v in enumerate(a): + for j, w in enumerate(b): c[i+j] += v*w + return c + + +def polynomial_value(a, t): + value = 0 + for c in reversed(a): value = value*t+c + return value + + +def x_poly_product(a, b): + """Descending x coefficients, each an ascending integer t polynomial.""" + out = [[0] for _ in range(len(a)+len(b)-1)] + for i, p in enumerate(a): + for j, q in enumerate(b): out[i+j] = poly_add(out[i+j], poly_mul(p,q)) + return out + + +def packed_multiply(value, coefficients, bits): + return sum(c*(value << (bits*k)) for k,c in enumerate(coefficients) if c) + + +def trace_sequence(coefficients, maximum, *, t=None, bits=None): + """Newton identities; exactly one of integer t or radix bit size is used.""" + degree = len(coefficients)-1 + if (t is None) == (bits is None): raise ValueError('supply t or bits') + co = [polynomial_value(a,t) for a in coefficients] if bits is None else None + def multiply(v,i): + return v*co[i] if bits is None else packed_multiply(v,coefficients[i],bits) + result = [degree] + for m in range(1,maximum+1): + if m <= degree: + result.append(-sum(multiply(result[m-i],i) for i in range(1,m)) + -m*multiply(1,m)) + else: + result.append(-sum(multiply(result[m-i],i) for i in range(1,degree+1))) + return result + + +def weighted_quotient(source): + """Common strong lumping for every coefficient A_k in A(t)=sum t^k A_k.""" + rows=source['quotient_transitions']; output=source['quotient_rank_output'] + labels=output[:]; counts=[len(set(labels))] + while True: + lookup={}; new=[] + for i,row in enumerate(rows): + totals=Counter((mask.bit_count(),labels[j]) for mask,j in enumerate(row)) + key=(labels[i],tuple(sorted(totals.items()))) + new.append(lookup.setdefault(key,len(lookup))) + counts.append(len(lookup)) + if len(lookup)==len(set(labels)): + labels=new; break + labels=new + reps=[labels.index(i) for i in range(len(set(labels)))] + weighted=[] + for i in reps: + counts_row=Counter((mask.bit_count(),labels[j]) for mask,j in enumerate(rows[i])) + weighted.append([(k,j,n) for (k,j),n in sorted(counts_row.items())]) + # Check ALL source rows against their claimed lumped transitions. + for i,row in enumerate(rows): + expected=Counter((mask.bit_count(),labels[j]) for mask,j in enumerate(row)) + actual={(k,j):n for k,j,n in weighted[labels[i]]} + if dict(expected)!=actual: raise AssertionError('not a common lumping') + return dict(labels=labels,reps=reps,rows=weighted, + output=[output[i] for i in reps], + initial=[labels[i] for i in source['quotient_initial']],counts=counts) + + +def block_rows(source, ids): + pos={v:i for i,v in enumerate(ids)}; rows=[] + for i in ids: + counts=Counter((mask.bit_count(),pos[j]) for mask,j in + enumerate(source['quotient_transitions'][i]) if j in pos) + rows.append([(k,j,n) for (k,j),n in sorted(counts.items())]) + return rows + + +def strongly_connected(rows): + n=len(rows) + for reverse in (False,True): + edges=[set() for _ in rows] + for i,row in enumerate(rows): + for _,j,c in row: + if c: edges[j if reverse else i].add(i if reverse else j) + visited={0}; todo=[0] + while todo: + for j in edges[todo.pop()]: + if j not in visited: visited.add(j);todo.append(j) + if len(visited)!=n:return False + return True + + +def direct_matrix_traces(rows, maximum, bits): + """Independent multiplication of the SMALL raw block, not Newton recurrence.""" + n=len(rows); powers=[[int(i==j) for j in range(n)] for i in range(n)] + traces=[n] + for _ in range(maximum): + powers=[[sum(c*(powers[j][column]<<(bits*k)) for k,j,c in row) + for column in range(n)] for row in rows] + traces.append(sum(powers[i][i] for i in range(n))) + return traces + + +def perron_quotient(rows): + """Positive equitable block quotient; the Perron eigenvalue is retained.""" + labels=[0]*len(rows) + while True: + lookup={}; new=[] + for i,row in enumerate(rows): + totals=Counter() + for k,j,n in row: totals[k,labels[j]]+=n + key=(labels[i],tuple(sorted(totals.items()))) + new.append(lookup.setdefault(key,len(lookup))) + if len(lookup)==len(set(labels)):labels=new;break + labels=new + reps=[labels.index(i) for i in range(len(set(labels)))];out=[] + for i in reps: + totals=Counter() + for k,j,n in rows[i]:totals[k,labels[j]]+=n + out.append([(k,j,n) for (k,j),n in sorted(totals.items())]) + for i,row in enumerate(rows): + totals=Counter() + for k,j,n in row:totals[k,labels[j]]+=n + if dict(totals)!={(k,j):n for k,j,n in out[labels[i]]}: + raise AssertionError('equitable block identity failed') + return {'labels':labels,'rows':out} + + +def scalar_sequences(quotient, maximum, t): + v=[0]*len(quotient['rows']) + for mask,j in enumerate(quotient['initial']):v[j]+=t**mask.bit_count() + p0=[];p2=[] + for _ in range(maximum): + p0.append(sum(vv for vv,r in zip(v,quotient['output']) if r==0)) + p2.append(sum(vv for vv,r in zip(v,quotient['output']) if r==2)) + new=[0]*len(v) + for i,row in enumerate(quotient['rows']): + for k,j,c in row:new[j]+=c*t**k*v[i] + v=new + return p0,p2,[b-a for a,b in zip(p0,p2)] + + +def bareiss(matrix): + a=[list(row) for row in matrix];n=len(a);previous=1;sign=1 + for k in range(n-1): + if not a[k][k]: + j=next((j for j in range(k+1,n) if a[j][k]),None) + if j is None:return 0 + a[k],a[j]=a[j],a[k];sign=-sign + pivot=a[k][k] + for i in range(k+1,n): + for j in range(k+1,n): + numerator=pivot*a[i][j]-a[i][k]*a[k][j] + if numerator%previous:raise AssertionError('Bareiss division not exact') + a[i][j]=numerator//previous + a[i][k]=0 + previous=pivot + return sign*a[-1][-1] + + +def squarefree(coefficients): + a=list(map(Fraction,coefficients));n=len(a)-1 + b=[(n-i)*a[i] for i in range(n)] + def remainder(a,b): + a=a[:] + while len(a)>=len(b): + c=a[0]/b[0] + for i,x in enumerate(b):a[i]-=c*x + while a and not a[0]:a.pop(0) + return a + while b:a,b=b,remainder(a,b) + return len(a)==1 + + +def factor_weights(definition, which): + terms=Counter() + def add_block(size,sgn): + for name,multiplicity in definition['blocks'][str(size)]['factorization']: + terms[name]+=sgn*multiplicity + if which in ('P0','M'):add_block(5,1 if which=='P0' else -1) + if which in ('P2','M'):add_block(15,1) + if which!='M':add_block(16,-1);terms['positive_square']+=2 + return {name:w for name,w in terms.items() if w} + + +def verify(source_path=SOURCE,definition_path=DEFINITION): + started=time.perf_counter();raw=Path(source_path).read_bytes();source=json.loads(raw) + definition=json.loads(Path(definition_path).read_text()) + blob=hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() + if blob!=definition['source_blob']:raise ValueError('wrong upstream certificate bytes') + q=weighted_quotient(source);dimension=len(q['rows']) + maximum=dimension+15+16+1 + bits=4*maximum+8;radix=1<=radix:raise AssertionError('insufficient radix for injectivity') + blocks={};traces={} + for size_text,entry in definition['blocks'].items(): + n=int(size_text); rows=block_rows(source,entry['quotient_state_indices']) + if not strongly_connected(rows):raise AssertionError('claimed block not irreducible') + if not any(j==i for i,row in enumerate(rows) for _,j,_ in row): + raise AssertionError('aperiodicity loop missing') + characteristic=[[1]] + for name,multiplicity in entry['factorization']: + for _ in range(multiplicity): + characteristic=x_poly_product(characteristic, + definition['factors'][name]['coefficients_desc_x_ascending_t']) + # Raw matrix traces through n determine its characteristic polynomial. + actual=direct_matrix_traces(rows,n,bits) + predicted=trace_sequence(characteristic,n,bits=bits) + if actual!=predicted:raise AssertionError('factorization trace check failed') + # Factor coefficients and true characteristic coefficients have this + # conservative l1 bound, so evaluation cannot hide coefficient errors. + candidate_bound=sum(sum(abs(c) for c in a) for a in characteristic) + actual_bound=factorial(n)*32**n + if candidate_bound+actual_bound>=radix:raise AssertionError('factor bound too large') + traces[n]=trace_sequence(characteristic,maximum,bits=bits) + pfq=perron_quotient(rows) + pfname={5:'closed_2',15:'open_5',16:'shared_4a'}[n] + pfco=definition['factors'][pfname]['coefficients_desc_x_ascending_t'] + if direct_matrix_traces(pfq['rows'],len(pfq['rows']),bits)!=trace_sequence(pfco,len(pfq['rows']),bits=bits): + raise AssertionError('Perron quotient characteristic mismatch') + pfq['factor_name']=pfname + blocks[size_text]=dict(state_indices=entry['quotient_state_indices'],rows=rows,perron_quotient=pfq, + characteristic_coefficients_desc_x_ascending_t=characteristic, + direct_trace_checks=n,irreducible_and_aperiodic_for_positive_t=True) + v=[0]*dimension + for mask,j in enumerate(q['initial']):v[j]+=1<<(bits*mask.bit_count()) + small=[] + for m in range(1,maximum+1): + p0=sum(vv for vv,r in zip(v,q['output']) if r==0) + p2=sum(vv for vv,r in zip(v,q['output']) if r==2) + monomial=2<<(2*m*bits) + if p0!=traces[5][m]-traces[16][m]+monomial:raise AssertionError(('P0',m)) + if p2!=traces[15][m]-traces[16][m]+monomial:raise AssertionError(('P2',m)) + if m<=6: + small.append({'length':m,'rank0_coefficients':[(p0>>(bits*k))&(radix-1) for k in range(4*m+1)], + 'rank2_coefficients':[(p2>>(bits*k))&(radix-1) for k in range(4*m+1)]}) + if m=radix:raise AssertionError('resultant coefficient bound too large') + minimality=[] + # Characteristic factors give upper bounds. These exact minors give matching + # lower bounds, using the physical tail beginning at m=2, never a tolerance. + for t,channel,order in [(1,'M',15),(2,'M',14),(3,'M',16),(3,'P0',17),(3,'P2',23)]: + seq=scalar_sequences(q,2*order+1,t)[{'P0':0,'P2':1,'M':2}[channel]] + det=bareiss([[seq[1+i+j] for j in range(order)] for i in range(order)]) + if det==0:raise AssertionError(('zero Hankel minor',t,channel,order)) + minimality.append(dict(fugacity=t,probability=str(Fraction(t,1+t)),channel=channel, + minimum_scalar_order=order,hankel_start_length=2,determinant=str(det))) + generic_factors=[definition['factors'][name]['coefficients_desc_x_ascending_t'] + for name in factor_weights(definition,'M')] + rec=[[1]] + for f in generic_factors:rec=x_poly_product(rec,f) + if len(rec)-1!=16 or not squarefree([polynomial_value(c,3) for c in rec]): + raise AssertionError('generic squarefree recurrence proof failed') + return {'schema':'matching-one.width4-parametric-traces.v1','source_head':definition['source_head'], + 'source_blob':blob,'weighted_quotient':q,'blocks':blocks, + 'identities':{'P0':'tr(B5^m)-tr(B16^m)+2*t^(2m)', + 'P2':'tr(B15^m)-tr(B16^m)+2*t^(2m)', + 'M':'tr(B15^m)-tr(B5^m)'}, + 'normalization':'divide by (1+t)^(4*m); t=p/(1-p); endpoints by continuity', + 'trace_factor_weights':{ch:factor_weights(definition,ch) for ch in ('P0','P2','M')}, + 'certificate':{'common_weighted_lumping_counts':q['counts'], + 'all_509_rows_checked':True,'zero_polynomials_checked_each':maximum, + 'P0_sufficient_moments':dimension+5+16+1,'P2_sufficient_moments':maximum, + 'radix_bits':bits,'difference_coefficient_bound':'34*16^m < radix', + 'method':'exact Kronecker evaluation with proved coefficient bound, then finite-dimensional Cayley-Hamilton', + 'small_block_raw_matrix_trace_checks':36,'resultant_sylvester_identity':True}, + 'generic_minimum_orders':{'P0':17,'P2':23,'M':16},'minimality':minimality, + 'generic_M_recurrence_coefficients_desc_x_ascending_t':rec, + 'generic_recurrence_squarefree_over_Q_t':True,'small_integer_sector_polynomials':small, + 'seconds':time.perf_counter()-started, + 'limits':['width four only, physical m>=2','small-block traces are NOT individual probabilities', + 'generic rank is not uniform at exceptional parameters','not a continuum operator identification or all-width pTL intertwiner']} + + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--source',type=Path,default=SOURCE) + ap.add_argument('--definition',type=Path,default=DEFINITION);ap.add_argument('--out',type=Path) + args=ap.parse_args();report=verify(args.source,args.definition) + text=json.dumps(report,indent=2,allow_nan=False)+'\n' + if args.out: + args.out.parent.mkdir(parents=True,exist_ok=True) + with args.out.open('x',encoding='utf-8') as f:f.write(text) + else:print(text,end='') +if __name__=='__main__':main() diff --git a/tests/test_two_cycle_core_onsets.py b/tests/test_two_cycle_core_onsets.py new file mode 100644 index 00000000..1f7569f9 --- /dev/null +++ b/tests/test_two_cycle_core_onsets.py @@ -0,0 +1,38 @@ +"""Checks of the geometric equality classes, not substitutes for the proof.""" +from pathlib import Path +import sys +import unittest +ROOT=Path(__file__).resolve().parents[1] +sys.path.insert(0,str(ROOT/'scripts')) +import rank_two_onset as o + +class TwoCycleCoreTests(unittest.TestCase): + def test_existing_small_diamond_exhaustive_classification(self): + for L in (2,3): + result=o.check_small(L,True) + self.assertEqual(result['rank2_below_onset'],0) + self.assertEqual(result['minimizers'],4*L*L) + + def test_axis_equality_is_a_cross(self): + for L in (2,3,4): + result=o.check_small(L,False) + self.assertEqual(result['rank2_below_onset'],0) + self.assertEqual(result['minimizers'],L*L) + + def test_all_constructed_larger_minimizers_are_rank_two(self): + for L in range(2,9): + for diamond in (False,True): + sets=o.predicted_minimizers(L,diamond);adj=o.geometry(L,diamond)[3] + self.assertEqual(len(sets),4*L*L if diamond else L*L) + for mask in sets: + self.assertEqual(mask.bit_count(),3*L-1 if diamond else 2*L-1) + self.assertEqual(o.rank(mask,adj),2) + + def test_diamond_periods_are_the_named_geometry(self): + for L in (2,3,5): + _,_,canonical,_=o.geometry(L,True) + for x,y in ((0,0),(1,2),(-3,7)): + self.assertEqual(canonical(x,y),canonical(x+L,y+L)) + self.assertEqual(canonical(x,y),canonical(x+L,y-L)) + +if __name__=='__main__':unittest.main() diff --git a/tests/test_width4_cylinder_certificate.py b/tests/test_width4_cylinder_certificate.py new file mode 100644 index 00000000..b9af9315 --- /dev/null +++ b/tests/test_width4_cylinder_certificate.py @@ -0,0 +1,19 @@ +"""The crossing comparison and all-length sign use rational bounds.""" +from pathlib import Path +from fractions import Fraction +import sys +import unittest +ROOT=Path(__file__).resolve().parents[1] +sys.path.insert(0,str(ROOT/'scripts')) +import width4_cylinder_certificate as c + +class CylinderCertificateTests(unittest.TestCase): + def test_exact_intervals_and_all_m_sign(self): + d=c.certificate() + self.assertTrue(d['one_positive_root_Descartes']) + self.assertGreater(Fraction(d['hprime_p_interval'][0]),0) + self.assertLess(16*Fraction(d['relative_remainder_ratio_upper'])**6,2) + self.assertEqual([r['m'] for r in d['all_m_root_sign']['m2_to_5']],[2,3,4,5]) + self.assertTrue(d['matches_Jacobsen_2015_table2_n4_within_1e_minus40']) + +if __name__=='__main__':unittest.main() diff --git a/tests/test_width4_parametric_traces.py b/tests/test_width4_parametric_traces.py new file mode 100644 index 00000000..2e9def1b --- /dev/null +++ b/tests/test_width4_parametric_traces.py @@ -0,0 +1,64 @@ +"""Mathematical controls: all-p identity, specialization and physical counts.""" +from fractions import Fraction +import json +from pathlib import Path +import sys +import unittest +ROOT=Path(__file__).resolve().parents[1] +sys.path.insert(0,str(ROOT/'scripts')) +import width4_parametric_traces as s +from rank_two_onset import rank + +class ParametricTraceTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + source=s.SOURCE + if not source.exists():source=ROOT.parent/'source_inputs/width4-rank-closure-certificate.json' + cls.data=s.verify(source) + cls.definition=json.loads(s.DEFINITION.read_text()) + + def test_every_parameter_polynomial_is_certified(self): + c=self.data['certificate'] + self.assertEqual(c['zero_polynomials_checked_each'],126) + self.assertTrue(c['resultant_sylvester_identity']) + self.assertEqual(self.data['weighted_quotient']['counts'],[3,35,94,94]) + + def test_independent_lift_census_at_rectangular_controls(self): + for m in (2,3): + adj=[] + for y in range(m): + for x in range(4): + adj.append([(((y+dy)%m)*4+(x+dx)%4,dx,dy) + for dx,dy in ((1,0),(-1,0),(0,1),(0,-1))]) + counts=[[0]*(4*m+1) for _ in range(3)] + for mask in range(1<<(4*m)):counts[rank(mask,adj)][mask.bit_count()]+=1 + row=self.data['small_integer_sector_polynomials'][m-1] + self.assertEqual(counts[0],row['rank0_coefficients']) + self.assertEqual(counts[2],row['rank2_coefficients']) + + def test_exceptional_parameter_is_not_generic_order(self): + orders={(r['probability'],r['channel']):r['minimum_scalar_order'] for r in self.data['minimality']} + self.assertEqual(orders['1/2','M'],15) + self.assertEqual(orders['2/3','M'],14) + self.assertEqual(orders['3/4','M'],16) + f=self.definition['factors'] + def at(name,t):return [s.polynomial_value(c,t) for c in f[name]['coefficients_desc_x_ascending_t']] + self.assertEqual(at('closed_b',2),at('negative_square',2)) + self.assertEqual(at('closed_b',1),[1,0]) + + def test_shared_modes_cancel_only_in_the_difference(self): + weights=self.data['trace_factor_weights'] + for name in ('shared_3','shared_4a','shared_4b'): + self.assertEqual(weights['P0'][name],weights['P2'][name]) + self.assertNotIn(name,weights['M']) + self.assertEqual(self.data['generic_minimum_orders'],{'P0':17,'P2':23,'M':16}) + + def test_diagonal_thermal_derivative_has_a_length_factor(self): + # Exact coefficient of e in two diagonal eigenvalue powers. + from math import comb + lam=Fraction(3,5) + for m in range(1,21): + coefficient=comb(m,1)*lam**(m-1)-comb(m,1)*lam**(m-1)*(-1) + self.assertEqual(coefficient,2*m*lam**(m-1)) + +if __name__=='__main__':unittest.main()