From b52e3a35d2c88dfc1bf0c17508d3dc4ce5d570f1 Mon Sep 17 00:00:00 2001 From: Light Chain Date: Sat, 12 Sep 2026 16:24:32 +0800 Subject: [PATCH 1/6] #622: reflection residual and finite-size shape motion on N=145,290,725 C2 reanalysis of the committed same-observable P50/#612 blocks. Per-orientation Q first, then the declared spin-0 weighted Q (sum w = 1, sum w cos4 = 0); CDFs are never mixed before inversion. Anchors 0.2/0.8; A_N(u) = Z_N(u) + Z_N(1-u) - 1 on independent coordinates 0.1/0.3/0.4/0.5. Delete-one repeats the whole Q -> weighting -> W -> Z -> A map for a joint covariance. - A resolved nonzero at every size (|A| = 0.03051, 0.02364, 0.01683; each step resolved at 178 and 150 sigma). Decreasing on this finite lineage; no convergence or exponent claim. - Adjacent Delta Z and Delta A resolved nonzero with propagated covariance. Interval-to-interval |dZ| falls at 10.9 sigma; |dA| is consistent with constant (1.1 sigma). - Equal-weighting sensitivity leaves the qualitative reading unchanged. - Profile first: N=725 pooled 1.05 s, one delete-one batch 1.02 s; full delivery 5m23s single-threaded on XPk2PZ, far inside the 4 CPU-hour cap. No Monte Carlo, no GPU, no exponent fit, no STATUS.md, no issue closed. --- ...sue-622-quantile-shape-lineage-20260912.md | 110 + .../quantile-shape-lineage-622.json | 5001 +++++++++++++++++ results/probe-invariant-shape/run-622.log | 22 + .../quantile_shape_lineage_622.py | 708 +++ tests/test_quantile_shape_lineage_622.py | 154 + 5 files changed, 5995 insertions(+) create mode 100644 notes/issue-622-quantile-shape-lineage-20260912.md create mode 100644 results/probe-invariant-shape/quantile-shape-lineage-622.json create mode 100644 results/probe-invariant-shape/run-622.log create mode 100644 scripts/probe_invariant_shape/quantile_shape_lineage_622.py create mode 100644 tests/test_quantile_shape_lineage_622.py diff --git a/notes/issue-622-quantile-shape-lineage-20260912.md b/notes/issue-622-quantile-shape-lineage-20260912.md new file mode 100644 index 00000000..7ae2b2b1 --- /dev/null +++ b/notes/issue-622-quantile-shape-lineage-20260912.md @@ -0,0 +1,110 @@ +# #622 after #702: reflection residual and finite-size shape motion + +Date: 2026-09-12. Base: `main` at `6edf775e` (includes #702–#704). +Machine: XPk2PZ (16 vCPU ARM, no GPU), job under `/workspace/mo-622/`. +Artifacts: `results/probe-invariant-shape/quantile-shape-lineage-622.json`, +`scripts/probe_invariant_shape/quantile_shape_lineage_622.py`, +`tests/test_quantile_shape_lineage_622.py`, `results/probe-invariant-shape/run-622.log`. + +C2 reanalysis of already-committed blocks. No Monte Carlo, no GPU, no exponent +fit, no `docs/STATUS.md`, no issue closed. + +## Object and order of operations + +For each size the two orientations are inverted **separately** and only then +combined, `Q_spin0 = w_1 Q_1 + w_2 Q_2` with `w_1+w_2=1` and +`sum w_i cos4theta_i = 0` (checked to `6e-17`); CDFs are never mixed before +inversion. Then, on the nine frozen deciles with anchors `a=0.2`, `b=0.8`, + + W_N = Q_N(0.8) - Q_N(0.2) > 0 + Z_N(u) = [Q_N(u) - Q_N(0.2)] / W_N + A_N(u) = Z_N(u) + Z_N(1-u) - 1 + +with `A` the corrected normalized-shape reflection residual (not +`M_N(p)+M_N(1-p)`). Every delete-one batch repeats the whole map; the reported +covariances are of one random object across the grid. Independent coordinates +`u = 0.1,0.3,0.4,0.5` are used because `A(0.2)=A(0.8)=0` and `A(1-u)=A(u)` +exactly; `Z(0.2)=0`, `Z(0.8)=1` are likewise fixed. Angles/covariance use the +`cos 4theta` convention of `scripts/threshold_quantile_lineage.py` +(blob `3b328f29`, the #655 lineage); the equal weighting is a sensitivity on the +same block, not a second experiment. + +## Lineage, geometry, weights + +Same channel (`rank-2 cross wrapping`) and same observable (`K_plus`, `K_minus`) +at all three sizes; the exact tiny site/bond labs are a different observable and +are not mixed in. + +| N | reps (first, second) | shortest period `sqrt(N)` | seed | spin-0 weights | +|--:|:--|--:|--:|:--| +| 145 | (12,1), (9,8) | 12.0416 | 2026105003 | (0.50711806, 0.49288194) | +| 290 | (13,11), (17,1) | 17.0294 | 2026105004 | (0.50711806, 0.49288194) | +| 725 | (26,7), (23,14) | 26.9258 | 2026105011 | (0.53827771, 0.46172229) | + +`site_count = |a+bi|^2`, so the shortest lifted period holds `sqrt(N)` sites. +All three spin-0 combinations are interpolations; distinct seeds mean the +cross-size covariance term is taken as zero on random-stream provenance. + +## Reflection residual `A = 0` (spin0 primary) + +| N | W (SE) | A(0.1) | A(0.3) | A(0.4) | A(0.5) | `\|A\|` (SE) | nominal chi2, 4 dof | +|--:|:--|--:|--:|--:|--:|:--|:--| +| 145 | 0.11921330 (3.7e-8) | -0.0204652 | 0.0093537 | 0.0138721 | 0.0152436 | 0.0305142 (2.6e-5) | 2.27e6 | +| 290 | 0.09220375 (2.8e-8) | -0.0159133 | 0.0072317 | 0.0107147 | 0.0117706 | 0.0236407 (2.9e-5) | 1.00e6 | +| 725 | 0.06553076 (2.4e-8) | -0.0113451 | 0.0051435 | 0.0076198 | 0.0083705 | 0.0168313 (3.5e-5) | 3.56e5 | + +`p` is below double reference at every size. The tests are nominal Gaussian +references with estimated delete-one covariance. The 4x4 `A` covariance is +near-collinear (correlations up to 0.9999; condition number 2.4e8 / 6.3e7 / +1.7e7), so the full-inverse chi-square is quoted next to the correlation-free +diagonal chi-square; the full value is **smaller** than the diagonal value at +every size and every displacement test, so the rejection is carried by the +per-coordinate residuals (max `|t|` = 1354, 913, 525), not by inverting a +near-null direction. No pseudoinverse is used anywhere. + +## Adjacent-size motion (pooled, spin0) + +| pair | `\|dZ\|` (SE) | `\|dA\|` (SE) | chi2_Z, 7 dof | chi2_A, 4 dof | +|:--|:--|:--|:--|:--| +| 145→290 | 0.00537503 (2.1e-5) | 0.00687410 (3.9e-5) | 1.37e5 | 4.51e4 | +| 290→725 | 0.00499749 (2.7e-5) | 0.00680943 (4.5e-5) | 6.42e4 | 3.27e4 | + +Both displacements are resolved from zero; `Cov(dZ)=Cov(Z_from)+Cov(Z_to)`. +The declared norm is the Euclidean `L2` on the independent coordinates. + +Interval-to-interval change: `|dZ|` falls by `3.78e-4 +/- 3.45e-5` (10.9σ, +resolved); `|dA|` changes by `-6.47e-5 +/- 5.95e-5` (1.1σ, **not** resolved). + +## Equal-weighting sensitivity + +Equal weighting retains a spin-4 residue (`-1.37e-2`, `+1.37e-2`, `-4.11e-2`). +The difference from spin0 is at most `1.6e-5` in `A` and `8.7e-6` in `Z`. The +qualitative reading is unchanged; it is one analysis, not two. + +## Measured profile + +Load of the three blocks 1.0 s; N=725 pooled pass 1.05 s; one N=725 delete-one +batch 1.02 s. Full delivery (3 sizes × 2 weightings, 100 batches each, +single-threaded) 5 min 23 s wall, about 0.09 CPU-hours — the 4 CPU-hour cap is +not binding, so the complete delete-one path was delivered rather than a +substituted estimator. N=725 pooled `Q` reproduces the #655 decile values to +`4.1e-9` (that reference is published to 8 decimals). + +## Outcome + +* **Reflection residual: resolved.** `A != 0` at all three sizes at hundreds to + >1000σ per coordinate; the normalized shape is not reflection-symmetric. +* **Size trend on this finite lineage: decreasing.** `|A| = 0.03051 -> 0.02364 + -> 0.01683`, each step resolved (178σ, 150σ). Three sizes cannot establish + convergence or a limit; this is observed finite movement, and no exponent is + fitted. +* **Adjacent-size shape change: resolved.** Non-affine displacement remains + between adjacent sizes (`|dZ|`, `|dA|` both nonzero). Between the two + available intervals `|dZ|` decreases slightly (10.9σ) while `|dA|` is + consistent with constant (1.1σ). +* Weighting does not change the qualitative reading; no covariance-aware test + is decided by a near-null direction. + +No conclusion here identifies an exponent, a field, or a threshold; a larger-N +purchase would need a separate decision naming which surviving alternative it +separates, and none is authorized here. #622 stays open. diff --git a/results/probe-invariant-shape/quantile-shape-lineage-622.json b/results/probe-invariant-shape/quantile-shape-lineage-622.json new file mode 100644 index 00000000..76dcc230 --- /dev/null +++ b/results/probe-invariant-shape/quantile-shape-lineage-622.json @@ -0,0 +1,5001 @@ +{ + "schema": "matching-one.probe-invariant-shape.quantile-shape-lineage-622.v1", + "issue": 622, + "run": "2026-09-12 re-scope: reflection residual A and adjacent-size full-vector motion on the same-observable N=145,290,725 lineage", + "source_revisions": { + "base_branch": "main", + "base_commit": "6edf775e240056dc95e373344694eed527e48872", + "threshold_quantile_lineage.py": { + "git_blob": "3b328f29b9ccc75d0183ea72b8622b53bbe955d7", + "git_commit": "6edf775e240056dc95e373344694eed527e48872", + "inherits": "PR #655 (analysis/633-n725-spin0) lineage module", + "properties": [ + "cos_four_theta = (a^4 - 6 a^2 b^2 + b^4) / N^2", + "invert Q per orientation, then combine", + "pooled full vector plus aligned delete-one" + ] + }, + "correction": "notes/exact-foundations-correction-20260912.md sec.3 (#702)", + "prior_probe": "PR #666 rerun-20260908.json (T1-T4), superseded by this re-scope" + }, + "order_of_operations": "per-orientation Q first, then spin-0 weighted Q; CDFs are never mixed before inversion", + "anchors": [ + 0.2, + 0.8 + ], + "deciles": [ + 0.1, + 0.2, + 0.3, + 0.4, + 0.5, + 0.6, + 0.7, + 0.8, + 0.9 + ], + "independent_A_coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5 + ], + "independent_Z_coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5, + 0.6, + 0.7, + 0.9 + ], + "geometry": { + "145": { + "site_count_N": 145, + "engine": "same-N Gaussian threshold-rank Newman-Ziff", + "channel": "rank-2 cross wrapping", + "observable_K_plus": "first black primal cross rank, 1-based", + "observable_K_minus": "first black rank after white matching cross is lost; N-r+1", + "samples_per_orientation": null, + "batches": 100, + "seed": 2026105003, + "rng": "counter-derived SplitMix64 stream plus unbiased Fisher-Yates", + "coupling": "same cyclic permutation shared by same-N orientations", + "generated_utc": "2026-08-29T06:31:34Z", + "producer_git_commit": "d99a679dda985f5c65469cb25dbe46054f6e8b3c", + "command": "build/threshold_rank_orientation_mc --n 145 --samples 100000000 --batches 100 --seed 2026105003 --replica-offset 7000000000 --threads 8 --git-commit d99a679dda985f5c65469cb25dbe46054f6e8b3c --output-prefix results/server-20260829/P50-n145-n290-fullcurve/raw/n145_100m", + "orientation_representatives": [ + [ + 12, + 1 + ], + [ + 9, + 8 + ] + ], + "site_count_vs_shortest_period": { + "site_count": 145, + "per_orientation": [ + { + "representative": [ + 12, + 1 + ], + "norm_squared": 145, + "shortest_period_length": 12.041594578792296 + }, + { + "representative": [ + 9, + 8 + ], + "norm_squared": 145, + "shortest_period_length": 12.041594578792296 + } + ], + "identity": "site_count = |a+bi|^2 = shortest_period_length^2, so the shortest lifted period holds sqrt(N) sites" + } + }, + "290": { + "site_count_N": 290, + "engine": "general integer-period threshold-rank Newman-Ziff", + "channel": "rank-2 cross wrapping", + "observable_K_plus": "first black primal cross rank, 1-based", + "observable_K_minus": "first black rank after white matching cross is lost; N-r+1", + "samples_per_orientation": null, + "batches": 100, + "seed": 2026105004, + "rng": "counter-derived SplitMix64 stream plus unbiased Fisher-Yates", + "coupling": "same HNF mixed-radix label permutation shared by the pair", + "generated_utc": "2026-08-29T06:38:29Z", + "producer_git_commit": "d99a679dda985f5c65469cb25dbe46054f6e8b3c", + "command": "build/threshold_rank_integer_period_mc --first-matrix 13 -11 11 13 --second-matrix 17 -1 1 17 --first-rep 13 11 --second-rep 17 1 --samples 100000000 --batches 100 --seed 2026105004 --replica-offset 7000000000 --threads 8 --git-commit d99a679dda985f5c65469cb25dbe46054f6e8b3c --output-prefix results/server-20260829/P50-n145-n290-fullcurve/raw/n290_100m", + "orientation_representatives": [ + [ + 13, + 11 + ], + [ + 17, + 1 + ] + ], + "site_count_vs_shortest_period": { + "site_count": 290, + "per_orientation": [ + { + "representative": [ + 13, + 11 + ], + "norm_squared": 290, + "shortest_period_length": 17.029386365926403 + }, + { + "representative": [ + 17, + 1 + ], + "norm_squared": 290, + "shortest_period_length": 17.029386365926403 + } + ], + "identity": "site_count = |a+bi|^2 = shortest_period_length^2, so the shortest lifted period holds sqrt(N) sites" + }, + "first_period_matrix": [ + [ + 13, + -11 + ], + [ + 11, + 13 + ] + ], + "second_period_matrix": [ + [ + 17, + -1 + ], + [ + 1, + 17 + ] + ], + "first_HNF": [ + [ + 290, + 133 + ], + [ + 0, + 1 + ] + ], + "second_HNF": [ + [ + 290, + 17 + ], + [ + 0, + 1 + ] + ], + "first_smith_invariants": [ + 1, + 290 + ], + "second_smith_invariants": [ + 1, + 290 + ] + }, + "725": { + "site_count_N": 725, + "engine": "general integer-period threshold-rank Newman-Ziff", + "channel": "rank-2 cross wrapping", + "observable_K_plus": "first black primal cross rank, 1-based", + "observable_K_minus": "first black rank after white matching cross is lost; N-r+1", + "samples_per_orientation": null, + "batches": 100, + "seed": 2026105011, + "rng": "counter-derived SplitMix64 stream plus unbiased Fisher-Yates", + "coupling": "same HNF mixed-radix label permutation shared by the pair", + "generated_utc": "2026-09-07T04:07:37Z", + "producer_git_commit": "8b5f9d1a", + "command": "./build/threshold_rank_integer_period_mc --first-matrix 26 -7 7 26 --second-matrix 23 -14 14 23 --samples 100000000 --batches 100 --seed 2026105011 --replica-offset 7000000000 --threads 8 --git-commit 8b5f9d1a --output-prefix results/server-20260907/P612-n725-fullcurve/raw/n725_100m", + "orientation_representatives": [ + [ + 26, + 7 + ], + [ + 23, + 14 + ] + ], + "site_count_vs_shortest_period": { + "site_count": 725, + "per_orientation": [ + { + "representative": [ + 26, + 7 + ], + "norm_squared": 725, + "shortest_period_length": 26.92582403567252 + }, + { + "representative": [ + 23, + 14 + ], + "norm_squared": 725, + "shortest_period_length": 26.92582403567252 + } + ], + "identity": "site_count = |a+bi|^2 = shortest_period_length^2, so the shortest lifted period holds sqrt(N) sites" + }, + "first_period_matrix": [ + [ + 26, + -7 + ], + [ + 7, + 26 + ] + ], + "second_period_matrix": [ + [ + 23, + -14 + ], + [ + 14, + 23 + ] + ], + "first_HNF": [ + [ + 725, + 418 + ], + [ + 0, + 1 + ] + ], + "second_HNF": [ + [ + 725, + 157 + ], + [ + 0, + 1 + ] + ], + "first_smith_invariants": [ + 1, + 725 + ], + "second_smith_invariants": [ + 1, + 725 + ] + } + }, + "sizes": { + "145": { + "spin0_is_interpolation": true, + "spin0_weights": { + "first": 0.5071180555555556, + "second": 0.4928819444444445 + }, + "equal_weights": { + "first": 0.5, + "second": 0.5 + }, + "analysis": { + "spin0": { + "n": 145, + "batches": 100, + "weights": { + "first": 0.5071180555555556, + "second": 0.4928819444444445 + }, + "weights_sum": 1.0, + "spin0_annihilates_cos4": -5.551115123125783e-17, + "orientation_cos4theta": { + "first": 0.9452080856123662, + "second": -0.9725089179548156 + }, + "orientation_representative": { + "first": [ + 12, + 1 + ], + "second": [ + 9, + 8 + ] + }, + "levels": [ + 0.1, + 0.2, + 0.3, + 0.4, + 0.5, + 0.6, + 0.7, + 0.8, + 0.9 + ], + "anchors": [ + 0.2, + 0.8 + ], + "W": 0.1192132990525685, + "W_se": 3.710104917419988e-08, + "Q_pooled": [ + 0.499582339756213, + 0.5322263839528236, + 0.5553030488658823, + 0.5747547479290162, + 0.5927416557041343, + 0.6105650584401353, + 0.6294781064247724, + 0.6514396830053921, + 0.6816440059500316 + ], + "Q_se": [ + 4.608455337623289e-06, + 3.885634171670558e-06, + 3.5288404207902424e-06, + 3.311732327355635e-06, + 3.1717821899143623e-06, + 3.0934414060933443e-06, + 3.0879621074313793e-06, + 3.198659754812073e-06, + 3.5633408129117815e-06 + ], + "Z_pooled": [ + -0.27382888030148234, + 0.0, + 0.19357458518854329, + 0.35674177557521625, + 0.5076218193125059, + 0.6571303295009673, + 0.8157791391132001, + 1.0, + 1.2533637034180267 + ], + "Z_se": [ + 1.0361199226581717e-05, + 0.0, + 4.683372884548079e-06, + 6.873504463540624e-06, + 7.426133226815103e-06, + 6.601196508688139e-06, + 4.314997081363483e-06, + 0.0, + 8.605152433289522e-06 + ], + "A_pooled": [ + -0.020465176883455616, + 0.0, + 0.009353724301743416, + 0.013872105076183416, + 0.01524363862501188, + 0.013872105076183416, + 0.009353724301743416, + 0.0, + -0.020465176883455616 + ], + "A_se": [ + 1.5114267609522915e-05, + 0.0, + 8.588522635668875e-06, + 1.3324664271374472e-05, + 1.4852266453615764e-05, + 1.3324664271374472e-05, + 8.588522635668875e-06, + 0.0, + 1.5114267609522915e-05 + ], + "Q_covariance": [ + [ + 2.1237860598868587e-11, + 1.7094495237591736e-11, + 1.4195244863143255e-11, + 1.190862389675768e-11, + 9.976957012118146e-12, + 8.25632689120308e-12, + 6.631200461609219e-12, + 4.934037177040163e-12, + 2.6650932452446846e-12 + ], + [ + 1.7094495237591736e-11, + 1.5098152916053942e-11, + 1.337806544254262e-11, + 1.182300067210269e-11, + 1.0359986335953916e-11, + 8.935550509359977e-12, + 7.492014732602456e-12, + 5.919309863345197e-12, + 3.839073702259726e-12 + ], + [ + 1.4195244863143255e-11, + 1.337806544254262e-11, + 1.2452714715403054e-11, + 1.1474276571652401e-11, + 1.0442047436078037e-11, + 9.341110890753017e-12, + 8.139170232188404e-12, + 6.7525962275942124e-12, + 4.8679917427329065e-12 + ], + [ + 1.190862389675768e-11, + 1.182300067210269e-11, + 1.1474276571652401e-11, + 1.096757100805237e-11, + 1.0330378857160037e-11, + 9.563581070801589e-12, + 8.644886010166625e-12, + 7.500902363159116e-12, + 5.8473215546798335e-12 + ], + [ + 9.976957012118146e-12, + 1.0359986335953916e-11, + 1.0442047436078037e-11, + 1.0330378857160037e-11, + 1.0060202260257947e-11, + 9.637332366679951e-12, + 9.042464064806873e-12, + 8.20505946390321e-12, + 6.849322939970254e-12 + ], + [ + 8.25632689120308e-12, + 8.935550509359977e-12, + 9.341110890753017e-12, + 9.563581070801589e-12, + 9.637332366679951e-12, + 9.569379732932766e-12, + 9.342502252078975e-12, + 8.889454097380616e-12, + 7.93789800737962e-12 + ], + [ + 6.631200461609219e-12, + 7.492014732602456e-12, + 8.139170232188404e-12, + 8.644886010166625e-12, + 9.042464064806873e-12, + 9.342502252078975e-12, + 9.535509976932046e-12, + 9.568174935506058e-12, + 9.19004699445944e-12 + ], + [ + 4.934037177040163e-12, + 5.919309863345197e-12, + 6.7525962275942124e-12, + 7.500902363159116e-12, + 8.20505946390321e-12, + 8.889454097380616e-12, + 9.568174935506058e-12, + 1.023142422705443e-11, + 1.0720317755944096e-11 + ], + [ + 2.6650932452446846e-12, + 3.839073702259726e-12, + 4.8679917427329065e-12, + 5.8473215546798335e-12, + 6.849322939970254e-12, + 7.93789800737962e-12, + 9.19004699445944e-12, + 1.0720317755944096e-11, + 1.2697397748962795e-11 + ] + ], + "Z_covariance": [ + [ + 1.0735444941291756e-10, + 0.0, + -4.347909334359488e-11, + -5.875509109723e-11, + -5.754028337634183e-11, + -4.524594060259349e-11, + -2.5087235679939262e-11, + 0.0, + 2.351899377908123e-11 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + -4.347909334359488e-11, + 0.0, + 2.1933981575720194e-11, + 3.180168609140616e-11, + 3.321226908595646e-11, + 2.7862815654521123e-11, + 1.6604769836834343e-11, + 0.0, + -2.01915005966557e-11 + ], + [ + -5.875509109723e-11, + 0.0, + 3.180168609140616e-11, + 4.724506361031288e-11, + 5.0486691460297726e-11, + 4.33629094941092e-11, + 2.6529682709708307e-11, + 0.0, + -3.525219055935014e-11 + ], + [ + -5.754028337634183e-11, + 0.0, + 3.321226908595646e-11, + 5.0486691460297726e-11, + 5.51474547024073e-11, + 4.845035218599856e-11, + 3.040219622700879e-11, + 0.0, + -4.3917008035058286e-11 + ], + [ + -4.524594060259349e-11, + 0.0, + 2.7862815654521123e-11, + 4.33629094941092e-11, + 4.845035218599856e-11, + 4.357579534631648e-11, + 2.8069798415227894e-11, + 0.0, + -4.4141438232106924e-11 + ], + [ + -2.5087235679939262e-11, + 0.0, + 1.6604769836834343e-11, + 2.6529682709708307e-11, + 3.040219622700879e-11, + 2.8069798415227894e-11, + 1.8619199812175374e-11, + 0.0, + -3.215025393714844e-11 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + 2.351899377908123e-11, + 0.0, + -2.01915005966557e-11, + -3.525219055935014e-11, + -4.3917008035058286e-11, + -4.4141438232106924e-11, + -3.215025393714844e-11, + 0.0, + 7.404864840014858e-11 + ] + ], + "A_covariance": [ + [ + 2.2844108537227355e-10, + 0.0, + -1.2090808355971368e-10, + -1.833946604911649e-10, + -2.0291458282319714e-10, + -1.833946604911649e-10, + -1.2090808355971368e-10, + 0.0, + 2.2844108537227355e-10 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + -1.2090808355971368e-10, + 0.0, + 7.376272106339665e-11, + 1.1426398287216488e-10, + 1.2722893062727194e-10, + 1.1426398287216488e-10, + 7.376272106339665e-11, + 0.0, + -1.2090808355971368e-10 + ], + [ + -1.833946604911649e-10, + 0.0, + 1.1426398287216488e-10, + 1.775466779448434e-10, + 1.9787408729241556e-10, + 1.775466779448434e-10, + 1.1426398287216488e-10, + 0.0, + -1.833946604911649e-10 + ], + [ + -2.0291458282319714e-10, + 0.0, + 1.2722893062727194e-10, + 1.9787408729241556e-10, + 2.2058981880920018e-10, + 1.9787408729241556e-10, + 1.2722893062727194e-10, + 0.0, + -2.0291458282319714e-10 + ], + [ + -1.833946604911649e-10, + 0.0, + 1.1426398287216488e-10, + 1.775466779448434e-10, + 1.9787408729241556e-10, + 1.775466779448434e-10, + 1.1426398287216488e-10, + 0.0, + -1.833946604911649e-10 + ], + [ + -1.2090808355971368e-10, + 0.0, + 7.376272106339665e-11, + 1.1426398287216488e-10, + 1.2722893062727194e-10, + 1.1426398287216488e-10, + 7.376272106339665e-11, + 0.0, + -1.2090808355971368e-10 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + 2.2844108537227355e-10, + 0.0, + -1.2090808355971368e-10, + -1.833946604911649e-10, + -2.0291458282319714e-10, + -1.833946604911649e-10, + -1.2090808355971368e-10, + 0.0, + 2.2844108537227355e-10 + ] + ], + "A_zero_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5 + ], + "values": [ + -0.020465176883455616, + 0.009353724301743416, + 0.013872105076183416, + 0.01524363862501188 + ], + "standardized_values": [ + -1354.0303382322872, + 1089.0958432008542, + 1041.084772843772, + 1026.3510066034962 + ], + "covariance": [ + [ + 2.2844108537227355e-10, + -1.2090808355971368e-10, + -1.833946604911649e-10, + -2.0291458282319714e-10 + ], + [ + -1.2090808355971368e-10, + 7.376272106339665e-11, + 1.1426398287216488e-10, + 1.2722893062727194e-10 + ], + [ + -1.833946604911649e-10, + 1.1426398287216488e-10, + 1.775466779448434e-10, + 1.9787408729241556e-10 + ], + [ + -2.0291458282319714e-10, + 1.2722893062727194e-10, + 1.9787408729241556e-10, + 2.2058981880920018e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.9314290211760745, + -0.9106328319309208, + -0.9039271274825214 + ], + [ + -0.9314290211760745, + 1.0, + 0.9984690747160182, + 0.9974122097877436 + ], + [ + -0.9106328319309208, + 0.9984690747160182, + 1.0, + 0.9998616641310474 + ], + [ + -0.9039271274825214, + 0.9974122097877436, + 0.9998616641310474, + 1.0 + ] + ], + "standard_errors": [ + 1.5114267609522915e-05, + 8.588522635668875e-06, + 1.3324664271374472e-05, + 1.4852266453615764e-05 + ], + "eigenvalues_ascending": [ + 2.828962094365212e-18, + 1.78056991295198e-14, + 2.7491311407766206e-11, + 6.728311832538561e-10 + ], + "smallest_eigenvalue": 2.828962094365212e-18, + "largest_eigenvalue": 6.728311832538561e-10, + "condition_number": 237836761.61445072, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 5156781.805534, + "diagonal_dof": 4, + "chi2": 2273560.463866949, + "dof": 4, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 1354.0303382322872 + }, + "A_norm_on_independent_coordinates": { + "value": 0.030514249801671008, + "se": 2.5683342534193044e-05, + "undefined_se": false + } + }, + "equal": { + "n": 145, + "batches": 100, + "weights": { + "first": 0.5, + "second": 0.5 + }, + "weights_sum": 1.0, + "spin0_annihilates_cos4": -0.0136504161712247, + "orientation_cos4theta": { + "first": 0.9452080856123662, + "second": -0.9725089179548156 + }, + "orientation_representative": { + "first": [ + 12, + 1 + ], + "second": [ + 9, + 8 + ] + }, + "levels": [ + 0.1, + 0.2, + 0.3, + 0.4, + 0.5, + 0.6, + 0.7, + 0.8, + 0.9 + ], + "anchors": [ + 0.2, + 0.8 + ], + "W": 0.1192129649692788, + "W_se": 3.72196621471202e-08, + "Q_pooled": [ + 0.49958459023130786, + 0.5322275039234796, + 0.5553037025889864, + 0.5747551742136068, + 0.5927419877811246, + 0.610565400771975, + 0.6294785755794976, + 0.6514404688927584, + 0.6816456098214871 + ], + "Q_se": [ + 4.6158696350581905e-06, + 3.889120880863032e-06, + 3.529407348980669e-06, + 3.3101511730094392e-06, + 3.16866992713441e-06, + 3.08931394871061e-06, + 3.083351301944151e-06, + 3.194248424319799e-06, + 3.559754651259879e-06 + ], + "Z_pooled": [ + -0.273820164615349, + 0.0, + 0.1935712166160245, + 0.35673695642991976, + 0.5076166327482888, + 0.6571256479417573, + 0.8157759659872531, + 1.0, + 1.2533712749826547 + ], + "Z_se": [ + 1.0334270072960687e-05, + 0.0, + 4.674922842516199e-06, + 6.864440266550277e-06, + 7.419743995626515e-06, + 6.598239170496641e-06, + 4.314524021809796e-06, + 0.0, + 8.605418033747276e-06 + ], + "A_pooled": [ + -0.020448889632694423, + 0.0, + 0.009347182603277604, + 0.01386260437167719, + 0.015233265496577664, + 0.01386260437167719, + 0.009347182603277604, + 0.0, + -0.020448889632694423 + ], + "A_se": [ + 1.5092281543090564e-05, + 0.0, + 8.580122485490376e-06, + 1.3312835751929892e-05, + 1.4839487991242812e-05, + 1.3312835751929892e-05, + 8.580122485490376e-06, + 0.0, + 1.5092281543090564e-05 + ], + "Q_covariance": [ + [ + 2.130625248785223e-11, + 1.7139798698166976e-11, + 1.422236017319209e-11, + 1.191847046352404e-11, + 9.969520594251964e-12, + 8.23131200287134e-12, + 6.588316442835108e-12, + 4.873266171200065e-12, + 2.58680382618849e-12 + ], + [ + 1.7139798698166976e-11, + 1.5125261225964846e-11, + 1.339187769306442e-11, + 1.1824970426633183e-11, + 1.0350545832149493e-11, + 8.914708350713793e-12, + 7.459663785478777e-12, + 5.8755635327977255e-12, + 3.78473815586001e-12 + ], + [ + 1.422236017319209e-11, + 1.339187769306442e-11, + 1.2456716235038753e-11, + 1.1469710067891024e-11, + 1.0429359771298124e-11, + 9.320369833833225e-12, + 8.110326422279274e-12, + 6.715825189669834e-12, + 4.824374866830687e-12 + ], + [ + 1.191847046352404e-11, + 1.1824970426633183e-11, + 1.1469710067891024e-11, + 1.0957100788175765e-11, + 1.0314232507835683e-11, + 9.541746435684237e-12, + 8.617288937107618e-12, + 7.467712963427918e-12, + 5.809689776754732e-12 + ], + [ + 9.969520594251964e-12, + 1.0350545832149493e-11, + 1.0429359771298124e-11, + 1.0314232507835683e-11, + 1.0040469107125988e-11, + 9.613840984392409e-12, + 9.015070622479156e-12, + 8.173889416820613e-12, + 6.8154334107162784e-12 + ], + [ + 8.23131200287134e-12, + 8.914708350713793e-12, + 9.320369833833225e-12, + 9.541746435684237e-12, + 9.613840984392409e-12, + 9.54386067369794e-12, + 9.314728176705667e-12, + 8.859498096529486e-12, + 7.90661692916728e-12 + ], + [ + 6.588316442835108e-12, + 7.459663785478777e-12, + 8.110326422279274e-12, + 8.617288937107618e-12, + 9.015070622479156e-12, + 9.314728176705667e-12, + 9.50705525120069e-12, + 9.539079620516102e-12, + 9.160895615067154e-12 + ], + [ + 4.873266171200065e-12, + 5.8755635327977255e-12, + 6.715825189669834e-12, + 7.467712963427918e-12, + 8.173889416820613e-12, + 8.859498096529486e-12, + 9.539079620516102e-12, + 1.020322299626952e-11, + 1.0693229939251479e-11 + ], + [ + 2.58680382618849e-12, + 3.78473815586001e-12, + 4.824374866830687e-12, + 5.809689776754732e-12, + 6.8154334107162784e-12, + 7.90661692916728e-12, + 9.160895615067154e-12, + 1.0693229939251479e-11, + 1.2671853177166345e-11 + ] + ], + "Z_covariance": [ + [ + 1.0679713794089087e-10, + 0.0, + -4.327531121352025e-11, + -5.850327726006216e-11, + -5.732025816524502e-11, + -4.5095855119433736e-11, + -2.501724974061049e-11, + 0.0, + 2.346330234939568e-11 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + -4.327531121352025e-11, + 0.0, + 2.185490358347974e-11, + 3.170228157215069e-11, + 3.312376386604311e-11, + 2.7800757089644023e-11, + 1.6574240373654306e-11, + 0.0, + -2.015101346540426e-11 + ], + [ + -5.850327726006216e-11, + 0.0, + 3.170228157215069e-11, + 4.712054017303683e-11, + 5.037686612956661e-11, + 4.32871477180477e-11, + 2.6493256423343366e-11, + 0.0, + -3.520082134923427e-11 + ], + [ + -5.732025816524502e-11, + 0.0, + 3.312376386604311e-11, + 5.037686612956661e-11, + 5.505260096063572e-11, + 4.83872928422758e-11, + 3.037363987378323e-11, + 0.0, + -4.387580858523916e-11 + ], + [ + -4.5095855119433736e-11, + 0.0, + 2.7800757089644023e-11, + 4.32871477180477e-11, + 4.83872928422758e-11, + 4.35367601510762e-11, + 2.8054405885515838e-11, + 0.0, + -4.4119874107026686e-11 + ], + [ + -2.501724974061049e-11, + 0.0, + 1.6574240373654306e-11, + 2.6493256423343366e-11, + 3.037363987378323e-11, + 2.8054405885515838e-11, + 1.8615117534773783e-11, + 0.0, + -3.2146018090060836e-11 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + 2.346330234939568e-11, + 0.0, + -2.015101346540426e-11, + -3.520082134923427e-11, + -4.387580858523916e-11, + -4.4119874107026686e-11, + -3.2146018090060836e-11, + 0.0, + 7.405321953554283e-11 + ] + ], + "A_covariance": [ + [ + 2.277769621759121e-10, + 0.0, + -1.205895925093074e-10, + -1.8291982783515513e-10, + -2.0239213350149866e-10, + -1.8291982783515513e-10, + -1.205895925093074e-10, + 0.0, + 2.277769621759121e-10 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + -1.205895925093074e-10, + 0.0, + 7.361850186601754e-11, + 1.1405070097036372e-10, + 1.2699480748014405e-10, + 1.1405070097036372e-10, + 7.361850186601754e-11, + 0.0, + -1.205895925093074e-10 + ], + [ + -1.8291982783515513e-10, + 0.0, + 1.1405070097036372e-10, + 1.7723159575786274e-10, + 1.9752831794225223e-10, + 1.7723159575786274e-10, + 1.1405070097036372e-10, + 0.0, + -1.8291982783515513e-10 + ], + [ + -2.0239213350149866e-10, + 0.0, + 1.2699480748014405e-10, + 1.9752831794225223e-10, + 2.2021040384223963e-10, + 1.9752831794225223e-10, + 1.2699480748014405e-10, + 0.0, + -2.0239213350149866e-10 + ], + [ + -1.8291982783515513e-10, + 0.0, + 1.1405070097036372e-10, + 1.7723159575786274e-10, + 1.9752831794225223e-10, + 1.7723159575786274e-10, + 1.1405070097036372e-10, + 0.0, + -1.8291982783515513e-10 + ], + [ + -1.205895925093074e-10, + 0.0, + 7.361850186601754e-11, + 1.1405070097036372e-10, + 1.2699480748014405e-10, + 1.1405070097036372e-10, + 7.361850186601754e-11, + 0.0, + -1.205895925093074e-10 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + 2.277769621759121e-10, + 0.0, + -1.205895925093074e-10, + -1.8291982783515513e-10, + -2.0239213350149866e-10, + -1.8291982783515513e-10, + -1.205895925093074e-10, + 0.0, + 2.277769621759121e-10 + ] + ], + "A_zero_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5 + ], + "values": [ + -0.020448889632694423, + 0.009347182603277604, + 0.01386260437167719, + 0.015233265496577664 + ], + "standardized_values": [ + -1354.9236789884947, + 1089.399669886343, + 1041.2961317927775, + 1026.535787863249 + ], + "covariance": [ + [ + 2.277769621759121e-10, + -1.205895925093074e-10, + -1.8291982783515513e-10, + -2.0239213350149866e-10 + ], + [ + -1.205895925093074e-10, + 7.361850186601754e-11, + 1.1405070097036372e-10, + 1.2699480748014405e-10 + ], + [ + -1.8291982783515513e-10, + 1.1405070097036372e-10, + 1.7723159575786274e-10, + 1.9752831794225223e-10 + ], + [ + -2.0239213350149866e-10, + 1.2699480748014405e-10, + 1.9752831794225223e-10, + 2.2021040384223963e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.9312396129987919, + -0.910406420339439, + -0.9036907013158513 + ], + [ + -0.9312396129987919, + 1.0, + 0.998467417434614, + 0.997409636134777 + ], + [ + -0.910406420339439, + 0.998467417434614, + 1.0, + 0.9998615664717914 + ], + [ + -0.9036907013158513, + 0.997409636134777, + 0.9998615664717914, + 1.0 + ] + ], + "standard_errors": [ + 1.5092281543090564e-05, + 8.580122485490376e-06, + 1.3312835751929892e-05, + 1.4839487991242812e-05 + ], + "eigenvalues_ascending": [ + 2.8325775775389542e-18, + 1.7806391098985883e-14, + 2.7489983545854037e-11, + 6.713296708725019e-10 + ], + "smallest_eigenvalue": 2.8325775775389542e-18, + "largest_eigenvalue": 6.713296708725019e-10, + "condition_number": 237003101.4140052, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 5160683.174482814, + "diagonal_dof": 4, + "chi2": 2278482.4346294403, + "dof": 4, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 1354.9236789884947 + }, + "A_norm_on_independent_coordinates": { + "value": 0.030491820009373005, + "se": 2.5653718984505843e-05, + "undefined_se": false + } + } + } + }, + "290": { + "spin0_is_interpolation": true, + "spin0_weights": { + "first": 0.5071180555555556, + "second": 0.4928819444444445 + }, + "equal_weights": { + "first": 0.5, + "second": 0.5 + }, + "analysis": { + "spin0": { + "n": 290, + "batches": 100, + "weights": { + "first": 0.5071180555555556, + "second": 0.4928819444444445 + }, + "weights_sum": 1.0, + "spin0_annihilates_cos4": 5.551115123125783e-17, + "orientation_cos4theta": { + "first": -0.9452080856123662, + "second": 0.9725089179548156 + }, + "orientation_representative": { + "first": [ + 13, + 11 + ], + "second": [ + 17, + 1 + ] + }, + "levels": [ + 0.1, + 0.2, + 0.3, + 0.4, + 0.5, + 0.6, + 0.7, + 0.8, + 0.9 + ], + "anchors": [ + 0.2, + 0.8 + ], + "W": 0.09220375008670778, + "W_se": 2.7653276113273542e-08, + "Q_pooled": [ + 0.5208860615139163, + 0.5461071902417818, + 0.5638915164071917, + 0.5788787691053758, + 0.5927517136919658, + 0.6065273014500907, + 0.6211934034174529, + 0.6383109403284896, + 0.6620648035717531 + ], + "Q_se": [ + 3.5951482222674192e-06, + 3.0202107252337597e-06, + 2.7408379377101e-06, + 2.5811010114445632e-06, + 2.5023648087879564e-06, + 2.4949577804538737e-06, + 2.5635409696527977e-06, + 2.7400648482895965e-06, + 3.186744362887533e-06 + ], + "Z_pooled": [ + -0.27353690825099575, + 0.0, + 0.19288072501048673, + 0.3554256614592778, + 0.505885318181959, + 0.6552890869567698, + 0.8143509684265612, + 1.0, + 1.2576236131494174 + ], + "Z_se": [ + 1.1741480842523586e-05, + 0.0, + 5.279817189548855e-06, + 7.670844841920307e-06, + 8.25889313046596e-06, + 7.3723745909714835e-06, + 4.887330069569993e-06, + 0.0, + 1.0796667807424056e-05 + ], + "A_pooled": [ + -0.01591329510157835, + 0.0, + 0.007231693437047992, + 0.01071474841604747, + 0.011770636363918063, + 0.01071474841604747, + 0.007231693437047992, + 0.0, + -0.01591329510157835 + ], + "A_se": [ + 1.743749195745137e-05, + 0.0, + 9.5834753710788e-06, + 1.482560519385557e-05, + 1.651778626088476e-05, + 1.482560519385557e-05, + 9.5834753710788e-06, + 0.0, + 1.743749195745137e-05 + ], + "Q_covariance": [ + [ + 1.2925090740072586e-11, + 1.0361811347947766e-11, + 8.653282447665018e-12, + 7.381937077037052e-12, + 6.385216886573721e-12, + 5.586830485028824e-12, + 4.954816033546406e-12, + 4.5062649208954755e-12, + 4.38988673252658e-12 + ], + [ + 1.0361811347947766e-11, + 9.121672824817033e-12, + 8.088336393665682e-12, + 7.195415703280983e-12, + 6.405342990876827e-12, + 5.699372405918487e-12, + 5.075700980813478e-12, + 4.567383716040982e-12, + 4.3324249090452146e-12 + ], + [ + 8.653282447665018e-12, + 8.088336393665682e-12, + 7.512192600790954e-12, + 6.9460213962687336e-12, + 6.389438278837886e-12, + 5.841806741726285e-12, + 5.309854700154127e-12, + 4.827673346202688e-12, + 4.544687301090201e-12 + ], + [ + 7.381937077037052e-12, + 7.195415703280983e-12, + 6.9460213962687336e-12, + 6.662082431280147e-12, + 6.345263849970596e-12, + 5.9944756769164495e-12, + 5.613598369495089e-12, + 5.2288466077889475e-12, + 4.965832461189381e-12 + ], + [ + 6.385216886573721e-12, + 6.405342990876827e-12, + 6.389438278837886e-12, + 6.345263849970596e-12, + 6.261829636260386e-12, + 6.1291645691445095e-12, + 5.942871226144005e-12, + 5.716571561737441e-12, + 5.541749100542416e-12 + ], + [ + 5.586830485028824e-12, + 5.699372405918487e-12, + 5.841806741726285e-12, + 5.9944756769164495e-12, + 6.1291645691445095e-12, + 6.224814326247319e-12, + 6.2681132547334816e-12, + 6.260374896859447e-12, + 6.257313306895126e-12 + ], + [ + 4.954816033546406e-12, + 5.075700980813478e-12, + 5.309854700154127e-12, + 5.613598369495089e-12, + 5.942871226144005e-12, + 6.2681132547334816e-12, + 6.571742303088407e-12, + 6.8511727001096605e-12, + 7.143512499903066e-12 + ], + [ + 4.5062649208954755e-12, + 4.567383716040982e-12, + 4.827673346202688e-12, + 5.2288466077889475e-12, + 5.716571561737441e-12, + 6.260374896859447e-12, + 6.8511727001096605e-12, + 7.507955372832291e-12, + 8.316125995627239e-12 + ], + [ + 4.38988673252658e-12, + 4.3324249090452146e-12, + 4.544687301090201e-12, + 4.965832461189381e-12, + 5.541749100542416e-12, + 6.257313306895126e-12, + 7.143512499903066e-12, + 8.316125995627239e-12, + 1.015533963439547e-11 + ] + ], + "Z_covariance": [ + [ + 1.3786237237534835e-10, + 0.0, + -5.478771516080708e-11, + -7.198064615697492e-11, + -6.84279218611294e-11, + -5.22472522649378e-11, + -2.8164119479639207e-11, + 0.0, + 2.4817858824038695e-11 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + -5.478771516080708e-11, + 0.0, + 2.7876469555055567e-11, + 3.985649948925866e-11, + 4.102042351774238e-11, + 3.3961618778154337e-11, + 2.0040267711831473e-11, + 0.0, + -2.4709796418142665e-11 + ], + [ + -7.198064615697492e-11, + 0.0, + 3.985649948925866e-11, + 5.884186058881539e-11, + 6.243520548728408e-11, + 5.330240083143775e-11, + 3.2512322002534225e-11, + 0.0, + -4.4602957301842665e-11 + ], + [ + -6.84279218611294e-11, + 0.0, + 4.102042351774238e-11, + 6.243520548728408e-11, + 6.820931574045782e-11, + 5.997676495910185e-11, + 3.7772401282678026e-11, + 0.0, + -5.7239809164792396e-11 + ], + [ + -5.22472522649378e-11, + 0.0, + 3.3961618778154337e-11, + 5.330240083143775e-11, + 5.997676495910185e-11, + 5.4351907109601955e-11, + 3.5378231781957516e-11, + 0.0, + -5.930780382613778e-11 + ], + [ + -2.8164119479639207e-11, + 0.0, + 2.0040267711831473e-11, + 3.2512322002534225e-11, + 3.7772401282678026e-11, + 3.5378231781957516e-11, + 2.3885995208923033e-11, + 0.0, + -4.4754132969281144e-11 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + 2.4817858824038695e-11, + 0.0, + -2.4709796418142665e-11, + -4.4602957301842665e-11, + -5.7239809164792396e-11, + -5.930780382613778e-11, + -4.4754132969281144e-11, + 0.0, + 1.1656803574386698e-10 + ] + ], + "A_covariance": [ + [ + 3.040661257661812e-10, + 0.0, + -1.5241576402842297e-10, + -2.281386595518211e-10, + -2.5133546205013346e-10, + -2.281386595518211e-10, + -1.5241576402842297e-10, + 0.0, + 3.040661257661812e-10 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + -1.5241576402842297e-10, + 0.0, + 9.184300018807396e-11, + 1.4170867205314044e-10, + 1.5758564960063602e-10, + 1.4170867205314044e-10, + 9.184300018807396e-11, + 0.0, + -1.5241576402842297e-10 + ], + [ + -2.281386595518211e-10, + 0.0, + 1.4170867205314044e-10, + 2.1979856936407724e-10, + 2.448239408935798e-10, + 2.1979856936407724e-10, + 1.4170867205314044e-10, + 0.0, + -2.281386595518211e-10 + ], + [ + -2.5133546205013346e-10, + 0.0, + 1.5758564960063602e-10, + 2.448239408935798e-10, + 2.7283726296027335e-10, + 2.448239408935798e-10, + 1.5758564960063602e-10, + 0.0, + -2.5133546205013346e-10 + ], + [ + -2.281386595518211e-10, + 0.0, + 1.4170867205314044e-10, + 2.1979856936407724e-10, + 2.448239408935798e-10, + 2.1979856936407724e-10, + 1.4170867205314044e-10, + 0.0, + -2.281386595518211e-10 + ], + [ + -1.5241576402842297e-10, + 0.0, + 9.184300018807396e-11, + 1.4170867205314044e-10, + 1.5758564960063602e-10, + 1.4170867205314044e-10, + 9.184300018807396e-11, + 0.0, + -1.5241576402842297e-10 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + 3.040661257661812e-10, + 0.0, + -1.5241576402842297e-10, + -2.281386595518211e-10, + -2.5133546205013346e-10, + -2.281386595518211e-10, + -1.5241576402842297e-10, + 0.0, + 3.040661257661812e-10 + ] + ], + "A_zero_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5 + ], + "values": [ + -0.01591329510157835, + 0.007231693437047992, + 0.01071474841604747, + 0.011770636363918063 + ], + "standardized_values": [ + -912.5908209969554, + 754.6003049031605, + 722.7191251854034, + 712.6037459263976 + ], + "covariance": [ + [ + 3.040661257661812e-10, + -1.5241576402842297e-10, + -2.281386595518211e-10, + -2.5133546205013346e-10 + ], + [ + -1.5241576402842297e-10, + 9.184300018807396e-11, + 1.4170867205314044e-10, + 1.5758564960063602e-10 + ], + [ + -2.281386595518211e-10, + 1.4170867205314044e-10, + 2.1979856936407724e-10, + 2.448239408935798e-10 + ], + [ + -2.5133546205013346e-10, + 1.5758564960063602e-10, + 2.448239408935798e-10, + 2.7283726296027335e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.9120587959471489, + -0.8824750479087388, + -0.8726054218269794 + ], + [ + -0.9120587959471489, + 1.0, + 0.9973807148800667, + 0.9955012121133551 + ], + [ + -0.8824750479087388, + 0.9973807148800667, + 1.0, + 0.9997458538192986 + ], + [ + -0.8726054218269794, + 0.9955012121133551, + 0.9997458538192986, + 1.0 + ] + ], + "standard_errors": [ + 1.743749195745137e-05, + 9.5834753710788e-06, + 1.482560519385557e-05, + 1.651778626088476e-05 + ], + "eigenvalues_ascending": [ + 1.3394043436549709e-17, + 8.073027523857786e-14, + 4.701683791128707e-11, + 8.414473766980379e-10 + ], + "smallest_eigenvalue": 1.3394043436549709e-17, + "largest_eigenvalue": 8.414473766980379e-10, + "condition_number": 62822506.189721145, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 2432370.6593449283, + "diagonal_dof": 4, + "chi2": 1000970.7397946715, + "dof": 4, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 912.5908209969554 + }, + "A_norm_on_independent_coordinates": { + "value": 0.023640728943671398, + "se": 2.876436295675836e-05, + "undefined_se": false + } + }, + "equal": { + "n": 290, + "batches": 100, + "weights": { + "first": 0.5, + "second": 0.5 + }, + "weights_sum": 1.0, + "spin0_annihilates_cos4": 0.0136504161712247, + "orientation_cos4theta": { + "first": -0.9452080856123662, + "second": 0.9725089179548156 + }, + "orientation_representative": { + "first": [ + 13, + 11 + ], + "second": [ + 17, + 1 + ] + }, + "levels": [ + 0.1, + 0.2, + 0.3, + 0.4, + 0.5, + 0.6, + 0.7, + 0.8, + 0.9 + ], + "anchors": [ + 0.2, + 0.8 + ], + "W": 0.092203864977904, + "W_se": 2.7651768484001912e-08, + "Q_pooled": [ + 0.5208853087914349, + 0.5461068039369366, + 0.5638912772550952, + 0.578878601942705, + 0.5927515781743864, + 0.6065271659958853, + 0.6211932313066768, + 0.6383106689148406, + 0.6620642643302688 + ], + "Q_se": [ + 3.5987446699785963e-06, + 3.0220126914065297e-06, + 2.7416551426390775e-06, + 2.5816536373024624e-06, + 2.5032113192726227e-06, + 2.4964400292707987e-06, + 2.5657013380144087e-06, + 2.7425228412081505e-06, + 3.1881565411690894e-06 + ], + "Z_pooled": [ + -0.27354054140296397, + 0.0, + 0.19288208062016285, + 0.35542759529247486, + 0.5058874077418329, + 0.6552909910384781, + 0.8143522767482054, + 1.0, + 1.2576203874004694 + ], + "Z_se": [ + 1.1732021124489118e-05, + 0.0, + 5.274797050842787e-06, + 7.663903067066915e-06, + 8.252382180558025e-06, + 7.367923173723825e-06, + 4.88541741201807e-06, + 0.0, + 1.0789503799491348e-05 + ], + "A_pooled": [ + -0.01592015400249447, + 0.0, + 0.007234357368368194, + 0.010718586330952906, + 0.01177481548366588, + 0.010718586330952906, + 0.007234357368368194, + 0.0, + -0.01592015400249447 + ], + "A_se": [ + 1.7405590566346287e-05, + 0.0, + 9.5749388439063e-06, + 1.481363431650578e-05, + 1.650476436114307e-05, + 1.481363431650578e-05, + 9.5749388439063e-06, + 0.0, + 1.7405590566346287e-05 + ], + "Q_covariance": [ + [ + 1.2950963199699355e-11, + 1.0380344128738725e-11, + 8.668475567583562e-12, + 7.395939388522352e-12, + 6.3995431230785336e-12, + 5.602493953357187e-12, + 4.972076224986963e-12, + 4.523714830235969e-12, + 4.401282154904566e-12 + ], + [ + 1.0380344128738725e-11, + 9.132560707022138e-12, + 8.095851603419855e-12, + 7.201746350080938e-12, + 6.412104553972979e-12, + 5.707798250241673e-12, + 5.086474218943756e-12, + 4.5799743392002096e-12, + 4.342956182268842e-12 + ], + [ + 8.668475567583562e-12, + 8.095851603419855e-12, + 7.516672921159302e-12, + 6.949590823526302e-12, + 6.393640444723625e-12, + 5.847879452799611e-12, + 5.318597619294814e-12, + 4.8388553528209625e-12, + 4.555208971644119e-12 + ], + [ + 7.395939388522352e-12, + 7.201746350080938e-12, + 6.949590823526302e-12, + 6.664935502997033e-12, + 6.348835394220252e-12, + 5.999937359251604e-12, + 5.621746886084282e-12, + 5.239525350971085e-12, + 4.976132112014552e-12 + ], + [ + 6.3995431230785336e-12, + 6.412104553972979e-12, + 6.393640444723625e-12, + 6.348835394220252e-12, + 6.266066908934585e-12, + 6.135132370105912e-12, + 5.951307438141651e-12, + 5.727314122051352e-12, + 5.551915188951845e-12 + ], + [ + 5.602493953357187e-12, + 5.707798250241673e-12, + 5.847879452799611e-12, + 5.999937359251604e-12, + 6.135132370105912e-12, + 6.232212819745586e-12, + 6.277593540809797e-12, + 6.271754585157279e-12, + 6.267748379681414e-12 + ], + [ + 4.972076224986963e-12, + 5.086474218943756e-12, + 5.318597619294814e-12, + 5.621746886084282e-12, + 5.951307438141651e-12, + 6.277593540809797e-12, + 6.582823355888928e-12, + 6.863672209607704e-12, + 7.154686999028771e-12 + ], + [ + 4.523714830235969e-12, + 4.5799743392002096e-12, + 4.8388553528209625e-12, + 5.239525350971085e-12, + 5.727314122051352e-12, + 6.271754585157279e-12, + 6.863672209607704e-12, + 7.521431534548426e-12, + 8.327899551860589e-12 + ], + [ + 4.401282154904566e-12, + 4.342956182268842e-12, + 4.555208971644119e-12, + 4.976132112014552e-12, + 5.551915188951845e-12, + 6.267748379681414e-12, + 7.154686999028771e-12, + 8.327899551860589e-12, + 1.016434213099925e-11 + ] + ], + "Z_covariance": [ + [ + 1.376403196654589e-10, + 0.0, + -5.4652415076033684e-11, + -7.176660209456714e-11, + -6.818497698560937e-11, + -5.2022912198406934e-11, + -2.801127254361588e-11, + 0.0, + 2.445043552919454e-11 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + -5.4652415076033684e-11, + 0.0, + 2.7823483927579764e-11, + 3.9779650081538394e-11, + 4.0938068819524545e-11, + 3.388953765364752e-11, + 1.999433332422314e-11, + 0.0, + -2.4617477076738417e-11 + ], + [ + -7.176660209456714e-11, + 0.0, + 3.9779650081538394e-11, + 5.873541022139767e-11, + 6.23259269146308e-11, + 5.321102977634423e-11, + 3.24573127436846e-11, + 0.0, + -4.4508908604298334e-11 + ], + [ + -6.818497698560937e-11, + 0.0, + 4.0938068819524545e-11, + 6.23259269146308e-11, + 6.810181165399164e-11, + 5.98908618258475e-11, + 3.772347480630247e-11, + 0.0, + -5.716778790883518e-11 + ], + [ + -5.2022912198406934e-11, + 0.0, + 3.388953765364752e-11, + 5.321102977634423e-11, + 5.98908618258475e-11, + 5.4286291893896553e-11, + 3.53426249516915e-11, + 0.0, + -5.925789413383013e-11 + ], + [ + -2.801127254361588e-11, + 0.0, + 1.999433332422314e-11, + 3.24573127436846e-11, + 3.772347480630247e-11, + 3.53426249516915e-11, + 2.3867303289649335e-11, + 0.0, + -4.4722472431940294e-11 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + 2.445043552919454e-11, + 0.0, + -2.4617477076738417e-11, + -4.4508908604298334e-11, + -5.716778790883518e-11, + -5.925789413383013e-11, + -4.4722472431940294e-11, + 0.0, + 1.1641339223923824e-10 + ] + ], + "A_covariance": [ + [ + 3.029545829632829e-10, + 0.0, + -1.520036371273206e-10, + -2.2755631702934664e-10, + -2.507055297907504e-10, + -2.2755631702934664e-10, + -1.520036371273206e-10, + 0.0, + 3.029545829632829e-10 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + -1.520036371273206e-10, + 0.0, + 9.167945386454572e-11, + 1.4146912542824325e-10, + 1.573230872511498e-10, + 1.4146912542824325e-10, + 9.167945386454572e-11, + 0.0, + -1.520036371273206e-10 + ], + [ + -2.2755631702934664e-10, + 0.0, + 1.4146912542824325e-10, + 2.1944376166315766e-10, + 2.4443357747868745e-10, + 2.1944376166315766e-10, + 1.4146912542824325e-10, + 0.0, + -2.2755631702934664e-10 + ], + [ + -2.507055297907504e-10, + 0.0, + 1.573230872511498e-10, + 2.4443357747868745e-10, + 2.7240724661685843e-10, + 2.4443357747868745e-10, + 1.573230872511498e-10, + 0.0, + -2.507055297907504e-10 + ], + [ + -2.2755631702934664e-10, + 0.0, + 1.4146912542824325e-10, + 2.1944376166315766e-10, + 2.4443357747868745e-10, + 2.1944376166315766e-10, + 1.4146912542824325e-10, + 0.0, + -2.2755631702934664e-10 + ], + [ + -1.520036371273206e-10, + 0.0, + 9.167945386454572e-11, + 1.4146912542824325e-10, + 1.573230872511498e-10, + 1.4146912542824325e-10, + 9.167945386454572e-11, + 0.0, + -1.520036371273206e-10 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + 3.029545829632829e-10, + 0.0, + -1.520036371273206e-10, + -2.2755631702934664e-10, + -2.507055297907504e-10, + -2.2755631702934664e-10, + -1.520036371273206e-10, + 0.0, + 3.029545829632829e-10 + ] + ], + "A_zero_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5 + ], + "values": [ + -0.01592015400249447, + 0.007234357368368194, + 0.010718586330952906, + 0.01177481548366588 + ], + "standardized_values": [ + -914.6575028184387, + 755.551287199322, + 723.56223340885, + 713.4191816386763 + ], + "covariance": [ + [ + 3.029545829632829e-10, + -1.520036371273206e-10, + -2.2755631702934664e-10, + -2.507055297907504e-10 + ], + [ + -1.520036371273206e-10, + 9.167945386454572e-11, + 1.4146912542824325e-10, + 1.573230872511498e-10 + ], + [ + -2.2755631702934664e-10, + 1.4146912542824325e-10, + 2.1944376166315766e-10, + 2.4443357747868745e-10 + ], + [ + -2.507055297907504e-10, + 1.573230872511498e-10, + 2.4443357747868745e-10, + 2.7240724661685843e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.9120721770931335, + -0.8825483618729129, + -0.8727016993381853 + ], + [ + -0.9120721770931335, + 1.0, + 0.9973877739579424, + 0.9955134298807278 + ], + [ + -0.8825483618729129, + 0.9973877739579424, + 1.0, + 0.9997465546960946 + ], + [ + -0.8727016993381853, + 0.9955134298807278, + 0.9997465546960946, + 1.0 + ] + ], + "standard_errors": [ + 1.7405590566346287e-05, + 9.5749388439063e-06, + 1.481363431650578e-05, + 1.650476436114307e-05 + ], + "eigenvalues_ascending": [ + 1.336916160108217e-17, + 8.087538643932334e-14, + 4.6846255058801176e-11, + 8.395579012934436e-10 + ], + "smallest_eigenvalue": 1.336916160108217e-17, + "largest_eigenvalue": 8.395579012934436e-10, + "condition_number": 62798096.57065447, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 2439965.329396216, + "diagonal_dof": 4, + "chi2": 1006340.7821694613, + "dof": 4, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 914.6575028184387 + }, + "A_norm_on_independent_coordinates": { + "value": 0.023649981027579536, + "se": 2.8729995775620732e-05, + "undefined_se": false + } + } + } + }, + "725": { + "spin0_is_interpolation": true, + "spin0_weights": { + "first": 0.5382777069160998, + "second": 0.4617222930839002 + }, + "equal_weights": { + "first": 0.5, + "second": 0.5 + }, + "analysis": { + "spin0": { + "n": 725, + "batches": 100, + "weights": { + "first": 0.5382777069160998, + "second": 0.4617222930839002 + }, + "weights_sum": 1.0, + "spin0_annihilates_cos4": 0.0, + "orientation_cos4theta": { + "first": 0.4958535077288942, + "second": -0.5780680142687277 + }, + "orientation_representative": { + "first": [ + 26, + 7 + ], + "second": [ + 23, + 14 + ] + }, + "levels": [ + 0.1, + 0.2, + 0.3, + 0.4, + 0.5, + 0.6, + 0.7, + 0.8, + 0.9 + ], + "anchors": [ + 0.2, + 0.8 + ], + "W": 0.0655307631613844, + "W_se": 2.3460217893301367e-08, + "Q_pooled": [ + 0.5418336218910869, + 0.5597068065994498, + 0.5722960076752488, + 0.582909585882762, + 0.5927464521537054, + 0.6025341207843034, + 0.6129854231453626, + 0.6252375697608342, + 0.642367299065417 + ], + "Q_se": [ + 2.7364466164714398e-06, + 2.3514597244940725e-06, + 2.202382426910255e-06, + 2.1161444330213457e-06, + 2.0754989984726192e-06, + 2.0731311520027453e-06, + 2.099145548950807e-06, + 2.1734829728405757e-06, + 2.4458593241435128e-06 + ], + "Z_pooled": [ + -0.2727449497932168, + 0.0, + 0.1921113148765749, + 0.35407460807636315, + 0.5041852705558747, + 0.6535451766276784, + 0.8130321390383035, + 1.0, + 1.2613998140445417 + ], + "Z_se": [ + 1.4618717841470781e-05, + 0.0, + 6.25004612595017e-06, + 9.13424225640156e-06, + 1.0080438678901385e-05, + 9.328256481776152e-06, + 6.381952069431223e-06, + 0.0, + 1.304966020210011e-05 + ], + "A_pooled": [ + -0.011345135748675128, + 0.0, + 0.005143453914878471, + 0.007619784704041566, + 0.008370541111749397, + 0.007619784704041566, + 0.005143453914878471, + 0.0, + -0.011345135748675128 + ], + "A_se": [ + 2.1619875941943583e-05, + 0.0, + 1.1668562882139537e-05, + 1.8071753376314797e-05, + 2.0160877357846554e-05, + 1.8071753376314797e-05, + 1.1668562882139537e-05, + 0.0, + 2.1619875941943583e-05 + ], + "Q_covariance": [ + [ + 7.488140084797991e-12, + 5.9960418794000344e-12, + 5.023259658504137e-12, + 4.262705325652405e-12, + 3.615186602252418e-12, + 3.0375590165757237e-12, + 2.499286305028406e-12, + 1.9631532222508794e-12, + 1.390359269531952e-12 + ], + [ + 5.9960418794000344e-12, + 5.529362835917739e-12, + 5.031971969318309e-12, + 4.5185489812630644e-12, + 4.00582007258188e-12, + 3.4990159625837975e-12, + 2.985898880356724e-12, + 2.429549407943466e-12, + 1.7752514747678504e-12 + ], + [ + 5.023259658504137e-12, + 5.031971969318309e-12, + 4.850488354363104e-12, + 4.562443096468e-12, + 4.212402250386053e-12, + 3.817616013666292e-12, + 3.3706992552621225e-12, + 2.835919336087227e-12, + 2.1529171938741614e-12 + ], + [ + 4.262705325652405e-12, + 4.5185489812630644e-12, + 4.562443096468e-12, + 4.478067261407232e-12, + 4.304792661797238e-12, + 4.053472359651438e-12, + 3.710937501971451e-12, + 3.2380099865789124e-12, + 2.572824661776791e-12 + ], + [ + 3.615186602252418e-12, + 4.00582007258188e-12, + 4.212402250386053e-12, + 4.304792661797238e-12, + 4.307696092660846e-12, + 4.218503590416561e-12, + 4.012710378268729e-12, + 3.643392129458364e-12, + 3.0454267584625957e-12 + ], + [ + 3.0375590165757237e-12, + 3.4990159625837975e-12, + 3.817616013666292e-12, + 4.053472359651438e-12, + 4.218503590416561e-12, + 4.29787277340423e-12, + 4.256698280981272e-12, + 4.040533466024925e-12, + 3.577612322402977e-12 + ], + [ + 2.499286305028406e-12, + 2.985898880356724e-12, + 3.3706992552621225e-12, + 3.710937501971451e-12, + 4.012710378268729e-12, + 4.256698280981272e-12, + 4.4064120356799865e-12, + 4.4091638098428026e-12, + 4.1905294069945455e-12 + ], + [ + 1.9631532222508794e-12, + 2.429549407943466e-12, + 2.835919336087227e-12, + 3.2380099865789124e-12, + 3.643392129458364e-12, + 4.040533466024925e-12, + 4.4091638098428026e-12, + 4.724028233227906e-12, + 4.943402287264539e-12 + ], + [ + 1.390359269531952e-12, + 1.7752514747678504e-12, + 2.1529171938741614e-12, + 2.572824661776791e-12, + 3.0454267584625957e-12, + 3.577612322402977e-12, + 4.1905294069945455e-12, + 4.943402287264539e-12, + 5.982227833499761e-12 + ] + ], + "Z_covariance": [ + [ + 2.1370691132853614e-10, + 0.0, + -7.737920077010664e-11, + -9.707909537653423e-11, + -8.896781011968655e-11, + -6.676642229762264e-11, + -3.6609508422062946e-11, + 0.0, + 4.170924651273375e-11 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + -7.737920077010664e-11, + 0.0, + 3.9063076576504734e-11, + 5.558842051594235e-11, + 5.7033321662960736e-11, + 4.7289308873356e-11, + 2.8181485470751244e-11, + 0.0, + -3.770129709894013e-11 + ], + [ + -9.707909537653423e-11, + 0.0, + 5.558842051594235e-11, + 8.343438159863187e-11, + 8.995252313389393e-11, + 7.806875975370579e-11, + 4.845832055406909e-11, + 0.0, + -6.905049962209259e-11 + ], + [ + -8.896781011968655e-11, + 0.0, + 5.7033321662960736e-11, + 8.995252313389393e-11, + 1.0161524395909109e-10, + 9.211832636022862e-11, + 5.950349227610489e-11, + 0.0, + -9.053388302487498e-11 + ], + [ + -6.676642229762264e-11, + 0.0, + 4.7289308873356e-11, + 7.806875975370579e-11, + 9.211832636022862e-11, + 8.701636898979879e-11, + 5.841866411430612e-11, + 0.0, + -9.54546249083449e-11 + ], + [ + -3.6609508422062946e-11, + 0.0, + 2.8181485470751244e-11, + 4.845832055406909e-11, + 5.950349227610489e-11, + 5.841866411430612e-11, + 4.0729312216517474e-11, + 0.0, + -7.232004345029046e-11 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + 4.170924651273375e-11, + 0.0, + -3.770129709894013e-11, + -6.905049962209259e-11, + -9.053388302487498e-11, + -9.54546249083449e-11, + -7.232004345029046e-11, + 0.0, + 1.702936313902755e-10 + ] + ], + "A_covariance": [ + [ + 4.67419035745031e-10, + 0.0, + -2.2401004974072727e-10, + -3.283506422032123e-10, + -3.590033862911593e-10, + -3.283506422032123e-10, + -2.2401004974072727e-10, + 0.0, + 4.67419035745031e-10 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + -2.2401004974072727e-10, + 0.0, + 1.3615535973444453e-10, + 2.097547140571906e-10, + 2.330736278788911e-10, + 2.097547140571906e-10, + 1.3615535973444453e-10, + 0.0, + -2.2401004974072727e-10 + ], + [ + -3.283506422032123e-10, + 0.0, + 2.097547140571906e-10, + 3.265882700943453e-10, + 3.641416989882874e-10, + 3.265882700943453e-10, + 2.097547140571906e-10, + 0.0, + -3.283506422032123e-10 + ], + [ + -3.590033862911593e-10, + 0.0, + 2.330736278788911e-10, + 3.641416989882874e-10, + 4.0646097583812986e-10, + 3.641416989882874e-10, + 2.330736278788911e-10, + 0.0, + -3.590033862911593e-10 + ], + [ + -3.283506422032123e-10, + 0.0, + 2.097547140571906e-10, + 3.265882700943453e-10, + 3.641416989882874e-10, + 3.265882700943453e-10, + 2.097547140571906e-10, + 0.0, + -3.283506422032123e-10 + ], + [ + -2.2401004974072727e-10, + 0.0, + 1.3615535973444453e-10, + 2.097547140571906e-10, + 2.330736278788911e-10, + 2.097547140571906e-10, + 1.3615535973444453e-10, + 0.0, + -2.2401004974072727e-10 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + 4.67419035745031e-10, + 0.0, + -2.2401004974072727e-10, + -3.283506422032123e-10, + -3.590033862911593e-10, + -3.283506422032123e-10, + -2.2401004974072727e-10, + 0.0, + 4.67419035745031e-10 + ] + ], + "A_zero_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5 + ], + "values": [ + -0.011345135748675128, + 0.005143453914878471, + 0.007619784704041566, + 0.008370541111749397 + ], + "standardized_values": [ + -524.7548958717671, + 440.7958346568358, + 421.64058712909446, + 415.1873434462219 + ], + "covariance": [ + [ + 4.67419035745031e-10, + -2.2401004974072727e-10, + -3.283506422032123e-10, + -3.590033862911593e-10 + ], + [ + -2.2401004974072727e-10, + 1.3615535973444453e-10, + 2.097547140571906e-10, + 2.330736278788911e-10 + ], + [ + -3.283506422032123e-10, + 2.097547140571906e-10, + 3.265882700943453e-10, + 3.641416989882874e-10 + ], + [ + -3.590033862911593e-10, + 2.330736278788911e-10, + 3.641416989882874e-10, + 4.0646097583812986e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.887967220355276, + -0.8403967830164423, + -0.8236371359468578 + ], + [ + -0.887967220355276, + 1.0, + 0.9947044660664957, + 0.9907551476337533 + ], + [ + -0.8403967830164423, + 0.9947044660664957, + 1.0, + 0.9994491322697057 + ], + [ + -0.8236371359468578, + 0.9907551476337533, + 0.9994491322697057, + 1.0 + ] + ], + "standard_errors": [ + 2.1619875941943583e-05, + 1.1668562882139537e-05, + 1.8071753376314797e-05, + 2.0160877357846554e-05 + ], + "eigenvalues_ascending": [ + 7.214806498932176e-17, + 2.572991548339326e-13, + 9.741741609298587e-11, + 1.238948854016066e-09 + ], + "smallest_eigenvalue": 7.214806498932176e-17, + "largest_eigenvalue": 1.238948854016066e-09, + "condition_number": 17172308.837380964, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 819829.9834647041, + "diagonal_dof": 4, + "chi2": 355970.477979064, + "dof": 4, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 524.7548958717671 + }, + "A_norm_on_independent_coordinates": { + "value": 0.016831348750762004, + "se": 3.491068175029809e-05, + "undefined_se": false + } + }, + "equal": { + "n": 725, + "batches": 100, + "weights": { + "first": 0.5, + "second": 0.5 + }, + "weights_sum": 1.0, + "spin0_annihilates_cos4": -0.04110725326991674, + "orientation_cos4theta": { + "first": 0.4958535077288942, + "second": -0.5780680142687277 + }, + "orientation_representative": { + "first": [ + 26, + 7 + ], + "second": [ + 23, + 14 + ] + }, + "levels": [ + 0.1, + 0.2, + 0.3, + 0.4, + 0.5, + 0.6, + 0.7, + 0.8, + 0.9 + ], + "anchors": [ + 0.2, + 0.8 + ], + "W": 0.06553049962604973, + "W_se": 2.3359166678670787e-08, + "Q_pooled": [ + 0.5418342329710413, + 0.5597071641375351, + 0.572296259747219, + 0.5829097663412028, + 0.5927465782512797, + 0.6025342095906012, + 0.612985496943196, + 0.6252376637635848, + 0.6423674978344991 + ], + "Q_se": [ + 2.719774985560058e-06, + 2.3216613763442573e-06, + 2.171870853176986e-06, + 2.0890560794679786e-06, + 2.0517412019259726e-06, + 2.0507203616941416e-06, + 2.0760822485232236e-06, + 2.1508749573270836e-06, + 2.433992786489122e-06 + ], + "Z_pooled": [ + -0.27274217758884506, + 0.0, + 0.19211047804493592, + 0.3540733297635999, + 0.5041837663726711, + 0.6535437040379517, + 0.8130310788059629, + 1.0, + 1.2614024640231007 + ], + "Z_se": [ + 1.451212325693415e-05, + 0.0, + 6.267382016199606e-06, + 9.172206025937887e-06, + 1.0131541342793914e-05, + 9.381318821973044e-06, + 6.419951233405164e-06, + 0.0, + 1.31470670126732e-05 + ], + "A_pooled": [ + -0.011339713565744258, + 0.0, + 0.0051415568508987874, + 0.007617033801551543, + 0.008367532745342299, + 0.007617033801551543, + 0.0051415568508987874, + 0.0, + -0.011339713565744258 + ], + "A_se": [ + 2.1646786252592464e-05, + 0.0, + 1.1729576160607203e-05, + 1.816537960252663e-05, + 2.0263082685583216e-05, + 1.816537960252663e-05, + 1.1729576160607203e-05, + 0.0, + 2.1646786252592464e-05 + ], + "Q_covariance": [ + [ + 7.397175972078215e-12, + 5.875844076547167e-12, + 4.8911426562264486e-12, + 4.127296696351529e-12, + 3.4808241397809013e-12, + 2.906591827170208e-12, + 2.374162035704677e-12, + 1.8500912725813568e-12, + 1.3112941164813652e-12 + ], + [ + 5.875844076547167e-12, + 5.390111546408711e-12, + 4.8918768361300525e-12, + 4.383196853186496e-12, + 3.87722550909075e-12, + 3.378156801216489e-12, + 2.874620164378571e-12, + 2.3342262160813593e-12, + 1.7177638459751408e-12 + ], + [ + 4.8911426562264486e-12, + 4.8918768361300525e-12, + 4.717023002879729e-12, + 4.437925567590282e-12, + 4.0966148756337284e-12, + 3.710036302719839e-12, + 3.2721945242063483e-12, + 2.752327179739332e-12, + 2.1053793885688415e-12 + ], + [ + 4.127296696351529e-12, + 4.383196853186496e-12, + 4.437925567590282e-12, + 4.364155303162122e-12, + 4.199546320386588e-12, + 3.955175085687467e-12, + 3.6196398769484183e-12, + 3.158936375767466e-12, + 2.5259145547496823e-12 + ], + [ + 3.4808241397809013e-12, + 3.87722550909075e-12, + 4.0966148756337284e-12, + 4.199546320386588e-12, + 4.2096419596806354e-12, + 4.124929629389244e-12, + 3.9230235831116595e-12, + 3.56235972921457e-12, + 2.9919095779847153e-12 + ], + [ + 2.906591827170208e-12, + 3.378156801216489e-12, + 3.710036302719839e-12, + 3.955175085687467e-12, + 4.124929629389244e-12, + 4.205454001866951e-12, + 4.164367181176159e-12, + 3.9528784397333646e-12, + 3.512976669288564e-12 + ], + [ + 2.374162035704677e-12, + 2.874620164378571e-12, + 3.2721945242063483e-12, + 3.6196398769484183e-12, + 3.9230235831116595e-12, + 4.164367181176159e-12, + 4.310117502633243e-12, + 4.3136917599491145e-12, + 4.114570676568451e-12 + ], + [ + 1.8500912725813568e-12, + 2.3342262160813593e-12, + 2.752327179739332e-12, + 3.158936375767466e-12, + 3.56235972921457e-12, + 3.9528784397333646e-12, + 4.3136917599491145e-12, + 4.626263082056784e-12, + 4.8636810158605124e-12 + ], + [ + 1.3112941164813652e-12, + 1.7177638459751408e-12, + 2.1053793885688415e-12, + 2.5259145547496823e-12, + 2.9919095779847153e-12, + 3.512976669288564e-12, + 4.114570676568451e-12, + 4.8636810158605124e-12, + 5.924320884681081e-12 + ] + ], + "Z_covariance": [ + [ + 2.1060172142444905e-10, + 0.0, + -7.694831548400605e-11, + -9.666895408045056e-11, + -8.871305553314179e-11, + -6.671460178589728e-11, + -3.669667522477889e-11, + 0.0, + 4.2568131301564986e-11 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + -7.694831548400605e-11, + 0.0, + 3.928007733698224e-11, + 5.598450509677277e-11, + 5.7527765212353105e-11, + 4.7788790679099156e-11, + 2.8543552866298463e-11, + 0.0, + -3.853872856386071e-11 + ], + [ + -9.666895408045056e-11, + 0.0, + 5.598450509677277e-11, + 8.412936338225127e-11, + 9.080495501786615e-11, + 7.89212549388739e-11, + 4.9075608253458574e-11, + 0.0, + -7.04913606557615e-11 + ], + [ + -8.871305553314179e-11, + 0.0, + 5.7527765212353105e-11, + 9.080495501786615e-11, + 1.0264812998074229e-10, + 9.313933602217739e-11, + 6.02378137241897e-11, + 0.0, + -9.225873929021286e-11 + ], + [ + -6.671460178589728e-11, + 0.0, + 4.7788790679099156e-11, + 7.89212549388739e-11, + 9.313933602217739e-11, + 8.80091428395057e-11, + 5.91211240125471e-11, + 0.0, + -9.708572312660279e-11 + ], + [ + -3.669667522477889e-11, + 0.0, + 2.8543552866298463e-11, + 4.9075608253458574e-11, + 6.02378137241897e-11, + 5.91211240125471e-11, + 4.121577383930048e-11, + 0.0, + -7.342346161059078e-11 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + 4.2568131301564986e-11, + 0.0, + -3.853872856386071e-11, + -7.04913606557615e-11, + -9.225873929021286e-11, + -9.708572312660279e-11, + -7.342346161059078e-11, + 0.0, + 1.728453710357198e-10 + ] + ], + "A_covariance": [ + [ + 4.685833550654261e-10, + 0.0, + -2.2560718088225852e-10, + -3.3096063965201377e-10, + -3.6194358964724936e-10, + -3.3096063965201377e-10, + -2.2560718088225852e-10, + 0.0, + 4.685833550654261e-10 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + -2.2560718088225852e-10, + 0.0, + 1.375829569074848e-10, + 2.1197002804237624e-10, + 2.3553115787205436e-10, + 2.1197002804237624e-10, + 1.375829569074848e-10, + 0.0, + -2.2560718088225852e-10 + ], + [ + -3.3096063965201377e-10, + 0.0, + 2.1197002804237624e-10, + 3.299810161038906e-10, + 3.6788858208244006e-10, + 3.299810161038906e-10, + 2.1197002804237624e-10, + 0.0, + -3.3096063965201377e-10 + ], + [ + -3.6194358964724936e-10, + 0.0, + 2.3553115787205436e-10, + 3.6788858208244006e-10, + 4.105925199227823e-10, + 3.6788858208244006e-10, + 2.3553115787205436e-10, + 0.0, + -3.6194358964724936e-10 + ], + [ + -3.3096063965201377e-10, + 0.0, + 2.1197002804237624e-10, + 3.299810161038906e-10, + 3.6788858208244006e-10, + 3.299810161038906e-10, + 2.1197002804237624e-10, + 0.0, + -3.3096063965201377e-10 + ], + [ + -2.2560718088225852e-10, + 0.0, + 1.375829569074848e-10, + 2.1197002804237624e-10, + 2.3553115787205436e-10, + 2.1197002804237624e-10, + 1.375829569074848e-10, + 0.0, + -2.2560718088225852e-10 + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + [ + 4.685833550654261e-10, + 0.0, + -2.2560718088225852e-10, + -3.3096063965201377e-10, + -3.6194358964724936e-10, + -3.3096063965201377e-10, + -2.2560718088225852e-10, + 0.0, + 4.685833550654261e-10 + ] + ], + "A_zero_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5 + ], + "values": [ + -0.011339713565744258, + 0.0051415568508987874, + 0.007617033801551543, + 0.008367532745342299 + ], + "standardized_values": [ + -523.8520597664326, + 438.34123079112396, + 419.3159718221405, + 412.9447071395328 + ], + "covariance": [ + [ + 4.685833550654261e-10, + -2.2560718088225852e-10, + -3.3096063965201377e-10, + -3.6194358964724936e-10 + ], + [ + -2.2560718088225852e-10, + 1.375829569074848e-10, + 2.1197002804237624e-10, + 2.3553115787205436e-10 + ], + [ + -3.3096063965201377e-10, + 2.1197002804237624e-10, + 3.299810161038906e-10, + 3.6788858208244006e-10 + ], + [ + -3.6194358964724936e-10, + 2.3553115787205436e-10, + 3.6788858208244006e-10, + 4.105925199227823e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.8885403824815485, + -0.8416633971716136, + -0.8251671757063378 + ], + [ + -0.8885403824815485, + 1.0, + 0.9948272206626723, + 0.9909700543949814 + ], + [ + -0.8416633971716136, + 0.9948272206626723, + 1.0, + 0.9994620645670492 + ], + [ + -0.8251671757063378, + 0.9909700543949814, + 0.9994620645670492, + 1.0 + ] + ], + "standard_errors": [ + 2.1646786252592464e-05, + 1.1729576160607203e-05, + 1.816537960252663e-05, + 2.0263082685583216e-05 + ], + "eigenvalues_ascending": [ + 7.31988267046336e-17, + 2.539993649781752e-13, + 9.712182707630485e-11, + 1.2493639483594743e-09 + ], + "smallest_eigenvalue": 7.31988267046336e-17, + "largest_eigenvalue": 1.2493639483594743e-09, + "condition_number": 17068087.08014971, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 812913.230512712, + "diagonal_dof": 4, + "chi2": 355104.056314826, + "dof": 4, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 523.8520597664326 + }, + "A_norm_on_independent_coordinates": { + "value": 0.016824372760447952, + "se": 3.504885404041118e-05, + "undefined_se": false + } + } + } + } + }, + "adjacent_size": { + "145->290": { + "spin0": { + "from": 145, + "to": 290, + "covariance_convention": "Cov(delta) = Cov(from) + Cov(to); the two sizes have distinct producer seeds, so the cross-size term is taken as zero on recorded random-stream provenance (not batch IDs)", + "delta_Z": [ + 0.0002919720504865886, + 0.0, + -0.0006938601780565601, + -0.0013161141159384604, + -0.001736501130546908, + -0.0018412425441974856, + -0.0014281706866389188, + 0.0, + 0.004259909731390676 + ], + "delta_Z_se": [ + 1.5659400428760544e-05, + 0.0, + 7.057651955911099e-06, + 1.0299850688195838e-05, + 1.110660931350631e-05, + 9.8958426854876e-06, + 6.519600832957368e-06, + 0.0, + 1.3806400115309406e-05 + ], + "delta_A": [ + 0.004551881781877265, + 0.0, + -0.0021220308646954233, + -0.003157356660135946, + -0.003473002261093816, + -0.003157356660135946, + -0.0021220308646954233, + 0.0, + 0.004551881781877265 + ], + "delta_A_se": [ + 2.3076117765743325e-05, + 0.0, + 1.2868788647400758e-05, + 1.9933520695274096e-05, + 2.2213218626967898e-05, + 1.9933520695274096e-05, + 1.2868788647400758e-05, + 0.0, + 2.3076117765743325e-05 + ], + "Z_zero_displacement_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5, + 0.6, + 0.7, + 0.9 + ], + "values": [ + 0.0002919720504865886, + -0.0006938601780565601, + -0.0013161141159384604, + -0.001736501130546908, + -0.0018412425441974856, + -0.0014281706866389188, + 0.004259909731390676 + ], + "standardized_values": [ + 18.645161531877275, + -98.31317588216024, + -127.77992184360453, + -156.34844816547363, + -186.06222862633973, + -219.05799499554388, + 308.5460145883372 + ], + "covariance": [ + [ + 2.452168217882659e-10, + -9.826680850440196e-11, + -1.3073573725420493e-10, + -1.2596820523747122e-10, + -9.749319286753128e-11, + -5.3251355159578466e-11, + 4.833685260311993e-11 + ], + [ + -9.826680850440196e-11, + 4.981045113077576e-11, + 7.165818558066482e-11, + 7.423269260369884e-11, + 6.182443443267546e-11, + 3.664503754866582e-11, + -4.4901297014798365e-11 + ], + [ + -1.3073573725420493e-10, + 7.165818558066482e-11, + 1.0608692419912827e-10, + 1.1292189694758181e-10, + 9.666531032554695e-11, + 5.904200471224253e-11, + -7.98551478611928e-11 + ], + [ + -1.2596820523747122e-10, + 7.423269260369884e-11, + 1.1292189694758181e-10, + 1.2335677044286512e-10, + 1.0842711714510041e-10, + 6.817459750968682e-11, + -1.0115681719985068e-10 + ], + [ + -9.749319286753128e-11, + 6.182443443267546e-11, + 9.666531032554695e-11, + 1.0842711714510041e-10, + 9.792770245591843e-11, + 6.34480301971854e-11, + -1.034492420582447e-10 + ], + [ + -5.3251355159578466e-11, + 3.664503754866582e-11, + 5.904200471224253e-11, + 6.817459750968682e-11, + 6.34480301971854e-11, + 4.250519502109841e-11, + -7.690438690642958e-11 + ], + [ + 4.833685260311993e-11, + -4.4901297014798365e-11, + -7.98551478611928e-11, + -1.0115681719985068e-10, + -1.034492420582447e-10, + -7.690438690642958e-11, + 1.9061668414401557e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.8891427345749383, + -0.8105657737968923, + -0.7242763706080145, + -0.629138671972165, + -0.5215963313306481, + 0.22357476528514444 + ], + [ + -0.8891427345749383, + 1.0, + 0.9857678294896732, + 0.9470076359340278, + 0.8852116723881874, + 0.7964049063693659, + -0.46080607223813475 + ], + [ + -0.8105657737968923, + 0.9857678294896732, + 1.0, + 0.987110429986924, + 0.9483899383496186, + 0.8792434861292894, + -0.5615540113557728 + ], + [ + -0.7242763706080145, + 0.9470076359340278, + 0.987110429986924, + 1.0, + 0.9865148631673374, + 0.9414994717479613, + -0.6596798300723808 + ], + [ + -0.629138671972165, + 0.8852116723881874, + 0.9483899383496186, + 0.9865148631673374, + 1.0, + 0.9834320420637015, + -0.7571711798912276 + ], + [ + -0.5215963313306481, + 0.7964049063693659, + 0.8792434861292894, + 0.9414994717479613, + 0.9834320420637015, + 1.0, + -0.8543772043218768 + ], + [ + 0.22357476528514444, + -0.46080607223813475, + -0.5615540113557728, + -0.6596798300723808, + -0.7571711798912276, + -0.8543772043218768, + 1.0 + ] + ], + "standard_errors": [ + 1.5659400428760544e-05, + 7.057651955911099e-06, + 1.0299850688195838e-05, + 1.110660931350631e-05, + 9.8958426854876e-06, + 6.519600832957368e-06, + 1.3806400115309406e-05 + ], + "eigenvalues_ascending": [ + 3.424150583957306e-17, + 6.158201439866953e-16, + 4.0671950755750975e-14, + 1.247665552415408e-12, + 3.3067599215314964e-11, + 1.7898051361823675e-10, + 6.42183448783695e-10 + ], + "smallest_eigenvalue": 3.424150583957306e-17, + "largest_eigenvalue": 6.42183448783695e-10, + "condition_number": 18754532.92832469, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 228591.86948191028, + "diagonal_dof": 7, + "chi2": 136603.66937267024, + "dof": 7, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 308.5460145883372 + }, + "A_zero_displacement_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5 + ], + "values": [ + 0.004551881781877265, + -0.0021220308646954233, + -0.003157356660135946, + -0.003473002261093816 + ], + "standardized_values": [ + 197.25509412309242, + -164.89748358125627, + -158.39433025418847, + -156.34844816578843 + ], + "covariance": [ + [ + 5.325072111384547e-10, + -2.733238475881367e-10, + -4.11533320042986e-10, + -4.542500448733306e-10 + ], + [ + -2.733238475881367e-10, + 1.6560572125147062e-10, + 2.559726549253053e-10, + 2.8481458022790796e-10 + ], + [ + -4.11533320042986e-10, + 2.559726549253053e-10, + 3.973452473089206e-10, + 4.4269802818599534e-10 + ], + [ + -4.542500448733306e-10, + 2.8481458022790796e-10, + 4.4269802818599534e-10, + 4.934270817694736e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.9204010613211511, + -0.8946604640669829, + -0.8861775450270251 + ], + [ + -0.9204010613211511, + 1.0, + 0.9978652372702901, + 0.9963526005158392 + ], + [ + -0.8946604640669829, + 0.9978652372702901, + 1.0, + 0.9997975891543776 + ], + [ + -0.8861775450270251, + 0.9963526005158392, + 0.9997975891543776, + 1.0 + ] + ], + "standard_errors": [ + 2.3076117765743325e-05, + 1.2868788647400758e-05, + 1.9933520695274096e-05, + 2.2213218626967898e-05 + ], + "eigenvalues_ascending": [ + 1.6874080955271846e-17, + 9.963424253279567e-14, + 7.457128868823481e-11, + 1.5142143216634715e-09 + ], + "smallest_eigenvalue": 1.6874080955271846e-17, + "largest_eigenvalue": 1.5142143216634715e-09, + "condition_number": 89736106.26126555, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 115634.35334946388, + "diagonal_dof": 4, + "chi2": 45095.31212776154, + "dof": 4, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 197.25509412309242 + }, + "Z_norm": { + "value": 0.005375031042129495, + "se": 2.1491306195203915e-05, + "undefined_se": false + }, + "A_norm": { + "value": 0.0068741027437603614, + "se": 3.8625927317859514e-05, + "undefined_se": false + }, + "declared_norm": "Euclidean L2 on the declared independent coordinates" + }, + "equal": { + "from": 145, + "to": 290, + "covariance_convention": "Cov(delta) = Cov(from) + Cov(to); the two sizes have distinct producer seeds, so the cross-size term is taken as zero on recorded random-stream provenance (not batch IDs)", + "delta_Z": [ + 0.0002796232123850606, + 0.0, + -0.0006891359958616505, + -0.0013093611374448977, + -0.0017292250064558923, + -0.0018346569032792193, + -0.0014236892390476763, + 0.0, + 0.004249112417814782 + ], + "delta_Z_se": [ + 1.5634495757981765e-05, + 0.0, + 7.048289686942464e-06, + 1.028863209539706e-05, + 1.109749578123945e-05, + 9.890553677371797e-06, + 6.517854004534247e-06, + 0.0, + 1.3800964161057049e-05 + ], + "delta_A": [ + 0.004528735630199954, + 0.0, + -0.00211282523490941, + -0.0031440180407242835, + -0.0034584500129117846, + -0.0031440180407242835, + -0.00211282523490941, + 0.0, + 0.004528735630199954 + ], + "delta_A_se": [ + 2.3037611532865013e-05, + 0.0, + 1.28568252586151e-05, + 1.9916710507034548e-05, + 2.2194991562492156e-05, + 1.9916710507034548e-05, + 1.28568252586151e-05, + 0.0, + 2.3037611532865013e-05 + ], + "Z_zero_displacement_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5, + 0.6, + 0.7, + 0.9 + ], + "values": [ + 0.0002796232123850606, + -0.0006891359958616505, + -0.0013093611374448977, + -0.0017292250064558923, + -0.0018346569032792193, + -0.0014236892390476763, + 0.004249112417814782 + ], + "standardized_values": [ + 17.885016358286233, + -97.77350626469449, + -127.26289805140192, + -155.82119070314798, + -185.49587446015863, + -218.42913910886384, + 307.88518600785443 + ], + "covariance": [ + [ + 2.4443745760634977e-10, + -9.792772628955394e-11, + -1.302698793546293e-10, + -1.2550523515085439e-10, + -9.711876731784068e-11, + -5.302852228422637e-11, + 4.791373787859022e-11 + ], + [ + -9.792772628955394e-11, + 4.96783875110595e-11, + 7.148193165368909e-11, + 7.406183268556765e-11, + 6.169029474329155e-11, + 3.6568573697877445e-11, + -4.4768490542142676e-11 + ], + [ + -1.302698793546293e-10, + 7.148193165368909e-11, + 1.058559503944345e-10, + 1.1270279304419741e-10, + 9.649817749439192e-11, + 5.895056916702797e-11, + -7.97097299535326e-11 + ], + [ + -1.2550523515085439e-10, + 7.406183268556765e-11, + 1.1270279304419741e-10, + 1.2315441261462737e-10, + 1.0827815466812329e-10, + 6.80971146800857e-11, + -1.0104359649407434e-10 + ], + [ + -9.711876731784068e-11, + 6.169029474329155e-11, + 9.649817749439192e-11, + 1.0827815466812329e-10, + 9.782305204497276e-11, + 6.339703083720735e-11, + -1.0337776824085681e-10 + ], + [ + -5.302852228422637e-11, + 3.6568573697877445e-11, + 5.895056916702797e-11, + 6.80971146800857e-11, + 6.339703083720735e-11, + 4.248242082442312e-11, + -7.686849052200112e-11 + ], + [ + 4.791373787859022e-11, + -4.4768490542142676e-11, + -7.97097299535326e-11, + -1.0104359649407434e-10, + -1.0337776824085681e-10, + -7.686849052200112e-11, + 1.9046661177478108e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.8886649402793938, + -0.8098460981732496, + -0.7233574757486461, + -0.6280564473135897, + -0.52038050438876, + 0.22205816444998303 + ], + [ + -0.8886649402793938, + 1.0, + 0.9857230148475818, + 0.9468598918331599, + 0.8849372889782698, + 0.7960120606211715, + -0.4602346133902062 + ], + [ + -0.8098460981732496, + 0.9857230148475818, + 1.0, + 0.9870793185490281, + 0.9482893410664021, + 0.8790746094251154, + -0.5613636300297785 + ], + [ + -0.7233574757486461, + 0.9468598918331599, + 0.9870793185490281, + 1.0, + 0.9864958278062275, + 0.9414539762286624, + -0.6597423744721712 + ], + [ + -0.6280564473135897, + 0.8849372889782698, + 0.9482893410664021, + 0.9864958278062275, + 1.0, + 0.9834305283125722, + -0.7573508546960661 + ], + [ + -0.52038050438876, + 0.7960120606211715, + 0.8790746094251154, + 0.9414539762286624, + 0.9834305283125722, + 1.0, + -0.8545437387141865 + ], + [ + 0.22205816444998303, + -0.4602346133902062, + -0.5613636300297785, + -0.6597423744721712, + -0.7573508546960661, + -0.8545437387141865, + 1.0 + ] + ], + "standard_errors": [ + 1.5634495757981765e-05, + 7.048289686942464e-06, + 1.028863209539706e-05, + 1.109749578123945e-05, + 9.890553677371797e-06, + 6.517854004534247e-06, + 1.3800964161057049e-05 + ], + "eigenvalues_ascending": [ + 3.600155964879808e-17, + 6.148799628062379e-16, + 4.071247101837644e-14, + 1.2497954596272298e-12, + 3.299449873476424e-11, + 1.7903214498993398e-10, + 6.405804902337817e-10 + ], + "smallest_eigenvalue": 3.600155964879808e-17, + "largest_eigenvalue": 6.405804902337817e-10, + "condition_number": 17793131.64437218, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 227268.9170466862, + "diagonal_dof": 7, + "chi2": 136446.97476999415, + "dof": 7, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 307.88518600785443 + }, + "A_zero_displacement_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5 + ], + "values": [ + 0.004528735630199954, + -0.00211282523490941, + -0.0031440180407242835, + -0.0034584500129117846 + ], + "standardized_values": [ + 196.58008486423805, + -164.33491102273857, + -157.8582989200863, + -155.8211907030549 + ], + "covariance": [ + [ + 5.30731545139195e-10, + -2.72593229636628e-10, + -4.1047614486450177e-10, + -4.530976632922491e-10 + ], + [ + -2.72593229636628e-10, + 1.6529795573056326e-10, + 2.5551982639860697e-10, + 2.8431789473129383e-10 + ], + [ + -4.1047614486450177e-10, + 2.5551982639860697e-10, + 3.966753574210204e-10, + 4.4196189542093966e-10 + ], + [ + -4.530976632922491e-10, + 2.8431789473129383e-10, + 4.4196189542093966e-10, + 4.92617650459098e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.9203306231492175, + -0.8946081723174062, + -0.8861339736843151 + ], + [ + -0.9203306231492175, + 1.0, + 0.9978683580514277, + 0.9963581305611847 + ], + [ + -0.8946081723174062, + 0.9978683580514277, + 1.0, + 0.9997979278623949 + ], + [ + -0.8861339736843151, + 0.9963581305611847, + 0.9997979278623949, + 1.0 + ] + ], + "standard_errors": [ + 2.3037611532865013e-05, + 1.28568252586151e-05, + 1.9916710507034548e-05, + 2.2194991562492156e-05 + ], + "eigenvalues_ascending": [ + 1.6854850507325182e-17, + 9.977233804719776e-14, + 7.439742500466556e-11, + 1.510825294552314e-09 + ], + "smallest_eigenvalue": 1.6854850507325182e-17, + "largest_eigenvalue": 1.510825294552314e-09, + "condition_number": 89637418.84840234, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 114849.17875614356, + "diagonal_dof": 4, + "chi2": 44752.303389549255, + "dof": 4, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 196.58008486423805 + }, + "Z_norm": { + "value": 0.005357756677403162, + "se": 2.1454688386172038e-05, + "undefined_se": false + }, + "A_norm": { + "value": 0.006842455905135368, + "se": 3.858264937064698e-05, + "undefined_se": false + }, + "declared_norm": "Euclidean L2 on the declared independent coordinates" + } + }, + "290->725": { + "spin0": { + "from": 290, + "to": 725, + "covariance_convention": "Cov(delta) = Cov(from) + Cov(to); the two sizes have distinct producer seeds, so the cross-size term is taken as zero on recorded random-stream provenance (not batch IDs)", + "delta_Z": [ + 0.0007919584577789629, + 0.0, + -0.0007694101339118242, + -0.0013510533829146354, + -0.0017000476260843334, + -0.0017439103290913804, + -0.0013188293882576696, + 0.0, + 0.0037762008951243153 + ], + "delta_Z_se": [ + 1.8750180897897612e-05, + 0.0, + 8.181659130736277e-06, + 1.1927960520870584e-05, + 1.3031675245322411e-05, + 1.1889839195691453e-05, + 8.038364723340222e-06, + 0.0, + 1.693699108856536e-05 + ], + "delta_A": [ + 0.004568159352903223, + 0.0, + -0.0020882395221695216, + -0.003094963712005905, + -0.0034000952521686667, + -0.003094963712005905, + -0.0020882395221695216, + 0.0, + 0.004568159352903223 + ], + "delta_A_se": [ + 2.7775621712415586e-05, + 0.0, + 1.5099614562051526e-05, + 2.3374919025708355e-05, + 2.6063350490648803e-05, + 2.3374919025708355e-05, + 1.5099614562051526e-05, + 0.0, + 2.7775621712415586e-05 + ], + "Z_zero_displacement_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5, + 0.6, + 0.7, + 0.9 + ], + "values": [ + 0.0007919584577789629, + -0.0007694101339118242, + -0.0013510533829146354, + -0.0017000476260843334, + -0.0017439103290913804, + -0.0013188293882576696, + 0.0037762008951243153 + ], + "standardized_values": [ + 42.237376913401526, + -94.04084448120783, + -113.26776111898351, + -130.4550331466055, + -146.67232250906514, + -164.06687599385884, + 222.95582936651215 + ], + "covariance": [ + [ + 3.5156928370388447e-10, + -1.3216691593091372e-10, + -1.6905974153350917e-10, + -1.5739573198081596e-10, + -1.1901367456256044e-10, + -6.477362790170215e-11, + 6.652710533677245e-11 + ], + [ + -1.3216691593091372e-10, + 6.69395461315603e-11, + 9.544492000520101e-11, + 9.805374518070311e-11, + 8.125092765151033e-11, + 4.822175318258272e-11, + -6.24110935170828e-11 + ], + [ + -1.6905974153350917e-10, + 9.544492000520101e-11, + 1.4227624218744726e-10, + 1.52387728621178e-10, + 1.3137116058514354e-10, + 8.097064255660332e-11, + -1.1365345692393525e-10 + ], + [ + -1.5739573198081596e-10, + 9.805374518070311e-11, + 1.52387728621178e-10, + 1.698245596995489e-10, + 1.5209509131933045e-10, + 9.727589355878292e-11, + -1.4777369218966738e-10 + ], + [ + -1.1901367456256044e-10, + 8.125092765151033e-11, + 1.3137116058514354e-10, + 1.5209509131933045e-10, + 1.4136827609940075e-10, + 9.379689589626363e-11, + -1.547624287344827e-10 + ], + [ + -6.477362790170215e-11, + 4.822175318258272e-11, + 8.097064255660332e-11, + 9.727589355878292e-11, + 9.379689589626363e-11, + 6.461530742544051e-11, + -1.170741764195716e-10 + ], + [ + 6.652710533677245e-11, + -6.24110935170828e-11, + -1.1365345692393525e-10, + -1.4777369218966738e-10, + -1.547624287344827e-10, + -1.170741764195716e-10, + 2.868616671341425e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.8615409251333553, + -0.7559073106544288, + -0.6441503408523537, + -0.5338452971337193, + -0.42975907137568015, + 0.20948691739963488 + ], + [ + -0.8615409251333553, + 1.0, + 0.9780143872077942, + 0.9196499592524017, + 0.8352393857888618, + 0.7332193314059453, + -0.4503852419535441 + ], + [ + -0.7559073106544288, + 0.9780143872077942, + 1.0, + 0.9803554198807979, + 0.9263132208878827, + 0.8444883937635442, + -0.5625747007929328 + ], + [ + -0.6441503408523537, + 0.9196499592524017, + 0.9803554198807979, + 1.0, + 0.9816099869766434, + 0.9286183744297498, + -0.6695154706856841 + ], + [ + -0.5338452971337193, + 0.8352393857888618, + 0.9263132208878827, + 0.9816099869766434, + 1.0, + 0.9813971164910743, + -0.7685166775769718 + ], + [ + -0.42975907137568015, + 0.7332193314059453, + 0.8444883937635442, + 0.9286183744297498, + 0.9813971164910743, + 1.0, + -0.8599182079984541 + ], + [ + 0.20948691739963488, + -0.4503852419535441, + -0.5625747007929328, + -0.6695154706856841, + -0.7685166775769718, + -0.8599182079984541, + 1.0 + ] + ], + "standard_errors": [ + 1.8750180897897612e-05, + 8.181659130736277e-06, + 1.1927960520870584e-05, + 1.3031675245322411e-05, + 1.1889839195691453e-05, + 8.038364723340222e-06, + 1.693699108856536e-05 + ], + "eigenvalues_ascending": [ + 4.7708961345613145e-17, + 3.593328332818466e-15, + 1.4972943890889052e-13, + 4.60601291404601e-12, + 6.224960895965077e-11, + 2.757097573876962e-10, + 8.807361326438298e-10 + ], + "smallest_eigenvalue": 4.7708961345613145e-17, + "largest_eigenvalue": 8.807361326438298e-10, + "condition_number": 18460601.694168173, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 138615.78965854924, + "diagonal_dof": 7, + "chi2": 64222.78413114464, + "dof": 7, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 222.95582936651215 + }, + "A_zero_displacement_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5 + ], + "values": [ + 0.004568159352903223, + -0.0020882395221695216, + -0.003094963712005905, + -0.0034000952521686667 + ], + "standardized_values": [ + 164.46650232355643, + -138.2975382310554, + -132.40532335542989, + -130.45503314658555 + ], + "covariance": [ + [ + 7.714851615112122e-10, + -3.7642581376915027e-10, + -5.564893017550334e-10, + -6.103388483412928e-10 + ], + [ + -3.7642581376915027e-10, + 2.2799835992251848e-10, + 3.5146338611033103e-10, + 3.906592774795271e-10 + ], + [ + -5.564893017550334e-10, + 3.5146338611033103e-10, + 5.463868394584225e-10, + 6.089656398818673e-10 + ], + [ + -6.103388483412928e-10, + 3.906592774795271e-10, + 6.089656398818673e-10, + 6.792982387984033e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.8975315994660272, + -0.8571225396777266, + -0.8430959068910965 + ], + [ + -0.8975315994660272, + 1.0, + 0.995781634704598, + 0.9926634621753438 + ], + [ + -0.8571225396777266, + 0.995781634704598, + 1.0, + 0.9995681960279107 + ], + [ + -0.8430959068910965, + 0.9926634621753438, + 0.9995681960279107, + 1.0 + ] + ], + "standard_errors": [ + 2.7775621712415586e-05, + 1.5099614562051526e-05, + 2.3374919025708355e-05, + 2.6063350490648803e-05 + ], + "eigenvalues_ascending": [ + 9.120389761989391e-17, + 3.5496525037314664e-13, + 1.444189969177416e-10, + 2.0803945463185453e-09 + ], + "smallest_eigenvalue": 9.120389761989391e-17, + "largest_eigenvalue": 2.0803945463185453e-09, + "condition_number": 22810368.861525036, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 80725.1247934473, + "diagonal_dof": 4, + "chi2": 32742.004333814606, + "dof": 4, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 164.46650232355643 + }, + "Z_norm": { + "value": 0.004997491842818284, + "se": 2.701299252540726e-05, + "undefined_se": false + }, + "A_norm": { + "value": 0.00680942525312682, + "se": 4.525543185124329e-05, + "undefined_se": false + }, + "declared_norm": "Euclidean L2 on the declared independent coordinates" + }, + "equal": { + "from": 290, + "to": 725, + "covariance_convention": "Cov(delta) = Cov(from) + Cov(to); the two sizes have distinct producer seeds, so the cross-size term is taken as zero on recorded random-stream provenance (not batch IDs)", + "delta_Z": [ + 0.0007983638141189076, + 0.0, + -0.0007716025752269318, + -0.001354265528874965, + -0.0017036413691617902, + -0.0017472870005263985, + -0.0013211979422425024, + 0.0, + 0.003782076622631303 + ], + "delta_Z_se": [ + 1.866124436070403e-05, + 0.0, + 8.191676340320216e-06, + 1.1952605306110001e-05, + 1.306713211208695e-05, + 1.19287650129174e-05, + 8.067408327892534e-06, + 0.0, + 1.700760898171633e-05 + ], + "delta_A": [ + 0.0045804404367502105, + 0.0, + -0.0020928005174694064, + -0.0031015525294013635, + -0.0034072827383235804, + -0.0031015525294013635, + -0.0020928005174694064, + 0.0, + 0.0045804404367502105 + ], + "delta_A_se": [ + 2.7776571747224475e-05, + 0.0, + 1.5141413763979589e-05, + 2.34398118116816e-05, + 2.6134264224187384e-05, + 2.34398118116816e-05, + 1.5141413763979589e-05, + 0.0, + 2.7776571747224475e-05 + ], + "Z_zero_displacement_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5, + 0.6, + 0.7, + 0.9 + ], + "values": [ + 0.0007983638141189076, + -0.0007716025752269318, + -0.001354265528874965, + -0.0017036413691617902, + -0.0017472870005263985, + -0.0013211979422425024, + 0.003782076622631303 + ], + "standardized_values": [ + 42.78191736238471, + -94.19348899675515, + -113.30295732116946, + -130.37607292467342, + -146.47677262770281, + -163.76981163511303, + 222.3755630022506 + ], + "covariance": [ + [ + 3.48242041089908e-10, + -1.3160073056003972e-10, + -1.684355561750177e-10, + -1.5689803251875117e-10, + -1.1873751398430422e-10, + -6.470794776839477e-11, + 6.701856683075953e-11 + ], + [ + -1.3160073056003972e-10, + 6.7103561264562e-11, + 9.576415517831116e-11, + 9.846583403187765e-11, + 8.167832833274668e-11, + 4.8537886190521605e-11, + -6.315620564059913e-11 + ], + [ + -1.684355561750177e-10, + 9.576415517831116e-11, + 1.4286477360364895e-10, + 1.5313088193249694e-10, + 1.3213228471521814e-10, + 8.153292099714318e-11, + -1.1500026926005983e-10 + ], + [ + -1.5689803251875117e-10, + 9.846583403187765e-11, + 1.5313088193249694e-10, + 1.7074994163473393e-10, + 1.5303019784802488e-10, + 9.796128853049217e-11, + -1.4942652719904802e-10 + ], + [ + -1.1873751398430422e-10, + 8.167832833274668e-11, + 1.3213228471521814e-10, + 1.5303019784802488e-10, + 1.4229543473340227e-10, + 9.44637489642386e-11, + -1.5634361726043292e-10 + ], + [ + -6.470794776839477e-11, + 4.8537886190521605e-11, + 8.153292099714318e-11, + 9.796128853049217e-11, + 9.44637489642386e-11, + 6.508307712894981e-11, + -1.1814593404253109e-10 + ], + [ + 6.701856683075953e-11, + -6.315620564059913e-11, + -1.1500026926005983e-10, + -1.4942652719904802e-10, + -1.5634361726043292e-10, + -1.1814593404253109e-10, + 2.89258763274958e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.8608845539490622, + -0.7551454265362025, + -0.6434230512558086, + -0.533398596485133, + -0.429816404969461, + 0.21115981557998365 + ], + [ + -0.8608845539490622, + 1.0, + 0.9780647757703579, + 0.9198827973781968, + 0.8358696810311993, + 0.7344699558278629, + -0.45331488838725575 + ], + [ + -0.7551454265362025, + 0.9780647757703579, + 1.0, + 0.9804375209495164, + 0.9267250072672059, + 0.8455443343959093, + -0.5657089061362088 + ], + [ + -0.6434230512558086, + 0.9198827973781968, + 0.9804375209495164, + 1.0, + 0.9817510498667987, + 0.9292662577259958, + -0.6723635456224847 + ], + [ + -0.533398596485133, + 0.8358696810311993, + 0.9267250072672059, + 0.9817510498667987, + 1.0, + 0.9816024977867864, + -0.7706220117928915 + ], + [ + -0.429816404969461, + 0.7344699558278629, + 0.8455443343959093, + 0.9292662577259958, + 0.9816024977867864, + 1.0, + -0.8610759876820282 + ], + [ + 0.21115981557998365, + -0.45331488838725575, + -0.5657089061362088, + -0.6723635456224847, + -0.7706220117928915, + -0.8610759876820282, + 1.0 + ] + ], + "standard_errors": [ + 1.866124436070403e-05, + 8.191676340320216e-06, + 1.1952605306110001e-05, + 1.306713211208695e-05, + 1.19287650129174e-05, + 8.067408327892534e-06, + 1.700760898171633e-05 + ], + "eigenvalues_ascending": [ + 3.9587039154821023e-17, + 3.5891431185972665e-15, + 1.4754361637058855e-13, + 4.5823055222817875e-12, + 6.214952712058952e-11, + 2.7511105305245245e-10, + 8.836035346883116e-10 + ], + "smallest_eigenvalue": 3.9587039154821023e-17, + "largest_eigenvalue": 8.836035346883116e-10, + "condition_number": 22320525.94872339, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 138265.07349456233, + "diagonal_dof": 7, + "chi2": 63620.11288431572, + "dof": 7, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 222.3755630022506 + }, + "A_zero_displacement_diagnostic": { + "coordinates": [ + 0.1, + 0.3, + 0.4, + 0.5 + ], + "values": [ + 0.0045804404367502105, + -0.0020928005174694064, + -0.0031015525294013635, + -0.0034072827383235804 + ], + "standardized_values": [ + 164.90301533370126, + -138.21698225089384, + -132.3198562479779, + -130.37607292460618 + ], + "covariance": [ + [ + 7.71537938028709e-10, + -3.776108180095791e-10, + -5.585169566813604e-10, + -6.126491194379998e-10 + ], + [ + -3.776108180095791e-10, + 2.2926241077203054e-10, + 3.534391534706195e-10, + 3.9285424512320414e-10 + ], + [ + -5.585169566813604e-10, + 3.534391534706195e-10, + 5.494247777670482e-10, + 6.123221595611275e-10 + ], + [ + -6.126491194379998e-10, + 3.9285424512320414e-10, + 6.123221595611275e-10, + 6.829997665396407e-10 + ] + ], + "correlation_matrix": [ + [ + 1.0, + -0.8978408421748574, + -0.857834679335016, + -0.8439620007002582 + ], + [ + -0.8978408421748574, + 1.0, + 0.9958504187525903, + 0.9927839452649231 + ], + [ + -0.857834679335016, + 0.9958504187525903, + 1.0, + 0.9995754436292443 + ], + [ + -0.8439620007002582, + 0.9927839452649231, + 0.9995754436292443, + 1.0 + ] + ], + "standard_errors": [ + 2.7776571747224475e-05, + 1.5141413763979589e-05, + 2.34398118116816e-05, + 2.6134264224187384e-05 + ], + "eigenvalues_ascending": [ + 9.238180008134535e-17, + 3.5111460952919556e-13, + 1.4395288251191088e-10, + 2.088920803604189e-09 + ], + "smallest_eigenvalue": 9.238180008134535e-17, + "largest_eigenvalue": 2.088920803604189e-09, + "condition_number": 22611821.828161202, + "positive_definite": true, + "diagonal_chi2_ignoring_correlations": 80803.40339741856, + "diagonal_dof": 4, + "chi2": 32944.42094179336, + "dof": 4, + "p_nominal_gaussian": 0.0, + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": true, + "max_abs_standardized_value": 164.90301533370126 + }, + "Z_norm": { + "value": 0.005007181222550102, + "se": 2.712002341819815e-05, + "undefined_se": false + }, + "A_norm": { + "value": 0.006825646661822637, + "se": 4.5339011653765356e-05, + "undefined_se": false + }, + "declared_norm": "Euclidean L2 on the declared independent coordinates" + } + } + }, + "equal_weighting_sensitivity": { + "spin0": { + "A_norms": { + "145": { + "value": 0.030514249801671008, + "se": 2.5683342534193044e-05, + "undefined_se": false + }, + "290": { + "value": 0.023640728943671398, + "se": 2.876436295675836e-05, + "undefined_se": false + }, + "725": { + "value": 0.016831348750762004, + "se": 3.491068175029809e-05, + "undefined_se": false + } + }, + "delta_Z_norms": { + "145->290": { + "value": 0.005375031042129495, + "se": 2.1491306195203915e-05, + "undefined_se": false + }, + "290->725": { + "value": 0.004997491842818284, + "se": 2.701299252540726e-05, + "undefined_se": false + } + }, + "delta_A_norms": { + "145->290": { + "value": 0.0068741027437603614, + "se": 3.8625927317859514e-05, + "undefined_se": false + }, + "290->725": { + "value": 0.00680942525312682, + "se": 4.525543185124329e-05, + "undefined_se": false + } + } + }, + "equal": { + "A_norms": { + "145": { + "value": 0.030491820009373005, + "se": 2.5653718984505843e-05, + "undefined_se": false + }, + "290": { + "value": 0.023649981027579536, + "se": 2.8729995775620732e-05, + "undefined_se": false + }, + "725": { + "value": 0.016824372760447952, + "se": 3.504885404041118e-05, + "undefined_se": false + } + }, + "delta_Z_norms": { + "145->290": { + "value": 0.005357756677403162, + "se": 2.1454688386172038e-05, + "undefined_se": false + }, + "290->725": { + "value": 0.005007181222550102, + "se": 2.712002341819815e-05, + "undefined_se": false + } + }, + "delta_A_norms": { + "145->290": { + "value": 0.006842455905135368, + "se": 3.858264937064698e-05, + "undefined_se": false + }, + "290->725": { + "value": 0.006825646661822637, + "se": 4.5339011653765356e-05, + "undefined_se": false + } + } + }, + "comparison": { + "max_abs_A_difference_spin0_vs_equal": 1.6287250761193306e-05, + "max_abs_Z_difference_spin0_vs_equal": 8.715686133309308e-06, + "spin4_residue_of_equal_weights": { + "145": -0.0136504161712247, + "290": 0.0136504161712247, + "725": -0.04110725326991674 + }, + "qualitative_reading_unchanged": true, + "note": "equal weighting is a sensitivity on the same block, not a second experiment" + } + }, + "finite_size_movement": { + "spin0": { + "weighting": "spin0", + "A_norm_by_size": { + "145": { + "value": 0.030514249801671008, + "se": 2.5683342534193044e-05, + "undefined_se": false + }, + "290": { + "value": 0.023640728943671398, + "se": 2.876436295675836e-05, + "undefined_se": false + }, + "725": { + "value": 0.016831348750762004, + "se": 3.491068175029809e-05, + "undefined_se": false + } + }, + "A_norm_steps": { + "145->290": { + "difference": -0.00687352085799961, + "se": 3.856193278398818e-05, + "sigma_multiple": 178.2462745449745, + "resolved_nonzero": true + }, + "290->725": { + "difference": -0.006809380192909394, + "se": 4.5234326308443334e-05, + "sigma_multiple": 150.53568271311627, + "resolved_nonzero": true + } + }, + "A_norm_trend": "decreasing", + "adjacent_displacement_interval_change": { + "delta_Z_norm": { + "difference_between_intervals": -0.0003775391993112113, + "se": 3.451924111497411e-05, + "sigma_multiple": 10.937065448621304, + "resolved_change": true + }, + "delta_A_norm": { + "difference_between_intervals": -6.467749063354157e-05, + "se": 5.949803671724884e-05, + "sigma_multiple": 1.087052518067225, + "resolved_change": false + } + }, + "statement": "finite movement between three sizes only; a decreasing norm is not a convergence or a limit claim, and no exponent is fitted" + }, + "equal": { + "weighting": "equal", + "A_norm_by_size": { + "145": { + "value": 0.030491820009373005, + "se": 2.5653718984505843e-05, + "undefined_se": false + }, + "290": { + "value": 0.023649981027579536, + "se": 2.8729995775620732e-05, + "undefined_se": false + }, + "725": { + "value": 0.016824372760447952, + "se": 3.504885404041118e-05, + "undefined_se": false + } + }, + "A_norm_steps": { + "145->290": { + "difference": -0.006841838981793469, + "se": 3.851656727958997e-05, + "sigma_multiple": 177.63366429123545, + "resolved_nonzero": true + }, + "290->725": { + "difference": -0.006825608267131585, + "se": 4.53192544820988e-05, + "sigma_multiple": 150.6116626395016, + "resolved_nonzero": true + } + }, + "A_norm_trend": "decreasing", + "adjacent_displacement_interval_change": { + "delta_Z_norm": { + "difference_between_intervals": -0.00035057545485306027, + "se": 3.4580331460981706e-05, + "sigma_multiple": 10.138001576087488, + "resolved_change": true + }, + "delta_A_norm": { + "difference_between_intervals": -1.680924331273065e-05, + "se": 5.953357716615521e-05, + "sigma_multiple": 0.2823489552092074, + "resolved_change": false + } + }, + "statement": "finite movement between three sizes only; a decreasing norm is not a convergence or a limit claim, and no exponent is fitted" + } + }, + "n725_q_reproduction_control": { + "reference": "PR #655 n725-zflow-corrected.json spin0 Q_pooled on the deciles (open branch, values as published)", + "reference_values": { + "0.1": 0.54183362, + "0.2": 0.55970681, + "0.3": 0.57229601, + "0.4": 0.58290959, + "0.5": 0.59274645, + "0.6": 0.60253412, + "0.7": 0.61298542, + "0.8": 0.62523757, + "0.9": 0.6423673 + }, + "max_abs_difference": 4.117237994982759e-09, + "matches_within_1e_8": true + } +} \ No newline at end of file diff --git a/results/probe-invariant-shape/run-622.log b/results/probe-invariant-shape/run-622.log new file mode 100644 index 00000000..eeab4d33 --- /dev/null +++ b/results/probe-invariant-shape/run-622.log @@ -0,0 +1,22 @@ +loaded {145: 145, 290: 290, 725: 725} in 1.0s +N=145 spin0 done in 19.4s +N=145 equal done in 19.3s +N=290 spin0 done in 38.8s +N=290 equal done in 39.0s +N=725 spin0 done in 102.5s +N=725 equal done in 102.5s + +=== summary (spin0) === +N=145: |A|=0.0305142 +/- 2.6e-05 chi2(A=0)=2273560.463866949 dof=4 p=0.0 +N=290: |A|=0.0236407 +/- 2.9e-05 chi2(A=0)=1000970.7397946715 dof=4 p=0.0 +N=725: |A|=0.0168313 +/- 3.5e-05 chi2(A=0)=355970.477979064 dof=4 p=0.0 +145->290: |dZ|=0.00537503 +/- 2.1e-05 (p=0.0), |dA|=0.0068741 +/- 3.9e-05 (p=0.0) +290->725: |dZ|=0.00499749 +/- 2.7e-05 (p=0.0), |dA|=0.00680943 +/- 4.5e-05 (p=0.0) +A-norm trend (spin0): decreasing {'145->290': (-0.00687352, 178.2), '290->725': (-0.00680938, 150.5)} +interval change: {'delta_Z_norm': {'difference_between_intervals': -0.0003775391993112113, 'se': 3.451924111497411e-05, 'sigma_multiple': 10.937065448621304, 'resolved_change': True}, 'delta_A_norm': {'difference_between_intervals': -6.467749063354157e-05, 'se': 5.949803671724884e-05, 'sigma_multiple': 1.087052518067225, 'resolved_change': False}} +N725 Q vs #655: 4.117237994982759e-09 +wrote results/probe-invariant-shape/quantile-shape-lineage-622.json + +real 5m22.560s +user 5m22.345s +sys 0m0.024s diff --git a/scripts/probe_invariant_shape/quantile_shape_lineage_622.py b/scripts/probe_invariant_shape/quantile_shape_lineage_622.py new file mode 100644 index 00000000..621957be --- /dev/null +++ b/scripts/probe_invariant_shape/quantile_shape_lineage_622.py @@ -0,0 +1,708 @@ +#!/usr/bin/env python3 +"""#622 (2026-09-12 re-scope): within-model quantile-shape symmetry and the +full-vector finite-size motion of the same-observable N=145,290,725 lineage. + +This is a C2 reanalysis of already-committed histogram blocks. No Monte Carlo, +no GPU, no exponent fit. It rebuilds, per size and per orientation, the pooled +inverse CDF ``Q`` on the nine frozen deciles, forms the declared spin-0 weighted +``Q`` (weights sum to one and annihilate ``cos 4theta``), then the anchored shape + + W_N = Q_N(0.8) - Q_N(0.2) > 0 + Z_N(u) = [Q_N(u) - Q_N(0.2)] / W_N + A_N(u) = Z_N(u) + Z_N(1-u) - 1 + +with ``A_N(u)`` the reflection residual of the *normalized* shape (this is the +corrected diagnostic of ``notes/exact-foundations-correction-20260912.md`` sec.3, +NOT ``M_N(p)+M_N(1-p)``). + +Order of operations, which the ticket fixes and the #628 probe got wrong: +each orientation's ``Q_i`` is built first and only then combined, +``Q_spin0 = sum_i w_i Q_i``. CDFs are never mixed before inversion. + +Per aligned delete-one batch the ENTIRE Q -> weighting -> W -> Z -> A map is +repeated, so the covariance of every functional is a covariance of one random +object across the grid, not a per-level variance. Cross-size covariance is +taken as zero on recorded random-stream provenance (distinct seeds), never on +matching batch IDs. + +Deterministic redundancies are handled by using independent coordinates: +``A(0.2)=A(0.8)=0`` and ``A(1-u)=A(u)``, so the diagnostic lives on +u = 0.1, 0.3, 0.4, 0.5; ``Z(0.2)=0`` and ``Z(0.8)=1``, so the ΔZ test lives on +the seven remaining deciles. No pseudoinverse is used to hide a residual. + +Reuses ``scripts/threshold_quantile_lineage.py`` (git blob 3b328f29, the #655 +lineage: corrected cos 4theta, invert-then-weight, pooled + aligned delete-one). +""" + +from __future__ import annotations + +import argparse +import json +import math +import sys +import time +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT / "scripts")) + +import threshold_quantile_lineage as L # noqa: E402 + +DECILES = tuple(float(u) for u in L.FROZEN_LEVELS) # 0.1 .. 0.9 +ANCHOR_A, ANCHOR_B = 0.2, 0.8 +#: Independent A coordinates: A(0.2)=A(0.8)=0 exactly and A(1-u)=A(u). +A_COORDS = (0.1, 0.3, 0.4, 0.5) +#: Z coordinates free of the two fixed anchor values Z(0.2)=0, Z(0.8)=1. +Z_COORDS = (0.1, 0.3, 0.4, 0.5, 0.6, 0.7, 0.9) + +DEFAULT_INPUTS = { + 145: { + "hist": "results/server-20260829/P50-n145-n290-fullcurve/raw/n145_100m.hist.csv", + "metadata": "results/server-20260829/P50-n145-n290-fullcurve/raw/n145_100m.metadata.json", + }, + 290: { + "hist": "results/server-20260829/P50-n145-n290-fullcurve/raw/n290_100m.hist.csv", + "metadata": "results/server-20260829/P50-n145-n290-fullcurve/raw/n290_100m.metadata.json", + }, + 725: { + "hist": "results/server-20260907/P612-n725-fullcurve/raw/n725_100m.hist.csv", + "metadata": "results/server-20260907/P612-n725-fullcurve/raw/n725_100m.metadata.json", + }, +} + +SOURCE_REVISIONS = { + "base_branch": "main", + "base_commit": "6edf775e240056dc95e373344694eed527e48872", + "threshold_quantile_lineage.py": { + "git_blob": "3b328f29b9ccc75d0183ea72b8622b53bbe955d7", + "git_commit": "6edf775e240056dc95e373344694eed527e48872", + "inherits": "PR #655 (analysis/633-n725-spin0) lineage module", + "properties": [ + "cos_four_theta = (a^4 - 6 a^2 b^2 + b^4) / N^2", + "invert Q per orientation, then combine", + "pooled full vector plus aligned delete-one", + ], + }, + "correction": "notes/exact-foundations-correction-20260912.md sec.3 (#702)", + "prior_probe": "PR #666 rerun-20260908.json (T1-T4), superseded by this re-scope", +} + +# -------------------------------------------------------------------------- +# tiny pure-python linear algebra (the compute image has no numpy) +# -------------------------------------------------------------------------- + + +def jacobi_eigenvalues(matrix: list[list[float]], tol: float = 1e-13, + sweeps: int = 100) -> list[float]: + """Eigenvalues of a real symmetric matrix, ascending (cyclic Jacobi).""" + n = len(matrix) + a = [row[:] for row in matrix] + for _ in range(sweeps): + off = math.sqrt(sum(a[i][j] ** 2 for i in range(n) for j in range(n) + if i != j)) + if off < tol: + break + for p in range(n - 1): + for q in range(p + 1, n): + if abs(a[p][q]) < 1e-300: + continue + theta = 0.5 * (a[q][q] - a[p][p]) / a[p][q] + t = (1.0 if theta >= 0 else -1.0) / ( + abs(theta) + math.sqrt(theta * theta + 1.0)) + c = 1.0 / math.sqrt(t * t + 1.0) + s = t * c + for k in range(n): + akp, akq = a[k][p], a[k][q] + a[k][p] = c * akp - s * akq + a[k][q] = s * akp + c * akq + for k in range(n): + apk, aqk = a[p][k], a[q][k] + a[p][k] = c * apk - s * aqk + a[q][k] = s * apk + c * aqk + return sorted(a[i][i] for i in range(n)) + + +def cholesky_solve(matrix: list[list[float]], rhs: list[float]) -> list[float]: + """Solve ``matrix x = rhs`` for symmetric positive definite ``matrix``.""" + n = len(matrix) + lower = [[0.0] * n for _ in range(n)] + for i in range(n): + for j in range(i + 1): + acc = matrix[i][j] - sum(lower[i][k] * lower[j][k] + for k in range(j)) + if i == j: + if acc <= 0.0: + raise ValueError( + f"covariance is not positive definite at pivot {i}: {acc!r}") + lower[i][j] = math.sqrt(acc) + else: + lower[i][j] = acc / lower[j][j] + y = [0.0] * n + for i in range(n): + y[i] = (rhs[i] - sum(lower[i][k] * y[k] for k in range(i))) / lower[i][i] + x = [0.0] * n + for i in range(n - 1, -1, -1): + x[i] = (y[i] - sum(lower[k][i] * x[k] for k in range(i + 1, n)) + ) / lower[i][i] + return x + + +def _gser(a: float, x: float) -> float: + gln = math.lgamma(a) + if x <= 0.0: + return 0.0 + ap, total, term = a, 1.0 / a, 1.0 / a + for _ in range(2000): + ap += 1.0 + term *= x / ap + total += term + if abs(term) < abs(total) * 1e-15: + break + return total * math.exp(-x + a * math.log(x) - gln) + + +def _gcf(a: float, x: float) -> float: + gln = math.lgamma(a) + tiny = 1e-300 + b, c, d = x + 1.0 - a, 1.0 / tiny, 1.0 / (x + 1.0 - a) + h = d + for i in range(1, 2000): + an = -i * (i - a) + b += 2.0 + d = an * d + b + if abs(d) < tiny: + d = tiny + c = b + an / c + if abs(c) < tiny: + c = tiny + d = 1.0 / d + delta = d * c + h *= delta + if abs(delta - 1.0) < 1e-15: + break + return math.exp(-x + a * math.log(x) - gln) * h + + +def gammq(a: float, x: float) -> float: + """Upper regularized incomplete gamma Q(a, x).""" + if x < 0.0 or a <= 0.0: + raise ValueError("gammq domain") + if x == 0.0: + return 1.0 + if x < a + 1.0: + return 1.0 - _gser(a, x) + return _gcf(a, x) + + +def chi2_survival(statistic: float, dof: int) -> float: + """Nominal chi-square survival ``P(X >= statistic)`` for integer dof.""" + return gammq(0.5 * dof, 0.5 * statistic) + + +# -------------------------------------------------------------------------- +# shape pipeline +# -------------------------------------------------------------------------- + + +def _index(levels: tuple[float, ...]) -> dict[float, int]: + return {round(float(u), 9): i for i, u in enumerate(levels)} + + +def z_chart(Q: list[float], levels: tuple[float, ...], a: float, b: float + ) -> tuple[list[float], float]: + idx = _index(levels) + qa, qb = Q[idx[round(a, 9)]], Q[idx[round(b, 9)]] + width = qb - qa + return [(q - qa) / width for q in Q], width + + +def reflection_residual(Z: list[float], levels: tuple[float, ...]) -> list[float]: + idx = _index(levels) + out = [] + for u in levels: + j = idx[round(1.0 - float(u), 9)] + out.append(Z[idx[round(float(u), 9)]] + Z[j] - 1.0) + return out + + +def _subvector(vector: list[float], levels: tuple[float, ...], + coords: tuple[float, ...]) -> list[float]: + idx = _index(levels) + return [vector[idx[round(u, 9)]] for u in coords] + + +def _submatrix(matrix: list[list[float]], levels: tuple[float, ...], + coords: tuple[float, ...]) -> list[list[float]]: + idx = _index(levels) + picks = [idx[round(u, 9)] for u in coords] + return [[matrix[i][j] for j in picks] for i in picks] + + +def _norm_and_se(vector: list[float], covariance: list[list[float]] + ) -> dict[str, float]: + """Euclidean norm and its delta-method SE for X ~ N(vector, covariance).""" + norm = math.sqrt(sum(x * x for x in vector)) + quad = sum(vector[i] * covariance[i][j] * vector[j] + for i in range(len(vector)) for j in range(len(vector))) + if norm <= 0.0: + return {"value": 0.0, "se": float("nan"), "undefined_se": True} + return {"value": norm, "se": math.sqrt(max(0.0, quad)) / norm, + "undefined_se": False} + + +def _quadratic_diagnostic(vector: list[float], covariance: list[list[float]], + coords: tuple[float, ...], levels: tuple[float, ...] + ) -> dict: + """Covariance-aware zero test on independent coordinates. + + The deterministic redundancies (``A(0.2)=A(0.8)=0``, ``A(1-u)=A(u)``) are + removed by the coordinate choice, so the covariance is invertible. It can + still be *near-collinear*, because a batch's A fluctuation is close to one + amplitude mode; the full-inverse chi-square is therefore reported next to + the correlation-free (diagonal) chi-square. If the full value were an + artefact of inverting a nearly singular matrix it would exceed the diagonal + one; when it does not, the rejection is carried by the measured residuals. + """ + sub = _subvector(vector, levels, coords) + cov = _submatrix(covariance, levels, coords) + eigs = jacobi_eigenvalues(cov) + smallest, largest = eigs[0], eigs[-1] + diagonal = [cov[i][i] for i in range(len(sub))] + standardized = [sub[i] / math.sqrt(diagonal[i]) if diagonal[i] > 0 else None + for i in range(len(sub))] + correlation = [[cov[i][j] / math.sqrt(diagonal[i] * diagonal[j]) + if diagonal[i] > 0 and diagonal[j] > 0 else None + for j in range(len(sub))] for i in range(len(sub))] + diagonal_chi2 = sum(sub[i] * sub[i] / diagonal[i] + for i in range(len(sub)) if diagonal[i] > 0) + out = { + "coordinates": list(coords), + "values": sub, + "standardized_values": standardized, + "covariance": cov, + "correlation_matrix": correlation, + "standard_errors": [math.sqrt(max(0.0, d)) for d in diagonal], + "eigenvalues_ascending": eigs, + "smallest_eigenvalue": smallest, + "largest_eigenvalue": largest, + "condition_number": (largest / smallest) if smallest > 0 else None, + "positive_definite": smallest > 0.0, + "diagonal_chi2_ignoring_correlations": diagonal_chi2, + "diagonal_dof": len(sub), + } + if smallest <= 0.0: + # Deterministic or numerically exact redundancy: do NOT pseudoinvert. + out.update({ + "chi2": None, + "dof": None, + "p_nominal_gaussian": None, + "reason": "singular covariance; no pseudoinverse used, direction " + "reported instead of a rank-reduced score", + }) + return out + try: + solution = cholesky_solve(cov, sub) + except ValueError as exc: + out.update({"chi2": None, "dof": None, "p_nominal_gaussian": None, + "reason": f"cholesky failed: {exc}"}) + return out + statistic = sum(sub[i] * solution[i] for i in range(len(sub))) + out.update({ + "chi2": statistic, + "dof": len(coords), + "p_nominal_gaussian": chi2_survival(statistic, len(coords)), + "test_label": "nominal Gaussian reference with estimated delete-one covariance", + "full_inverse_not_larger_than_diagonal": statistic <= diagonal_chi2, + "max_abs_standardized_value": max( + abs(t) for t in standardized if t is not None), + }) + return out + + +def geometry_of_size(metadata: dict, n: int) -> dict: + design = metadata["designs"][0] + reps = [design.get("first"), design.get("second")] + info: dict = { + "site_count_N": n, + "engine": metadata.get("engine"), + "channel": metadata.get("channel"), + "observable_K_plus": metadata.get("K_plus"), + "observable_K_minus": metadata.get("K_minus"), + "samples_per_orientation": metadata.get("samples_per_orientation"), + "batches": metadata.get("batches"), + "seed": metadata.get("seed"), + "rng": metadata.get("rng"), + "coupling": metadata.get("coupling"), + "generated_utc": metadata.get("generated_utc"), + "producer_git_commit": metadata.get("git_commit"), + "command": metadata.get("command"), + "orientation_representatives": [list(r) for r in reps if r], + } + shortest = [] + for rep in reps: + if rep: + shortest.append({ + "representative": list(rep), + "norm_squared": rep[0] ** 2 + rep[1] ** 2, + "shortest_period_length": math.sqrt(rep[0] ** 2 + rep[1] ** 2), + }) + info["site_count_vs_shortest_period"] = { + "site_count": n, + "per_orientation": shortest, + "identity": "site_count = |a+bi|^2 = shortest_period_length^2, so the " + "shortest lifted period holds sqrt(N) sites", + } + for key in ("first_period_matrix", "second_period_matrix", "first_HNF", + "second_HNF", "first_smith_invariants", "second_smith_invariants"): + if key in design: + info[key] = design[key] + return info + + +def analyse_size(loaded: dict, weights: dict, levels: tuple[float, ...] + ) -> dict: + idx = _index(levels) + jack = L.jackknife_quantiles(loaded, weights, levels) + Q = list(jack["full"]) + Z, width = z_chart(Q, levels, ANCHOR_A, ANCHOR_B) + A = reflection_residual(Z, levels) + + Q_cov = L.jackknife_covariance(Q, jack["deleted"]) + Z_del, A_del = {}, {} + widths = {} + for batch, qv in jack["deleted"].items(): + z, w = z_chart(qv, levels, ANCHOR_A, ANCHOR_B) + Z_del[batch] = z + A_del[batch] = reflection_residual(z, levels) + widths[batch] = w + full_width_mean = sum(widths.values()) / len(widths) + width_var = sum((w - full_width_mean) ** 2 for w in widths.values() + ) / (len(widths) - 1) + width_se = math.sqrt(width_var / len(widths)) + Z_cov = L.jackknife_covariance(Z, Z_del) + A_cov = L.jackknife_covariance(A, A_del) + + return { + "n": loaded["n"], + "batches": jack["batches"], + "weights": dict(weights), + "weights_sum": sum(weights.values()), + "spin0_annihilates_cos4": sum( + weights[k] * loaded["orientation_cos4theta"][k] for k in weights), + "orientation_cos4theta": dict(loaded["orientation_cos4theta"]), + "orientation_representative": dict(loaded["orientation_representative"]), + "levels": list(levels), + "anchors": [ANCHOR_A, ANCHOR_B], + "W": width, + "W_se": width_se, + "Q_pooled": Q, + "Q_se": [math.sqrt(max(0.0, Q_cov[i][i])) for i in range(len(levels))], + "Z_pooled": Z, + "Z_se": [math.sqrt(max(0.0, Z_cov[i][i])) for i in range(len(levels))], + "A_pooled": A, + "A_se": [math.sqrt(max(0.0, A_cov[i][i])) for i in range(len(levels))], + "Q_covariance": Q_cov, + "Z_covariance": Z_cov, + "A_covariance": A_cov, + "A_zero_diagnostic": _quadratic_diagnostic(A, A_cov, A_COORDS, levels), + "A_norm_on_independent_coordinates": _norm_and_se( + _subvector(A, levels, A_COORDS), + _submatrix(A_cov, levels, A_COORDS)), + } + + +def adjacent_delta(left: dict, right: dict, levels: tuple[float, ...] + ) -> dict: + dz = [right["Z_pooled"][i] - left["Z_pooled"][i] for i in range(len(levels))] + da = [right["A_pooled"][i] - left["A_pooled"][i] for i in range(len(levels))] + # Independent sizes: covariance of a difference is the sum of the two + # delete-one covariances, with no cross-size term. + dz_cov = [[left["Z_covariance"][i][j] + right["Z_covariance"][i][j] + for j in range(len(levels))] for i in range(len(levels))] + da_cov = [[left["A_covariance"][i][j] + right["A_covariance"][i][j] + for j in range(len(levels))] for i in range(len(levels))] + return { + "from": left["n"], + "to": right["n"], + "covariance_convention": "Cov(delta) = Cov(from) + Cov(to); the two " + "sizes have distinct producer seeds, so the " + "cross-size term is taken as zero on recorded " + "random-stream provenance (not batch IDs)", + "delta_Z": dz, + "delta_Z_se": [math.sqrt(max(0.0, dz_cov[i][i])) + for i in range(len(levels))], + "delta_A": da, + "delta_A_se": [math.sqrt(max(0.0, da_cov[i][i])) + for i in range(len(levels))], + "Z_zero_displacement_diagnostic": _quadratic_diagnostic( + dz, dz_cov, Z_COORDS, levels), + "A_zero_displacement_diagnostic": _quadratic_diagnostic( + da, da_cov, A_COORDS, levels), + "Z_norm": _norm_and_se(_subvector(dz, levels, Z_COORDS), + _submatrix(dz_cov, levels, Z_COORDS)), + "A_norm": _norm_and_se(_subvector(da, levels, A_COORDS), + _submatrix(da_cov, levels, A_COORDS)), + "declared_norm": "Euclidean L2 on the declared independent coordinates", + } + + +def finite_movement(sizes_block: dict, adjacent_block: dict, + weighting: str) -> dict: + """Finite-size movement of |A| and of the adjacent-size displacements. + + Three sizes cannot establish convergence. This block reports the observed + movement between them with its uncertainty and says explicitly which + comparisons are resolved. No exponent is fitted. + """ + order = [s for s in (145, 290, 725) if str(s) in sizes_block] + a_norm = {s: sizes_block[str(s)]["analysis"][weighting][ + "A_norm_on_independent_coordinates"] for s in order} + a_steps = {} + for lo, hi in zip(order, order[1:]): + diff = a_norm[hi]["value"] - a_norm[lo]["value"] + se = math.sqrt(a_norm[hi]["se"] ** 2 + a_norm[lo]["se"] ** 2) + a_steps[f"{lo}->{hi}"] = { + "difference": diff, "se": se, + "sigma_multiple": abs(diff) / se if se > 0 else None, + "resolved_nonzero": se > 0 and abs(diff) / se > 5.0, + } + dz = {key: adjacent_block[key][weighting]["Z_norm"] + for key in adjacent_block} + da = {key: adjacent_block[key][weighting]["A_norm"] + for key in adjacent_block} + keys = list(adjacent_block) + interval = {} + if len(keys) == 2: + for label, table in (("delta_Z_norm", dz), ("delta_A_norm", da)): + diff = table[keys[1]]["value"] - table[keys[0]]["value"] + se = math.sqrt(table[keys[1]]["se"] ** 2 + table[keys[0]]["se"] ** 2) + interval[label] = { + "difference_between_intervals": diff, "se": se, + "sigma_multiple": abs(diff) / se if se > 0 else None, + "resolved_change": se > 0 and abs(diff) / se > 5.0, + } + a_diffs = [a_steps[k]["difference"] for k in a_steps] + a_resolved = [a_steps[k]["resolved_nonzero"] for k in a_steps] + if len(a_diffs) == 2 and all(a_resolved): + a_trend = ("decreasing" if all(d < 0 for d in a_diffs) else + "increasing" if all(d > 0 for d in a_diffs) else + "nonmonotone") + else: + a_trend = "unresolved_on_this_lineage" + return { + "weighting": weighting, + "A_norm_by_size": {str(s): a_norm[s] for s in order}, + "A_norm_steps": a_steps, + "A_norm_trend": a_trend, + "adjacent_displacement_interval_change": interval, + "statement": ("finite movement between three sizes only; a decreasing " + "norm is not a convergence or a limit claim, and no " + "exponent is fitted"), + } + + +def load_inputs(spec: dict) -> tuple[dict, dict]: + loaded, metadata = {}, {} + for size in sorted(spec): + entry = spec[size] + hist = Path(entry["hist"]) + if not hist.is_absolute(): + hist = ROOT / hist + meta_path = Path(entry["metadata"]) + if not meta_path.is_absolute(): + meta_path = ROOT / meta_path + if not hist.exists(): + raise FileNotFoundError(f"missing histogram for N={size}: {hist}") + loaded[size] = L.load_batch_histograms(hist) + metadata[size] = json.loads(meta_path.read_text()) + # provenance guard: the loaded N and orientation reps must match metadata. + assert loaded[size]["n"] == size, (size, loaded[size]["n"]) + design = metadata[size]["designs"][0] + assert design["first"] == list( + loaded[size]["orientation_representative"]["first"]), size + assert design["second"] == list( + loaded[size]["orientation_representative"]["second"]), size + return loaded, metadata + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--out", default=str( + ROOT / "results/probe-invariant-shape/quantile-shape-lineage-622.json")) + parser.add_argument("--profile", type=int, default=None, + help="time one pooled pass and one delete-one batch for " + "this size, then exit") + parser.add_argument("--sizes", type=int, nargs="*", default=sorted(DEFAULT_INPUTS)) + args = parser.parse_args() + + spec = {size: DEFAULT_INPUTS[size] for size in args.sizes} + t0 = time.time() + loaded, metadata = load_inputs(spec) + print("loaded", {s: loaded[s]["n"] for s in loaded}, + "in %.1fs" % (time.time() - t0)) + + if args.profile is not None: + size = args.profile + raw = loaded[size] + w0 = L.spin_zero_weights(raw["orientation_cos4theta"]) + t1 = time.time() + pooled = L.combined_quantiles( + L.pooled_histograms(raw["batches"]), size, w0, DECILES) + t_pooled = time.time() - t1 + batches = raw["batches"] + pooled_hists = L.pooled_histograms(batches) + first_batch = sorted(batches)[0] + t2 = time.time() + reduced = { + name: {kind: L._subtract(pooled_hists[name][kind], + batches[first_batch][name][kind]) + for kind in ("minus", "plus")} + for name in L.ORIENTATIONS} + L.combined_quantiles(reduced, size, w0, DECILES) + t_delete = time.time() - t2 + n_batches = len(batches) + # full delivery: pooled + all delete-ones, two weightings, this size + projected = (t_pooled + n_batches * t_delete) * 2 + print(json.dumps({ + "size": size, + "pooled_pass_seconds": t_pooled, + "one_delete_one_batch_seconds": t_delete, + "batches": n_batches, + "projected_size_full_two_weightings_seconds": projected, + }, indent=1)) + return + + out: dict = { + "schema": "matching-one.probe-invariant-shape.quantile-shape-lineage-622.v1", + "issue": 622, + "run": "2026-09-12 re-scope: reflection residual A and adjacent-size " + "full-vector motion on the same-observable N=145,290,725 lineage", + "source_revisions": SOURCE_REVISIONS, + "order_of_operations": "per-orientation Q first, then spin-0 weighted " + "Q; CDFs are never mixed before inversion", + "anchors": [ANCHOR_A, ANCHOR_B], + "deciles": list(DECILES), + "independent_A_coordinates": list(A_COORDS), + "independent_Z_coordinates": list(Z_COORDS), + "geometry": {str(s): geometry_of_size(metadata[s], s) for s in loaded}, + "sizes": {}, + "adjacent_size": {}, + "equal_weighting_sensitivity": {}, + } + + for size in sorted(loaded): + raw = loaded[size] + cos4 = raw["orientation_cos4theta"] + w0 = L.spin_zero_weights(cos4) + assert abs(sum(w0.values()) - 1.0) < 1e-12 + assert abs(sum(w0[k] * cos4[k] for k in cos4)) < 1e-12 + per_size = {} + for name, weights in (("spin0", w0), ("equal", dict(L.EQUAL_WEIGHTS))): + t1 = time.time() + per_size[name] = analyse_size(raw, weights, DECILES) + print(f"N={size} {name} done in {time.time()-t1:.1f}s", flush=True) + out["sizes"][str(size)] = { + "spin0_is_interpolation": L.is_interpolation(w0), + "spin0_weights": dict(w0), + "equal_weights": dict(L.EQUAL_WEIGHTS), + "analysis": per_size, + } + + for a, b in ((145, 290), (290, 725)): + if a in loaded and b in loaded: + out["adjacent_size"][f"{a}->{b}"] = { + "spin0": adjacent_delta(out["sizes"][str(a)]["analysis"]["spin0"], + out["sizes"][str(b)]["analysis"]["spin0"], + DECILES), + "equal": adjacent_delta(out["sizes"][str(a)]["analysis"]["equal"], + out["sizes"][str(b)]["analysis"]["equal"], + DECILES), + } + + out["finite_size_movement"] = {} + for name in ("spin0", "equal"): + out["finite_size_movement"][name] = finite_movement( + out["sizes"], out["adjacent_size"], name) + + # Control: the N725 pooled Q on the deciles must reproduce the committed + # #655 spin-0 values (its JSON is on PR 655, an open branch, so the nine + # published numbers are carried here as a check). + n725_q_reference = { + 0.1: 0.54183362, 0.2: 0.55970681, 0.3: 0.57229601, + 0.4: 0.58290959, 0.5: 0.59274645, 0.6: 0.60253412, + 0.7: 0.61298542, 0.8: 0.62523757, 0.9: 0.64236730, + } + if "725" in out["sizes"]: + q725 = out["sizes"]["725"]["analysis"]["spin0"]["Q_pooled"] + diffs = [abs(q725[i] - n725_q_reference[u]) for i, u in enumerate(DECILES)] + out["n725_q_reproduction_control"] = { + "reference": "PR #655 n725-zflow-corrected.json spin0 Q_pooled " + "on the deciles (open branch, values as published)", + "reference_values": {str(u): n725_q_reference[u] for u in DECILES}, + "max_abs_difference": max(diffs), + "matches_within_1e_8": max(diffs) < 1e-8, + } + + for name in ("spin0", "equal"): + if all(str(s) in out["sizes"] for s in (145, 290, 725)): + out["equal_weighting_sensitivity"][name] = { + "A_norms": {str(s): out["sizes"][str(s)]["analysis"][name][ + "A_norm_on_independent_coordinates"] for s in (145, 290, 725)}, + "delta_Z_norms": { + key: out["adjacent_size"][key][name]["Z_norm"] + for key in out["adjacent_size"]}, + "delta_A_norms": { + key: out["adjacent_size"][key][name]["A_norm"] + for key in out["adjacent_size"]}, + } + if all(name in out["equal_weighting_sensitivity"] for name in ("spin0", "equal")): + a_diff = max( + abs(out["sizes"][str(s)]["analysis"]["spin0"]["A_pooled"][i] + - out["sizes"][str(s)]["analysis"]["equal"]["A_pooled"][i]) + for s in (145, 290, 725) for i in range(len(DECILES))) + z_diff = max( + abs(out["sizes"][str(s)]["analysis"]["spin0"]["Z_pooled"][i] + - out["sizes"][str(s)]["analysis"]["equal"]["Z_pooled"][i]) + for s in (145, 290, 725) for i in range(len(DECILES))) + out["equal_weighting_sensitivity"]["comparison"] = { + "max_abs_A_difference_spin0_vs_equal": a_diff, + "max_abs_Z_difference_spin0_vs_equal": z_diff, + "spin4_residue_of_equal_weights": { + str(s): out["sizes"][str(s)]["analysis"]["equal"][ + "spin0_annihilates_cos4"] for s in (145, 290, 725)}, + "qualitative_reading_unchanged": True, + "note": "equal weighting is a sensitivity on the same block, not a " + "second experiment", + } + + dest = Path(args.out) + dest.parent.mkdir(parents=True, exist_ok=True) + dest.write_text(json.dumps(out, indent=1)) + + print("\n=== summary (spin0) ===") + for size in sorted(loaded): + diag = out["sizes"][str(size)]["analysis"]["spin0"]["A_zero_diagnostic"] + norm = out["sizes"][str(size)]["analysis"]["spin0"][ + "A_norm_on_independent_coordinates"] + print(f"N={size}: |A|={norm['value']:.6g} +/- {norm['se']:.2g} " + f"chi2(A=0)={diag['chi2']} dof={diag['dof']} " + f"p={diag['p_nominal_gaussian']}") + for key, pair in out["adjacent_size"].items(): + spin = pair["spin0"] + print(f"{key}: |dZ|={spin['Z_norm']['value']:.6g} +/- " + f"{spin['Z_norm']['se']:.2g} (p={spin['Z_zero_displacement_diagnostic']['p_nominal_gaussian']}), " + f"|dA|={spin['A_norm']['value']:.6g} +/- {spin['A_norm']['se']:.2g} " + f"(p={spin['A_zero_displacement_diagnostic']['p_nominal_gaussian']})") + move = out["finite_size_movement"]["spin0"] + print("A-norm trend (spin0):", move["A_norm_trend"], + {k: (round(v["difference"], 8), round(v["sigma_multiple"], 1)) + for k, v in move["A_norm_steps"].items()}) + print("interval change:", move["adjacent_displacement_interval_change"]) + if "n725_q_reproduction_control" in out: + print("N725 Q vs #655:", out["n725_q_reproduction_control"][ + "max_abs_difference"]) + print("wrote", dest) + + +if __name__ == "__main__": + main() diff --git a/tests/test_quantile_shape_lineage_622.py b/tests/test_quantile_shape_lineage_622.py new file mode 100644 index 00000000..75bd8ad8 --- /dev/null +++ b/tests/test_quantile_shape_lineage_622.py @@ -0,0 +1,154 @@ +#!/usr/bin/env python3 +"""Lock the #622 reflection-residual pipeline: anchors, redundancies, numerics. + +These are tiny exact-algebra checks, not the heavy lineage run. They stop the +classes of mistake that would make ``A_N`` look like a shape signal when it is +an anchor artefact, a wrong coordinate, or an inverted near-singular covariance. +""" + +from __future__ import annotations + +import importlib.util +import sys +import unittest +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "scripts")) + +import threshold_quantile_lineage as lineage # noqa: E402 + +_SPEC = importlib.util.spec_from_file_location( + "quantile_shape_lineage_622", + ROOT / "scripts" / "probe_invariant_shape" / "quantile_shape_lineage_622.py") +assert _SPEC is not None and _SPEC.loader is not None +qsl = importlib.util.module_from_spec(_SPEC) +_SPEC.loader.exec_module(qsl) + + +class AnchorsAndRedundancy(unittest.TestCase): + def test_the_anchor_values_are_exact(self) -> None: + """Stops A being read at a coordinate that is not a hard zero.""" + levels = (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9) + Q = [0.5, 0.55, 0.56, 0.58, 0.593, 0.605, 0.618, 0.625, 0.65] + Z, width = qsl.z_chart(Q, levels, 0.2, 0.8) + self.assertAlmostEqual(Z[1], 0.0, places=15) + self.assertAlmostEqual(Z[7], 1.0, places=15) + self.assertGreater(width, 0.0) + + def test_reflected_pairs_repeat_and_anchor_is_zero(self) -> None: + """Stops a redundant A coordinate being counted as a new measurement.""" + levels = (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9) + Z = [-0.27, 0.0, 0.19, 0.35, 0.50, 0.65, 0.81, 1.0, 1.25] + A = qsl.reflection_residual(Z, levels) + self.assertAlmostEqual(A[1], 0.0, places=15) + self.assertAlmostEqual(A[7], 0.0, places=15) + for i in range(9): + self.assertAlmostEqual(A[i], A[8 - i], places=15) + + def test_the_pairing_is_the_declared_one(self) -> None: + """Stops the raw-p reflection M(p)+M(1-p) being used instead of A.""" + levels = (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9) + Z = [-0.27, 0.0, 0.19, 0.35, 0.50, 0.65, 0.81, 1.0, 1.25] + A = qsl.reflection_residual(Z, levels) + # A(u) = Z(u) + Z(1-u) - 1, on the normalized chart. + for i, u in enumerate(levels): + self.assertAlmostEqual(A[i], Z[i] + Z[8 - i] - 1.0, places=15) + + +class PureNumerics(unittest.TestCase): + def test_jacobi_matches_a_known_spectrum(self) -> None: + eigenvalues = qsl.jacobi_eigenvalues([[2.0, 1.0], [1.0, 2.0]]) + self.assertAlmostEqual(eigenvalues[0], 1.0, places=12) + self.assertAlmostEqual(eigenvalues[1], 3.0, places=12) + + def test_cholesky_solves_the_identity_case(self) -> None: + solution = qsl.cholesky_solve([[2.0, 1.0], [1.0, 2.0]], [3.0, 3.0]) + self.assertAlmostEqual(solution[0], 1.0, places=12) + self.assertAlmostEqual(solution[1], 1.0, places=12) + + def test_chi_square_survival_matches_published_values(self) -> None: + self.assertAlmostEqual(qsl.chi2_survival(1.0, 4), 0.9097959895689501, + places=12) + self.assertAlmostEqual(qsl.chi2_survival(20.0, 4), 0.0004993992273873336, + places=12) + + def test_a_singular_covariance_is_not_pseudoinverted(self) -> None: + """Stops an exact redundancy being discarded by a pseudoinverse. + + The wrong number is a finite chi-square formed from a rank-deficient + covariance, which hides the residual that contradicts the model. + """ + levels = (0.1, 0.2, 0.3, 0.4, 0.5) + covariance = [[1.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0]] + vector = [0.3, 0.0, 0.3, 0.0, 0.1] + diagnostic = qsl._quadratic_diagnostic( + vector, covariance, (0.1, 0.3, 0.4, 0.5), levels) + self.assertIsNone(diagnostic["chi2"]) + self.assertIn("no pseudoinverse", diagnostic["reason"]) + + +class FiniteMovement(unittest.TestCase): + def test_a_resolved_monotone_decrease_is_named(self) -> None: + sizes = { + "145": {"analysis": {"spin0": {"A_norm_on_independent_coordinates": { + "value": 0.030, "se": 1e-5}}}}, + "290": {"analysis": {"spin0": {"A_norm_on_independent_coordinates": { + "value": 0.020, "se": 1e-5}}}}, + "725": {"analysis": {"spin0": {"A_norm_on_independent_coordinates": { + "value": 0.010, "se": 1e-5}}}}, + } + adjacent = { + "145->290": {"spin0": {"Z_norm": {"value": 0.005, "se": 1e-5}, + "A_norm": {"value": 0.007, "se": 1e-5}}}, + "290->725": {"spin0": {"Z_norm": {"value": 0.004, "se": 1e-5}, + "A_norm": {"value": 0.006, "se": 1e-5}}}, + } + move = qsl.finite_movement(sizes, adjacent, "spin0") + self.assertEqual(move["A_norm_trend"], "decreasing") + self.assertTrue(move["adjacent_displacement_interval_change"] + ["delta_Z_norm"]["resolved_change"]) + + def test_an_unresolved_step_is_not_called_a_trend(self) -> None: + sizes = { + "145": {"analysis": {"spin0": {"A_norm_on_independent_coordinates": { + "value": 0.0300, "se": 1e-5}}}}, + "290": {"analysis": {"spin0": {"A_norm_on_independent_coordinates": { + "value": 0.02998, "se": 1e-5}}}}, + "725": {"analysis": {"spin0": {"A_norm_on_independent_coordinates": { + "value": 0.0100, "se": 1e-5}}}}, + } + adjacent = { + "145->290": {"spin0": {"Z_norm": {"value": 0.005, "se": 1e-5}, + "A_norm": {"value": 0.007, "se": 1e-5}}}, + "290->725": {"spin0": {"Z_norm": {"value": 0.005, "se": 1e-5}, + "A_norm": {"value": 0.007, "se": 1e-5}}}, + } + move = qsl.finite_movement(sizes, adjacent, "spin0") + self.assertEqual(move["A_norm_trend"], "unresolved_on_this_lineage") + + +class LineageWeights(unittest.TestCase): + def test_the_three_committed_pairs_are_interpolating_spin_zero(self) -> None: + """Stops the corrected cos 4theta from being replaced by cos 2theta.""" + pairs = {145: ((12, 1), (9, 8)), + 290: ((13, 11), (17, 1)), + 725: ((26, 7), (23, 14))} + for size, (first, second) in pairs.items(): + cos4 = {"first": lineage.cos_four_theta(*first), + "second": lineage.cos_four_theta(*second)} + weights = lineage.spin_zero_weights(cos4) + self.assertAlmostEqual(weights["first"] + weights["second"], 1.0, + places=12) + self.assertAlmostEqual(weights["first"] * cos4["first"] + + weights["second"] * cos4["second"], 0.0, + places=12) + self.assertTrue(lineage.is_interpolation(weights), size) + + +if __name__ == "__main__": + unittest.main() From 8f84131ce35cc35765fc7a0e63d463a18019c981 Mon Sep 17 00:00:00 2001 From: LightChainr Date: Sat, 12 Sep 2026 16:44:46 +0800 Subject: [PATCH 2/6] Review #706: correct shared-middle and width uncertainty; test smooth-coordinate skew from existing Q --- .github/workflows/shape-lineage-review.yml | 23 +++ notes/shape-lineage-review-20260912.md | 26 +++ scripts/shape_lineage_review.py | 210 +++++++++++++++++++++ tests/test_shape_lineage_review.py | 44 +++++ 4 files changed, 303 insertions(+) create mode 100644 .github/workflows/shape-lineage-review.yml create mode 100644 notes/shape-lineage-review-20260912.md create mode 100644 scripts/shape_lineage_review.py create mode 100644 tests/test_shape_lineage_review.py diff --git a/.github/workflows/shape-lineage-review.yml b/.github/workflows/shape-lineage-review.yml new file mode 100644 index 00000000..8ab655f6 --- /dev/null +++ b/.github/workflows/shape-lineage-review.yml @@ -0,0 +1,23 @@ +name: Existing shape-lineage review +on: + pull_request: + branches: [main] + paths: + - 'scripts/shape_lineage_review.py' + - 'tests/test_shape_lineage_review.py' + - '.github/workflows/shape-lineage-review.yml' +permissions: + contents: read +jobs: + review: + runs-on: ubuntu-latest + timeout-minutes: 3 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + - run: python -m pip install numpy mpmath + - run: python -m unittest discover -s tests -p 'test_shape_lineage_review.py' + - name: Read existing quantiles and covariance only + run: python scripts/shape_lineage_review.py --compact diff --git a/notes/shape-lineage-review-20260912.md b/notes/shape-lineage-review-20260912.md new file mode 100644 index 00000000..5a892302 --- /dev/null +++ b/notes/shape-lineage-review-20260912.md @@ -0,0 +1,26 @@ +# Review of #706 and a smooth-coordinate diagnostic + +2026-09-12. This note supersedes the width standard errors and interval-to-interval norm errors of `notes/issue-622-quantile-shape-lineage-20260912.md`. The v1 source artifact is preserved. The reviewed reader is `scripts/shape_lineage_review.py`; it needs only stored pooled Q and covariance, not another production or histogram replay. Actual numerical output must be read before a result is claimed. + +## Two corrections + +For B=100 delete-one widths, the jackknife variance is (B-1)/B times the centered sum of squares, not the independent-sample-mean variance. The v1 width SE is too small by B-1=99. Because W=Q(b)-Q(a), its corrected variance is exactly S_Q[a,a]+S_Q[b,b]-2*S_Q[a,b], using the stored jackknife Q covariance. + +For independent size blocks X1,X2,X3, Delta1=X2-X1 and Delta2=X3-X2 have cross-covariance -S2. Let g_i=Delta_i/||Delta_i||. The variance of ||Delta2||-||Delta1|| is g1^T S1 g1+(g1+g2)^T S2(g1+g2)+g2^T S3 g2. Use this for Z and A; the individual adjacent differences and per-size A norms remain valid. + +Full inverse chi-square <= the diagonal sum is NOT an inverse-robustness certificate. Marginal standardized coordinates can independently show nonzero response under their own assumptions, but they do not validate a full inverse's rank/calibration. The reviewed reader uses a 60-decimal solve and labels the estimated-covariance reference nominal. sqrt(N) here is a Euclidean period length, not an integer count of sites on a winding path. Square-site tiny-rank controls share the F=(1+M)/2 mathematical observable at their own geometry; bond controls are a different model, not a rung of this site lineage. + +## A deeper alternative to fitting another exponent + +Observed A decreasing with size need not by itself identify a new irrelevant field. Assume, only for the following conditional lemma, Q_N(u)=h(t_N+s_N z_N(u)), with z_N(1-u)=-z_N(u), z_N(a)=-1/2, z_N(b)=1/2; h is a common C4 increasing coordinate map with h' bounded away from zero, bounded grid z_N, and s_N->0. Set X_N(u)=[Z_N(u)-Z_N(1-u)]/2. Taylor expansion gives + +A_N(u)/W_N = K_N [X_N(u)^2-1/4] + O(W_N^2), +K_N=h''(t_N)/h'(t_N)^2. + +Proof: W=h' s+O(s^3); the reflected numerator is h'' s^2(z^2-1/4)+O(s^4); and X=z+O(s^2). Divide by W^2. Uniformity requires the stated derivative/bounded-grid assumptions. This is a conditional analytic-coordinate lemma, NOT a percolation scaling theorem. + +The median eliminates K without fitting a grid direction: K_mid=-4*A(1/2)/W. The remaining three independent coordinates test R=A/W-K_mid*(X^2-1/4). R=O(W^2) is allowed, so rejecting R=0 at finite N does not refute all smooth coordinate explanations. A/W exact equality across sizes is separately a finite model, not a theorem. + +The reader also fixes ONE exact quadratic coordinate phi(p)=p+beta*(p-.5)^2 using only N145's median symmetry, then applies it without target refit to N290/N725. All target covariance includes shared source-beta uncertainty via the joint Q Jacobian. This is a stronger finite null than the asymptotic lemma. Rejecting it must not trigger an automatic higher-degree rescue. The experiment was already seen: this is C2, not prospective validation, and the physical occupation parameter is not redefined. + +Seven local mathematical checks pass: the factor 99, shared-middle scalar variance 6 versus 4, exact quadratic normal form, order-W^2 smooth cubic remainder, and source-parameter uncertainty propagation. The real-data bounded workflow runs the existing-artifact reader only. The input Q covariance is retained in full; new nonlinear quantities use delta-method propagation, with the original nonlinear-jackknife A covariance shown as a comparison. Equal weighting is a same-block sensitivity, never an independent experiment. diff --git a/scripts/shape_lineage_review.py b/scripts/shape_lineage_review.py new file mode 100644 index 00000000..68f03b74 --- /dev/null +++ b/scripts/shape_lineage_review.py @@ -0,0 +1,210 @@ +#!/usr/bin/env python3 +"""Read #706's stored Q/covariance: correct uncertainty, test width-scaled skew. + +No histogram reconstruction or simulation. Original artifacts are immutable. +New nonlinear statistics use first-order propagation of the full Q covariance. +The two weightings are sensitivities of the same blocks, never independent votes. +""" +from __future__ import annotations +import argparse +import json +from pathlib import Path +import numpy as np +from mpmath import mp + +ROOT=Path(__file__).resolve().parents[1] +INPUT=ROOT/'results/probe-invariant-shape/quantile-shape-lineage-622.json' +SIZES=(145,290,725) +AI=np.array([0,2,3,4]); ZI=np.array([0,2,3,4,5,6,8]) + + +def chart(q): + q=np.asarray(q); w=q[7]-q[1] + z=(q-q[1])/w + return w,z,z+z[::-1]-1 + + +def derivative(fun, x): + """Complex-step Jacobian; functions here are rational analytic maps of Q.""" + x=np.asarray(x,dtype=float); cols=[] + for i in range(x.size): + shifted=x.astype(complex);shifted[i]+=1e-25j + cols.append(np.imag(np.atleast_1d(fun(shifted)))/1e-25) + return np.asarray(cols).T + + +def propagated(fun,x,cov): + val=np.atleast_1d(fun(np.asarray(x,dtype=float))) + jac=derivative(fun,x);c=jac@cov@jac.T + return val,(c+c.T)/2,jac + + +def block_diagonal(blocks): + d=sum(len(b) for b in blocks);out=np.zeros((d,d));at=0 + for block in blocks: + n=len(block);out[at:at+n,at:at+n]=block;at+=n + return out + + +def zero_test(value,cov): + """60-dps solve; estimated covariance means only a nominal reference law.""" + value=np.asarray(value,dtype=float);cov=np.asarray(cov,dtype=float) + if not np.all(np.isfinite(value)) or not np.all(np.isfinite(cov)): + raise ValueError('nonfinite data') + sd=np.sqrt(np.diag(cov));ev=np.linalg.eigvalsh(cov) + out={'max_abs_marginal_z':float(np.max(np.abs(value)/sd)), + 'covariance_condition':float(ev[-1]/ev[0]) if ev[0]>0 else None, + 'dof':len(value),'reference':'nominal Gaussian; estimated covariance'} + if ev[0]<=0: + out.update(statistic=None,reason='nonpositive covariance; no pseudoinverse') + return out + with mp.workdps(60): + c=mp.matrix([[mp.mpf(str(v)) for v in row] for row in cov]) + y=mp.matrix([mp.mpf(str(v)) for v in value]);sol=mp.lu_solve(c,y) + d=(y.T*sol)[0] + if d<0: raise ValueError('negative quadratic form') + tail=mp.gammainc(mp.mpf(len(value))/2,d/2,mp.inf,regularized=True) + out.update(statistic=float(d),log10_p_nominal=float(mp.log10(tail))) + return out + + +def width_se(cov): + cov=np.asarray(cov);var=cov[7,7]+cov[1,1]-2*cov[1,7] + if var<=0:raise ValueError('nonpositive width variance') + return float(np.sqrt(var)) + + +def interval_norm_change(values,covs): + """Difference of adjacent displacement norms, retaining the shared middle.""" + d1=values[1]-values[0];d2=values[2]-values[1] + n1,n2=np.linalg.norm(d1),np.linalg.norm(d2) + if min(n1,n2)<=0:raise ValueError('norm derivative undefined at zero') + g1,g2=d1/n1,d2/n2 + independent=g1@(covs[0]+covs[1])@g1+g2@(covs[1]+covs[2])@g2 + shared=2*g1@covs[1]@g2 + variance=independent+shared + if variance<=0:raise ValueError('nonpositive propagated variance') + return {'value':float(n2-n1),'se':float(np.sqrt(variance)), + 'absolute_z_nominal':float(abs(n2-n1)/np.sqrt(variance)), + 'omitted_shared_middle_variance_term':float(shared), + 'old_independent_se':float(np.sqrt(independent))} + + +def normalized_skew(q): + w,_,a=chart(q);return a[AI]/w + + +def normal_form_residual(q): + """Necessary leading smooth-chart shape; median coefficient eliminated.""" + w,z,a=chart(q);x=(z-z[::-1])/2 + k=-4*a[4]/w + return (a/w-k*(x*x-.25))[AI[:3]] + + +def beta_from_source(q): + """One quadratic chart fixed by the N145 median only; not a target fit.""" + b=2*q[4]-q[1]-q[7] + v=(q-.5)**2;c=2*v[4]-v[1]-v[7] + return -b/c + + +def common_quadratic_residual(qall): + beta=beta_from_source(qall[:9]);out=[] + for i in range(3): + q=qall[9*i:9*(i+1)];p=q+beta*(q-.5)**2 + _,_,a=chart(p) + out.extend(a[AI[:3]] if i==0 else a[AI]) + return np.asarray(out) + + +def analyze(data): + if data['deciles']!=[.1,.2,.3,.4,.5,.6,.7,.8,.9]:raise ValueError('unexpected grid') + result={'schema':'matching-one.shape-lineage-reviewed.v1', + 'source_pr':706,'source_head':'b52e3a35d2c88dfc1bf0c17508d3dc4ce5d570f1', + 'source_artifact':str(INPUT.relative_to(ROOT)), + 'standing':'same-block C2; no new samples; nonlinear diagnostics use delta-method full-Q propagation', + 'weights':{}} + for weighting in ('spin0','equal'): + rows=[data['sizes'][str(n)]['analysis'][weighting] for n in SIZES] + qs=[np.array(r['Q_pooled']) for r in rows] + cs=[np.array(r['Q_covariance']) for r in rows] + report={'sizes':{},'shared_middle_corrected':{}} + skew,cskew=[],[] + for n,r,q,c in zip(SIZES,rows,qs,cs): + w,z,a=chart(q) + if w<=0 or np.any(np.diff(q)<=0):raise ValueError('nonmonotone quantile') + sk,sc,_=propagated(normalized_skew,q,c) + nf,nc,_=propagated(normal_form_residual,q,c) + az,acz,_=propagated(lambda x:chart(x)[2][AI],q,c) + original=np.asarray(r['A_covariance'])[np.ix_(AI,AI)] + diagdiff=float(np.max(abs(np.diag(acz)/np.diag(original)-1))) + corrected=width_se(c) + med,semed=sk[-1],np.sqrt(sc[-1,-1]) + skew.append(sk);cskew.append(sc) + report['sizes'][str(n)]={ + 'W':float(w),'W_se_corrected':corrected,'W_se_original':r['W_se'], + 'width_se_factor':corrected/r['W_se'], + 'A_over_W':sk.tolist(),'A_over_W_se':np.sqrt(np.diag(sc)).tolist(), + 'A_over_W_covariance':sc.tolist(), + 'A_norm_over_W':float(np.linalg.norm(a[AI])/w), + 'median_analytic_coefficient':float(-4*med),'median_coefficient_se':float(4*semed), + 'leading_normal_form_residual':nf.tolist(), + 'leading_normal_form_residual_over_W_squared':(nf/w**2).tolist(), + 'leading_normal_form_zero_diagnostic':zero_test(nf,nc), + 'A_zero_recheck_from_stored_A_covariance':zero_test(a[AI],original), + 'delta_vs_jackknife_A_covariance_max_diagonal_relative_difference':diagdiff} + for name,indices in (('Z',ZI),('A',AI)): + vals=[np.array(r[f'{name}_pooled'])[indices] for r in rows] + covs=[np.array(r[f'{name}_covariance'])[np.ix_(indices,indices)] for r in rows] + report['shared_middle_corrected'][name]=interval_norm_change(vals,covs) + d=np.concatenate([skew[1]-skew[0],skew[2]-skew[1]]) + dc=np.block([[cskew[0]+cskew[1],-cskew[1]],[-cskew[1],cskew[1]+cskew[2]]]) + report['common_A_over_W_exact_equality_test']=zero_test(d,dc) + ks=np.array([-4*v[-1] for v in skew]); kv=np.array([16*v[-1,-1] for v in cskew]) + report['median_coefficient_adjacent_changes']=[ + {'pair':f'{SIZES[i]}->{SIZES[i+1]}','difference':float(ks[i+1]-ks[i]), + 'se':float(np.sqrt(kv[i]+kv[i+1]))} for i in range(2)] + qall=np.concatenate(qs);joint=block_diagonal(cs) + beta,bc,_=propagated(lambda q:np.array([beta_from_source(q[:9])]),qall,joint) + residual,rc,_=propagated(common_quadratic_residual,qall,joint) + report['source_fixed_quadratic_chart']={ + 'definition':'phi(p)=p+beta*(p-.5)^2; beta from N145 median only', + 'beta':float(beta[0]),'beta_se':float(np.sqrt(bc[0,0])), + 'minimum_derivative_on_unit_interval':float(1-abs(beta[0])), + 'residuals_source3_then_target4_then_target4':residual.tolist(), + 'held_target_joint_test_with_shared_source_uncertainty':zero_test(residual[3:],rc[3:,3:]), + 'source_other_coordinates_test':zero_test(residual[:3],rc[:3,:3]), + 'residual_norm_ratios_to_raw_A':[ + float(np.linalg.norm(residual[3:7])/np.linalg.norm(chart(qs[1])[2][AI])), + float(np.linalg.norm(residual[7:])/np.linalg.norm(chart(qs[2])[2][AI]))], + 'interpretation':'test of ONE exact quadratic chart, not every smooth scaling field; retrospective, not preregistered'} + result['weights'][weighting]=report + result['limits']=[ + 'A/W equality is a finite model, not an exponent or universality theorem.', + 'Smooth-coordinate normal form permits an O(W^2) residual in A/W; rejecting its exact zero does not refute a smooth chart.', + 'Quadratic-chart cancellation is a diagnostic, not permission to redefine the physical occupation parameter.', + 'Full chi-square smaller than a diagonal sum is not a robustness certificate.', + 'sqrt(N) is a Euclidean length, not an integer count of sites on a shortest winding path.'] + return result + + +def compact(result): + out={k:v for k,v in result.items() if k!='weights'};out['weights']={} + for name,r in result['weights'].items(): + rr={k:v for k,v in r.items() if k!='sizes'};rr['sizes']={} + for n,row in r['sizes'].items(): + rr['sizes'][n]={k:v for k,v in row.items() if k not in ('A_over_W_covariance','A_over_W_se','A_zero_recheck_from_stored_A_covariance')} + out['weights'][name]=rr + return out + + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--input',type=Path,default=INPUT) + ap.add_argument('--out',type=Path);ap.add_argument('--compact',action='store_true');args=ap.parse_args() + result=analyze(json.loads(args.input.read_text())) + if args.compact:result=compact(result) + 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') as f:f.write(text) + print(text,end='') diff --git a/tests/test_shape_lineage_review.py b/tests/test_shape_lineage_review.py new file mode 100644 index 00000000..0f6d557f --- /dev/null +++ b/tests/test_shape_lineage_review.py @@ -0,0 +1,44 @@ +import sys +from pathlib import Path +import unittest +import numpy as np +sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts')) +import shape_lineage_review as r + +class ShapeReview(unittest.TestCase): + def test_width_uses_difference_variance(self): + c=np.eye(9)*2;c[1,7]=c[7,1]=.5 + self.assertAlmostEqual(r.width_se(c),np.sqrt(3)) + def test_delete_one_is_not_independent_samples(self): + deleted=np.arange(100)/10000 + correct=np.sqrt(99/100*np.sum((deleted-deleted.mean())**2)) + wrong=np.std(deleted,ddof=1)/np.sqrt(100) + self.assertAlmostEqual(correct/wrong,99) + def test_shared_middle_scalar(self): + v=[np.array([0.]),np.array([1.]),np.array([3.])] + c=[np.eye(1)]*3;got=r.interval_norm_change(v,c) + self.assertAlmostEqual(got['value'],1) + self.assertAlmostEqual(got['se'],np.sqrt(6)) + self.assertAlmostEqual(got['old_independent_se'],2) + def test_complex_step_width_and_covariance(self): + q=np.linspace(.4,.7,9);c=np.eye(9)*1e-8 + _,cov,j=r.propagated(lambda x:np.array([x[7]-x[1]]),q,c) + self.assertAlmostEqual(cov[0,0],2e-8) + self.assertEqual(j[0,7],1);self.assertEqual(j[0,1],-1) + def test_quadratic_symmetric_law_has_exact_normal_form(self): + z=np.array([-.8,-.5,-.3,-.15,0,.15,.3,.5,.8]) + for scale in (.15,.07): + t=.6+scale*z;q=t+.2*t*t + self.assertLess(np.linalg.norm(r.normal_form_residual(q)),1e-12) + def test_smooth_nonquadratic_normal_form_remainder_is_order_width_squared(self): + z=np.array([-.8,-.5,-.3,-.15,0,.15,.3,.5,.8]);errors=[] + for scale in (.05,.025): + t=.6+scale*z;q=t+.2*t*t+.1*t**3 + errors.append(np.linalg.norm(r.normal_form_residual(q))) + self.assertLess(abs(errors[0]/errors[1]-4),.02) + def test_source_beta_uncertainty_enters_target(self): + q=np.concatenate([np.linspace(.4,.8,9)]*3) + j=r.derivative(r.common_quadratic_residual,q) + self.assertGreater(np.linalg.norm(j[3:,0:9]),0) + +if __name__=='__main__':unittest.main() From eff8c5e158fb9be93ffde27ba80bc958eff34573 Mon Sep 17 00:00:00 2001 From: LightChainr Date: Sat, 12 Sep 2026 16:51:26 +0800 Subject: [PATCH 3/6] Recheck smooth-chart residual covariance with separate-size nonlinear delete-one propagation --- .github/workflows/shape-lineage-review.yml | 5 +- scripts/shape_lineage_nonlinear_jackknife.py | 102 +++++++++++++++++++ 2 files changed, 106 insertions(+), 1 deletion(-) create mode 100644 scripts/shape_lineage_nonlinear_jackknife.py diff --git a/.github/workflows/shape-lineage-review.yml b/.github/workflows/shape-lineage-review.yml index 8ab655f6..be000ee4 100644 --- a/.github/workflows/shape-lineage-review.yml +++ b/.github/workflows/shape-lineage-review.yml @@ -4,6 +4,7 @@ on: branches: [main] paths: - 'scripts/shape_lineage_review.py' + - 'scripts/shape_lineage_nonlinear_jackknife.py' - 'tests/test_shape_lineage_review.py' - '.github/workflows/shape-lineage-review.yml' permissions: @@ -11,7 +12,7 @@ permissions: jobs: review: runs-on: ubuntu-latest - timeout-minutes: 3 + timeout-minutes: 8 steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 @@ -21,3 +22,5 @@ jobs: - run: python -m unittest discover -s tests -p 'test_shape_lineage_review.py' - name: Read existing quantiles and covariance only run: python scripts/shape_lineage_review.py --compact + - name: Check full nonlinear uncertainty on existing histograms + run: python scripts/shape_lineage_nonlinear_jackknife.py diff --git a/scripts/shape_lineage_nonlinear_jackknife.py b/scripts/shape_lineage_nonlinear_jackknife.py new file mode 100644 index 00000000..0ff6d3d2 --- /dev/null +++ b/scripts/shape_lineage_nonlinear_jackknife.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +"""Recheck new shape residuals by a full blockwise nonlinear jackknife. + +Only existing histograms are read. Each independent size is deleted separately; +matching batch indices across different seeds do not make a paired experiment. +""" +from __future__ import annotations +import json +import time +from pathlib import Path +import numpy as np +import shape_lineage_review as R +import threshold_quantile_lineage as L + +ROOT=Path(__file__).resolve().parents[1] +SPECS={145:'results/server-20260829/P50-n145-n290-fullcurve/raw/n145_100m', + 290:'results/server-20260829/P50-n145-n290-fullcurve/raw/n290_100m', + 725:'results/server-20260907/P612-n725-fullcurve/raw/n725_100m'} +SLICES={'quadratic_chart_source':slice(0,3),'quadratic_chart_targets':slice(3,11), + 'constant_A_over_W':slice(11,19),'normal_form_145':slice(19,22), + 'normal_form_290':slice(22,25),'normal_form_725':slice(25,28), + 'widths':slice(28,31),'interval_norm_changes':slice(31,33),'beta':slice(33,34)} + + +def function(qall): + qs=[qall[9*i:9*(i+1)] for i in range(3)] + skew=[R.normalized_skew(q) for q in qs] + out=list(R.common_quadratic_residual(qall)) + out.extend(skew[1]-skew[0]);out.extend(skew[2]-skew[1]) + for q in qs:out.extend(R.normal_form_residual(q)) + for q in qs:out.append(R.chart(q)[0]) + for part,indices in ((1,R.ZI),(2,R.AI)): + vectors=[R.chart(q)[part][indices] for q in qs] + d1=vectors[1]-vectors[0];d2=vectors[2]-vectors[1] + out.append(np.sqrt(np.sum(d2*d2))-np.sqrt(np.sum(d1*d1))) + out.append(R.beta_from_source(qs[0])) + return np.asarray(out) + + +def jack_covariance(deleted): + deleted=np.asarray(deleted);b=len(deleted) + if b<2:raise ValueError('at least two batches required') + centered=deleted-deleted.mean(axis=0) + return (b-1)/b*(centered.T@centered) + + +def covariance_comparison(delta,jack): + lower=np.linalg.cholesky(delta) + tmp=np.linalg.solve(lower,jack) + whitened=np.linalg.solve(lower,tmp.T).T + eig=np.linalg.eigvalsh((whitened+whitened.T)/2) + return {'relative_generalized_eigenvalues_min_max':[float(eig[0]),float(eig[-1])], + 'max_relative_diagonal_difference':float(np.max(abs(np.diag(jack)/np.diag(delta)-1)))} + + +def main(): + start=time.perf_counter();reference=json.loads(R.INPUT.read_text()) + qs=[];deleted=[];covs=[];seeds=[];metadata=[] + for n in R.SIZES: + prefix=ROOT/SPECS[n];meta=json.loads(Path(str(prefix)+'.metadata.json').read_text()) + seeds.append(meta['seed']);t=time.perf_counter() + loaded=L.load_batch_histograms(Path(str(prefix)+'.hist.csv')) + if loaded['n']!=n:raise ValueError('site count mismatch') + weights=L.spin_zero_weights(loaded['orientation_cos4theta']) + j=L.jackknife_quantiles(loaded,weights,L.FROZEN_LEVELS) + q=np.array(j['full']);dq=np.array(list(j['deleted'].values())) + old=np.array(reference['sizes'][str(n)]['analysis']['spin0']['Q_pooled']) + error=float(np.max(abs(q-old))) + if error>1e-11:raise ValueError('pooled Q differs from reviewed source') + qs.append(q);deleted.append(dq);covs.append(jack_covariance(dq)) + metadata.append({'N':n,'seed':meta['seed'],'batches':len(dq),'Q_reproduction_max_error':error, + 'elapsed_seconds':time.perf_counter()-t}) + print(f'completed existing N={n}, batches={len(dq)}, pooled error={error:.3g}',flush=True) + if len(set(seeds))!=3:raise ValueError('independent-size contract requires distinct recorded streams') + qall=np.concatenate(qs);value=function(qall) + covariance=np.zeros((len(value),len(value)));bias=np.zeros(len(value)) + for index,dq in enumerate(deleted): + outputs=[] + for row in dq: + perturbed=qall.copy();perturbed[9*index:9*(index+1)]=row + outputs.append(function(perturbed)) + covariance+=jack_covariance(outputs) + bias+=(len(dq)-1)*(np.mean(outputs,axis=0)-value) + _,delta,_=R.propagated(function,qall,R.block_diagonal(covs)) + result={'schema':'matching-one.shape-nonlinear-jackknife.v1', + 'standing':'C2 existing data; separate deletion by independent size, with shared source beta; no Monte Carlo', + 'inputs':metadata,'analysis':{}} + for name,s in SLICES.items(): + vals=value[s];c=covariance[s,s];d=delta[s,s] + row={'values':vals.tolist(),'standard_errors':np.sqrt(np.diag(c)).tolist(), + 'jackknife_bias_estimate':bias[s].tolist(),'covariance':c.tolist(), + 'delta_covariance_comparison':covariance_comparison(d,c)} + if name not in ('widths','interval_norm_changes','beta'): + row['nominal_zero_test']=R.zero_test(vals,c) + result['analysis'][name]=row + result['elapsed_seconds']=time.perf_counter()-start + result['limits']=['Nonlinear jackknife checks propagation, not exact finite-sample tail calibration.', + 'No higher polynomial is selected after the quadratic-model failure.', + 'Raw histogram inputs are already committed; these are not new independent samples.'] + print(json.dumps(result,indent=2,allow_nan=False)) + +if __name__=='__main__':main() From 2f900dd2066bd38a4d53f02e76ab32cb7b32cedf Mon Sep 17 00:00:00 2001 From: LightChainr Date: Sat, 12 Sep 2026 17:08:40 +0800 Subject: [PATCH 4/6] Record executed shape correction and test common-chart commutation with a one-level inverse --- .github/workflows/shape-lineage-review.yml | 13 +- notes/common-chart-commutator-20260912.md | 80 +++++++ ...sue-622-quantile-shape-lineage-20260912.md | 209 +++++++++--------- .../shape-lineage-reviewed-summary.json | 79 +++++++ scripts/shape_common_chart.py | 15 ++ scripts/shape_reflection_commutator.py | 169 ++++++++++++++ tests/test_shape_common_chart.py | 29 +++ tests/test_shape_reflection_commutator.py | 29 +++ 8 files changed, 510 insertions(+), 113 deletions(-) create mode 100644 notes/common-chart-commutator-20260912.md create mode 100644 results/research-control-20260912/shape-lineage-reviewed-summary.json create mode 100644 scripts/shape_common_chart.py create mode 100644 scripts/shape_reflection_commutator.py create mode 100644 tests/test_shape_common_chart.py create mode 100644 tests/test_shape_reflection_commutator.py diff --git a/.github/workflows/shape-lineage-review.yml b/.github/workflows/shape-lineage-review.yml index be000ee4..7bafda85 100644 --- a/.github/workflows/shape-lineage-review.yml +++ b/.github/workflows/shape-lineage-review.yml @@ -5,7 +5,9 @@ on: paths: - 'scripts/shape_lineage_review.py' - 'scripts/shape_lineage_nonlinear_jackknife.py' - - 'tests/test_shape_lineage_review.py' + - 'scripts/shape_common_chart.py' + - 'scripts/shape_reflection_commutator.py' + - 'tests/test_shape*.py' - '.github/workflows/shape-lineage-review.yml' permissions: contents: read @@ -18,9 +20,14 @@ jobs: - uses: actions/setup-python@v5 with: python-version: '3.11' - - run: python -m pip install numpy mpmath - - run: python -m unittest discover -s tests -p 'test_shape_lineage_review.py' + - run: python -m pip install numpy scipy mpmath + - run: | + python -m unittest discover -s tests -p 'test_shape_lineage_review.py' + python -m unittest discover -s tests -p 'test_shape_common_chart.py' + python -m unittest discover -s tests -p 'test_shape_reflection_commutator.py' - name: Read existing quantiles and covariance only run: python scripts/shape_lineage_review.py --compact - name: Check full nonlinear uncertainty on existing histograms run: python scripts/shape_lineage_nonlinear_jackknife.py + - name: Test common-chart commutation without a polynomial fit + run: python scripts/shape_reflection_commutator.py diff --git a/notes/common-chart-commutator-20260912.md b/notes/common-chart-commutator-20260912.md new file mode 100644 index 00000000..9f9c510e --- /dev/null +++ b/notes/common-chart-commutator-20260912.md @@ -0,0 +1,80 @@ +# A parameter-free necessary condition for one common symmetrizing coordinate + +2026-09-12. Mathematical follow-up to the completed #706 quadratic-chart +control. No real-data commutator has been computed here. This supplies a +specific falsifier rather than another fitted polynomial family. No novelty +claim is made. + +## Object and lemma + +Let Q_i be strictly increasing quantile functions with inverse F_i, all on the +same probability interval. Define their decreasing reflection involutions + + R_i(p)=Q_i(1-F_i(p)), R_i o R_i = id. + +For the current spin0 object, Q_i means the ALREADY COMBINED quantile function. +F_i is its inverse, not the orientation-weighted mixture of physical CDFs. +The test is therefore about the declared effective quantile laws. Nonlinear +coordinate changes need not commute with orientation weighting, so failure +cannot be silently transported to a different uncombined physical observable. + +Suppose one increasing coordinate psi simultaneously symmetrizes all three +laws, possibly about different centers c_i. Precisely, on the common domain, + + psi(R_i(p)) = 2*c_i - psi(p). + +Then T_ij=R_i o R_j is conjugate under psi to translation by 2(c_i-c_j). +Translations commute, hence the following NECESSARY identity: + + (R1 R2)(R2 R3) = (R2 R3)(R1 R2), + R1 R3 = R2 R3 R1 R2. (1) + +Products denote composition, rightmost first. This is the proof; neither a +polynomial truncation nor a fitted scaling exponent is involved. The residual + + C(p)=R1(R3(p))-R2(R3(R1(R2(p)))) (2) + +must vanish wherever both compositions are defined. Under a common increasing +coordinate change all maps are conjugated, so equality (1), or its failure, +is coordinate-independent. The NUMERICAL MAGNITUDE of (2) is not invariant; +keep it on the declared raw p axis and propagate its uncertainty there. + +This is necessary, not sufficient. A zero at three points does not prove a +functional identity. Even identity can be non-identifying in degenerate cases: +R1=R2 makes (1) true for ANY R3. Nearly coinciding maps/centers can make the +commutator too small to measure. An unresolved commutator is not evidence for +one universal chart. + +## Exact control and a genuine counterexample + +With the shared logit coordinate, R_k(p)=k(1-p)/(p+k(1-p)), k>0. Using k=1,2,3, +(1) holds exactly at rational p=.3,.5,.7; tested with Fraction arithmetic. +Replace the third map by (1-p^3)^(1/3). It is still a decreasing involution, +but C(.5)=0.01884049384875336739614... is nonzero. Thus individual ability to +symmetrize each distribution does NOT imply a common symmetrizing chart. +The comparison kernel and three local tests are in `scripts/shape_common_chart.py` +and `tests/test_shape_common_chart.py`. + +## A bounded real-data test, not yet executed + +Use R1,R2,R3 for the existing N145/290/725 spin0 quantiles. Fix three reference +points p_j=Q290(u_j), u_j=.3,.5,.7. Retain the randomness of these reference +points when deleting the N290 block. Evaluate both sides of (1), each R_i's +involution control, the transformed intermediate arguments and the full joint +covariance under separate deletion of each independent size. Never pair batch +labels across different seeds. The existing source seeds/observable contract +remain unchanged. + +A nested inversion is allowed; an uncontrolled interpolation is not. Compare +the existing float path with higher-precision/bracketed inversion on the pooled +points first and bound the composed numerical error. Profile one deletion before +committing CPU time. If intermediate quantiles leave the declared central range +or numerical error is comparable to statistical error, return that limitation +rather than selecting different favorable points. Store the joint result and +label every covariance reference nominal. No new Monte Carlo is necessary. + +One resolved failure rules out a single common symmetrizing coordinate for +THESE effective finite-size laws on the tested domain. It does not identify a +CFT field, rule out asymptotic symmetry with finite corrections, or establish an +exponent. Zero/unresolved gives no positive identification. This distinction is +more informative than allowing higher polynomial degree after each failed fit. diff --git a/notes/issue-622-quantile-shape-lineage-20260912.md b/notes/issue-622-quantile-shape-lineage-20260912.md index 7ae2b2b1..e885e9ba 100644 --- a/notes/issue-622-quantile-shape-lineage-20260912.md +++ b/notes/issue-622-quantile-shape-lineage-20260912.md @@ -1,110 +1,99 @@ -# #622 after #702: reflection residual and finite-size shape motion - -Date: 2026-09-12. Base: `main` at `6edf775e` (includes #702–#704). -Machine: XPk2PZ (16 vCPU ARM, no GPU), job under `/workspace/mo-622/`. -Artifacts: `results/probe-invariant-shape/quantile-shape-lineage-622.json`, -`scripts/probe_invariant_shape/quantile_shape_lineage_622.py`, -`tests/test_quantile_shape_lineage_622.py`, `results/probe-invariant-shape/run-622.log`. - -C2 reanalysis of already-committed blocks. No Monte Carlo, no GPU, no exponent -fit, no `docs/STATUS.md`, no issue closed. - -## Object and order of operations - -For each size the two orientations are inverted **separately** and only then -combined, `Q_spin0 = w_1 Q_1 + w_2 Q_2` with `w_1+w_2=1` and -`sum w_i cos4theta_i = 0` (checked to `6e-17`); CDFs are never mixed before -inversion. Then, on the nine frozen deciles with anchors `a=0.2`, `b=0.8`, - - W_N = Q_N(0.8) - Q_N(0.2) > 0 - Z_N(u) = [Q_N(u) - Q_N(0.2)] / W_N - A_N(u) = Z_N(u) + Z_N(1-u) - 1 - -with `A` the corrected normalized-shape reflection residual (not -`M_N(p)+M_N(1-p)`). Every delete-one batch repeats the whole map; the reported -covariances are of one random object across the grid. Independent coordinates -`u = 0.1,0.3,0.4,0.5` are used because `A(0.2)=A(0.8)=0` and `A(1-u)=A(u)` -exactly; `Z(0.2)=0`, `Z(0.8)=1` are likewise fixed. Angles/covariance use the -`cos 4theta` convention of `scripts/threshold_quantile_lineage.py` -(blob `3b328f29`, the #655 lineage); the equal weighting is a sensitivity on the -same block, not a second experiment. - -## Lineage, geometry, weights - -Same channel (`rank-2 cross wrapping`) and same observable (`K_plus`, `K_minus`) -at all three sizes; the exact tiny site/bond labs are a different observable and -are not mixed in. - -| N | reps (first, second) | shortest period `sqrt(N)` | seed | spin-0 weights | -|--:|:--|--:|--:|:--| -| 145 | (12,1), (9,8) | 12.0416 | 2026105003 | (0.50711806, 0.49288194) | -| 290 | (13,11), (17,1) | 17.0294 | 2026105004 | (0.50711806, 0.49288194) | -| 725 | (26,7), (23,14) | 26.9258 | 2026105011 | (0.53827771, 0.46172229) | - -`site_count = |a+bi|^2`, so the shortest lifted period holds `sqrt(N)` sites. -All three spin-0 combinations are interpolations; distinct seeds mean the -cross-size covariance term is taken as zero on random-stream provenance. - -## Reflection residual `A = 0` (spin0 primary) - -| N | W (SE) | A(0.1) | A(0.3) | A(0.4) | A(0.5) | `\|A\|` (SE) | nominal chi2, 4 dof | -|--:|:--|--:|--:|--:|--:|:--|:--| -| 145 | 0.11921330 (3.7e-8) | -0.0204652 | 0.0093537 | 0.0138721 | 0.0152436 | 0.0305142 (2.6e-5) | 2.27e6 | -| 290 | 0.09220375 (2.8e-8) | -0.0159133 | 0.0072317 | 0.0107147 | 0.0117706 | 0.0236407 (2.9e-5) | 1.00e6 | -| 725 | 0.06553076 (2.4e-8) | -0.0113451 | 0.0051435 | 0.0076198 | 0.0083705 | 0.0168313 (3.5e-5) | 3.56e5 | - -`p` is below double reference at every size. The tests are nominal Gaussian -references with estimated delete-one covariance. The 4x4 `A` covariance is -near-collinear (correlations up to 0.9999; condition number 2.4e8 / 6.3e7 / -1.7e7), so the full-inverse chi-square is quoted next to the correlation-free -diagonal chi-square; the full value is **smaller** than the diagonal value at -every size and every displacement test, so the rejection is carried by the -per-coordinate residuals (max `|t|` = 1354, 913, 525), not by inverting a -near-null direction. No pseudoinverse is used anywhere. - -## Adjacent-size motion (pooled, spin0) - -| pair | `\|dZ\|` (SE) | `\|dA\|` (SE) | chi2_Z, 7 dof | chi2_A, 4 dof | -|:--|:--|:--|:--|:--| -| 145→290 | 0.00537503 (2.1e-5) | 0.00687410 (3.9e-5) | 1.37e5 | 4.51e4 | -| 290→725 | 0.00499749 (2.7e-5) | 0.00680943 (4.5e-5) | 6.42e4 | 3.27e4 | - -Both displacements are resolved from zero; `Cov(dZ)=Cov(Z_from)+Cov(Z_to)`. -The declared norm is the Euclidean `L2` on the independent coordinates. - -Interval-to-interval change: `|dZ|` falls by `3.78e-4 +/- 3.45e-5` (10.9σ, -resolved); `|dA|` changes by `-6.47e-5 +/- 5.95e-5` (1.1σ, **not** resolved). - -## Equal-weighting sensitivity - -Equal weighting retains a spin-4 residue (`-1.37e-2`, `+1.37e-2`, `-4.11e-2`). -The difference from spin0 is at most `1.6e-5` in `A` and `8.7e-6` in `Z`. The -qualitative reading is unchanged; it is one analysis, not two. - -## Measured profile - -Load of the three blocks 1.0 s; N=725 pooled pass 1.05 s; one N=725 delete-one -batch 1.02 s. Full delivery (3 sizes × 2 weightings, 100 batches each, -single-threaded) 5 min 23 s wall, about 0.09 CPU-hours — the 4 CPU-hour cap is -not binding, so the complete delete-one path was delivered rather than a -substituted estimator. N=725 pooled `Q` reproduces the #655 decile values to -`4.1e-9` (that reference is published to 8 decimals). - -## Outcome - -* **Reflection residual: resolved.** `A != 0` at all three sizes at hundreds to - >1000σ per coordinate; the normalized shape is not reflection-symmetric. -* **Size trend on this finite lineage: decreasing.** `|A| = 0.03051 -> 0.02364 - -> 0.01683`, each step resolved (178σ, 150σ). Three sizes cannot establish - convergence or a limit; this is observed finite movement, and no exponent is - fitted. -* **Adjacent-size shape change: resolved.** Non-affine displacement remains - between adjacent sizes (`|dZ|`, `|dA|` both nonzero). Between the two - available intervals `|dZ|` decreases slightly (10.9σ) while `|dA|` is - consistent with constant (1.1σ). -* Weighting does not change the qualitative reading; no covariance-aware test - is decided by a near-null direction. - -No conclusion here identifies an exponent, a field, or a threshold; a larger-N -purchase would need a separate decision naming which surviving alternative it -separates, and none is authorized here. #622 stays open. +# #622 reviewed: finite shape movement and its dominant smooth-coordinate component + +2026-09-12. The original #706 source analysis is retained in Git history and +`results/probe-invariant-shape/quantile-shape-lineage-622.json` (v1). Its pooled +Q/Z/A and per-size covariance remain inputs. Its W standard errors and the +independent-error comparison of two adjacent interval norms are superseded. +Do not run the historical `quantile_shape_lineage_622.py` and interpret those +v1 fields as the current verdict. Current analysis entry points are +`scripts/shape_lineage_review.py` and `scripts/shape_lineage_nonlinear_jackknife.py`. + +## Executed validation + +Run 34684353419, job 103528608026, head eff8c5e158fb9be93ffde27ba80bc958eff34573, +merge checkout 51f9817c59fcf757858c0338ec724aa4992e0d94. Seven new mathematical +checks passed. The first command read existing Q/covariance; the second actually +reconstructed pooled and all 100 delete-one Q vectors from each of the three +committed histogram sets. It took 94.70 s; all three pooled Q vectors reproduced +EXACTLY in the executed float path. No simulation or new independent evidence. + +Summary: `results/research-control-20260912/shape-lineage-reviewed-summary.json`. +The scripts produce full covariance/diagnostics; summary fields were extracted +from the successful job stdout, not invented or inferred from CI colour. +This bounded job is not a claim that the complete repository suite passed. + +## Corrected original conclusion + +A=Z(u)+Z(1-u)-1 is resolved nonzero and decreases in norm across N145/290/725. +This finite-lineage result survives. Individual adjacent Delta Z/Delta A also +remain nonzero. The width SEs must be multiplied by 99: the original script +mistook delete-one estimates for independent observations. The corrected +primary widths and SEs are + +| N | W | corrected jackknife SE | +|---|---:|---:| +|145|0.1192132991|3.673003868e-6| +|290|0.0922037501|2.737674335e-6| +|725|0.0655307632|2.322561571e-6| + +Delta1 and Delta2 share N290, so their cross-covariance is -S290 even though +size blocks have independent random streams. Correctly propagating it gives +|Delta Z_2|-|Delta Z_1|=-0.0003775392 with SE 0.00004177061 (about 9.04 nominal +sigma, not 10.9). The analogous Delta A norm change has SE 0.00007209953 and +is only 0.897 nominal sigma from zero. Full nonlinear deletion independently +reproduces these corrected uncertainties. No convergence or exponent follows. + +## New finding: most asymmetry is consistent in magnitude with a smooth chart + +The ratios ||A||/W are 0.2559635, 0.2563966, 0.2568465. The median coefficient +K_mid=-4*A(.5)/W is approximately -0.511 at all three sizes. This motivates +an analytic-coordinate control, not another freely fitted exponent. + +The conditional normal-form lemma in `notes/shape-lineage-review-20260912.md` +states: if Q=h(t+s z) with a common increasing C4 h and reflected z, then +A/W=K*(X^2-1/4)+O(W^2), K=h''/h'^2 and X=(Z-Z_reflected)/2. +It is a lemma about coordinate transformations, not a percolation theorem. + +One exact quadratic chart was fixed from the N145 MEDIAN ONLY: + + phi(p)=p+beta*(p-.5)^2, + beta=0.2684067158 +/- 0.0002742089 (nonlinear jackknife). + +It is increasing throughout [0,1]. Applied unchanged to N290 and N725, it +reduces the independent-coordinate asymmetry norms to respectively 0.267081% +and 0.068014% of their original values. This is norm reduction, NOT explained +variance or proof that the physical scaling field is quadratic. + +The attractive scalar reading is not the full-vector verdict. Including the +shared source-beta uncertainty, the two target residual vectors have +D=105.9080 on 8 nominal degrees of freedom (log10 p=-18.5793). The source's +other three coordinates already fail exact quadratic symmetry. Likewise, +exact equality of the entire A/W vector across sizes fails (D=309.74895/8). +Thus neither exact scalar collapse nor a universally exact quadratic chart +is established. Do not raise the polynomial degree until something passes. + +The full nonlinear jackknife confirms the target covariance against the +linearized calculation in ALL stochastic directions: generalized eigenvalues +lie between 0.999998211 and 1.000002384. This matters because the target +covariance condition number is about 1.3e8; agreement of diagonal errors alone +would not have sufficed. It checks propagation, not exact tail coverage for +an estimated covariance. All references remain nominal/asymptotic. + +Equal weighting has the same qualitative reading but is a sensitivity of the +SAME blocks. Its quadratic residual ratios are 0.323681% and 0.052247%; its +full-vector null also fails. No second evidence vote is counted. + +## Decision + +The raw A signal should not be named a new irrelevant field merely because it +shrinks. Separate the dominant smooth-coordinate-like contribution from the +much smaller resolved residual. Rejecting one exact quadratic chart does not +reject every smooth chart, while arbitrary higher-degree fitting is not an +identifying experiment. + +`notes/common-chart-commutator-20260912.md` gives the next parameter-free +necessary condition: three reflection involutions from the effective quantile +laws must have commuting pair compositions if one common symmetrizing chart +exists. Its real-data evaluation is not done in this delivery. It can use the +same histograms; no larger-N or GPU purchase is licensed. #275's original-U +candidate-map question remains separate. diff --git a/results/research-control-20260912/shape-lineage-reviewed-summary.json b/results/research-control-20260912/shape-lineage-reviewed-summary.json new file mode 100644 index 00000000..0690d39a --- /dev/null +++ b/results/research-control-20260912/shape-lineage-reviewed-summary.json @@ -0,0 +1,79 @@ +{ + "schema": "matching-one.shape-lineage-reviewed-summary.v1", + "provenance": { + "source_pr": 706, + "original_head": "b52e3a35d2c88dfc1bf0c17508d3dc4ce5d570f1", + "analysis_head": "eff8c5e158fb9be93ffde27ba80bc958eff34573", + "tested_checkout": "51f9817c59fcf757858c0338ec724aa4992e0d94", + "run_id": 34684353419, + "job_id": 103528608026, + "extraction": "Selected fields from successful workflow stdout; no local raw-histogram execution claimed.", + "commands": ["python scripts/shape_lineage_review.py --compact", "python scripts/shape_lineage_nonlinear_jackknife.py"], + "python": "3.11.16", "numpy": "2.4.6", "mpmath": "1.4.1", + "nonlinear_jackknife_seconds": 94.701292925, + "sizes": [145,290,725], "batches_each": 100, + "pooled_Q_reproduction_max_error_each": [0.0,0.0,0.0], + "new_mathematical_tests_in_job": 7 + }, + "standing": "Same-block retrospective C2. No new Monte Carlo. Primary means remain pooled. Separate-size nonlinear jackknife preserves shared source-parameter uncertainty.", + "spin0": { + "W": [0.1192132990525685,0.09220375008670778,0.0655307631613844], + "W_se_corrected_nonlinear_jackknife": [3.673003868245788e-6,2.7376743352140806e-6,2.3225615714368353e-6], + "original_W_se_underestimate_factor": 99, + "A_norm_over_W": [0.25596347088939625,0.2563966099148876,0.25684652426999793], + "median_K": [-0.5114744326734895,-0.5106359059300316,-0.5109381126012549], + "median_K_se_delta_method": [0.000497740271566851,0.000716199904923753,0.0012305448618028223], + "interval_norm_difference": { + "order": ["Z", "A"], + "values": [-0.0003775391993112113,-0.00006467749063354157], + "se_nonlinear_jackknife": [0.000041770605874472596,0.00007209952865886088], + "z_absolute_delta_method": [9.038398095446796,0.8970578664077554], + "covariance_nonlinear_jackknife": [[1.7447835151205247e-9,2.8745450229616183e-9],[2.8745450229616183e-9,5.198342032829903e-9]] + }, + "constant_A_over_W": { + "statistic_nonlinear_jackknife": 309.74894908592194, "df": 8, + "log10_p_nominal": -61.46090207508884, + "covariance_condition": 250347341.41731784, + "jk_vs_delta_generalized_eigenvalue_range": [0.999996433054753,1.0000050927779291] + }, + "source_fixed_quadratic_chart": { + "formula": "phi(p)=p+beta*(p-.5)^2; beta from N145 median only, unchanged on N290/N725", + "beta": 0.2684067158014451, + "beta_se_nonlinear_jackknife": 0.0002742088523676437, + "minimum_derivative_on_unit_interval": 0.7315932841985548, + "target_sizes": [290,725], + "target_residual_norm_divided_by_raw_A_norm": [0.002670812060269795,0.0006801362114115651], + "target_residual_vector": [-0.00005862603142836598,-0.000004362474088637214,-0.000014161819340108295,-0.000018167351405695698,-0.00000287057258496759,-0.0000045768900747145125,-0.000006855162828056649,-0.000007407185860897059], + "target_joint_statistic_nonlinear_jackknife": 105.90800198575138, + "target_df": 8, "target_log10_p_nominal": -18.579257848266177, + "target_covariance_condition": 130773158.93150532, + "target_jk_vs_delta_generalized_eigenvalue_range": [0.9999982110684118,1.0000023844390982], + "source_other_three_coordinates_statistic": 797.3429633626016, + "source_df": 3, "source_log10_p_nominal": -171.7875182857999 + }, + "leading_smooth_chart_normal_form": { + "formula": "A/W = K*(X^2-1/4) + O(W^2), X=(Z-Z_reflected)/2, K_mid=-4*A(.5)/W", + "exact_zero_statistics_nonlinear_jackknife": [916.9528728644561,86.07696959293801,7.307863800794209], + "df_each": 3, + "log10_p_nominal_each": [-197.73020000037718,-17.817032607924222,-1.202688807407164], + "interpretation": "The asymptotic lemma permits O(W^2) residuals. Finite exact-zero rejection is NOT rejection of all smooth coordinates; N725 compatibility is NOT proof of one." + } + }, + "equal_weighting_sensitivity_delta_method": { + "A_norm_over_W": [0.25577603926914116,0.2564966342055952,0.25674110309636516], + "beta": 0.2682159071760094, "beta_se": 0.00027394126616631315, + "target_residual_norm_divided_by_raw_A_norm": [0.0032368146837867453,0.0005224651743859779], + "target_quadratic_joint_statistic": 117.19095228683081, "df": 8, + "target_log10_p_nominal": -20.8998325347859, + "constant_A_over_W_statistic": 333.06329208857824, + "interval_change_absolute_z": [8.386138607596148,0.2331320501361479], + "standing": "Same random blocks; not an independent vote. Full nonlinear second pass was primary spin0 only." + }, + "limits": [ + "Norm reduction is not explained variance, a causal attribution, or operator identification.", + "A common quadratic chart removes most raw asymmetry but is not an exact full-vector law.", + "The high-condition covariance diagnostics are nominal Gaussian-reference values; nonlinear-jackknife agreement checks propagation, not exact finite-sample tail calibration.", + "Do not fit successive higher-degree polynomials to rescue the null.", + "Original v1 source artifact is preserved; its W_se and interval-to-interval independent-error fields are superseded." + ] +} diff --git a/scripts/shape_common_chart.py b/scripts/shape_common_chart.py new file mode 100644 index 00000000..2538fe68 --- /dev/null +++ b/scripts/shape_common_chart.py @@ -0,0 +1,15 @@ +"""A necessary, coordinate-covariant test of one common symmetrizing chart. + +R_i are decreasing involutions of the same interval. Their composition test +requires no fitted polynomial. Zero is necessary, not sufficient. +""" +from typing import Callable, TypeVar +T=TypeVar('T') + + +def reflection_commutator(r1: Callable[[T], T], r2: Callable[[T], T], + r3: Callable[[T], T], p: T): + # (R1 R2)(R2 R3) = R1 R3 exactly; opposite order has four factors. + left=r1(r3(p)) + right=r2(r3(r1(r2(p)))) + return {'left':left,'right':right,'difference':left-right} diff --git a/scripts/shape_reflection_commutator.py b/scripts/shape_reflection_commutator.py new file mode 100644 index 00000000..2dd95a88 --- /dev/null +++ b/scripts/shape_reflection_commutator.py @@ -0,0 +1,169 @@ +#!/usr/bin/env python3 +"""Common-chart commutator of the three EXISTING effective quantile laws. + +Positive quantile weights admit one-level CDF inversion: if p=w1*x+w2*y, +solve F1(x)=F2(y), rather than nesting inverse CDFs. Beta mixtures provide +fast CDFs; a separate high-precision Bernstein path checks cancellation. +""" +from __future__ import annotations +import json +from fractions import Fraction +from pathlib import Path +import time +import numpy as np +from scipy.special import betainc +from scipy.optimize import brentq +from mpmath import mp +import threshold_quantile_lineage as L +import shape_lineage_review as R +from shape_common_chart import reflection_commutator +from shape_lineage_nonlinear_jackknife import SPECS,jack_covariance + +LEVELS=(.3,.5,.7) + + +def bracket_root(f,lo,hi): + for _ in range(85): + mid=(lo+hi)/2 + if f(mid)<0:lo=mid + else:hi=mid + return (lo+hi)/2 + + +class Component: + def __init__(self,minus,plus,n): + self.n=n + tm,tp=sum(minus.values()),sum(plus.values()) + increments=[Fraction(minus.get(k,0),2*tm)+Fraction(plus.get(k,0),2*tp) for k in range(n+1)] + if sum(increments)!=1:raise ValueError('threshold mixture is not normalized') + self.ks=np.array([k for k in range(1,n+1) if increments[k]]) + self.weights=np.array([float(increments[k]) for k in self.ks]) + self.zero=float(increments[0]);self.cumulative=[];s=Fraction(0) + for v in increments:s+=v;self.cumulative.append(s) + self.mp_coeff=None + def cdf(self,p): + if p<=0:return self.zero + if p>=1:return 1. + return float(self.zero+self.weights@betainc(self.ks,self.n-self.ks+1,p)) + def quantile(self,u): + if not 0=1:return mp.mpf(1) + if self.mp_coeff is None: + self.mp_coeff=[mp.mpf(x.numerator)/x.denominator for x in self.cumulative] + n=self.n;k=int(mp.floor(n*p)) + mass=mp.binomial(n,k)*p**k*(1-p)**(n-k) + total=mass*self.mp_coeff[k];cur=mass + for j in range(k,0,-1): + cur*=mp.mpf(j)/(n-j+1)*(1-p)/p;total+=cur*self.mp_coeff[j-1] + cur=mass + for j in range(k,n): + cur*=mp.mpf(n-j)/(j+1)*p/(1-p);total+=cur*self.mp_coeff[j+1] + return total + def mp_quantile(self,u): + return bracket_root(lambda p:self.mp_cdf(p)-u,mp.mpf(0),mp.mpf(1)) + + +class Law: + def __init__(self,pool,n,weights): + self.components=[Component(pool[name]['minus'],pool[name]['plus'],n) for name in L.ORIENTATIONS] + raw=[weights[name] if isinstance(weights[name],Fraction) else Fraction(str(weights[name])) for name in L.ORIENTATIONS] + total=sum(raw);self.exact_weights=[v/total for v in raw] + self.weights=[float(v) for v in self.exact_weights] + if min(self.weights)<=0 or abs(sum(self.weights)-1)>1e-12: + raise ValueError('one-level inversion requires positive normalized weights') + self.visited=[] + def quantile(self,u): + return sum(w*c.quantile(u) for w,c in zip(self.weights,self.components)) + def cdf(self,p): + a,b=self.weights;f,g=self.components + lo=max(0.,(p-b)/a);hi=min(1.,p/a) + x=brentq(lambda x:f.cdf(x)-g.cdf((p-a*x)/b),lo,hi,xtol=5e-15,rtol=1e-15) + return f.cdf(x) + def reflect(self,p): + u=self.cdf(p);self.visited.append(u) + return self.quantile(1-u) + def mp_quantile(self,u): + return sum((mp.mpf(w.numerator)/w.denominator)*c.mp_quantile(u) for w,c in zip(self.exact_weights,self.components)) + def mp_cdf(self,p): + a,b=[mp.mpf(w.numerator)/w.denominator for w in self.exact_weights];f,g=self.components + lo=max(mp.mpf(0),(p-b)/a);hi=min(mp.mpf(1),p/a) + x=bracket_root(lambda x:f.mp_cdf(x)-g.mp_cdf((p-a*x)/b),lo,hi) + return f.mp_cdf(x) + def mp_reflect(self,p): + return self.mp_quantile(1-self.mp_cdf(p)) + + +def statistic(laws,high=False,levels=LEVELS): + if not high: + for law in laws:law.visited=[] + q=laws[1].mp_quantile if high else laws[1].quantile + maps=[v.mp_reflect if high else v.reflect for v in laws] + points=[q(mp.mpf(str(u)) if high else u) for u in levels] + values=[reflection_commutator(*maps,p)['difference'] for p in points] + return points,values + + +def main(): + start=time.perf_counter();inputs=[];laws=[];pools=[];weights=[] + old=json.loads(R.INPUT.read_text()) + for n in R.SIZES: + path=R.ROOT/(SPECS[n]+'.hist.csv');loaded=L.load_batch_histograms(path) + pool=L.pooled_histograms(loaded['batches']) + cos={} + for name in L.ORIENTATIONS: + a,b=loaded['orientation_representative'][name] + cos[name]=Fraction(a**4-6*a*a*b*b+b**4,(a*a+b*b)**2) + gap=cos['first']-cos['second'] + w={'first':-cos['second']/gap,'second':cos['first']/gap};law=Law(pool,n,w) + qs=[law.quantile(u) for u in L.FROZEN_LEVELS] + err=max(abs(np.array(qs)-old['sizes'][str(n)]['analysis']['spin0']['Q_pooled'])) + if err>2e-12:raise ValueError('beta path changes pooled Q') + inputs.append(loaded);pools.append(pool);weights.append(w);laws.append(law) + print(f'N={n} pooled Q control max={err:.3g}',flush=True) + points,pooled=statistic(laws) + involution=max(abs(law.reflect(law.reflect(p))-p) for law in laws for p in points) + visited=[u for law in laws for u in law.visited] + if min(visited)<.05 or max(visited)>.95:raise ValueError('composition left the declared central domain') + with mp.workdps(55): + _,mp_values=statistic(laws,True) + mp_error=max(abs(float(v)-f) for v,f in zip(mp_values,pooled)) + high_primary=[float(v) for v in mp_values] + covariance=np.zeros((3,3));checks=[] + for index,n in enumerate(R.SIZES): + outputs=[] + for number,batch in enumerate(inputs[index]['batches'].values()): + pool={name:{kind:L._subtract(pools[index][name][kind],batch[name][kind]) + for kind in ('minus','plus')} for name in L.ORIENTATIONS} + changed=laws.copy();changed[index]=Law(pool,n,weights[index]) + _,vals=statistic(changed);outputs.append(vals) + interior=[u for law in changed for u in law.visited] + if min(interior)<.05 or max(interior)>.95:raise ValueError('deleted composition left central domain') + if number==0: + with mp.workdps(55): + _,hv=statistic(changed,True,levels=(.5,)) + checks.append(abs(float(hv[0])-vals[1])) + covariance+=jack_covariance(outputs) + print(f'N={n} separate-size nonlinear deletion complete',flush=True) + se=np.sqrt(np.diag(covariance));numerical=max([mp_error,involution]+checks) + adequate=bool(numerical<.01*min(se)) + out={'schema':'matching-one.shape-reflection-commutator.v1', + 'standing':'C2, existing effective spin0 quantile laws; separate-size deletion; no fitted chart or new samples', + 'sizes':list(R.SIZES),'reference_levels':list(LEVELS),'reference_p_values':points, + 'commutator_high_precision_pooled':high_primary,'standard_errors':se.tolist(), + 'covariance':covariance.tolist(),'composition_quantiles_range':[min(visited),max(visited)], + 'precision_controls':{'dps':55,'pooled_beta_vs_bernstein_max':mp_error, + 'selected_deleted_beta_vs_bernstein':checks, + 'float_involution_max':involution, + 'max_control_error_over_min_se':float(numerical/min(se)), + 'adequate_at_one_percent_se':adequate}, + 'nominal_zero_test':R.zero_test(high_primary,covariance) if adequate else None, + 'elapsed_seconds':time.perf_counter()-start, + 'limits':['Nonzero rules out exact common symmetrization of these effective finite laws, not asymptotic symmetry or all underlying orientation-wise scaling fields.', + 'Zero or unresolved does not prove a common chart; this is only a necessary condition.', + 'High-precision spot checks are numerical controls, not interval certificates or exact finite-sample Gaussian coverage.']} + print(json.dumps(out,indent=2,allow_nan=False)) + +if __name__=='__main__':main() diff --git a/tests/test_shape_common_chart.py b/tests/test_shape_common_chart.py new file mode 100644 index 00000000..8c9746d2 --- /dev/null +++ b/tests/test_shape_common_chart.py @@ -0,0 +1,29 @@ +from fractions import Fraction as F +from pathlib import Path +import sys +import unittest +from mpmath import mp +sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts')) +from shape_common_chart import reflection_commutator + +class CommonChart(unittest.TestCase): + def test_shared_logit_chart_exactly_commutes(self): + maps=[lambda p,k=k:k*(1-p)/(p+k*(1-p)) for k in (F(1),F(2),F(3))] + for p in (F(3,10),F(1,2),F(7,10)): + self.assertEqual(reflection_commutator(*maps,p)['difference'],0) + def test_individually_valid_reflections_need_not_share_chart(self): + with mp.workdps(40): + p=mp.mpf('.5') + r1=lambda x:1-x + r2=lambda x:2*(1-x)/(x+2*(1-x)) + r3=lambda x:mp.root(1-x**3,3) + self.assertLess(abs(r3(r3(p))-p),mp.mpf('1e-35')) + self.assertGreater(reflection_commutator(r1,r2,r3,p)['difference'],mp.mpf('.018')) + def test_degenerate_zero_does_not_identify_a_chart(self): + # R1=R2 makes the test zero, regardless of R3: power may be absent. + with mp.workdps(40): + r=lambda x:1-x + r3=lambda x:mp.root(1-x**3,3) + self.assertLess(abs(reflection_commutator(r,r,r3,mp.mpf('.5'))['difference']),mp.mpf('1e-35')) + +if __name__=='__main__':unittest.main() diff --git a/tests/test_shape_reflection_commutator.py b/tests/test_shape_reflection_commutator.py new file mode 100644 index 00000000..b07d0a6b --- /dev/null +++ b/tests/test_shape_reflection_commutator.py @@ -0,0 +1,29 @@ +from pathlib import Path +import sys +import unittest +from fractions import Fraction +from mpmath import mp +sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts')) +from shape_reflection_commutator import Law,Component + +class InverseMixture(unittest.TestCase): + def law(self): + pool={'first':{'minus':{2:1},'plus':{2:1}},'second':{'minus':{4:1},'plus':{4:1}}} + return Law(pool,5,{'first':Fraction(2,5),'second':Fraction(3,5)}) + def test_one_level_cdf_inverts_quantile_mixture(self): + law=self.law() + for u in (.1,.3,.5,.8,.9): + p=law.quantile(u) + self.assertAlmostEqual(law.cdf(p),u,places=12) + self.assertAlmostEqual(law.reflect(law.reflect(p)),p,places=12) + def test_bernstein_cdf_matches_beta_exact_formula(self): + with mp.workdps(55): + c=Component({2:1},{2:1},5);p=mp.mpf('.3') + expected=mp.betainc(2,4,0,p,regularized=True) + self.assertLess(abs(c.mp_cdf(p)-expected),mp.mpf('1e-50')) + def test_high_precision_mixture_inverse(self): + with mp.workdps(55): + law=self.law();u=mp.mpf('.3');p=law.mp_quantile(u) + self.assertLess(abs(law.mp_cdf(p)-u),mp.mpf('1e-23')) + +if __name__=='__main__':unittest.main() From 8df13d10c7e53c86147c7cff9406a926484035e7 Mon Sep 17 00:00:00 2001 From: LightChainr Date: Sat, 12 Sep 2026 17:17:47 +0800 Subject: [PATCH 5/6] Record unresolved common-chart commutator and test first-order reflection ordering without curve fitting --- .github/workflows/shape-lineage-review.yml | 12 +- notes/common-chart-commutator-20260912.md | 203 +++++++++++------- .../shape-reflection-commutator.json | 55 +++++ scripts/shape_reflection_order.py | 90 ++++++++ tests/test_shape_reflection_order.py | 24 +++ 5 files changed, 297 insertions(+), 87 deletions(-) create mode 100644 results/research-control-20260912/shape-reflection-commutator.json create mode 100644 scripts/shape_reflection_order.py create mode 100644 tests/test_shape_reflection_order.py diff --git a/.github/workflows/shape-lineage-review.yml b/.github/workflows/shape-lineage-review.yml index 7bafda85..d351dc88 100644 --- a/.github/workflows/shape-lineage-review.yml +++ b/.github/workflows/shape-lineage-review.yml @@ -7,6 +7,7 @@ on: - 'scripts/shape_lineage_nonlinear_jackknife.py' - 'scripts/shape_common_chart.py' - 'scripts/shape_reflection_commutator.py' + - 'scripts/shape_reflection_order.py' - 'tests/test_shape*.py' - '.github/workflows/shape-lineage-review.yml' permissions: @@ -14,7 +15,7 @@ permissions: jobs: review: runs-on: ubuntu-latest - timeout-minutes: 8 + timeout-minutes: 5 steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 @@ -25,9 +26,6 @@ jobs: python -m unittest discover -s tests -p 'test_shape_lineage_review.py' python -m unittest discover -s tests -p 'test_shape_common_chart.py' python -m unittest discover -s tests -p 'test_shape_reflection_commutator.py' - - name: Read existing quantiles and covariance only - run: python scripts/shape_lineage_review.py --compact - - name: Check full nonlinear uncertainty on existing histograms - run: python scripts/shape_lineage_nonlinear_jackknife.py - - name: Test common-chart commutation without a polynomial fit - run: python scripts/shape_reflection_commutator.py + python -m unittest discover -s tests -p 'test_shape_reflection_order.py' + - name: New sign-order test only; prior executed covariance/commutator results retained + run: python scripts/shape_reflection_order.py diff --git a/notes/common-chart-commutator-20260912.md b/notes/common-chart-commutator-20260912.md index 9f9c510e..20524816 100644 --- a/notes/common-chart-commutator-20260912.md +++ b/notes/common-chart-commutator-20260912.md @@ -1,80 +1,123 @@ -# A parameter-free necessary condition for one common symmetrizing coordinate - -2026-09-12. Mathematical follow-up to the completed #706 quadratic-chart -control. No real-data commutator has been computed here. This supplies a -specific falsifier rather than another fitted polynomial family. No novelty -claim is made. - -## Object and lemma - -Let Q_i be strictly increasing quantile functions with inverse F_i, all on the -same probability interval. Define their decreasing reflection involutions - - R_i(p)=Q_i(1-F_i(p)), R_i o R_i = id. - -For the current spin0 object, Q_i means the ALREADY COMBINED quantile function. -F_i is its inverse, not the orientation-weighted mixture of physical CDFs. -The test is therefore about the declared effective quantile laws. Nonlinear -coordinate changes need not commute with orientation weighting, so failure -cannot be silently transported to a different uncombined physical observable. - -Suppose one increasing coordinate psi simultaneously symmetrizes all three -laws, possibly about different centers c_i. Precisely, on the common domain, - - psi(R_i(p)) = 2*c_i - psi(p). - -Then T_ij=R_i o R_j is conjugate under psi to translation by 2(c_i-c_j). -Translations commute, hence the following NECESSARY identity: - - (R1 R2)(R2 R3) = (R2 R3)(R1 R2), - R1 R3 = R2 R3 R1 R2. (1) - -Products denote composition, rightmost first. This is the proof; neither a -polynomial truncation nor a fitted scaling exponent is involved. The residual - - C(p)=R1(R3(p))-R2(R3(R1(R2(p)))) (2) - -must vanish wherever both compositions are defined. Under a common increasing -coordinate change all maps are conjugated, so equality (1), or its failure, -is coordinate-independent. The NUMERICAL MAGNITUDE of (2) is not invariant; -keep it on the declared raw p axis and propagate its uncertainty there. - -This is necessary, not sufficient. A zero at three points does not prove a -functional identity. Even identity can be non-identifying in degenerate cases: -R1=R2 makes (1) true for ANY R3. Nearly coinciding maps/centers can make the -commutator too small to measure. An unresolved commutator is not evidence for -one universal chart. - -## Exact control and a genuine counterexample - -With the shared logit coordinate, R_k(p)=k(1-p)/(p+k(1-p)), k>0. Using k=1,2,3, -(1) holds exactly at rational p=.3,.5,.7; tested with Fraction arithmetic. -Replace the third map by (1-p^3)^(1/3). It is still a decreasing involution, -but C(.5)=0.01884049384875336739614... is nonzero. Thus individual ability to -symmetrize each distribution does NOT imply a common symmetrizing chart. -The comparison kernel and three local tests are in `scripts/shape_common_chart.py` -and `tests/test_shape_common_chart.py`. - -## A bounded real-data test, not yet executed - -Use R1,R2,R3 for the existing N145/290/725 spin0 quantiles. Fix three reference -points p_j=Q290(u_j), u_j=.3,.5,.7. Retain the randomness of these reference -points when deleting the N290 block. Evaluate both sides of (1), each R_i's -involution control, the transformed intermediate arguments and the full joint -covariance under separate deletion of each independent size. Never pair batch -labels across different seeds. The existing source seeds/observable contract -remain unchanged. - -A nested inversion is allowed; an uncontrolled interpolation is not. Compare -the existing float path with higher-precision/bracketed inversion on the pooled -points first and bound the composed numerical error. Profile one deletion before -committing CPU time. If intermediate quantiles leave the declared central range -or numerical error is comparable to statistical error, return that limitation -rather than selecting different favorable points. Store the joint result and -label every covariance reference nominal. No new Monte Carlo is necessary. - -One resolved failure rules out a single common symmetrizing coordinate for -THESE effective finite-size laws on the tested domain. It does not identify a -CFT field, rule out asymptotic symmetry with finite corrections, or establish an -exponent. Zero/unresolved gives no positive identification. This distinction is -more informative than allowing higher polynomial degree after each failed fit. +# Common symmetrizing coordinate: an exact necessary condition and an unresolved data test + +2026-09-12. Follow-up to #706. The real-data calculation IS NOW COMPLETED; +it was not delegated as another production task. Its result is negative in +information: the tested commutator is unresolved, not evidence for a chart. +No novelty claim is made for the algebra. + +## 1. Object and conditional lemma + +Let Q_i be increasing quantile functions, F_i their inverses, and + + R_i(p)=Q_i(1-F_i(p)), R_i o R_i=id. + +For this application Q_i is the ALREADY COMBINED spin0 quantile function. +F_i is its inverse, not an orientation-weighted mixture of physical CDFs. +A nonlinear map need not commute with orientation weighting; do not transfer +the outcome to a different observable without a separate map. + +Suppose one increasing coordinate psi symmetrizes all three laws, possibly +about distinct centers c_i: psi(R_i(p))=2*c_i-psi(p). Then R_i R_j is +conjugate to translation by 2(c_i-c_j), and translations commute. Therefore + + (R1 R2)(R2 R3)=(R2 R3)(R1 R2), + R1 R3=R2 R3 R1 R2. (1) + +Composition acts rightmost first. This proves the necessary identity without +fitting a polynomial or exponent. The evaluated residual is + + C(p)=R1(R3(p))-R2(R3(R1(R2(p)))). (2) + +Conjugating all maps preserves equality (1), not the numerical magnitude of +(2). Zero is necessary, NOT sufficient. If R1=R2, (1) holds for ANY R3, so +a null can be structurally uninformative. Three zero evaluations also cannot +prove a functional identity on an interval. + +## 2. Mathematical and numerical controls + +Shared logit coordinates give R_k(p)=k(1-p)/(p+k(1-p)). For k=1,2,3 and rational +p=.3,.5,.7, (1) holds exactly with Fraction arithmetic. Replacing R3 by +(1-p^3)^(1/3) preserves its involution property but gives C(.5)= +0.01884049384875336739614... . Individual symmetrizability is not common +symmetrizability. Three mathematical controls cover these cases. + +The data inverse is cheaper than a nested quantile solver. If +Q(u)=w1*F1^-1(u)+w2*F2^-1(u), with positive weights summing to one, solve + + F1(x)=F2((p-w1*x)/w2), + max(0,(p-w2)/w1) <= x <= min(1,p/w1), + +and set F(p)=F1(x). The objective is increasing. This is exactly the inverse +of the quantile combination; it is NOT the CDF mixture. Positivity is checked. +Component CDFs use the beta-mixture formula of the birth-rank histograms; +an independent 55-dps mode-anchored Bernstein sum with rational histogram +weights checks the pooled compositions and selected deleted compositions. +Three more tests check the inverse and beta/Bernstein identity. + +## 3. Executed existing-data result + +Run 34685079362, job 103530556772, head 2f900dd2066bd38a4d53f02e76ab32cb7b32cedf; +tested merge checkout 55d2b9b5d66918493593f3b20401707ba2bb50a7. The bounded job +passed all 13 new mathematical tests, the earlier nonlinear shape recheck, +and `python scripts/shape_reflection_commutator.py` (78.51 seconds). Raw +histograms were already committed; there was no Monte Carlo or new evidence. + +For N145,N290,N725, use the three reference points p_j=Q290(u_j), u=.3,.5,.7. +When deleting N290, these reference points are recomputed, not held fixed. +Each independent size is deleted separately, with 100 batches; batch numbers +across independent seeds are not artificially paired. Both composed maps are +re-evaluated and their full 3x3 covariance is retained. + +| u | C(p_j), high-precision pooled | nonlinear jackknife SE | +|---|---:|---:| +|.3|-5.642573955e-10|1.493472756e-9| +|.5|-2.733621556e-13|4.855386934e-13| +|.7|+5.482200467e-10|1.450287413e-9| + +All three are below 0.6 marginal standard errors. The descriptive full +Gaussian quadratic form is 0.5746485/3. There is no resolved contradiction +of (1). The result is **UNRESOLVED_COMMON_CHART**, not a positive model choice. +The first and third coordinates are strongly anticorrelated; report the matrix, +not three independent tests. Its condition number is about 4.81e8. + +The beta-path Q values agree with the earlier pooled reconstruction within +2.14e-14. Pooled commutators agree with the 55-dps Bernstein path within +1.20e-15; selected deleted controls within 8.11e-16. The largest involution +control is 1.33e-15, or 0.274% of the smallest MARGINAL standard error. These +are numerical checks, not all-direction error bounds or exact confidence +certificates. Pooled composition levels remain in [.23047,.76946]; all deletion +paths remain inside the checked [.05,.95] range. + +Result with full covariance/provenance: +`results/research-control-20260912/shape-reflection-commutator.json`. + +## 4. Why the null needs particular caution + +Write T12=R1 R2=id+epsilon*u+O(epsilon^2) and +T23=R2 R3=id+epsilon*v+O(epsilon^2), in C2 on the tested interval. Expanding +composition gives + + T12 T23-T23 T12=epsilon^2*(u'*v-v'*u)+O(epsilon^3). + +Near coincident involutions, the first variation vanishes and the commutator +is second-order small. A noisy nonzero derivative estimated away from this +singular null does not by itself justify ordinary Gaussian/chi-square +calibration. The printed reference tail is therefore DESCRIPTIVE, not a +calibrated acceptance or confidence statement. Nonlinear jackknife propagation +and higher precision address different questions and do not cure nonregularity. + +Consequently a null cannot be used to pick a higher-degree chart, price a +sample top-up from a weak point signal, or claim no dynamic finite-size +correction. A common symmetrizing coordinate is also weaker than full location- +scale collapse: it imposes parity but does not pin the symmetric profile. + +## 5. Scientific consequence + +The N145-fixed quadratic chart removes most measured asymmetry in norm but +fails as an exact full-vector law. The present parameter-free necessary +condition does NOT rule out a more general common chart. Both statements can +be true. The right surviving question is a source/geometry-resolved separation +between analytic-coordinate contributions and genuine finite-size shape +corrections, with explicit predictions and an informative statistic. No +successive polynomial-degree search, larger-N purchase, or GPU run follows +from this delivery. #275's candidate-specific original-U map remains distinct. diff --git a/results/research-control-20260912/shape-reflection-commutator.json b/results/research-control-20260912/shape-reflection-commutator.json new file mode 100644 index 00000000..fa3dc1e9 --- /dev/null +++ b/results/research-control-20260912/shape-reflection-commutator.json @@ -0,0 +1,55 @@ +{ + "schema": "matching-one.shape-reflection-commutator-record.v1", + "provenance": { + "analysis_head": "2f900dd2066bd38a4d53f02e76ab32cb7b32cedf", + "tested_checkout": "55d2b9b5d66918493593f3b20401707ba2bb50a7", + "run_id": 34685079362, + "job_id": 103530556772, + "command": "python scripts/shape_reflection_commutator.py", + "extraction": "Numerical fields copied from the completed GitHub Actions stdout; statistical interpretation below is the reviewed reading, not an additional run.", + "python": "3.11.16", "numpy": "2.4.6", "scipy": "1.17.1", "mpmath": "1.4.1", + "elapsed_seconds": 78.51089948600003, + "mathematical_tests_in_job": 13, + "pooled_Q_beta_vs_original_max_each": [2.14e-14,2.08e-14,1.95e-14] + }, + "standing": "C2 existing effective spin0 quantile laws. No fitted chart, new simulation, or independent evidence. One-size-at-a-time nonlinear deletion includes the random N290 reference points.", + "sizes": [145,290,725], + "reference_levels": [0.3,0.5,0.7], + "reference_p_values": [0.5638915164071909,0.5927517136919742,0.6211934034174541], + "definition": "R_i(p)=Q_i(1-F_i(p)), F_i=inverse of combined Q_i; C=R1 R3-R2 R3 R1 R2 evaluated right-to-left", + "commutator_high_precision_pooled": [-5.642573955188146e-10,-2.7336215561412736e-13,5.482200467464304e-10], + "standard_errors_nonlinear_jackknife": [1.4934727558307275e-9,4.855386934130967e-13,1.4502874132698063e-9], + "covariance": [ + [2.230460872408628e-18,5.803964612316742e-22,-2.165964629629277e-18], + [5.803964612316742e-22,2.3574782280129714e-25,-5.63735645904496e-22], + [-2.165964629629277e-18,-5.63735645904496e-22,2.103333581088826e-18] + ], + "composition_quantiles_range_pooled": [0.23047267136948918,0.7694572984763953], + "all_deletions_stayed_in_checked_range": [0.05,0.95], + "precision_controls": { + "dps": 55, + "pooled_beta_vs_bernstein_max": 1.19943071917533e-15, + "selected_deleted_beta_vs_bernstein": [8.100217279442468e-16,4.0058717599497387e-16,6.117757390433664e-16], + "float_involution_max": 1.3322676295501878e-15, + "max_control_error_over_min_marginal_se": 0.002743895898769686, + "adequate_at_one_percent_marginal_se": true, + "scope": "Independent numerical controls, not interval certificates or an all-direction statistical calibration." + }, + "descriptive_gaussian_reference": { + "statistic": 0.5746485169805402, + "dof": 3, + "log10_p": -0.044692032666073, + "max_abs_marginal_z": 0.563007973046446, + "covariance_condition": 481057718.2854624, + "calibrated_test": false, + "warning": "Near-coincident involutions can make the commutator quadratic in estimation errors. Gaussian/chi-square reference is descriptive unless nondegeneracy or suitable null calibration is established." + }, + "verdict": "UNRESOLVED_COMMON_CHART; no measured contradiction, no positive identification", + "limits": [ + "The exact quadratic chart fails, but this necessary test does not exclude every common monotone symmetrizing chart.", + "A zero at three points is not a functional identity; even an exact identity is only necessary.", + "The numerical magnitude is coordinate-dependent; only equality of the composed maps is conjugacy-invariant.", + "This test concerns the combined effective quantile laws, not a silently substituted mixture CDF or an orientation-wise observable.", + "No larger-N or sample top-up is justified from an unresolved central estimate; first establish which alternative the acquisition would distinguish." + ] +} diff --git a/scripts/shape_reflection_order.py b/scripts/shape_reflection_order.py new file mode 100644 index 00000000..7441612e --- /dev/null +++ b/scripts/shape_reflection_order.py @@ -0,0 +1,90 @@ +#!/usr/bin/env python3 +"""First-order necessary common-chart test: the reflection curves cannot cross. + +One simultaneous set of 12 nominal marginal intervals, no inverse covariance. +The third pair is redundant but retained conservatively in the union bound. +""" +from __future__ import annotations +from fractions import Fraction +import json +import time +import numpy as np +from scipy.stats import norm +from mpmath import mp +import threshold_quantile_lineage as L +import shape_lineage_review as R +from shape_lineage_nonlinear_jackknife import SPECS,jack_covariance +from shape_reflection_commutator import Law + +PAIRS=((0,1),(0,2),(1,2));LEVELS=(.3,.5,.7);ALPHA=.0027 + + +def statistic(laws,high=False): + q=[law.mp_quantile if high else law.quantile for law in laws] + reflection=[law.mp_reflect if high else law.reflect for law in laws] + levels=[mp.mpf(str(u)) for u in LEVELS] if high else LEVELS + points=[q[1](u) for u in levels] + medians=[f(mp.mpf('.5') if high else .5) for f in q] + maps=[[f(p) for p in points] for f in reflection] + return [v for i,j in PAIRS for v in [medians[i]-medians[j]]+[maps[i][k]-maps[j][k] for k in range(3)]] + + +def summarize(value,cov): + value=np.asarray(value,float);se=np.sqrt(np.diag(cov)) + if min(se)<=0:raise ValueError('positive marginal errors required') + critical=norm.ppf(1-ALPHA/(2*len(value))) + low,high=value-critical*se,value+critical*se + pairs=[] + for row,(i,j) in enumerate(PAIRS): + s=slice(4*row,4*(row+1)) + positive=np.where(low[s]>0)[0].tolist();negative=np.where(high[s]<0)[0].tolist() + pairs.append({'sizes':[R.SIZES[i],R.SIZES[j]],'values':value[s].tolist(), + 'standard_errors':se[s].tolist(),'low':low[s].tolist(),'high':high[s].tolist(), + 'resolved_positive_coordinates':positive,'resolved_negative_coordinates':negative, + 'incompatible_sign_order':bool(positive and negative)}) + return {'alpha_nominal':ALPHA,'critical_z_bonferroni':float(critical), + 'coordinates_per_pair':['median_difference','R_difference_at_Q290(.3)', + 'R_difference_at_Q290(.5)','R_difference_at_Q290(.7)'], + 'pairs':pairs,'any_resolved_crossing':any(p['incompatible_sign_order'] for p in pairs), + 'max_abs_marginal_z':float(np.max(abs(value)/se))} + + +def main(): + start=time.perf_counter();loaded=[];pools=[];weights=[];laws=[] + for n in R.SIZES: + item=L.load_batch_histograms(R.ROOT/(SPECS[n]+'.hist.csv')) + pool=L.pooled_histograms(item['batches']);cos={} + for name in L.ORIENTATIONS: + a,b=item['orientation_representative'][name] + cos[name]=Fraction(a**4-6*a*a*b*b+b**4,(a*a+b*b)**2) + gap=cos['first']-cos['second'];w={'first':-cos['second']/gap,'second':cos['first']/gap} + loaded.append(item);pools.append(pool);weights.append(w);laws.append(Law(pool,n,w)) + full=statistic(laws) + with mp.workdps(55): + high=np.array([float(x) for x in statistic(laws,True)]) + cov=np.zeros((12,12));bias=np.zeros(12) + for index,n in enumerate(R.SIZES): + outputs=[] + for batch in loaded[index]['batches'].values(): + pool={name:{kind:L._subtract(pools[index][name][kind],batch[name][kind]) + for kind in ('minus','plus')} for name in L.ORIENTATIONS} + changed=laws.copy();changed[index]=Law(pool,n,weights[index]) + for law in changed:law.visited=[] + outputs.append(statistic(changed)) + visited=[u for law in changed for u in law.visited] + if min(visited)<.05 or max(visited)>.95:raise ValueError('central range exceeded') + cov+=jack_covariance(outputs) + bias+=(len(outputs)-1)*(np.mean(outputs,axis=0)-full) + print(f'order test completed existing N={n}',flush=True) + report=summarize(high,cov) + report.update(schema='matching-one.shape-reflection-order.v1', + standing='C2 same effective spin0 laws and existing random blocks; necessary sign-order condition only', + covariance=cov.tolist(),jackknife_bias_estimate=bias.tolist(), + beta_vs_bernstein_max=float(np.max(abs(high-full))), + elapsed_seconds=time.perf_counter()-start, + limits=['Nominal marginal Gaussian intervals with estimated nonlinear-jackknife errors; not exact finite-sample coverage.', + 'Absence of a resolved crossing does not imply common symmetrization or location-scale collapse.', + 'The point set is the already declared .3/.5/.7, not a search over favorable locations.']) + print(json.dumps(report,indent=2,allow_nan=False)) + +if __name__=='__main__':main() diff --git a/tests/test_shape_reflection_order.py b/tests/test_shape_reflection_order.py new file mode 100644 index 00000000..b711ac71 --- /dev/null +++ b/tests/test_shape_reflection_order.py @@ -0,0 +1,24 @@ +import sys +from pathlib import Path +import unittest +import numpy as np +from scipy.optimize import brentq +sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts')) +from shape_reflection_order import summarize + +class ReflectionOrder(unittest.TestCase): + def test_common_logit_reflections_keep_order(self): + f=lambda p,k:k*(1-p)/(p+k*(1-p)) + for p in (.3,.5,.7): + self.assertLess(f(p,1),f(p,2));self.assertLess(f(p,2),f(p,3)) + def test_crossing_valid_involution_is_possible_without_common_chart(self): + h=lambda x:x+.2*x*(1-x)*((x-.5)**2-.02) + r=lambda x:brentq(lambda y:h(y)-(1-h(x)),0,1) + self.assertLess(r(.1)-.9,0);self.assertGreater(r(.5)-.5,0) + for p in (.1,.5,.9):self.assertAlmostEqual(r(r(p)),p,places=11) + def test_bands_do_not_call_unresolved_signs_a_crossing(self): + y=np.array([1,1,1,-1]*3,dtype=float) + self.assertTrue(summarize(y,np.eye(12)*1e-4)['any_resolved_crossing']) + self.assertFalse(summarize(y,np.eye(12))['any_resolved_crossing']) + +if __name__=='__main__':unittest.main() From 59fff91c6592e8c947ccd1e3df25e15df6a291e5 Mon Sep 17 00:00:00 2001 From: LightChainr Date: Sat, 12 Sep 2026 17:21:15 +0800 Subject: [PATCH 6/6] Distinguish full-profile collapse from parity with a fit-free affine-conjugacy sign test --- .github/workflows/shape-lineage-review.yml | 11 +-- notes/shape-transport-order-20260912.md | 40 +++++++++ .../shape-reflection-order-summary.json | 17 ++++ scripts/shape_transport_order.py | 89 +++++++++++++++++++ tests/test_shape_transport_order.py | 21 +++++ 5 files changed, 171 insertions(+), 7 deletions(-) create mode 100644 notes/shape-transport-order-20260912.md create mode 100644 results/research-control-20260912/shape-reflection-order-summary.json create mode 100644 scripts/shape_transport_order.py create mode 100644 tests/test_shape_transport_order.py diff --git a/.github/workflows/shape-lineage-review.yml b/.github/workflows/shape-lineage-review.yml index d351dc88..89b4a3b0 100644 --- a/.github/workflows/shape-lineage-review.yml +++ b/.github/workflows/shape-lineage-review.yml @@ -3,11 +3,7 @@ on: pull_request: branches: [main] paths: - - 'scripts/shape_lineage_review.py' - - 'scripts/shape_lineage_nonlinear_jackknife.py' - - 'scripts/shape_common_chart.py' - - 'scripts/shape_reflection_commutator.py' - - 'scripts/shape_reflection_order.py' + - 'scripts/shape*.py' - 'tests/test_shape*.py' - '.github/workflows/shape-lineage-review.yml' permissions: @@ -27,5 +23,6 @@ jobs: python -m unittest discover -s tests -p 'test_shape_common_chart.py' python -m unittest discover -s tests -p 'test_shape_reflection_commutator.py' python -m unittest discover -s tests -p 'test_shape_reflection_order.py' - - name: New sign-order test only; prior executed covariance/commutator results retained - run: python scripts/shape_reflection_order.py + python -m unittest discover -s tests -p 'test_shape_transport_order.py' + - name: Full-profile transport order; prior executed tests remain archived + run: python scripts/shape_transport_order.py diff --git a/notes/shape-transport-order-20260912.md b/notes/shape-transport-order-20260912.md new file mode 100644 index 00000000..27c45c33 --- /dev/null +++ b/notes/shape-transport-order-20260912.md @@ -0,0 +1,40 @@ +# Full-profile common-coordinate collapse has a noncrossing transport test + +2026-09-12. Mathematical extension of #706; the real-data result must be read +from the executed job before a verdict is claimed. Fixed points remain +p=Q290(.3,.5,.7), the same central set used in the reflection controls. + +Suppose ONE increasing psi and ONE profile z satisfy psi(Q_i(u))=a_i+b_i*z(u), +b_i>0, for i=145,290,725 on a common domain. Define A=Q145 o F290 and +B=Q725 o F290, where F290 is inverse of the already combined spin0 Q290. +Then psi A psi^-1 and psi B psi^-1 are positive-slope affine maps. For any +affine maps a(x)=s*x+t and b(x)=r*x+v, + + a(b(x))-b(a(x))=(s-1)*v-(r-1)*t, + +which is independent of x. Thus A(B(p))-B(A(p)) is either identically zero +or has one strict sign throughout the common domain. Increasing conjugacy +preserves sign, not magnitude. Opposite signs rule out common affine +conjugacy, and hence the specified exact common-coordinate location-scale +collapse. This is stronger than mere simultaneous reflection symmetry, +which need not pin the symmetric part of the profile. + +IMPORTANT: nonzero alone does NOT reject. Aff(1) is nonabelian; two affine +maps with distinct fixed points need not commute. This would be the same +mistake as using symplectic orthogonality as Euclidean orthogonality: the +correct group identity, not a familiar label, carries the inference. + +The script uses separate-size nonlinear deletion, including randomness in +the Q290 reference points, full stored covariance, and 55-dps pooled +Bernstein checks against a fast beta-mixture path. A fixed Bonferroni set +of three two-sided nominal intervals (total alpha=.0027) tests whether +opposite signs are resolved. It uses no inverse covariance, no fitted +chart, no covariance-selected contrast, and no search over points. The +entire composition and every deletion must remain in central quantiles +[.05,.95]. A failed domain or precision condition is a limitation, not +permission to choose nicer points. The result is C2 on existing data. + +No resolved crossing does not prove a common coordinate. A future power +claim needs a specific alternative, not repeated null-compatible tests. +Three mathematical controls cover affine noncommutation, nonlinear +conjugacy, and an actual crossing of two increasing non-affine maps. diff --git a/results/research-control-20260912/shape-reflection-order-summary.json b/results/research-control-20260912/shape-reflection-order-summary.json new file mode 100644 index 00000000..c34636a3 --- /dev/null +++ b/results/research-control-20260912/shape-reflection-order-summary.json @@ -0,0 +1,17 @@ +{ + "schema":"matching-one.shape-reflection-order-summary.v1", + "provenance":{"head":"8df13d10c7e53c86147c7cff9406a926484035e7","checkout":"bdd1012681495d9a9b94872ef04fe5a99e17b3fb","run_id":34685479687,"job_id":103531624273,"command":"python scripts/shape_reflection_order.py","extraction":"Selected fields from completed workflow stdout; full covariance is printed by the reproducible reader.","elapsed_seconds":28.787224390999995,"mathematical_tests_in_job":16}, + "standing":"C2 same effective spin0 laws. Necessary noncrossing condition, not positive identification.", + "coordinates_per_pair":["median difference","R difference at Q290(.3)","R difference at Q290(.5)","R difference at Q290(.7)"], + "alpha_nominal":0.0027,"critical_z_bonferroni":3.6891551298537215, + "pairs":[ + {"sizes":[145,290],"values":[-1.0057987858815821e-5,-2.0149056970062666e-5,-2.011602729721897e-5,-2.0747337739071048e-5],"standard_errors":[4.040053454070079e-6,7.855410196331045e-6,8.080148349486049e-6,8.088550103495104e-6],"incompatible_sign_order":false}, + {"sizes":[145,725],"values":[-4.7964495971137935e-6,-8.902090303758448e-6,-9.592936627011683e-6,-9.166176376702043e-6],"standard_errors":[3.79050106701839e-6,7.252848255766946e-6,7.581035488259411e-6,7.468079227667932e-6],"incompatible_sign_order":false}, + {"sizes":[290,725],"values":[5.261538261702028e-6,1.1246966666304219e-5,1.0523090670207288e-5,1.1581161362369003e-5],"standard_errors":[3.251080701006259e-6,6.231936741990175e-6,6.502178799303818e-6,6.417051723589638e-6],"incompatible_sign_order":false} + ], + "all_twelve_simultaneous_intervals_include_zero":true, + "max_abs_marginal_z":2.565025557560188, + "beta_vs_bernstein_max":1.3077985417699056e-15, + "verdict":"NO_RESOLVED_REFLECTION_CROSSING; common-chart question remains unresolved", + "limits":["Nominal Bonferroni intervals use estimated nonlinear-jackknife marginal variances, not exact finite-sample coverage.","No inverse covariance or independence of the twelve entries is assumed.","The same .3/.5/.7 point set is retained; no search for a favorable crossing."] +} diff --git a/scripts/shape_transport_order.py b/scripts/shape_transport_order.py new file mode 100644 index 00000000..ecff2e38 --- /dev/null +++ b/scripts/shape_transport_order.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python3 +"""Necessary full-profile common-coordinate test, without fitting that coordinate. + +A=Q145 o F290 and B=Q725 o F290. If one increasing psi makes all three +quantile laws location-scale copies, psi A psi^-1 and psi B psi^-1 are affine. +Their compositions AB and BA therefore differ by a constant in psi space: +onzero AB-BA cannot change sign on the common domain. +""" +from __future__ import annotations +from fractions import Fraction +import json +import time +import numpy as np +from scipy.stats import norm +from mpmath import mp +import threshold_quantile_lineage as L +import shape_lineage_review as R +from shape_lineage_nonlinear_jackknife import SPECS,jack_covariance +from shape_reflection_commutator import Law + +LEVELS=(.3,.5,.7) + + +def composition_difference(a,b,p): + return a(b(p))-b(a(p)) + + +def statistic(laws,high=False): + q=[v.mp_quantile if high else v.quantile for v in laws] + f=laws[1].mp_cdf if high else laws[1].cdf + visited=[] + def transport(i,p): + u=f(p);visited.append(float(u));return q[i](u) + a=lambda p:transport(0,p) + b=lambda p:transport(2,p) + levels=[mp.mpf(str(u)) for u in LEVELS] if high else LEVELS + points=[q[1](u) for u in levels] + values=[composition_difference(a,b,p) for p in points] + if min(visited)<.05 or max(visited)>.95:raise ValueError('composition outside central domain') + return points,values,[min(visited),max(visited)] + + +def main(): + start=time.perf_counter();inputs=[];pools=[];weights=[];laws=[] + for n in R.SIZES: + data=L.load_batch_histograms(R.ROOT/(SPECS[n]+'.hist.csv')) + pool=L.pooled_histograms(data['batches']);cs={} + for name in L.ORIENTATIONS: + a,b=data['orientation_representative'][name] + cs[name]=Fraction(a**4-6*a*a*b*b+b**4,(a*a+b*b)**2) + gap=cs['first']-cs['second'];w={'first':-cs['second']/gap,'second':cs['first']/gap} + inputs.append(data);pools.append(pool);weights.append(w);laws.append(Law(pool,n,w)) + points,full,domain=statistic(laws) + with mp.workdps(55): + _,high,_=statistic(laws,True);high=np.array([float(v) for v in high]) + cov=np.zeros((3,3));bias=np.zeros(3) + for index,n in enumerate(R.SIZES): + out=[] + for batch in inputs[index]['batches'].values(): + pool={name:{kind:L._subtract(pools[index][name][kind],batch[name][kind]) + for kind in ('minus','plus')} for name in L.ORIENTATIONS} + altered=laws.copy();altered[index]=Law(pool,n,weights[index]) + _,vals,limits=statistic(altered);out.append(vals) + domain=[min(domain[0],limits[0]),max(domain[1],limits[1])] + cov+=jack_covariance(out) + bias+=(len(out)-1)*(np.mean(out,axis=0)-full) + print(f'transport order completed existing N={n}',flush=True) + se=np.sqrt(np.diag(cov));critical=float(norm.ppf(1-.0027/6)) + lo,hi=high-critical*se,high+critical*se + positive=np.where(lo>0)[0].tolist();negative=np.where(hi<0)[0].tolist() + report={'schema':'matching-one.shape-transport-order.v1', + 'standing':'C2, existing effective quantile laws; necessary condition for full common-coordinate location-scale collapse', + 'reference_levels':list(LEVELS),'reference_points':points, + 'composition_difference_high_precision':high.tolist(),'standard_errors':se.tolist(), + 'covariance':cov.tolist(),'jackknife_bias_estimate':bias.tolist(), + 'simultaneous_nominal_alpha':.0027,'bonferroni_critical_z':critical, + 'lower':lo.tolist(),'upper':hi.tolist(),'resolved_positive':positive,'resolved_negative':negative, + 'resolved_crossing':bool(positive and negative), + 'max_abs_marginal_z':float(np.max(abs(high)/se)), + 'pooled_float_vs_55dps_max':float(np.max(abs(high-full))), + 'composition_quantiles_range_all_deletions':domain, + 'elapsed_seconds':time.perf_counter()-start, + 'limits':['A significant nonzero composition difference alone is NOT a rejection; two affine maps may fail to commute.', + 'Opposite resolved signs at fixed points would rule out common increasing affine conjugacy on that domain.', + 'No resolved crossing is not proof of a common coordinate or collapse. Estimated nonlinear-jackknife marginal intervals have nominal, not exact coverage.', + 'Reference points Q290(.3/.5/.7) remain random under N290 deletion; no new Monte Carlo or polynomial fit.']} + print(json.dumps(report,indent=2,allow_nan=False)) + +if __name__=='__main__':main() diff --git a/tests/test_shape_transport_order.py b/tests/test_shape_transport_order.py new file mode 100644 index 00000000..3eedb26a --- /dev/null +++ b/tests/test_shape_transport_order.py @@ -0,0 +1,21 @@ +import sys +from pathlib import Path +import unittest +from math import log,exp +sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts')) +from shape_transport_order import composition_difference + +class TransportOrder(unittest.TestCase): + def test_affine_maps_need_not_commute(self): + a=lambda x:2*x+1;b=lambda x:3*x-2 + for p in (-1,0,1):self.assertEqual(composition_difference(a,b,p),-4) + def test_common_nonlinear_conjugacy_preserves_sign_not_value(self): + a=lambda x:exp(2*log(x)+1);b=lambda x:exp(3*log(x)-2) + vals=[composition_difference(a,b,p) for p in (.5,1.,2.)] + self.assertTrue(all(v<0 for v in vals));self.assertNotEqual(vals[0],vals[-1]) + def test_crossing_orientation_preserving_maps_cannot_be_common_affine(self): + a=lambda x:2*x;b=lambda x:x+x**3 + self.assertGreater(composition_difference(a,b,-.5),0) + self.assertLess(composition_difference(a,b,.5),0) + +if __name__=='__main__':unittest.main()