From 72d2ee6b8e5d25bd96aaef586c113bc94201f64a Mon Sep 17 00:00:00 2001 From: Light Chain Date: Sat, 12 Sep 2026 22:12:16 +0800 Subject: [PATCH] Rectangle matching-root consistency without aspect bound; P398 is periodic IC TL On axis rectangles m>=w>=2, p_{w,m} -> p_c^site uniformly in the long side as w->infty. No m/w bound and no w/log(wm)->infty. Compare exponential rates of P0 and P2 via Harris and disjoint slabs, even when both are tiny. H=P2/(P0+P2) is not the birth-mixture F; #613 stays for the full law. P398 is the periodic identified-connectivity O(1) TL chain on 2w endpoints: Phi D_i = e_{2i} Phi, Phi J_i = e_{2i+1} Phi. #715's join-only distinction was a representation error. eta <-> -eta via half-step K, K^2 = site rotation. Stationary law at eta=0 is the published FPL/RS pushforward, imported not proved. Additive on main. Independent of #708-#716. Do not merge. Full-repo CI not run. --- ...ct-uniform-balance-consistency-20260912.md | 214 +++++++ notes/p398-is-periodic-tl-20260912.md | 206 ++++++ notes/root-tl-handoff-20260912.md | 65 ++ notes/root-tl-review-20260912-zh.md | 148 +++++ notes/root-tl-source-audit-20260912.md | 78 +++ .../p398-tl-fattening.json | 588 ++++++++++++++++++ .../rectangular-rank-odds-controls.json | 334 ++++++++++ scripts/p398_tl_fattening.py | 244 ++++++++ scripts/rectangular_rank_odds.py | 204 ++++++ tests/test_p398_tl_fattening.py | 45 ++ tests/test_rectangular_rank_odds.py | 39 ++ 11 files changed, 2165 insertions(+) create mode 100644 notes/aspect-uniform-balance-consistency-20260912.md create mode 100644 notes/p398-is-periodic-tl-20260912.md create mode 100644 notes/root-tl-handoff-20260912.md create mode 100644 notes/root-tl-review-20260912-zh.md create mode 100644 notes/root-tl-source-audit-20260912.md create mode 100644 results/research-control-20260912/p398-tl-fattening.json create mode 100644 results/research-control-20260912/rectangular-rank-odds-controls.json create mode 100644 scripts/p398_tl_fattening.py create mode 100644 scripts/rectangular_rank_odds.py create mode 100644 tests/test_p398_tl_fattening.py create mode 100644 tests/test_rectangular_rank_odds.py diff --git a/notes/aspect-uniform-balance-consistency-20260912.md b/notes/aspect-uniform-balance-consistency-20260912.md new file mode 100644 index 00000000..4f9cb649 --- /dev/null +++ b/notes/aspect-uniform-balance-consistency-20260912.md @@ -0,0 +1,214 @@ +# Rectangular homological balance is consistent without an aspect-ratio bound + +2026-09-12. Direct continuation of #276/#613/#716. This is a mathematical +consequence of established subcritical sharpness and the repository's digital +Alexander identity. It is NOT a new numerical value of p_c, a claimed novel +sharpness theorem, or an inference from the width-2/3/4 spectra. + +## 1. The distinction and theorem + +Let G_(w,m) be the square-site NN graph on the axis torus with periods (w,0), +(0,m), integers m>=w>=2. Let r be its ambient rational H1 rank, P_j=Pr_p(r=j), +M=P_2-P_0 and F=(1+M)/2. Parallel lifted edges at period two are retained. +The matching complement graph is the NN+NNN graph on the same sites. + +The following established inputs are used: + +1. For site percolation on each infinite graph, every fixed subcritical p has + an exponential one-arm bound a_R(p)<=C(p) exp[-c(p)R]. Both graphs are + locally finite transitive finite-range graphs. See Duminil-Copin--Tassion, + arXiv:1502.03050v3, Theorem 1.1(3) and the explicit site adaptation in §1.2. + The main theorem there is printed in bond language; §1.2 is essential here. +2. p_c(NN)+p_c(NN+NNN)=1. Grimmett--Li, RSA 65 (2024), 832--856, + DOI 10.1002/rsa.21226, introduction Eqs. (1.1),(1.3) and the amenable + p_u=p_c discussion, supply the matching-pair relation with its provenance. +3. The repository's honest-torus digital-Alexander identity is configurationwise + r_NN(omega)+r_matching(omega^c)=2. This is not inferred from the new census. + +**Theorem.** The unique zero p_(w,m) of M satisfies + + lim_(w->infinity) sup_(m>=w) |p_(w,m)-p_c(NN)| = 0. (1) + +There is NO upper bound on m/w, and NO condition w/log(wm)->infinity in (1). +This improves the *root* conclusion on axis rectangles, not the full threshold- +distribution conclusion of #613. It does not extend the geometry to arbitrary +skew quotients without an additional strip construction. + +In fact define the conditional rank profile + + H_(w,m)(p)=P_2(p)/(P_0(p)+P_2(p)) = Pr(r=2 | r != 1). (2) + +This is strictly increasing from zero to one. Every compact set of its interior +quantiles converges uniformly to p_c, uniformly over all m>=w. H is NOT the +birth-time mixture F, and it is not proposed as a new independent observation. + +## 2. A local event with an embedded finite support + +Fix R>=1 with 2R+2<=w. For either infinite graph, let a_R be the unconditional +probability that the occupied origin is connected, inside the sup-norm box +[-R,R]^2, to its boundary. The root being occupied is included. + +For each torus vertex v, define A_v by the corresponding local lifted box. Its +vertices are distinct and its relevant edges coincide with the infinite graph: +2R+2<=w<=m rules out identification of the box and spurious boundary adjacency. +Therefore Pr(A_v)=a_R. If an occupied cycle has a nonzero winding class, its +lift cannot remain in that box. The initial segment up to first exit witnesses +A_v for a vertex on the cycle. In particular + + intersection_v A_v^c is contained in {r=0}. (3) + +All events A_v^c are decreasing. Harris positive association for product sites +gives, without pretending these overlapping boxes are independent, + + P_0 >= Pr(intersection_v A_v^c) >= (1-a_R)^(wm). (4) + +For completeness, association on finitely many independent Bernoulli variables +follows by induction: condition on the last variable; the conditional covariance +is nonnegative by induction, and the covariance of the two conditional means is +nonnegative because they are monotone in the same direction. Products of +nonnegative decreasing indicators remain decreasing, so iterate this result. + +This exponential LOWER bound is the step absent from the elementary union-bound +proof of full-law concentration. It remains meaningful even if wm a_R is huge. + +## 3. Disjoint slab crossings give the other exponential rate + +Take L=floor(m/(R+1)) disjoint slabs, with vertex rows + + y=k(R+1),...,k(R+1)+R, k=0,...,L-1. + +Let B_k be an occupied bottom-to-top crossing entirely in slab k, with the +horizontal coordinate periodic. The slabs share no vertex, so their B_k events +are independent under site product measure. Inter-slab edges are not part of +these events. + +If r=2, some occupied cycle has nonzero vertical winding. A vertically lifted +copy of it traverses each chosen slab. Between the last visit to the bottom +before a first visit to the top lies a path contained in that slab. The NN and +matching steps both change y by at most one. Thus + + {r=2} is contained in intersection_(k=0)^(L-1) B_k. (5) + +A slab crossing starts at one of w bottom vertices. Before a lift reaches the +top row at distance R, it reaches the boundary of an embedded radius-R box +about that starting vertex (possibly through a horizontal side first). This +is precisely an A_v event, so a union bound gives Pr(B_k)<=w a_R. No assumed +independence between possible starting vertices is used. +Consequently, whenever w a_R<1, + + P_2 <= (w a_R)^floor(m/(R+1)). (6) + +Since m>=w>=2R+2, floor(m/(R+1))>=m/[2(R+1)]. Combining (4),(6), + + P_2/P_0 <= exp[-m gamma_w], + gamma_w = -log(w a_R)/[2(R+1)] + w log(1-a_R). (7) + +The second term is NEGATIVE. It must not be dropped in a finite sign test. +Given a certified upper bound alpha>=a_R, one fully rational sufficient test is + + w alpha < (1-alpha)^[2w(R+1)]. (8) + +The executable checks compare these rationals exactly. A positive result is a +finite-width sign certificate for all m>=w, conditional on the validity of the +supplied arm upper bound. It does not itself determine a new numerical p_c. + +## 4. Proof of the aspect-uniform statement + +For fixed p=8. Exponential decay gives + + -log(w a_R)/[2(R+1)] >= [c R-log(Cw)]/[2(R+1)] -> c/2, + w log(1-a_R) -> 0. + +Hence gamma_w>=c/4>0 for all sufficiently large w. Equation (7) proves an +exponentially small ratio P_2/P_0 uniformly in m>=w, even if both probabilities +are themselves extremely small. In particular M(p)<0. + +For fixed p>p_c(NN), set p*=1-p0. +This uses actual site sharpness on the degree-eight graph, not a bond result +or a planar-drawing assertion about its crossing diagonals. + +Finite rank is increasing under occupied-set inclusion and is nonconstant. On +some empty-to-full chain an insertion changes the relevant increasing event; +that pivotal configuration has positive product probability at every interior +p. The finite Russo derivative is therefore strictly positive for Pr(r>0) +and for Pr(r=2). Thus P_0'<0, P_2'>0, and M'>0 on (0,1). Endpoints are -1,+1. +The unique M zero lies between p_c-epsilon and p_c+epsilon for all sufficiently +large w and EVERY m>=w. This proves (1). + +Moreover, H<=P_2/P_0 below p_c and 1-H<=P_0/P_2 above p_c. The same inequalities +uniformly trap all H quantiles in [delta,1-delta] for fixed delta>0. For a fixed +width the result does not assert that an inner m-limit of the matching roots +exists or equals a specific pTL eigenvalue crossing. If such limits exist, or +one chooses any accumulation point of the actual finite roots at each width, +all those choices converge to p_c as width tends to infinity. + +## 5. Why this does not contradict the thin-torus theorem + +Take w_j=j and m_j=ceil(exp(j^2)). The previous full/empty-row bounds imply +for every fixed p in (0,1): r->1, F(p)->1/2, and the equal mixture of the two +birth-time laws tends to (delta_0+delta_1)/2. In the SAME sequence, (1) gives + + p_(w_j,m_j)->p_c, + H_(w_j,m_j)(p)->1{p>p_c}, p!=p_c. (9) + +Thus the physical matching median can consistently target p_c while most of +its threshold mixture escapes to the endpoints. Sign/order of two rare sectors +is not equivalent to absolute concentration of the full law. +#613's original full-law theorem remains valid as stated. This result neither +shows its geometric condition necessary nor supplies a sharp condition for the +entire birth distribution. It supplies a less restrictive root theorem. + +## 6. Robustness to an intrinsic source and information accounting + +For a source s independent of p, zero tilted mean of X=r-1 is equivalent to + + ell(p)+2s=0, ell=log(P_2/P_0). (10) + +For any rectangular sequence w->infinity,m>=w, if |s|/m->0 then the exponential +sign margins on either side of p_c dominate 2s. Its source-balanced root also +converges to p_c. More generally H levels with |logit(u)|=o(m) obey the same +trapping along that sequence. This is an asymptotic statement, not permission +to change a frozen source/observer contract to get a preferred score. + +Conditioning is not a free precision gain. Write E=P_0+P_2. For a single +independent rank snapshot the Fisher information for p is exactly + + I_rank = (E')^2/[E(1-E)] + E (H')^2/[H(1-H)]. (11) + +Derive it directly from P_0=E(1-H), P_2=EH, P_1=1-E; the cross terms cancel. +The second term is E times the information in a conditionally retained sample. +At balance, M'=2E H', and that term equals (M')^2/E. A sharper-looking conditional +CDF does not remove the cost of seeing r!=1. This identity is for independent +one-p snapshots; it is not a lower bound for whole-permutation, conditional, +importance-sampling or exact-transfer estimators. + +## 7. Executed checks, and scope + +`scripts/rectangular_rank_odds.py` verifies the local-arm implication and each +required slab crossing on all 65,536 configurations of a 4x4 torus for BOTH NN +and NN+NNN graphs: 131,072 graph/configuration evaluations. Complementary rank +sum is checked on all 65,536 pairings. Exact probability versions of (4),(6), +and (11) are checked at p=1/10,1/3,1/2. Another 236 fixed structural graph cases +check larger embedded radii; they are not a size census or Monte Carlo run. +Three sign certificates use the elementary simple-path upper bound + + a_R <= d (d-1)^(R-1) p^(R+1), + +at (d,p,w,R)=(4,1/10,16,2),(8,1/20,16,2),(4,1/4,256,32). +Their approximate positive gamma margins are .0818820,.2524822,.0635379; +the signs are checked with rationals, not these decimals. + +These checks do not prove an asymptotic theorem by extrapolation. Sections 2--4 +do the mathematical work. No quantitative rate in w or certified numerical +interval for p_c is obtained because near-critical arm constants are not supplied. +No all-width spectral representation, CFT exponent, or ordinary/Jordan model +identification is needed. Novelty relative to published homological-estimator +proofs has not been established. + +Sources (primary text sections read): +- https://arxiv.org/html/1502.03050v3, Thm 1.1(3), §1.2 site adaptation. +- https://onlinelibrary.wiley.com/doi/10.1002/rsa.21226, Eqs. (1.1),(1.3), amenable case. +- Repository #276/#613 and #702 digital-Alexander scope; #716 supplies the + separate thin-geometry full-law contrast, not this relative-probability proof. diff --git a/notes/p398-is-periodic-tl-20260912.md b/notes/p398-is-periodic-tl-20260912.md new file mode 100644 index 00000000..930240b2 --- /dev/null +++ b/notes/p398-is-periodic-tl-20260912.md @@ -0,0 +1,206 @@ +# P398 is exactly a periodic identified-connectivity TL stochastic chain + +2026-09-12. Correction to #715 §Q3a and its review comment, with a constructive +all-width identification. No new process is defined. No generic realization +or integrability theorem is claimed as new. #709's specific input/output +certificates remain valid and acquire a precise existing-model interpretation. + +## 1. The literature comparison missed a change of representation + +#715 argues that TL acts on noncrossing matchings and is join-only, whereas +P398 acts on noncrossing partitions and contains detach moves. This does NOT +separate the processes. There is a standard fattening/medial bijection from +noncrossing partitions of w cyclic points to noncrossing perfect matchings +of 2w cyclic endpoints. Under that bijection the two halves of the TL generators +are exactly the point-detach and adjacent-join maps. + +The relevant published model is NOT the full faithful TL representation, not +a through-line sector sum, and not the cylinder's distinct-connectivity (DC) +representation. It is the periodic IDENTIFIED-CONNECTIVITY (IC), zero-defect, +loop-weight-one representation on disk link patterns, of dimension Catalan(w). +Pearce--Rittenberg--de Gier--Nienhuis (2002), arXiv:math-ph/0209017v2, +Eq. (2.15) together with the IC quotient discussion around (2.17), names it. +Cantini--Sportiello, arXiv:1003.3376v1, §2.2 Eq. (4), gives the exact reconnection +map without requiring interpretation of a drawing. + +The source's statement that lines may join without the reverse concerns the +algebra's line/defect filtration; it is not a statement that the induced map +on w-point set partitions can never detach a point. There are 2w local TL maps, +not w. Losing this factor of two hides the detach half. + +## 2. Explicit bijection and proof at every width + +Use zero-based indices i in Z/wZ. Replace point i by consecutive endpoints +L_i=2i and R_i=2i+1. For each block B={i_1,...,i_k}, ordered cyclically, connect + + R_(i_j) to L_(i_(j+1)), j modulo k. (1) + +For a singleton this is the adjacent pair (2i,2i+1). Call the resulting matching +Phi(pi). It is noncrossing: the curves can be drawn as the oriented boundary of +a small regular neighbourhood of the disjoint noncrossing block trees. + +Conversely a noncrossing perfect matching of 2w cyclic endpoints pairs opposite +parities (each arc contains an even number of endpoints on either side). +The map sigma(i)=mate(2i+1)/2 is a permutation. Its cycles give the original +blocks. In the disk picture these are precisely the components obtained by +contracting each L_i,R_i interval; noncrossing guarantees their cyclic successor +order and prevents interlacing blocks. This inverse recovers (1), proving a +bijection, not merely equality of Catalan counts. + +Let e_a on link patterns join adjacent endpoints a,b=a+1. If they are already +paired, it does nothing. Otherwise remove (a,c),(b,d) and replace them by +(a,b),(c,d), all indices modulo 2w. Then + + Phi(detach_i pi) = e_(2i) Phi(pi), + Phi(join_(i,i+1) pi) = e_(2i+1) Phi(pi). (2) + +For the first identity, the reconnection isolates L_i,R_i and reconnects the +predecessor and successor of i in its old block. For the second, it splices +the cyclic successor lists of the two neighbouring blocks. If the two points +were already in one block, they are consecutive within it, so e does nothing. +The argument includes i=w-1 at the cyclic seam. Contractible-loop weight is 1, +which is essential for no extra scalar coefficient in the no-op case. + +## 3. Generator, intervention, and boundary convention + +The repository Generator acts on functions, with row convention + + G_eta f(pi)=sum_i (1+eta)[f(join_i pi)-f(pi)] + +(1-eta)[f(detach_i pi)-f(pi)]. (3) + +Thus under Phi it is exactly the transpose of the standard column-state TL +intensity generator + + L_eta=sum_i [(1-eta)(E_(2i)-I)+(1+eta)(E_(2i+1)-I)]. (4) + +At eta=0 this is the homogeneous periodic dense O(1)/TL stochastic process on +2w endpoints, unit clock per generator. A discrete-time convention averaging +by 2w only rescales time. For eta!=0 it is an alternating-rate TL chain. No +integrability claim for that whole staggered family is inferred here. +The localized #709 pulse also maps exactly: + + H=J_0-J_(w-2) <-> E_1-E_(2w-3), (5) + +with the same function/state transpose convention. Being outside span{J,D} +does not put this perturbation outside the TL operator algebra. + +P398's IC disk quotient forgets front/back annular path distinctions. It must +NOT be substituted for #708's homology-preserving lifted torus closure. The +P398 process remains different from microscopic square-site percolation, and +its parameter eta is not thereby identified with occupation probability p. + +## 4. An exact half-step complement and new dictionary identities + +Let rho rotate all 2w endpoints by +1 and define K=Phi^-1 rho Phi. This is a +permutation of partition states, not generally an involution. If sigma is the +cyclic block-successor permutation and c(i)=i+1, then + + sigma_K=c sigma^-1, + K^2 = one-site cyclic rotation, + K^(2w)=id. (6) + +It is a Kreweras-type complement, with the indexing convention fixed by (6). +The old geometric reflection is a different symmetry; under Phi it reflects +endpoints a->2w-1-a. + +Equation (2) immediately gives + + K detach_i = join_i K, + K join_i = detach_(i+1) K. (7) + +Consequently the rate-pencils are conjugate: + + G_eta[pi,pi'] = G_(-eta)[K pi,K pi']. (8) + +They are exactly isospectral at eta and -eta. This holds for every width, and +for an arbitrary time-dependent eta(t), with the corresponding sign-reversed +schedule after conjugacy. It is not a fit from a finite parameter ladder. + +The readouts are transformed too, not silently held fixed. Write b(pi) for +number of blocks, s_i(pi) for the indicator that i is a singleton, and +c_i(pi)=1{pi_i=pi_(i+1)}. Then + + b(K pi)=w+1-b(pi), + s_(i+1)(K pi)=c_i(pi), + c_i(K pi)=s_i(pi). (9) + +The last two follow by tracking the corresponding adjacent matched pair. For +the first, the planar bipartite incidence map between the blocks and the +complementary blocks has w edges and one face; Euler's relation gives +cycles(sigma)+cycles(c sigma^-1)=w+1. Equivalently, draw each noncrossing block +as a tree in the disk: the complementary regions containing the interleaved +points are exactly the cycles of c sigma^-1, and each added tree edge increases +the number of such regions by one. There are w-b(pi) tree edges, so there are +w-b(pi)+1 complementary blocks. + +In particular the original wrap(pi)=1{pi_0=pi_(w-1)} becomes singleton_0 after K. +The declared three-readout dictionary is NOT K-invariant, so this does not +license a larger observable-admissible quotient than the one already certified. + +For any source mu, + + E^eta_mu[b(X_t)] + E^(-eta)_(K_*mu)[b(X_t)] = w+1. (10) + +Uniform source is K-invariant. Hence at eta=0 its expected block count is +(w+1)/2 at EVERY time, even though the uniform measure need not be stationary. +All-singleton and single-block source states are interchanged. The wrapped-pair +source generally maps to a state outside that short source list; retaining the +source transformation is essential. At stationarity for |eta|<1, + + pi_eta(pi)=pi_(-eta)(K pi), + E_(pi_eta)b + E_(pi_-eta)b = w+1. (11) + +## 5. A published all-width stationary description is now applicable + +Cantini--Sportiello's proof of the Razumov--Stroganov correspondence applies +exactly to the link-pattern operator in (4) at eta=0. In their notation, +§2.4 Eqs. (22)--(24), H_w=sum_(a=1)^(2w) e_a and the proved equality is +H_w |s_w>=2w |s_w>, where |s_w> counts square fully-packed loops refined by +boundary link pattern. Thus the P398 stationary law is + + pi_0(pi) = FPL_w(Phi(pi))/A_w, + A_w = product_(j=0)^(w-1) (3j+1)!/(w+j)!. (12) + +This is an import of their theorem, not a new proof or discovery. It describes +the pushforward of a static FPL ensemble; it does not construct a Markov dynamics +on FPL configurations conjugate to P398. No corresponding formula for arbitrary +eta is claimed. + +The exact independent stationary solves at widths 2,3,4,5 give primitive integer +normalizations 2,7,42,429, respectively. At w=4 the 14 weights take values 1,3,7; +at w=5 the 42 weights take values 1,4,6,14,17,42. These are consistency checks +of the identified model and theorem scope, not independent evidence for (12). +No large FPL enumeration or width extension is required to use the theorem. + +## 6. Executed verification and implications + +`scripts/p398_tl_fattening.py` constructs every matching at w=2..8 and verifies +its inverse partition map, all 31,040 join/detach conjugacy equalities, the seam, +all defining TL map relations, the half-step square, and each readout identity. +At w<=6 an independent restricted-growth partition enumeration gives the same +state set. Fraction stationary solves at w<=5 verify (11) also at eta=+/-1/4. +The full G and H matrices at w=4,5 were independently rebuilt from reconnections +and agree entrywise with the unchanged #709 analysis script in the supplied +archive. The previously certified double-pulse claims remain scoped as before; +we do not re-score or extend their rank certificates here. + +The statement in #715 that no named process matches P398 should be withdrawn. +Its realization-theory citations and the fact that #709 is a model/observer- +specific certificate remain useful. The positive outcome is not only a wording +correction: it gives an exact literature dictionary, the stationary FPL law, +and extra rate/readout transport constraints for subsequent work. + +The generic TL algebra can be nonsemisimple at this loop value, and different +representations have different Jordan structure. Neither the algebra's name +nor the stationary correspondence identifies a continuum field for #275, or +proves Jordan visibility in a particular P398 input/output channel. + +Primary sources read: +- Pearce--Rittenberg--de Gier--Nienhuis, J. Phys. A 35 (2002) L661--L668, + https://arxiv.org/html/math-ph/0209017v2, §2 Eqs. (2.15)--(2.17), §3. +- Cantini--Sportiello, JCTA 118 (2011) 1549--1574, + https://arxiv.org/html/1003.3376v1, §§2.2--2.4 and proof statement in §3. + Source's loop-parameter sign convention differs from the 2002 notation; + both specialize the deleted-loop multiplier to 1. +- Actual repository maps: main@eb89e942, scripts/planar_state_operations.py; + PR #709 head 83e011a7, existing G and H; #715 head 308f66c7 and its review. diff --git a/notes/root-tl-handoff-20260912.md b/notes/root-tl-handoff-20260912.md new file mode 100644 index 00000000..ca792f81 --- /dev/null +++ b/notes/root-tl-handoff-20260912.md @@ -0,0 +1,65 @@ +# Completed-analysis handoff for the existing issue channels + +2026-09-12. Prepared comments, NOT posted by this delivery. No new issue is needed +for the work completed here. Preserve earlier artifacts and author review holds. + +## #715 / #713: replace the negative process-identification paragraph + +The asserted P398/TL distinction is false after an explicit change of state representation. +For each w-point noncrossing block, pair the right endpoint of each point with the left +endpoint of its cyclic successor, using 2w endpoints. This bijection Phi obeys +`Phi D_i=e_(2i) Phi`, `Phi J_i=e_(2i+1) Phi`, with loop multiplier one. +P398 G is exactly the periodic identified-connectivity (IC), zero-defect O(1) TL +stochastic generator on 2w endpoints (transpose the standard column-state convention). +The DC/through-line representations are NOT interchangeable with this one. + +See `notes/p398-is-periodic-tl-20260912.md`. The all-width proof is local reconnection; +31,040 operations at w=2..8 and the entire archived w=4/5 G/H matrices were checked. +The half-step endpoint rotation also exchanges J/D and conjugates eta to -eta, +with necessary source/readout changes. Cantini--Sportiello's established RS theorem +supplies the eta=0 FPL-pushforward stationary law. The particular #709 pulse and +observer certificate remains a model-specific result; this correction neither +invalidates it nor certifies its novelty. No extra width table is commissioned. + +Retain #715's realization-theory/Volterra references. Revise only the process map and +its dependent framing. For deeper retrieval compare the exact S/F/H and IC boundary +condition, not labels such as partitions vs matchings or join-only vs join/detach. +This is the continuation of #713, not a second broad prior-art ticket. + +## #276 / #613 / #716: distinguish root consistency from full-law concentration + +For square-site axis rectangles m>=w>=2, the matching root satisfies +`lim_(w->infinity) sup_(m>=w) |p_(w,m)-p_c|=0`. +The proof uses site one-arm exponential decay on NN and its matching partner, +Harris association, disjoint slabs, and existing digital-Alexander rank duality. +The key bounds are `P0>=(1-a_R)^(wm)` and +`P2<=(w*a_R)^floor(m/(R+1))`, with R=floor(w/8). +They compare exponential RATES even when both P0 and P2 are tiny. + +The same claim holds for compact interior quantiles of `H=P2/(P0+P2)`; +H is not the birth-mixture CDF F. On w=j,m=ceil(exp(j^2)) the root still tends +to pc while the F distribution tends to half mass at each endpoint. +Thus #613's full-law condition stays intact, but it was unnecessarily strong +for the root alone on rectangles. No claim for arbitrary tilted quotients, +no numerical pc, no width-uniform critical exponent, and no all-width pTL map. + +See `notes/aspect-uniform-balance-consistency-20260912.md` for the proof and +`rectangular-rank-odds-controls.json` for finite controls. Re-running thin lengths +or the old #613 root proof is not the next task. Literature should compare this +precise all-aspect conditional-ratio theorem with published estimator consistency. +This retrieval can stay in the existing #276/#613/#716 discussion. + +## #594 / #598 / #600 / #610: use the correctly identified process + +The original reflection quotient and first-order parity rule are unaffected. +They now live inside a named periodic IC TL process. The local H from #709 is +`e_1-e_(2w-3)` in the same operator algebra, although outside span{J,D}. +Do not call P398 a new unknown process; do not call it square-site percolation. +The half-step complement is NOT generally an involution and the original +three-readout dictionary is NOT invariant under it. It therefore supplies +transport identities, not an automatic larger quotient for the unchanged task. + +The stationary FPL theorem gives exact baseline benchmarks at all widths without +a new enumeration program. Dynamic inserted matrix elements matching #709 are +still a distinct question for the ongoing primary retrieval. No new GPU or +large-CPU allocation follows from this handoff. diff --git a/notes/root-tl-review-20260912-zh.md b/notes/root-tl-review-20260912-zh.md new file mode 100644 index 00000000..42b3c90c --- /dev/null +++ b/notes/root-tl-review-20260912-zh.md @@ -0,0 +1,148 @@ +# 矩形匹配根的一致性与 P398 的 TL 身份：本轮复核及推进 + +日期：2026-09-12。源状态：#716 head `8f60bd28`；#715 head `308f66c7`； +#709 head `83e011a7`。仓库主线操作定义读取自 `main@eb89e942`。 +本轮没有合并、写入远端或覆盖已有产物。两项结果的推导、脚本和小规模核对已完成； +不应为同样的工作重新派单。文献新颖性没有得到认证。 + +## 1. 匹配根不需要全分布集中的几何条件 + +在轴向矩形环面 `(w,0),(0,m)` 上，令 `m>=w>=2`， +`P_j=Pr(r=j)`，`M=P_2-P_0`。已有严格单调性给出唯一匹配根 `p_(w,m)`。 +利用两张无限格子的点渗流亚临界指数衰减、amenable matching 临界概率关系， +以及已有有限 digital-Alexander 恒等式，证明了 + + lim_(w→∞) sup_(m>=w) |p_(w,m)-p_c(square-site)| = 0. + +不需要 `m/w` 有界，也不需要 `w/log(wm)→∞`。结论仅覆盖本证明的轴向矩形； +没有把任意倾斜商、宽度一致谱式或二维临界指数一起宣布解决。 + +### 真正新增的一步是比较稀有概率的指数率 + +取嵌入半径 `R=floor(w/8)`。设 `a_R` 为原点在局部方框中连接至边界的概率， +包括原点被占据。所有顶点都没有局部臂，足以保证 rank 为零。 +局部盒子并不独立；对它们的递减补事件使用 Harris 正关联得到 + + P_0 >= (1-a_R)^(wm). + +另一方面，rank 为二必须穿过每个高度为 R 的横向条带。 +取不共享站点的条带，才在这里使用独立性，得到 + + P_2 <= (w*a_R)^floor(m/(R+1)). + +因此在亚临界侧，充分大的 w 对所有 m>=w 同时满足 + + P_2/P_0 <= exp(-kappa(p)*m). + +超临界侧对 matching 补图使用同一论证，得到反向比率。 +两边绝对概率即使同时极小，也不妨碍它们的大小顺序稳定，故根被夹到 p_c。 + +这个论证不依赖宽度 2/3/4 的传递矩阵，也不依赖先证明所有宽度的圆柱极限存在。 +若某宽度的实际有限匹配根有多个内极限聚点，选择其中任意一个，随宽度增长也被同样夹逼。 +这不是对未建立的任意 pTL 特征值定义的一致性宣告。 + +### 与上一轮薄环面结果形成同模型的严格分离 + +取 `w_j=j,m_j=ceil(exp(j^2))`。同一序列同时有： + + 匹配根 -> p_c； + 条件剖面 H=P_2/(P_0+P_2) -> p_c 处的阶跃； + 无条件阈值混合分布 -> (delta_0+delta_1)/2。 + +所以 #613 全分布定理的条件不是错误，只是不必原样施加到匹配根上。 +中位数在弱极限下不连续，不能先取退化的 CDF 极限再反推有限根。 + +另外，若拓扑源与 p 无关且 `|s|/m→0`，源平衡根也一致。 +条件剖面很陡不代表获得免费信息：对单个独立 rank 快照，精确信息分解为 + + I_rank=(E')^2/[E(1-E)] + E*(H')^2/[H(1-H)], E=P_0+P_2。 + +保留非 rank-1 样本的条件信息必须乘以发生率 E。 +这不是全排列、条件化或精确转移估计器的计算复杂度下界。 + +## 2. #715 对 P398 的否定性识别需要撤回 + +检索稿和评审把“非交叉分区 vs 非交叉配对”、“含 detach vs join-only”当成模型不同的证据。 +这些描述在端点加倍的标准编码下实际上是同一个操作集合。 + +把站点 i 替成端点 `(L_i,R_i)=(2i,2i+1)`。每个块按圆周顺序，把 `R_i` 连到 +块内后继 j 的 `L_j`。得到 `w` 点非交叉分区与 `2w` 端点非交叉完美配对的显式双射 Phi。 +其局部操作满足 + + Phi D_i = e_(2i) Phi； + Phi J_i = e_(2i+1) Phi。 + +`e_a` 把相邻端点连成一对，并把它们原来的两个配对端点重新相连；已配对时是无操作， +闭环因子为 1。这直接证明所有宽度的算子共轭，不是仅用 Catalan 数相等来猜身份。 + +正确文献对象是 **2w 端点、零缺陷、periodic identified-connectivity（IC）圆盘 link patterns +上的 stochastic dense O(1)/Temperley–Lieb 链**。 +Pearce–Rittenberg–de Gier–Nienhuis 2002 的 Eq.(2.15) 和 IC 讨论给出边界约定， +Cantini–Sportiello 的 Eq.(4) 给出完全一致的重连操作。 +主线 G 使用行向量函数约定，文献经常使用列向量概率约定；矩阵需转置，单位时钟不变。 + +这个身份纠正并不把 P398 变成微观 square-site percolation。 +IC 会遗忘环形路径绕行的前后区别，不能替换 #708 为 rank 保存的提升连通状态。 +#709 的局部奇干预也仍在 TL 代数内：离开 `span{J,D}` 不等于离开整个算子代数。 +原双脉冲实例的秩证书不因此失效，但过程本身不应再被写作新定义的未知命名过程。 + +## 3. 身份识别带来可直接使用的额外结构 + +### 半步旋转使 eta 与 -eta 的整个动力学共轭 + +把 2w 个端点旋转一步，再解码回分区，得到 K。它是 Kreweras 型补映射， +但通常不是二阶对合：`K^2` 是站点旋转一步，`K^(2w)=id`。 + + K D_i = J_i K； K J_i = D_(i+1) K； + G_eta[pi,pi']=G_-eta[Kpi,Kpi']。 + +此式也适用于随时间变化的 eta(t) 干预。源和读出必须同步变换。 +若 b 是块数、s_i 是 singleton 指示、c_i 是相邻连通指示，则 + + b(Kpi)=w+1-b(pi)； + s_(i+1)(Kpi)=c_i(pi)； c_i(Kpi)=s_i(pi)。 + +原 `wrap` 因此映到 `singleton_0`，不是原样不动。 +对均匀初态，在 eta=0 的每个时刻，块数期望严格等于 `(w+1)/2`； +这不要求均匀初态是平稳分布。对任意初态有携带源变换的双参数响应恒等式。 +不能据此把原有不封闭的三个读出悄悄当成 K 不变字典。 + +### 已发表的全宽度平稳律可以导入 + +Cantini–Sportiello 的 Razumov–Stroganov 证明给出 + + pi_0(pi)=FPL_w(Phi(pi))/A_w， + A_w=product_(j=0)^(w-1) (3j+1)!/(w+j)!。 + +这里 FPL 是指定边界的完全填充环配置计数，按 link pattern 分类。 +本轮导入这一已有定理，未声称重新证明完整 FPL 定理；也未把这个静态推前分布 +误写成 FPL 配置上完整动力学的同构。任意交替速率 eta 的平稳公式仍不在本结论内。 + +独立 Fraction 平稳求解在 w=2,3,4,5 得到本原整数权重总和 2,7,42,429， +块数均值 3/2,2,5/2,3。这些是模型映射的核对，不是新发现的整数序列。 + +## 4. 本轮实际执行与未执行 + +- P398：w=2..8 全部状态，31,040 条 join/detach 逐操作共轭；包括周期接缝、全部 TL + 映射关系、半步旋转平方和读出恒等式。w<=6 又以独立受限增长序列枚举核对状态集。 +- w=2..5：精确 Fraction 平稳求解，另在 eta=±1/4 核对生成元与平稳律的共轭。 +- w=4,5：从 TL 重连独立重建 G/H，与未改动的 #709 脚本逐项相等。 +- 概率引理：4x4 上两张图各 65,536 个配置，共 131,072 次图/配置核对； + 补图 rank-sum 65,536 对；236 个较大支撑上的固定结构案例。 +- 三个正的有限符号证书使用简单路径并合界，所有符号用有理数检查； + 未把这些远离临界的控制当成 p_c 数值区间。 +- 16 项本地数学测试通过。最终补丁的应用、重生成与文件摘要见包外 `VALIDATION.json`。 +- 没有完整仓库 CI，没有新 Monte Carlo、GPU 或服务器操作。 + +## 5. 团队检索最值得核对的两个精确对象 + +第一项是上述 **不限制矩形长宽比的匹配根/条件扇区分位数一致性**。 +请比较实际命题与证明，而不是只查“homological percolation”或已知固定长宽比阈值。 +根一致性、rank 概率集中和 F 的全分布收敛必须分开。 + +第二项是在已知 **periodic IC O(1) TL 链** 上，与原 S/F/H 相同的动态矩阵元和两次局部生成元 +插入。#713/#715 可以继续承担这项文献映射；无需再为“P398 是否有命名过程”开重复单。 +特定有限观测证书是否已有先例仍需精确匹配，不能从本次过程同构推断其未发表或已发表。 + +当前已有 #711/#712/#714 分别覆盖谱、几何起点、热导数/Jordan 检索。 +本轮不新增平行文献任务，不因名称识别直接扩大宽度或采购计算资源。 diff --git a/notes/root-tl-source-audit-20260912.md b/notes/root-tl-source-audit-20260912.md new file mode 100644 index 00000000..b5f24ec7 --- /dev/null +++ b/notes/root-tl-source-audit-20260912.md @@ -0,0 +1,78 @@ +# Source and claim audit: root consistency / P398 TL identification + +2026-09-12. Status PRIMARY_TEXT_READ below means the stated sections and equations +were actually opened. It does not mean every proof in each paper was independently +reproved. No broad novelty search was performed. + +## Repository inputs actually read + +- #716, `8f60bd28e72eb2e00399bdb8f5528190dfb0f045`, thin-torus result and source modes. +- #715, `308f66c7c6e34af7feb4fb689f27dfccea3eefea`, + `notes/lit-double-pulse-observability-20260912.md`, especially Q3a. + Review comment `5646126309` repeats the negative P398/TL identification. +- #709, `83e011a7ceeab23b9ae5eab741f41ea15c983459`, + `scripts/p398_double_pulse_exact.py`, plus the already supplied unmodified archive. +- `main@eb89e9422791d9e3c3a78f0e65d56912b815a7bd`, + `scripts/planar_state_operations.py`: exact definitions of detach and cyclic join. +- #711--#714 retrieval tickets; #276/#613 probability contract. No replacement + retrieval tasks were created and no issue/PR lifecycle was changed. + +The reused #709 script copy has Git blob +`e211c5cf9e3677dd7f95c27deec5402723361f1b`, SHA256 +`975bd781a27a4e2f03fe84f15669b1cd8ac0b9030a6c86dd3cc378df6825bb28`. +The standalone archive check verifies that copy before comparing G/H; it is not +an assertion that a complete repository checkout or complete CI was executed. + +## Primary probability sources + +**Duminil-Copin--Tassion**, *A new proof of the sharpness of the phase transition +for Bernoulli percolation and the Ising model*, arXiv:1502.03050v3: +https://arxiv.org/html/1502.03050v3 +PRIMARY_TEXT_READ: Theorem 1.1, §1.2, specifically the paragraph Site percolation. +The finite-range exponential-decay conclusion and explicit site adaptation are +used. The printed bond-square pc=1/2 discussion is NOT used for square-site pc. +The present finite-torus probability-ratio bound is derived in our note; it is +not attributed as a theorem appearing in this source. + +**Grimmett--Li**, *Percolation critical probabilities of matching lattice-pairs*, +Random Structures & Algorithms 65 (2024) 832--856, DOI 10.1002/rsa.21226: +https://onlinelibrary.wiley.com/doi/10.1002/rsa.21226 +PRIMARY_TEXT_READ: introductory Eqs. (1.1),(1.3), amenable pc=pu passage, +and theorem context. The introduction carries its own provenance for the matching +relation. The square NN graph and NN+NNN matching graph satisfy the relevant +one-ended/transitive/amenable planar-primal setting. No nonamenable equality of +pc and pu is imported. + +## Primary process/representation sources + +**Pearce--Rittenberg--de Gier--Nienhuis**, *Temperley-Lieb Stochastic Processes*, +J. Phys. A 35 (2002) L661--L668, arXiv:math-ph/0209017v2: +https://arxiv.org/html/math-ph/0209017v2 +PRIMARY_TEXT_READ: §2 Eqs. (2.1),(2.4),(2.15)--(2.17), IC/DC distinction; +§3 stationary-conjecture context. The representation required here is periodic IC +at even endpoint number L=2w, dimension Catalan(w), not the larger DC space. +Its statement about irreversible joining in line filtrations does not rule out +point detach in a different state encoding. We establish the needed map directly. + +**Cantini--Sportiello**, *Proof of the Razumov-Stroganov conjecture*, +J. Combin. Theory A 118 (2011) 1549--1574, arXiv:1003.3376v1: +https://arxiv.org/html/1003.3376v1 +PRIMARY_TEXT_READ: §2.1 ASM/FPL normalization, §2.2 Eq. (4) reconnection, +§2.4 Eqs. (22)--(24), and proof statement in §3. The static FPL boundary-pattern +count vector is an eigenvector of sum e_i with eigenvalue 2w. The previously +conjectural periodic IC stationary correspondence is proved here. We import +that theorem after identifying the generator; we do not claim to have rechecked +the entire combinatorial proof or derived the alternating-rate stationary law. + +The arXiv HTMLs display a recent auto-rendered date in their body. Bibliographic +attribution uses the original arXiv version/publication dates above, not the +HTML rendering timestamp. No PDF parsing or figure interpretation was required. + +## Limits of the audit + +No originality certification for the fattening map, complement identities, +Hankel theory, the stationary law, or the all-aspect root consequence. The first +four are established structural ingredients. The last consequence has an explicit +proof and a precisely scoped novelty/retrieval question for the team. +Not observing a process name in a keyword search is not a no-go; the #715 mistake +is resolved by an actual conjugacy, not by finding a more similar abstract. diff --git a/results/research-control-20260912/p398-tl-fattening.json b/results/research-control-20260912/p398-tl-fattening.json new file mode 100644 index 00000000..0a44b65b --- /dev/null +++ b/results/research-control-20260912/p398-tl-fattening.json @@ -0,0 +1,588 @@ +{ + "schema": "matching-one.p398-tl-identification.v1", + "status": "constructive all-width identity; finite controls not a novelty claim", + "map": "detach_i <-> e_(2i); join_i <-> e_(2i+1), zero-based; loop weight 1", + "boundary": "periodic identified-connectivity disk link patterns, 2w endpoints", + "row_generator": "sum_a (E_a-I)^T in the standard column-state TL convention", + "total_move_equalities": 31040, + "widths": [ + { + "width": 2, + "states": 2, + "move_equalities": 8, + "bijection_and_cyclic_seam": true, + "TL_relations": true, + "half_step_square_is_site_rotation": true, + "rate_swap_and_observer_identities": true, + "stationary": { + "states_lexicographic": [ + [ + 0, + 0 + ], + [ + 0, + 1 + ] + ], + "primitive_integer_weights": [ + 1, + 1 + ], + "weight_sum": 2, + "ASM_product": 2, + "mean_blocks": "3/2", + "eta_quarter_law_conjugacy": true + } + }, + { + "width": 3, + "states": 5, + "move_equalities": 30, + "bijection_and_cyclic_seam": true, + "TL_relations": true, + "half_step_square_is_site_rotation": true, + "rate_swap_and_observer_identities": true, + "stationary": { + "states_lexicographic": [ + [ + 0, + 0, + 0 + ], + [ + 0, + 0, + 1 + ], + [ + 0, + 1, + 0 + ], + [ + 0, + 1, + 1 + ], + [ + 0, + 1, + 2 + ] + ], + "primitive_integer_weights": [ + 2, + 1, + 1, + 1, + 2 + ], + "weight_sum": 7, + "ASM_product": 7, + "mean_blocks": "2", + "eta_quarter_law_conjugacy": true + } + }, + { + "width": 4, + "states": 14, + "move_equalities": 112, + "bijection_and_cyclic_seam": true, + "TL_relations": true, + "half_step_square_is_site_rotation": true, + "rate_swap_and_observer_identities": true, + "stationary": { + "states_lexicographic": [ + [ + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 1, + 2 + ], + [ + 0, + 1, + 0, + 0 + ], + [ + 0, + 1, + 0, + 2 + ], + [ + 0, + 1, + 1, + 0 + ], + [ + 0, + 1, + 1, + 1 + ], + [ + 0, + 1, + 1, + 2 + ], + [ + 0, + 1, + 2, + 0 + ], + [ + 0, + 1, + 2, + 1 + ], + [ + 0, + 1, + 2, + 2 + ], + [ + 0, + 1, + 2, + 3 + ] + ], + "primitive_integer_weights": [ + 7, + 3, + 3, + 1, + 3, + 3, + 1, + 1, + 3, + 3, + 3, + 1, + 3, + 7 + ], + "weight_sum": 42, + "ASM_product": 42, + "mean_blocks": "5/2", + "eta_quarter_law_conjugacy": true + } + }, + { + "width": 5, + "states": 42, + "move_equalities": 420, + "bijection_and_cyclic_seam": true, + "TL_relations": true, + "half_step_square_is_site_rotation": true, + "rate_swap_and_observer_identities": true, + "stationary": { + "states_lexicographic": [ + [ + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 1, + 2 + ], + [ + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 2 + ], + [ + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 0, + 1, + 1, + 1 + ], + [ + 0, + 0, + 1, + 1, + 2 + ], + [ + 0, + 0, + 1, + 2, + 0 + ], + [ + 0, + 0, + 1, + 2, + 1 + ], + [ + 0, + 0, + 1, + 2, + 2 + ], + [ + 0, + 0, + 1, + 2, + 3 + ], + [ + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0, + 2 + ], + [ + 0, + 1, + 0, + 2, + 0 + ], + [ + 0, + 1, + 0, + 2, + 2 + ], + [ + 0, + 1, + 0, + 2, + 3 + ], + [ + 0, + 1, + 1, + 0, + 0 + ], + [ + 0, + 1, + 1, + 0, + 2 + ], + [ + 0, + 1, + 1, + 1, + 0 + ], + [ + 0, + 1, + 1, + 1, + 1 + ], + [ + 0, + 1, + 1, + 1, + 2 + ], + [ + 0, + 1, + 1, + 2, + 0 + ], + [ + 0, + 1, + 1, + 2, + 1 + ], + [ + 0, + 1, + 1, + 2, + 2 + ], + [ + 0, + 1, + 1, + 2, + 3 + ], + [ + 0, + 1, + 2, + 0, + 0 + ], + [ + 0, + 1, + 2, + 0, + 3 + ], + [ + 0, + 1, + 2, + 1, + 0 + ], + [ + 0, + 1, + 2, + 1, + 1 + ], + [ + 0, + 1, + 2, + 1, + 3 + ], + [ + 0, + 1, + 2, + 2, + 0 + ], + [ + 0, + 1, + 2, + 2, + 1 + ], + [ + 0, + 1, + 2, + 2, + 2 + ], + [ + 0, + 1, + 2, + 2, + 3 + ], + [ + 0, + 1, + 2, + 3, + 0 + ], + [ + 0, + 1, + 2, + 3, + 1 + ], + [ + 0, + 1, + 2, + 3, + 2 + ], + [ + 0, + 1, + 2, + 3, + 3 + ], + [ + 0, + 1, + 2, + 3, + 4 + ] + ], + "primitive_integer_weights": [ + 42, + 17, + 17, + 4, + 14, + 17, + 6, + 4, + 4, + 6, + 14, + 1, + 6, + 17, + 17, + 6, + 6, + 1, + 4, + 4, + 1, + 4, + 17, + 14, + 6, + 6, + 6, + 17, + 14, + 4, + 1, + 6, + 4, + 6, + 1, + 14, + 17, + 17, + 4, + 4, + 17, + 42 + ], + "weight_sum": 429, + "ASM_product": 429, + "mean_blocks": "3", + "eta_quarter_law_conjugacy": true + } + }, + { + "width": 6, + "states": 132, + "move_equalities": 1584, + "bijection_and_cyclic_seam": true, + "TL_relations": true, + "half_step_square_is_site_rotation": true, + "rate_swap_and_observer_identities": true + }, + { + "width": 7, + "states": 429, + "move_equalities": 6006, + "bijection_and_cyclic_seam": true, + "TL_relations": true, + "half_step_square_is_site_rotation": true, + "rate_swap_and_observer_identities": true + }, + { + "width": 8, + "states": 1430, + "move_equalities": 22880, + "bijection_and_cyclic_seam": true, + "TL_relations": true, + "half_step_square_is_site_rotation": true, + "rate_swap_and_observer_identities": true + } + ], + "elapsed_seconds": 1.1160894289999987 +} diff --git a/results/research-control-20260912/rectangular-rank-odds-controls.json b/results/research-control-20260912/rectangular-rank-odds-controls.json new file mode 100644 index 00000000..91b1bd5d --- /dev/null +++ b/results/research-control-20260912/rectangular-rank-odds-controls.json @@ -0,0 +1,334 @@ +{ + "schema": "matching-one.rectangle-rank-odds-controls.v1", + "status": "finite controls for a proof using Harris association and subcritical one-arm decay", + "sign_certificates": [ + { + "width": 16, + "radius": 2, + "one_arm_upper_bound": "3/250", + "slab_upper_bound": "24/125", + "comparison_exponent": 96, + "exact_margin_positive": true, + "uniform_sign_certified": true, + "exact_margin_expression": "(1-alpha)^(2*w*(R+1))-w*alpha", + "margin_numerator_bits": 762, + "margin_denominator_bits": 765, + "gamma_diagnostic": 0.08188201807741816, + "scope": "all integer lengths m>=width, if the supplied one-arm upper bound is valid", + "p": "1/10", + "graph_degree": 4, + "input_certificate": "simple-path union bound; no unknown empirical constant" + }, + { + "width": 16, + "radius": 2, + "one_arm_upper_bound": "7/1000", + "slab_upper_bound": "14/125", + "comparison_exponent": 96, + "exact_margin_positive": true, + "uniform_sign_certified": true, + "exact_margin_expression": "(1-alpha)^(2*w*(R+1))-w*alpha", + "margin_numerator_bits": 956, + "margin_denominator_bits": 957, + "gamma_diagnostic": 0.2524822289564091, + "scope": "all integer lengths m>=width, if the supplied one-arm upper bound is valid", + "p": "1/20", + "graph_degree": 8, + "input_certificate": "simple-path union bound; no unknown empirical constant" + }, + { + "width": 256, + "radius": 32, + "one_arm_upper_bound": "617673396283947/18446744073709551616", + "slab_upper_bound": "617673396283947/72057594037927936", + "comparison_exponent": 16896, + "exact_margin_positive": true, + "uniform_sign_certified": true, + "exact_margin_expression": "(1-alpha)^(2*w*(R+1))-w*alpha", + "margin_numerator_bits": 1081344, + "margin_denominator_bits": 1081345, + "gamma_diagnostic": 0.0635379337724439, + "scope": "all integer lengths m>=width, if the supplied one-arm upper bound is valid", + "p": "1/4", + "graph_degree": 4, + "input_certificate": "simple-path union bound; no unknown empirical constant" + } + ], + "tiny_controls": { + "exhaustive_graph_configurations": 131072, + "models": [ + { + "graph": "NN", + "width": 4, + "length": 4, + "configurations_checked": 65536, + "rank_totals": [ + 36559, + 19932, + 9045 + ], + "rank_counts_by_occupation": [ + [ + 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 + ] + ], + "comparisons": [ + { + "p": "1/10", + "P0": "9991754668952271/10000000000000000", + "P2": "21871721557/10000000000000000", + "all_no_arm_probability": "7757756385390567/10000000000000000", + "FKG_P0_lower": "57125244999226064840458852424351587369729378632991366165872845135126086326536961/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "exact_slab_crossing_probability": "3940399/100000000", + "independent_slab_P2_upper": "15526744279201/10000000000000000", + "one_arm_slab_P2_upper": "11826721/625000000", + "inequalities_exact": true, + "information": { + "E": "2497944135168457/2500000000000000", + "conditional_H": "21871721557/9991776540673828", + "H_derivative": "987191831432577261272963400/6239724902422490575327767760849", + "rank_Fisher_information": "6143435284913078065077485213751278592999/4529984725189184474100677907769531250000", + "activity_information": "1052561389234309746278400/782721459937802876426191", + "conditional_information_per_original_snapshot": "412601276925606715777222030116677861151333561/36112282522064154182569722327247124105468750000", + "exact_decomposition": true + } + }, + { + "p": "1/3", + "P0": "38405120/43046721", + "P2": "484673/43046721", + "all_no_arm_probability": "4997632/43046721", + "FKG_P0_lower": "1015593790680526778210669542150045696/147808829414345923316083210206383297601", + "exact_slab_crossing_probability": "2465/6561", + "independent_slab_P2_upper": "6076225/43046721", + "one_arm_slab_P2_upper": "1", + "inequalities_exact": true, + "information": { + "E": "38889793/43046721", + "conditional_H": "484673/38889793", + "H_derivative": "397877045796864/1512415999582849", + "rank_Fisher_information": "1336299246146238349312/78432416299914739335", + "activity_information": "3775488196608/315746229367", + "conditional_information_per_original_snapshot": "1908590658420618885136384/375689177779715498261745", + "exact_decomposition": true + } + }, + { + "p": "1/2", + "P0": "36559/65536", + "P2": "9045/65536", + "all_no_arm_probability": "743/65536", + "FKG_P0_lower": "48661191875666868481/1208925819614629174706176", + "exact_slab_crossing_probability": "175/256", + "independent_slab_P2_upper": "30625/65536", + "one_arm_slab_P2_upper": "1", + "inequalities_exact": true, + "information": { + "E": "11401/16384", + "conditional_H": "9045/45604", + "H_derivative": "324024008/129982801", + "rank_Fisher_information": "285878389994501/8788049495280", + "activity_information": "303038464/56811183", + "conditional_information_per_original_snapshot": "1640493090006001/60320621490480", + "exact_decomposition": true + } + } + ] + }, + { + "graph": "NN+NNN", + "width": 4, + "length": 4, + "configurations_checked": 65536, + "rank_totals": [ + 9045, + 19932, + 36559 + ], + "rank_counts_by_occupation": [ + [ + 1, + 16, + 120, + 560, + 1660, + 2864, + 2512, + 1088, + 208, + 16, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 160, + 1472, + 4704, + 6368, + 4580, + 1984, + 560, + 96, + 8, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 32, + 792, + 3984, + 8082, + 9440, + 7448, + 4272, + 1812, + 560, + 120, + 16, + 1 + ] + ], + "comparisons": [ + { + "p": "1/10", + "P0": "9883835992257237/10000000000000000", + "P2": "5706487944271/10000000000000000", + "all_no_arm_probability": "1310755478808321/2000000000000000", + "FKG_P0_lower": "391319373606687166436978500344352160054307264910131730112040840907935053064903471120510245371570176092135566619752440438163794319228883299435521/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "exact_slab_crossing_probability": "9700957/100000000", + "independent_slab_P2_upper": "94108566715849/10000000000000000", + "one_arm_slab_P2_upper": "3243675988851841/62500000000000000", + "inequalities_exact": true, + "information": { + "E": "2472385620050377/2500000000000000", + "conditional_H": "5706487944271/9889542480201508", + "H_derivative": "183365646427128935448645251400/6112690654231887140760017842129", + "rank_Fisher_information": "3019210155746209482514285419839936789062839/193875156471805977026690640186207031250000", + "activity_information": "145993522681620331613798400/10405943590009961780213711", + "conditional_information_per_original_snapshot": "175743143482839124245345308494994274726958713321/113886727023072268204288429584738295667968750000", + "exact_decomposition": true + } + }, + { + "p": "1/3", + "P0": "22992896/43046721", + "P2": "6841025/43046721", + "all_no_arm_probability": "1949696/43046721", + "FKG_P0_lower": "1052589578584345138319489682257975621399266243613939167696320004096/507528786056415600719754159741696356908742250191663887263627442114881", + "exact_slab_crossing_probability": "49/81", + "independent_slab_P2_upper": "2401/6561", + "one_arm_slab_P2_upper": "1", + "inequalities_exact": true, + "information": { + "E": "29833921/43046721", + "conditional_H": "6841025/29833921", + "H_derivative": "2634327093869568/890062842234241", + "rank_Fisher_information": "6839207869549555816448/168532956573741168075", + "activity_information": "19176971309568/3079606495225", + "conditional_information_per_original_snapshot": "41833521638064740867138048/1217728000076876890965675", + "exact_decomposition": true + } + }, + { + "p": "1/2", + "P0": "9045/65536", + "P2": "36559/65536", + "all_no_arm_probability": "133/65536", + "FKG_P0_lower": "362184594182720980613658216570962841601/22300745198530623141535718272648361505980416", + "exact_slab_crossing_probability": "221/256", + "independent_slab_P2_upper": "48841/65536", + "one_arm_slab_P2_upper": "1", + "inequalities_exact": true, + "information": { + "E": "11401/16384", + "conditional_H": "36559/45604", + "H_derivative": "324024008/129982801", + "rank_Fisher_information": "285878389994501/8788049495280", + "activity_information": "303038464/56811183", + "conditional_information_per_original_snapshot": "1640493090006001/60320621490480", + "exact_decomposition": true + } + } + ] + } + ], + "complementary_rank_sum_checked": 65536, + "additional_structural_graph_cases": 236 + }, + "limits": [ + "No numerical p_c interval or rate near criticality is inferred.", + "The all-aspect root theorem is proved in the accompanying note, not from these sizes.", + "Fisher decomposition concerns independent one-p snapshots, not full permutation paths." + ], + "elapsed_seconds": 1.4845421620000252 +} diff --git a/scripts/p398_tl_fattening.py b/scripts/p398_tl_fattening.py new file mode 100644 index 00000000..b8adeb7e --- /dev/null +++ b/scripts/p398_tl_fattening.py @@ -0,0 +1,244 @@ +#!/usr/bin/env python3 +"""P398 is the periodic identified-connectivity O(1) TL chain on 2w ends. + +Constructive all-width map; bounded exhaustive checks at w=2..8. No simulation. +Row generators act on functions. A deterministic map contributes Q_map-I. +Fattening identifies detach_i with e_(2i), join_i with e_(2i+1), 0-based. +The half-step rotation exchanges the two rate families, not arbitrary readouts. +""" +from __future__ import annotations +import argparse +from collections import Counter +from fractions import Fraction +from functools import lru_cache +from itertools import combinations +import json +from math import comb, factorial, gcd, lcm +from pathlib import Path +import time +from typing import Sequence + +State = tuple[int, ...] + + +def canonical(values: Sequence[int]) -> State: + labels: dict[int, int] = {} + return tuple(labels.setdefault(value, len(labels)) for value in values) + + +@lru_cache(None) +def link_patterns(ends: int) -> tuple[State, ...]: + if type(ends) is not int or ends < 0 or ends % 2: + raise ValueError('a nonnegative even endpoint count is required') + if not ends: + return ((),) + result = [] + for mate in range(1, ends, 2): + for inside in link_patterns(mate-1): + for outside in link_patterns(ends-mate-1): + p = [-1]*ends + p[0], p[mate] = mate, 0 + for i,j in enumerate(inside): p[i+1] = j+1 + for i,j in enumerate(outside): p[i+mate+1] = j+mate+1 + result.append(tuple(p)) + return tuple(result) + + +def fatten(state: Sequence[int]) -> State: + """Block cyclic successor i->j gives a pair (2i+1,2j).""" + if not state: + return () + state = canonical(state) + p = [-1]*(2*len(state)) + for label in range(max(state)+1): + vertices = [i for i,x in enumerate(state) if x == label] + for i,j in zip(vertices, vertices[1:]+vertices[:1]): + p[2*i+1], p[2*j] = 2*j, 2*i+1 + return tuple(p) + + +def unfatten(pairing: Sequence[int]) -> State: + n = len(pairing) + if n % 2 or any(type(j) is not int or not 0 <= j < n + or pairing[j] != i or j == i or (i+j)%2 != 1 + for i,j in enumerate(pairing)): + raise ValueError('expected a bipartite fixed-point-free pairing') + labels = [-1]*(n//2) + for i in range(n//2): + if labels[i] >= 0: continue + j = i + while labels[j] < 0: + labels[j] = i + j = pairing[2*j+1]//2 + return canonical(labels) + + +def join(state: Sequence[int], i: int) -> State: + if not 0 <= i < len(state): raise ValueError('point outside state') + a,b = state[i],state[(i+1)%len(state)] + return canonical([a if x == b else x for x in state]) + + +def detach(state: Sequence[int], i: int) -> State: + if not 0 <= i < len(state): raise ValueError('point outside state') + q = list(state); q[i] = max(state)+1 + return canonical(q) + + +def tl_reconnect(pairing: Sequence[int], a: int) -> State: + n = len(pairing) + if not 0 <= a < n: raise ValueError('endpoint outside pairing') + b = (a+1)%n + c,d = pairing[a],pairing[b] + if c == b: return tuple(pairing) + q = list(pairing) + q[a],q[b],q[c],q[d] = b,a,d,c + return tuple(q) + + +def rotate(pairing: Sequence[int], shift: int = 1) -> State: + n = len(pairing) + if not n: return () + q = [-1]*n + for i,j in enumerate(pairing): q[(i+shift)%n] = (j+shift)%n + return tuple(q) + + +def half_step(state: Sequence[int]) -> State: + return unfatten(rotate(fatten(state))) + + +def reflection(pairing: Sequence[int]) -> State: + n=len(pairing); q=[-1]*n + for i,j in enumerate(pairing): q[n-1-i] = n-1-j + return tuple(q) + + +def independent_rgs(width: int) -> list[State]: + """Independent restricted-growth enumeration, only used at widths <=6.""" + quads=list(combinations(range(width),4)) + result=[] + def grow(prefix: State): + if len(prefix) == width: + if not any(prefix[a]==prefix[c] and prefix[b]==prefix[d] + and prefix[a]!=prefix[b] for a,b,c,d in quads): + result.append(prefix) + return + for k in range(max(prefix, default=-1)+2): grow(prefix+(k,)) + grow(()) + return result + + +def state_space(width: int) -> list[State]: + if type(width) is not int or not 2 <= width <= 8: + raise ValueError('bounded executable controls require width 2..8') + return sorted(unfatten(p) for p in link_patterns(2*width)) + + +def generator(states: Sequence[State], eta: Fraction = Fraction(0)) -> list[list[Fraction]]: + if abs(eta)>1: raise ValueError('Markov rates require |eta|<=1') + n=len(states);w=len(states[0]);index={s:i for i,s in enumerate(states)} + out=[[Fraction(0)]*n for _ in range(n)] + for row,s in enumerate(states): + for i in range(w): + for fn,rate in ((join,1+eta),(detach,1-eta)): + out[row][index[fn(s,i)]] += rate + out[row][row] -= rate + return out + + +def stationary(g: list[list[Fraction]]) -> list[Fraction]: + n=len(g) + a=[[g[i][j] for i in range(n)]+[Fraction(0)] for j in range(n)] + a[-1]=[Fraction(1)]*(n+1) + for k in range(n): + pivot=next((j for j in range(k,n) if a[j][k]),None) + if pivot is None: raise ValueError('stationary system singular') + a[k],a[pivot]=a[pivot],a[k] + div=a[k][k];a[k]=[x/div for x in a[k]] + for j in range(n): + if j != k and a[j][k]: + mult=a[j][k];a[j]=[x-mult*y for x,y in zip(a[j],a[k])] + pi=[row[-1] for row in a] + assert sum(pi)==1 and min(pi)>0 + assert all(sum(pi[i]*g[i][j] for i in range(n))==0 for j in range(n)) + return pi + + +def asm_number(width: int) -> int: + ans=Fraction(1) + for j in range(width): ans*=Fraction(factorial(3*j+1),factorial(width+j)) + if ans.denominator!=1: raise AssertionError('ASM product not integral') + return ans.numerator + + +def report(max_width: int = 8) -> dict: + if not 2 <= max_width <= 8: raise ValueError('max_width must be 2..8') + start=time.perf_counter();rows=[];total_moves=0 + for w in range(2,max_width+1): + ss=state_space(w);pairset=set(link_patterns(2*w));n=len(ss) + assert n==len(set(ss))==comb(2*w,w)//(w+1) + if w<=6: assert ss==independent_rgs(w) + for s in ss: + p=fatten(s);k=half_step(s) + assert p in pairset and unfatten(p)==s and fatten(unfatten(p))==p + assert max(k)+max(s)+2==w+1 + assert fatten(canonical(s[::-1]))==reflection(p) + assert half_step(k)==canonical((s[-1],)+s[:-1]) + for i in range(w): + assert fatten(detach(s,i))==tl_reconnect(p,2*i) + assert fatten(join(s,i))==tl_reconnect(p,2*i+1) + assert half_step(detach(s,i))==join(k,i) + assert half_step(join(s,i))==detach(k,(i+1)%w) + assert int(s[i]==s[(i+1)%w])==int(k.count(k[(i+1)%w])==1) + assert int(s.count(s[i])==1)==int(k[i]==k[(i+1)%w]) + # Named TL relations: idempotence, adjacent sandwich and distant commuting. + for a in range(2*w): + e=tl_reconnect(p,a) + assert tl_reconnect(e,a)==e + for b in ((a-1)%(2*w),(a+1)%(2*w)): + assert tl_reconnect(tl_reconnect(e,b),a)==e + for b in range(a+1,2*w): + if (b-a)%(2*w) not in (1,2*w-1): + assert tl_reconnect(e,b)==tl_reconnect(tl_reconnect(p,b),a) + item={'width':w,'states':n,'move_equalities':2*w*n, + 'bijection_and_cyclic_seam':True,'TL_relations':True, + 'half_step_square_is_site_rotation':True, + 'rate_swap_and_observer_identities':True} + total_moves+=2*w*n + if w<=5: + g=generator(ss);pi=stationary(g) + den=lcm(*(q.denominator for q in pi));ivec=[int(q*den) for q in pi] + common=gcd(*ivec);ivec=[x//common for x in ivec] + assert sum(ivec)==asm_number(w) + mean=sum(q*(max(s)+1) for q,s in zip(pi,ss)) + assert mean==Fraction(w+1,2) + index={s:i for i,s in enumerate(ss)};perm=[index[half_step(s)] for s in ss] + gp=generator(ss,Fraction(1,4));gm=generator(ss,Fraction(-1,4)) + assert all(gp[i][j]==gm[perm[i]][perm[j]] for i in range(n) for j in range(n)) + pp,pm=stationary(gp),stationary(gm) + assert all(pp[i]==pm[perm[i]] for i in range(n)) + item['stationary']={'states_lexicographic':[list(s) for s in ss], + 'primitive_integer_weights':ivec,'weight_sum':sum(ivec), + 'ASM_product':asm_number(w),'mean_blocks':str(mean), + 'eta_quarter_law_conjugacy':True} + rows.append(item) + return {'schema':'matching-one.p398-tl-identification.v1', + 'status':'constructive all-width identity; finite controls not a novelty claim', + 'map':'detach_i <-> e_(2i); join_i <-> e_(2i+1), zero-based; loop weight 1', + 'boundary':'periodic identified-connectivity disk link patterns, 2w endpoints', + 'row_generator':'sum_a (E_a-I)^T in the standard column-state TL convention', + 'total_move_equalities':total_moves,'widths':rows, + 'elapsed_seconds':time.perf_counter()-start} + + +def main() -> None: + ap=argparse.ArgumentParser(description=__doc__) + ap.add_argument('--out',type=Path);ap.add_argument('--max-width',type=int,default=8) + args=ap.parse_args();text=json.dumps(report(args.max_width),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/rectangular_rank_odds.py b/scripts/rectangular_rank_odds.py new file mode 100644 index 00000000..fd893626 --- /dev/null +++ b/scripts/rectangular_rank_odds.py @@ -0,0 +1,204 @@ +#!/usr/bin/env python3 +"""Finite controls for aspect-uniform homological-balance consistency. + +The all-width theorem is in the accompanying proof, not an extrapolation of +these tiny tables. Uses exact integers/Fractions; no Monte Carlo, no p_c fit. +""" +from __future__ import annotations +import argparse +from fractions import Fraction as F +import json +from math import log, log1p +from pathlib import Path +import time + + +def steps(matching: bool): + out=[(1,0),(-1,0),(0,1),(0,-1)] + if matching:out += [(1,1),(1,-1),(-1,1),(-1,-1)] + return out + + +def lifted_rank(mask: int, width: int, length: int, matching: bool=False) -> int: + """Physical integer lifts, independent of local-arm / slab classification.""" + if min(width,length)<2 or mask<0 or mask>>(width*length): + raise ValueError('invalid periodic graph') + pos={};direction=None + for root in range(width*length): + if root in pos or not (mask>>root)&1:continue + pos[root]=(0,0);stack=[root] + while stack: + v=stack.pop();x,y=v%width,v//width;px,py=pos[v] + for dx,dy in steps(matching): + u=((y+dy)%length)*width+(x+dx)%width + if not (mask>>u)&1:continue + candidate=(px+dx,py+dy) + if u not in pos:pos[u]=candidate;stack.append(u) + else: + a,b=candidate[0]-pos[u][0],candidate[1]-pos[u][1] + assert a%width==0 and b%length==0 + a,b=a//width,b//length + if a or b: + if direction is None:direction=(a,b) + elif direction[0]*b-direction[1]*a:return 2 + return int(direction is not None) + + +def local_arm(mask: int,w: int,m: int,v: int,radius: int,matching: bool) -> bool: + if radius<1 or 2*radius+2>min(w,m):raise ValueError('local box is not embedded') + x0,y0=v%w,v//w + if not (mask>>v)&1:return False + seen={(0,0)};stack=[(0,0)] + while stack: + x,y=stack.pop() + if max(abs(x),abs(y))==radius:return True + for dx,dy in steps(matching): + a,b=x+dx,y+dy + if max(abs(a),abs(b))>radius or (a,b) in seen:continue + u=((y0+b)%m)*w+(x0+a)%w + if (mask>>u)&1:seen.add((a,b));stack.append((a,b)) + return False + + +def slab_crossing(mask: int,w: int,m: int,y0: int,radius: int,matching: bool) -> bool: + if not 0<=y0<=m-radius-1:raise ValueError('slab crosses the closing seam') + seen={(x,0) for x in range(w) if (mask>>(y0*w+x))&1};stack=list(seen) + while stack: + x,y=stack.pop() + if y==radius:return True + for dx,dy in steps(matching): + a,b=(x+dx)%w,y+dy + if not 0<=b<=radius or (a,b) in seen:continue + if (mask>>((y0+b)*w+a))&1:seen.add((a,b));stack.append((a,b)) + return False + + +def path_arm_bound(degree: int,p: F,radius: int) -> F: + if degree<2 or not 0 dict: + """An upper bound alpha on the unconditional local one-arm probability. + + Exact positive margin implies P2/P0 <= exp(-gamma*m)<1 for EVERY m>=w. + No claim is made that any arbitrary supplied alpha bounds a physical law. + """ + if type(width) is not int or type(radius) is not int or radius<1 or width<2*radius+2: + raise ValueError('require 1<=R and 2R+2<=width') + if not 00) + return {'width':width,'radius':radius,'one_arm_upper_bound':str(alpha), + 'slab_upper_bound':str(q),'comparison_exponent':exponent, + 'exact_margin_positive':margin>0,'uniform_sign_certified':holds, + 'exact_margin_expression':'(1-alpha)^(2*w*(R+1))-w*alpha', + 'margin_numerator_bits':abs(margin.numerator).bit_length(), + 'margin_denominator_bits':margin.denominator.bit_length(), + 'gamma_diagnostic':(-log(float(q))/(2*(radius+1))+width*log1p(-float(alpha))) if q<1 else None, + 'scope':'all integer lengths m>=width, if the supplied one-arm upper bound is valid'} + + +def evaluate_counts(counts: list[int],p: F) -> tuple[F,F]: + n=len(counts)-1;value=F(0);derivative=F(0) + for k,c in enumerate(counts): + value+=c*p**k*(1-p)**(n-k) + if k:derivative+=c*k*p**(k-1)*(1-p)**(n-k) + if k dict: + e=p0+p2 + if not 00 or d0==d2==0 + return {'E':str(e),'conditional_H':str(h),'H_derivative':str(dh), + 'rank_Fisher_information':str(direct),'activity_information':str(activity), + 'conditional_information_per_original_snapshot':str(conditional), + 'exact_decomposition':True} + + +def tiny_controls() -> dict: + w=m=4;radius=1;n=w*m;allmask=(1<=independent_set>=lower + assert p2<=exact_slab**2<=upper + comparisons.append({'p':str(p),'P0':str(p0),'P2':str(p2), + 'all_no_arm_probability':str(independent_set),'FKG_P0_lower':str(lower), + 'exact_slab_crossing_probability':str(exact_slab),'independent_slab_P2_upper':str(exact_slab**2), + 'one_arm_slab_P2_upper':str(upper),'inequalities_exact':True, + 'information':fisher_decomposition(p0,p2,d0,d2)}) + ranks[matching]=stored + rows.append({'graph':'NN+NNN' if matching else 'NN','width':w,'length':m, + 'configurations_checked':1<0:assert any(local_arm(mask,w,m,v,r,matching) for v in range(w*m)) + if rank==2:assert all(slab_crossing(mask,w,m,y,r,matching) + for y in range(0,m-r,r+1)) + structural+=1 + return {'exhaustive_graph_configurations':2*(1<<16),'models':rows, + 'complementary_rank_sum_checked':1<<16,'additional_structural_graph_cases':structural} + + +def report() -> dict: + start=time.perf_counter();certificates=[] + for degree,p,w,r in ((4,F(1,10),16,2),(8,F(1,20),16,2),(4,F(1,4),256,32)): + cert=sign_certificate(w,r,path_arm_bound(degree,p,r)) + assert cert['uniform_sign_certified'] + cert.update({'p':str(p),'graph_degree':degree,'input_certificate':'simple-path union bound; no unknown empirical constant'}) + certificates.append(cert) + return {'schema':'matching-one.rectangle-rank-odds-controls.v1', + 'status':'finite controls for a proof using Harris association and subcritical one-arm decay', + 'sign_certificates':certificates,'tiny_controls':tiny_controls(), + 'limits':['No numerical p_c interval or rate near criticality is inferred.', + 'The all-aspect root theorem is proved in the accompanying note, not from these sizes.', + 'Fisher decomposition concerns independent one-p snapshots, not full permutation paths.'], + 'elapsed_seconds':time.perf_counter()-start} + + +def main() -> None: + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--out',type=Path);args=ap.parse_args() + text=json.dumps(report(),indent=2,allow_nan=False)+'\n' + if args.out: + args.out.parent.mkdir(parents=True,exist_ok=True) + with args.out.open('x',encoding='utf-8') as f:f.write(text) + else:print(text,end='') + +if __name__=='__main__':main() diff --git a/tests/test_p398_tl_fattening.py b/tests/test_p398_tl_fattening.py new file mode 100644 index 00000000..7e0d4c58 --- /dev/null +++ b/tests/test_p398_tl_fattening.py @@ -0,0 +1,45 @@ +import sys +from pathlib import Path +import unittest +from fractions import Fraction as F +sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts')) +import p398_tl_fattening as t + +class TestFattening(unittest.TestCase): + def test_bijection_independent_rgs(self): + for w in range(2,7): + states=t.state_space(w) + self.assertEqual(states,t.independent_rgs(w)) + self.assertEqual({t.fatten(s) for s in states},set(t.link_patterns(2*w))) + def test_each_move(self): + for s in t.state_space(5): + for i in range(5): + self.assertEqual(t.fatten(t.join(s,i)),t.tl_reconnect(t.fatten(s),2*i+1)) + self.assertEqual(t.fatten(t.detach(s,i)),t.tl_reconnect(t.fatten(s),2*i)) + def test_periodic_seam(self): + s=(0,1,2,3) + self.assertEqual(t.fatten(t.join(s,3)),t.tl_reconnect(t.fatten(s),7)) + def test_half_step_not_involution(self): + s=(0,0,1,2,3) + self.assertEqual(t.half_step(t.half_step(s)),t.canonical((s[-1],)+s[:-1])) + self.assertNotEqual(t.half_step(t.half_step(s)),s) + def test_readout_transport(self): + for s in t.state_space(6): + k=t.half_step(s) + self.assertEqual(max(s)+max(k)+2,7) + self.assertEqual(s[0]==s[-1],k.count(k[0])==1) + def test_staggered_generator_conjugacy(self): + ss=t.state_space(4);ix={s:i for i,s in enumerate(ss)};k=[ix[t.half_step(s)] for s in ss] + gp=t.generator(ss,F(1,4));gm=t.generator(ss,F(-1,4)) + self.assertTrue(all(gp[i][j]==gm[k[i]][k[j]] for i in range(len(ss)) for j in range(len(ss)))) + def test_stationary_normalization(self): + ss=t.state_space(4);pi=t.stationary(t.generator(ss)) + self.assertEqual(sum(p*(max(s)+1) for p,s in zip(pi,ss)),F(5,2)) + self.assertEqual(t.asm_number(4),42) + self.assertEqual(sorted(set(p*42 for p in pi)),[1,3,7]) + def test_input_guards(self): + with self.assertRaises(ValueError):t.link_patterns(5) + with self.assertRaises(ValueError):t.unfatten((0,1)) + with self.assertRaises(ValueError):t.generator(t.state_space(3),F(2)) + +if __name__=='__main__':unittest.main() diff --git a/tests/test_rectangular_rank_odds.py b/tests/test_rectangular_rank_odds.py new file mode 100644 index 00000000..89fa4f93 --- /dev/null +++ b/tests/test_rectangular_rank_odds.py @@ -0,0 +1,39 @@ +import sys +from pathlib import Path +import unittest +from fractions import Fraction as F +sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts')) +import rectangular_rank_odds as r + +class TestRankOdds(unittest.TestCase): + def test_local_box_guard(self): + with self.assertRaises(ValueError):r.local_arm(0,3,8,0,1,False) + with self.assertRaises(ValueError):r.sign_certificate(3,1,F(1,100)) + def test_path_bound(self): + self.assertEqual(r.path_arm_bound(4,F(1,10),2),F(3,250)) + self.assertEqual(r.path_arm_bound(8,F(1,20),2),F(7,1000)) + def test_exact_positive_margin(self): + c=r.sign_certificate(16,2,F(3,250)) + self.assertTrue(c['uniform_sign_certified']) + self.assertGreater(c['gamma_diagnostic'],0) + def test_failed_margin_not_a_result(self): + self.assertFalse(r.sign_certificate(16,2,F(1,10))['uniform_sign_certified']) + def test_two_cross_cycles(self): + w=m=8;mask=sum(1<