From 525c8e98d99c44d4c76280a1f0f83064df9bfa72 Mon Sep 17 00:00:00 2001 From: LightChainr <172050935+LightChainr@users.noreply.github.com> Date: Sat, 12 Sep 2026 23:28:10 +0800 Subject: [PATCH] Width-four site sources and exact rank conditioning (do not merge) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Additive on #708's finite automaton; no dependence on unmerged #710 or #716. Requires PR708's results/research-control-20260912/width4-rank-closure-certificate.json (blob 50b7297), which is not duplicated here. - Seven D4 column-partition lumpings classified exactly; the common strong lumpings have 94/303/179/262/509/303/509 states and each equals the colour-preserving D4 orbit partition blockwise. - Square-site two-row dipole source: zero linear response, nonzero mixed response; exact rational sign certificates for the mixed shifts of the finite root. Four-sign extraction of M is exact at finite amplitudes. - Exact integer backward sampler conditioning on any final rank; the complete nonuniform 4x3 conditional law is verified configurationwise. - Withdraws #717 §2.3's categorical distinction; see the finite critical polynomial dictionary note for the periodic-lift/site-weight dictionary. Standard library only. 14 local tests pass on this tree (6+4+4); the full repository CI suite was not executed. No publication-readiness claim. --- ...critical-polynomial-dictionary-20260912.md | 136 + notes/site-source-handoff-20260912.md | 66 + notes/site-source-primary-audit-20260912.md | 42 + notes/site-source-review-20260912-zh.md | 83 + ...width4-exact-rank-conditioning-20260912.md | 126 + ...dth4-local-site-source-closure-20260912.md | 164 + .../width4-conditioned-rank-controls.json | 1172 ++ ...width4-site-source-independent-checks.json | 46 + .../width4-site-source-physical-checks.json | 335 + .../width4-site-source-quotients.json | 10480 ++++++++++++++++ scripts/site_source_graph_checks.py | 201 + scripts/verify_width4_site_sources.py | 94 + scripts/width4_conditioned_rank.py | 261 + scripts/width4_site_sources.py | 315 + tests/test_site_source_graph_checks.py | 45 + tests/test_width4_conditioned_rank.py | 61 + tests/test_width4_site_sources.py | 64 + 17 files changed, 13691 insertions(+) create mode 100644 notes/finite-critical-polynomial-dictionary-20260912.md create mode 100644 notes/site-source-handoff-20260912.md create mode 100644 notes/site-source-primary-audit-20260912.md create mode 100644 notes/site-source-review-20260912-zh.md create mode 100644 notes/width4-exact-rank-conditioning-20260912.md create mode 100644 notes/width4-local-site-source-closure-20260912.md create mode 100644 results/research-control-20260912/width4-conditioned-rank-controls.json create mode 100644 results/research-control-20260912/width4-site-source-independent-checks.json create mode 100644 results/research-control-20260912/width4-site-source-physical-checks.json create mode 100644 results/research-control-20260912/width4-site-source-quotients.json create mode 100644 scripts/site_source_graph_checks.py create mode 100644 scripts/verify_width4_site_sources.py create mode 100644 scripts/width4_conditioned_rank.py create mode 100644 scripts/width4_site_sources.py create mode 100644 tests/test_site_source_graph_checks.py create mode 100644 tests/test_width4_conditioned_rank.py create mode 100644 tests/test_width4_site_sources.py diff --git a/notes/finite-critical-polynomial-dictionary-20260912.md b/notes/finite-critical-polynomial-dictionary-20260912.md new file mode 100644 index 00000000..bfd3689f --- /dev/null +++ b/notes/finite-critical-polynomial-dictionary-20260912.md @@ -0,0 +1,136 @@ +# Finite critical-polynomial events are the rank sectors, not a different observer + +2026-09-12. Review of #717 at c2f58b6756b0f9103c4b292dca3f045f497abd32. +This note corrects a literature/object dictionary. The identification is not +claimed as new. It does not identify full transfer representations or establish +an all-width leading-weight theorem. + +## 1. What the primary texts actually support + +Mertens--Ziff, arXiv:1603.07289v2, introduction following Eq. (4), explicitly +connect the finite cross-wrapping difference to the critical polynomial of +Scullard--Jacobsen. Section II, Eqs. (12), (20), (21) and the text following +(21), identifies R^c-R^0 with that matching difference. Therefore #717 §2.3's +categorical statement that 2D/0D are not the matching P2/P0 is incorrect for +this matched finite site ensemble and embedding. Different names do not +establish different events. One must first compare the configurations and +weights. + +Scullard--Jacobsen, arXiv:1209.1451v1, §2.1 defines the periodic-extension +classification; §3.3 gives an intrinsic torus-loop test. That test puts a +configuration with a noncontractible surrounding loop in 1D. Thus a spiral +with one nonzero primitive winding vector is not a rank-two cross simply +because both coordinate projections are nonzero. + +Jacobsen, arXiv:1507.03027v1, §2 Eq. (4) and §6.1 Eq. (32) distinguish the +finite topological partition sum from the local square-site realization. +The generic FK edge-subset sum at q != 1 must not be silently substituted for +a site-subset sum. The correct site local weights are part of the dictionary. +The 2012 text also explicitly permits site problems through suitable local +connectivity weights/correlations. The normalized local two-choice operator +in the 2015 square-site convention is + + R_i(p_i) = (1-p_i) E_(i+2) E_i + p_i E_(i+1). + +This gives the right local Bernoulli weights; by itself it does not verify a +particular implementation's staggering, torus closure, or source/readout map. + +A second wording correction: the intermediate value argument in Jacobsen §4 +is not by itself a uniqueness proof. Immediately before Eq. (13), existence +of a positive unique finite zero is described as observed. Keep actual +monotonicity proofs separate. No universal cylinder uniqueness theorem is +inferred from the intermediate value theorem in this note. + +## 2. Configuration-level dictionary with the needed topology + +Let a finite embedded square-site NN occupied graph G live on an honest +oriented torus, with periodic lift to the plane. For a connected component C, +let L_C <= Z^2 be the gain subgroup of its closed walks, expressed in the +period basis. Covering path lifting gives: + +* connected components of the lift of C correspond to cosets of L_C; +* the deck-translation stabilizer of a chosen lifted component is L_C; +* its growth direction rank is rank L_C. + +These follow by comparing two root-to-root lifts: their endpoints differ by +precisely the gain of a closed walk. No large repeated-box simulation is needed. + +For embedded graph components on a torus, the nonzero image is saturated. +At rank one, a nonzero closed walk decomposes into simple cycles. A nontrivial +embedded simple torus cycle has primitive class, so the common rank-one image +contains its primitive generator. At rank two, a regular neighborhood of C +cannot have genus zero: a genus-zero neighborhood's H1 is generated by disjoint +boundary circles, an isotropic family of torus classes of rank at most one. +A genus-one neighborhood contains two curves meeting once. Their ambient +intersection is one, so their classes form an integral basis of H1(T^2). +Thus L_C=Z^2 at rank two, not a proper finite-index subgroup. + +Different graph components are disjoint. Their ambient classes have zero +intersection. Hence independent rank-one classes cannot be carried by separate +components; if total rank is two, one component itself has rank two and every +other component has trivial ambient image. + +Consequently: + + 0D <=> every occupied component has zero ambient image <=> r=0; + 1D <=> a primitive one-direction family (including spiral) <=> r=1; + 2D <=> a rank-two cross component <=> r=2. + +The finite 4x4 word [3,6,12,9] is a useful tripwire: its winding generators are +(+1,+1) and (-1,-1), so it is 1D, not 2D. + +The source theorem is for embedded NN primary graphs. Applying the argument +blindly to diagonals drawn as crossing abstract edges in the matching graph +is not justified; its complementary digital neighborhood is a separate map. + +## 3. Weights and normalizer, including arbitrary local site sources + +For independent site probabilities p_v, let t_v=p_v/(1-p_v) in the interior. +Define the site event polynomial (q=1, not an unspecified q-extension) + + C_B(t) = sum_omega [1_(2D)(omega)-1_(0D)(omega)] product_(v in omega) t_v. + +Then the exact finite identity is + + C_B(t) / product_v(1+t_v) + = P_2(p)-P_0(p) = E_p[r-1] = M_B(p). + +This is a polynomial identity after denominators are cleared, so endpoint +values follow by continuity. It holds for arbitrary finite sizes and local +probabilities in the stated embedded site ensemble, not merely at a root or +in a cylinder limit. A different lattice cell convention may add a common +nonzero normalizing factor; that factor must be recorded, not suppressed. + +Because equality holds for the full multivariate polynomial, all specified +local-source and thermal derivatives agree after the same normalization. +Uniform-p derivatives include the partition-normalizer derivative. The identity +at q=1 does not determine a generic-Potts-q derivative: q-continuations remain +additional structure. Likewise it does not fix #275's homology-marked, +restricted-trace moving-root U from the unmarked scalar M. + +## 4. What remains genuinely new work in #708/#710 + +The finite event identity is literature-backed and should not be sold as an +unpublished bridge. The small B5/B15/B16 matrices, exact factor cancellations, +full-p visible-order certificates and explicit finite-length root remainder +are different deliverables. Equality of one scalar partition sum does not +make their matrices similar to the augmented pTL matrices. It does not give +an all-width equality of leading closure coefficients, an all-width spectral +remainder, or a fixed-aspect correction exponent. + +The new source work in this package uses PR708's source-safe deterministic +rank states rather than assuming its smaller homogeneous strong lumping +remains valid under local occupation fields. + +## Sources read in this continuation + +All three are PRIMARY_TEXT_READ at the stated sections in HTML. No PDF or +figure was needed for the claims here. Equation labels refer to the rendered +HTML and should be checked when citing a publisher/PDF version. + +* https://arxiv.org/html/1603.07289v2 — introduction, §II, Eqs. (12),(20),(21). +* https://arxiv.org/html/1209.1451v1 — §2.1 and §3.3, local-site discussion §3.2. +* https://arxiv.org/html/1507.03027v1 — §§2--4 and §6.1. + +No broad novelty search was performed. A missing formula in the texts read is +not a statement that no prior formula exists. diff --git a/notes/site-source-handoff-20260912.md b/notes/site-source-handoff-20260912.md new file mode 100644 index 00000000..4408fbad --- /dev/null +++ b/notes/site-source-handoff-20260912.md @@ -0,0 +1,66 @@ +# Completed work and corrections for the existing issue channels + +2026-09-12. Prepared handoff; not yet posted to GitHub. No duplicate issue, +new production, hardware allocation, merge, or STATUS promotion is requested. + +## #711 / #717: dictionary correction, not another bibliography search + +Withdraw #717 §2.3's categorical distinction between critical-polynomial 2D/0D +and the same finite site ensemble's rank2/rank0. Read Mertens--Ziff 2016, +arXiv:1603.07289v2 introduction and §II Eqs. (12),(20),(21) with the following +paragraph. The finite event identity is already explicitly connected there. +Use `notes/finite-critical-polynomial-dictionary-20260912.md` for the exact +periodic-lift and site-weight dictionary, including the rank-one spiral trap. +Preserve the distinct correct boundary: no all-width B5/B15/B16 matrix +intertwiner or closure-weight theorem follows. Also do not attribute uniqueness +to the intermediate value theorem alone. + +The remaining literature task should compare actual local site weights, +embedding, topological closure and scalar spectral decompositions, not just +whether the papers use identical names. Missing small-block formulas in a +bounded reading are not proof of novelty. + +## #636: source compatibility and rare-sector conditioning delivered + +On the existing PR708 finite automaton, all seven D4 types of column-probability +groupings are now classified exactly. Common strong lumpings have 94/303/179/ +262/509/303/509 states, respectively; every one equals the corresponding +colour-preserving D4 orbit partition blockwise. Two independently addressed +adjacent columns already require all 509 deterministic rank classes within +this lumping class. No further width-four state enumeration is needed. + +A genuine square-site two-row dipole source has zero linear response but +nonzero mixed response. The 4x4 coefficients are 327/1024 and 633/2048 at +p=1/2; the finite root's mixed shifts have strict rational sign certificates. +Four-sign extraction of M is exact at finite amplitudes, by separate degree<=2 +multiaffinity. This does not inherit P398's continuous-time response formula. + +An exact integer backward sampler conditions on any final rank. The complete +nonuniform 4x3 conditional law is verified configurationwise; the 4x128 rare +case has exact normalizers and fixed-seed algorithm controls. Do not commission +billions of direct snapshots merely to see rare sectors that this oracle can +condition on. Conversely do not claim the fixed-width oracle scales cheaply +to large circumference. + +Files are additive on PR708, no dependence on unmerged #710 or #716. +All-width structural closure weights and width-uniform spectral estimates +remain different, uncompleted questions. This deliverable does not authorize +a next-width scan or a new transfer engine. + +## #275 / #337: what this does and does not supply + +The full multivariate rank event polynomial fixes occupation-source derivatives +with the correct physical normalizer. It does not fix a generic-q continuation, +a homology-line-marked source, or the candidate-specific restricted-trace and +moving-root original-U map. Do not use the extra site sources as a post-hoc +rescue of a frozen candidate or claim continuum identification from a nonzero +mixed finite response. The source-safe exact oracle can verify a specified +future forward map once that map is actually supplied. + +## Verification boundary + +The completed archive includes proofs, executable standard-library-only code, +full labels/actions, rational source/root certificates, exact conditioned path +probabilities, and a minimal-workspace patch application/reproduction check. +The repository's complete CI suite was NOT executed for these new files. +Past successful CI on #708/#710 is not a substitute. diff --git a/notes/site-source-primary-audit-20260912.md b/notes/site-source-primary-audit-20260912.md new file mode 100644 index 00000000..0b454a1a --- /dev/null +++ b/notes/site-source-primary-audit-20260912.md @@ -0,0 +1,42 @@ +# Primary-source sections actually read + +2026-09-12. This is a bounded verification log, not a broad novelty review. +No new paper is labelled read in full when only the listed sections were used. + +1. Mertens--Ziff, *Percolation in Finite Matching Lattices*, PRE 94 (2016) + 062152, arXiv:1603.07289v2. PRIMARY SECTIONS READ: introduction and §II, + especially introduction following (4), (12), (20), (21) and its following + paragraph. Supplies the explicit finite matching/critical-polynomial + relationship. https://arxiv.org/html/1603.07289v2 +2. Scullard--Jacobsen, *Transfer matrix computation of generalised critical + polynomials in percolation*, J. Phys. A 45 (2012) 494004, + arXiv:1209.1451v1. PRIMARY SECTIONS READ: §2.1, site local-weight examples, + §3.3. Defines 0D/1D/2D and the noncontractible surrounding-loop criterion. + https://arxiv.org/html/1209.1451v1 +3. Jacobsen, *Critical points of Potts and O(N) models from eigenvalue + identities in periodic Temperley-Lieb algebras*, J. Phys. A 48 (2015) + 454003, arXiv:1507.03027v1. PRIMARY SECTIONS READ: §§2--4 and §6.1. + Separates the finite partition object, augmented annular state information, + cylinder asymptotics and the two-term square-site R operator. + https://arxiv.org/html/1507.03027v1 +4. Corstanje--van der Meulen--Schauer, *Conditioning continuous-time Markov + processes by guiding*, arXiv:2111.11377v2. PRIMARY SECTIONS READ: introduction + and §2, especially Definition 2.3 and Example 2.4. Background attribution + for h-transform conditioning; the discrete integer recursion here is proved + directly rather than imported from a continuous-time generator formula. + https://arxiv.org/html/2111.11377v2 + +The latest #717 note was read through the authenticated GitHub connector at +head c2f58b6756b0f9103c4b292dca3f045f497abd32. Its broad non-equivalence statement +is contradicted by source 1; its caution about nonidentical matrix presentations +remains appropriate. + +PR708 certificate metadata was fetched at +f782061c1a592ed2f9fd0e9dabaa45f0e54bc4e7. Local mounted bytes match the fetched +Git blob 50b7297deefe7c50215aea2ed534ca5810461af3. The code refuses other bytes. +Only the certificate is reused; no uncommitted new-analysis script is imported. + +No PDF was analyzed, no quotation was invented, and no table/figure not read +was used as evidence. A failed optional publisher h-transform fetch was not +relied on; the arXiv primary §2 was available. The new finite proofs and +computed certificates have not undergone an independent external review. diff --git a/notes/site-source-review-20260912-zh.md b/notes/site-source-review-20260912-zh.md new file mode 100644 index 00000000..b5c13522 --- /dev/null +++ b/notes/site-source-review-20260912-zh.md @@ -0,0 +1,83 @@ +# 本轮推进：有限事件字典、真实点渗流的局部源，以及稀有扇区条件采样 + +2026-09-12。复核最新 #717，直接消费 #708 的不可变状态证书。本轮不修改远端，不合并 PR，不覆盖旧生产，不增加大规模检索或算力任务。 + +## 1. 先纠正一个影响研究方向的文献判断 + +#717 §2.3 将 2D/0D 与 Matching One 的 rank 2/0 判断为不同事件，这不成立。Mertens–Ziff 2016 的引言及 Eq. (21) 前后已经将有限 cross/no-wrap 差值联系到 Scullard–Jacobsen 的 critical polynomial。我们补写了配置级周期提升字典，并明确了点占据的局部权重和物理配分函数。 + +对同一嵌入、同一 site ensemble，有限恒等式为 + + C_B({t_v}) / ∏_v(1+t_v) = P_2({p_v})-P_0({p_v}) = M_B({p_v}). + +它不只在根处成立，也不需要先取圆柱极限。rank-one spiral 属于 1D，不能因为两个绕行投影均非零而误判成 2D。4×4 的 [3,6,12,9] 是具体校验。 + +这一事件恒等式不是新颖性主张；它也不使两个转移矩阵自动相似，不给出全部宽度的领先闭合权重，更不确定 q≠1 的 Potts 延拓或 original-U 的 thermal jet。另须撤回“中值定理本身证明唯一性”的过强文献归纳。 + +## 2. 新完成：局部占据源要求什么状态 + +在 #708 的 509 个确定性 rank 续接类上，对每种列概率分组，要求同一压缩对各组概率的整个开集有效，且每行可独立改变这些概率。逐多项式系数的强合并给出： + +| 独立概率分组 | 最终类数 | +|---|---:| +| 四列同概率 | 94 | +| 一列单独、其余三列同概率 | 303 | +| 两组相对列 | 179 | +| 两组相邻列 | 262 | +| 两相邻列分别标记、其余两列同概率 | 509 | +| 两相对列分别标记、其余两列同概率 | 303 | +| 四列独立 | 509 | + +四个列标签的 15 种集合划分在 D4 下恰为这七型，没有按有利结果挑分组。七个最终分区均与各自概率分组稳定子群的轨道分区逐类相等。这里是给定有限状态表示的共同强合并最小值，不是所有正实现或任意非线性状态的最小维数。 + +一个简单反例足以说明 94 类的限制：历史 [1,1] 和 [2,2] 具有相同占据数、即时 rank，也在同一个均匀概率类内。下一行概率设为 (q,p,p,p)，两者最终 rank 期望之差恰为 q-p。因此均匀概率下正确的压缩，不能不经检查就运输到局部 source。 + +## 3. 新完成：方格点渗流中的分离双源响应 + +在空间行 y，仅将列 0、2 的占据概率改成 p+ε_y、p−ε_y，另外两列仍为 p。反射使 ε_y 改号，故原 rank 读出 M 的单源一阶响应严格为零。 + +两个不同空间行 a,b 的混合响应 χ_ab 却非零。4×4、p=1/2： + + χ_12 = 327/1024，χ_13 = 633/2048。 + +这已经是真实 site-percolation 的源响应，不是 P398 校准过程。把奇源先压到 94 维不变子空间会使该源算子为零，错误地丢掉两个插入之间的非平凡分量。该投影零式也已按整数矩阵块和直接验证。 + +而且没有必要将 ε 外推到零：每个源只改动同一行的两个独立 Bernoulli 站点，M 对各 ε 的次数至多二。因此 + + [M(h,k)−M(h,−k)−M(−h,k)+M(−h,−k)]/(4hk)=χ_ab + +在任意非零、合法的有限幅度下精确成立。该恒等式针对 M，不针对非线性的根，也不等于没有抽样方差。 + +4×4 的未扰动有限根约为 0.5906721123310283。在有理数根区间上严格证明 χ>0、M_p>0，故根的混合源导数为 −χ/M_p。相邻行约 −0.0577415189712485，间隔一行约 −0.0549132944707030。它们是有限系统根的 mixed coefficients，不是无限体临界点位移。 + +## 4. 新完成：不用等待稀有事件自然出现的条件采样器 + +利用确定性 rank 状态，完成了整数后向递推 h_y(s)，可直接从最终 rank 固定为 0、1 或 2 的原始站点乘积测度中抽样。每一步用合法的非负整数权重 W_y(b)h_(y+1)(τ(s,b)) 选下一行；路径概率中的 h 因子望远镜消去，恰得原始配置权重除以指定 rank 的正规化常数。 + +这是一种标准有限时域 Doob 型条件化的具体实现，不是新的一般采样理论。不需要整张配置的拒绝重试、不需要 burn-in、不用浮点采样权重。代价是必须先计算精确后向常数，且复杂度仍依赖状态数和大整数位长，不能宣称大宽度问题已解决。 + +在 p=591417/1000000、4×128 上： + +| rank | 概率 | 条件占据点数均值 | +|---|---:|---:| +| 0 | 4.2444165285438005×10^-10 | 265.21829715618895 | +| 2 | 4.2441877885758733×10^-10 | 341.4414449341080 | + +这些概率和条件矩由整数前后向计算得出，不是从八条验证轨迹估出来的。每个 rank 的四条固定种子轨迹均经独立物理提升图重判；完整配置已保存。它们仅是算法控制，不构成新的渗流证据。 + +同时实现了正规化与热导数之间的精确关系： + + ∂_p log(P_2/P_0)=[E(K|r=2)−E(K|r=0)]/[p(1−p)]。 + +本控制值约为 315.4371084311523。K 是总占据数，不是 birth time。非均匀源必须使用对应的逐点条件指标，不能照搬均匀 K 公式。 + +## 5. 验证范围 + +- 69,888 个物理 NN 配置逐项核对状态表、分量同调饱和性、全部占据数系数和两源多项式。 +- 65,152 条 D4/转移共轭关系；各概率分组的共同强合并均闭合。 +- 不调用系数细化器的独立有理数网格验证，共 71 个多维参数点、36,139 条完整状态概率行。网格次数充分，因此验证的是整个多项式族，不是随机参数吻合。 +- 非均匀 4×3 的全部 4,096 配置：12,288 个条件路径概率等式及条件占据一、二阶矩全通过。 +- 4×128 稀有控制的前后向正规化常数一致；八条条件轨迹通过独立物理 rank 检查。 +- 本地测试和补丁应用／重生成记录在归档根目录 VALIDATION.json；未运行完整仓库 CI。 + +本包仅依赖 #708 的状态 JSON；不依赖 #710、#716 或上一轮尚未确认提交的 root/TL 包。没有重新实现更大宽度引擎，没有新生产或 GPU 任务。可将已完成事项记到既有 #636/#711；#275 的候选专用 original-U 前向映射仍未由这些不带标记的 rank 响应自动提供。 diff --git a/notes/width4-exact-rank-conditioning-20260912.md b/notes/width4-exact-rank-conditioning-20260912.md new file mode 100644 index 00000000..27300db8 --- /dev/null +++ b/notes/width4-exact-rank-conditioning-20260912.md @@ -0,0 +1,126 @@ +# Rejection-free rank-conditioned configurations from exact backward messages + +2026-09-12. A concrete sampler and conditional score on the certified width-four +rank automaton. This is the standard finite-horizon conditional change of +measure, specialized and verified here; not a new general Doob-transform theorem. +The implementation uses the source-safe 509 states, not a homogeneous quotient +for an inhomogeneous input. + +## 1. Integer weights and the backward recursion + +For each site use a rational p_(y,j)=a_(y,j)/d_(y,j). A row-mask weight can be +written w_y(b)=W_y(b)/D_y, where + + W_y(b)=product_j [a_(y,j) if b_j=1 else d_(y,j)-a_(y,j)], + D_y=product_j d_(y,j). + +Let c_r(s)=1{close_rank(s)=r} be the final rank event. Define h_m=c_r and, +for y=m-1,...,1, + + h_y(s)=sum_b W_y(b) h_(y+1)(tau(s,b)). + +The exact unnormalized rank probability is + + Z_r=sum_b W_0(b) h_1(initial(b)), + P_r=Z_r/product_y D_y. + +If Z_r=0 the conditioning is impossible and the program raises an error. Zeros +at individual states are not inverted; the sampler can only reach states +with positive conditional mass. + +The first row is drawn with integer weights W_0(b)h_1(initial(b)). After that, +at a state s before row y, the next mask is drawn with integer weights +W_y(b)h_(y+1)(tau(s,b)). Exact uniform integer selection avoids rounded +transition probabilities, even when P_r is tiny. + +Multiplying these conditional probabilities along a completed word makes all +h factors telescope, giving + + product_y W_y(b_y) / Z_r if the final rank is r, + zero otherwise. + +That is exactly the original site product measure conditioned on rank r. +The construction neither repeats percolation configurations until one passes +nor uses burn-in, an asymptotic cylinder eigenvector, or an approximate tilt. +It does require the exact backward normalizers. Their construction is the +nontrivial resource, not free conditional information. + +The state count is fixed at 509 here. The elementary arithmetic operation +count is O(509*16*m) for a backward table and O(16*m) integer sampling decisions +per word. Integer bit lengths grow with m and the denominators. These are NOT +unit-cost timing bounds or complexity claims as circumference increases. + +## 2. Conditional occupation moments and a thermal likelihood score + +Let K be the total occupied site count (not a rank-birth time). A second forward +pass propagates the exact weight, K-weight and K^2-weight by + + (z,z1,z2) -> W_b*(z, z1+kz, z2+2kz1+k^2z). + +Summing by final rank yields exact conditional means and variances. +For homogeneous interior p, direct differentiation of the product measure gives + + d_p log P_r = [E(K | r)-Np]/[p(1-p)], + d_p log(P_2/P_0) = [E(K|r=2)-E(K|r=0)]/[p(1-p)]. + +This is also an exact normalizer/thermal-jet map. It does not estimate a ratio +from an unobserved rare denominator. The rank-2 event is increasing and rank-0 +event decreasing, so their conditional mean difference is strictly positive +in the nondegenerate interior setting; the finite polynomial check confirms it. +For general inhomogeneous fields the corresponding per-site conditional score +is obtained from its own occupied indicator, not from a homogeneous K formula. + +## 3. Executed controls, not a new probability production + +On a nonuniform 4x3 product measure with twelve specified rational site +probabilities, all 4,096 configurations were physically classified. Their +rank normalizers and conditional first/second K moments agree with the forward +DP. For all three target ranks, all 12,288 sequential word-probability identities +agree exactly with the product-weight conditional formula. This validates the +ENTIRE finite conditional distribution at the control size, not just empirical +frequency agreement from a few draws. + +A long control uses p=591417/1000000 and m=128, N=512. This is a rational near +q4, not the exact cylinder root and not an estimate of two-dimensional p_c. +Forward and backward integer normalizers agree: + +| target rank | exact-probability diagnostic | conditional mean K | conditional variance K | +|---|---:|---:|---:| +| 0 | 4.2444165285438005e-10 | 265.21829715618895 | 78.51788627252415 | +| 2 | 4.2441877885758733e-10 | 341.4414449341080 | 73.32447740787667 | + +Their total mass is 8.488604317119674e-10, and the thermal log-odds derivative +is 315.4371084311523. Exact rational quantities, rather than just these +floating diagnostics, are retained. The large derivative rational is stored +with hexadecimal numerator/denominator to avoid Python's decimal-conversion +size limit; this is lossless, not a numerical approximation. + +Four fixed PRNG seeds were used per rare rank as algorithm controls. Every +resulting 512-site configuration was reclassified by independent physical +lift traversal and has the required rank. Its full conditional path probability +was independently multiplied and checked against the telescoping formula. +The eight row-mask words and seeds are retained. They are NOT new evidence +about sector probabilities, covariance, or finite-size scaling. The law is +exact given uniform integer bits; seeded pseudorandom bits serve reproducibility. + +## 4. Scientific use and limits + +The prior observation that direct one-p snapshots can miss both rare sectors +remains correct. It is not an unavoidable cost of the underlying physical +question: a finite exact sufficient-state representation supports a different +conditional algorithm. This example makes that limitation concrete. + +This routine is useful as an exact oracle for testing future importance or +conditional algorithms and for generating configurations with a declared +rank. It does not solve a large-width sampling problem, lower-bound the cost +of other estimators, beat an optimized existing transfer implementation, or +justify a new production. No parameter was tuned to obtain a favourable rank +verdict. Source-safe states and normalizers are mandatory. + +Background: Corstanje--van der Meulen--Schauer, arXiv:2111.11377v2, §2, +Definitions 2.3 and Example 2.4, describes the established h-transform +conditioning principle for Markov processes. The discrete finite recursion +above is proved directly by its path probabilities; the continuous-time +paper is attribution/background, not a claim that its generator formula is +our discrete update. Primary §2 read at +https://arxiv.org/html/2111.11377v2 . No literature novelty claim is made. diff --git a/notes/width4-local-site-source-closure-20260912.md b/notes/width4-local-site-source-closure-20260912.md new file mode 100644 index 00000000..fbca85b8 --- /dev/null +++ b/notes/width4-local-site-source-closure-20260912.md @@ -0,0 +1,164 @@ +# Actual site-percolation sources expose information erased by a homogeneous quotient + +2026-09-12. Exact finite analysis on the unmodified PR708 rank automaton, +head f782061c1a592ed2f9fd0e9dabaa45f0e54bc4e7, certificate Git blob +50b7297deefe7c50215aea2ed534ca5810461af3. Unlike P398, this is the square-site +Bernoulli model itself. New source experiments are not retroactive changes to +any frozen production or to #275's candidate contract. + +## 1. A typed multivariate forward map + +Let tau(s,b) be the 509-class deterministic successor for a four-bit row b. +For independent probabilities p_(y,j) at spatial row y and column j, write + + w_y(b) = product_j p_(y,j)^b_j (1-p_(y,j))^(1-b_j), + K_y[s,t] = sum_(b:tau(s,b)=t) w_y(b). + +The initializer weights row zero exactly once; the closure has no extra site +weight. For m>=2, + + M(p) = b_0^T K_1 ... K_(m-1) c, c(s)=close_rank(s)-1. + +PR708's arbitrary deterministic future equivalence guarantees this identity +for all such fields. Its rank-specific shear quotient remains valid because +history weights are not changed when equivalent histories are combined. It +still does not retain a primitive line or local-marked output automatically. + +## 2. Exhaustive column-grouping classification at width four + +Partition the columns into groups. All columns in a group share a probability; +different groups can vary independently in an open cube, independently at +every row. For a mask b, let k_g(b) be its population in group g. The row +weights are the products p_g^k_g(1-p_g)^(|g|-k_g). These multidegree Bernstein +basis functions are linearly independent. Therefore a strong lumping works +for the whole family exactly when, for each source block and each target +block, the counts of transitions into that target agree coefficientwise for +every k-vector. + +Refining the rank-output partition by those count signatures gives the +coarsest common strong lumping of THIS finite 509-state representation. This +is a linear equalities argument, not numerical sampling over parameters. +There are 15 set partitions of four columns, with seven D4 types: + +| independently varying column groups | exact refinement | final classes | +|---|---|---:| +| {0,1,2,3} | 3,35,94,94 | 94 | +| {0};{1,2,3} | 3,81,302,303,303 | 303 | +| {0,2};{1,3} | 3,62,179,179 | 179 | +| {0,1};{2,3} | 3,90,262,262 | 262 | +| {0};{1};{2,3} | 3,146,508,509,509 | 509 | +| {0};{2};{1,3} | 3,99,303,303 | 303 | +| {0};{1};{2};{3} | 3,164,509,509 | 509 | + +Every class is reachable with a physical history of length >=2. For all seven +families, the resulting partition is EXACTLY the orbit partition of the D4 +subgroup fixing every probability group setwise, not just the same cardinality. +The script reconstructs D4 actions by relabeling physical histories and checks +all 8*509*16=65,152 transition conjugacies, all rank readouts, permutations and +group multiplication. All final labels and actions are retained in JSON. +This is a finite verified classification, not a general theorem equating +lumping with automorphism orbits at arbitrary width. + +This exposes a concrete information difference. Histories [1,1] and [2,2] +are in one 94-state homogeneous class, have equal occupation 2 and immediate +rank 1. Append one row with probabilities (q,p,p,p). Their final expected-rank +difference is EXACTLY q-p. Indeed, with the two initial singleton rows in +column i, the three-row closed rank is 1{the new mask contains i} plus +1{the new row is full}. The full-row term cancels between the two histories. +The homogeneous quotient therefore loses a local source response already +at first order for these conditional histories. + +The minima above concern common strong lumpings of the specified automaton. +They are not minimal positive realizations among all encodings, nonlinear +state dimensions, continuum fields, or sample-complexity statements. Two +independently addressed ADJACENT columns suffice to recover all 509 states; +opposite addressed columns leave a reflection. Those are distinct source +families, not a contradiction. + +## 3. A spatial two-source experiment with the original rank readout + +On a selected row y, set + + p_(y,0)=p+epsilon_y, p_(y,2)=p-epsilon_y, + p_(y,1)=p_(y,3)=p. + +This is a real site-probability perturbation, valid whenever its probabilities +lie in [0,1]. Reflection j -> 2-j exchanges the two perturbed columns and sends +epsilon_y to -epsilon_y while leaving the baseline law and r invariant. +A single-row source therefore has identically zero first derivative in M. +For two DISTINCT spatial rows a,b, write + + chi_ab(p) = d_(epsilon_a) d_(epsilon_b) M |_(0,0). + +At p=1/2 the base integer row matrix A=16K and source matrix H=16K' have +mask weights 1 and 4(b_0-b_2), respectively. The exact mixed derivative is +obtained by two H insertions, the other rows retaining A, divided by 16^m. +In operator language the first H maps invariant functions to a nontrivial +reflection sector and the second can map back. If P is D4 averaging, PHP=0; +a source law built only by projecting this H into the 94 invariant classes +would incorrectly return zero for the separated mixed response. + +For the 4x4 torus, using rows 1 and 2 or rows 1 and 3, + + chi_12(1/2) = 327/1024, + chi_13(1/2) = 633/2048. + +An independent lifted-graph census derives their entire unnormalized Bernstein +coefficient polynomials, of degree N-4. The signed configuration factor is +(r-1)(b_(a,0)-b_(a,2))(b_(b,0)-b_(b,2)); division by p^2(1-p)^2 removes the +two necessarily occupied and two necessarily empty source sites. This verifies +the source transfer calculation independently of the state transitions. + +### No small-amplitude extrapolation is necessary for M + +For distinct source rows the Bernoulli expectation is of degree at most two in +EACH epsilon: only two sites are changed per row. Thus its odd-odd part is +exactly epsilon_a epsilon_b chi_ab. For ANY nonzero admissible amplitudes h,k, + + [M(h,k)-M(h,-k)-M(-h,k)+M(-h,-k)]/(4 h k) = chi_ab(p). + +This is an exact multiaffine polynomial identity, not an O(h^2) approximation. +The code verifies it at two unequal amplitude pairs and at a second baseline +probability. A noisy estimator still has variance/amplitude tradeoffs; exact +finite-amplitude unbiasedness does not mean zero Monte Carlo noise. This is +NOT asserted for finite differences of the roots themselves. + +## 4. The finite matching root also feels the two-source response + +Let p_*(epsilon_a,epsilon_b) be the local root of M in uniform background p. +Strict positivity of M_p at the unperturbed root gives the implicit function. +Single-source root derivatives vanish there. Hence + + d_a d_b p_* |0 = - chi_ab(p_*(0,0))/M_p(p_*(0,0)). + +Independent 4x4 integer polynomials isolate the unperturbed root in a rational +90-bisection interval. Termwise outward rational bounds give M_p>0 and chi>0 +on the WHOLE interval, not merely at a decimal evaluation. Diagnostics are + + p_*(0,0) = 0.5906721123310283... + adjacent rows: chi=0.2875032870596704..., root mixed derivative=-0.0577415189712485... + separated rows: chi=0.2734211524893206..., root mixed derivative=-0.0549132944707030... + +These are finite 4x4 responses. No infinite-volume critical point or operator +identity is inferred. The source-specific diagonal second derivatives may +also contribute to a simultaneous finite perturbation; the numbers above +are the mixed coefficients only. + +Even the sign of chi is not fixed by symmetry at other geometries: at baseline +p=1/2, adjacent rows in a 4x12 torus give the exact negative coefficient +-74769655273/4398046511104, whereas row separation two gives the positive +16319187079/2199023255552. These DP-only controls are not new independent data. + +## 5. Validation and scope + +69,888 physical NN configurations across 4x2,4x3,4x4 were traversed independently +in the universal-cover displacement convention. All ranks agree with the PR708 +state table. Component saturation and rank-two-in-one-component properties +were also checked. Every per-occupation rank count is conserved exactly. +These finite checks validate the executable, not the all-width topology proof. + +The source profile table and separated mixed responses are new executed finite +analyses; no stochastic production was used to estimate them. #275's two +candidate same-source original-U predictions are still not supplied by an +unmarked-rank response calculation. Do not change that frozen contract merely +because these additional sources are analytically accessible. diff --git a/results/research-control-20260912/width4-conditioned-rank-controls.json b/results/research-control-20260912/width4-conditioned-rank-controls.json new file mode 100644 index 00000000..318567ae --- /dev/null +++ b/results/research-control-20260912/width4-conditioned-rank-controls.json @@ -0,0 +1,1172 @@ +{ + "schema": "matching-one.width4-exact-rank-bridge.v1", + "source_blob": "50b7297deefe7c50215aea2ed534ca5810461af3", + "small_inhomogeneous_probability_rows": [ + [ + "1/3", + "2/5", + "3/7", + "4/9" + ], + [ + "3/4", + "2/3", + "3/5", + "1/2" + ], + [ + "2/7", + "4/5", + "1/4", + "5/6" + ] + ], + "small_physical_configurations": 4096, + "conditional_path_equalities": 12288, + "small_sector_probabilities": [ + "5512627/11907000", + "312863/850500", + "2014291/11907000" + ], + "small_conditional_mean_occupations": [ + "28545229/5512627", + "59053979/8760164", + "33694763/4028582" + ], + "rare_control": { + "length": 128, + "sites": 512, + "p_exact": "591417/1000000", + "note": "rational near q4; not an exact balance root", + "sectors": [ + { + "rank": 0, + "probability_exact": "424441652854380027741425772138038453335587068292692179982315156275000080844417411252363609621573371780622510894515298176991543154412468714935382604330000387342225860516178121984042088735360550058280572253403293302424925167090593119838025247636804894873056950847498654530396866789339728460732399970465069242338098451905331464937235733863367577003397400247866615445405484172063913705531518829451458217385470420685651775039878327221375811778681028739070567087148563489793025749842913389133936731789142104167500488731511121755880382814635655872596042801697245097351514797589724767058497338311185410075736801955655636011421664581812186412568118609458690250702655479886376526235074388614312179532528325117534815884676234182692935373999860526049653741439872556801409135213284482266682964377630054139279230967225932878885088638931132145597609148531765160792764468664201299027849540775889493424120691764409714286556444228619202229700386629227525946208115896491349931417457511320619648633939524360705814132712610570019095050278557026922796657323516691457346700317585313023084039428829278555208850028319673533240798783935001612503065044801465154856748094989529228835376118844902587329890664493185188323658616296798329921160179807600098605774214726508230972209156071012538460750383741170348467171958303342066529476722695810770161449056798521688131952630314662884947463675655239389214852837072579509190954406676523153032554361217508633453547024700932420589535604673484947722976240793124191426067032072123035547751134713279554724777458266041675874786322163279919816538617323011713840310109962088677706287237802269133107519783978815039547588577216500099552404222975217571139628026711848872851813944090487128792658218181152207760323158711256224336489591793931669355819128941344296203829359318631132715268814255296583043601505608630832657509947454884774258946109512723771909861255398026594963798724832497835640437159194373964069258034318724822666594902029561717551795767528452956678059997316089102063138659533069739411215755989544700249138296828517651958139962976213339998999285022195181901459347543182741834105873135271435382791489627969290952449924320940190662330512623268905834621780217278739208264491247792863389955289231609172362303649863945904908000149262474259483008713434869736981200093666925273736422333300003522815345964288301432482009205181613692498409099732876266076110645905607958740875653227495740651690402887076373676877149260317524769614735544021093471914295817119805152085971141151744238628620836132949077609080353484400328287730721447588279980171359824656290641355347205875555639907095003917742476306405037411918348339805298768064451144732109343604319607358460974869574590979760331083746333845385610332104293955313603735109378638746094835951634031707837399252866781327283343230985157982586155289011859308028930037770962685591782584762656012216999538543787816256102719935059269742494900656306915512114039107946628258521482350577391796212795688792644618152812569089745685089884823934763464971192398857379537189701823214651358050192006310883289905230684137514816511/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "probability_diagnostic": 4.2444165285438005e-10, + "mean_occupation_exact": "2244737990281210423643823463092099086974700418302713692593412796102327829179123638198650789679844197482502032544678402984912940710567148997373118282265439151171300048430128021789241689703747118941827124140090689254674036023583736992803288232014286162511337166158175963586380193257571329710097111330837347944920809355005261737921157455561303463496735341713268940033057957906504224997337204297826461737488132822708180682808469072441349949123430250389999686126259366745090800124940311837349237827514405165174939648071744547442868849123915527136523304811403187729060139465191676635815703422120245603782535787865650102556582624217598482201589367364648166697117737535964635799057082803907361056690472023876385205301685171502495320058231473721136405428406680895024103154697481478768986251915609859776987089922652864006361839372148872781763466794270135479389758187071715281499194646297772832864663927143771448033793298547968053564616258586792446414845020359161929921825449334321373521192508560393619507729528705181937469991182459497433428066018488432630838748575116490755915842616114269165594310620844234737356679294709432012737970726103239815497899232616732270241813520501854110164065638470155473643850343083522595905830762081656995817086050974839074376129291946358583714910261225758183424652519277761909917060996657530264605203636553315648319202898194438608910418736311743205992635256059123889495333541844465366347959086595554816045031010578648455197613788393406418362256002737372090367385855932488632780125862519544889797874407917217055353187854693788271269935811743077075819293244409364116957615242174228283482110837414613159890445173701843727527087023264372011810654396637586414953548473116515304664638317644809868563748249829301956664940234884752004319579803181646719115545320941161830673402660702797844391010995799311544110009106460148640541841319210978253870254187317641772336723997204918205408593229161450891972649112388337831962017057535939418933460599677239635431072846364389877865696710413031024651299091103978336947221381061171839487027983148646462920444611284968739944450262339321828654116983214471297521531978775781106086493112191736277927104359935503590960359597318669542820665379206648319496157200454525000402172687545470241627615381743076409355033560036450411326713812311318050466258066809970242267589859197299899314037313367151104/8463737284910129025873516669612478404114236667502810508418662758392702425263832076546735887157436921279644387252380055811584345522828221047889182770477294227270750015095879051100075166995571619650785956799356034005934347095875745196685299831235204642875294625202602409090772670112187515177652924102244771766047045491487321953510898539759605518468666182194186964006611758197110188176453409964577582367624322053658155537754611376482423692042981736347354858390717169689208697462526658354336933490628241449406973104628342893386467697412546884943390480015613537856271220010201116273781620942630107445376100152078778460182528900677762572319906279982347917636005243849010881713419911112844052055408808850635362701847742284042858589527099448700409288014911131232738163070582804334915449738619248625156369127402766090641378256006480116054175417715767882568095021556836463558508854704286436099461681374970748802228538559222427031776854006887522493267864863762366777970110270981128324560856953140280626322184858615905134819673659892297359968740903783153667853232489164985888814677489820693324873593535375656354762940550077780266429048741120931365367834761476907354097588075974967383062758098768486172454244090486624626846941370148551286496970266105153277456404457821481514208000232527688264824321794891384673476448980971105898405462481869090628348700214824256994978295566299977729637323928304487373019910693382460389237293645382017079736467183131241301698539999112457743269314605034480605226666754263702637243490909713273213505475682760885936510885231622525112873264352489998253125656110763057581747085089198789225738143618214790688560485874873756279402435120088860437657783162183789313050795562246164468929085316938369079686461091920490070318527652768344856414512180822584945117460622249951523416449980843194276642773984330667309253160794303764404987228101967131188867652672714857486406683082672195036747519879612133007758102788164271902532310485834470340140071906243623928480963010366298898826926019964433549027019565071945407647062452994618890612677906154231462934192625332717867862774058661323044750665840228998196494273311019154321558113931138297015579002699992051447445959799899563621521030144582363970602547828582192878358104634430812140644566862200600591976958373631803256546787987749410885513810132638909239608682820316984652287672786815791", + "mean_occupation_diagnostic": 265.21829715618895, + "variance_occupation_diagnostic": 78.51788627252415, + "counting_bits_in_normalizer": 10174, + "stored_backward_state_values": 65152, + "bounded_algorithm_control_draws": [ + { + "seed": 20260912, + "physical_rank": 0, + "occupied_sites": 259, + "row_masks": [ + 0, + 8, + 8, + 8, + 6, + 1, + 10, + 14, + 3, + 13, + 13, + 2, + 3, + 14, + 2, + 3, + 7, + 3, + 11, + 11, + 2, + 7, + 10, + 5, + 7, + 9, + 7, + 0, + 4, + 5, + 5, + 14, + 8, + 13, + 1, + 5, + 12, + 6, + 0, + 9, + 13, + 4, + 0, + 12, + 5, + 2, + 14, + 13, + 9, + 7, + 14, + 3, + 14, + 6, + 7, + 10, + 10, + 9, + 12, + 6, + 4, + 12, + 10, + 9, + 10, + 1, + 7, + 10, + 9, + 4, + 7, + 14, + 4, + 2, + 12, + 1, + 3, + 13, + 11, + 12, + 14, + 8, + 6, + 12, + 10, + 6, + 11, + 10, + 5, + 6, + 11, + 8, + 8, + 0, + 6, + 11, + 10, + 1, + 6, + 3, + 13, + 12, + 14, + 14, + 5, + 2, + 11, + 7, + 8, + 7, + 1, + 7, + 10, + 8, + 4, + 1, + 1, + 13, + 14, + 6, + 14, + 7, + 7, + 6, + 10, + 9, + 11, + 7 + ], + "row_mask_sha256": "fbb98e974b01fa4e857166bc676376392ec7270e1534bc5ef5dd3a7878888251" + }, + { + "seed": 20260913, + "physical_rank": 0, + "occupied_sites": 277, + "row_masks": [ + 12, + 12, + 12, + 10, + 14, + 6, + 9, + 13, + 11, + 3, + 5, + 11, + 2, + 12, + 12, + 3, + 10, + 13, + 6, + 5, + 8, + 11, + 0, + 13, + 11, + 12, + 3, + 5, + 13, + 10, + 7, + 14, + 6, + 6, + 10, + 3, + 14, + 10, + 3, + 0, + 1, + 4, + 2, + 9, + 1, + 7, + 9, + 0, + 3, + 7, + 10, + 2, + 7, + 5, + 6, + 10, + 4, + 2, + 12, + 5, + 8, + 10, + 7, + 10, + 7, + 6, + 7, + 11, + 9, + 13, + 10, + 14, + 7, + 11, + 13, + 3, + 13, + 6, + 7, + 6, + 12, + 11, + 13, + 3, + 3, + 13, + 11, + 5, + 14, + 7, + 2, + 7, + 9, + 5, + 7, + 14, + 1, + 4, + 3, + 11, + 5, + 5, + 5, + 12, + 14, + 14, + 1, + 5, + 10, + 4, + 7, + 9, + 7, + 9, + 5, + 3, + 11, + 2, + 6, + 14, + 5, + 5, + 6, + 5, + 2, + 7, + 3, + 14 + ], + "row_mask_sha256": "56e53b1f5712b9fa11ba50d6db5a4175bc5c28bb35622a2be0ca6b12b1dd66b8" + }, + { + "seed": 20260914, + "physical_rank": 0, + "occupied_sites": 266, + "row_masks": [ + 14, + 13, + 2, + 3, + 5, + 12, + 14, + 8, + 7, + 9, + 3, + 3, + 9, + 14, + 10, + 2, + 4, + 10, + 0, + 11, + 7, + 6, + 11, + 7, + 2, + 8, + 4, + 14, + 0, + 4, + 9, + 6, + 3, + 8, + 3, + 10, + 1, + 14, + 5, + 14, + 3, + 2, + 14, + 1, + 13, + 11, + 8, + 3, + 13, + 1, + 14, + 7, + 14, + 12, + 9, + 7, + 11, + 4, + 6, + 12, + 9, + 14, + 13, + 6, + 9, + 10, + 1, + 13, + 6, + 12, + 11, + 6, + 14, + 2, + 14, + 14, + 3, + 1, + 13, + 3, + 5, + 0, + 7, + 3, + 2, + 1, + 7, + 7, + 14, + 14, + 2, + 13, + 8, + 5, + 2, + 6, + 3, + 6, + 14, + 12, + 13, + 14, + 3, + 9, + 0, + 3, + 11, + 9, + 13, + 9, + 5, + 1, + 1, + 12, + 13, + 9, + 8, + 10, + 7, + 5, + 10, + 6, + 14, + 14, + 12, + 12, + 3, + 12 + ], + "row_mask_sha256": "00a94eccef2e627701da4df2a9cd7c435e76ed9314d2af31ec60869200f6d482" + }, + { + "seed": 20260915, + "physical_rank": 0, + "occupied_sites": 270, + "row_masks": [ + 1, + 11, + 7, + 2, + 6, + 4, + 2, + 3, + 12, + 11, + 2, + 3, + 10, + 10, + 13, + 14, + 13, + 2, + 14, + 9, + 9, + 12, + 12, + 11, + 12, + 12, + 2, + 7, + 0, + 10, + 3, + 8, + 1, + 3, + 14, + 0, + 1, + 1, + 4, + 14, + 7, + 3, + 14, + 12, + 13, + 13, + 14, + 7, + 5, + 14, + 6, + 10, + 13, + 14, + 10, + 8, + 13, + 13, + 14, + 9, + 4, + 11, + 2, + 11, + 11, + 11, + 9, + 14, + 14, + 12, + 0, + 9, + 5, + 5, + 14, + 0, + 11, + 9, + 9, + 8, + 12, + 5, + 3, + 7, + 3, + 12, + 4, + 0, + 14, + 0, + 7, + 3, + 12, + 3, + 7, + 6, + 14, + 6, + 5, + 3, + 10, + 12, + 13, + 3, + 5, + 14, + 6, + 13, + 11, + 5, + 7, + 10, + 3, + 4, + 14, + 9, + 14, + 5, + 8, + 2, + 10, + 12, + 14, + 6, + 9, + 3, + 11, + 13 + ], + "row_mask_sha256": "33f06b68f5186f3e54c8e7c0fc5d962961e1660661730ef3af572b627ba48aac" + } + ] + }, + { + "rank": 2, + "probability_exact": "424418778857587345829011265409214890768197555781465099773892853978279390351381192342317554215259527499448233168867188084222868416994081560241020951589186564781612407646954781192143631092812139563187839080331039366936065359152855610683690928077554840576747555204285274166172076271669516129786801191838778200748324147465452325151075249628010753482613163898296939958030477558745531608548556585908891049649271190960723367259669650165630881261126634762955312291402241150609111134822732127345300694520909242008544768952159430231210703057501239585220297230197300664652326348549176392453739205300908993862348332841907201376815350776118201063352982013420556608452042920127704275647192040401142886964458070262302761262597646061649893491689851417949106284657383000029799559334058403614691557593803701604944901490920192293681363478117663078143649230714531970285673223964509332968417274763338811369787713525539759398023189304674956624192652183627991431354356148568419059928380638361475934926654527499432853776167313689893349306384107088918839283165438027933267613727001040997272136950261499618024526147879248504436404637103588493953431351056440300746793506814373122985705598163719305518751204810466997299108378416450644831921736990894922513111164817259109517174808139751906198321633400748189716098109681648345760026686382099412844884463546605577875361904444838928582620276399165145817709682819567379174075481381314884390340114891591994442701509679757620184312581251371615835196575486386814181467647269234902566892679040151339983577999597194900500966988510842195907180091795224504415791289496604462023874231350617703770375472437912802543143301045285005474338031481614498789016648208233128507255916093711604840433075188856523788441949701383789129759099601139245140861896561694576306114491893629907210192947430279727462070076129363219856074946089037445766462584154652176923387238582701793599801473515163960223481537178162885147790472098463675971214321871552962753703539594567229312050962432815759154418166894160893665214319334537247731603023238429146687847550313911109835461765336530438242453563772088244839587150282143645938038915926633370518144747322692481742886077193464223341349021233213945313271386882277956928717738314728549675900601426251226185878036184883145350990761851575456691934160610227944380864888831667385920615909525357381326041701470515941476245876915792403250156318850606008463574471856395606298889923845873238919599911058466435161427843860037441599312664626772566254111110487376243864641689110039343919554585697142234843406935028539472366707768404748038447596836713966534081088492532567419401356275287147466443336691587922953218538994478450416497404661942935909000847435068935651410263096776097816676202933465392784005103597592119825750479865529048939130311338052554609051873426536052227575931613718594381677812495481946243286815032087659016084942770152191061017956276802643228145124474760038381888953079453967681488957709262263943748547539486492258663295043622772985147849761432483981824415903637965821475703932532004744490896596523286523905835524101404521477/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "probability_diagnostic": 4.2441877885758733e-10, + "mean_occupation_exact": "110413584367617722458970215343896451659642208958711569301261607648264195923042722329785026358964647664914366320693798192713955388031922620782106750251537091696444460666514967959682445809546113464658390389049265593457059660083994846066116858885464052582912131549129528883613459885041263471381253445821117771092893694579837876209052555933569837790388533163038703620146028655192210485677500601380663880898248230926750204588975937731894645830171062302618778836962420228017333687698547584048838493211276115868529615287894965696683972307483350645123268765046794611581593495067619665805941121614592450838772521574829641396817447816617237344903270176036692980038187269665909633524473890564156468346327551917345580104929143989602389017014931594334907175406329664751289707746936169423546212196444961561795153678031365266843832569110799512967175786225082073822061403583454497553932385988743484659384521445740733477409123911824127035451113991571168820918154903118111293397227894752401450633007429151185356111774073417235421781665098956814942438870500501566542177028259703773606267919796391939507771025378633149404565899234988993227175668619962606501442875435738410179759262487345586827383898282086744351399960243585573700933374509091858711865102940322291308135595150165992684196123214460765942454236801021073000914005304825185999614441675638578446968440290326354158316915468280116997159074281828971146161372563521749635208419787505700184467319287089450312231627071899170820605040352459838744154810929665731232384648069140830702177423710363878878035459039706736734152354159673728445046028624216325097287747235930843337636668199995130511264571952900918613470220552061105335798571719588475667159801662332206933776600271071927016959991770928209749129328650493577033574176400929485233004112226982045872857266485994958622890989813590293705853487035692109850630968374785343228848096150497978888827809939488638562572903047776876385356651204277543163124107584159912788237723901814644948598733493169699944458295829420399697841478903008072390290462273551427985877128917924389886382896474753076439737030041046318090426641083310447922198176962618041064406143830597088082385472687360076767081540118110110274805710747255269741511089522744399839938321027297236446326009463507274320355736845143101212096045446215940086563632036430765069824/323374874391494954241557281503374819373677684046488234274562756221029424228125067184037182624728772516939208037993343283920416999807769692209546802371314578865530975290081717036204243818236400906177599733751193042235067085825546409133514704271978155864716699023097607949685166577235245992300892769507722480332699117558169673763294358531212902199424947715927503038499713482803735551977219595099954353794143298346409769391821037322234791597770940005445208554810696712320635223144858296794298600737581198773050607745913858643615132865359249001792615726005417189470397652571719847793876175897699865360595610410954041939884487214879133347622094912994149941373031479052189651729929841573729584333641632156702995678586238679625360802826654856707510020193427454875049114106873715238615621641066190347024787643967747606963251853737518344439008044994246427333942985852238410702868845120999420964811352050425279514736416887935081313318383878777500867300185496680043683284766990283967526235783455468824491083816466053178142883483398234210436472428855991767999165081868441155032939963292856728839468300312978336276466473457953652087224281643547217427560567755921425476303871166350114553381941125309530633586298047990745000129837555856334775145952487636360109007322268303642416377661011426616866425119461291313314352090396556412578724048298696926891222712962801355179831661318003185074429030753233927778800428268828524562928286707733984597791908427265600060824203960498218471003243930989987403968179544846728475261038875123446786616412667780627321480519805358736437086263072222227050166385943757368665641831255937295308828248282077964342617390940191406392003981334057954497139760628414468805549878146559543164316385861655594080769124315282452370310339293662493092048943400139447957978935537948615556500081574233386374063227309888598763691009495811146254758564252683920947910881832214908595333081195921491639012744482716180452534559101443466266742788135241208088402198587073433921223901194798840566474537153656391616951326026736791889281691689526831136537100890204811292361566050980634228108918710558658919631635677381185881942879738086836833684106837366190423070932825628081336373733509064954966513446902529912464377993713287122380192413503531001103367800329659567829194569770037431181279573889622005636589418455492689469", + "mean_occupation_diagnostic": 341.441444934108, + "variance_occupation_diagnostic": 73.32447740787667, + "counting_bits_in_normalizer": 10174, + "stored_backward_state_values": 65152, + "bounded_algorithm_control_draws": [ + { + "seed": 20260912, + "physical_rank": 2, + "occupied_sites": 344, + "row_masks": [ + 2, + 11, + 14, + 14, + 7, + 6, + 11, + 13, + 14, + 10, + 10, + 11, + 8, + 15, + 5, + 1, + 13, + 7, + 3, + 3, + 11, + 3, + 10, + 11, + 13, + 9, + 9, + 7, + 3, + 1, + 7, + 15, + 15, + 9, + 15, + 15, + 6, + 11, + 7, + 15, + 8, + 9, + 7, + 15, + 12, + 11, + 7, + 6, + 14, + 14, + 11, + 14, + 14, + 3, + 11, + 15, + 12, + 11, + 7, + 11, + 11, + 13, + 14, + 4, + 13, + 15, + 11, + 14, + 7, + 11, + 6, + 12, + 6, + 13, + 11, + 10, + 12, + 9, + 11, + 13, + 7, + 1, + 5, + 13, + 3, + 15, + 15, + 2, + 3, + 15, + 1, + 5, + 15, + 4, + 15, + 7, + 3, + 5, + 13, + 14, + 12, + 15, + 11, + 15, + 10, + 13, + 7, + 13, + 15, + 15, + 15, + 11, + 9, + 11, + 10, + 10, + 6, + 6, + 13, + 6, + 15, + 13, + 3, + 13, + 7, + 3, + 14, + 11 + ], + "row_mask_sha256": "0feb8bdad14d33106c91cc58ac6de1d3a7d54e001ebba0812fe89657b838122f" + }, + { + "seed": 20260913, + "physical_rank": 2, + "occupied_sites": 350, + "row_masks": [ + 14, + 14, + 14, + 12, + 15, + 15, + 7, + 10, + 15, + 5, + 13, + 7, + 15, + 15, + 11, + 15, + 15, + 14, + 6, + 13, + 11, + 3, + 7, + 14, + 15, + 15, + 14, + 5, + 15, + 15, + 7, + 11, + 13, + 13, + 7, + 7, + 6, + 14, + 10, + 9, + 9, + 14, + 7, + 4, + 5, + 12, + 10, + 13, + 9, + 3, + 7, + 6, + 3, + 14, + 7, + 13, + 11, + 12, + 12, + 13, + 15, + 9, + 15, + 2, + 10, + 10, + 2, + 3, + 5, + 9, + 14, + 15, + 13, + 5, + 14, + 6, + 13, + 9, + 7, + 4, + 5, + 14, + 10, + 13, + 15, + 15, + 11, + 2, + 14, + 12, + 11, + 6, + 5, + 15, + 14, + 9, + 15, + 15, + 5, + 5, + 4, + 6, + 15, + 15, + 14, + 7, + 7, + 10, + 7, + 13, + 15, + 13, + 14, + 3, + 15, + 14, + 13, + 14, + 14, + 7, + 12, + 7, + 9, + 14, + 11, + 9, + 12, + 8 + ], + "row_mask_sha256": "b40d0edd99667d13740e000a1c335aa1740b355efcced9f057f57c3d6be6faea" + }, + { + "seed": 20260914, + "physical_rank": 2, + "occupied_sites": 333, + "row_masks": [ + 15, + 12, + 6, + 5, + 7, + 13, + 7, + 13, + 6, + 7, + 9, + 14, + 7, + 15, + 11, + 5, + 11, + 11, + 14, + 6, + 2, + 7, + 3, + 14, + 15, + 5, + 11, + 6, + 12, + 5, + 6, + 14, + 11, + 11, + 9, + 7, + 13, + 11, + 14, + 13, + 7, + 15, + 2, + 2, + 10, + 15, + 7, + 15, + 5, + 5, + 9, + 14, + 2, + 15, + 2, + 6, + 10, + 10, + 7, + 13, + 9, + 8, + 11, + 7, + 7, + 11, + 6, + 15, + 1, + 3, + 15, + 7, + 11, + 8, + 14, + 2, + 15, + 14, + 14, + 6, + 5, + 15, + 15, + 8, + 11, + 10, + 9, + 9, + 13, + 13, + 8, + 15, + 7, + 12, + 13, + 11, + 12, + 14, + 10, + 7, + 6, + 7, + 1, + 13, + 9, + 7, + 1, + 13, + 12, + 13, + 6, + 12, + 12, + 15, + 15, + 14, + 11, + 5, + 15, + 10, + 6, + 7, + 5, + 15, + 5, + 15, + 11, + 11 + ], + "row_mask_sha256": "e38e7f3c1815719b4ae0fdfa5cc4dc475f677301b83b85ade224a7a94eef562a" + }, + { + "seed": 20260915, + "physical_rank": 2, + "occupied_sites": 348, + "row_masks": [ + 3, + 15, + 10, + 6, + 11, + 7, + 3, + 6, + 7, + 14, + 4, + 6, + 11, + 13, + 13, + 9, + 15, + 14, + 7, + 7, + 11, + 5, + 13, + 5, + 15, + 5, + 11, + 13, + 15, + 13, + 12, + 9, + 11, + 5, + 7, + 14, + 11, + 14, + 7, + 11, + 15, + 4, + 12, + 11, + 7, + 11, + 13, + 7, + 2, + 3, + 11, + 5, + 15, + 8, + 14, + 7, + 9, + 15, + 15, + 11, + 1, + 3, + 14, + 11, + 13, + 13, + 7, + 3, + 6, + 12, + 14, + 15, + 1, + 11, + 6, + 13, + 13, + 13, + 13, + 7, + 3, + 15, + 7, + 15, + 5, + 15, + 14, + 11, + 3, + 11, + 5, + 11, + 5, + 11, + 13, + 11, + 15, + 15, + 12, + 5, + 6, + 14, + 7, + 10, + 15, + 5, + 7, + 7, + 11, + 15, + 5, + 15, + 2, + 11, + 14, + 6, + 13, + 9, + 5, + 11, + 14, + 13, + 8, + 9, + 15, + 2, + 7, + 15 + ], + "row_mask_sha256": "952bbf158b946264d53faaa399cc4849b6370855414e3d034b9010f9e2bd3135" + } + ] + } + ], + "probability_rank_not_1": 8.488604317119674e-10, + "rank_odds_thermal_derivative": 315.4371084311523, + "rank_odds_thermal_derivative_exact_hex": { + "numerator": "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", + "denominator": "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" + }, + "elapsed_seconds": 3.376444150999987 + }, + "limits": [ + "Eight fixed-seed draws are algorithm controls, not a new probability estimate.", + "Each completed configuration is checked by physical lifted-graph traversal.", + "Uniform integer bits give the exact conditional law; a seeded PRNG is used in controls.", + "No rejection of a whole percolation configuration, burn-in, or asymptotic conditioning.", + "Conditioning requires exact backward normalizers on the certified finite state space.", + "No cost guarantee as circumference increases, and no comparison with optimized transfer codes." + ], + "elapsed_seconds": 3.4604507999999896 +} diff --git a/results/research-control-20260912/width4-site-source-independent-checks.json b/results/research-control-20260912/width4-site-source-independent-checks.json new file mode 100644 index 00000000..e5226c53 --- /dev/null +++ b/results/research-control-20260912/width4-site-source-independent-checks.json @@ -0,0 +1,46 @@ +{ + "schema": "matching-one.width4-site-source-independent-grid.v1", + "profiles": { + "homogeneous": { + "rational_tensor_grid_points": 5, + "classes": 94, + "all_source_rows_checked": 509 + }, + "one_marked": { + "rational_tensor_grid_points": 8, + "classes": 303, + "all_source_rows_checked": 509 + }, + "opposite_pairs": { + "rational_tensor_grid_points": 9, + "classes": 179, + "all_source_rows_checked": 509 + }, + "adjacent_pairs": { + "rational_tensor_grid_points": 9, + "classes": 262, + "all_source_rows_checked": 509 + }, + "two_marked_adjacent": { + "rational_tensor_grid_points": 12, + "classes": 509, + "all_source_rows_checked": 509 + }, + "two_marked_opposite": { + "rational_tensor_grid_points": 12, + "classes": 303, + "all_source_rows_checked": 509 + }, + "all_independent": { + "rational_tensor_grid_points": 16, + "classes": 509, + "all_source_rows_checked": 509 + } + }, + "exact_state_rows_checked": 36139, + "all_family_identities_certified_by_degree_complete_grids": true, + "D4_averaged_odd_operator_is_zero": true, + "unprojected_H_times_invariant_indicators_nonzero_entries": 1940, + "standing": "finite exact common-lumping/projection verification, not generic positive minimality", + "elapsed_seconds": 0.15983757200001492 +} diff --git a/results/research-control-20260912/width4-site-source-physical-checks.json b/results/research-control-20260912/width4-site-source-physical-checks.json new file mode 100644 index 00000000..207b96cf --- /dev/null +++ b/results/research-control-20260912/width4-site-source-physical-checks.json @@ -0,0 +1,335 @@ +{ + "schema": "matching-one.site-source-physical-checks.v1", + "source_blob": "50b7297deefe7c50215aea2ed534ca5810461af3", + "physical_configurations_checked": 69888, + "component_saturation_checks": 111969, + "all_component_images_saturated": true, + "all_rank2_images_carried_by_one_component": true, + "tables": { + "2": { + "sites": 8, + "configurations": 256, + "rank_bernstein_counts": [ + [ + 1, + 8, + 24, + 32, + 14, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 4, + 24, + 56, + 48, + 12, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 8, + 16, + 8, + 1 + ] + ], + "M_bernstein_counts": [ + -1, + -8, + -24, + -32, + -14, + 8, + 16, + 8, + 1 + ], + "mixed_degree_N_minus_4_coefficients": {}, + "M_half": "-23/128", + "mixed_at_half": {} + }, + "3": { + "sites": 12, + "configurations": 4096, + "rank_bernstein_counts": [ + [ + 1, + 12, + 66, + 216, + 456, + 624, + 510, + 180, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 4, + 39, + 168, + 402, + 516, + 273, + 28, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 12, + 96, + 222, + 192, + 66, + 12, + 1 + ] + ], + "M_bernstein_counts": [ + -1, + -12, + -66, + -216, + -456, + -624, + -498, + -84, + 222, + 192, + 66, + 12, + 1 + ], + "mixed_degree_N_minus_4_coefficients": { + "1": [ + 0, + 2, + 14, + 42, + 64, + 38, + -2, + -6, + 0 + ] + }, + "M_half": "-183/512", + "mixed_at_half": { + "1": "19/32" + } + }, + "4": { + "sites": 16, + "configurations": 65536, + "rank_bernstein_counts": [ + [ + 1, + 16, + 120, + 560, + 1812, + 4272, + 7448, + 9440, + 8082, + 3984, + 792, + 32, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 8, + 96, + 560, + 1984, + 4580, + 6368, + 4704, + 1472, + 160, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16, + 208, + 1088, + 2512, + 2864, + 1660, + 560, + 120, + 16, + 1 + ] + ], + "M_bernstein_counts": [ + -1, + -16, + -120, + -560, + -1812, + -4272, + -7448, + -9424, + -7874, + -2896, + 1720, + 2832, + 1660, + 560, + 120, + 16, + 1 + ], + "mixed_degree_N_minus_4_coefficients": { + "1": [ + 0, + 0, + 2, + 20, + 96, + 264, + 432, + 376, + 128, + -4, + -6, + 0, + 0 + ], + "2": [ + 0, + 0, + 2, + 20, + 98, + 280, + 428, + 328, + 112, + 4, + -6, + 0, + 0 + ] + }, + "M_half": "-13757/32768", + "mixed_at_half": { + "1": "327/1024", + "2": "633/2048" + } + } + }, + "finite_4x4_root_bracket": [ + "731216657943851720561691753/1237940039285380274899124224", + "365608328971925860280845877/618970019642690137449562112" + ], + "finite_4x4_root_diagnostic": 0.5906721123310283, + "root_Mprime_interval": [ + "7468421440448324325658436758171986944879560825695232718658327697199801735507311314293247799665036105377984109654520371282671490089968126678787648269372930713994444194718100911926784655507224281530500041001317655419378377325169874084140597516615445543969922200605185487407089395940345860134590119142337916462329213572726513934980808992935261927234304315635944496255492605367110467732463293156239636183125/1499941105714815242941825151438695275687387948448394039434162785945609357003976779252520694022167235100910982898195704960834061409041785334284330339447981462657327671077290369080178820523715186958578360930583729374717470295508653247940090402695592690153713769880540096606555767354689117335107142429071912192064038686935941016889583410779167233161454436585539815983836176877921309369250706625652102004736", + "477978972188692756842139964060193033685573336768123891719553867036141343450634495285878848215461413265126922396047609355966539531600274680043057666806818552976219082356994212480104715509858728551647571319556275848023445071887817902726386025958397030701597524215531989097861250962374907221231521705457630953928053278718095788494991957823190572453584848690836820415879699006842014433718413265594785636258309/95996230765748175548276809692076497643992828700697218523786418300518998848254513872161324417418703046458302905484525117493379930178674261394197141724670813610068970948946583621131444513517771965349015099557358679981918098912553807868165785772517932169837681272354566182819569110700103509446857115460602380292098475963900225080933338289866702922333083941474548222965515320186963799632045224041734528303104" + ], + "root_source_responses": [ + { + "row_distance": 1, + "mixed_M_interval": [ + "14547828283533961212133767138168641408032201985875369735175885900976862819137953463953662991496955985993310242406427707943796401011333545810858340079186474164825877368315553771315806422632403701647475767857093730934944053313808173123872164715669791666325069442512076240197977641523015823126931782625631899447183559824969053/50600563326827654588123836679729326762389162441035529589225339506857584891998836722990095925359281123796769466079202977847452184346448369216753349985184627480379356069141590341116726935523304085309941919618186267140501870856173174654525838912289889085202514128089692388083353653807625633046581877161501565826926935273373696", + "232765252536543379394140279033372218709582752541770256516160862959103609340010649422228910809274151394763285809315844924658906895064926790816846854596324608446963874199555236239952914970223510291613796547510989999917246428646922779840202699669786016138575698766045727488003450776862422334704255004547138057161531084004757023/809609013229242473409981386875669228198226599056568473427605432109721358271981387567841534805748497980748311457267247645559234949543173907468053599762954039686069697106265445457867630968372865364959070713890980274248029933698770794472413422596638225363240226049435078209333658460922010128745310034584025053230830964373979136" + ], + "mixed_root_interval": [ + "-431237998288925934367139804980408272097135229769284400139464533589669022300387127778889600730352231463081634215270766784867547279536533287423608291442445482569525200121846105313602568163441435729251200948138506192325922438158342817322847300807159283395287563707706996658980903247850735179583691850943011183590256306469191582307822842125502873285096360337511352492521766486650203001175467365170516328448/7468421440448324325658436758171986944879560825695232718658327697199801735507311314293247799665036105377984109654520371282671490089968126678787648269372930713994444194718100911926784655507224281530500041001317655419378377325169874084140597516615445543969922200605185487407089395940345860134590119142337916462329213572726513934980808992935261927234304315635944496255492605367110467732463293156239636183125", + "-27599231890491259799496946946916376483299375443555865672835911144068530855785021188486934796069418441156714414092761606154035620992921400885782642965524485219038937265236732041284237199615542859320289914480457486584241954549696097205526724146430061778089606194961227127951597133842346945266835757546984887778277817743328457203778936305382178803464108605585329543821619524986488526520452342550247843561472/477978972188692756842139964060193033685573336768123891719553867036141343450634495285878848215461413265126922396047609355966539531600274680043057666806818552976219082356994212480104715509858728551647571319556275848023445071887817902726386025958397030701597524215531989097861250962374907221231521705457630953928053278718095788494991957823190572453584848690836820415879699006842014433718413265594785636258309" + ], + "mixed_M_diagnostic": 0.2875032870596704, + "mixed_root_diagnostic": -0.0577415189712485 + }, + { + "row_distance": 2, + "mixed_M_interval": [ + "110682114731440544989619685933579997100412810179292343647186169565921990352336841644368936905566943912305893907101493325333846412435116100654037865369083339486109873989753302405375195806784274222359452322639242940777028160959423012490277024221010812368124729292417919968582131196312803085440662108470017191855890765583452547/404804506614621236704990693437834614099113299528284236713802716054860679135990693783920767402874248990374155728633623822779617474771586953734026799881477019843034848553132722728933815484186432682479535356945490137124014966849385397236206711298319112681620113024717539104666829230461005064372655017292012526615415482186989568", + "221364229462881089979239376397942160065687328280998918276944071313473075841210721962340010227814969229984602231591224928731295592933227255476357724042287066379403106580296417377155629713819371069552014790878962374215675321269883715470550064079221738255105873270133465615664551108956209623757591271006195891171031271362934183/809609013229242473409981386875669228198226599056568473427605432109721358271981387567841534805748497980748311457267247645559234949543173907468053599762954039686069697106265445457867630968372865364959070713890980274248029933698770794472413422596638225363240226049435078209333658460922010128745310034584025053230830964373979136" + ], + "mixed_root_interval": [ + "-8041482858640208974523731060323919078925310736354438809300259754829659360149171329705384577784039836583740815635042162461229361448468239492548302476140213578281930953019611983026071840611801364106873899223273107018846335953001903993083957848351254542920991106799142952648996710951351936617136955628460691014239528139034573784875609265059637479775102393779874696515567219500011713865990173960551006208/146439636087222045601145818787686018527050212268533974875653484258819641872692378711632309797353649125058511954010203358483754707646433856446816632732802563019498905778786292390721267755043613363343138058849365792536830927944507334983148970914028343999410239227552656615825282273340114904599806257692900322790768893582872822254525666528142390730084398345802833259911619713080597406518888101102737964375", + "-8749133350200547364281819214559149806731814645647308934935724551670757510167223407102274105469165985538601343419493948056635995631450224953545301765850863102584090214128595119898428672628470650335368232166804719951190565112983926664432759631456849172921193581024547326919272526493797222125561908505538449296285657744702520532416029920982730671626405594407950740274586929419762762225241589215131045199872/159326324062897585614046654686731011228524445589374630573184622345380447816878165095292949405153804421708974132015869785322179843866758226681019222268939517658739694118998070826701571836619576183882523773185425282674481690629272634242128675319465676900532508071843996365953750320791635740410507235152543651309351092906031929498330652607730190817861616230278940138626566335614004811239471088531595212086103" + ], + "mixed_M_diagnostic": 0.2734211524893206, + "mixed_root_diagnostic": -0.05491329447070299 + } + ], + "spiral_control": { + "row_masks": [ + 3, + 6, + 12, + 9 + ], + "rank": 1, + "components": [ + { + "rank": 1, + "saturated": true, + "rank_two_index": 0, + "cycle_gains": [ + [ + -1, + -1 + ], + [ + 1, + 1 + ] + ] + } + ], + "critical_polynomial_sector": "1D" + }, + "limits": [ + "Exact finite responses, not continuum field assignments.", + "Root mixed derivative is -mixed_M/Mprime only at the baseline root.", + "The elementary Bernstein inequalities certify signs over the whole root bracket." + ], + "elapsed_seconds": 0.7551919500000395 +} diff --git a/results/research-control-20260912/width4-site-source-quotients.json b/results/research-control-20260912/width4-site-source-quotients.json new file mode 100644 index 00000000..121c96d9 --- /dev/null +++ b/results/research-control-20260912/width4-site-source-quotients.json @@ -0,0 +1,10480 @@ +{ + "schema": "matching-one.width4-site-sources.v1", + "source_blob": "50b7297deefe7c50215aea2ed534ca5810461af3", + "scope": "coarsest common strong rank lumping on PR708; no arbitrary positive minimum", + "profiles": { + "homogeneous": { + "groups": [ + [ + 0, + 1, + 2, + 3 + ] + ], + "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 + ], + "ladder": [ + 3, + 35, + 94, + 94 + ], + "classes": 94, + "label_preserving_D4_indices": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "equals_orbit_partition_blockwise": true + }, + "one_marked": { + "groups": [ + [ + 0 + ], + [ + 1, + 2, + 3 + ] + ], + "labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 2, + 3, + 8, + 9, + 6, + 7, + 10, + 11, + 12, + 13, + 12, + 14, + 15, + 16, + 17, + 16, + 18, + 17, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 35, + 36, + 37, + 38, + 39, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 20, + 23, + 21, + 22, + 24, + 25, + 26, + 30, + 32, + 27, + 31, + 28, + 29, + 33, + 34, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 68, + 69, + 72, + 70, + 71, + 73, + 74, + 43, + 46, + 47, + 41, + 42, + 45, + 44, + 48, + 49, + 50, + 51, + 57, + 54, + 55, + 59, + 60, + 52, + 53, + 58, + 56, + 61, + 62, + 75, + 76, + 77, + 78, + 79, + 80, + 76, + 77, + 81, + 82, + 79, + 80, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 85, + 86, + 91, + 92, + 89, + 90, + 93, + 94, + 95, + 96, + 97, + 98, + 95, + 99, + 94, + 100, + 101, + 98, + 99, + 102, + 103, + 104, + 105, + 106, + 107, + 103, + 104, + 108, + 109, + 107, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 155, + 159, + 154, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 163, + 164, + 168, + 167, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 170, + 176, + 173, + 174, + 178, + 179, + 171, + 172, + 177, + 175, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 182, + 183, + 187, + 188, + 186, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 110, + 111, + 112, + 117, + 114, + 118, + 119, + 113, + 115, + 116, + 120, + 121, + 122, + 129, + 130, + 125, + 126, + 132, + 123, + 124, + 131, + 127, + 128, + 137, + 134, + 133, + 140, + 141, + 138, + 139, + 135, + 136, + 142, + 143, + 144, + 150, + 151, + 147, + 148, + 153, + 145, + 146, + 152, + 149, + 232, + 233, + 234, + 235, + 236, + 233, + 234, + 237, + 235, + 236, + 238, + 239, + 240, + 241, + 242, + 243, + 239, + 240, + 244, + 245, + 242, + 243, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 247, + 248, + 253, + 251, + 252, + 254, + 255, + 254, + 256, + 257, + 258, + 259, + 260, + 259, + 260, + 261, + 262, + 263, + 264, + 261, + 262, + 265, + 266, + 264, + 267, + 268, + 194, + 191, + 190, + 197, + 198, + 195, + 196, + 192, + 193, + 199, + 200, + 201, + 207, + 208, + 204, + 205, + 210, + 202, + 203, + 209, + 206, + 213, + 212, + 211, + 214, + 215, + 216, + 219, + 225, + 226, + 221, + 222, + 228, + 220, + 227, + 223, + 224, + 218, + 217, + 229, + 230, + 231, + 269, + 270, + 269, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 275, + 277, + 278, + 280, + 279, + 281, + 274, + 282, + 283, + 284, + 285, + 286, + 287, + 288, + 289, + 290, + 287, + 288, + 289, + 290, + 291, + 285, + 292, + 293, + 294, + 294, + 295, + 296, + 297, + 297, + 298, + 291, + 299, + 300, + 300, + 301, + 302 + ], + "ladder": [ + 3, + 81, + 302, + 303, + 303 + ], + "classes": 303, + "label_preserving_D4_indices": [ + 0, + 4 + ], + "equals_orbit_partition_blockwise": true + }, + "opposite_pairs": { + "groups": [ + [ + 0, + 2 + ], + [ + 1, + 3 + ] + ], + "labels": [ + 0, + 1, + 2, + 3, + 1, + 4, + 3, + 5, + 2, + 3, + 6, + 7, + 3, + 5, + 7, + 8, + 9, + 10, + 9, + 10, + 11, + 12, + 13, + 12, + 14, + 13, + 15, + 16, + 16, + 17, + 18, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 12, + 13, + 12, + 13, + 14, + 15, + 29, + 29, + 30, + 21, + 22, + 20, + 23, + 27, + 24, + 26, + 25, + 28, + 31, + 32, + 33, + 34, + 32, + 35, + 34, + 36, + 37, + 36, + 38, + 37, + 39, + 16, + 18, + 16, + 17, + 18, + 19, + 20, + 24, + 26, + 21, + 25, + 22, + 23, + 27, + 28, + 40, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 44, + 45, + 48, + 46, + 47, + 49, + 50, + 20, + 24, + 26, + 21, + 22, + 27, + 23, + 25, + 28, + 31, + 32, + 36, + 32, + 35, + 36, + 38, + 33, + 34, + 37, + 34, + 37, + 39, + 42, + 44, + 46, + 43, + 45, + 47, + 44, + 46, + 48, + 49, + 45, + 47, + 50, + 51, + 52, + 53, + 51, + 54, + 53, + 55, + 52, + 53, + 56, + 57, + 53, + 55, + 57, + 58, + 59, + 60, + 61, + 62, + 59, + 63, + 58, + 64, + 65, + 62, + 63, + 66, + 67, + 68, + 69, + 70, + 71, + 67, + 68, + 72, + 73, + 71, + 74, + 75, + 76, + 74, + 75, + 77, + 78, + 79, + 80, + 81, + 80, + 81, + 82, + 83, + 84, + 82, + 85, + 84, + 86, + 87, + 88, + 89, + 88, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 58, + 59, + 60, + 61, + 62, + 59, + 63, + 58, + 62, + 63, + 64, + 65, + 69, + 67, + 71, + 66, + 70, + 68, + 67, + 71, + 72, + 68, + 73, + 111, + 112, + 113, + 111, + 114, + 113, + 115, + 116, + 115, + 117, + 116, + 111, + 115, + 111, + 114, + 115, + 117, + 112, + 113, + 116, + 113, + 116, + 118, + 119, + 120, + 118, + 121, + 120, + 119, + 120, + 122, + 123, + 120, + 123, + 90, + 91, + 92, + 93, + 94, + 99, + 100, + 97, + 98, + 95, + 96, + 104, + 102, + 106, + 101, + 105, + 103, + 107, + 110, + 109, + 108, + 124, + 125, + 126, + 125, + 127, + 128, + 129, + 130, + 131, + 132, + 131, + 133, + 132, + 134, + 135, + 136, + 130, + 136, + 129, + 137, + 138, + 74, + 75, + 76, + 79, + 75, + 80, + 81, + 74, + 77, + 78, + 80, + 81, + 82, + 87, + 88, + 82, + 85, + 88, + 83, + 84, + 89, + 84, + 86, + 94, + 91, + 90, + 97, + 98, + 95, + 96, + 92, + 93, + 99, + 100, + 101, + 107, + 108, + 104, + 105, + 110, + 102, + 103, + 109, + 106, + 139, + 140, + 141, + 142, + 143, + 140, + 141, + 144, + 142, + 143, + 145, + 140, + 142, + 139, + 141, + 143, + 140, + 142, + 144, + 145, + 141, + 143, + 146, + 147, + 148, + 146, + 149, + 148, + 150, + 147, + 148, + 151, + 148, + 150, + 152, + 153, + 152, + 154, + 155, + 156, + 157, + 158, + 157, + 158, + 159, + 160, + 161, + 162, + 159, + 160, + 163, + 164, + 162, + 165, + 166, + 94, + 91, + 90, + 97, + 98, + 99, + 100, + 92, + 93, + 95, + 96, + 104, + 107, + 110, + 101, + 105, + 108, + 102, + 106, + 109, + 103, + 126, + 125, + 124, + 125, + 127, + 128, + 131, + 135, + 136, + 131, + 133, + 136, + 132, + 130, + 132, + 134, + 130, + 129, + 129, + 137, + 138, + 152, + 154, + 152, + 153, + 155, + 156, + 157, + 158, + 161, + 159, + 162, + 160, + 158, + 159, + 162, + 163, + 160, + 164, + 157, + 165, + 166, + 167, + 168, + 167, + 169, + 170, + 171, + 171, + 169, + 170, + 171, + 171, + 172, + 168, + 173, + 174, + 175, + 175, + 173, + 174, + 175, + 175, + 176, + 172, + 176, + 177, + 177, + 178, + 178 + ], + "ladder": [ + 3, + 62, + 179, + 179 + ], + "classes": 179, + "label_preserving_D4_indices": [ + 0, + 2, + 4, + 6 + ], + "equals_orbit_partition_blockwise": true + }, + "adjacent_pairs": { + "groups": [ + [ + 0, + 1 + ], + [ + 2, + 3 + ] + ], + "labels": [ + 0, + 1, + 1, + 2, + 3, + 4, + 5, + 6, + 3, + 5, + 4, + 6, + 7, + 8, + 8, + 9, + 10, + 10, + 11, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 13, + 15, + 16, + 14, + 17, + 18, + 19, + 19, + 20, + 21, + 20, + 21, + 22, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 24, + 25, + 26, + 28, + 27, + 29, + 33, + 34, + 37, + 35, + 36, + 38, + 40, + 39, + 41, + 30, + 31, + 32, + 42, + 44, + 43, + 45, + 49, + 50, + 46, + 48, + 47, + 51, + 53, + 52, + 54, + 55, + 56, + 57, + 55, + 56, + 57, + 58, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 60, + 61, + 62, + 67, + 68, + 69, + 63, + 65, + 64, + 66, + 70, + 71, + 72, + 73, + 73, + 74, + 75, + 76, + 77, + 78, + 75, + 77, + 76, + 78, + 79, + 80, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 81, + 82, + 83, + 88, + 86, + 89, + 90, + 84, + 85, + 87, + 91, + 92, + 94, + 93, + 95, + 99, + 101, + 100, + 102, + 96, + 98, + 97, + 103, + 104, + 105, + 106, + 107, + 104, + 106, + 107, + 108, + 109, + 108, + 109, + 110, + 110, + 111, + 112, + 113, + 114, + 112, + 114, + 113, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 116, + 117, + 118, + 119, + 121, + 120, + 122, + 123, + 126, + 127, + 124, + 125, + 129, + 128, + 130, + 134, + 136, + 135, + 131, + 133, + 132, + 137, + 138, + 173, + 174, + 177, + 178, + 179, + 175, + 176, + 182, + 183, + 180, + 181, + 185, + 184, + 186, + 190, + 192, + 191, + 187, + 189, + 188, + 193, + 140, + 139, + 141, + 145, + 146, + 142, + 144, + 143, + 147, + 149, + 148, + 150, + 151, + 156, + 157, + 158, + 152, + 154, + 153, + 155, + 159, + 160, + 162, + 161, + 163, + 167, + 169, + 168, + 170, + 164, + 166, + 165, + 171, + 172, + 195, + 194, + 197, + 196, + 198, + 199, + 200, + 201, + 212, + 210, + 202, + 203, + 208, + 209, + 204, + 206, + 205, + 207, + 211, + 213, + 214, + 215, + 216, + 215, + 217, + 218, + 217, + 218, + 219, + 220, + 219, + 220, + 221, + 221, + 222, + 223, + 224, + 225, + 223, + 225, + 224, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 228, + 227, + 230, + 229, + 231, + 232, + 244, + 243, + 234, + 233, + 235, + 239, + 240, + 236, + 238, + 237, + 241, + 242, + 245, + 246, + 247, + 248, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 259, + 260, + 261, + 260, + 261 + ], + "ladder": [ + 3, + 90, + 262, + 262 + ], + "classes": 262, + "label_preserving_D4_indices": [ + 0, + 5 + ], + "equals_orbit_partition_blockwise": true + }, + "two_marked_adjacent": { + "groups": [ + [ + 0 + ], + [ + 1 + ], + [ + 2, + 3 + ] + ], + "labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + 288, + 289, + 290, + 291, + 292, + 293, + 294, + 295, + 296, + 297, + 298, + 299, + 300, + 301, + 302, + 303, + 304, + 305, + 306, + 307, + 308, + 309, + 310, + 311, + 312, + 313, + 314, + 315, + 316, + 317, + 318, + 319, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 328, + 329, + 330, + 331, + 332, + 333, + 334, + 335, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 460, + 461, + 462, + 463, + 464, + 465, + 466, + 467, + 468, + 469, + 470, + 471, + 472, + 473, + 474, + 475, + 476, + 477, + 478, + 479, + 480, + 481, + 482, + 483, + 484, + 485, + 486, + 487, + 488, + 489, + 490, + 491, + 492, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 500, + 501, + 502, + 503, + 504, + 505, + 506, + 507, + 508 + ], + "ladder": [ + 3, + 146, + 508, + 509, + 509 + ], + "classes": 509, + "label_preserving_D4_indices": [ + 0 + ], + "equals_orbit_partition_blockwise": true + }, + "two_marked_opposite": { + "groups": [ + [ + 0 + ], + [ + 2 + ], + [ + 1, + 3 + ] + ], + "labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 2, + 3, + 8, + 9, + 6, + 7, + 10, + 11, + 12, + 13, + 12, + 14, + 15, + 16, + 17, + 16, + 18, + 17, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 35, + 36, + 37, + 38, + 39, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 20, + 23, + 21, + 22, + 24, + 25, + 26, + 30, + 32, + 27, + 31, + 28, + 29, + 33, + 34, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 68, + 69, + 72, + 70, + 71, + 73, + 74, + 43, + 46, + 47, + 41, + 42, + 45, + 44, + 48, + 49, + 50, + 51, + 57, + 54, + 55, + 59, + 60, + 52, + 53, + 58, + 56, + 61, + 62, + 75, + 76, + 77, + 78, + 79, + 80, + 76, + 77, + 81, + 82, + 79, + 80, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 85, + 86, + 91, + 92, + 89, + 90, + 93, + 94, + 95, + 96, + 97, + 98, + 95, + 99, + 94, + 100, + 101, + 98, + 99, + 102, + 103, + 104, + 105, + 106, + 107, + 103, + 104, + 108, + 109, + 107, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 155, + 159, + 154, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 163, + 164, + 168, + 167, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 170, + 176, + 173, + 174, + 178, + 179, + 171, + 172, + 177, + 175, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 182, + 183, + 187, + 188, + 186, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 110, + 111, + 112, + 117, + 114, + 118, + 119, + 113, + 115, + 116, + 120, + 121, + 122, + 129, + 130, + 125, + 126, + 132, + 123, + 124, + 131, + 127, + 128, + 137, + 134, + 133, + 140, + 141, + 138, + 139, + 135, + 136, + 142, + 143, + 144, + 150, + 151, + 147, + 148, + 153, + 145, + 146, + 152, + 149, + 232, + 233, + 234, + 235, + 236, + 233, + 234, + 237, + 235, + 236, + 238, + 239, + 240, + 241, + 242, + 243, + 239, + 240, + 244, + 245, + 242, + 243, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 247, + 248, + 253, + 251, + 252, + 254, + 255, + 254, + 256, + 257, + 258, + 259, + 260, + 259, + 260, + 261, + 262, + 263, + 264, + 261, + 262, + 265, + 266, + 264, + 267, + 268, + 194, + 191, + 190, + 197, + 198, + 195, + 196, + 192, + 193, + 199, + 200, + 201, + 207, + 208, + 204, + 205, + 210, + 202, + 203, + 209, + 206, + 213, + 212, + 211, + 214, + 215, + 216, + 219, + 225, + 226, + 221, + 222, + 228, + 220, + 227, + 223, + 224, + 218, + 217, + 229, + 230, + 231, + 269, + 270, + 269, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 275, + 277, + 278, + 280, + 279, + 281, + 274, + 282, + 283, + 284, + 285, + 286, + 287, + 288, + 289, + 290, + 287, + 288, + 289, + 290, + 291, + 285, + 292, + 293, + 294, + 294, + 295, + 296, + 297, + 297, + 298, + 291, + 299, + 300, + 300, + 301, + 302 + ], + "ladder": [ + 3, + 99, + 303, + 303 + ], + "classes": 303, + "label_preserving_D4_indices": [ + 0, + 4 + ], + "equals_orbit_partition_blockwise": true + }, + "all_independent": { + "groups": [ + [ + 0 + ], + [ + 1 + ], + [ + 2 + ], + [ + 3 + ] + ], + "labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + 288, + 289, + 290, + 291, + 292, + 293, + 294, + 295, + 296, + 297, + 298, + 299, + 300, + 301, + 302, + 303, + 304, + 305, + 306, + 307, + 308, + 309, + 310, + 311, + 312, + 313, + 314, + 315, + 316, + 317, + 318, + 319, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 328, + 329, + 330, + 331, + 332, + 333, + 334, + 335, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 460, + 461, + 462, + 463, + 464, + 465, + 466, + 467, + 468, + 469, + 470, + 471, + 472, + 473, + 474, + 475, + 476, + 477, + 478, + 479, + 480, + 481, + 482, + 483, + 484, + 485, + 486, + 487, + 488, + 489, + 490, + 491, + 492, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 500, + 501, + 502, + 503, + 504, + 505, + 506, + 507, + 508 + ], + "ladder": [ + 3, + 164, + 509, + 509 + ], + "classes": 509, + "label_preserving_D4_indices": [ + 0 + ], + "equals_orbit_partition_blockwise": true + } + }, + "D4_permutations": [ + [ + 0, + 1, + 2, + 3 + ], + [ + 1, + 2, + 3, + 0 + ], + [ + 2, + 3, + 0, + 1 + ], + [ + 3, + 0, + 1, + 2 + ], + [ + 0, + 3, + 2, + 1 + ], + [ + 1, + 0, + 3, + 2 + ], + [ + 2, + 1, + 0, + 3 + ], + [ + 3, + 2, + 1, + 0 + ] + ], + "D4_actions": [ + [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + 288, + 289, + 290, + 291, + 292, + 293, + 294, + 295, + 296, + 297, + 298, + 299, + 300, + 301, + 302, + 303, + 304, + 305, + 306, + 307, + 308, + 309, + 310, + 311, + 312, + 313, + 314, + 315, + 316, + 317, + 318, + 319, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 328, + 329, + 330, + 331, + 332, + 333, + 334, + 335, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 460, + 461, + 462, + 463, + 464, + 465, + 466, + 467, + 468, + 469, + 470, + 471, + 472, + 473, + 474, + 475, + 476, + 477, + 478, + 479, + 480, + 481, + 482, + 483, + 484, + 485, + 486, + 487, + 488, + 489, + 490, + 491, + 492, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 500, + 501, + 502, + 503, + 504, + 505, + 506, + 507, + 508 + ], + [ + 0, + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 19, + 16, + 17, + 18, + 20, + 28, + 31, + 27, + 29, + 30, + 32, + 42, + 44, + 46, + 43, + 45, + 47, + 51, + 53, + 56, + 58, + 52, + 54, + 55, + 57, + 59, + 75, + 77, + 73, + 74, + 76, + 78, + 89, + 88, + 90, + 104, + 105, + 107, + 111, + 106, + 108, + 109, + 110, + 112, + 126, + 127, + 129, + 130, + 132, + 134, + 136, + 128, + 131, + 133, + 135, + 137, + 138, + 21, + 22, + 23, + 24, + 25, + 26, + 34, + 35, + 40, + 33, + 36, + 37, + 38, + 39, + 41, + 48, + 49, + 50, + 60, + 62, + 64, + 66, + 69, + 71, + 61, + 63, + 65, + 67, + 68, + 70, + 72, + 82, + 84, + 86, + 79, + 80, + 81, + 83, + 85, + 87, + 91, + 93, + 95, + 97, + 99, + 100, + 102, + 92, + 94, + 96, + 98, + 101, + 103, + 113, + 116, + 118, + 120, + 123, + 124, + 114, + 115, + 117, + 119, + 121, + 122, + 125, + 140, + 142, + 144, + 146, + 148, + 150, + 152, + 139, + 141, + 143, + 145, + 147, + 149, + 151, + 179, + 180, + 178, + 183, + 186, + 177, + 187, + 176, + 181, + 182, + 184, + 185, + 189, + 191, + 193, + 195, + 197, + 198, + 188, + 190, + 192, + 194, + 196, + 220, + 221, + 222, + 227, + 225, + 230, + 231, + 223, + 224, + 226, + 228, + 229, + 233, + 235, + 237, + 238, + 240, + 241, + 242, + 232, + 234, + 236, + 239, + 281, + 278, + 286, + 287, + 277, + 279, + 280, + 282, + 283, + 284, + 285, + 289, + 291, + 293, + 294, + 296, + 297, + 288, + 290, + 292, + 295, + 326, + 323, + 321, + 322, + 329, + 320, + 330, + 319, + 324, + 325, + 327, + 328, + 332, + 334, + 336, + 337, + 339, + 340, + 331, + 333, + 335, + 338, + 341, + 374, + 376, + 377, + 379, + 381, + 383, + 375, + 378, + 380, + 382, + 384, + 364, + 366, + 368, + 370, + 371, + 373, + 363, + 365, + 367, + 369, + 372, + 386, + 388, + 390, + 392, + 394, + 395, + 385, + 387, + 389, + 391, + 393, + 396, + 418, + 419, + 427, + 428, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 430, + 432, + 434, + 435, + 437, + 438, + 429, + 431, + 433, + 436, + 463, + 460, + 461, + 462, + 464, + 465, + 466, + 467, + 469, + 471, + 473, + 475, + 476, + 477, + 468, + 470, + 472, + 474, + 478, + 479, + 480, + 153, + 154, + 155, + 156, + 158, + 157, + 159, + 160, + 161, + 162, + 163, + 164, + 166, + 168, + 170, + 171, + 173, + 175, + 165, + 167, + 169, + 172, + 174, + 199, + 200, + 203, + 208, + 209, + 201, + 202, + 204, + 205, + 206, + 207, + 211, + 213, + 215, + 216, + 218, + 219, + 210, + 212, + 214, + 217, + 244, + 246, + 248, + 251, + 253, + 243, + 245, + 247, + 249, + 250, + 252, + 256, + 258, + 260, + 263, + 264, + 254, + 255, + 257, + 259, + 261, + 262, + 266, + 268, + 270, + 271, + 273, + 275, + 276, + 265, + 267, + 269, + 272, + 274, + 301, + 298, + 299, + 300, + 302, + 303, + 316, + 314, + 304, + 305, + 308, + 310, + 312, + 315, + 306, + 307, + 309, + 311, + 313, + 317, + 318, + 344, + 343, + 342, + 351, + 352, + 345, + 346, + 347, + 348, + 349, + 350, + 354, + 356, + 358, + 359, + 361, + 362, + 353, + 355, + 357, + 360, + 400, + 397, + 398, + 399, + 401, + 402, + 407, + 409, + 410, + 411, + 413, + 415, + 408, + 406, + 412, + 414, + 404, + 403, + 405, + 416, + 417, + 442, + 439, + 440, + 441, + 443, + 444, + 457, + 452, + 446, + 448, + 450, + 453, + 455, + 445, + 447, + 449, + 451, + 454, + 456, + 458, + 459, + 482, + 483, + 493, + 498, + 499, + 500, + 501, + 494, + 495, + 496, + 497, + 504, + 481, + 484, + 485, + 487, + 486, + 488, + 489, + 491, + 490, + 492, + 502, + 503, + 508, + 507, + 505, + 506 + ], + [ + 0, + 4, + 8, + 12, + 1, + 5, + 9, + 13, + 2, + 6, + 10, + 14, + 3, + 7, + 11, + 15, + 18, + 19, + 16, + 17, + 20, + 44, + 45, + 42, + 46, + 43, + 47, + 75, + 73, + 76, + 77, + 74, + 78, + 104, + 107, + 108, + 110, + 105, + 111, + 106, + 109, + 112, + 23, + 25, + 21, + 22, + 24, + 26, + 49, + 48, + 50, + 82, + 84, + 79, + 85, + 86, + 80, + 81, + 83, + 87, + 113, + 116, + 120, + 123, + 114, + 117, + 121, + 118, + 124, + 115, + 119, + 122, + 125, + 28, + 31, + 27, + 29, + 30, + 32, + 53, + 56, + 57, + 51, + 58, + 52, + 54, + 55, + 59, + 89, + 88, + 90, + 126, + 129, + 132, + 136, + 133, + 137, + 127, + 130, + 134, + 128, + 131, + 135, + 138, + 33, + 37, + 39, + 34, + 35, + 40, + 36, + 38, + 41, + 60, + 64, + 69, + 61, + 65, + 67, + 70, + 62, + 66, + 71, + 63, + 68, + 72, + 91, + 97, + 100, + 92, + 98, + 101, + 93, + 95, + 99, + 102, + 94, + 96, + 103, + 142, + 146, + 150, + 139, + 143, + 147, + 151, + 140, + 144, + 148, + 152, + 141, + 145, + 149, + 227, + 225, + 222, + 223, + 228, + 221, + 229, + 220, + 230, + 231, + 224, + 226, + 235, + 238, + 241, + 232, + 236, + 239, + 233, + 237, + 240, + 242, + 234, + 326, + 323, + 321, + 319, + 320, + 327, + 328, + 322, + 329, + 330, + 324, + 325, + 334, + 337, + 340, + 331, + 335, + 338, + 341, + 332, + 336, + 339, + 333, + 420, + 419, + 425, + 426, + 418, + 427, + 428, + 421, + 422, + 423, + 424, + 432, + 435, + 438, + 429, + 433, + 436, + 430, + 434, + 437, + 431, + 160, + 158, + 155, + 156, + 163, + 154, + 164, + 153, + 157, + 159, + 161, + 162, + 168, + 171, + 175, + 165, + 169, + 172, + 166, + 170, + 173, + 167, + 174, + 256, + 260, + 263, + 254, + 257, + 261, + 258, + 264, + 255, + 259, + 262, + 246, + 251, + 243, + 247, + 249, + 252, + 244, + 248, + 253, + 245, + 250, + 268, + 271, + 275, + 265, + 269, + 272, + 266, + 270, + 273, + 276, + 267, + 274, + 344, + 343, + 349, + 350, + 342, + 351, + 352, + 345, + 346, + 347, + 348, + 356, + 359, + 362, + 353, + 357, + 360, + 354, + 358, + 361, + 355, + 441, + 442, + 439, + 440, + 443, + 444, + 457, + 452, + 448, + 453, + 445, + 449, + 451, + 454, + 446, + 450, + 455, + 447, + 456, + 458, + 459, + 179, + 180, + 178, + 183, + 177, + 186, + 187, + 176, + 181, + 182, + 184, + 185, + 191, + 195, + 198, + 188, + 192, + 196, + 189, + 193, + 197, + 190, + 194, + 281, + 278, + 277, + 284, + 285, + 286, + 287, + 279, + 280, + 282, + 283, + 291, + 294, + 297, + 288, + 292, + 295, + 289, + 293, + 296, + 290, + 376, + 379, + 383, + 380, + 384, + 374, + 377, + 381, + 375, + 378, + 382, + 368, + 371, + 363, + 369, + 372, + 364, + 366, + 370, + 373, + 365, + 367, + 388, + 392, + 395, + 385, + 389, + 393, + 396, + 386, + 390, + 394, + 387, + 391, + 462, + 463, + 460, + 461, + 464, + 465, + 478, + 472, + 466, + 467, + 473, + 476, + 468, + 474, + 469, + 471, + 475, + 477, + 470, + 479, + 480, + 203, + 200, + 199, + 206, + 207, + 208, + 209, + 201, + 202, + 204, + 205, + 213, + 216, + 219, + 210, + 214, + 217, + 211, + 215, + 218, + 212, + 300, + 301, + 298, + 299, + 302, + 303, + 308, + 312, + 315, + 306, + 309, + 313, + 310, + 305, + 307, + 311, + 314, + 316, + 304, + 317, + 318, + 399, + 400, + 397, + 398, + 401, + 402, + 405, + 406, + 409, + 411, + 415, + 412, + 404, + 407, + 410, + 413, + 408, + 414, + 403, + 416, + 417, + 483, + 493, + 481, + 488, + 489, + 491, + 490, + 484, + 485, + 487, + 486, + 503, + 482, + 498, + 499, + 501, + 500, + 494, + 495, + 497, + 496, + 504, + 492, + 502, + 506, + 505, + 508, + 507 + ], + [ + 0, + 8, + 1, + 9, + 2, + 10, + 3, + 11, + 4, + 12, + 5, + 13, + 6, + 14, + 7, + 15, + 17, + 18, + 19, + 16, + 20, + 73, + 74, + 75, + 76, + 77, + 78, + 23, + 21, + 24, + 25, + 22, + 26, + 82, + 79, + 80, + 83, + 84, + 85, + 86, + 81, + 87, + 27, + 30, + 28, + 31, + 29, + 32, + 88, + 89, + 90, + 33, + 37, + 34, + 38, + 39, + 35, + 40, + 36, + 41, + 91, + 97, + 92, + 98, + 93, + 99, + 94, + 100, + 101, + 95, + 102, + 96, + 103, + 44, + 45, + 42, + 46, + 43, + 47, + 107, + 108, + 109, + 104, + 110, + 105, + 111, + 106, + 112, + 49, + 48, + 50, + 113, + 120, + 114, + 121, + 115, + 122, + 116, + 123, + 117, + 118, + 124, + 119, + 125, + 51, + 52, + 55, + 53, + 56, + 57, + 58, + 54, + 59, + 126, + 132, + 133, + 127, + 134, + 128, + 135, + 129, + 136, + 137, + 130, + 131, + 138, + 60, + 61, + 67, + 62, + 63, + 68, + 64, + 69, + 65, + 70, + 66, + 71, + 72, + 146, + 139, + 147, + 140, + 148, + 141, + 149, + 142, + 150, + 143, + 151, + 144, + 152, + 145, + 319, + 320, + 321, + 322, + 324, + 323, + 325, + 326, + 327, + 328, + 329, + 330, + 337, + 331, + 338, + 332, + 339, + 333, + 334, + 340, + 335, + 341, + 336, + 160, + 158, + 155, + 153, + 154, + 161, + 162, + 156, + 163, + 164, + 157, + 159, + 171, + 165, + 172, + 166, + 173, + 167, + 174, + 168, + 175, + 169, + 170, + 342, + 343, + 347, + 348, + 344, + 349, + 350, + 351, + 352, + 345, + 346, + 359, + 353, + 360, + 354, + 361, + 355, + 356, + 362, + 357, + 358, + 176, + 177, + 178, + 183, + 184, + 180, + 185, + 179, + 186, + 187, + 181, + 182, + 195, + 188, + 196, + 189, + 197, + 190, + 191, + 198, + 192, + 193, + 194, + 368, + 363, + 369, + 364, + 370, + 365, + 371, + 372, + 366, + 373, + 367, + 379, + 380, + 374, + 381, + 375, + 382, + 376, + 383, + 384, + 377, + 378, + 392, + 385, + 393, + 386, + 394, + 387, + 388, + 395, + 389, + 396, + 390, + 391, + 203, + 200, + 204, + 205, + 199, + 206, + 207, + 208, + 209, + 201, + 202, + 216, + 210, + 217, + 211, + 218, + 212, + 213, + 219, + 214, + 215, + 398, + 399, + 400, + 397, + 401, + 402, + 405, + 406, + 411, + 412, + 407, + 413, + 408, + 414, + 409, + 415, + 404, + 410, + 403, + 416, + 417, + 227, + 225, + 222, + 223, + 221, + 228, + 229, + 220, + 230, + 231, + 224, + 226, + 238, + 232, + 239, + 233, + 240, + 234, + 235, + 241, + 236, + 237, + 242, + 420, + 419, + 418, + 423, + 424, + 425, + 426, + 427, + 428, + 421, + 422, + 435, + 429, + 436, + 430, + 437, + 431, + 432, + 438, + 433, + 434, + 260, + 254, + 261, + 255, + 262, + 256, + 263, + 257, + 258, + 264, + 259, + 243, + 249, + 244, + 245, + 250, + 246, + 251, + 247, + 252, + 248, + 253, + 271, + 265, + 272, + 266, + 273, + 267, + 274, + 268, + 275, + 269, + 270, + 276, + 440, + 441, + 442, + 439, + 443, + 444, + 456, + 455, + 457, + 452, + 445, + 451, + 446, + 447, + 448, + 453, + 449, + 454, + 450, + 458, + 459, + 277, + 278, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + 279, + 280, + 294, + 288, + 295, + 289, + 296, + 290, + 291, + 297, + 292, + 293, + 461, + 462, + 463, + 460, + 464, + 465, + 473, + 468, + 474, + 469, + 475, + 470, + 476, + 467, + 471, + 477, + 472, + 478, + 466, + 479, + 480, + 299, + 300, + 301, + 298, + 302, + 303, + 304, + 305, + 312, + 306, + 313, + 307, + 314, + 308, + 315, + 309, + 310, + 311, + 316, + 317, + 318, + 493, + 481, + 482, + 494, + 495, + 497, + 496, + 498, + 499, + 501, + 500, + 502, + 483, + 488, + 489, + 490, + 491, + 484, + 485, + 486, + 487, + 503, + 504, + 492, + 507, + 508, + 506, + 505 + ], + [ + 0, + 1, + 8, + 9, + 4, + 5, + 12, + 13, + 2, + 3, + 10, + 11, + 6, + 7, + 14, + 15, + 18, + 17, + 16, + 19, + 20, + 23, + 25, + 21, + 24, + 22, + 26, + 73, + 75, + 76, + 74, + 77, + 78, + 79, + 82, + 84, + 85, + 80, + 83, + 81, + 86, + 87, + 44, + 45, + 42, + 43, + 46, + 47, + 49, + 48, + 50, + 107, + 108, + 104, + 110, + 109, + 105, + 106, + 111, + 112, + 113, + 114, + 120, + 121, + 116, + 117, + 123, + 115, + 122, + 118, + 119, + 124, + 125, + 27, + 30, + 28, + 29, + 31, + 32, + 33, + 37, + 39, + 34, + 38, + 35, + 36, + 40, + 41, + 88, + 89, + 90, + 91, + 92, + 97, + 98, + 100, + 101, + 93, + 94, + 99, + 95, + 96, + 102, + 103, + 53, + 56, + 57, + 51, + 52, + 55, + 54, + 58, + 59, + 60, + 61, + 67, + 64, + 65, + 69, + 70, + 62, + 63, + 68, + 66, + 71, + 72, + 126, + 132, + 133, + 129, + 136, + 137, + 127, + 128, + 134, + 135, + 130, + 131, + 138, + 139, + 146, + 147, + 142, + 143, + 150, + 151, + 140, + 141, + 148, + 149, + 144, + 145, + 152, + 160, + 158, + 155, + 156, + 163, + 154, + 164, + 153, + 161, + 162, + 157, + 159, + 165, + 171, + 172, + 168, + 169, + 175, + 166, + 167, + 173, + 174, + 170, + 319, + 320, + 321, + 326, + 323, + 327, + 328, + 322, + 324, + 325, + 329, + 330, + 331, + 337, + 338, + 334, + 335, + 340, + 341, + 332, + 333, + 339, + 336, + 344, + 343, + 349, + 350, + 342, + 347, + 348, + 345, + 346, + 351, + 352, + 353, + 359, + 360, + 356, + 357, + 362, + 354, + 355, + 361, + 358, + 227, + 225, + 222, + 223, + 228, + 221, + 229, + 220, + 224, + 226, + 230, + 231, + 232, + 238, + 239, + 235, + 236, + 241, + 233, + 234, + 240, + 237, + 242, + 254, + 260, + 261, + 256, + 257, + 263, + 255, + 262, + 258, + 259, + 264, + 243, + 249, + 246, + 247, + 251, + 252, + 244, + 245, + 250, + 248, + 253, + 265, + 271, + 272, + 268, + 269, + 275, + 266, + 267, + 273, + 274, + 270, + 276, + 420, + 419, + 425, + 426, + 418, + 423, + 424, + 421, + 422, + 427, + 428, + 429, + 435, + 436, + 432, + 433, + 438, + 430, + 431, + 437, + 434, + 441, + 440, + 439, + 442, + 443, + 444, + 456, + 455, + 445, + 451, + 448, + 449, + 453, + 454, + 446, + 447, + 452, + 450, + 457, + 458, + 459, + 176, + 177, + 178, + 183, + 180, + 184, + 185, + 179, + 181, + 182, + 186, + 187, + 188, + 195, + 196, + 191, + 192, + 198, + 189, + 190, + 197, + 193, + 194, + 203, + 200, + 199, + 206, + 207, + 204, + 205, + 201, + 202, + 208, + 209, + 210, + 216, + 217, + 213, + 214, + 219, + 211, + 212, + 218, + 215, + 363, + 368, + 369, + 371, + 372, + 364, + 365, + 370, + 366, + 367, + 373, + 379, + 380, + 376, + 383, + 384, + 374, + 375, + 381, + 382, + 377, + 378, + 385, + 392, + 393, + 388, + 389, + 395, + 396, + 386, + 387, + 394, + 390, + 391, + 399, + 398, + 397, + 400, + 401, + 402, + 405, + 406, + 403, + 404, + 411, + 412, + 409, + 415, + 407, + 408, + 413, + 414, + 410, + 416, + 417, + 281, + 278, + 277, + 284, + 285, + 282, + 283, + 279, + 280, + 286, + 287, + 288, + 294, + 295, + 291, + 292, + 297, + 289, + 290, + 296, + 293, + 300, + 299, + 298, + 301, + 302, + 303, + 306, + 312, + 313, + 308, + 309, + 315, + 307, + 314, + 310, + 311, + 305, + 304, + 316, + 317, + 318, + 462, + 461, + 460, + 463, + 464, + 465, + 478, + 472, + 468, + 473, + 474, + 476, + 467, + 469, + 470, + 475, + 471, + 477, + 466, + 479, + 480, + 481, + 493, + 483, + 488, + 489, + 490, + 491, + 484, + 485, + 486, + 487, + 503, + 482, + 494, + 495, + 497, + 496, + 498, + 499, + 501, + 500, + 502, + 492, + 504, + 506, + 505, + 507, + 508 + ], + [ + 0, + 2, + 1, + 3, + 8, + 10, + 9, + 11, + 4, + 6, + 5, + 7, + 12, + 14, + 13, + 15, + 17, + 16, + 19, + 18, + 20, + 27, + 30, + 28, + 29, + 31, + 32, + 21, + 23, + 24, + 22, + 25, + 26, + 34, + 33, + 37, + 38, + 35, + 36, + 40, + 39, + 41, + 73, + 74, + 75, + 77, + 76, + 78, + 88, + 89, + 90, + 79, + 80, + 82, + 83, + 81, + 84, + 86, + 85, + 87, + 91, + 93, + 92, + 94, + 97, + 99, + 98, + 95, + 96, + 100, + 102, + 101, + 103, + 42, + 43, + 44, + 46, + 45, + 47, + 51, + 52, + 55, + 53, + 54, + 56, + 58, + 57, + 59, + 48, + 49, + 50, + 60, + 62, + 61, + 63, + 67, + 68, + 64, + 66, + 65, + 69, + 71, + 70, + 72, + 107, + 108, + 109, + 104, + 105, + 106, + 111, + 110, + 112, + 126, + 127, + 128, + 132, + 134, + 133, + 135, + 129, + 130, + 131, + 136, + 137, + 138, + 113, + 114, + 115, + 120, + 121, + 122, + 116, + 118, + 117, + 119, + 123, + 124, + 125, + 140, + 139, + 141, + 146, + 148, + 147, + 149, + 142, + 144, + 143, + 145, + 150, + 152, + 151, + 176, + 177, + 178, + 183, + 184, + 180, + 185, + 179, + 181, + 182, + 186, + 187, + 189, + 188, + 190, + 195, + 197, + 196, + 191, + 193, + 192, + 194, + 198, + 153, + 154, + 155, + 160, + 158, + 161, + 162, + 156, + 157, + 159, + 163, + 164, + 166, + 165, + 167, + 171, + 173, + 172, + 174, + 168, + 170, + 169, + 175, + 203, + 200, + 204, + 205, + 199, + 201, + 202, + 208, + 209, + 206, + 207, + 211, + 210, + 212, + 216, + 218, + 217, + 213, + 215, + 214, + 219, + 319, + 320, + 321, + 322, + 324, + 323, + 325, + 326, + 329, + 330, + 327, + 328, + 332, + 331, + 333, + 337, + 339, + 338, + 334, + 336, + 335, + 340, + 341, + 364, + 363, + 365, + 368, + 370, + 369, + 366, + 367, + 371, + 373, + 372, + 374, + 375, + 379, + 381, + 380, + 382, + 376, + 377, + 378, + 383, + 384, + 386, + 385, + 387, + 392, + 394, + 393, + 388, + 390, + 389, + 391, + 395, + 396, + 342, + 343, + 347, + 348, + 344, + 345, + 346, + 351, + 352, + 349, + 350, + 354, + 353, + 355, + 359, + 361, + 360, + 356, + 358, + 357, + 362, + 398, + 397, + 400, + 399, + 401, + 402, + 403, + 404, + 407, + 408, + 411, + 413, + 412, + 414, + 409, + 410, + 406, + 415, + 405, + 416, + 417, + 220, + 221, + 222, + 223, + 225, + 224, + 226, + 227, + 230, + 231, + 228, + 229, + 233, + 232, + 234, + 238, + 240, + 239, + 235, + 237, + 236, + 241, + 242, + 277, + 278, + 281, + 282, + 283, + 279, + 280, + 286, + 287, + 284, + 285, + 289, + 288, + 290, + 294, + 296, + 295, + 291, + 293, + 292, + 297, + 244, + 243, + 245, + 249, + 250, + 246, + 248, + 247, + 251, + 253, + 252, + 254, + 255, + 260, + 261, + 262, + 256, + 258, + 257, + 259, + 263, + 264, + 266, + 265, + 267, + 271, + 273, + 272, + 274, + 268, + 270, + 269, + 275, + 276, + 299, + 298, + 301, + 300, + 302, + 303, + 304, + 305, + 316, + 314, + 306, + 307, + 312, + 313, + 308, + 310, + 309, + 311, + 315, + 317, + 318, + 420, + 419, + 418, + 423, + 424, + 421, + 422, + 427, + 428, + 425, + 426, + 430, + 429, + 431, + 435, + 437, + 436, + 432, + 434, + 433, + 438, + 461, + 460, + 463, + 462, + 464, + 465, + 469, + 468, + 470, + 473, + 475, + 474, + 471, + 472, + 476, + 477, + 467, + 466, + 478, + 479, + 480, + 440, + 439, + 442, + 441, + 443, + 444, + 456, + 455, + 446, + 445, + 447, + 451, + 452, + 448, + 450, + 449, + 453, + 454, + 457, + 458, + 459, + 482, + 481, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 500, + 501, + 502, + 483, + 484, + 485, + 486, + 487, + 488, + 489, + 490, + 491, + 492, + 504, + 503, + 507, + 508, + 505, + 506 + ], + [ + 0, + 4, + 2, + 6, + 1, + 5, + 3, + 7, + 8, + 12, + 10, + 14, + 9, + 13, + 11, + 15, + 16, + 19, + 18, + 17, + 20, + 42, + 43, + 44, + 46, + 45, + 47, + 28, + 27, + 29, + 31, + 30, + 32, + 53, + 51, + 52, + 54, + 56, + 58, + 57, + 55, + 59, + 21, + 22, + 23, + 25, + 24, + 26, + 48, + 49, + 50, + 34, + 35, + 33, + 36, + 40, + 37, + 39, + 38, + 41, + 60, + 64, + 62, + 66, + 61, + 65, + 63, + 69, + 71, + 67, + 70, + 68, + 72, + 75, + 77, + 73, + 76, + 74, + 78, + 104, + 105, + 106, + 107, + 111, + 108, + 110, + 109, + 112, + 89, + 88, + 90, + 126, + 129, + 127, + 130, + 128, + 131, + 132, + 136, + 134, + 133, + 137, + 135, + 138, + 79, + 80, + 81, + 82, + 84, + 86, + 85, + 83, + 87, + 113, + 116, + 118, + 114, + 117, + 115, + 119, + 120, + 123, + 124, + 121, + 122, + 125, + 91, + 93, + 95, + 92, + 94, + 96, + 97, + 100, + 99, + 102, + 98, + 101, + 103, + 142, + 140, + 144, + 139, + 143, + 141, + 145, + 146, + 150, + 148, + 152, + 147, + 151, + 149, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 230, + 231, + 228, + 229, + 235, + 233, + 237, + 232, + 236, + 234, + 238, + 241, + 240, + 242, + 239, + 179, + 180, + 178, + 176, + 177, + 181, + 182, + 183, + 186, + 187, + 184, + 185, + 191, + 189, + 193, + 188, + 192, + 190, + 194, + 195, + 198, + 197, + 196, + 277, + 278, + 279, + 280, + 281, + 286, + 287, + 284, + 285, + 282, + 283, + 291, + 289, + 293, + 288, + 292, + 290, + 294, + 297, + 296, + 295, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 163, + 164, + 161, + 162, + 168, + 166, + 170, + 165, + 169, + 167, + 171, + 175, + 173, + 172, + 174, + 246, + 244, + 248, + 243, + 247, + 245, + 251, + 253, + 249, + 252, + 250, + 256, + 258, + 254, + 257, + 255, + 259, + 260, + 263, + 264, + 261, + 262, + 268, + 266, + 270, + 265, + 269, + 267, + 271, + 275, + 273, + 276, + 272, + 274, + 199, + 200, + 201, + 202, + 203, + 208, + 209, + 206, + 207, + 204, + 205, + 213, + 211, + 215, + 210, + 214, + 212, + 216, + 219, + 218, + 217, + 298, + 301, + 300, + 299, + 302, + 303, + 316, + 314, + 308, + 310, + 306, + 309, + 307, + 311, + 312, + 315, + 305, + 313, + 304, + 317, + 318, + 326, + 323, + 321, + 322, + 320, + 329, + 330, + 319, + 327, + 328, + 324, + 325, + 334, + 332, + 336, + 331, + 335, + 333, + 337, + 340, + 339, + 338, + 341, + 418, + 419, + 420, + 421, + 422, + 427, + 428, + 425, + 426, + 423, + 424, + 432, + 430, + 434, + 429, + 433, + 431, + 435, + 438, + 437, + 436, + 376, + 374, + 377, + 375, + 378, + 379, + 383, + 381, + 380, + 384, + 382, + 364, + 366, + 363, + 365, + 367, + 368, + 371, + 370, + 373, + 369, + 372, + 388, + 386, + 390, + 385, + 389, + 387, + 391, + 392, + 395, + 394, + 393, + 396, + 460, + 463, + 462, + 461, + 464, + 465, + 466, + 467, + 478, + 472, + 469, + 471, + 468, + 470, + 473, + 476, + 475, + 477, + 474, + 479, + 480, + 342, + 343, + 344, + 345, + 346, + 351, + 352, + 349, + 350, + 347, + 348, + 356, + 354, + 358, + 353, + 357, + 355, + 359, + 362, + 361, + 360, + 439, + 442, + 441, + 440, + 443, + 444, + 448, + 446, + 450, + 445, + 449, + 447, + 453, + 455, + 451, + 454, + 452, + 457, + 456, + 458, + 459, + 397, + 400, + 399, + 398, + 401, + 402, + 403, + 404, + 409, + 407, + 410, + 408, + 406, + 411, + 415, + 413, + 412, + 414, + 405, + 416, + 417, + 483, + 482, + 481, + 484, + 485, + 487, + 486, + 488, + 489, + 491, + 490, + 492, + 493, + 498, + 499, + 500, + 501, + 494, + 495, + 496, + 497, + 504, + 503, + 502, + 505, + 506, + 508, + 507 + ], + [ + 0, + 8, + 4, + 12, + 2, + 10, + 6, + 14, + 1, + 9, + 5, + 13, + 3, + 11, + 7, + 15, + 19, + 18, + 17, + 16, + 20, + 75, + 77, + 73, + 76, + 74, + 78, + 44, + 42, + 46, + 45, + 43, + 47, + 107, + 104, + 105, + 111, + 108, + 110, + 109, + 106, + 112, + 28, + 31, + 27, + 30, + 29, + 32, + 89, + 88, + 90, + 53, + 56, + 51, + 58, + 57, + 52, + 55, + 54, + 59, + 126, + 132, + 129, + 136, + 127, + 134, + 130, + 133, + 137, + 128, + 135, + 131, + 138, + 23, + 25, + 21, + 24, + 22, + 26, + 82, + 84, + 86, + 79, + 85, + 80, + 83, + 81, + 87, + 49, + 48, + 50, + 113, + 120, + 116, + 123, + 118, + 124, + 114, + 121, + 117, + 115, + 122, + 119, + 125, + 34, + 35, + 40, + 33, + 37, + 39, + 38, + 36, + 41, + 91, + 97, + 100, + 93, + 99, + 95, + 102, + 92, + 98, + 101, + 94, + 96, + 103, + 60, + 64, + 69, + 62, + 66, + 71, + 61, + 67, + 65, + 70, + 63, + 68, + 72, + 146, + 142, + 150, + 140, + 148, + 144, + 152, + 139, + 147, + 143, + 151, + 141, + 149, + 145, + 326, + 323, + 321, + 322, + 329, + 320, + 330, + 319, + 327, + 328, + 324, + 325, + 337, + 334, + 340, + 332, + 339, + 336, + 331, + 338, + 335, + 341, + 333, + 227, + 225, + 222, + 220, + 221, + 230, + 231, + 223, + 228, + 229, + 224, + 226, + 238, + 235, + 241, + 233, + 240, + 237, + 242, + 232, + 239, + 236, + 234, + 418, + 419, + 427, + 428, + 420, + 425, + 426, + 423, + 424, + 421, + 422, + 435, + 432, + 438, + 430, + 437, + 434, + 429, + 436, + 433, + 431, + 179, + 180, + 178, + 183, + 186, + 177, + 187, + 176, + 184, + 185, + 181, + 182, + 195, + 191, + 198, + 189, + 197, + 193, + 188, + 196, + 192, + 190, + 194, + 379, + 376, + 383, + 374, + 381, + 377, + 380, + 384, + 375, + 382, + 378, + 368, + 371, + 364, + 370, + 366, + 373, + 363, + 369, + 372, + 365, + 367, + 392, + 388, + 395, + 386, + 394, + 390, + 385, + 393, + 389, + 396, + 387, + 391, + 281, + 278, + 286, + 287, + 277, + 284, + 285, + 282, + 283, + 279, + 280, + 294, + 291, + 297, + 289, + 296, + 293, + 288, + 295, + 292, + 290, + 463, + 462, + 461, + 460, + 464, + 465, + 478, + 472, + 473, + 476, + 469, + 475, + 471, + 477, + 468, + 474, + 467, + 470, + 466, + 479, + 480, + 160, + 158, + 155, + 156, + 154, + 163, + 164, + 153, + 161, + 162, + 157, + 159, + 171, + 168, + 175, + 166, + 173, + 170, + 165, + 172, + 169, + 167, + 174, + 344, + 343, + 342, + 351, + 352, + 349, + 350, + 347, + 348, + 345, + 346, + 359, + 356, + 362, + 354, + 361, + 358, + 353, + 360, + 357, + 355, + 260, + 256, + 263, + 258, + 264, + 254, + 261, + 257, + 255, + 262, + 259, + 246, + 251, + 244, + 248, + 253, + 243, + 249, + 247, + 252, + 245, + 250, + 271, + 268, + 275, + 266, + 273, + 270, + 276, + 265, + 272, + 269, + 267, + 274, + 442, + 441, + 440, + 439, + 443, + 444, + 457, + 452, + 456, + 455, + 448, + 453, + 446, + 450, + 445, + 451, + 449, + 454, + 447, + 458, + 459, + 199, + 200, + 203, + 208, + 209, + 206, + 207, + 204, + 205, + 201, + 202, + 216, + 213, + 219, + 211, + 218, + 215, + 210, + 217, + 214, + 212, + 400, + 399, + 398, + 397, + 401, + 402, + 411, + 409, + 415, + 407, + 413, + 410, + 412, + 404, + 408, + 414, + 406, + 405, + 403, + 416, + 417, + 301, + 300, + 299, + 298, + 302, + 303, + 316, + 314, + 312, + 308, + 315, + 310, + 305, + 306, + 313, + 309, + 307, + 311, + 304, + 317, + 318, + 493, + 483, + 482, + 498, + 499, + 501, + 500, + 494, + 495, + 497, + 496, + 504, + 481, + 488, + 489, + 491, + 490, + 484, + 485, + 487, + 486, + 503, + 502, + 492, + 508, + 507, + 506, + 505 + ] + ], + "physical_class_histories": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 3, + 3 + ], + [ + 4, + 4 + ], + [ + 5, + 5 + ], + [ + 6, + 6 + ], + [ + 7, + 7 + ], + [ + 8, + 8 + ], + [ + 9, + 9 + ], + [ + 10, + 10 + ], + [ + 11, + 11 + ], + [ + 12, + 12 + ], + [ + 13, + 13 + ], + [ + 14, + 14 + ], + [ + 15, + 15 + ], + [ + 0, + 7 + ], + [ + 0, + 11 + ], + [ + 0, + 13 + ], + [ + 0, + 14 + ], + [ + 0, + 15 + ], + [ + 1, + 3 + ], + [ + 1, + 7 + ], + [ + 1, + 9 + ], + [ + 1, + 11 + ], + [ + 1, + 13 + ], + [ + 1, + 15 + ], + [ + 2, + 3 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 11 + ], + [ + 2, + 14 + ], + [ + 2, + 15 + ], + [ + 3, + 1 + ], + [ + 3, + 2 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 9 + ], + [ + 3, + 11 + ], + [ + 3, + 13 + ], + [ + 3, + 14 + ], + [ + 3, + 15 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 4, + 15 + ], + [ + 5, + 7 + ], + [ + 5, + 13 + ], + [ + 5, + 15 + ], + [ + 6, + 2 + ], + [ + 6, + 3 + ], + [ + 6, + 4 + ], + [ + 6, + 7 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 6, + 15 + ], + [ + 7, + 0 + ], + [ + 7, + 1 + ], + [ + 7, + 2 + ], + [ + 7, + 3 + ], + [ + 7, + 4 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 9 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 7, + 15 + ], + [ + 8, + 9 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 8, + 14 + ], + [ + 8, + 15 + ], + [ + 9, + 1 + ], + [ + 9, + 3 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 9, + 15 + ], + [ + 10, + 11 + ], + [ + 10, + 14 + ], + [ + 10, + 15 + ], + [ + 11, + 0 + ], + [ + 11, + 1 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 6 + ], + [ + 11, + 7 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 11, + 14 + ], + [ + 11, + 15 + ], + [ + 12, + 4 + ], + [ + 12, + 6 + ], + [ + 12, + 7 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 11 + ], + [ + 12, + 13 + ], + [ + 12, + 14 + ], + [ + 12, + 15 + ], + [ + 13, + 0 + ], + [ + 13, + 1 + ], + [ + 13, + 3 + ], + [ + 13, + 4 + ], + [ + 13, + 5 + ], + [ + 13, + 6 + ], + [ + 13, + 7 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 11 + ], + [ + 13, + 12 + ], + [ + 13, + 14 + ], + [ + 13, + 15 + ], + [ + 14, + 0 + ], + [ + 14, + 2 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 6 + ], + [ + 14, + 7 + ], + [ + 14, + 8 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ], + [ + 14, + 12 + ], + [ + 14, + 13 + ], + [ + 14, + 15 + ], + [ + 15, + 1 + ], + [ + 15, + 2 + ], + [ + 15, + 3 + ], + [ + 15, + 4 + ], + [ + 15, + 5 + ], + [ + 15, + 6 + ], + [ + 15, + 7 + ], + [ + 15, + 8 + ], + [ + 15, + 9 + ], + [ + 15, + 10 + ], + [ + 15, + 11 + ], + [ + 15, + 12 + ], + [ + 15, + 13 + ], + [ + 15, + 14 + ], + [ + 1, + 3, + 2 + ], + [ + 1, + 3, + 6 + ], + [ + 1, + 3, + 14 + ], + [ + 1, + 7, + 4 + ], + [ + 1, + 7, + 5 + ], + [ + 1, + 7, + 12 + ], + [ + 1, + 7, + 13 + ], + [ + 1, + 9, + 8 + ], + [ + 1, + 11, + 10 + ], + [ + 1, + 11, + 14 + ], + [ + 1, + 13, + 5 + ], + [ + 1, + 13, + 7 + ], + [ + 1, + 15, + 1 + ], + [ + 1, + 15, + 2 + ], + [ + 1, + 15, + 3 + ], + [ + 1, + 15, + 4 + ], + [ + 1, + 15, + 5 + ], + [ + 1, + 15, + 6 + ], + [ + 1, + 15, + 8 + ], + [ + 1, + 15, + 9 + ], + [ + 1, + 15, + 10 + ], + [ + 1, + 15, + 11 + ], + [ + 1, + 15, + 12 + ], + [ + 2, + 3, + 1 + ], + [ + 2, + 3, + 9 + ], + [ + 2, + 3, + 13 + ], + [ + 2, + 6, + 4 + ], + [ + 2, + 6, + 12 + ], + [ + 2, + 7, + 5 + ], + [ + 2, + 7, + 13 + ], + [ + 2, + 11, + 8 + ], + [ + 2, + 11, + 10 + ], + [ + 2, + 11, + 14 + ], + [ + 2, + 14, + 10 + ], + [ + 2, + 14, + 11 + ], + [ + 2, + 15, + 1 + ], + [ + 2, + 15, + 2 + ], + [ + 2, + 15, + 3 + ], + [ + 2, + 15, + 4 + ], + [ + 2, + 15, + 5 + ], + [ + 2, + 15, + 6 + ], + [ + 2, + 15, + 7 + ], + [ + 2, + 15, + 8 + ], + [ + 2, + 15, + 9 + ], + [ + 2, + 15, + 10 + ], + [ + 2, + 15, + 12 + ], + [ + 3, + 6, + 4 + ], + [ + 3, + 6, + 12 + ], + [ + 3, + 7, + 5 + ], + [ + 3, + 7, + 13 + ], + [ + 3, + 9, + 8 + ], + [ + 3, + 11, + 10 + ], + [ + 3, + 11, + 14 + ], + [ + 3, + 13, + 5 + ], + [ + 3, + 13, + 7 + ], + [ + 3, + 14, + 10 + ], + [ + 3, + 14, + 11 + ], + [ + 3, + 15, + 1 + ], + [ + 3, + 15, + 2 + ], + [ + 3, + 15, + 3 + ], + [ + 3, + 15, + 4 + ], + [ + 3, + 15, + 5 + ], + [ + 3, + 15, + 6 + ], + [ + 3, + 15, + 8 + ], + [ + 3, + 15, + 9 + ], + [ + 3, + 15, + 10 + ], + [ + 3, + 15, + 12 + ], + [ + 4, + 6, + 2 + ], + [ + 4, + 6, + 3 + ], + [ + 4, + 6, + 11 + ], + [ + 4, + 7, + 1 + ], + [ + 4, + 7, + 5 + ], + [ + 4, + 7, + 9 + ], + [ + 4, + 7, + 13 + ], + [ + 4, + 12, + 8 + ], + [ + 4, + 13, + 5 + ], + [ + 4, + 13, + 7 + ], + [ + 4, + 14, + 10 + ], + [ + 4, + 14, + 11 + ], + [ + 4, + 15, + 1 + ], + [ + 4, + 15, + 2 + ], + [ + 4, + 15, + 3 + ], + [ + 4, + 15, + 4 + ], + [ + 4, + 15, + 5 + ], + [ + 4, + 15, + 6 + ], + [ + 4, + 15, + 8 + ], + [ + 4, + 15, + 9 + ], + [ + 4, + 15, + 10 + ], + [ + 4, + 15, + 12 + ], + [ + 4, + 15, + 14 + ], + [ + 5, + 7, + 1 + ], + [ + 5, + 7, + 2 + ], + [ + 5, + 7, + 3 + ], + [ + 5, + 7, + 4 + ], + [ + 5, + 7, + 5 + ], + [ + 5, + 7, + 6 + ], + [ + 5, + 7, + 9 + ], + [ + 5, + 7, + 11 + ], + [ + 5, + 7, + 12 + ], + [ + 5, + 7, + 13 + ], + [ + 5, + 7, + 14 + ], + [ + 5, + 13, + 1 + ], + [ + 5, + 13, + 3 + ], + [ + 5, + 13, + 4 + ], + [ + 5, + 13, + 5 + ], + [ + 5, + 13, + 6 + ], + [ + 5, + 13, + 7 + ], + [ + 5, + 13, + 8 + ], + [ + 5, + 13, + 9 + ], + [ + 5, + 13, + 11 + ], + [ + 5, + 13, + 12 + ], + [ + 5, + 13, + 14 + ], + [ + 5, + 15, + 1 + ], + [ + 5, + 15, + 2 + ], + [ + 5, + 15, + 3 + ], + [ + 5, + 15, + 4 + ], + [ + 5, + 15, + 5 + ], + [ + 5, + 15, + 6 + ], + [ + 5, + 15, + 8 + ], + [ + 5, + 15, + 9 + ], + [ + 5, + 15, + 10 + ], + [ + 5, + 15, + 11 + ], + [ + 5, + 15, + 12 + ], + [ + 5, + 15, + 14 + ], + [ + 6, + 3, + 1 + ], + [ + 6, + 3, + 9 + ], + [ + 6, + 7, + 5 + ], + [ + 6, + 7, + 13 + ], + [ + 6, + 11, + 8 + ], + [ + 6, + 11, + 10 + ], + [ + 6, + 11, + 14 + ], + [ + 6, + 13, + 5 + ], + [ + 6, + 13, + 7 + ], + [ + 6, + 14, + 10 + ], + [ + 6, + 14, + 11 + ], + [ + 6, + 15, + 1 + ], + [ + 6, + 15, + 2 + ], + [ + 6, + 15, + 3 + ], + [ + 6, + 15, + 4 + ], + [ + 6, + 15, + 5 + ], + [ + 6, + 15, + 6 + ], + [ + 6, + 15, + 8 + ], + [ + 6, + 15, + 9 + ], + [ + 6, + 15, + 10 + ], + [ + 6, + 15, + 12 + ], + [ + 7, + 0, + 7 + ], + [ + 7, + 0, + 11 + ], + [ + 7, + 0, + 13 + ], + [ + 7, + 0, + 14 + ], + [ + 7, + 1, + 13 + ], + [ + 7, + 9, + 8 + ], + [ + 7, + 11, + 10 + ], + [ + 7, + 11, + 14 + ], + [ + 7, + 13, + 1 + ], + [ + 7, + 13, + 3 + ], + [ + 7, + 13, + 4 + ], + [ + 7, + 13, + 5 + ], + [ + 7, + 13, + 6 + ], + [ + 7, + 13, + 7 + ], + [ + 7, + 13, + 8 + ], + [ + 7, + 13, + 9 + ], + [ + 7, + 13, + 11 + ], + [ + 7, + 13, + 12 + ], + [ + 7, + 14, + 10 + ], + [ + 7, + 15, + 2 + ], + [ + 7, + 15, + 10 + ], + [ + 8, + 9, + 1 + ], + [ + 8, + 9, + 3 + ], + [ + 8, + 9, + 7 + ], + [ + 8, + 11, + 2 + ], + [ + 8, + 11, + 6 + ], + [ + 8, + 11, + 10 + ], + [ + 8, + 11, + 14 + ], + [ + 8, + 12, + 4 + ], + [ + 8, + 13, + 5 + ], + [ + 8, + 13, + 7 + ], + [ + 8, + 14, + 10 + ], + [ + 8, + 14, + 11 + ], + [ + 8, + 15, + 1 + ], + [ + 8, + 15, + 2 + ], + [ + 8, + 15, + 3 + ], + [ + 8, + 15, + 4 + ], + [ + 8, + 15, + 5 + ], + [ + 8, + 15, + 6 + ], + [ + 8, + 15, + 8 + ], + [ + 8, + 15, + 9 + ], + [ + 8, + 15, + 10 + ], + [ + 8, + 15, + 12 + ], + [ + 8, + 15, + 13 + ], + [ + 9, + 3, + 2 + ], + [ + 9, + 3, + 6 + ], + [ + 9, + 7, + 4 + ], + [ + 9, + 7, + 5 + ], + [ + 9, + 7, + 13 + ], + [ + 9, + 11, + 10 + ], + [ + 9, + 11, + 14 + ], + [ + 9, + 13, + 5 + ], + [ + 9, + 13, + 7 + ], + [ + 9, + 14, + 10 + ], + [ + 9, + 14, + 11 + ], + [ + 9, + 15, + 1 + ], + [ + 9, + 15, + 2 + ], + [ + 9, + 15, + 3 + ], + [ + 9, + 15, + 4 + ], + [ + 9, + 15, + 5 + ], + [ + 9, + 15, + 6 + ], + [ + 9, + 15, + 8 + ], + [ + 9, + 15, + 9 + ], + [ + 9, + 15, + 10 + ], + [ + 9, + 15, + 12 + ], + [ + 10, + 11, + 1 + ], + [ + 10, + 11, + 2 + ], + [ + 10, + 11, + 3 + ], + [ + 10, + 11, + 6 + ], + [ + 10, + 11, + 7 + ], + [ + 10, + 11, + 8 + ], + [ + 10, + 11, + 9 + ], + [ + 10, + 11, + 10 + ], + [ + 10, + 11, + 12 + ], + [ + 10, + 11, + 13 + ], + [ + 10, + 11, + 14 + ], + [ + 10, + 14, + 2 + ], + [ + 10, + 14, + 3 + ], + [ + 10, + 14, + 4 + ], + [ + 10, + 14, + 6 + ], + [ + 10, + 14, + 7 + ], + [ + 10, + 14, + 8 + ], + [ + 10, + 14, + 9 + ], + [ + 10, + 14, + 10 + ], + [ + 10, + 14, + 11 + ], + [ + 10, + 14, + 12 + ], + [ + 10, + 14, + 13 + ], + [ + 10, + 15, + 1 + ], + [ + 10, + 15, + 2 + ], + [ + 10, + 15, + 3 + ], + [ + 10, + 15, + 4 + ], + [ + 10, + 15, + 5 + ], + [ + 10, + 15, + 6 + ], + [ + 10, + 15, + 7 + ], + [ + 10, + 15, + 8 + ], + [ + 10, + 15, + 9 + ], + [ + 10, + 15, + 10 + ], + [ + 10, + 15, + 12 + ], + [ + 10, + 15, + 13 + ], + [ + 11, + 0, + 7 + ], + [ + 11, + 0, + 11 + ], + [ + 11, + 0, + 13 + ], + [ + 11, + 0, + 14 + ], + [ + 11, + 2, + 14 + ], + [ + 11, + 6, + 4 + ], + [ + 11, + 7, + 5 + ], + [ + 11, + 7, + 13 + ], + [ + 11, + 13, + 5 + ], + [ + 11, + 13, + 7 + ], + [ + 11, + 14, + 2 + ], + [ + 11, + 14, + 3 + ], + [ + 11, + 14, + 4 + ], + [ + 11, + 14, + 6 + ], + [ + 11, + 14, + 8 + ], + [ + 11, + 14, + 9 + ], + [ + 11, + 14, + 10 + ], + [ + 11, + 14, + 11 + ], + [ + 11, + 14, + 12 + ], + [ + 11, + 15, + 1 + ], + [ + 11, + 15, + 5 + ], + [ + 12, + 6, + 2 + ], + [ + 12, + 6, + 3 + ], + [ + 12, + 7, + 1 + ], + [ + 12, + 7, + 5 + ], + [ + 12, + 7, + 13 + ], + [ + 12, + 11, + 10 + ], + [ + 12, + 11, + 14 + ], + [ + 12, + 13, + 5 + ], + [ + 12, + 13, + 7 + ], + [ + 12, + 14, + 10 + ], + [ + 12, + 14, + 11 + ], + [ + 12, + 15, + 1 + ], + [ + 12, + 15, + 2 + ], + [ + 12, + 15, + 3 + ], + [ + 12, + 15, + 4 + ], + [ + 12, + 15, + 5 + ], + [ + 12, + 15, + 6 + ], + [ + 12, + 15, + 8 + ], + [ + 12, + 15, + 9 + ], + [ + 12, + 15, + 10 + ], + [ + 12, + 15, + 12 + ], + [ + 13, + 0, + 7 + ], + [ + 13, + 0, + 11 + ], + [ + 13, + 0, + 13 + ], + [ + 13, + 0, + 14 + ], + [ + 13, + 1, + 7 + ], + [ + 13, + 3, + 2 + ], + [ + 13, + 7, + 1 + ], + [ + 13, + 7, + 2 + ], + [ + 13, + 7, + 3 + ], + [ + 13, + 7, + 4 + ], + [ + 13, + 7, + 5 + ], + [ + 13, + 7, + 6 + ], + [ + 13, + 7, + 9 + ], + [ + 13, + 7, + 11 + ], + [ + 13, + 7, + 12 + ], + [ + 13, + 7, + 13 + ], + [ + 13, + 7, + 14 + ], + [ + 13, + 11, + 10 + ], + [ + 13, + 14, + 10 + ], + [ + 13, + 15, + 8 + ], + [ + 13, + 15, + 10 + ], + [ + 14, + 0, + 7 + ], + [ + 14, + 0, + 11 + ], + [ + 14, + 0, + 13 + ], + [ + 14, + 0, + 14 + ], + [ + 14, + 2, + 11 + ], + [ + 14, + 3, + 1 + ], + [ + 14, + 7, + 5 + ], + [ + 14, + 7, + 13 + ], + [ + 14, + 11, + 1 + ], + [ + 14, + 11, + 2 + ], + [ + 14, + 11, + 3 + ], + [ + 14, + 11, + 6 + ], + [ + 14, + 11, + 7 + ], + [ + 14, + 11, + 8 + ], + [ + 14, + 11, + 9 + ], + [ + 14, + 11, + 10 + ], + [ + 14, + 11, + 12 + ], + [ + 14, + 11, + 14 + ], + [ + 14, + 13, + 5 + ], + [ + 14, + 15, + 4 + ], + [ + 14, + 15, + 5 + ], + [ + 1, + 3, + 14, + 10 + ], + [ + 2, + 3, + 13, + 5 + ], + [ + 4, + 6, + 11, + 10 + ], + [ + 5, + 7, + 1, + 13 + ], + [ + 5, + 7, + 9, + 8 + ], + [ + 5, + 7, + 11, + 10 + ], + [ + 5, + 7, + 14, + 10 + ], + [ + 5, + 13, + 1, + 7 + ], + [ + 5, + 13, + 3, + 2 + ], + [ + 5, + 13, + 11, + 10 + ], + [ + 5, + 13, + 14, + 10 + ], + [ + 7, + 1, + 13, + 5 + ], + [ + 8, + 9, + 7, + 5 + ], + [ + 10, + 11, + 2, + 14 + ], + [ + 10, + 11, + 6, + 4 + ], + [ + 10, + 11, + 7, + 5 + ], + [ + 10, + 11, + 13, + 5 + ], + [ + 10, + 14, + 2, + 11 + ], + [ + 10, + 14, + 3, + 1 + ], + [ + 10, + 14, + 7, + 5 + ], + [ + 10, + 14, + 13, + 5 + ], + [ + 11, + 2, + 14, + 10 + ], + [ + 13, + 1, + 7, + 5 + ], + [ + 14, + 2, + 11, + 10 + ], + [ + 5, + 7, + 1, + 13, + 5 + ], + [ + 5, + 13, + 1, + 7, + 5 + ], + [ + 10, + 11, + 2, + 14, + 10 + ], + [ + 10, + 14, + 2, + 11, + 10 + ] + ], + "group_transition_checks": 65152, + "witness": { + "histories": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ] + ], + "states": [ + 1, + 2 + ], + "same_homogeneous_class": 1, + "same_occupation": 2, + "same_immediate_rank": 1, + "next_row_probabilities": [ + "q", + "p", + "p", + "p" + ], + "rank_difference_polynomial": "q-p", + "exact_check": "1/5" + }, + "dipole_responses_at_p_half": [ + { + "length": 3, + "row_distance": 1, + "linear": "0", + "mixed_exact": "19/32", + "mixed_diagnostic": 0.59375 + }, + { + "length": 4, + "row_distance": 1, + "linear": "0", + "mixed_exact": "327/1024", + "mixed_diagnostic": 0.3193359375 + }, + { + "length": 4, + "row_distance": 2, + "linear": "0", + "mixed_exact": "633/2048", + "mixed_diagnostic": 0.30908203125 + }, + { + "length": 6, + "row_distance": 1, + "linear": "0", + "mixed_exact": "64451/524288", + "mixed_diagnostic": 0.12293052673339844 + }, + { + "length": 6, + "row_distance": 2, + "linear": "0", + "mixed_exact": "45877/524288", + "mixed_diagnostic": 0.08750343322753906 + }, + { + "length": 6, + "row_distance": 3, + "linear": "0", + "mixed_exact": "13407/262144", + "mixed_diagnostic": 0.051143646240234375 + }, + { + "length": 8, + "row_distance": 1, + "linear": "0", + "mixed_exact": "2722003/67108864", + "mixed_diagnostic": 0.0405610054731369 + }, + { + "length": 8, + "row_distance": 2, + "linear": "0", + "mixed_exact": "1324513/33554432", + "mixed_diagnostic": 0.03947356343269348 + }, + { + "length": 8, + "row_distance": 3, + "linear": "0", + "mixed_exact": "1003051/67108864", + "mixed_diagnostic": 0.014946624636650085 + }, + { + "length": 12, + "row_distance": 1, + "linear": "0", + "mixed_exact": "-74769655273/4398046511104", + "mixed_diagnostic": -0.017000651331045447 + }, + { + "length": 12, + "row_distance": 2, + "linear": "0", + "mixed_exact": "16319187079/2199023255552", + "mixed_diagnostic": 0.0074211070927958644 + }, + { + "length": 12, + "row_distance": 3, + "linear": "0", + "mixed_exact": "14751629763/4398046511104", + "mixed_diagnostic": 0.0033541322779910843 + } + ], + "finite_amplitude_checks": [ + { + "amplitudes": [ + "1/20", + "1/7" + ], + "corners": { + "-1,-1": "-67589497/160563200", + "-1,1": "-68321977/160563200", + "1,-1": "-68321977/160563200", + "1,1": "-67589497/160563200" + }, + "four_sign_divided_difference": "327/1024" + }, + { + "amplitudes": [ + "1/3", + "1/4" + ], + "corners": { + "-1,-1": "-54921/131072", + "-1,1": "-61897/131072", + "1,-1": "-61897/131072", + "1,1": "-54921/131072" + }, + "four_sign_divided_difference": "327/1024" + } + ], + "limits": [ + "Seven column set partitions modulo D4 exhaust the grouping cases.", + "Spatial occupation sources, not continuous-time P398 generators.", + "No continuum spin, original-U candidate, or new sampling verdict." + ], + "elapsed_seconds": 0.20853289999996605 +} diff --git a/scripts/site_source_graph_checks.py b/scripts/site_source_graph_checks.py new file mode 100644 index 00000000..feab5107 --- /dev/null +++ b/scripts/site_source_graph_checks.py @@ -0,0 +1,201 @@ +#!/usr/bin/env python3 +"""Independent lifted-graph checks of rank, local site sources and root response. + +No boundary-state update is used to obtain graph ranks. Integer polynomials are +unnormalized Bernstein counts. Enumeration is bounded to existing tiny tori. +""" +from __future__ import annotations +import argparse +from fractions import Fraction +from itertools import combinations +import json +from math import comb, gcd +from pathlib import Path +import time +from width4_site_sources import DEFAULT_CERTIFICATE, EXPECTED_BLOB, follow, load_certificate + + +def lifted_graph(word, width=4): + """Return ambient rank and component cycle gain generators from physical edges.""" + length = len(word) + if width < 2 or length < 2 or any(not 0 <= b < 1 << width for b in word): + raise ValueError('honest rectangular periods and valid masks required') + occupied = sum(mask << (width*y) for y, mask in enumerate(word)) + positions = {} + images = [] + all_gains = [] + for root in range(width*length): + if root in positions or not ((occupied >> root) & 1): + continue + positions[root] = (0, 0) + todo = [root] + gains = set() + while todo: + u = todo.pop() + x, y = u % width, u // width + px, py = positions[u] + for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)): + v = ((y+dy) % length)*width + (x+dx) % width + if not (occupied >> v) & 1: + continue + candidate = (px+dx, py+dy) + if v not in positions: + positions[v] = candidate + todo.append(v) + else: + wx, wy = candidate[0]-positions[v][0], candidate[1]-positions[v][1] + if wx % width or wy % length: + raise AssertionError('invalid lifted displacement') + gain = (wx//width, wy//length) + if gain != (0, 0): + gains.add(gain) + gains = sorted(gains) + index = 0 + for a, b in combinations(gains, 2): + index = gcd(index, abs(a[0]*b[1]-a[1]*b[0])) + if index: + rank = 2 + saturated = index == 1 + elif gains: + rank = 1 + divisor = 0 + for x, y in gains: + divisor = gcd(divisor, gcd(abs(x), abs(y))) + saturated = divisor == 1 + else: + rank, saturated = 0, True + images.append({'rank': rank, 'saturated': saturated, 'rank_two_index': index, + 'cycle_gains': gains}) + all_gains.extend(gains) + rank = 0 if not all_gains else 1 + if any(a[0]*b[1]-a[1]*b[0] for a, b in combinations(all_gains, 2)): + rank = 2 + return rank, images + + +def unnormalized_bernstein(coefficients, p): + p = Fraction(p) + degree = len(coefficients)-1 + return sum((c*p**k*(1-p)**(degree-k) for k, c in enumerate(coefficients)), Fraction(0)) + + +def bernstein_derivative(coefficients): + n = len(coefficients)-1 + return [(k+1)*coefficients[k+1]-(n-k)*coefficients[k] for k in range(n)] + + +def bernstein_interval(coefficients, lo, hi): + """Outward exact termwise interval, not a floating root approximation.""" + n = len(coefficients)-1 + lower = upper = Fraction(0) + for k, c in enumerate(coefficients): + a = lo**k*(1-hi)**(n-k) + b = hi**k*(1-lo)**(n-k) + lower += c*(a if c >= 0 else b) + upper += c*(b if c >= 0 else a) + return lower, upper + + +def physical_controls(source): + start = time.perf_counter() + tables = {} + total = 0 + saturation_components = 0 + for length in (2, 3, 4): + n = 4*length + counts = [[0]*(n+1) for _ in range(3)] + mixed = {distance: [0]*(n-3) for distance in range(1, min(3, length-1))} + for mask in range(1 << n): + word = [(mask >> (4*y)) & 15 for y in range(length)] + rank, images = lifted_graph(word) + if rank != source['quotient_rank_output'][follow(source, word)]: + raise AssertionError('graph and automaton disagree') + if any(not image['saturated'] for image in images): + raise AssertionError('embedded component has nonsaturated image') + if sum(image['rank'] == 2 for image in images) > 1: + raise AssertionError('disjoint independent rank-two components') + if rank == 2 and not any(image['rank'] == 2 for image in images): + raise AssertionError('disjoint rank-one components generate rank two') + saturation_components += len(images) + k = mask.bit_count() + counts[rank][k] += 1 + for distance, coefficients in mixed.items(): + a, b = word[1], word[1+distance] + sign = ((a & 1)-((a >> 2) & 1))*((b & 1)-((b >> 2) & 1)) + if sign: + coefficients[k-2] += sign*(rank-1) + total += 1 + if any(sum(counts[j][k] for j in range(3)) != comb(n, k) for k in range(n+1)): + raise AssertionError('occupation-count conservation failed') + matching = [b-a for a, b in zip(counts[0], counts[2])] + tables[str(length)] = {'sites': n, 'configurations': 1 << n, + 'rank_bernstein_counts': counts, 'M_bernstein_counts': matching, + 'mixed_degree_N_minus_4_coefficients': mixed, + 'M_half': str(unnormalized_bernstein(matching, Fraction(1, 2))), + 'mixed_at_half': {d: str(unnormalized_bernstein(c, Fraction(1, 2))) + for d, c in mixed.items()}} + matching = tables['4']['M_bernstein_counts'] + derivative = bernstein_derivative(matching) + lo, hi = Fraction(0), Fraction(1) + for _ in range(90): + mid = (lo+hi)/2 + if unnormalized_bernstein(matching, mid) < 0: + lo = mid + else: + hi = mid + if not unnormalized_bernstein(matching, lo) < 0 < unnormalized_bernstein(matching, hi): + raise AssertionError('root bracket signs failed') + dlo, dhi = bernstein_interval(derivative, lo, hi) + if not 0 < dlo <= dhi: + raise AssertionError('positive root derivative not certified') + root_response = [] + for distance, coefficients in tables['4']['mixed_degree_N_minus_4_coefficients'].items(): + clo, chi = bernstein_interval(coefficients, lo, hi) + if not 0 < clo <= chi: + raise AssertionError('positive mixed source response not certified') + bound = [-chi/dlo, -clo/dhi] + root_response.append({'row_distance': distance, + 'mixed_M_interval': [str(clo), str(chi)], + 'mixed_root_interval': list(map(str, bound)), + 'mixed_M_diagnostic': float(unnormalized_bernstein(coefficients, (lo+hi)/2)), + 'mixed_root_diagnostic': float(sum(bound)/2)}) + # A rank-one spiral is the essential counterexample to projection-label bookkeeping. + spiral = [3, 6, 12, 9] + spiral_rank, spiral_images = lifted_graph(spiral) + if spiral_rank != 1 or not any(x and y for im in spiral_images for x, y in im['cycle_gains']): + raise AssertionError('spiral control failed') + return {'schema': 'matching-one.site-source-physical-checks.v1', 'source_blob': EXPECTED_BLOB, + 'physical_configurations_checked': total, + 'component_saturation_checks': saturation_components, + 'all_component_images_saturated': True, + 'all_rank2_images_carried_by_one_component': True, + 'tables': tables, + 'finite_4x4_root_bracket': [str(lo), str(hi)], + 'finite_4x4_root_diagnostic': float((lo+hi)/2), + 'root_Mprime_interval': [str(dlo), str(dhi)], + 'root_source_responses': root_response, + 'spiral_control': {'row_masks': spiral, 'rank': spiral_rank, + 'components': spiral_images, 'critical_polynomial_sector': '1D'}, + 'limits': ['Exact finite responses, not continuum field assignments.', + 'Root mixed derivative is -mixed_M/Mprime only at the baseline root.', + 'The elementary Bernstein inequalities certify signs over the whole root bracket.'], + 'elapsed_seconds': time.perf_counter()-start} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--certificate', type=Path, default=DEFAULT_CERTIFICATE) + parser.add_argument('--out', type=Path) + args = parser.parse_args() + result = physical_controls(load_certificate(args.certificate)) + text = json.dumps(result, 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/scripts/verify_width4_site_sources.py b/scripts/verify_width4_site_sources.py new file mode 100644 index 00000000..e6844c0a --- /dev/null +++ b/scripts/verify_width4_site_sources.py @@ -0,0 +1,94 @@ +#!/usr/bin/env python3 +"""Independent exact-grid and projection checks of a saved source quotient. + +This verifier does not call the polynomial-coefficient refinement routine. +A degree-complete rational tensor grid certifies each full polynomial family. +""" +from __future__ import annotations +import argparse +from collections import defaultdict +from fractions import Fraction +from itertools import product +import json +from pathlib import Path +import time +from width4_site_sources import DEFAULT_CERTIFICATE, ROOT, load_certificate + +DEFAULT_RESULT = ROOT/'results/research-control-20260912/width4-site-source-quotients.json' + + +def verify(source, result): + started=time.perf_counter() + rows=source['quotient_transitions'] + ranks=source['quotient_rank_output'] + checks=0 + by_profile={} + for name, entry in result['profiles'].items(): + groups=entry['groups'];labels=entry['labels'] + if len(labels)!=509 or len(set(labels))!=entry['classes']: + raise AssertionError('incorrect partition dimensions') + grid=[tuple(Fraction(k+1,len(g)+2) for k in range(len(g)+1)) for g in groups] + point_count=0 + for values in product(*grid): + ps=[None]*4 + for g,p in zip(groups,values): + for j in g:ps[j]=p + denominator=1 + for p in ps:denominator*=p.denominator + weights=[] + for mask in range(16): + probability=Fraction(1) + for j,p in enumerate(ps):probability*=p if mask&(1<>2)&1)) + individual_nonzero+=sum(bool(v) for v in image.values()) + for block,value in image.items():totals[labels[i],block]+=value + if any(totals.values()) or individual_nonzero==0: + raise AssertionError('odd projection test fails') + return {'schema':'matching-one.width4-site-source-independent-grid.v1', + 'profiles':by_profile,'exact_state_rows_checked':checks, + 'all_family_identities_certified_by_degree_complete_grids':True, + 'D4_averaged_odd_operator_is_zero':True, + 'unprojected_H_times_invariant_indicators_nonzero_entries':individual_nonzero, + 'standing':'finite exact common-lumping/projection verification, not generic positive minimality', + 'elapsed_seconds':time.perf_counter()-started} + + +def main(): + p=argparse.ArgumentParser(description=__doc__) + p.add_argument('--certificate',type=Path,default=DEFAULT_CERTIFICATE) + p.add_argument('--result',type=Path,default=DEFAULT_RESULT) + p.add_argument('--out',type=Path) + args=p.parse_args() + result=verify(load_certificate(args.certificate),json.loads(args.result.read_text())) + text=json.dumps(result,indent=2)+'\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/scripts/width4_conditioned_rank.py b/scripts/width4_conditioned_rank.py new file mode 100644 index 00000000..ffc3f2bf --- /dev/null +++ b/scripts/width4_conditioned_rank.py @@ -0,0 +1,261 @@ +#!/usr/bin/env python3 +"""Exact finite-horizon conditioning on a final torus rank, using PR708 states. + +Positive integer backward messages implement the elementary Doob transform. +This is not a new general sampling theorem and not a large-width cost claim. +No burn-in, topology-event rejection, or floating-point sampling weights. +""" +from __future__ import annotations +import argparse +from fractions import Fraction +import hashlib +import json +from pathlib import Path +from random import Random +import time +from width4_site_sources import (DEFAULT_CERTIFICATE, EXPECTED_BLOB, follow, + load_certificate, row_integer_weights) +from site_source_graph_checks import lifted_graph + + +def integer_choice(weights, rng): + if any(type(x) is not int or x < 0 for x in weights): + raise ValueError('nonnegative integer weights required') + total = sum(weights) + if not total: + raise ValueError('cannot sample zero total weight') + draw = rng.randrange(total) + for i, weight in enumerate(weights): + if draw < weight: + return i + draw -= weight + raise AssertionError('integer choice failed') + + +class RankBridge: + """Condition independent site occupations on final rank 0, 1, or 2.""" + def __init__(self, source, probability_rows, target): + if type(target) is not int or target not in (0, 1, 2): + raise ValueError('rank target must be 0,1,2') + if len(probability_rows) < 2: + raise ValueError('at least two physical rows required') + self.source = source + self.target = target + entries = [row_integer_weights(row) for row in probability_rows] + self.weights = [w for w, _ in entries] + self.denominator = 1 + for _, d in entries: + self.denominator *= d + self.length = len(entries) + # h[y](state after row y-1) includes pending spatial rows y,...,m-1. + self.h = [None]*(self.length+1) + self.h[self.length] = [int(r == target) for r in source['quotient_rank_output']] + for y in range(self.length-1, 0, -1): + hnext = self.h[y+1] + weights = self.weights[y] + self.h[y] = [sum(weights[mask]*hnext[j] for mask, j in enumerate(row)) + for row in source['quotient_transitions']] + self.first_weights = [self.weights[0][mask]*self.h[1][j] + for mask, j in enumerate(source['quotient_initial'])] + self.mass = sum(self.first_weights) + if not self.mass: + raise ValueError('conditioning event has zero probability') + self.probability = Fraction(self.mass, self.denominator) + + def sample(self, rng): + """Exact under a uniform integer random-bit source; seeded PRNG for controls.""" + mask = integer_choice(self.first_weights, rng) + word = [mask] + state = self.source['quotient_initial'][mask] + for y in range(1, self.length): + row = self.source['quotient_transitions'][state] + weights = [self.weights[y][b]*self.h[y+1][j] for b, j in enumerate(row)] + if sum(weights) != self.h[y][state]: + raise AssertionError('backward normalizer inconsistent') + mask = integer_choice(weights, rng) + word.append(mask) + state = row[mask] + if self.source['quotient_rank_output'][state] != self.target: + raise AssertionError('wrong final rank') + return word + + def sequential_word_probability(self, word): + if len(word) != self.length or any(type(b) is not int or not 0 <= b < 16 for b in word): + raise ValueError('word has incorrect length or masks') + mask = word[0] + numerator = self.first_weights[mask] + if not numerator: + return Fraction(0) + result = Fraction(numerator, self.mass) + state = self.source['quotient_initial'][mask] + for y in range(1, self.length): + target = self.source['quotient_transitions'][state][word[y]] + numerator = self.weights[y][word[y]]*self.h[y+1][target] + if not numerator: + return Fraction(0) + result *= Fraction(numerator, self.h[y][state]) + state = target + return result + + def direct_word_probability(self, word): + if len(word) != self.length or any(type(b) is not int or not 0 <= b < 16 for b in word): + raise ValueError('word has incorrect length or masks') + state = follow(self.source, word) + if self.source['quotient_rank_output'][state] != self.target: + return Fraction(0) + mass = 1 + for y, mask in enumerate(word): + mass *= self.weights[y][mask] + return Fraction(mass, self.mass) + + +def sector_moments(source, probability_rows): + """Exact total occupation moments K,K^2; no numerical differentiation.""" + if len(probability_rows) < 2: + raise ValueError('at least two rows required') + entries = [row_integer_weights(row) for row in probability_rows] + size = len(source['quotient_transitions']) + mass, first, second = ([0]*size for _ in range(3)) + for b, state in enumerate(source['quotient_initial']): + value = entries[0][0][b] + k = b.bit_count() + mass[state] += value + first[state] += k*value + second[state] += k*k*value + denominator = entries[0][1] + for weights, den in entries[1:]: + denominator *= den + new, new1, new2 = ([0]*size for _ in range(3)) + for i, value in enumerate(mass): + if not value: + continue + for b, j in enumerate(source['quotient_transitions'][i]): + w, k = weights[b], b.bit_count() + new[j] += w*value + new1[j] += w*(first[i]+k*value) + new2[j] += w*(second[i]+2*k*first[i]+k*k*value) + mass, first, second = new, new1, new2 + result = [] + for rank in range(3): + indices = [i for i, r in enumerate(source['quotient_rank_output']) if r == rank] + z = sum(mass[i] for i in indices) + z1 = sum(first[i] for i in indices) + z2 = sum(second[i] for i in indices) + result.append({'mass': z, 'denominator': denominator, 'first_weighted': z1, + 'second_weighted': z2, 'probability': Fraction(z, denominator), + 'mean': Fraction(z1, z) if z else None, + 'variance': Fraction(z2, z)-Fraction(z1, z)**2 if z else None}) + if sum(r['probability'] for r in result) != 1: + raise AssertionError('total probability is not one') + ps = [Fraction(p) for row in probability_rows for p in row] + mean = sum(ps) + total_first = sum(r['first_weighted'] for r in result) + total_second = sum(r['second_weighted'] for r in result) + if Fraction(total_first, denominator) != mean: + raise AssertionError('unconditional mean mismatch') + if Fraction(total_second, denominator)-mean**2 != sum(p*(1-p) for p in ps): + raise AssertionError('unconditional variance mismatch') + return result + + +def bridge_report(source): + started = time.perf_counter() + small_rows = [[Fraction(1, 3), Fraction(2, 5), Fraction(3, 7), Fraction(4, 9)], + [Fraction(3, 4), Fraction(2, 3), Fraction(3, 5), Fraction(1, 2)], + [Fraction(2, 7), Fraction(4, 5), Fraction(1, 4), Fraction(5, 6)]] + bridges = [RankBridge(source, small_rows, r) for r in range(3)] + moments = sector_moments(source, small_rows) + sums = [[0, 0, 0] for _ in range(3)] + checked = 0 + for mask in range(1 << 12): + word = [(mask >> (4*y)) & 15 for y in range(3)] + rank = lifted_graph(word)[0] + mass = 1 + for y, b in enumerate(word): + mass *= bridges[rank].weights[y][b] + k = mask.bit_count() + sums[rank][0] += mass + sums[rank][1] += k*mass + sums[rank][2] += k*k*mass + for bridge in bridges: + if bridge.sequential_word_probability(word) != bridge.direct_word_probability(word): + raise AssertionError('conditional path law fails') + checked += 1 + for rank, (z, z1, z2) in enumerate(sums): + if (z, z1, z2) != (moments[rank]['mass'], moments[rank]['first_weighted'], + moments[rank]['second_weighted']): + raise AssertionError('independent conditional occupation moments fail') + if bridges[rank].mass != z: + raise AssertionError('independent rank normalizer fails') + # Fixed rational p close to q4, not the exact root and not a new p_c value. + p = Fraction(591417, 1000000) + length = 128 + ps = [[p]*4 for _ in range(length)] + begin = time.perf_counter() + rare_moments = sector_moments(source, ps) + rare = [] + for rank in (0, 2): + bridge = RankBridge(source, ps, rank) + if bridge.mass != rare_moments[rank]['mass']: + raise AssertionError('forward/backward rare normalizers disagree') + controls = [] + for seed in (20260912, 20260913, 20260914, 20260915): + word = bridge.sample(Random(seed)) + graph_rank = lifted_graph(word)[0] + if graph_rank != rank: + raise AssertionError('conditioned sample violates independent rank oracle') + if bridge.sequential_word_probability(word) != bridge.direct_word_probability(word): + raise AssertionError('long path telescoping fails') + controls.append({'seed': seed, 'physical_rank': graph_rank, + 'occupied_sites': sum(b.bit_count() for b in word), + 'row_masks': word, + 'row_mask_sha256': hashlib.sha256(bytes(word)).hexdigest()}) + rare.append({'rank': rank, 'probability_exact': str(bridge.probability), + 'probability_diagnostic': float(bridge.probability), + 'mean_occupation_exact': str(rare_moments[rank]['mean']), + 'mean_occupation_diagnostic': float(rare_moments[rank]['mean']), + 'variance_occupation_diagnostic': float(rare_moments[rank]['variance']), + 'counting_bits_in_normalizer': bridge.mass.bit_length(), + 'stored_backward_state_values': (length)*509, + 'bounded_algorithm_control_draws': controls}) + score = (rare_moments[2]['mean']-rare_moments[0]['mean'])/(p*(1-p)) + union_probability = rare_moments[0]['probability']+rare_moments[2]['probability'] + return {'schema': 'matching-one.width4-exact-rank-bridge.v1', 'source_blob': EXPECTED_BLOB, + 'small_inhomogeneous_probability_rows': [[str(p) for p in row] for row in small_rows], + 'small_physical_configurations': 4096, 'conditional_path_equalities': checked, + 'small_sector_probabilities': [str(b.probability) for b in bridges], + 'small_conditional_mean_occupations': [str(r['mean']) for r in moments], + 'rare_control': {'length': length, 'sites': 4*length, 'p_exact': str(p), + 'note': 'rational near q4; not an exact balance root', + 'sectors': rare, + 'probability_rank_not_1': float(union_probability), + 'rank_odds_thermal_derivative': float(score), + 'rank_odds_thermal_derivative_exact_hex': { + 'numerator': hex(score.numerator), 'denominator': hex(score.denominator)}, + 'elapsed_seconds': time.perf_counter()-begin}, + 'limits': ['Eight fixed-seed draws are algorithm controls, not a new probability estimate.', + 'Each completed configuration is checked by physical lifted-graph traversal.', + 'Uniform integer bits give the exact conditional law; a seeded PRNG is used in controls.', + 'No rejection of a whole percolation configuration, burn-in, or asymptotic conditioning.', + 'Conditioning requires exact backward normalizers on the certified finite state space.', + 'No cost guarantee as circumference increases, and no comparison with optimized transfer codes.'], + 'elapsed_seconds': time.perf_counter()-started} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--certificate', type=Path, default=DEFAULT_CERTIFICATE) + parser.add_argument('--out', type=Path) + args = parser.parse_args() + result = bridge_report(load_certificate(args.certificate)) + text = json.dumps(result, 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/scripts/width4_site_sources.py b/scripts/width4_site_sources.py new file mode 100644 index 00000000..51c1d3d6 --- /dev/null +++ b/scripts/width4_site_sources.py @@ -0,0 +1,315 @@ +#!/usr/bin/env python3 +"""Source-compatible rank quotients for the exact width-four site automaton. + +Standard library only. Upstream certificate: PR #708, immutable blob checked. +Column probability groups may vary independently at every spatial row. +Coarsest strong lumping is not an arbitrary positive-realization minimum. +""" +from __future__ import annotations +import argparse +from collections import Counter, deque +from fractions import Fraction +import hashlib +import json +from pathlib import Path +import time + +ROOT = Path(__file__).resolve().parents[1] +DEFAULT_CERTIFICATE = ROOT / 'results/research-control-20260912/width4-rank-closure-certificate.json' +EXPECTED_BLOB = '50b7297deefe7c50215aea2ed534ca5810461af3' +PROFILES = { + 'homogeneous': ((0, 1, 2, 3),), + 'one_marked': ((0,), (1, 2, 3)), + 'opposite_pairs': ((0, 2), (1, 3)), + 'adjacent_pairs': ((0, 1), (2, 3)), + 'two_marked_adjacent': ((0,), (1,), (2, 3)), + 'two_marked_opposite': ((0,), (2,), (1, 3)), + 'all_independent': ((0,), (1,), (2,), (3,)), +} +EXPECTED_COUNTS = (94, 303, 179, 262, 509, 303, 509) +D4 = tuple(tuple((sign*j+k) % 4 for j in range(4)) + for sign in (1, -1) for k in range(4)) + + +def load_certificate(path=DEFAULT_CERTIFICATE): + raw = Path(path).read_bytes() + blob = hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() + if blob != EXPECTED_BLOB: + raise ValueError(f'wrong certificate blob: {blob}; expected {EXPECTED_BLOB}') + source = json.loads(raw) + rows = source['quotient_transitions'] + if len(rows) != 509 or any(len(row) != 16 for row in rows): + raise ValueError('unexpected automaton dimensions') + return source + + +def canonical_labels(values): + lookup = {} + return [lookup.setdefault(value, len(lookup)) for value in values] + + +def validate_groups(groups): + groups = tuple(tuple(g) for g in groups) + if (any(not g for g in groups) or any(type(j) is not int for g in groups for j in g) + or sorted(j for g in groups for j in g) != list(range(4))): + raise ValueError('groups must partition columns 0,1,2,3') + return groups + + +def mask_signature(mask, groups): + return tuple(sum((mask >> j) & 1 for j in group) for group in groups) + + +def refine(source, groups): + """Polynomial coefficient refinement for all independently varying group p's.""" + groups = validate_groups(groups) + rows = source['quotient_transitions'] + keys = [mask_signature(mask, groups) for mask in range(16)] + labels = canonical_labels(source['quotient_rank_output']) + ladder = [len(set(labels))] + while True: + lookup = {} + new = [] + for i, row in enumerate(rows): + totals = Counter((keys[mask], labels[j]) for mask, j in enumerate(row)) + key = (labels[i], tuple(sorted(totals.items()))) + new.append(lookup.setdefault(key, len(lookup))) + ladder.append(len(lookup)) + if new == labels: + return {'groups': groups, 'labels': labels, 'ladder': ladder, + 'classes': len(lookup)} + labels = new + + +def transform_mask(mask, permutation): + return sum(((mask >> j) & 1) << permutation[j] for j in range(4)) + + +def follow(source, word): + if not word or any(type(mask) is not int or not 0 <= mask < 16 for mask in word): + raise ValueError('word must contain row masks in [0,15]') + state = source['quotient_initial'][word[0]] + for mask in word[1:]: + state = source['quotient_transitions'][state][mask] + return state + + +def histories(source): + """A physical (at least two rows) word for every deterministic rank class.""" + result = {} + todo = deque() + for a in range(16): + for b in range(16): + state = follow(source, [a, b]) + if state not in result: + result[state] = [a, b] + todo.append(state) + while todo: + state = todo.popleft() + for mask, target in enumerate(source['quotient_transitions'][state]): + if target not in result: + result[target] = result[state]+[mask] + todo.append(target) + if len(result) != 509: + raise AssertionError('not all rank classes have physical histories') + return [result[i] for i in range(509)] + + +def group_actions(source, words=None): + words = histories(source) if words is None else words + rows = source['quotient_transitions'] + output = source['quotient_rank_output'] + actions = [] + for permutation in D4: + action = [follow(source, [transform_mask(b, permutation) for b in word]) + for word in words] + if sorted(action) != list(range(509)): + raise AssertionError('group action is not a permutation') + for i, row in enumerate(rows): + if output[action[i]] != output[i]: + raise AssertionError('rank not invariant') + for mask, j in enumerate(row): + if action[j] != rows[action[i]][transform_mask(mask, permutation)]: + raise AssertionError('transition action fails') + actions.append(action) + return actions + + +def row_integer_weights(probabilities): + """Integer row weights with one common denominator; endpoints are supported.""" + if len(probabilities) != 4: + raise ValueError('exactly four probabilities required') + probabilities = [Fraction(x) for x in probabilities] + if any(p < 0 or p > 1 for p in probabilities): + raise ValueError('site probabilities must lie in [0,1]') + denominator = 1 + for p in probabilities: + denominator *= p.denominator + weights = [] + for mask in range(16): + value = 1 + for j, p in enumerate(probabilities): + value *= p.numerator if (mask >> j) & 1 else p.denominator-p.numerator + weights.append(value) + if sum(weights) != denominator: + raise AssertionError('row weights not normalized') + return weights, denominator + + +def signed_output(source, weights_by_row, denominators): + """Exact M or a signed-source coefficient; does not require positive weights.""" + if len(weights_by_row) < 2 or len(denominators) != len(weights_by_row): + raise ValueError('at least two equally specified rows required') + n = len(source['quotient_transitions']) + vector = [0]*n + denominator = 1 + for mask, j in enumerate(source['quotient_initial']): + vector[j] += weights_by_row[0][mask] + for d in denominators: + denominator *= d + for weights in weights_by_row[1:]: + moved = [0]*n + for i, value in enumerate(vector): + if value: + for mask, j in enumerate(source['quotient_transitions'][i]): + moved[j] += value*weights[mask] + vector = moved + return Fraction(sum(value*(r-1) for value, r in + zip(vector, source['quotient_rank_output'])), denominator) + + +def product_measure_M(source, probability_rows): + entries = [row_integer_weights(row) for row in probability_rows] + return signed_output(source, [a for a, _ in entries], [d for _, d in entries]) + + +def dipole_response(source, length, source_rows, p=Fraction(1, 2)): + """Mixed spatial-row dipole derivatives at any rational interior baseline p.""" + if type(length) is not int or length < 2: + raise ValueError('length must be an integer at least two') + if len(set(source_rows)) != len(source_rows) or any(type(y) is not int or y < 0 or y >= length for y in source_rows): + raise ValueError('distinct valid source rows required') + p = Fraction(p) + if not 0 < p < 1: + raise ValueError('interior probability required for signed local sources') + a, d = p.numerator, p.denominator + base, denominator = row_integer_weights([p]*4) + odd = [] + for mask, weight in enumerate(base): + numerator = weight*d*d*((mask & 1)-((mask >> 2) & 1)) + value, remainder = divmod(numerator, a*(d-a)) + if remainder: + raise AssertionError('dipole derivative should have integer coefficients') + odd.append(value) + return signed_output(source, [odd if y in source_rows else base for y in range(length)], + [denominator]*length) + + +def dipole_response_half(source, length, source_rows): + return dipole_response(source, length, source_rows, Fraction(1, 2)) + + +def four_sign(source, length, row1, row2, eps1, eps2, p=Fraction(1, 2)): + if row1 == row2 or not 0 <= row1 < length or not 0 <= row2 < length: + raise ValueError('two distinct source rows required') + eps1, eps2, p = Fraction(eps1), Fraction(eps2), Fraction(p) + if not eps1 or not eps2: + raise ValueError('nonzero amplitudes required') + total = Fraction(0) + corners = {} + for s in (-1, 1): + for t in (-1, 1): + ps = [[p]*4 for _ in range(length)] + for y, sign, eps in ((row1, s, eps1), (row2, t, eps2)): + ps[y][0] += sign*eps + ps[y][2] -= sign*eps + value = product_measure_M(source, ps) + corners[f'{s},{t}'] = str(value) + total += s*t*value + return total/(4*eps1*eps2), corners + + +def profile_report(source): + words = histories(source) + actions = group_actions(source, words) + for a, pa in enumerate(D4): + for b, pb in enumerate(D4): + c = D4.index(tuple(pa[pb[j]] for j in range(4))) + if any(actions[a][actions[b][i]] != actions[c][i] for i in range(509)): + raise AssertionError('D4 multiplication law fails') + profiles = {} + for (name, groups), expected in zip(PROFILES.items(), EXPECTED_COUNTS): + result = refine(source, groups) + eligible = [k for k, permutation in enumerate(D4) + if all({permutation[j] for j in group} == set(group) for group in groups)] + orbit_labels = canonical_labels(tuple(sorted({actions[k][i] for k in eligible})) + for i in range(509)) + if result['labels'] != orbit_labels or result['classes'] != expected: + raise AssertionError(f'orbit/refinement disagreement: {name}') + result['label_preserving_D4_indices'] = eligible + result['equals_orbit_partition_blockwise'] = True + profiles[name] = result + # Check the 94-class failure without using orbit names as proof. + a, b = follow(source, [1, 1]), follow(source, [2, 2]) + hom = profiles['homogeneous']['labels'] + if hom[a] != hom[b]: + raise AssertionError('witness not in one homogeneous block') + p, q = Fraction(2, 5), Fraction(3, 5) + weights, denominator = row_integer_weights([q, p, p, p]) + output = source['quotient_rank_output'] + rows = source['quotient_transitions'] + difference = Fraction(sum(weights[mask]*(output[rows[a][mask]]-output[rows[b][mask]]) + for mask in range(16)), denominator) + if difference != q-p: + raise AssertionError('marked-column witness failed') + response = [] + for m in (3, 4, 6, 8, 12): + one = dipole_response_half(source, m, (1,)) + if one: + raise AssertionError('odd linear response not zero') + for distance in range(1, min(4, m-1)): + mixed = dipole_response_half(source, m, (1, 1+distance)) + response.append({'length': m, 'row_distance': distance, 'linear': '0', + 'mixed_exact': str(mixed), 'mixed_diagnostic': float(mixed)}) + finite = [] + for eps1, eps2 in ((Fraction(1, 20), Fraction(1, 7)), + (Fraction(1, 3), Fraction(1, 4))): + value, corners = four_sign(source, 4, 1, 2, eps1, eps2) + if value != Fraction(327, 1024): + raise AssertionError('finite-amplitude identity failed') + finite.append({'amplitudes': [str(eps1), str(eps2)], 'corners': corners, + 'four_sign_divided_difference': str(value)}) + return {'schema': 'matching-one.width4-site-sources.v1', 'source_blob': EXPECTED_BLOB, + 'scope': 'coarsest common strong rank lumping on PR708; no arbitrary positive minimum', + 'profiles': profiles, 'D4_permutations': D4, + 'D4_actions': actions, 'physical_class_histories': words, + 'group_transition_checks': 8*509*16, + 'witness': {'histories': [[1, 1], [2, 2]], 'states': [a, b], + 'same_homogeneous_class': hom[a], 'same_occupation': 2, + 'same_immediate_rank': 1, 'next_row_probabilities': ['q', 'p', 'p', 'p'], + 'rank_difference_polynomial': 'q-p', 'exact_check': str(difference)}, + 'dipole_responses_at_p_half': response, 'finite_amplitude_checks': finite, + 'limits': ['Seven column set partitions modulo D4 exhaust the grouping cases.', + 'Spatial occupation sources, not continuous-time P398 generators.', + 'No continuum spin, original-U candidate, or new sampling verdict.']} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--certificate', type=Path, default=DEFAULT_CERTIFICATE) + parser.add_argument('--out', type=Path) + args = parser.parse_args() + start = time.perf_counter() + result = profile_report(load_certificate(args.certificate)) + result['elapsed_seconds'] = time.perf_counter()-start + text = json.dumps(result, 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_site_source_graph_checks.py b/tests/test_site_source_graph_checks.py new file mode 100644 index 00000000..52cb25da --- /dev/null +++ b/tests/test_site_source_graph_checks.py @@ -0,0 +1,45 @@ +import os +from pathlib import Path +import sys +import unittest +from fractions import Fraction +sys.path.insert(0, str(Path(__file__).resolve().parents[1]/'scripts')) +import width4_site_sources as ws +import site_source_graph_checks as gc +CERTIFICATE=Path(os.environ.get('MATCHING_ONE_RANK_CERTIFICATE',str(ws.DEFAULT_CERTIFICATE))) + +class PhysicalSourceTest(unittest.TestCase): + @classmethod + def setUpClass(cls):cls.source=ws.load_certificate(CERTIFICATE) + + def test_spiral_is_1D_not_rank2(self): + rank, images=gc.lifted_graph([3,6,12,9]) + self.assertEqual(rank,1) + self.assertTrue(any(x and y for im in images for x,y in im['cycle_gains'])) + + def test_existing_topological_memory_witnesses(self): + for word,r in (([13,5,13,0],0),([7,5,13,0],1),([0,7,5,7],0),([0,13,5,7],1),([11,14],2)): + rank,images=gc.lifted_graph(word) + self.assertEqual(rank,r) + self.assertTrue(all(im['saturated'] for im in images)) + + def test_full_physical_polynomial_and_root_certificate(self): + result=gc.physical_controls(self.source) + self.assertEqual(result['physical_configurations_checked'],69888) + self.assertEqual(result['tables']['4']['mixed_at_half'][1],'327/1024') + self.assertEqual(result['tables']['4']['mixed_at_half'][2],'633/2048') + for row in result['root_source_responses']: + lo,hi=map(Fraction,row['mixed_root_interval']) + self.assertLess(lo,hi) + self.assertLess(hi,0) + + def test_bernstein_derivative_and_interval(self): + # p^2+(1-p)^2 represented without binomial factors. + c=[1,0,1] + self.assertEqual(gc.bernstein_derivative(c),[-2,2]) + lo,hi=gc.bernstein_interval(c,Fraction(1,3),Fraction(1,2)) + for p in (Fraction(1,3),Fraction(2,5),Fraction(1,2)): + v=gc.unnormalized_bernstein(c,p) + self.assertLessEqual(lo,v);self.assertLessEqual(v,hi) + +if __name__ == '__main__':unittest.main() diff --git a/tests/test_width4_conditioned_rank.py b/tests/test_width4_conditioned_rank.py new file mode 100644 index 00000000..b59dbd0f --- /dev/null +++ b/tests/test_width4_conditioned_rank.py @@ -0,0 +1,61 @@ +import os +from pathlib import Path +import sys +import unittest +from fractions import Fraction +from random import Random +sys.path.insert(0, str(Path(__file__).resolve().parents[1]/'scripts')) +import width4_site_sources as ws +import width4_conditioned_rank as br +from site_source_graph_checks import lifted_graph +CERTIFICATE=Path(os.environ.get('MATCHING_ONE_RANK_CERTIFICATE',str(ws.DEFAULT_CERTIFICATE))) + +class RankBridgeTest(unittest.TestCase): + @classmethod + def setUpClass(cls):cls.source=ws.load_certificate(CERTIFICATE) + + def test_all_two_row_conditional_path_probabilities(self): + ps=[[Fraction(1,3),Fraction(2,5),Fraction(1,2),Fraction(3,4)], + [Fraction(2,3),Fraction(1,5),Fraction(3,7),Fraction(4,5)]] + for rank in range(3): + bridge=br.RankBridge(self.source,ps,rank) + total=Fraction(0) + for a in range(16): + for b in range(16): + value=bridge.sequential_word_probability([a,b]) + self.assertEqual(value,bridge.direct_word_probability([a,b])) + if lifted_graph([a,b])[0]!=rank:self.assertEqual(value,0) + total+=value + self.assertEqual(total,1) + + def test_conditional_moments_and_thermal_score(self): + p=Fraction(2,5);ps=[[p]*4]*3 + moments=br.sector_moments(self.source,ps) + direct=[Fraction(0)]*3;derivative=[Fraction(0)]*3 + for mask in range(1<<12): + word=[(mask>>(4*y))&15 for y in range(3)] + r=lifted_graph(word)[0];k=mask.bit_count() + weight=p**k*(1-p)**(12-k) + direct[r]+=weight + derivative[r]+=weight*(Fraction(k)-12*p)/(p*(1-p)) + self.assertEqual(direct,[m['probability'] for m in moments]) + lhs=derivative[2]/direct[2]-derivative[0]/direct[0] + rhs=(moments[2]['mean']-moments[0]['mean'])/(p*(1-p)) + self.assertEqual(lhs,rhs) + self.assertGreater(rhs,0) + + def test_samples_end_in_specified_physical_sector(self): + for rank in (0,1,2): + bridge=br.RankBridge(self.source,[[Fraction(3,5)]*4]*6,rank) + for seed in (4,5,6): + word=bridge.sample(Random(seed)) + self.assertEqual(lifted_graph(word)[0],rank) + self.assertEqual(bridge.sequential_word_probability(word),bridge.direct_word_probability(word)) + + def test_impossible_condition_and_invalid_word(self): + with self.assertRaises(ValueError):br.RankBridge(self.source,[[Fraction(0)]*4]*2,2) + bridge=br.RankBridge(self.source,[[Fraction(1,2)]*4]*2,0) + with self.assertRaises(ValueError):bridge.direct_word_probability([0]) + with self.assertRaises(ValueError):br.integer_choice([0,0],Random(1)) + +if __name__ == '__main__':unittest.main() diff --git a/tests/test_width4_site_sources.py b/tests/test_width4_site_sources.py new file mode 100644 index 00000000..f4c4b3c0 --- /dev/null +++ b/tests/test_width4_site_sources.py @@ -0,0 +1,64 @@ +import os +from pathlib import Path +import sys +import unittest +from fractions import Fraction +sys.path.insert(0, str(Path(__file__).resolve().parents[1]/'scripts')) +import width4_site_sources as ws + +CERTIFICATE = Path(os.environ.get('MATCHING_ONE_RANK_CERTIFICATE', str(ws.DEFAULT_CERTIFICATE))) + +class SiteSourcesTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.source = ws.load_certificate(CERTIFICATE) + + def test_all_profile_quotients_and_group_actions(self): + r = ws.profile_report(self.source) + self.assertEqual([x['classes'] for x in r['profiles'].values()], list(ws.EXPECTED_COUNTS)) + self.assertTrue(all(x['equals_orbit_partition_blockwise'] for x in r['profiles'].values())) + + def test_seven_profiles_exhaust_column_partitions(self): + words = [(0,)] + for _ in range(3): + words = [word+(k,) for word in words for k in range(max(word)+2)] + def groups(word): + return tuple(tuple(j for j,v in enumerate(word) if v==k) for k in range(max(word)+1)) + def canon(gs): + return tuple(sorted(tuple(sorted(g)) for g in gs)) + representatives = {min(canon([[pi[j] for j in g] for g in groups(word)]) for pi in ws.D4) + for word in words} + expected = {min(canon([[pi[j] for j in g] for g in gs]) for pi in ws.D4) + for gs in ws.PROFILES.values()} + self.assertEqual(len(words), 15) + self.assertEqual(len(representatives), 7) + self.assertEqual(representatives, expected) + + def test_first_odd_response_vanishes(self): + for p in (Fraction(1, 3), Fraction(1, 2), Fraction(3, 5)): + self.assertEqual(ws.dipole_response(self.source, 5, (2,), p), 0) + + def test_finite_amplitude_is_exact_not_an_extrapolation(self): + for p, a, b in ((Fraction(1, 2), Fraction(1, 3), Fraction(1, 4)), + (Fraction(2, 5), Fraction(1, 10), Fraction(1, 8))): + value, _ = ws.four_sign(self.source, 4, 1, 2, a, b, p) + self.assertEqual(value, ws.dipole_response(self.source, 4, (1, 2), p)) + self.assertEqual(ws.dipole_response_half(self.source, 4, (1, 2)), Fraction(327, 1024)) + + def test_homogeneous_block_does_not_carry_local_input(self): + s = self.source + labels = ws.refine(s, ws.PROFILES['homogeneous'])['labels'] + i, j = ws.follow(s, [1, 1]), ws.follow(s, [2, 2]) + self.assertEqual(labels[i], labels[j]) + p,q = Fraction(1, 3), Fraction(3, 5) + weights, den = ws.row_integer_weights([q,p,p,p]) + out=s['quotient_rank_output'];t=s['quotient_transitions'] + difference=Fraction(sum(w*(out[t[i][b]]-out[t[j][b]]) for b,w in enumerate(weights)),den) + self.assertEqual(difference, q-p) + + def test_invalid_inputs_rejected(self): + with self.assertRaises(ValueError):ws.validate_groups(((0,1),(1,2,3))) + with self.assertRaises(ValueError):ws.row_integer_weights([Fraction(5,4)]*4) + with self.assertRaises(ValueError):ws.dipole_response_half(self.source,4,(1,1)) + +if __name__ == '__main__':unittest.main()