diff --git a/tracks/mps/solutions/Wander-276/PR_BODY.md b/tracks/mps/solutions/Wander-276/PR_BODY.md new file mode 100644 index 000000000..e5bed1fba --- /dev/null +++ b/tracks/mps/solutions/Wander-276/PR_BODY.md @@ -0,0 +1,75 @@ + +![Wander — Issue #276](https://raw.githubusercontent.com/JunkaiWang-TheoPhy/quantum.harness/664506886413b68cdbc5a362a6075c78fd5d2c46/docs/showcase/ranger-archive/assets/missions-v2/07-quantum-geometry-curved-state-space-v2.png) + +> **EN** The spectrum is silent; the geometry is not. +> +> **中文** 能谱沉默，几何仍然说话。 + + +## Team + +| Field | Value | +|---|---| +| **Team name** | Wander | +| **Members** | Chenxi Wan, Yedi Shen, Junkai Wang | +| **Contact email** | WangTheoPhys@outlook.com | + +## Challenge + +Addresses #276: **What probes quantum chaos inside an exactly degenerate eigenspace?** + +This PR gives an executable answer: the probe is the **non-Abelian quantum geometry of the protected projector over coupling space**. Exact degeneracy silences internal level statistics, while the response amplitudes (X_a=(1-P)\partial_aP) generate the quantum metric, Berry curvature, gauge-invariant four-channel tensors, and global holonomy. + +## Scientific Advance + +| Layer | Result | +|---|---| +| Exact geometry | (\mathcal Q_{ab}=X_a^\dagger X_b), with metric and Berry curvature as its symmetric and antisymmetric parts | +| Independent mechanism | Generic cubic (\mathcal N=2) SYK supplies a charge-resolved cohomological BPS manifold independent of the Kapit–Mueller/Laughlin parent | +| Exact structure | Nilpotency produces orthogonal exact/coexact response branches (X=X_-\oplus X_+), (X_-^\dagger X_+=0) | +| Sealed test | The complete $N=8,10,12$ pilot and separately sealed, held-out $N=14$ four-channel test reject both registered separable covariance nulls | +| Controls | Decomposable-supercharge curvature atoms and a one-sided Laughlin Gaussian-null regression | + +The new scientific question is sharper than “is the Hamiltonian chaotic?” It asks whether the protected response tensor is controlled by registered two-point covariance data, or whether gauge-invariant four-point memory survives after that matching. + +## Outcome-Blind Protocol + +The held-out calculation freezes two parameter-free prediction models before opening the outcome sidecars: a collapsed separable covariance null and an exact/coexact Hodge-resolved separable covariance null. Complete disorder realizations—not tangent entries or tensor components—are the uncertainty unit. No scheduler dependency invokes unsealing; seal validation and scoring require a separate explicit action. + +**Final held-out verdict:** independent seal validation passed before explicit unsealing, and the frozen branch is `cohomological_non_gaussian_class`. + +| $N=14$ sparse sector | Physical median (95% bootstrap) | Collapsed null (97.5% prediction) | Hodge null (97.5% prediction) | +|---|---:|---:|---:| +| Adjacent | 0.301529 [0.291527, 0.312061] | [0.111789, 0.111852] | [0.112344, 0.112513] | +| Central | 0.374993 [0.368980, 0.380473] | [0.111338, 0.111353] | [0.111333, 0.111348] | + +Both primary physical intervals are disjoint from both sealed prediction intervals. The prediction JSON was frozen at SHA-256 `fc300dc7e4bdc1be157919e458ac868d3468533cce31108f23c9fba4f7e9f102`; the independently recomputable inference artifact is `177643e07fc6cf210362fc1077070bd1f0ba316b6805042a626de3f96c55a627`. + +## Claim Boundary + +- Established: an independent supersymmetric protection mechanism, exact Hodge-resolved response identity, analytic controls, and finite-size $N=8$--$14$ response memory beyond both frozen separable covariance-null families. +- Not established: asymptotic Geometric ETH, thermalization, real-time chaos, or a thermodynamic-limit theorem. +- The selected null-rejection branch means memory beyond the frozen separable Hodge/collapsed covariance models; it does not prove non-Gaussianity relative to every possible entrywise covariance model. + +## Deliverables + +- [Harness solution overview](https://github.com/JunkaiWang-TheoPhy/quantum.harness/blob/codex/issue-276-quantum-geometry/tracks/mps/solutions/Wander-276/README.md) +- [Research and reproduction guide](https://github.com/JunkaiWang-TheoPhy/quantum.harness/blob/codex/issue-276-quantum-geometry/tracks/mps/solutions/Wander-276/research/README.md) +- [Letter source](https://github.com/JunkaiWang-TheoPhy/quantum.harness/blob/codex/issue-276-quantum-geometry/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/main.tex) +- [Supplement source](https://github.com/JunkaiWang-TheoPhy/quantum.harness/blob/codex/issue-276-quantum-geometry/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/supplement.tex) +- [Compiled Letter](https://github.com/JunkaiWang-TheoPhy/quantum.harness/blob/codex/issue-276-quantum-geometry/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/response_complex_memory_v7.pdf) +- [Compiled Supplemental Material](https://github.com/JunkaiWang-TheoPhy/quantum.harness/blob/codex/issue-276-quantum-geometry/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/response_complex_memory_supplement_v7.pdf) +- [Machine-generated result report](https://github.com/JunkaiWang-TheoPhy/quantum.harness/blob/codex/issue-276-quantum-geometry/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_geometric_eth_report_v7.md) +- [Scientific ceiling and literature memo](https://github.com/JunkaiWang-TheoPhy/quantum.harness/blob/codex/issue-276-quantum-geometry/tracks/mps/solutions/Wander-276/research/docs/2026-08-01-scientific-ceiling-strategy.md) +- [Public research branch](https://github.com/JunkaiWang-TheoPhy/Chaos-of-Quantum-Geometry/tree/codex/task-05-geometric-chaos-baseline) + +## Verification + +```bash +cd tracks/mps/solutions/Wander-276 +bash verify.sh +``` + +The final verifier checks exact identities, controls, the complete pilot and held-out grids, the seal state machine, every compact hash, frozen branch recomputation, figure provenance, byte-exact Letter/Supplement PDFs, and 43 focused v7 tests. + +@OkongOyangO, please review the protected-response interpretation, the exact/coexact identity, and the outcome-blind four-channel test as Wander's Issue #276 submission. diff --git a/tracks/mps/solutions/Wander-276/README.md b/tracks/mps/solutions/Wander-276/README.md new file mode 100644 index 000000000..49e76b569 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/README.md @@ -0,0 +1,90 @@ +# Wander — Issue #276: Chaos in Exactly Degenerate Quantum Manifolds + +![Quantum geometry over an exactly degenerate manifold](https://raw.githubusercontent.com/JunkaiWang-TheoPhy/quantum.harness/664506886413b68cdbc5a362a6075c78fd5d2c46/docs/showcase/ranger-archive/assets/missions-v2/07-quantum-geometry-curved-state-space-v2.png) + +> **EN** The spectrum is silent; the geometry is not. +> +> **中文** 能谱沉默，几何仍然说话。 + +## Team + +| Field | Value | +|---|---| +| **Team name** | Wander | +| **Members** | Chenxi Wan, Yedi Shen, Junkai Wang | +| **Contact email** | WangTheoPhys@outlook.com | + +## Challenge and Answer + +This submission addresses [QuantumBFS/quantum.harness#276](https://github.com/QuantumBFS/quantum.harness/issues/276): **What probes quantum chaos inside an exactly degenerate eigenspace?** + +The executable answer is the **non-Abelian quantum geometry of the protected projector over coupling space**. If (P(\lambda)) is the degenerate projector and (X_a=(1-P)\partial_aP), then + +$$\mathcal Q_{ab}=X_a^\dagger X_b,\qquad g_{ab}=\frac{\mathcal Q_{ab}+\mathcal Q_{ba}}{2},\qquad F_{ab}=i(\mathcal Q_{ab}-\mathcal Q_{ba}).$$ + +Ordinary level statistics is undefined inside a flat multiplet, but (g), (F), gauge-invariant four-channel contractions, Chern numbers, and Wilson holonomy remain nontrivial. + +## Independent Protection Mechanisms + +The release no longer rests on one fractional-quantum-Hall example. + +| Mechanism | Protected manifold | Exact response structure | Role | +|---|---|---|---| +| Kapit–Mueller/Laughlin parent (H=B^\dagger B) | Frustration-free, gapped zero modes | One-sided response (X=-H_\perp^+B^\dagger\delta BP) | Local topological benchmark, Jacobi curvature, fixed-Chern holonomy | +| Generic cubic (\mathcal N=2) SYK (H=\{Q,Q^\dagger\}) | Charge-resolved harmonic cohomology | Orthogonal exact/coexact response (X=X_-\oplus X_+) | Independent supersymmetric mechanism and sealed covariance test | + +Nilpotency gives (X_-^\dagger X_+=0) exactly. The two-sided Hodge decomposition is therefore a physical response-complex structure, not a basis rewrite of the Laughlin calculation. + +## Registered Scientific Test + +For eight coupling tangents, the code whitens the channel covariance and evaluates the gauge-invariant tensor + +$$\mathcal T_{abcd}=\frac1D\operatorname{Tr}(\widehat X_a^\dagger\widehat X_b\widehat X_c^\dagger\widehat X_d).$$ + +The (N=8,10,12) pilot uses complete disorder realizations as the uncertainty unit. A held-out (N=14) calculation freezes two prediction models before any four-channel outcome is opened: + +1. a collapsed separable covariance Gaussian null; +2. an exact/coexact Hodge-resolved separable covariance Gaussian null. + +Safe covariates and predictions are SHA-256 sealed. Unsealing is an explicit, separate command and is never launched by the scheduler dependency chain. The seal was independently checked before opening, and the frozen result is: + +| $N=14$ sparse sector | Physical median (95% bootstrap) | Collapsed null (97.5% prediction) | Hodge null (97.5% prediction) | +|---|---:|---:|---:| +| Adjacent | 0.301529 [0.291527, 0.312061] | [0.111789, 0.111852] | [0.112344, 0.112513] | +| Central | 0.374993 [0.368980, 0.380473] | [0.111338, 0.111353] | [0.111333, 0.111348] | + +Both nulls miss both primary sectors, selecting `cohomological_non_gaussian_class`. + +## Claim Boundary + +This submission establishes an **independent model/operator class** for protected quantum-geometric chaos and finite-size $N=8$--$14$ four-channel response memory beyond two preregistered separable covariance nulls. It does **not** claim asymptotic Geometric ETH, conventional energy-resolved ETH, real-time chaos, or a thermodynamic-limit theorem. Null rejection does not by itself prove intrinsic non-Gaussianity after matching every entrywise nonseparable covariance. + +## Deliverables + +- [Research and reproduction guide](research/README.md) +- [Task-level guide](research/01_task_folder/task_05/README.md) +- [Letter source](research/overleaf_sync/cohomological_geometric_eth/main.tex) +- [Supplement source](research/overleaf_sync/cohomological_geometric_eth/supplement.tex) +- [Compiled Letter](research/01_task_folder/task_05/script/output/response_complex_memory_v7.pdf) +- [Compiled Supplemental Material](research/01_task_folder/task_05/script/output/response_complex_memory_supplement_v7.pdf) +- [Exact-data result report](research/01_task_folder/task_05/script/output/susy_hodge_geometric_eth_report_v7.md) +- [Scientific ceiling and literature memo](research/docs/2026-08-01-scientific-ceiling-strategy.md) +- [Public research branch](https://github.com/JunkaiWang-TheoPhy/Chaos-of-Quantum-Geometry/tree/codex/task-05-geometric-chaos-baseline) + +## Verification + +```bash +cd tracks/mps/solutions/Wander-276 +bash verify.sh +``` + +The verification path checks the exact Hodge identity, analytic controls, pilot-grid completeness, outcome-blind sealing, artifact hashes, frozen branch selection, figure provenance, and byte-exact Letter/Supplement delivery. + +## Next Scientific Gate + +The finite-size result is designed to expose the next theorem rather than hide it. The two high-ceiling targets are: + +- an asymptotic concentration/scaling law for the covariance-controlled response tensor; +- a spatially local nilpotent-supercharge model with a stable zero-mode count, open gap, and moving cohomological projector. + +These are journal-ceiling gates, not assumptions built into the current claim. diff --git a/tracks/mps/solutions/Wander-276/research/00_main/main_dashboard.md b/tracks/mps/solutions/Wander-276/research/00_main/main_dashboard.md new file mode 100644 index 000000000..d5e9a4a9d --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/00_main/main_dashboard.md @@ -0,0 +1,48 @@ +# Main Dashboard + +Global ledger for *Chaos of Quantum Geometry*. Read this first every session, then open the active task's `task_X_dashboard.md`. + +## Global Conventions +- **No mid-paragraph line breaks.** Keep each paragraph on one continuous physical line (no manual newlines inside a paragraph); do not hard-wrap prose at ~70/80 columns. Paragraphs stay separated by a blank line. Exceptions: list items, table rows, code, and the interior lines of multi-line math environments. Canonical rule lives in `CLAUDE.md` §9.1. +- **LaTeX cross-references.** Never use the `§`/`\S` form or hardcoded numbers to cite a section; always use `\label`/`\ref` — `Appendix~\ref{...}`, `Sec.~\ref{...}`, `Eq.~\eqref{...}`, `Fig.~\ref{...}` (non-breaking `~`). Canonical rule lives in `CLAUDE.md` §9.2. +- **Statuses:** ⚪ Start · 🟡 Ongoing · 🟢 Finished · 🔴 Blocked · ❌ Failed. The status here must match the status inside each `task_X_dashboard.md`. + +## Task Ledger + +| Task | Objective | Status | Last Updated | +|---|---|---|---| +| task_01 | Initialize the task-centric workspace (00_main / 01_task_folder / 02_recycle), sync the prompt family, and adopt the PRL workspace conventions | 🟢 Finished | 2026-06-18 [Claude] | +| task_02 | Read the seed paper (arXiv:2604.23287) end-to-end and expand `docs/paper-summary.md` per section; pin down the non-Abelian Berry curvature + quantum metric definitions | 🟡 Ongoing | 2026-07-27 [Codex] | +| task_03 | Build an FCI / correlated flat-band feasibility map for many-body non-Abelian quantum geometry as a chaos diagnostic | 🟡 Ongoing | 2026-07-27 [Codex] | +| task_05 | Deliver spectral silence, Geometric ETH channel memory, and fixed-Chern holonomy as an audited public paper/code release | 🟡 Ongoing | 2026-07-30 [Codex] | + +## Session Log +- 2026-06-18 [Claude]: **task_01 — workspace restructured to mirror PRL_Nonreciprocal.** Created `00_main/` (this dashboard + `system_prompt.md` + `history/`), `01_task_folder/` (task_01 init + task_02 seed-paper), and `02_recycle/`. Synced the prompt family (`system_prompt.md` ≡ `AGENTS.md` ≡ `.cursorrules`; `CLAUDE.md` superset). Renamed `literature/` → `lib/` and `overleaf-sync/` → `overleaf_sync/` to match PRL; removed the old flat `task/` folder (roadmap now lives in this ledger). Updated all READMEs + `.gitignore` cross-references. 🟢 task_01 Finished. +- 2026-06-18 [Claude]: **task_02 created** — read the seed paper end-to-end and expand the per-section summary; this is the first live research task. 🟡 Ongoing. +- 2026-07-13 09:15 [Codex]: **task_02 discussion triage** — reviewed the repo plus the Junkai/Desperado planning chat. The sharp next move is to finish the seed-paper definitions while opening the first concrete condensed-matter feasibility lane around FCI / correlated flat-band many-body quantum geometry, rather than expanding the manuscript title before a calculable model exists. 🟡 Ongoing. +- 2026-07-13 10:56 [Codex]: **task_03 created** - saved the Junkai/Desperado conversation triage as `docs/2026-07-13-junkai-desperado-research-triage.md` and opened the FCI / correlated flat-band feasibility lane as the first condensed-matter execution task. 🟡 Ongoing. +- 2026-07-27 14:10 [Codex]: **task_02 repo and literature reading** — read the active repo state against the full seed paper, verified Yiming Chen's recent `BPS Chaos` → `Fortuity in SYK Models` → Berry-curvature research chain, and added a clickable Chinese guide at `docs/2026-07-27-repo-and-yiming-chen-berry-geometry-guide.md`. The task stays 🟡 Ongoing because the per-section technical summary and numerical reproduction remain open. +- 2026-07-27 14:27 [Codex]: **task_03 candidate-system prioritization** — ranked condensed-matter targets and saved a clickable literature-backed note at `docs/2026-07-27-priority-condensed-matter-systems.md`. Recommended continuum FQH calibration → minimal lattice FCI → controlled chaos-axis tuning, with SUSY lattice fermions as a high-risk BPS analog and moiré/Josephson systems deferred. 🟡 Ongoing. +- 2026-07-27 14:31 [Codex]: **task_03 A0/A1 design discussion** — proposed a matched bosonic $\nu=1/2$ implementation: Kapit-Mueller lattice-Laughlin calibration plus continuum-LLL cross-check for A0, and a full-real-space checkerboard hard-core-boson FCI for A1, both using a shared gauge-covariant projector/link/Wilson-loop/QGT engine. No implementation started pending human approval. 🟡 Ongoing. +- 2026-07-27 15:15 [Codex]: **task_03 A0/A1 numerical delivery** — completed and reproduced the matched bosonic $\nu=1/2$ A0/A1 benchmarks. A0 combines a Kapit-Mueller lattice-Laughlin parent with a direct-coordinate continuum torus Laughlin overlap audit; A1 validates the flat-band checkerboard FCI through $N_b=4,5,6$. Both $8\times8$ twist bundles have $C_1=1$, unit Wilson determinant winding, an open external gap, nonsingular overlaps, resolved principal-log branches, and random local $U(2)$ gauge invariance. The complete runner passes 11 tests and a checksummed artifact audit. task_03 stays 🟡 Ongoing because the growing-rank quasihole chaos test is not part of A0/A1. +- 2026-07-27 15:54 [Codex]: **task_03 conclusion boundary** — recorded the safe interpretation of A0/A1: local non-Abelian curvature and quantum metric distinguish the continuum-like Laughlin parent from the matched checkerboard FCI despite identical integrated $C_1=1$, but the rank-two bundle cannot establish random-matrix chaos. The next decisive stage is a growing-rank quasihole zero-mode bundle plus a controlled perturbation and comparison to conventional chaos diagnostics. 🟡 Ongoing. +- 2026-07-27 16:24 [Codex]: **task_03 flagship-program discussion** — the human selected a two-plus-year, high-risk condensed-matter program. Compared large-rank FQH/FCI quasihole bundles, local exact-zero-mode constrained matter, and non-Abelian anyon holonomy; recommended Geometric ETH / random Hilbert-bundle universality as the main spine and saved the clickable literature-backed comparison at `docs/2026-07-27-yiming-level-condensed-matter-program-options.md`. No implementation or design approval is assumed. 🟡 Ongoing. +- 2026-07-27 16:39 [Codex]: **task_03 standard-model alternative discussion** — accepted the human's proposal to test Berry phase as a chaos diagnostic in familiar condensed-matter models as a useful low-risk calibration. Recommended a twisted $J_1$-$J_2$ XXZ/spinless-fermion model using local curvature, QGT, and small-loop phase statistics, with symmetry-resolved level statistics and dynamics as controls; saved the clickable scope review at `docs/2026-07-27-common-model-berry-phase-chaos-scope.md`. 🟡 Ongoing. +- 2026-07-27 17:03 [Codex]: **task_03 flagship architecture discussion** — developed the first concrete design section for “Geometric ETH in a fractional topological manifold”: a growing-rank Laughlin quasihole kernel as the structured bundle, off-bundle virtual mixing as the mechanism for changing projector geometry, and a finite-rank block-Wishart law for the joint non-Abelian QGT as the analytic target. Awaiting human approval before formal design documentation or implementation. 🟡 Ongoing. +- 2026-07-27 17:18 [Codex]: **task_03 flagship narrative revision** — accepted the human's criticism that the first architecture lacked a memorable paradox. Reframed the recommended story as “hidden chaos inside one fractional topological phase”: the protected $U(1)$ curvature keeps the same Chern/Hall data while the traceless $SU(D)$ quantum geometry changes from structured to random; Geometric ETH remains the explanatory engine rather than the headline. 🟡 Ongoing. +- 2026-07-27 17:32 [Codex]: **task_03 flagship writing architecture** — developed a result-dependent target abstract, six-paragraph introduction logic, argument-first section order, main-figure sequence, and explicit claim ladder for *Hidden Chaos Within a Topological Phase*. The manuscript is designed around the same-phase paradox; the Geometric-ETH mechanism appears after the phenomenon rather than leading the story. 🟡 Ongoing. +- 2026-07-27 16:52 [Codex]: **task_03 local-zero-mode second-paper discussion** — reviewed local SUSY/cohomology models and the July 2026 East–West-chain competition. Reframed the second paper around “the index counts zero modes, not their complexity,” with a finite-range random three-fermion supercharge as the proposed main model, Fendley–Schoutens zero modes as the structured control, and random-kernel Berry geometry as the analytic target. Saved the clickable review at `docs/2026-07-27-local-exact-zero-mode-geometric-chaos-options.md`. 🟡 Ongoing. +- 2026-07-27 17:58 [Codex]: **task_03 first-paper approval** — the human selected *Hidden Chaos Within a Topological Phase* for completion. Saved the approved research design at `docs/plans/2026-07-27-hidden-chaos-topological-phase-design.md`, requiring a growing-rank soft-core/projected Laughlin quasihole parent, a fixed-Hilbert gapped path, explicit central/traceless curvature separation, finite-\(D\) block-Wishart theory, cross-model controls, conventional chaos comparisons, and a complete reproducible manuscript. An exploratory audit demoted the existing hard-core underfilled A0 backend from a quasihole-parent candidate because it does not reproduce the continuum admissible count. 🟡 Ongoing. +- 2026-07-27 18:16 [Codex]: **task_03 first-paper implementation plan** — saved the twelve-task, test-driven implementation plan at `docs/plans/2026-07-27-hidden-chaos-topological-phase-implementation-plan.md`. It specifies exact file interfaces, growing-rank and same-phase gates, block-Wishart and conventional-chaos tests, generated figure/table/macro contracts, manuscript sections, and a one-command completion audit. Inline execution starts with the soft-core Laughlin parent and exact quasihole counting. 🟡 Ongoing. +- 2026-07-27 18:34 [Codex]: **task_03 A2 foundation** — implemented cyclic \((1,2)\)-admissible quasihole counting and a full soft-core boson Hamiltonian with correct occupation factors, contact interaction, density/on-site terms, and boundary twists. The pre-registered algebraic ranks are \(D=9,16,25\); the complete suite passes 19 tests. Spectral realization of those ranks is deliberately deferred to the next go/no-go runner. 🟡 Ongoing. +- 2026-07-27 18:58 [Codex]: **task_03 A2 parent gate passed** — added a rigorous projected-contact backend and degeneracy-safe QR/Rayleigh–Ritz eigensolver. The generated feasibility artifact verifies exact \(D=25,36,50\) Laughlin kernels at four twists, minimum external gaps \(0.0946952,0.0936047,0.0977652\), sub-\(1.1\times10^{-15}\) internal bandwidth, and 27 passing tests. Dense re-audit corrected the earlier sparse-solver error: legacy hard-core \(N_b=3\) has the correct 16 states; \(N_b=2\) has 21 rather than 20. 🟡 Ongoing. +- 2026-07-27 19:24 [Codex]: **task_03 arbitrary-rank physical bundle** — implemented the symmetric-boson Fock lift for twist-dependent band bases and overlap-only non-Abelian QGT geometry. The \(D=25\), \(5\times5\) parent bundle passes with \(C_1=10\), external gap \(0.0952460\), overlap singular value \(0.796310\), and \(U(25)\) gauge errors below \(4\times10^{-15}\). A retained \(3\times3\) failure shows determinant central-phase aliasing despite safe individual Wilson eigenphases; the new lift-mismatch diagnostic rejects it. The suite passes 31 tests. 🟡 Ongoing. +- 2026-07-27 19:51 [Codex]: **task_03 same-phase path passed** — screened four deterministic fixed-site-Hilbert endpoints and selected `generic_mid` by a frozen gap-times-projector-response score. The full \(D=25\), \(6\times6\), five-point path preserves \(C_1=10\), keeps the external gap above \(0.0396120\), limits bandwidth/gap to \(0.0574195\), and moves the physical projector to mean distance \(0.424107\). All branch, overlap, and \(U(25)\) gauge checks pass; the suite passes 37 tests. 🟡 Ongoing. +- 2026-07-27 17:57 [Codex]: **task_03 finite-rank RMT baseline** — derived exact finite-\(D\) block-Wishart second, fourth, and sixth moments by Wick-permutation sums and validated them against 4,000 samples for each \(M=4,\ldots,128\). The \(D=25\) same-phase path moves monotonically closer to the \(M=128\) eigenvalue law, but its endpoint moment and gap-ratio statistics remain nonuniversal; this is recorded as a quantitative onset rather than a plateau. Generalized finite-range density interactions were added as a negative mechanism control, and the suite passes 46 tests. 🟡 Ongoing. +- 2026-07-27 18:21 [Codex]: **task_03 growing-rank hidden-chaos and independent FCI control** — defined a gauge-covariant curvature increment by cross-bundle polar transport back to the Laughlin parent. Its endpoint gap ratio approaches the generated block-Wishart reference \(0.597503\): \(0.566145\) at \(D=25\) and \(0.592594\) at \(D=50\), with open gaps and fixed Chern data. A separately constructed disordered checkerboard FCI passes the same gates and gives \(0.540028,0.580106\). The total curvature retains a structured background, so the supported universality is local spectral repulsion of the transported increment. A fixed-quasihole \(D=36\) size control remains open. 🟡 Ongoing. +- 2026-07-27 18:52 [Codex]: **task_03 fixed-two-quasihole size control** — completed the \(D=25,36\) branch-resolved endpoint calculation at fixed \(N_\phi=2N_b+2\). The transported-increment gap ratio moves \(0.549255\to0.576366\) toward the block-Wishart \(0.597503\), with open endpoint gaps and fixed Chern data. The strict pre-registered gate remains false solely because the \(D=36\) bandwidth/gap \(0.517923\) exceeds the \(0.5\) ceiling; every other check passes and no threshold was relaxed. The result is retained as qualified finite-size evidence. 🟡 Ongoing. +- 2026-07-27 18:57 [Codex]: **task_03 conventional-chaos controls** — generated matched Poisson/GUE references, quasihole energy gap ratios, and twist-ensemble spectral form factors. On the Kapit–Mueller path, energy correlations enter the RMT window at \(g=0.25\), before the transported geometry at \(g=1.0\) (\(D=25\)) and \(g=0.75\) (\(D=50\)); the checkerboard \(D=50\) control reverses the sampled ordering. The conventional-control gate and 58 tests pass, establishing that geometric and spectral chaos scales are not redundant. 🟡 Ongoing. +- 2026-07-27 19:04 [Codex]: **task_03 manuscript figure package** — generated five argument-ordered paper figures, vector/raster manuscript assets, provenance JSON, an endpoint table, and script-derived LaTeX numerical macros. The production script enforces all positive scientific gates and preserves the fixed-two-quasihole strict-gate failure as an explicit manuscript limitation. The suite remains at 58 passing tests. 🟡 Ongoing. +- 2026-07-27 19:17 [Codex]: **task_03 first-paper delivery** — completed the 17-page preprint *Hidden Chaos Within a Topological Phase* with five generated main figures, full formalism/results/Geometric-ETH narrative, methods and limitations appendices, and an audited primary-source bibliography. The final delivery gate verifies warning-free compilation, figure hashes, extracted PDF content, all scientific gates, the retained fixed-quasihole strict failure, and 61 passing tests. The paper deliverable is complete; task_03 remains 🟡 Ongoing for larger-size scaling, external review, and subsequent research branches. +- 2026-07-30 19:30 [Codex]: **task_05 public-release preparation** — assembled the innovation-first repository entry points, 17-page paper, Markdown technical report, release notes, citation metadata, challenge draft, PR body, collaborator review comment, and public checklist. The compact release passes 17/17 contract checks, 38/38 quick tests, 86 tests with six production-data activations in the complete suite, and 25/25 article gates across seven synchronized figures. The prepared branch is ready for the human's Issue-first PR sequence; task_05 remains 🟡 Ongoing through review. +- 2026-07-30 19:50 [Codex]: **task_05 Issue-linked PR handoff** — linked the public release to `QuantumBFS/quantum.harness#276`, aligned the PR opening statement with the challenge question, and synchronized the prepared collaborator review comment and submission checklist. The release proceeds as a draft PR from `codex/task-05-geometric-chaos-baseline` into `main`. 🟡 Ongoing through scientific review. diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/README.md b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/README.md new file mode 100644 index 000000000..f786babf8 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/README.md @@ -0,0 +1,74 @@ +# Task 05 — Protected Response Complex and Geometric ETH + +This task asks a falsifiable question inside an exactly degenerate manifold: after matching registered two-point response data, does a gauge-invariant four-channel statistic follow a Gaussian Wick law? Across the completed finite-size $N=8$--$14$ sequence, the answer is no for both preregistered separable covariance nulls. + +## Physics Object + +For a protected projector (P(\lambda)), define (X_a=(1-P)\partial_aP). Then + +$$\mathcal Q_{ab}=X_a^\dagger X_b,\qquad g_{ab}=\tfrac12(\mathcal Q_{ab}+\mathcal Q_{ba}),\qquad F_{ab}=i(\mathcal Q_{ab}-\mathcal Q_{ba}).$$ + +The (\mathcal N=2) SYK supercharge (Q=\sum_{i dict[str, str]: + paths = ( + Path(__file__).resolve(), + SCRIPT_ROOT / "run_susy_hodge_geometric_eth_v7.py", + SCRIPT_ROOT / "run_susy_hodge_null_bank_v7.py", + SCRIPT_ROOT / "lgeth" / "hodge_wick.py", + SCRIPT_ROOT / "lgeth" / "wick_channels.py", + ) + return {str(path.relative_to(SCRIPT_ROOT)): sha256(path) for path in paths} + + +def _array_hash(values: np.ndarray) -> str: + contiguous = np.ascontiguousarray(values) + import hashlib + + return hashlib.sha256(contiguous.view(np.uint8)).hexdigest() + + +def _group_cases( + cases: list[tuple[int, str, int, str]], +) -> dict[tuple[int, str, str], list[int]]: + groups: dict[tuple[int, str, str], list[int]] = {} + if not cases: + raise ValueError("prediction requires at least one case") + for N, sector, realization, panel_kind in sorted(cases): + key = (int(N), str(sector), str(panel_kind)) + groups.setdefault(key, []).append(int(realization)) + for key, realizations in groups.items(): + if len(realizations) != len(set(realizations)): + raise ValueError(f"duplicate realization in prediction group {key}") + return groups + + +def _load_group_banks( + N: int, + sector: str, + panel_kind: str, + realizations: list[int], + *, + null_bank_root: Path, +) -> tuple[np.ndarray, np.ndarray, list[dict[str, Any]]]: + collapsed: list[np.ndarray] = [] + hodge: list[np.ndarray] = [] + records: list[dict[str, Any]] = [] + for realization in realizations: + metadata_path, arrays_path = null_bank_paths( + null_bank_root, + N, + sector, + realization, + panel_kind, + ) + if not metadata_path.is_file() or not arrays_path.is_file(): + raise FileNotFoundError("missing safe null bank") + metadata = json.loads(metadata_path.read_text(encoding="utf-8")) + if metadata.get("arrays_sha256") != sha256(arrays_path): + raise ValueError("null-bank array hash mismatch") + if not metadata.get("passed") or not all(metadata.get("checks", {}).values()): + raise ValueError("null bank contains a failed gate") + identity = metadata.get("identity", {}) + expected = (N, sector, realization, panel_kind) + observed = tuple( + identity.get(key) + for key in ("N", "sector", "realization", "panel_kind") + ) + if observed != expected: + raise ValueError("null-bank case identity mismatch") + with np.load(arrays_path) as arrays: + collapsed_values = np.asarray(arrays["collapsed_null"], dtype=float) + hodge_values = np.asarray(arrays["hodge_null"], dtype=float) + if collapsed_values.ndim != 1 or hodge_values.shape != collapsed_values.shape: + raise ValueError("null-bank draw shapes disagree") + if not np.all(np.isfinite(collapsed_values)) or not np.all( + np.isfinite(hodge_values) + ): + raise ValueError("null bank contains non-finite draws") + collapsed.append(collapsed_values) + hodge.append(hodge_values) + records.append( + { + "realization": realization, + "metadata_sha256": sha256(metadata_path), + "arrays_sha256": sha256(arrays_path), + } + ) + return np.asarray(collapsed), np.asarray(hodge), records + + +def aggregate_pilot_from_banks( + cases: list[tuple[int, str, int, str]], + *, + checkpoint_root: Path = CHECKPOINT_ROOT, + null_bank_root: Path = NULL_BANK_ROOT, + safe_covariates_json: Path = PILOT_BANK_SAFE_JSON, + output_json: Path = PILOT_BANK_JSON, + output_npz: Path = PILOT_BANK_NPZ, + null_replicates: int = NULL_REPLICATES, + bootstrap_replicates: int = PHYSICAL_BOOTSTRAP_REPLICATES, + seed: int = BASE_SEED, +) -> dict[str, Any]: + """Aggregate completed pilot sidecars using precomputed safe null banks.""" + + null_count = int(null_replicates) + bootstrap_count = int(bootstrap_replicates) + if null_count < 1 or bootstrap_count < 1: + raise ValueError("pilot aggregation requires positive replicate counts") + groups = _group_cases(cases) + write_safe_covariates( + cases, + root=checkpoint_root, + output_json=safe_covariates_json, + ) + output_arrays: dict[str, np.ndarray] = {} + summaries: list[dict[str, Any]] = [] + for (N, sector, panel_kind), realizations in sorted(groups.items()): + collapsed_banks, hodge_banks, bank_records = _load_group_banks( + N, + sector, + panel_kind, + realizations, + null_bank_root=null_bank_root, + ) + physical_values: list[float] = [] + balances: list[float] = [] + for realization in realizations: + safe_path, arrays_path, outcome_path = panel_paths( + checkpoint_root, + N, + sector, + realization, + panel_kind, + ) + if not outcome_path.is_file(): + raise FileNotFoundError("missing sequential-pilot outcome sidecar") + safe = json.loads(safe_path.read_text(encoding="utf-8")) + outcome = json.loads(outcome_path.read_text(encoding="utf-8")) + if ( + safe.get("arrays_sha256") != sha256(arrays_path) + or outcome.get("safe_identity_hash") != safe.get("identity_hash") + or outcome.get("safe_arrays_sha256") != safe.get("arrays_sha256") + ): + raise ValueError("pilot outcome identity mismatch") + observed_case = tuple( + outcome.get(key) + for key in ("N", "sector", "realization", "panel_kind") + ) + if observed_case != (N, sector, realization, panel_kind): + raise ValueError("pilot outcome case identity mismatch") + physical_values.append(float(outcome["R4"])) + balances.append(float(safe["signature"]["hodge_balance"])) + physical = np.asarray(physical_values, dtype=float) + if not np.all(np.isfinite(physical)): + raise ValueError("pilot physical outcome is not finite") + physical_bootstrap = _bootstrap_median( + physical, + bootstrap_count, + _derived_seed(seed, N, sector, panel_kind, "pilot_physical_bootstrap"), + ) + collapsed = _banked_complete_medians( + collapsed_banks, + null_count, + _derived_seed(seed, N, sector, panel_kind, "pilot_collapsed"), + ) + hodge = _banked_complete_medians( + hodge_banks, + null_count, + _derived_seed(seed, N, sector, panel_kind, "pilot_hodge"), + ) + prefix = f"N{N}_{sector}_{panel_kind}" + output_arrays[f"{prefix}_physical"] = physical + output_arrays[f"{prefix}_physical_bootstrap"] = physical_bootstrap + output_arrays[f"{prefix}_collapsed_null"] = collapsed + output_arrays[f"{prefix}_hodge_null"] = hodge + observed_median = float(np.median(physical)) + collapsed_interval = np.quantile( + collapsed, PREDICTION_QUANTILES + ).tolist() + hodge_interval = np.quantile(hodge, PREDICTION_QUANTILES).tolist() + summaries.append( + { + "N": N, + "sector": sector, + "panel_kind": panel_kind, + "realizations": len(realizations), + "observed_median": observed_median, + "physical_bootstrap_interval": np.quantile( + physical_bootstrap, [0.025, 0.975] + ).tolist(), + "collapsed_prediction_interval": collapsed_interval, + "hodge_prediction_interval": hodge_interval, + "collapsed_covered": collapsed_interval[0] + <= observed_median + <= collapsed_interval[2], + "hodge_covered": hodge_interval[0] + <= observed_median + <= hodge_interval[2], + "median_hodge_balance": float(np.median(balances)), + "null_banks": bank_records, + } + ) + _atomic_npz(output_npz, **output_arrays) + checks = { + "complete_requested_grid": sum( + item["realizations"] for item in summaries + ) + == len(cases), + "finite_outputs": all( + np.all(np.isfinite(values)) for values in output_arrays.values() + ), + "registered_null_replicates": all( + values.shape == (null_count,) + for key, values in output_arrays.items() + if key.endswith("_null") + ), + "registered_bootstrap_replicates": all( + values.shape == (bootstrap_count,) + for key, values in output_arrays.items() + if key.endswith("_physical_bootstrap") + ), + "safe_covariates_preexist": Path(safe_covariates_json).is_file(), + } + payload = { + "version": VERSION, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "uncertainty_unit": "complete_disorder_realization", + "null_replicates": null_count, + "physical_bootstrap_replicates": bootstrap_count, + "prediction_coverage": PREDICTION_COVERAGE, + "groups": summaries, + "safe_covariates_sha256": sha256(safe_covariates_json), + "arrays_sha256": sha256(output_npz), + "sources": _source_hashes(), + "checks": checks, + "passed": all(checks.values()), + } + if not payload["passed"]: + raise RuntimeError(f"banked pilot aggregation failed: {checks}") + _atomic_json(output_json, payload) + return payload + + +def write_n14_prediction( + cases: list[tuple[int, str, int, str]], + *, + checkpoint_root: Path = CHECKPOINT_ROOT, + null_bank_root: Path = NULL_BANK_ROOT, + safe_covariates_json: Path = N14_SAFE_JSON, + output_json: Path = N14_PREDICTION_JSON, + output_npz: Path = N14_PREDICTION_NPZ, + seal_path: Path = N14_PREDICTION_SEAL, + null_replicates: int = NULL_REPLICATES, + seed: int = BASE_SEED, +) -> dict[str, Any]: + """Predict group medians from safe two-point data and seal before unseal.""" + + count = int(null_replicates) + if count < 1: + raise ValueError("prediction requires positive null replicates") + groups = _group_cases(cases) + sizes = {key[0] for key in groups} + if len(sizes) != 1: + raise ValueError("a prediction seal must contain exactly one system size") + N = next(iter(sizes)) + required_primary = {(N, "central", "sparse"), (N, "adjacent", "sparse")} + if not required_primary.issubset(groups): + raise ValueError("prediction is missing the registered sparse primary pair") + write_safe_covariates( + cases, + root=checkpoint_root, + output_json=safe_covariates_json, + ) + output_arrays: dict[str, np.ndarray] = {} + summaries: list[dict[str, Any]] = [] + primary_pair: list[dict[str, Any]] = [] + for (group_N, sector, panel_kind), realizations in sorted(groups.items()): + collapsed_banks, hodge_banks, bank_records = _load_group_banks( + group_N, + sector, + panel_kind, + realizations, + null_bank_root=null_bank_root, + ) + collapsed = _banked_complete_medians( + collapsed_banks, + count, + _derived_seed(seed, group_N, sector, panel_kind, "sealed_collapsed"), + ) + hodge = _banked_complete_medians( + hodge_banks, + count, + _derived_seed(seed, group_N, sector, panel_kind, "sealed_hodge"), + ) + prefix = f"N{group_N}_{sector}_{panel_kind}" + output_arrays[f"{prefix}_collapsed"] = collapsed + output_arrays[f"{prefix}_hodge"] = hodge + record = { + "N": group_N, + "sector": sector, + "panel_kind": panel_kind, + "realizations": len(realizations), + "realization_ids": realizations, + "collapsed_interval": np.quantile( + collapsed, PREDICTION_QUANTILES + ).tolist(), + "hodge_interval": np.quantile(hodge, PREDICTION_QUANTILES).tolist(), + "collapsed_array_sha256": _array_hash(collapsed), + "hodge_array_sha256": _array_hash(hodge), + "null_banks": bank_records, + } + summaries.append(record) + if panel_kind == "sparse" and sector in {"central", "adjacent"}: + primary_pair.append( + { + key: record[key] + for key in ( + "N", + "sector", + "panel_kind", + "realizations", + "collapsed_interval", + "hodge_interval", + ) + } + ) + _atomic_npz(output_npz, **output_arrays) + checks = { + "complete_requested_grid": sum( + item["realizations"] for item in summaries + ) + == len(cases), + "registered_primary_pair": { + (item["sector"], item["panel_kind"]) for item in primary_pair + } + == {("central", "sparse"), ("adjacent", "sparse")}, + "finite_prediction_arrays": all( + np.all(np.isfinite(values)) for values in output_arrays.values() + ), + "complete_realization_unit": all( + item["realizations"] == len(item["realization_ids"]) + for item in summaries + ), + "safe_covariates_preexist": Path(safe_covariates_json).is_file(), + } + payload = { + "version": VERSION, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "system_size": N, + "observable": "normalized_response_memory", + "uncertainty_unit": "complete_disorder_realization", + "prediction_coverage": PREDICTION_COVERAGE, + "prediction_quantiles": list(PREDICTION_QUANTILES), + "null_replicates": count, + "safe_covariates_sha256": sha256(safe_covariates_json), + "prediction_arrays_file": Path(output_npz).name, + "prediction_arrays_sha256": sha256(output_npz), + "sources": _source_hashes(), + "groups": summaries, + "primary_pair": primary_pair, + "checks": checks, + } + serialized = json.dumps(payload, sort_keys=True).lower() + payload["checks"]["no_outcome_leakage"] = not any( + token in serialized for token in FORBIDDEN_PREDICTION_TOKENS + ) + payload["passed"] = all(payload["checks"].values()) + if not payload["passed"]: + raise RuntimeError(f"sealed prediction audit failed: {payload['checks']}") + _atomic_json(output_json, payload) + seal_file_hash(output_json, seal_path) + return payload + + +def _bootstrap_median( + values: np.ndarray, + replicates: int, + seed: int, +) -> np.ndarray: + samples = np.asarray(values, dtype=float) + count = int(replicates) + if samples.ndim != 1 or samples.size < 1 or count < 1: + raise ValueError("median bootstrap requires a nonempty realization vector") + rng = np.random.default_rng(int(seed)) + indices = rng.integers(0, samples.size, size=(count, samples.size)) + return np.median(samples[indices], axis=1) + + +def select_frozen_branch( + collapsed_pair_covered: bool, + hodge_pair_covered: bool, + structured_indistinguishable: bool, + numerical_gates_passed: bool, +) -> str: + """Map the registered pair outcome to exactly one frozen result branch.""" + + if not numerical_gates_passed: + return "feasibility_failure" + if collapsed_pair_covered and hodge_pair_covered: + return "strong_covariance_universality" + if not collapsed_pair_covered and hodge_pair_covered: + return "hodge_resolved_geometric_eth" + if not collapsed_pair_covered and not hodge_pair_covered: + if structured_indistinguishable: + return "structured_cohomology" + return "cohomological_non_gaussian_class" + # A collapsed-only success is not one of the preregistered scientific + # branches, so the analysis fails closed instead of inventing a claim. + return "feasibility_failure" + + +def _outside_interval(confidence: list[float], interval: list[float]) -> bool: + return confidence[1] < interval[0] or confidence[0] > interval[2] + + +def score_unsealed_n14( + prediction_json: Path, + prediction_seal: Path, + unsealed_json: Path, + *, + output_json: Path = N14_INFERENCE_JSON, + bootstrap_replicates: int = PHYSICAL_BOOTSTRAP_REPLICATES, + seed: int = BASE_SEED, + structured_indistinguishable: bool = False, +) -> dict[str, Any]: + """Score the held-out sparse pair after validating the prediction seal.""" + + prediction_hash = _validate_file_hash(prediction_json, prediction_seal) + prediction = json.loads(Path(prediction_json).read_text(encoding="utf-8")) + if not prediction.get("passed") or not all(prediction.get("checks", {}).values()): + raise ValueError("sealed prediction contains a failed gate") + unsealed = json.loads(Path(unsealed_json).read_text(encoding="utf-8")) + if not unsealed.get("passed"): + raise ValueError("unsealed outcome aggregate contains a failed gate") + if unsealed.get("prediction_sha256") != prediction_hash: + raise ValueError("unsealed aggregate references the wrong prediction") + try: + prediction_time = datetime.fromisoformat(prediction["generated_utc"]) + unsealed_time = datetime.fromisoformat(unsealed["unsealed_utc"]) + except (KeyError, TypeError, ValueError) as error: + raise ValueError("prediction/unseal timestamp is invalid") from error + if unsealed_time <= prediction_time: + raise ValueError("prediction must precede the outcome unseal") + records = unsealed.get("records", []) + primary = { + (int(item["N"]), str(item["sector"]), str(item["panel_kind"])): item + for item in prediction["primary_pair"] + } + results: list[dict[str, Any]] = [] + for key, predicted in sorted(primary.items()): + N, sector, panel_kind = key + values = np.asarray( + [ + float(record["R4"]) + for record in records + if ( + int(record["N"]), + str(record["sector"]), + str(record["panel_kind"]), + ) + == key + ], + dtype=float, + ) + if values.size != int(predicted["realizations"]): + raise ValueError("unsealed primary realization count mismatch") + bootstrap = _bootstrap_median( + values, + int(bootstrap_replicates), + _derived_seed(seed, N, sector, panel_kind, "physical_bootstrap"), + ) + observed = float(np.median(values)) + confidence = np.quantile(bootstrap, [0.025, 0.975]).tolist() + collapsed_interval = [float(value) for value in predicted["collapsed_interval"]] + hodge_interval = [float(value) for value in predicted["hodge_interval"]] + results.append( + { + "N": N, + "sector": sector, + "panel_kind": panel_kind, + "realizations": int(values.size), + "observed_median": observed, + "physical_bootstrap_interval": confidence, + "collapsed_prediction_interval": collapsed_interval, + "hodge_prediction_interval": hodge_interval, + "collapsed_covered": collapsed_interval[0] + <= observed + <= collapsed_interval[2], + "hodge_covered": hodge_interval[0] + <= observed + <= hodge_interval[2], + "robust_outside_both": _outside_interval( + confidence, collapsed_interval + ) + and _outside_interval(confidence, hodge_interval), + } + ) + collapsed_pair = all(item["collapsed_covered"] for item in results) + hodge_pair = all(item["hodge_covered"] for item in results) + robust_non_gaussian = all(item["robust_outside_both"] for item in results) + inference_resolved = ( + collapsed_pair + or hodge_pair + or bool(structured_indistinguishable) + or robust_non_gaussian + ) + numerical_gates = ( + len(results) == 2 + and all(np.isfinite(item["observed_median"]) for item in results) + and inference_resolved + ) + branch = select_frozen_branch( + collapsed_pair, + hodge_pair, + bool(structured_indistinguishable), + numerical_gates, + ) + payload = { + "version": VERSION, + "unsealed_utc": unsealed.get("unsealed_utc"), + "scored_utc": datetime.now(timezone.utc).isoformat(), + "prediction_sha256": prediction_hash, + "selected_branch": branch, + "primary_pair": results, + "pair_coverage": { + "collapsed": collapsed_pair, + "hodge": hodge_pair, + }, + "robust_non_gaussian_excess": robust_non_gaussian, + "structured_indistinguishable": bool(structured_indistinguishable), + "physical_bootstrap_replicates": int(bootstrap_replicates), + "checks": { + "valid_prediction_seal": True, + "prediction_precedes_unseal": unsealed_time > prediction_time, + "complete_primary_pair": len(results) == 2, + "complete_realization_uncertainty": all( + item["realizations"] > 0 for item in results + ), + "registered_branch_resolved": inference_resolved, + }, + } + payload["passed"] = all(payload["checks"].values()) + _atomic_json(output_json, payload) + return payload + + +def _parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(description=__doc__) + subparsers = parser.add_subparsers(dest="command", required=True) + predict = subparsers.add_parser("predict") + predict.add_argument("--null-replicates", type=int, default=NULL_REPLICATES) + unseal = subparsers.add_parser("unseal") + unseal.add_argument( + "--bootstrap-replicates", + type=int, + default=PHYSICAL_BOOTSTRAP_REPLICATES, + ) + pilot = subparsers.add_parser("pilot") + pilot.add_argument("--sizes", type=int, nargs="+", required=True) + pilot.add_argument("--null-replicates", type=int, default=NULL_REPLICATES) + pilot.add_argument( + "--bootstrap-replicates", + type=int, + default=PHYSICAL_BOOTSTRAP_REPLICATES, + ) + return parser + + +def main() -> None: + args = _parser().parse_args() + if args.command == "pilot": + payload = aggregate_pilot_from_banks( + registered_case_grid(tuple(args.sizes)), + null_replicates=args.null_replicates, + bootstrap_replicates=args.bootstrap_replicates, + ) + elif args.command == "predict": + cases = registered_case_grid((14,)) + payload = write_n14_prediction( + cases, + null_replicates=args.null_replicates, + ) + else: + cases = registered_case_grid((14,)) + unseal_outcomes( + cases, + prediction_json=N14_PREDICTION_JSON, + prediction_seal=N14_PREDICTION_SEAL, + output_json=N14_UNSEALED_JSON, + output_npz=N14_UNSEALED_NPZ, + ) + payload = score_unsealed_n14( + N14_PREDICTION_JSON, + N14_PREDICTION_SEAL, + N14_UNSEALED_JSON, + bootstrap_replicates=args.bootstrap_replicates, + ) + print(json.dumps(payload, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/generate_susy_hodge_controls_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/generate_susy_hodge_controls_v7.py new file mode 100644 index 000000000..c860656be --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/generate_susy_hodge_controls_v7.py @@ -0,0 +1,205 @@ +#!/usr/bin/env python3 +"""Generate analytic decomposable and one-sided control audit v7.""" + +from __future__ import annotations + +import hashlib +import json +from pathlib import Path +from typing import Any + +import numpy as np + +from lgeth.hodge_response import ( + HodgeSignature, + decomposable_curvature, + hodge_response, +) +from lgeth.hodge_wick import hodge_gaussian_r4_reference +from lgeth.susy_cohomology import ( + analytic_decomposable_curvature_multiplicities, + decomposable_bps_rank, + decomposable_couplings, + decomposable_tangent, + solve_bps_frame, +) +from lgeth.wick_channels import gaussian_r4_reference + + +SCRIPT_ROOT = Path(__file__).resolve().parent +OUTPUT_JSON = SCRIPT_ROOT / "output" / "susy_hodge_v7_controls.json" +VERSION = "v7" + + +def sha256(path: Path) -> str: + digest = hashlib.sha256() + with Path(path).open("rb") as handle: + for block in iter(lambda: handle.read(1 << 20), b""): + digest.update(block) + return digest.hexdigest() + + +def _atomic_json(path: Path, payload: dict[str, Any]) -> None: + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text( + json.dumps(payload, indent=2, sort_keys=True), + encoding="utf-8", + ) + temporary.replace(path) + + +def _source_hashes() -> dict[str, str]: + paths = ( + Path(__file__).resolve(), + SCRIPT_ROOT / "lgeth" / "susy_cohomology.py", + SCRIPT_ROOT / "lgeth" / "hodge_response.py", + SCRIPT_ROOT / "lgeth" / "hodge_wick.py", + SCRIPT_ROOT / "lgeth" / "wick_channels.py", + ) + return {str(path.relative_to(SCRIPT_ROOT)): sha256(path) for path in paths} + + +def _atomic_summary( + matrix: np.ndarray, + alpha: float, +) -> tuple[dict[str, int], float, list[float]]: + eigenvalues = np.linalg.eigvalsh(0.5 * (matrix + matrix.conj().T)) + target = 1.0 / float(alpha) ** 2 + tolerance = 2e-11 + counts = { + "negative": int(np.count_nonzero(np.isclose(eigenvalues, -target, atol=tolerance))), + "zero": int(np.count_nonzero(np.isclose(eigenvalues, 0.0, atol=tolerance))), + "positive": int(np.count_nonzero(np.isclose(eigenvalues, target, atol=tolerance))), + } + atoms = np.asarray([-target, 0.0, target]) + error = float(np.max(np.min(np.abs(eigenvalues[:, None] - atoms[None, :]), axis=1))) + return counts, error, eigenvalues.tolist() + + +def _one_sided_signature() -> HodgeSignature: + target = np.asarray([0.42, 0.27, 0.18, 0.09, 0.04]) + external = np.asarray([0.51, 0.31, 0.18]) + zero_target = np.zeros_like(target) + return HodgeSignature( + channel_count=8, + target_rank=5, + minus_weight=1.0, + plus_weight=0.0, + hodge_balance=0.0, + minus_channel_covariance=np.eye(8), + plus_channel_covariance=np.zeros((8, 8)), + minus_target_eigenvalues=target, + plus_target_eigenvalues=zero_target, + minus_external_eigenvalues=external, + plus_external_eigenvalues=np.empty(0), + minus_target_effective_rank=3.5, + plus_target_effective_rank=0.0, + minus_external_effective_rank=2.5, + plus_external_effective_rank=0.0, + minus_target_entropy=0.8, + plus_target_entropy=0.0, + minus_external_entropy=0.8, + plus_external_entropy=0.0, + orthogonality_relative_error=0.0, + ) + + +def generate_controls(output_json: Path = OUTPUT_JSON) -> dict[str, Any]: + """Write exact curvature atoms and immutable one-sided null regression.""" + + alpha = 1.7 + couplings6 = decomposable_couplings(6, alpha) + frame6 = solve_bps_frame(6, 3, couplings6, dense_cutoff=64) + tangents6 = np.stack( + [ + decomposable_tangent(6, "12", 3), + decomposable_tangent(6, "13", 4), + ] + ) + response6 = hodge_response(frame6, couplings6, tangents6) + diagonal_counts, diagonal_error, diagonal_eigenvalues = _atomic_summary( + decomposable_curvature(response6, 0), alpha + ) + off_counts, off_error, off_eigenvalues = _atomic_summary( + decomposable_curvature(response6, 0, 1), alpha + ) + expected_diagonal = analytic_decomposable_curvature_multiplicities( + 6, 3, "diagonal" + ) + expected_off = analytic_decomposable_curvature_multiplicities( + 6, 3, "off_diagonal" + ) + + couplings8 = decomposable_couplings(8, alpha) + rank8 = decomposable_bps_rank(8, 4) + frame8 = solve_bps_frame( + 8, + 4, + couplings8, + dense_cutoff=128, + expected_rank_override=rank8, + ) + + signature = _one_sided_signature() + hodge_reference = hodge_gaussian_r4_reference(signature, 8, 32, 211) + immutable_reference = gaussian_r4_reference( + signature.minus_target_eigenvalues, + signature.minus_external_eigenvalues, + 8, + 32, + 211, + ) + one_sided_difference = float( + np.max(np.abs(hodge_reference - immutable_reference)) + ) + checks = { + "N6_diagonal_multiplicities": diagonal_counts == expected_diagonal, + "N6_off_diagonal_multiplicities": off_counts == expected_off, + "N6_curvature_atoms": max(diagonal_error, off_error) < 2e-11, + "N8_decomposable_rank": frame8.projector_frame.shape[1] == rank8 == 60, + "N8_open_gap": frame8.gap > 1e-10, + "one_sided_exact_regression": one_sided_difference == 0.0, + } + payload = { + "version": VERSION, + "sources": _source_hashes(), + "decomposable_N6": { + "alpha": alpha, + "bps_rank": int(frame6.projector_frame.shape[1]), + "gap": float(frame6.gap), + "diagonal_multiplicities": diagonal_counts, + "off_diagonal_multiplicities": off_counts, + "diagonal_max_atom_error": diagonal_error, + "off_diagonal_max_atom_error": off_error, + "diagonal_eigenvalues": diagonal_eigenvalues, + "off_diagonal_eigenvalues": off_eigenvalues, + }, + "decomposable_N8": { + "bps_rank": int(frame8.projector_frame.shape[1]), + "expected_rank": rank8, + "gap": float(frame8.gap), + "kernel_residual": float(frame8.kernel_residual), + }, + "one_sided_regression": { + "samples": 32, + "seed": 211, + "max_absolute_difference": one_sided_difference, + }, + "checks": checks, + "passed": all(checks.values()), + } + if not payload["passed"]: + raise RuntimeError(f"SUSY/Hodge control audit failed: {checks}") + _atomic_json(output_json, payload) + return payload + + +def main() -> None: + payload = generate_controls() + print(json.dumps(payload, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/__init__.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/__init__.py new file mode 100644 index 000000000..cba872e98 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/__init__.py @@ -0,0 +1,117 @@ +"""Independent numerical core for the large-scale Geometric-ETH companion.""" + +from .channels import ( + PhysicalChannelCache, + build_physical_channel_cache, + cached_channel, + normalized_potential, + root_response_partition, +) +from .grassmann import covariance_deformed_rows +from .form_factors import ( + FormFactorParts, + JacobiFormFactor, + atom_raw_decomposition, + degenerate_energy_form_factor, + finite_jacobi_form_factor, + form_factor_parts, +) +from .controls import ( + FixedProjectorControl, + FourierTangentPair, + fixed_projector_spectral_ensemble, + fourier_tangent_pairs, + gram_normalize, + scrambled_tangent_pair, +) +from .jacobi import ( + NormalizedCurvature, + jacobi_parameters, + normalized_curvature, + sample_jacobi_interior, +) +from .manybody_response import ( + KernelFrame, + ManyBodyCase, + SiteResponseCache, + build_site_response_cache, + registered_fixed_two_qh_cases, + solve_kernel_frame, +) +from .wick_channels import ( + WickResult, + assemble_channels, + covariance_matched_wick, + fourier_density_panel, + gaussian_r4_reference, + local_density_panels, +) +from .bundle_geometry import ( + BundleGeometry, + analyze_ambient_frame_mesh, + analyze_frame_bundle, + manybody_frame_overlap, +) +from .twist_bundle import ( + TwistBundle, + build_twist_bundle, + load_twist_bundle, + save_twist_bundle, +) +from .holonomy import ( + ambient_unitary, + cue_wilson_reference, + deform_orbital_mesh, + local_generator_pair, + wilson_statistics, +) + +__all__ = [ + "FormFactorParts", + "BundleGeometry", + "FixedProjectorControl", + "FourierTangentPair", + "JacobiFormFactor", + "KernelFrame", + "ManyBodyCase", + "NormalizedCurvature", + "PhysicalChannelCache", + "SiteResponseCache", + "TwistBundle", + "WickResult", + "atom_raw_decomposition", + "analyze_ambient_frame_mesh", + "analyze_frame_bundle", + "ambient_unitary", + "assemble_channels", + "build_physical_channel_cache", + "build_site_response_cache", + "build_twist_bundle", + "cached_channel", + "covariance_deformed_rows", + "covariance_matched_wick", + "cue_wilson_reference", + "degenerate_energy_form_factor", + "deform_orbital_mesh", + "finite_jacobi_form_factor", + "fixed_projector_spectral_ensemble", + "form_factor_parts", + "fourier_tangent_pairs", + "fourier_density_panel", + "gaussian_r4_reference", + "gram_normalize", + "jacobi_parameters", + "local_density_panels", + "local_generator_pair", + "load_twist_bundle", + "manybody_frame_overlap", + "normalized_curvature", + "normalized_potential", + "registered_fixed_two_qh_cases", + "root_response_partition", + "sample_jacobi_interior", + "save_twist_bundle", + "scrambled_tangent_pair", + "solve_kernel_frame", + "wilson_statistics", +] diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/bundle_geometry.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/bundle_geometry.py new file mode 100644 index 000000000..75ae0bb4b --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/bundle_geometry.py @@ -0,0 +1,422 @@ +"""Gauge-covariant geometry of a degenerate bundle over a periodic mesh.""" + +from __future__ import annotations + +from dataclasses import dataclass +from functools import lru_cache +from math import factorial, prod, sqrt + +import numpy as np +from scipy.linalg import schur + +from .lattice import BosonBasis + + +@dataclass(frozen=True) +class BundleGeometry: + """Discrete links, curvature, topology, and noncontractible holonomy.""" + + link_x: np.ndarray + link_y: np.ndarray + plaquette: np.ndarray + plaquette_curvature: np.ndarray + wilson_x: np.ndarray + wilson_y: np.ndarray + wilson_x_phases: np.ndarray + wilson_y_phases: np.ndarray + chern_determinant: float + chern_trace_log: float + determinant_branch_margin: float + minimum_overlap_singular_value: float + maximum_link_unitarity_error: float + maximum_plaquette_unitarity_error: float + + +def polar_unitary(matrix: np.ndarray) -> tuple[np.ndarray, np.ndarray]: + """Return the polar unitary and singular values of a square overlap.""" + + values = np.asarray(matrix, dtype=complex) + if values.ndim != 2 or values.shape[0] != values.shape[1]: + raise ValueError("overlap matrix must be square") + left, singular_values, right_h = np.linalg.svd( + values, + full_matrices=False, + ) + return left @ right_h, singular_values + + +@lru_cache(maxsize=None) +def _ordered_particle_indices( + state: tuple[int, ...], +) -> tuple[tuple[int, ...], ...]: + particles = sum(state) + if particles == 0: + return ((),) + occupations = list(state) + result: list[tuple[int, ...]] = [] + + def visit(prefix: tuple[int, ...]) -> None: + if len(prefix) == particles: + result.append(prefix) + return + for orbital, population in enumerate(occupations): + if population == 0: + continue + occupations[orbital] -= 1 + visit((*prefix, orbital)) + occupations[orbital] += 1 + + visit(()) + return tuple(result) + + +def _occupation_tensor_amplitude(state: tuple[int, ...]) -> float: + return sqrt( + prod(factorial(population) for population in state) + / factorial(sum(state)) + ) + + +def apply_bosonic_fock_lift( + basis: BosonBasis, + single_particle_overlap: np.ndarray, + frames: np.ndarray, +) -> np.ndarray: + """Apply the symmetric bosonic lift of a one-particle overlap.""" + + overlap = np.asarray(single_particle_overlap, dtype=complex) + if overlap.shape != (basis.n_orbitals, basis.n_orbitals): + raise ValueError("single-particle overlap has the wrong shape") + coefficient_frames = np.asarray(frames, dtype=complex) + if coefficient_frames.ndim == 1: + coefficient_frames = coefficient_frames[:, None] + if ( + coefficient_frames.ndim != 2 + or coefficient_frames.shape[0] != basis.dimension + ): + raise ValueError("coefficient frames have the wrong shape") + particles = basis.n_particles + vectors = coefficient_frames.shape[1] + if particles == 0: + return coefficient_frames.copy() + tensor = np.zeros( + (basis.n_orbitals,) * particles + (vectors,), + dtype=complex, + ) + for state_index, state in enumerate(basis.states): + ordered = _ordered_particle_indices(state) + indices = tuple( + np.asarray( + [entry[axis] for entry in ordered], + dtype=int, + ) + for axis in range(particles) + ) + tensor[indices + (slice(None),)] = ( + _occupation_tensor_amplitude(state) + * coefficient_frames[state_index] + ) + transformed = tensor + for axis in range(particles): + transformed = np.tensordot( + overlap, + transformed, + axes=(1, axis), + ) + transformed = np.moveaxis(transformed, 0, axis) + result = np.empty( + (basis.dimension, vectors), + dtype=complex, + ) + for state_index, state in enumerate(basis.states): + ordered = _ordered_particle_indices(state) + indices = tuple( + np.asarray( + [entry[axis] for entry in ordered], + dtype=int, + ) + for axis in range(particles) + ) + result[state_index] = ( + _occupation_tensor_amplitude(state) + * np.sum( + transformed[indices + (slice(None),)], + axis=0, + ) + ) + return result + + +def manybody_frame_overlap( + basis: BosonBasis, + left_frame: np.ndarray, + right_frame: np.ndarray, + left_orbitals: np.ndarray, + right_orbitals: np.ndarray, +) -> np.ndarray: + """Return the physical overlap of two projected many-body frames.""" + + left_orbitals = np.asarray(left_orbitals, dtype=complex) + right_orbitals = np.asarray(right_orbitals, dtype=complex) + if left_orbitals.shape != right_orbitals.shape: + raise ValueError("orbital frames must have equal shape") + single_overlap = left_orbitals.conj().T @ right_orbitals + lifted_right = apply_bosonic_fock_lift( + basis, + single_overlap, + right_frame, + ) + return np.asarray(left_frame, dtype=complex).conj().T @ lifted_right + + +def _orthonormal_frame(frame: np.ndarray) -> np.ndarray: + values = np.asarray(frame, dtype=complex) + if values.ndim != 2 or values.shape[0] < values.shape[1]: + raise ValueError("frame must be a tall two-dimensional matrix") + orthonormal, _ = np.linalg.qr(values) + return orthonormal + + +def _curvature_from_unitary( + unitary: np.ndarray, + area: float, +) -> tuple[np.ndarray, np.ndarray]: + triangular, vectors = schur(unitary, output="complex") + phases = np.angle(np.diag(triangular)) + curvature = ( + vectors + @ np.diag(phases / area) + @ vectors.conj().T + ) + return 0.5 * (curvature + curvature.conj().T), phases + + +def _analyze_overlap_links( + overlaps_x: np.ndarray, + overlaps_y: np.ndarray, + delta_x: float, + delta_y: float, +) -> BundleGeometry: + if ( + overlaps_x.ndim != 4 + or overlaps_x.shape != overlaps_y.shape + or overlaps_x.shape[-1] != overlaps_x.shape[-2] + ): + raise ValueError("overlap arrays must have shape (nx, ny, D, D)") + nx, ny, rank, _ = overlaps_x.shape + link_x = np.empty_like(overlaps_x, dtype=complex) + link_y = np.empty_like(overlaps_y, dtype=complex) + minimum_singular = np.inf + maximum_link_error = 0.0 + identity = np.eye(rank, dtype=complex) + for ix in range(nx): + for iy in range(ny): + link_x[ix, iy], singular_x = polar_unitary( + overlaps_x[ix, iy] + ) + link_y[ix, iy], singular_y = polar_unitary( + overlaps_y[ix, iy] + ) + minimum_singular = min( + minimum_singular, + float(np.min(singular_x)), + float(np.min(singular_y)), + ) + maximum_link_error = max( + maximum_link_error, + float( + np.linalg.norm( + link_x[ix, iy].conj().T + @ link_x[ix, iy] + - identity + ) + ), + float( + np.linalg.norm( + link_y[ix, iy].conj().T + @ link_y[ix, iy] + - identity + ) + ), + ) + plaquette = np.empty_like(link_x) + curvature = np.empty_like(link_x) + determinant_flux = 0.0 + trace_log_flux = 0.0 + maximum_plaquette_error = 0.0 + maximum_trace_phase = 0.0 + area = float(delta_x * delta_y) + for ix in range(nx): + for iy in range(ny): + loop = ( + link_x[ix, iy] + @ link_y[(ix + 1) % nx, iy] + @ link_x[ix, (iy + 1) % ny].conj().T + @ link_y[ix, iy].conj().T + ) + loop, _ = polar_unitary(loop) + plaquette[ix, iy] = loop + maximum_plaquette_error = max( + maximum_plaquette_error, + float( + np.linalg.norm( + loop.conj().T @ loop - identity + ) + ), + ) + curvature[ix, iy], phases = _curvature_from_unitary( + loop, + area, + ) + trace_phase = float(np.sum(phases)) + determinant_phase = float( + np.angle(np.exp(1j * trace_phase)) + ) + determinant_flux += determinant_phase + trace_log_flux += trace_phase + maximum_trace_phase = max( + maximum_trace_phase, + abs(trace_phase), + ) + wilson_x = np.empty((ny, rank, rank), dtype=complex) + wilson_y = np.empty((nx, rank, rank), dtype=complex) + wilson_x_phases = np.empty((ny, rank), dtype=float) + wilson_y_phases = np.empty((nx, rank), dtype=float) + for iy in range(ny): + loop = identity.copy() + for ix in range(nx): + loop = loop @ link_x[ix, iy] + loop, _ = polar_unitary(loop) + wilson_x[iy] = loop + wilson_x_phases[iy] = np.sort(np.angle(np.linalg.eigvals(loop))) + for ix in range(nx): + loop = identity.copy() + for iy in range(ny): + loop = loop @ link_y[ix, iy] + loop, _ = polar_unitary(loop) + wilson_y[ix] = loop + wilson_y_phases[ix] = np.sort(np.angle(np.linalg.eigvals(loop))) + return BundleGeometry( + link_x=link_x, + link_y=link_y, + plaquette=plaquette, + plaquette_curvature=curvature, + wilson_x=wilson_x, + wilson_y=wilson_y, + wilson_x_phases=wilson_x_phases, + wilson_y_phases=wilson_y_phases, + chern_determinant=determinant_flux / (2.0 * np.pi), + chern_trace_log=trace_log_flux / (2.0 * np.pi), + determinant_branch_margin=float(np.pi - maximum_trace_phase), + minimum_overlap_singular_value=float(minimum_singular), + maximum_link_unitarity_error=maximum_link_error, + maximum_plaquette_unitarity_error=maximum_plaquette_error, + ) + + +def analyze_ambient_frame_mesh( + frames: np.ndarray, +) -> BundleGeometry: + """Analyze a periodic ambient-frame mesh.""" + + values = np.asarray(frames, dtype=complex) + if values.ndim != 4: + raise ValueError("frames must have shape (nx, ny, ambient, rank)") + nx, ny, _, rank = values.shape + normalized = np.empty_like(values) + for ix in range(nx): + for iy in range(ny): + normalized[ix, iy] = _orthonormal_frame(values[ix, iy]) + overlaps_x = np.empty((nx, ny, rank, rank), dtype=complex) + overlaps_y = np.empty_like(overlaps_x) + for ix in range(nx): + for iy in range(ny): + frame = normalized[ix, iy] + overlaps_x[ix, iy] = ( + frame.conj().T @ normalized[(ix + 1) % nx, iy] + ) + overlaps_y[ix, iy] = ( + frame.conj().T @ normalized[ix, (iy + 1) % ny] + ) + return _analyze_overlap_links( + overlaps_x, + overlaps_y, + 2.0 * np.pi / nx, + 2.0 * np.pi / ny, + ) + + +def analyze_frame_bundle( + coefficient_frames: np.ndarray, + orbital_frames: np.ndarray, + basis: BosonBasis, +) -> BundleGeometry: + """Analyze physical many-body frames whose orbital bases vary on a mesh.""" + + coefficients = np.asarray(coefficient_frames, dtype=complex) + orbitals = np.asarray(orbital_frames, dtype=complex) + if ( + coefficients.ndim != 4 + or orbitals.ndim != 4 + or coefficients.shape[:2] != orbitals.shape[:2] + or coefficients.shape[2] != basis.dimension + or orbitals.shape[-1] != basis.n_orbitals + ): + raise ValueError("coefficient/orbital frame meshes are incompatible") + nx, ny, _, rank = coefficients.shape + overlaps_x = np.empty((nx, ny, rank, rank), dtype=complex) + overlaps_y = np.empty_like(overlaps_x) + for ix in range(nx): + for iy in range(ny): + overlaps_x[ix, iy] = manybody_frame_overlap( + basis, + coefficients[ix, iy], + coefficients[(ix + 1) % nx, iy], + orbitals[ix, iy], + orbitals[(ix + 1) % nx, iy], + ) + overlaps_y[ix, iy] = manybody_frame_overlap( + basis, + coefficients[ix, iy], + coefficients[ix, (iy + 1) % ny], + orbitals[ix, iy], + orbitals[ix, (iy + 1) % ny], + ) + return _analyze_overlap_links( + overlaps_x, + overlaps_y, + 2.0 * np.pi / nx, + 2.0 * np.pi / ny, + ) + + +def random_local_gauge( + frames: np.ndarray, + seed: int, +) -> np.ndarray: + """Apply independent local frame gauges on a periodic mesh.""" + + values = np.asarray(frames, dtype=complex) + if values.ndim != 4: + raise ValueError("frames must have shape (nx, ny, ambient, rank)") + rng = np.random.default_rng(int(seed)) + result = np.empty_like(values) + rank = values.shape[-1] + for ix in range(values.shape[0]): + for iy in range(values.shape[1]): + matrix = rng.normal(size=(rank, rank)) + matrix = matrix + 1j * rng.normal(size=matrix.shape) + unitary, _ = np.linalg.qr(matrix) + result[ix, iy] = values[ix, iy] @ unitary + return result + + +def sorted_wilson_eigenphases( + geometry: BundleGeometry, +) -> np.ndarray: + """Return both noncontractible Wilson-loop phase spectra.""" + + return np.concatenate( + [geometry.wilson_x_phases, geometry.wilson_y_phases], + axis=0, + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/channels.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/channels.py new file mode 100644 index 000000000..2708f6c0d --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/channels.py @@ -0,0 +1,230 @@ +"""Model-independent channel geometry and exact nullity accounting.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any + +import numpy as np + +from .combinatorics import laughlin_zero_mode_count, root_descendant_partition +from .lattice import ( + build_kapit_laughlin_parent, + channel_matrix, + manybody_one_body_operator, + projected_site_potential, +) + + +@dataclass(frozen=True) +class NullityDecomposition: + """Accessibility and pulled-back-form contributions to curvature nullity.""" + + target_dimension: int + active_rank: int + curvature_rank: int + total: int + accessibility: int + form: int + active_cutoff: float + curvature_cutoff: float + + +@dataclass(frozen=True) +class PhysicalChannelCache: + """Task-local factorization of the physical tangent-to-channel map.""" + + N: int + n_flux: int + rank: int + external_dimension: int + energies: np.ndarray + tangent_basis: np.ndarray + channel_basis: np.ndarray + tangent_gram: np.ndarray + external_gap: float + kernel_bandwidth: float + metadata: dict[str, Any] + + +def build_physical_channel_cache( + n_particles: int = 3, + n_flux: int = 10, + theta_x: float = 0.17, + theta_y: float = 0.29, +) -> PhysicalChannelCache: + """Build the fixed Kapit--Mueller tangent-channel cache independently.""" + + N = int(n_particles) + n = int(n_flux) + system = build_kapit_laughlin_parent(N, n, theta_x, theta_y) + parent = system.parent.toarray() + energies, vectors = np.linalg.eigh(0.5 * (parent + parent.conj().T)) + rank = laughlin_zero_mode_count(N, n) + energies_p = energies[:rank] + energies_q = energies[rank:] + vectors_p = vectors[:, :rank] + vectors_q = vectors[:, rank:] + physical_sites = system.orbitals.shape[0] + tangent_basis = np.empty( + (physical_sites, system.basis.dimension, system.basis.dimension), + dtype=complex, + ) + channel_basis = np.empty( + (physical_sites, rank, system.basis.dimension - rank), + dtype=complex, + ) + for site in range(physical_sites): + potential = np.zeros(physical_sites, dtype=float) + potential[site] = 1.0 + projected = projected_site_potential(system.orbitals, potential) + tangent = manybody_one_body_operator(system.basis, projected) + tangent_basis[site] = tangent.toarray() + channel_basis[site] = channel_matrix( + energies_p, + vectors_p, + energies_q, + vectors_q, + tangent, + ) + tangent_gram = np.einsum( + "iab,jab->ij", + tangent_basis.conj(), + tangent_basis, + optimize=True, + ).real + return PhysicalChannelCache( + N=N, + n_flux=n, + rank=rank, + external_dimension=system.basis.dimension - rank, + energies=energies, + tangent_basis=tangent_basis, + channel_basis=channel_basis, + tangent_gram=tangent_gram, + external_gap=float(energies_q[0] - energies_p[-1]), + kernel_bandwidth=float(np.ptp(energies_p)), + metadata={ + "theta_x": float(theta_x), + "theta_y": float(theta_y), + "basis_dimension": int(system.basis.dimension), + "physical_sites": int(physical_sites), + }, + ) + + +def normalized_potential( + rng: np.random.Generator, + sites: int, +) -> np.ndarray: + """Draw a mean-zero unit vector of local-potential coefficients.""" + + values = rng.normal(size=int(sites)) + values -= np.mean(values) + norm = float(np.linalg.norm(values)) + if norm <= 0.0: + raise RuntimeError("local potential has zero norm") + return values / norm + + +def cached_channel( + coefficients: np.ndarray, + cache: PhysicalChannelCache, +) -> np.ndarray: + """Evaluate and Hilbert--Schmidt normalize a cached physical channel.""" + + vector = np.asarray(coefficients, dtype=float) + norm_squared = float(vector @ cache.tangent_gram @ vector) + if norm_squared <= 0.0: + raise RuntimeError("many-body tangent has zero norm") + return ( + np.tensordot(vector, cache.channel_basis, axes=(0, 0)) + / np.sqrt(norm_squared) + ) + + +def root_response_partition(N: int, n: int): + """Return the exact first-descendant root partition.""" + + return root_descendant_partition(int(N), int(n), q=1, k=1, r=2) + + +def _validated_channel_pair( + channel_v: np.ndarray, + channel_w: np.ndarray, +) -> tuple[np.ndarray, np.ndarray]: + x = np.asarray(channel_v, dtype=complex) + y = np.asarray(channel_w, dtype=complex) + if x.ndim != 2 or y.ndim != 2: + raise ValueError("channels must be two-dimensional") + if x.shape != y.shape: + raise ValueError("channels must have equal shape") + if x.shape[0] == 0 or x.shape[1] == 0: + raise ValueError("channels must be nonempty") + return x, y + + +def curvature_from_channels( + channel_v: np.ndarray, + channel_w: np.ndarray, +) -> np.ndarray: + """Return the Hermitian non-Abelian curvature channel form.""" + + x, y = _validated_channel_pair(channel_v, channel_w) + curvature = 1j * (x @ y.conj().T - y @ x.conj().T) + return 0.5 * (curvature + curvature.conj().T) + + +def _rank_with_cutoff( + matrix: np.ndarray, + rtol: float, + atol: float, +) -> tuple[int, float]: + if rtol < 0.0 or atol < 0.0: + raise ValueError("rank tolerances must be nonnegative") + singular_values = np.linalg.svd( + np.asarray(matrix, dtype=complex), + compute_uv=False, + ) + if singular_values.size == 0: + return 0, float(atol) + cutoff = max(float(atol), float(rtol) * float(singular_values[0])) + return int(np.count_nonzero(singular_values > cutoff)), cutoff + + +def nullity_decomposition( + channel_v: np.ndarray, + channel_w: np.ndarray, + rtol: float = 1e-12, + atol: float = 0.0, +) -> NullityDecomposition: + """Return the exact rank-nullity split at a specified numerical tolerance.""" + + x, y = _validated_channel_pair(channel_v, channel_w) + stacked = np.concatenate([x, y], axis=1) + active_rank, active_cutoff = _rank_with_cutoff( + stacked, + rtol=rtol, + atol=atol, + ) + curvature = curvature_from_channels(x, y) + curvature_rank, curvature_cutoff = _rank_with_cutoff( + curvature, + rtol=rtol, + atol=atol, + ) + target_dimension = x.shape[0] + accessibility = target_dimension - active_rank + form = active_rank - curvature_rank + if accessibility < 0 or form < 0: + raise RuntimeError("rank accounting produced a negative nullity") + return NullityDecomposition( + target_dimension=target_dimension, + active_rank=active_rank, + curvature_rank=curvature_rank, + total=target_dimension - curvature_rank, + accessibility=accessibility, + form=form, + active_cutoff=active_cutoff, + curvature_cutoff=curvature_cutoff, + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/combinatorics.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/combinatorics.py new file mode 100644 index 000000000..7f35e3aee --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/combinatorics.py @@ -0,0 +1,223 @@ +"""Exact root combinatorics for geometric-accessibility filtrations.""" + +from __future__ import annotations + +from dataclasses import dataclass +from functools import lru_cache +from math import comb +from typing import Iterator + + +Occupation = tuple[int, ...] + + +@dataclass(frozen=True) +class RootPartition: + """Partition a fixed-particle root space by deletion accessibility.""" + + n_particles: int + n_flux: int + q: int + k: int + r: int + states: tuple[Occupation, ...] + zero_modes: tuple[int, ...] + descendants: tuple[int, ...] + descendant_external: tuple[int, ...] + primitive: tuple[int, ...] + + +def occupation_states( + n_particles: int, + n_orbitals: int, +) -> Iterator[Occupation]: + """Yield weak compositions in deterministic lexicographic order.""" + + particles = int(n_particles) + orbitals = int(n_orbitals) + if particles < 0: + raise ValueError("n_particles must be nonnegative") + if orbitals <= 0: + raise ValueError("n_orbitals must be positive") + + def recurse(remaining: int, length: int) -> Iterator[Occupation]: + if length == 1: + yield (remaining,) + return + for population in range(remaining + 1): + for suffix in recurse(remaining - population, length - 1): + yield (population,) + suffix + + yield from recurse(particles, orbitals) + + +def cyclic_kr_admissible( + state: Occupation, + k: int, + r: int, +) -> bool: + """Return whether every cyclic window of length ``r`` contains at most ``k``.""" + + if not state: + raise ValueError("state must be nonempty") + cluster = int(k) + window = int(r) + if cluster < 0: + raise ValueError("k must be nonnegative") + if window <= 0 or window > len(state): + raise ValueError("r must lie between one and the orbital count") + return all( + sum( + state[(start + offset) % len(state)] + for offset in range(window) + ) + <= cluster + for start in range(len(state)) + ) + + +def _validate_laughlin_domain( + n_particles: int, + n_flux: int, +) -> tuple[int, int]: + particles = int(n_particles) + flux = int(n_flux) + if particles <= 0: + raise ValueError("n_particles must be positive") + if flux < 2 * particles: + raise ValueError("n_flux must be at least 2*n_particles") + return particles, flux + + +def laughlin_zero_mode_count( + n_particles: int, + n_flux: int, +) -> int: + """Return the cyclic bosonic Laughlin ``(1,2)`` root count.""" + + particles, flux = _validate_laughlin_domain( + n_particles, + n_flux, + ) + return ( + flux + * comb(flux - particles, particles) + // (flux - particles) + ) + + +def laughlin_onebody_capacity( + n_particles: int, + n_flux: int, +) -> int: + """Return ``dim(W_N^(1)/P_N)`` for cyclic Laughlin roots.""" + + particles, flux = _validate_laughlin_domain( + n_particles, + n_flux, + ) + if particles == 1: + return 0 + return 2 * flux * comb(flux - particles, particles - 2) + + +def _bounded_removals( + state: Occupation, + total: int, +) -> Iterator[Occupation]: + """Yield occupation removals bounded componentwise by ``state``.""" + + target = int(total) + + def recurse( + orbital: int, + remaining: int, + prefix: Occupation, + ) -> Iterator[Occupation]: + if orbital == len(state): + if remaining == 0: + yield prefix + return + maximum = min(state[orbital], remaining) + for removed in range(maximum + 1): + yield from recurse( + orbital + 1, + remaining - removed, + prefix + (removed,), + ) + + yield from recurse(0, target, ()) + + +@lru_cache(maxsize=None) +def _deletion_accessible( + state: Occupation, + q: int, + k: int, + r: int, +) -> bool: + for removal in _bounded_removals(state, q): + reduced = tuple( + population - removed + for population, removed in zip(state, removal, strict=True) + ) + if cyclic_kr_admissible(reduced, k=k, r=r): + return True + return False + + +def root_descendant_partition( + n_particles: int, + n_flux: int, + q: int, + k: int = 1, + r: int = 2, +) -> RootPartition: + """Partition roots by whether deleting ``q`` particles leaves an admissible root.""" + + particles = int(n_particles) + flux = int(n_flux) + body_order = int(q) + if particles <= 0: + raise ValueError("n_particles must be positive") + if flux <= 0: + raise ValueError("n_flux must be positive") + if body_order < 0 or body_order > particles: + raise ValueError("q must lie between zero and n_particles") + if r > flux: + raise ValueError("r cannot exceed n_flux") + + states = tuple(occupation_states(particles, flux)) + zero_modes = tuple( + index + for index, state in enumerate(states) + if cyclic_kr_admissible(state, k=k, r=r) + ) + descendants = tuple( + index + for index, state in enumerate(states) + if _deletion_accessible( + state, + q=body_order, + k=int(k), + r=int(r), + ) + ) + zero_set = set(zero_modes) + descendant_set = set(descendants) + descendant_external = tuple(sorted(descendant_set - zero_set)) + primitive = tuple( + sorted(set(range(len(states))) - descendant_set) + ) + return RootPartition( + n_particles=particles, + n_flux=flux, + q=body_order, + k=int(k), + r=int(r), + states=states, + zero_modes=zero_modes, + descendants=descendants, + descendant_external=descendant_external, + primitive=primitive, + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/controls.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/controls.py new file mode 100644 index 000000000..bbfe6ce60 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/controls.py @@ -0,0 +1,341 @@ +"""Independent interventions for spectral and projector-geometric chaos.""" + +from __future__ import annotations + +from dataclasses import dataclass + +import numpy as np + +from .form_factors import form_factor_parts +from .statistics import bulk_gap_ratio_per_spectrum + + +@dataclass(frozen=True) +class FourierTangentPair: + """Momentum-resolved real quadratures on a square physical lattice.""" + + length: int + kx: int + ky: int + orbit_key: tuple[int, int] + v: np.ndarray + w: np.ndarray + + +@dataclass(frozen=True) +class FixedProjectorControl: + """Energy statistics varied inside one exactly fixed target projector.""" + + alphas: np.ndarray + times: np.ndarray + energy_spectra: np.ndarray + mean_gap_ratio: np.ndarray + energy_raw: np.ndarray + energy_disconnected: np.ndarray + energy_connected: np.ndarray + projector_distance: np.ndarray + curvature_spectrum_error: np.ndarray + seed: int + + +def fourier_tangent_pairs(length: int) -> list[FourierTangentPair]: + """Return every nonzero momentum cosine/sine pair exactly once.""" + + linear_size = int(length) + if linear_size < 3 or linear_size % 2 == 0: + raise ValueError("length must be an odd integer at least three") + coordinates = np.asarray( + [ + (x, y) + for y in range(linear_size) + for x in range(linear_size) + ], + dtype=float, + ) + pairs: list[FourierTangentPair] = [] + for ky in range(linear_size): + for kx in range(linear_size): + if (kx, ky) == (0, 0): + continue + phase = ( + 2.0 + * np.pi + * ( + kx * coordinates[:, 0] + + ky * coordinates[:, 1] + ) + / linear_size + ) + v = np.cos(phase) + w = np.sin(phase) + v -= np.mean(v) + w -= np.mean(w) + norm_v = float(np.linalg.norm(v)) + norm_w = float(np.linalg.norm(w)) + if norm_v <= 1e-14 or norm_w <= 1e-14: + raise RuntimeError("nonzero momentum has a null real quadrature") + v /= norm_v + w /= norm_w + inverse = ( + (-kx) % linear_size, + (-ky) % linear_size, + ) + orbit_key = min((kx, ky), inverse) + pairs.append( + FourierTangentPair( + length=linear_size, + kx=kx, + ky=ky, + orbit_key=orbit_key, + v=v, + w=w, + ) + ) + return pairs + + +def _validated_tangent_gram( + tangent_gram: np.ndarray, + dimension: int, +) -> np.ndarray: + gram = np.asarray(tangent_gram, dtype=float) + if gram.shape != (dimension, dimension): + raise ValueError("tangent_gram has the wrong shape") + if np.any(~np.isfinite(gram)): + raise ValueError("tangent_gram must be finite") + gram = 0.5 * (gram + gram.T) + eigenvalues = np.linalg.eigvalsh(gram) + if float(eigenvalues[0]) < -1e-10 * max( + float(eigenvalues[-1]), + 1.0, + ): + raise ValueError("tangent_gram must be positive semidefinite") + return gram + + +def gram_normalize( + values: np.ndarray, + tangent_gram: np.ndarray, +) -> np.ndarray: + """Mean-center and normalize a coefficient vector in the tangent Gram.""" + + vector = np.asarray(values, dtype=float) + if vector.ndim != 1 or vector.size < 2 or np.any(~np.isfinite(vector)): + raise ValueError("tangent coefficients must be a finite vector") + gram = _validated_tangent_gram(tangent_gram, vector.size) + centered = vector - np.mean(vector) + norm_squared = float(centered @ gram @ centered) + if norm_squared <= 1e-24: + raise ValueError("tangent coefficients have zero Gram norm") + return centered / np.sqrt(norm_squared) + + +def scrambled_tangent_pair( + pair: FourierTangentPair, + random_v: np.ndarray, + random_w: np.ndarray, + g: float, + tangent_gram: np.ndarray, +) -> tuple[np.ndarray, np.ndarray]: + """Interpolate from a structured momentum pair to random local tangents.""" + + coupling = float(g) + if not 0.0 <= coupling <= 1.0: + raise ValueError("g must lie in [0,1]") + if pair.v.shape != pair.w.shape: + raise ValueError("Fourier tangent pair has inconsistent shapes") + gram = _validated_tangent_gram(tangent_gram, pair.v.size) + structured_v = gram_normalize(pair.v, gram) + structured_w = gram_normalize(pair.w, gram) + residual_v = gram_normalize(random_v, gram) + residual_w = gram_normalize(random_w, gram) + mixed_v = ( + np.sqrt(1.0 - coupling) * structured_v + + np.sqrt(coupling) * residual_v + ) + mixed_w = ( + np.sqrt(1.0 - coupling) * structured_w + + np.sqrt(coupling) * residual_w + ) + return ( + gram_normalize(mixed_v, gram), + gram_normalize(mixed_w, gram), + ) + + +def _center_and_normalize_hermitian(matrix: np.ndarray) -> np.ndarray: + values = np.asarray(matrix, dtype=complex) + if values.ndim != 2 or values.shape[0] != values.shape[1]: + raise ValueError("matrix must be square") + values = 0.5 * (values + values.conj().T) + values -= np.trace(values) / values.shape[0] * np.eye( + values.shape[0], + dtype=complex, + ) + norm = float(np.linalg.norm(values)) + if norm <= 1e-14: + raise RuntimeError("Hermitian control has zero norm") + return values / norm + + +def _numerical_projector_distance( + target_block: np.ndarray, +) -> float: + dimension = int(target_block.shape[0]) + full = np.zeros((2 * dimension, 2 * dimension), dtype=complex) + full[:dimension, :dimension] = 0.1 * target_block + full[dimension:, dimension:] = np.diag( + np.linspace(2.0, 3.0, dimension) + ) + eigenvalues, eigenvectors = np.linalg.eigh(full) + if float(eigenvalues[dimension - 1]) >= float(eigenvalues[dimension]): + raise RuntimeError("fixed-projector control closed its external gap") + observed = ( + eigenvectors[:, :dimension] + @ eigenvectors[:, :dimension].conj().T + ) + expected = np.zeros_like(full) + expected[:dimension, :dimension] = np.eye(dimension) + return float(np.linalg.norm(observed - expected)) + + +def projector_curvature_invariance( + reference_spectrum: np.ndarray, + repeated_spectra: np.ndarray, +) -> dict[str, float]: + """Return maximum absolute and relative errors of repeated curvature data.""" + + reference = np.asarray(reference_spectrum, dtype=float) + repeated = np.asarray(repeated_spectra, dtype=float) + if reference.ndim != 1 or repeated.ndim != 2: + raise ValueError("reference must be 1D and repeated_spectra must be 2D") + if repeated.shape[1] != reference.size: + raise ValueError("curvature spectra have incompatible dimensions") + difference = repeated - reference[None, :] + absolute = float(np.max(np.abs(difference))) + scale = max(float(np.max(np.abs(reference))), 1e-15) + return { + "maximum_absolute_error": absolute, + "maximum_relative_error": absolute / scale, + } + + +def fixed_projector_spectral_ensemble( + dimension: int, + samples: int, + alphas: np.ndarray, + seed: int, + reference_curvature_spectrum: np.ndarray | None = None, + times: np.ndarray | None = None, +) -> FixedProjectorControl: + """Generate a Poisson-to-GUE interpolation inside one fixed projector.""" + + rank = int(dimension) + count = int(samples) + alpha_grid = np.asarray(alphas, dtype=float) + time_grid = ( + np.linspace(0.0, 3.0, 61) + if times is None + else np.asarray(times, dtype=float) + ) + if rank < 4 or count < 2: + raise ValueError("require dimension>=4 and samples>=2") + if ( + alpha_grid.ndim != 1 + or alpha_grid.size < 1 + or np.any(~np.isfinite(alpha_grid)) + or np.any((alpha_grid < 0.0) | (alpha_grid > 1.0)) + ): + raise ValueError("alphas must be a finite one-dimensional grid in [0,1]") + if ( + time_grid.ndim != 1 + or time_grid.size < 1 + or np.any(~np.isfinite(time_grid)) + ): + raise ValueError("times must be a finite one-dimensional grid") + if reference_curvature_spectrum is None: + reference = np.linspace(-1.0, 1.0, rank) + else: + reference = np.asarray( + reference_curvature_spectrum, + dtype=float, + ) + if reference.shape != (rank,) or np.any(~np.isfinite(reference)): + raise ValueError("reference_curvature_spectrum must match dimension") + rng = np.random.default_rng(int(seed)) + spectra = np.empty( + (alpha_grid.size, count, rank), + dtype=np.float32, + ) + first_matrices = np.empty( + (alpha_grid.size, rank, rank), + dtype=complex, + ) + for sample in range(count): + spacings = rng.exponential(size=rank) + levels = np.cumsum(spacings) + poisson_matrix = _center_and_normalize_hermitian( + np.diag(levels) + ) + gaussian = ( + rng.normal(size=(rank, rank)) + + 1j * rng.normal(size=(rank, rank)) + ) + gue_matrix = _center_and_normalize_hermitian( + gaussian + gaussian.conj().T + ) + for index, alpha in enumerate(alpha_grid): + matrix = ( + np.sqrt(1.0 - alpha * alpha) * poisson_matrix + + alpha * gue_matrix + ) + spectra[index, sample] = np.linalg.eigvalsh(matrix) + if sample == 0: + first_matrices[index] = matrix + mean_gap_ratio = np.empty(alpha_grid.size, dtype=float) + raw = np.empty((alpha_grid.size, time_grid.size), dtype=float) + disconnected = np.empty_like(raw) + connected = np.empty_like(raw) + projector_distance = np.empty(alpha_grid.size, dtype=float) + repeated_curvature = np.repeat( + reference[None, :], + alpha_grid.size, + axis=0, + ) + for index, alpha in enumerate(alpha_grid): + mean_gap_ratio[index] = float( + np.mean( + bulk_gap_ratio_per_spectrum( + spectra[index], + bulk_fraction=0.7, + ) + ) + ) + parts = form_factor_parts(spectra[index], time_grid) + raw[index] = parts.raw + disconnected[index] = parts.disconnected + connected[index] = parts.connected + projector_distance[index] = _numerical_projector_distance( + first_matrices[index] + ) + invariance = projector_curvature_invariance( + reference, + repeated_curvature, + ) + curvature_error = np.full( + alpha_grid.size, + invariance["maximum_absolute_error"], + dtype=float, + ) + return FixedProjectorControl( + alphas=alpha_grid, + times=time_grid, + energy_spectra=spectra, + mean_gap_ratio=mean_gap_ratio, + energy_raw=raw, + energy_disconnected=disconnected, + energy_connected=connected, + projector_distance=projector_distance, + curvature_spectrum_error=curvature_error, + seed=int(seed), + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/form_factors.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/form_factors.py new file mode 100644 index 000000000..91af82f21 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/form_factors.py @@ -0,0 +1,272 @@ +"""Exact and empirical form factors for degenerate quantum geometry.""" + +from __future__ import annotations + +from dataclasses import dataclass + +import numpy as np +from scipy.special import eval_jacobi, gammaln, roots_jacobi + +from .jacobi import jacobi_parameters + + +@dataclass(frozen=True) +class FormFactorParts: + """Raw, disconnected, and connected form-factor components.""" + + raw: np.ndarray + disconnected: np.ndarray + connected: np.ndarray + normalization: int + + +@dataclass(frozen=True) +class JacobiFormFactor: + """Finite-dimensional connected Jacobi form factor.""" + + times: np.ndarray + connected_continuous: np.ndarray + connected_full: np.ndarray + plateau_full: float + unfolded_nodes: np.ndarray + quadrature_order: int + interior_dimension: int + atom_count_each: int + rank: int + channels: int + exponent: int + mass_error: float + orthogonality_error: float + + +def _validated_spectra_times( + spectra: np.ndarray, + times: np.ndarray, +) -> tuple[np.ndarray, np.ndarray]: + values = np.asarray(spectra, dtype=float) + grid = np.asarray(times, dtype=float) + if ( + values.ndim != 2 + or values.shape[0] < 1 + or values.shape[1] < 1 + or np.any(~np.isfinite(values)) + ): + raise ValueError("spectra must be a finite nonempty two-dimensional array") + if grid.ndim != 1 or grid.size < 1 or np.any(~np.isfinite(grid)): + raise ValueError("times must be a finite nonempty one-dimensional array") + return values, grid + + +def form_factor_parts( + spectra: np.ndarray, + times: np.ndarray, + phase_scale: float = 2.0 * np.pi, +) -> FormFactorParts: + """Return one consistently normalized form-factor decomposition.""" + + values, grid = _validated_spectra_times(spectra, times) + scale = float(phase_scale) + if not np.isfinite(scale): + raise ValueError("phase_scale must be finite") + levels = int(values.shape[1]) + partition = np.empty((values.shape[0], grid.size), dtype=np.complex128) + for start in range(0, values.shape[0], 512): + stop = min(start + 512, values.shape[0]) + phases = np.exp( + -1j + * scale + * values[start:stop, :, None] + * grid[None, None, :] + ) + partition[start:stop] = np.sum(phases, axis=1) + raw = np.mean(np.abs(partition) ** 2, axis=0) / levels + disconnected = np.abs(np.mean(partition, axis=0)) ** 2 / levels + connected = raw - disconnected + connected[np.abs(connected) < 5e-15] = 0.0 + return FormFactorParts( + raw=raw, + disconnected=disconnected, + connected=connected, + normalization=levels, + ) + + +def degenerate_energy_form_factor( + dimension: int, + times: np.ndarray, +) -> FormFactorParts: + """Return the exact centered SFF of a rank-``dimension`` flat band.""" + + rank = int(dimension) + if rank < 1: + raise ValueError("dimension must be positive") + spectra = np.zeros((2, rank), dtype=float) + return form_factor_parts(spectra, times, phase_scale=1.0) + + +def _log_jacobi_norm(order: int, exponent: int) -> float: + degree = int(order) + alpha = int(exponent) + return float( + (2 * alpha + 1) * np.log(2.0) + - np.log(2 * degree + 2 * alpha + 1) + + 2 * gammaln(degree + alpha + 1) + - gammaln(degree + 1) + - gammaln(degree + 2 * alpha + 1) + ) + + +def _weighted_jacobi_projector( + interior_dimension: int, + exponent: int, + quadrature_order: int, +) -> tuple[np.ndarray, np.ndarray, float, float]: + k = int(interior_dimension) + alpha = int(exponent) + order = int(quadrature_order) + if k < 1: + raise ValueError("interior_dimension must be positive") + if alpha < 0: + raise ValueError("exponent must be nonnegative") + if order < max(32, k): + raise ValueError("quadrature_order must be at least max(32,k)") + nodes, weights = roots_jacobi(order, alpha, alpha) + basis = np.empty((order, k), dtype=float) + square_root_weights = np.sqrt(weights) + for degree in range(k): + polynomial = eval_jacobi(degree, alpha, alpha, nodes) + basis[:, degree] = ( + square_root_weights + * polynomial + * np.exp(-0.5 * _log_jacobi_norm(degree, alpha)) + ) + if np.any(~np.isfinite(basis)): + raise RuntimeError("nonfinite orthonormal Jacobi basis") + gram = basis.T @ basis + orthogonality_error = float( + np.max(np.abs(gram - np.eye(k, dtype=float))) + ) + if orthogonality_error > 2e-8: + raise RuntimeError( + "Gauss--Jacobi basis failed orthogonality: " + f"{orthogonality_error:.3e}" + ) + projector = basis @ basis.T + density_mass = np.diag(projector) + mass_error = float(abs(np.sum(density_mass) - k)) + if mass_error > 2e-8: + raise RuntimeError( + f"Jacobi quadrature mass failed: {mass_error:.3e}" + ) + unfolded_nodes = np.cumsum(density_mass) - 0.5 * density_mass + return projector, unfolded_nodes, mass_error, orthogonality_error + + +def finite_jacobi_form_factor( + r: int, + M: int, + times: np.ndarray, + quadrature_order: int = 512, +) -> JacobiFormFactor: + """Return the exact finite-rank unfolded complex-Jacobi connected SFF.""" + + parameters = jacobi_parameters(r, M) + grid = np.asarray(times, dtype=float) + if ( + grid.ndim != 1 + or grid.size < 1 + or np.any(~np.isfinite(grid)) + or np.any(grid < 0.0) + ): + raise ValueError("times must be a finite nonnegative one-dimensional grid") + k = int(parameters.interior_dimension) + if k < 1: + raise ValueError("the continuous Jacobi sector is empty") + projector, unfolded, mass_error, orthogonality_error = ( + _weighted_jacobi_projector( + k, + parameters.exponent, + quadrature_order, + ) + ) + cluster_kernel = np.abs(projector) ** 2 + continuous = np.empty(grid.size, dtype=float) + for index, time in enumerate(grid): + phase = np.exp(-2j * np.pi * float(time) * unfolded) + cluster = float( + np.real(np.vdot(phase, cluster_kernel @ phase)) + ) + value = 1.0 - cluster / k + if -5e-11 < value < 0.0: + value = 0.0 + continuous[index] = value + atom_count = int(parameters.plus_atoms) + full = (k / parameters.r) * continuous + return JacobiFormFactor( + times=grid, + connected_continuous=continuous, + connected_full=full, + plateau_full=float(k / parameters.r), + unfolded_nodes=unfolded, + quadrature_order=int(quadrature_order), + interior_dimension=k, + atom_count_each=atom_count, + rank=int(parameters.r), + channels=int(parameters.M), + exponent=int(parameters.exponent), + mass_error=mass_error, + orthogonality_error=orthogonality_error, + ) + + +def atom_raw_decomposition( + interior_spectra: np.ndarray, + minus_atoms: int, + plus_atoms: int, + times: np.ndarray, + phase_scale: float = 2.0 * np.pi, +) -> dict[str, np.ndarray]: + """Decompose a full raw SFF into exact atom and continuum terms.""" + + interior, grid = _validated_spectra_times(interior_spectra, times) + negative = int(minus_atoms) + positive = int(plus_atoms) + if negative < 0 or positive < 0: + raise ValueError("atom counts must be nonnegative") + total = int(interior.shape[1] + negative + positive) + if total < 1: + raise ValueError("the full spectrum must be nonempty") + scale = float(phase_scale) + continuum_partition = np.sum( + np.exp( + -1j + * scale + * interior[:, :, None] + * grid[None, None, :] + ), + axis=1, + ) + atom_partition = ( + negative * np.exp(1j * scale * grid) + + positive * np.exp(-1j * scale * grid) + ) + atom_atom = np.abs(atom_partition) ** 2 / total + atom_continuum = ( + 2.0 + * np.real( + atom_partition.conj() + * np.mean(continuum_partition, axis=0) + ) + / total + ) + continuum_continuum = ( + np.mean(np.abs(continuum_partition) ** 2, axis=0) / total + ) + full = atom_atom + atom_continuum + continuum_continuum + return { + "full": full, + "atom_atom": atom_atom, + "atom_continuum": atom_continuum, + "continuum_continuum": continuum_continuum, + "normalization": np.asarray(total, dtype=int), + } diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/grassmann.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/grassmann.py new file mode 100644 index 000000000..c83c9c644 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/grassmann.py @@ -0,0 +1,350 @@ +"""Grassmannian diagnostics and covariance-deformed Geometric-ETH models.""" + +from __future__ import annotations + +from collections.abc import Iterable +from typing import Any + +import numpy as np +from scipy.linalg import solve_sylvester + + +def _validated_row_isometry( + rows: np.ndarray, + tolerance: float = 1e-9, +) -> np.ndarray: + matrix = np.asarray(rows, dtype=complex) + if matrix.ndim != 2 or matrix.shape[0] < 1: + raise ValueError("rows must be a nonempty two-dimensional matrix") + if matrix.shape[0] > matrix.shape[1]: + raise ValueError("a row isometry cannot have more rows than columns") + residual = np.linalg.norm( + matrix @ matrix.conj().T - np.eye(matrix.shape[0]) + ) + if residual > float(tolerance): + raise ValueError("rows do not form an isometry") + return matrix + + +def row_projector(rows: np.ndarray) -> np.ndarray: + """Return the ambient projector onto a whitened channel row space.""" + + matrix = _validated_row_isometry(rows) + projector = matrix.conj().T @ matrix + return 0.5 * (projector + projector.conj().T) + + +def mean_projector_anisotropy( + row_isometries: Iterable[np.ndarray], +) -> dict[str, Any]: + """Measure the departure of the ensemble mean projector from Haar.""" + + matrices = [_validated_row_isometry(rows) for rows in row_isometries] + if not matrices: + raise ValueError("at least one row isometry is required") + shape = matrices[0].shape + if any(matrix.shape != shape for matrix in matrices): + raise ValueError("all row isometries must have equal shape") + rank, dimension = shape + mean_projector = np.mean( + [row_projector(matrix) for matrix in matrices], + axis=0, + ) + isotropic = (rank / dimension) * np.eye(dimension) + difference = mean_projector - isotropic + eigenvalues = np.linalg.eigvalsh(mean_projector) + return { + "rank": rank, + "ambient_dimension": dimension, + "samples": len(matrices), + "trace": float(np.trace(mean_projector).real), + "relative_frobenius": float( + np.linalg.norm(difference) / np.linalg.norm(isotropic) + ), + "spectral_spread": float(eigenvalues[-1] - eigenvalues[0]), + "minimum_eigenvalue": float(eigenvalues[0]), + "maximum_eigenvalue": float(eigenvalues[-1]), + "mean_projector": mean_projector, + } + + +def coordinate_participation(rows: np.ndarray) -> dict[str, float]: + """Return the effective number of ambient coordinates used by a row space.""" + + projector = row_projector(rows) + weights = np.diag(projector).real + rank = float(np.sum(weights)) + denominator = float(np.sum(weights * weights)) + if denominator <= 0.0: + raise RuntimeError("projector diagonal has zero quadratic weight") + effective = rank * rank / denominator + return { + "effective_coordinates": effective, + "fraction": effective / projector.shape[0], + } + + +def polarization_imbalance(rows: np.ndarray) -> float: + """Return normalized weight imbalance between the two channel halves.""" + + projector = row_projector(rows) + dimension = projector.shape[0] + if dimension % 2: + raise ValueError("polarization requires an even ambient dimension") + half = dimension // 2 + plus = float(np.trace(projector[:half, :half]).real) + minus = float(np.trace(projector[half:, half:]).real) + rank = plus + minus + return (plus - minus) / rank + + +def frame_overlap(first: np.ndarray, second: np.ndarray) -> float: + """Return ``Tr(P_first P_second)`` without forming ambient projectors.""" + + left = _validated_row_isometry(first) + right = _validated_row_isometry(second) + if left.shape != right.shape: + raise ValueError("row isometries must have equal shape") + overlap = left @ right.conj().T + return float(np.linalg.norm(overlap) ** 2) + + +def haar_frame_overlap_mean(rank: int, dimension: int) -> float: + """Return the exact mean frame overlap of independent Haar projectors.""" + + rows = int(rank) + columns = int(dimension) + if rows < 1 or columns < rows: + raise ValueError("require 1 <= rank <= dimension") + return rows * rows / columns + + +def principal_angles(first: np.ndarray, second: np.ndarray) -> np.ndarray: + """Return principal angles between two equal-dimensional row spaces.""" + + left = _validated_row_isometry(first) + right = _validated_row_isometry(second) + if left.shape != right.shape: + raise ValueError("row isometries must have equal shape") + singular_values = np.linalg.svd( + left @ right.conj().T, + compute_uv=False, + ) + return np.arccos(np.clip(singular_values, 0.0, 1.0)) + + +def entry_fourth_ratio(row_isometries: Iterable[np.ndarray]) -> float: + """Return ``E|Y_ia|^4 / E|Y_ia|^2^2`` over an isometry ensemble.""" + + matrices = [_validated_row_isometry(rows) for rows in row_isometries] + if not matrices: + raise ValueError("at least one row isometry is required") + squared = np.concatenate( + [np.abs(matrix).ravel() ** 2 for matrix in matrices] + ) + second = float(np.mean(squared)) + fourth = float(np.mean(squared * squared)) + return fourth / (second * second) + + +def regularize_covariance( + covariance: np.ndarray, + floor_fraction: float = 1e-3, +) -> np.ndarray: + """Return a positive covariance with a scale-relative eigenvalue floor.""" + + matrix = np.asarray(covariance, dtype=complex) + if matrix.ndim != 2 or matrix.shape[0] != matrix.shape[1]: + raise ValueError("covariance must be square") + hermitian = 0.5 * (matrix + matrix.conj().T) + values, vectors = np.linalg.eigh(hermitian) + scale = float(values[-1]) + if scale <= 0.0 or values[0] < -1e-10 * scale: + raise ValueError("covariance must be positive semidefinite") + fraction = float(floor_fraction) + if not 0.0 < fraction <= 1.0: + raise ValueError("floor_fraction must lie in (0,1]") + floored = np.maximum(values, fraction * scale) + regularized = (vectors * floored[None, :]) @ vectors.conj().T + trace = float(np.trace(regularized).real) + return regularized * (matrix.shape[0] / trace) + + +def covariance_deformed_row_isometry( + rank: int, + covariance: np.ndarray, + rng: np.random.Generator, + floor_fraction: float = 1e-3, +) -> np.ndarray: + """Sample an elliptical Gaussian row space and whiten its left metric.""" + + regularized = regularize_covariance( + covariance, + floor_fraction=floor_fraction, + ) + dimension = regularized.shape[0] + rows = int(rank) + if rows < 1 or rows > dimension: + raise ValueError("require 1 <= rank <= covariance dimension") + values, vectors = np.linalg.eigh(regularized) + gaussian = ( + rng.normal(size=(rows, dimension)) + + 1j * rng.normal(size=(rows, dimension)) + ) / np.sqrt(2.0) + channels = ( + gaussian * np.sqrt(values)[None, :] + ) @ vectors.conj().T + gram = channels @ channels.conj().T + gram_values, gram_vectors = np.linalg.eigh( + 0.5 * (gram + gram.conj().T) + ) + if gram_values[0] <= 0.0: + raise RuntimeError("elliptical channel Gram matrix is singular") + inverse_sqrt = ( + gram_vectors * (gram_values ** -0.5)[None, :] + ) @ gram_vectors.conj().T + row_isometry = inverse_sqrt @ channels + _validated_row_isometry(row_isometry, tolerance=1e-8) + return row_isometry + + +def covariance_deformed_row_isometries( + rank: int, + covariance: np.ndarray, + samples: int, + rng: np.random.Generator, + floor_fraction: float = 1e-3, +) -> list[np.ndarray]: + """Sample several elliptical row spaces with one covariance factorization.""" + + regularized = regularize_covariance( + covariance, + floor_fraction=floor_fraction, + ) + dimension = regularized.shape[0] + rows = int(rank) + count = int(samples) + if rows < 1 or rows > dimension or count < 1: + raise ValueError("require 1 <= rank <= dimension and samples >= 1") + values, vectors = np.linalg.eigh(regularized) + square_root_right = np.sqrt(values)[:, None] * vectors.conj().T + result: list[np.ndarray] = [] + for _ in range(count): + gaussian = ( + rng.normal(size=(rows, dimension)) + + 1j * rng.normal(size=(rows, dimension)) + ) / np.sqrt(2.0) + channels = gaussian @ square_root_right + gram = channels @ channels.conj().T + gram_values, gram_vectors = np.linalg.eigh( + 0.5 * (gram + gram.conj().T) + ) + if gram_values[0] <= 0.0: + raise RuntimeError("elliptical channel Gram matrix is singular") + inverse_sqrt = ( + gram_vectors * (gram_values ** -0.5)[None, :] + ) @ gram_vectors.conj().T + row_isometry = inverse_sqrt @ channels + _validated_row_isometry(row_isometry, tolerance=1e-8) + result.append(row_isometry) + return result + + +def covariance_deformed_rows( + rank: int, + covariance: np.ndarray, + samples: int, + rng: np.random.Generator, + floor_fraction: float = 1e-3, +): + """Yield covariance-deformed row isometries without retaining the ensemble.""" + + regularized = regularize_covariance( + covariance, + floor_fraction=floor_fraction, + ) + dimension = regularized.shape[0] + rows = int(rank) + count = int(samples) + if rows < 1 or rows > dimension or count < 1: + raise ValueError("require 1 <= rank <= dimension and samples >= 1") + values, vectors = np.linalg.eigh(regularized) + square_root_right = np.sqrt(values)[:, None] * vectors.conj().T + for _ in range(count): + gaussian = ( + rng.normal(size=(rows, dimension)) + + 1j * rng.normal(size=(rows, dimension)) + ) / np.sqrt(2.0) + channels = gaussian @ square_root_right + gram = channels @ channels.conj().T + gram_values, gram_vectors = np.linalg.eigh( + 0.5 * (gram + gram.conj().T) + ) + if gram_values[0] <= 0.0: + raise RuntimeError("elliptical channel Gram matrix is singular") + inverse_sqrt = ( + gram_vectors * (gram_values ** -0.5)[None, :] + ) @ gram_vectors.conj().T + row_isometry = inverse_sqrt @ channels + _validated_row_isometry(row_isometry, tolerance=1e-8) + yield row_isometry + + +def covariance_first_order_variation( + gaussian: np.ndarray, + perturbation: np.ndarray, + channel_form: np.ndarray, +) -> dict[str, np.ndarray]: + """Return the exact first variation at ``C=I+epsilon*K``. + + The derivative of the inverse square root is fixed by its Sylvester + equation, so no commutativity between ``G G^dagger`` and + ``G K G^dagger`` is assumed. + """ + + G = np.asarray(gaussian, dtype=complex) + K = np.asarray(perturbation, dtype=complex) + J = np.asarray(channel_form, dtype=complex) + if G.ndim != 2 or G.shape[0] > G.shape[1]: + raise ValueError("gaussian must have shape rank x dimension") + dimension = G.shape[1] + if K.shape != (dimension, dimension): + raise ValueError("perturbation shape disagrees with gaussian") + if J.shape != (dimension, dimension): + raise ValueError("channel form shape disagrees with gaussian") + K = 0.5 * (K + K.conj().T) + A = G @ G.conj().T + values, vectors = np.linalg.eigh(0.5 * (A + A.conj().T)) + if values[0] <= 0.0: + raise ValueError("gaussian matrix must have full row rank") + square_root = ( + vectors * np.sqrt(values)[None, :] + ) @ vectors.conj().T + inverse_sqrt = ( + vectors * (values ** -0.5)[None, :] + ) @ vectors.conj().T + B = G @ K @ G.conj().T + sylvester_source = -inverse_sqrt @ B @ inverse_sqrt + delta_inverse_sqrt = solve_sylvester( + square_root, + square_root, + sylvester_source, + ) + Y = inverse_sqrt @ G + delta_Y = ( + delta_inverse_sqrt @ G + + 0.5 * inverse_sqrt @ G @ K + ) + omega = Y @ J @ Y.conj().T + delta_omega = ( + delta_Y @ J @ Y.conj().T + + Y @ J @ delta_Y.conj().T + ) + return { + "Y": Y, + "delta_Y": delta_Y, + "omega": 0.5 * (omega + omega.conj().T), + "delta_omega": 0.5 + * (delta_omega + delta_omega.conj().T), + "delta_inverse_sqrt": delta_inverse_sqrt, + } diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/hodge_response.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/hodge_response.py new file mode 100644 index 000000000..f66c3ff34 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/hodge_response.py @@ -0,0 +1,446 @@ +"""Exact/coexact BPS-projector responses for cubic N=2 SYK complexes.""" + +from __future__ import annotations + +from dataclasses import dataclass + +import numpy as np + +from .susy_cohomology import BPSFrame, cubic_supercharge, cubic_triples +from .wick_channels import ( + WickResult, + channel_covariance, + four_channel_tensor, + target_covariance, + whiten_channel_labels, +) + + +@dataclass(frozen=True) +class HodgeResponse: + """Resolved complement-to-BPS response for a tangent panel.""" + + minus: np.ndarray + plus: np.ndarray + total: np.ndarray + direct: np.ndarray + branch_sum_relative_error: float + direct_relative_error: float + orthogonality_relative_error: float + target_leakage: float + checks: dict[str, bool] + + +@dataclass(frozen=True) +class HodgeSignature: + """Gauge-invariant safe two-point data for a resolved response panel.""" + + channel_count: int + target_rank: int + minus_weight: float + plus_weight: float + hodge_balance: float + minus_channel_covariance: np.ndarray + plus_channel_covariance: np.ndarray + minus_target_eigenvalues: np.ndarray + plus_target_eigenvalues: np.ndarray + minus_external_eigenvalues: np.ndarray + plus_external_eigenvalues: np.ndarray + minus_target_effective_rank: float + plus_target_effective_rank: float + minus_external_effective_rank: float + plus_external_effective_rank: float + minus_target_entropy: float + plus_target_entropy: float + minus_external_entropy: float + plus_external_entropy: float + orthogonality_relative_error: float + + +def _relative_error(first: np.ndarray, second: np.ndarray) -> float: + denominator = max(float(np.linalg.norm(second)), np.finfo(float).tiny) + return float(np.linalg.norm(first - second) / denominator) + + +def _pseudoinverse_apply(frame: BPSFrame, rhs: np.ndarray) -> np.ndarray: + complement = np.asarray(frame.complement_frame, dtype=complex) + energies = np.asarray(frame.positive_energies, dtype=float) + if complement.shape[1] != energies.size or np.any(energies <= 0.0): + raise ValueError("BPS complement frame and energies are inconsistent") + coordinates = complement.conj().T @ np.asarray(rhs, dtype=complex) + return complement @ (coordinates / energies[:, None]) + + +def projector_derivative_from_response( + projector_frame: np.ndarray, + response: np.ndarray, +) -> np.ndarray: + """Reconstruct dP from X = (1-P)dP P.""" + + frame = np.asarray(projector_frame, dtype=complex) + values = np.asarray(response, dtype=complex) + if values.shape != frame.shape: + raise ValueError("projector frame and response shape disagree") + derivative = values @ frame.conj().T + frame @ values.conj().T + return 0.5 * (derivative + derivative.conj().T) + + +def project_moduli_tangents( + couplings: np.ndarray, + candidates: np.ndarray, + *, + relative_tolerance: float = 1e-12, +) -> np.ndarray: + """Remove the complex radial/phase line and orthonormalize row tangents.""" + + coefficients = np.asarray(couplings, dtype=complex) + values = np.asarray(candidates, dtype=complex) + if coefficients.ndim != 1 or values.ndim != 2: + raise ValueError("couplings and tangent candidates have wrong dimensions") + if values.shape[1] != coefficients.size or values.shape[0] < 1: + raise ValueError("tangent candidates have the wrong shape") + norm_squared = float(np.vdot(coefficients, coefficients).real) + if norm_squared <= 0.0: + raise ValueError("coupling vector has zero norm") + overlaps = values @ coefficients.conj() + projected = values - np.outer(overlaps / norm_squared, coefficients) + q, r = np.linalg.qr(projected.T, mode="reduced") + diagonal = np.diag(r) + scale = max(float(np.linalg.norm(projected, ord=2)), np.finfo(float).tiny) + if diagonal.size != values.shape[0] or np.any( + np.abs(diagonal) <= float(relative_tolerance) * scale + ): + raise ValueError("projected tangent candidates do not have full rank") + phases = diagonal / np.abs(diagonal) + q = q * phases[None, :] + tangents = np.asarray(q.T, dtype=complex) + if not np.allclose( + tangents @ tangents.conj().T, + np.eye(values.shape[0]), + atol=5e-13, + rtol=5e-13, + ): + raise RuntimeError("moduli tangent orthonormalization failed") + if float(np.max(np.abs(tangents @ coefficients.conj()))) > 5e-13: + raise RuntimeError("moduli tangent retains radial or phase leakage") + return tangents + + +def coupling_panels( + couplings: np.ndarray, + panel_size: int, + seed: int, +) -> dict[str, np.ndarray]: + """Return deterministic sparse and isotropic coupling-space panels.""" + + coefficients = np.asarray(couplings, dtype=complex) + size = int(panel_size) + if coefficients.ndim != 1 or not 1 <= size < coefficients.size - 1: + raise ValueError("invalid coupling panel dimensions") + sparse_seed, isotropic_seed = np.random.SeedSequence(int(seed)).spawn(2) + sparse_rng = np.random.default_rng(sparse_seed) + isotropic_rng = np.random.default_rng(isotropic_seed) + coordinates = sparse_rng.permutation(coefficients.size)[:size] + sparse_candidates = np.eye(coefficients.size, dtype=complex)[coordinates] + isotropic_candidates = isotropic_rng.normal( + size=(size, coefficients.size) + ) + 1j * isotropic_rng.normal(size=(size, coefficients.size)) + return { + "sparse": project_moduli_tangents(coefficients, sparse_candidates), + "isotropic": project_moduli_tangents( + coefficients, + isotropic_candidates, + ), + } + + +def _positive_spectrum(values: np.ndarray, rtol: float = 1e-12) -> np.ndarray: + spectrum = np.maximum(np.asarray(values, dtype=float), 0.0) + if spectrum.size == 0: + return spectrum + largest = float(np.max(spectrum)) + if largest <= 0.0: + return np.empty(0, dtype=float) + return spectrum[spectrum > float(rtol) * largest] + + +def _effective_rank(values: np.ndarray) -> float: + spectrum = _positive_spectrum(values) + if spectrum.size == 0: + return 0.0 + return float(np.sum(spectrum) ** 2 / np.sum(spectrum**2)) + + +def _spectral_entropy(values: np.ndarray) -> float: + spectrum = _positive_spectrum(values) + if spectrum.size <= 1: + return 0.0 + probabilities = spectrum / np.sum(spectrum) + return float( + -np.sum(probabilities * np.log(probabilities)) / np.log(spectrum.size) + ) + + +def _branch_spectra(values: np.ndarray) -> tuple[np.ndarray, np.ndarray]: + branch = np.asarray(values, dtype=complex) + target_rank = branch.shape[-1] + if float(np.linalg.norm(branch)) <= np.finfo(float).tiny: + return np.zeros(target_rank, dtype=float), np.empty(0, dtype=float) + target = np.linalg.eigvalsh(target_covariance(branch)) + target = np.maximum(np.asarray(target, dtype=float), 0.0) + external = external_covariance_eigenvalues_scalable(branch) + return target, external + + +def external_covariance_eigenvalues_scalable( + channels: np.ndarray, + rtol: float = 1e-12, +) -> np.ndarray: + """Return the external spectrum from the smaller exact Gram side. + + The nonzero spectra of ``S S^dagger`` and ``S^dagger S`` agree. Choosing + the smaller side changes neither the observable nor the null covariance, + while avoiding the prohibitive ``(mD)^2`` allocation at central N=14. + """ + + values = np.asarray(channels, dtype=complex) + if values.ndim != 3: + raise ValueError("channels must have shape (label, ambient, rank)") + labels, ambient, rank = values.shape + stacked = values.transpose(1, 0, 2).reshape(ambient, labels * rank) + if ambient <= labels * rank: + covariance = stacked @ stacked.conj().T / labels + else: + covariance = stacked.conj().T @ stacked / labels + covariance = 0.5 * (covariance + covariance.conj().T) + eigenvalues = np.linalg.eigvalsh(covariance) + largest = max(float(eigenvalues[-1]), 0.0) + if largest <= 0.0: + raise ValueError("external covariance has no positive support") + return np.asarray( + eigenvalues[eigenvalues > float(rtol) * largest], + dtype=float, + ) + + +def scalable_covariance_matched_wick( + channels: np.ndarray, + rtol: float = 1e-10, +) -> WickResult: + """Evaluate the frozen four-channel statistic with scalable covariance.""" + + whitened = whiten_channel_labels(channels, rtol=rtol) + values = whitened.channels + rank = values.shape[-1] + left = target_covariance(values) + left_eigenvalues = np.linalg.eigvalsh(left) + right_eigenvalues = external_covariance_eigenvalues_scalable(values) + left_trace = float(np.sum(left_eigenvalues)) + right_trace = float(np.sum(right_eigenvalues)) + A_left = ( + rank + * float(np.sum(left_eigenvalues**2)) + / (left_trace * left_trace) + ) + B_right = ( + rank + * float(np.sum(right_eigenvalues**2)) + / (right_trace * right_trace) + ) + tensor = four_channel_tensor(values) + identity = np.eye(values.shape[0]) + wick = ( + A_left * np.einsum("mn,rs->mnrs", identity, identity) + + B_right * np.einsum("ms,rn->mnrs", identity, identity) + ) + connected = tensor - wick + denominator = float(np.linalg.norm(wick)) + if denominator <= 0.0: + raise RuntimeError("Wick tensor has zero norm") + return WickResult( + tensor=tensor, + wick_tensor=wick, + connected=connected, + R4=float(np.linalg.norm(connected) / denominator), + A_left=A_left, + B_right=B_right, + left_eigenvalues=left_eigenvalues, + right_eigenvalues=right_eigenvalues, + channel_covariance_eigenvalues=whitened.covariance_eigenvalues, + ) + + +def hodge_signature(response: HodgeResponse) -> HodgeSignature: + """Reduce a resolved response to safe gauge-invariant two-point data.""" + + minus = np.asarray(response.minus, dtype=complex) + plus = np.asarray(response.plus, dtype=complex) + if minus.shape != plus.shape or minus.ndim != 3: + raise ValueError("Hodge branches must share (label, ambient, rank) shape") + minus_weight = float(np.sum(np.abs(minus) ** 2)) + plus_weight = float(np.sum(np.abs(plus) ** 2)) + total_weight = minus_weight + plus_weight + if total_weight <= 0.0: + raise ValueError("Hodge response has zero total weight") + balance = float(4.0 * minus_weight * plus_weight / total_weight**2) + minus_target, minus_external = _branch_spectra(minus) + plus_target, plus_external = _branch_spectra(plus) + minus_channel = ( + channel_covariance(minus) + if minus_weight > np.finfo(float).tiny + else np.zeros((minus.shape[0], minus.shape[0]), dtype=complex) + ) + plus_channel = ( + channel_covariance(plus) + if plus_weight > np.finfo(float).tiny + else np.zeros((plus.shape[0], plus.shape[0]), dtype=complex) + ) + cross_scale = max( + float(np.linalg.norm(minus) * np.linalg.norm(plus)), + np.finfo(float).tiny, + ) + cross = np.einsum( + "mai,maj->mij", + minus.conj(), + plus, + optimize=True, + ) + orthogonality = float(np.linalg.norm(cross) / cross_scale) + return HodgeSignature( + channel_count=int(minus.shape[0]), + target_rank=int(minus.shape[-1]), + minus_weight=minus_weight, + plus_weight=plus_weight, + hodge_balance=balance, + minus_channel_covariance=minus_channel, + plus_channel_covariance=plus_channel, + minus_target_eigenvalues=minus_target, + plus_target_eigenvalues=plus_target, + minus_external_eigenvalues=minus_external, + plus_external_eigenvalues=plus_external, + minus_target_effective_rank=_effective_rank(minus_target), + plus_target_effective_rank=_effective_rank(plus_target), + minus_external_effective_rank=_effective_rank(minus_external), + plus_external_effective_rank=_effective_rank(plus_external), + minus_target_entropy=_spectral_entropy(minus_target), + plus_target_entropy=_spectral_entropy(plus_target), + minus_external_entropy=_spectral_entropy(minus_external), + plus_external_entropy=_spectral_entropy(plus_external), + orthogonality_relative_error=orthogonality, + ) + + +def decomposable_curvature( + response: HodgeResponse, + first: int, + second: int | None = None, +) -> np.ndarray: + """Return the Hermitian Appendix-D curvature matrix from Hodge branches.""" + + minus = np.asarray(response.minus, dtype=complex) + plus = np.asarray(response.plus, dtype=complex) + left = int(first) + if not 0 <= left < minus.shape[0]: + raise IndexError("first curvature channel is out of range") + if second is None: + curvature = ( + minus[left].conj().T @ minus[left] + - plus[left].conj().T @ plus[left] + ) + else: + right = int(second) + if not 0 <= right < minus.shape[0] or right == left: + raise IndexError("second curvature channel is invalid") + ordered = ( + minus[left].conj().T @ minus[right] + - plus[right].conj().T @ plus[left] + ) + curvature = ordered + ordered.conj().T + return 0.5 * (curvature + curvature.conj().T) + + +def hodge_response( + frame: BPSFrame, + couplings: np.ndarray, + tangents: np.ndarray, + *, + tolerance: float = 5e-10, +) -> HodgeResponse: + """Compute exact, coexact, summed, and direct resolvent responses.""" + + coefficients = np.asarray(couplings, dtype=complex) + directions = np.asarray(tangents, dtype=complex) + coordinates = len(cubic_triples(frame.N)) + if coefficients.shape != (coordinates,): + raise ValueError("cubic coupling vector has the wrong shape") + if directions.ndim != 2 or directions.shape[1] != coordinates: + raise ValueError("tangent panel has the wrong shape") + if directions.shape[0] < 1: + raise ValueError("tangent panel is empty") + projector = np.asarray(frame.projector_frame, dtype=complex) + minus_values: list[np.ndarray] = [] + plus_values: list[np.ndarray] = [] + direct_values: list[np.ndarray] = [] + for tangent in directions: + dq_in = cubic_supercharge(frame.N, frame.charge - 3, tangent) + dq_out = cubic_supercharge(frame.N, frame.charge, tangent) + rhs_minus = frame.q_in @ (dq_in.getH() @ projector) + rhs_plus = frame.q_out.getH() @ (dq_out @ projector) + d_hamiltonian = ( + dq_in @ frame.q_in.getH() + + frame.q_in @ dq_in.getH() + + dq_out.getH() @ frame.q_out + + frame.q_out.getH() @ dq_out + ).tocsr() + rhs_direct = d_hamiltonian @ projector + minus_values.append(-_pseudoinverse_apply(frame, rhs_minus)) + plus_values.append(-_pseudoinverse_apply(frame, rhs_plus)) + direct_values.append(-_pseudoinverse_apply(frame, rhs_direct)) + minus = np.asarray(minus_values, dtype=complex) + plus = np.asarray(plus_values, dtype=complex) + direct = np.asarray(direct_values, dtype=complex) + total = minus + plus + branch_sum_error = _relative_error(total, minus + plus) + direct_error = _relative_error(total, direct) + orthogonality_errors: list[float] = [] + for left, right in zip(minus, plus, strict=True): + scale = max( + float(np.linalg.norm(left) * np.linalg.norm(right)), + np.finfo(float).tiny, + ) + orthogonality_errors.append( + float(np.linalg.norm(left.conj().T @ right) / scale) + ) + orthogonality_error = max(orthogonality_errors) + total_norm = max(float(np.linalg.norm(total)), np.finfo(float).tiny) + leakage = float( + np.linalg.norm( + np.einsum( + "ir,mij->mrj", + projector.conj(), + total, + optimize=True, + ) + ) + / total_norm + ) + checks = { + "finite_response": bool( + np.all(np.isfinite(total.real)) and np.all(np.isfinite(total.imag)) + ), + "branch_sum": branch_sum_error < float(tolerance), + "direct_resolvent": direct_error < float(tolerance), + "hodge_orthogonality": orthogonality_error < float(tolerance), + "target_leakage": leakage < float(tolerance), + } + return HodgeResponse( + minus=minus, + plus=plus, + total=total, + direct=direct, + branch_sum_relative_error=branch_sum_error, + direct_relative_error=direct_error, + orthogonality_relative_error=orthogonality_error, + target_leakage=leakage, + checks=checks, + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/hodge_wick.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/hodge_wick.py new file mode 100644 index 000000000..29fa21134 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/hodge_wick.py @@ -0,0 +1,202 @@ +"""Covariance-matched Gaussian nulls for exact/coexact response branches.""" + +from __future__ import annotations + +from collections.abc import Sequence + +import numpy as np + +from .hodge_response import HodgeSignature +from .wick_channels import ( + _fast_covariance_matched_r4, + gaussian_r4_reference, + sample_matched_gaussian_channels, +) + + +def _positive(values: np.ndarray, rtol: float = 1e-12) -> np.ndarray: + spectrum = np.maximum(np.asarray(values, dtype=float), 0.0) + if spectrum.ndim != 1 or spectrum.size == 0: + return np.empty(0, dtype=float) + largest = float(np.max(spectrum)) + if largest <= 0.0: + return np.empty(0, dtype=float) + return spectrum[spectrum > float(rtol) * largest] + + +def _haar_unitary(size: int, rng: np.random.Generator) -> np.ndarray: + gaussian = rng.normal(size=(size, size)) + 1j * rng.normal( + size=(size, size) + ) + q, r = np.linalg.qr(gaussian) + diagonal = np.diag(r) + phases = np.ones(size, dtype=complex) + nonzero = np.abs(diagonal) > np.finfo(float).tiny + phases[nonzero] = diagonal[nonzero] / np.abs(diagonal[nonzero]) + return np.asarray(q * phases[None, :], dtype=complex) + + +def _sample_branch( + target_eigenvalues: np.ndarray, + external_eigenvalues: np.ndarray, + channel_covariance: np.ndarray, + channel_count: int, + weight_fraction: float, + rng: np.random.Generator, +) -> np.ndarray: + target_full = np.maximum(np.asarray(target_eigenvalues, dtype=float), 0.0) + external = _positive(external_eigenvalues) + if target_full.ndim != 1 or target_full.size == 0 or external.size == 0: + raise ValueError("nonzero Hodge branch has empty covariance support") + if float(np.sum(target_full)) <= 0.0: + raise ValueError("nonzero Hodge branch has zero target covariance") + target_full = target_full / np.sum(target_full) + external = external / np.sum(external) + gaussian = ( + rng.normal(size=(channel_count, external.size, target_full.size)) + + 1j + * rng.normal(size=(channel_count, external.size, target_full.size)) + ) / np.sqrt(2.0) + local = ( + np.sqrt(external)[None, :, None] + * gaussian + * np.sqrt(target_full)[None, None, :] + ) + target_rotation = _haar_unitary(target_full.size, rng) + rotated = np.einsum( + "mai,ij->maj", + local, + target_rotation, + optimize=True, + ) + label_covariance = np.asarray(channel_covariance, dtype=complex) + if label_covariance.shape != (channel_count, channel_count): + raise ValueError("Hodge branch channel covariance has the wrong shape") + label_covariance = 0.5 * (label_covariance + label_covariance.conj().T) + eigenvalues, eigenvectors = np.linalg.eigh(label_covariance) + eigenvalues = np.maximum(eigenvalues, 0.0) + trace = float(np.sum(eigenvalues)) + if trace <= 0.0: + raise ValueError("nonzero Hodge branch has zero channel covariance") + label_root = ( + eigenvectors * np.sqrt(eigenvalues * channel_count / trace)[None, :] + ) @ eigenvectors.conj().T + correlated = np.einsum( + "mn,nai->mai", + label_root, + rotated, + optimize=True, + ) + return np.sqrt(float(weight_fraction)) * correlated + + +def sample_hodge_gaussian_channels( + signature: HodgeSignature, + channel_count: int, + rng: np.random.Generator, +) -> np.ndarray: + """Draw one response tensor from the safe two-branch Hodge signature.""" + + labels = int(channel_count) + if labels < 1 or labels != int(signature.channel_count): + raise ValueError("channel count disagrees with the Hodge signature") + weights = np.asarray( + [signature.minus_weight, signature.plus_weight], + dtype=float, + ) + if np.any(weights < 0.0) or float(np.sum(weights)) <= 0.0: + raise ValueError("Hodge branch weights must be nonnegative and nonzero") + active = np.flatnonzero(weights > np.finfo(float).tiny * np.sum(weights)) + if active.size == 1: + if int(active[0]) == 0: + target = _positive(signature.minus_target_eigenvalues) + external = _positive(signature.minus_external_eigenvalues) + else: + target = _positive(signature.plus_target_eigenvalues) + external = _positive(signature.plus_external_eigenvalues) + return sample_matched_gaussian_channels( + target, + external, + labels, + rng, + ) + fractions = weights / np.sum(weights) + minus = _sample_branch( + signature.minus_target_eigenvalues, + signature.minus_external_eigenvalues, + signature.minus_channel_covariance, + labels, + float(fractions[0]), + rng, + ) + plus = _sample_branch( + signature.plus_target_eigenvalues, + signature.plus_external_eigenvalues, + signature.plus_channel_covariance, + labels, + float(fractions[1]), + rng, + ) + if minus.shape[0] != plus.shape[0] or minus.shape[2] != plus.shape[2]: + raise RuntimeError("Hodge branch samples do not share channel and target axes") + return np.concatenate([minus, plus], axis=1) + + +def hodge_gaussian_r4_reference( + signature: HodgeSignature, + channel_count: int, + samples: int, + seed: int, +) -> np.ndarray: + """Return deterministic finite-size R4 samples for one Hodge signature.""" + + count = int(samples) + labels = int(channel_count) + if count < 1: + raise ValueError("Hodge Gaussian reference requires at least one sample") + weights = np.asarray( + [signature.minus_weight, signature.plus_weight], + dtype=float, + ) + active = np.flatnonzero(weights > np.finfo(float).tiny * np.sum(weights)) + if active.size == 1: + if int(active[0]) == 0: + target = _positive(signature.minus_target_eigenvalues) + external = _positive(signature.minus_external_eigenvalues) + else: + target = _positive(signature.plus_target_eigenvalues) + external = _positive(signature.plus_external_eigenvalues) + return gaussian_r4_reference(target, external, labels, count, int(seed)) + rng = np.random.default_rng(int(seed)) + result = np.empty(count, dtype=float) + for sample in range(count): + channels = sample_hodge_gaussian_channels(signature, labels, rng) + result[sample] = _fast_covariance_matched_r4(channels) + return result + + +def complete_realization_null( + signatures: Sequence[HodgeSignature], + samples: int, + seed: int, +) -> np.ndarray: + """Draw medians using one complete Gaussian tensor per realization.""" + + records = tuple(signatures) + count = int(samples) + if not records or count < 1: + raise ValueError("complete-realization null requires records and samples") + labels = int(records[0].channel_count) + if any(int(record.channel_count) != labels for record in records): + raise ValueError("Hodge signatures have inconsistent channel counts") + rng = np.random.default_rng(int(seed)) + result = np.empty(count, dtype=float) + for sample in range(count): + values = [ + _fast_covariance_matched_r4( + sample_hodge_gaussian_channels(record, labels, rng) + ) + for record in records + ] + result[sample] = float(np.median(values)) + return result diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/holonomy.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/holonomy.py new file mode 100644 index 000000000..acb7a9e16 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/holonomy.py @@ -0,0 +1,267 @@ +"""Periodic isospectral unitary orbits and Wilson-loop chaos statistics.""" + +from __future__ import annotations + +import numpy as np +from scipy.linalg import expm + +from .bundle_geometry import BundleGeometry + + +def _normalize_hermitian(matrix: np.ndarray) -> np.ndarray: + values = np.asarray(matrix, dtype=complex) + values = 0.5 * (values + values.conj().T) + values -= np.trace(values) / values.shape[0] * np.eye( + values.shape[0], + dtype=complex, + ) + norm = float(np.linalg.norm(values, 2)) + if norm <= 1e-12: + raise RuntimeError("local generator has zero spectral norm") + return values / norm + + +def _local_hopping_generator( + length: int, + rng: np.random.Generator, +) -> np.ndarray: + sites = length * length + matrix = np.zeros((sites, sites), dtype=complex) + for y in range(length): + for x in range(length): + source = y * length + x + for nx, ny in ( + ((x + 1) % length, y), + (x, (y + 1) % length), + ): + destination = ny * length + nx + amplitude = ( + rng.normal() + 1j * rng.normal() + ) / np.sqrt(2.0) + matrix[destination, source] += amplitude + matrix[source, destination] += np.conjugate(amplitude) + return _normalize_hermitian(matrix) + + +def local_generator_pair( + length: int, + seed: int, + commuting: bool, +) -> tuple[np.ndarray, np.ndarray]: + """Return deterministic local Hermitian generators on a square torus.""" + + linear = int(length) + if linear < 2: + raise ValueError("generator lattice length must be at least two") + rng = np.random.default_rng(int(seed)) + sites = linear * linear + if commuting: + first = np.diag(rng.normal(size=sites)) + second = np.diag(rng.normal(size=sites)) + return ( + _normalize_hermitian(first), + _normalize_hermitian(second), + ) + first = _local_hopping_generator(linear, rng) + second = _local_hopping_generator(linear, rng) + if float(np.linalg.norm(first @ second - second @ first)) <= 1e-3: + raise RuntimeError("noncommuting generator seed is accidentally singular") + return first, second + + +def ambient_unitary( + theta_x: float, + theta_y: float, + g: float, + generators: tuple[np.ndarray, np.ndarray], +) -> np.ndarray: + """Return a smooth periodic physical-site unitary.""" + + coupling = float(g) + if coupling < 0.0 or not np.isfinite(coupling): + raise ValueError("g must be finite and nonnegative") + first, second = ( + np.asarray(generators[0], dtype=complex), + np.asarray(generators[1], dtype=complex), + ) + if ( + first.ndim != 2 + or first.shape[0] != first.shape[1] + or second.shape != first.shape + ): + raise ValueError("ambient generators must be equal square matrices") + return expm( + 1j * coupling * np.sin(float(theta_x)) * first + ) @ expm( + 1j * coupling * np.sin(float(theta_y)) * second + ) + + +def deform_orbital_mesh( + orbital_frames: np.ndarray, + g: float, + seed: int, + commuting: bool, +) -> np.ndarray: + """Apply the periodic ambient unitary orbit to physical orbital frames.""" + + frames = np.asarray(orbital_frames, dtype=complex) + if frames.ndim != 4 or frames.shape[0] != frames.shape[1]: + raise ValueError( + "orbital frames must have shape (mesh, mesh, sites, orbitals)" + ) + sites = frames.shape[2] + length = int(round(np.sqrt(sites))) + if length * length != sites: + raise ValueError("physical sites do not form a square lattice") + generators = local_generator_pair( + length, + seed=int(seed), + commuting=bool(commuting), + ) + mesh = frames.shape[0] + twists = 2.0 * np.pi * np.arange(mesh) / mesh + result = np.empty_like(frames) + for ix, theta_x in enumerate(twists): + for iy, theta_y in enumerate(twists): + result[ix, iy] = ( + ambient_unitary( + theta_x, + theta_y, + g, + generators, + ) + @ frames[ix, iy] + ) + return result + + +def _circular_gap_ratio(phases: np.ndarray) -> float: + angles = np.sort(np.mod(np.asarray(phases, dtype=float), 2.0 * np.pi)) + if angles.size < 3: + raise ValueError("circular gap ratio requires at least three phases") + spacings = np.diff(np.concatenate([angles, angles[:1] + 2.0 * np.pi])) + next_spacings = np.roll(spacings, -1) + maximum = np.maximum(spacings, next_spacings) + valid = maximum > 1e-14 + if not np.any(valid): + return 0.0 + ratios = np.minimum(spacings[valid], next_spacings[valid]) / maximum[valid] + return float(np.mean(ratios)) + + +def _loop_statistics( + loops: np.ndarray, + k_values: np.ndarray, +) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + values = np.asarray(loops, dtype=complex) + count, rank, second = values.shape + if rank != second: + raise ValueError("Wilson loops must be square") + phases = np.empty((count, rank), dtype=float) + gap_ratio = np.empty(count, dtype=float) + form_factor = np.empty((count, k_values.size), dtype=float) + determinant_phase = np.empty(count, dtype=float) + for index, loop in enumerate(values): + eigenphases = np.sort(np.angle(np.linalg.eigvals(loop))) + phases[index] = eigenphases + gap_ratio[index] = _circular_gap_ratio(eigenphases) + determinant_phase[index] = float( + np.angle(np.exp(1j * np.sum(eigenphases))) + ) + form_factor[index] = [ + abs(np.sum(np.exp(1j * k * eigenphases))) ** 2 / rank + for k in k_values + ] + return phases, gap_ratio, form_factor, determinant_phase + + +def wilson_statistics( + geometry: BundleGeometry, + wilson_x: np.ndarray | None = None, + wilson_y: np.ndarray | None = None, + k_values: np.ndarray | None = None, +) -> dict[str, np.ndarray | float]: + """Return common-phase-invariant Wilson spectral statistics.""" + + loops_x = geometry.wilson_x if wilson_x is None else wilson_x + loops_y = geometry.wilson_y if wilson_y is None else wilson_y + rank = loops_x.shape[-1] + if loops_x.shape[-2:] != (rank, rank) or loops_y.shape[-2:] != ( + rank, + rank, + ): + raise ValueError("Wilson loop dimensions disagree") + ks = ( + np.arange(1, rank + 1, dtype=int) + if k_values is None + else np.asarray(k_values, dtype=int) + ) + if ks.ndim != 1 or ks.size == 0 or np.any(ks < 1): + raise ValueError("Wilson powers must be positive integers") + phases_x, gaps_x, form_x, determinant_x = _loop_statistics( + loops_x, + ks, + ) + phases_y, gaps_y, form_y, determinant_y = _loop_statistics( + loops_y, + ks, + ) + return { + "k_values": ks, + "phases": np.concatenate([phases_x, phases_y], axis=0), + "gap_ratio": np.concatenate([gaps_x, gaps_y]), + "form_factor": np.concatenate([form_x, form_y], axis=0), + "determinant_phase_x": determinant_x, + "determinant_phase_y": determinant_y, + "mean_gap_ratio": float(np.mean(np.concatenate([gaps_x, gaps_y]))), + "mean_form_factor": np.mean( + np.concatenate([form_x, form_y], axis=0), + axis=0, + ), + } + + +def _haar_unitary( + dimension: int, + rng: np.random.Generator, +) -> np.ndarray: + gaussian = ( + rng.normal(size=(dimension, dimension)) + + 1j * rng.normal(size=(dimension, dimension)) + ) / np.sqrt(2.0) + q, r = np.linalg.qr(gaussian) + phases = np.diag(r) + phases = phases / np.abs(phases) + return q * phases.conj()[None, :] + + +def cue_wilson_reference( + D: int, + samples: int, + k_values: np.ndarray, + seed: int, +) -> dict[str, np.ndarray]: + """Return independent circular-unitary Wilson statistics.""" + + rank = int(D) + count = int(samples) + ks = np.asarray(k_values, dtype=int) + if rank < 3 or count < 1 or ks.ndim != 1 or np.any(ks < 1): + raise ValueError("invalid CUE reference dimensions") + rng = np.random.default_rng(int(seed)) + gaps = np.empty(count, dtype=float) + form_factor = np.empty((count, ks.size), dtype=float) + for sample in range(count): + unitary = _haar_unitary(rank, rng) + phases = np.angle(np.linalg.eigvals(unitary)) + gaps[sample] = _circular_gap_ratio(phases) + form_factor[sample] = [ + abs(np.sum(np.exp(1j * k * phases))) ** 2 / rank + for k in ks + ] + return { + "k_values": ks, + "gap_ratio": gaps, + "form_factor": form_factor, + } diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/jacobi.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/jacobi.py new file mode 100644 index 000000000..f1bc36330 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/jacobi.py @@ -0,0 +1,312 @@ +"""Metric-normalized curvature and finite Jacobi compression theory.""" + +from __future__ import annotations + +from dataclasses import dataclass + +import numpy as np +from scipy import linalg +from scipy.special import eval_jacobi, gammaln + +from .channels import _validated_channel_pair + + +@dataclass(frozen=True) +class NormalizedCurvature: + """Curvature whitened by the channel Gram matrix on its support.""" + + rank: int + kernel_dimension: int + cutoff: float + active_basis: np.ndarray + gamma_eigenvalues: np.ndarray + Y: np.ndarray + J: np.ndarray + omega: np.ndarray + + +@dataclass(frozen=True) +class JacobiParameters: + """Finite-dimensional parameters of a Haar signature compression.""" + + r: int + M: int + interior_dimension: int + exponent: int + plus_atoms: int + minus_atoms: int + + +def canonical_channel_form(M: int) -> np.ndarray: + """Return the Hermitian channel form for ``[X_v,X_w]``.""" + + channels = int(M) + if channels < 1: + raise ValueError("M must be positive") + identity = np.eye(channels, dtype=complex) + zero = np.zeros_like(identity) + return np.block( + [ + [zero, 1j * identity], + [-1j * identity, zero], + ] + ) + + +def normalized_curvature( + channel_v: np.ndarray, + channel_w: np.ndarray, + rtol: float = 1e-12, + atol: float = 0.0, +) -> NormalizedCurvature: + """Return ``Omega=Gamma^{-1/2} F Gamma^{-1/2}=Y J Y^dagger``.""" + + x, y = _validated_channel_pair(channel_v, channel_w) + if rtol < 0.0 or atol < 0.0: + raise ValueError("rank tolerances must be nonnegative") + doubled = np.concatenate([x, y], axis=1) + gamma = doubled @ doubled.conj().T + eigenvalues, eigenvectors = np.linalg.eigh( + 0.5 * (gamma + gamma.conj().T) + ) + scale = max(float(eigenvalues[-1]), 0.0) + cutoff = max(float(atol), float(rtol) * scale) + keep = eigenvalues > cutoff + active_values = eigenvalues[keep] + active_basis = eigenvectors[:, keep] + rank = int(active_values.size) + if rank == 0: + raise ValueError("the channel Gram matrix has empty support") + projected = active_basis.conj().T @ doubled + Y = projected / np.sqrt(active_values)[:, None] + J = canonical_channel_form(x.shape[1]) + omega = Y @ J @ Y.conj().T + omega = 0.5 * (omega + omega.conj().T) + return NormalizedCurvature( + rank=rank, + kernel_dimension=x.shape[0] - rank, + cutoff=cutoff, + active_basis=active_basis, + gamma_eigenvalues=active_values, + Y=Y, + J=J, + omega=omega, + ) + + +def haar_row_isometry( + r: int, + doubled_channels: int, + rng: np.random.Generator, +) -> np.ndarray: + """Sample an ``r x doubled_channels`` complex Haar row isometry.""" + + rows = int(r) + columns = int(doubled_channels) + if rows < 1 or columns < 1 or rows > columns: + raise ValueError("require 1 <= r <= doubled_channels") + gaussian = ( + rng.normal(size=(columns, rows)) + + 1j * rng.normal(size=(columns, rows)) + ) / np.sqrt(2.0) + q, r_factor = np.linalg.qr(gaussian, mode="reduced") + phases = np.diag(r_factor) + phases = np.where( + np.abs(phases) > 0.0, + phases / np.abs(phases), + 1.0, + ) + q = q * phases.conj()[None, :] + return q.conj().T + + +def jacobi_parameters(r: int, M: int) -> JacobiParameters: + """Return interior Jacobi size/exponent and forced boundary atoms.""" + + rank = int(r) + channels = int(M) + if channels < 1 or rank < 1 or rank > 2 * channels: + raise ValueError("require M>=1 and 1<=r<=2M") + if rank <= channels: + interior = rank + exponent = channels - rank + atoms = 0 + else: + interior = 2 * channels - rank + exponent = rank - channels + atoms = rank - channels + return JacobiParameters( + r=rank, + M=channels, + interior_dimension=interior, + exponent=exponent, + plus_atoms=atoms, + minus_atoms=atoms, + ) + + +def _jacobi_norm(order: int, exponent: int) -> float: + degree = int(order) + alpha = int(exponent) + log_norm = ( + (2 * alpha + 1) * np.log(2.0) + - np.log(2 * degree + 2 * alpha + 1) + + 2 * gammaln(degree + alpha + 1) + - gammaln(degree + 1) + - gammaln(degree + 2 * alpha + 1) + ) + return float(np.exp(log_norm)) + + +def jacobi_one_point_density( + x: np.ndarray, + r: int, + M: int, +) -> np.ndarray: + """Return the normalized interior one-eigenvalue Jacobi density.""" + + parameters = jacobi_parameters(r, M) + values = np.asarray(x, dtype=float) + density = np.zeros_like(values) + interior = parameters.interior_dimension + if interior == 0: + return density + mask = np.abs(values) <= 1.0 + points = values[mask] + weight = np.maximum(1.0 - points * points, 0.0) ** ( + parameters.exponent + ) + kernel = np.zeros_like(points) + for order in range(interior): + polynomial = eval_jacobi( + order, + parameters.exponent, + parameters.exponent, + points, + ) + kernel += polynomial * polynomial / _jacobi_norm( + order, + parameters.exponent, + ) + density[mask] = weight * kernel / interior + density = np.maximum(density, 0.0) + return density + + +def sample_jacobi_compression( + r: int, + M: int, + samples: int, + seed: int, +) -> np.ndarray: + """Sample spectra of a Haar compression of ``diag(+1_M,-1_M)``.""" + + parameters = jacobi_parameters(r, M) + count = int(samples) + if count < 1: + raise ValueError("samples must be positive") + rng = np.random.default_rng(int(seed)) + signature = np.concatenate( + [ + np.ones(parameters.M, dtype=float), + -np.ones(parameters.M, dtype=float), + ] + ) + spectra = np.empty((count, parameters.r), dtype=float) + for sample in range(count): + rows = haar_row_isometry( + parameters.r, + 2 * parameters.M, + rng, + ) + omega = (rows * signature[None, :]) @ rows.conj().T + spectra[sample] = np.linalg.eigvalsh( + 0.5 * (omega + omega.conj().T) + ) + return spectra + + +def sample_jacobi_interior( + r: int, + M: int, + samples: int, + seed: int, +) -> tuple[np.ndarray, np.ndarray]: + """Sample the finite Jacobi law and remove only algebraically forced atoms. + + The Boolean labels are fixed by the exact intersection dimensions, not by + a floating-point threshold. The full spectra are ordered, so the first + ``minus_atoms`` and last ``plus_atoms`` entries carry the labels. + """ + + parameters = jacobi_parameters(r, M) + full = sample_jacobi_compression(r, M, samples, seed) + labels = np.zeros_like(full, dtype=bool) + if parameters.minus_atoms: + labels[:, : parameters.minus_atoms] = True + labels[:, -parameters.plus_atoms :] = True + if not np.allclose( + full[:, : parameters.minus_atoms], -1.0, atol=2e-10, rtol=0.0 + ): + raise RuntimeError("negative Jacobi atoms failed the exact label audit") + if not np.allclose( + full[:, -parameters.plus_atoms :], 1.0, atol=2e-10, rtol=0.0 + ): + raise RuntimeError("positive Jacobi atoms failed the exact label audit") + interior = full[~labels].reshape( + int(samples), parameters.interior_dimension + ) + return interior, labels + + +def sample_jacobi_wishart( + r: int, + M: int, + samples: int, + seed: int, +) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + """Sample the exact complex Jacobi law via a matrix-beta construction. + + For interior size ``k`` and exponent ``a``, two independent complex + Wishart matrices with ``k+a=M`` columns generate the eigenvalues on + ``[0,1]``. The affine map ``lambda=2t-1`` gives the signature-compression + spectrum; the intersection-theorem atoms are then inserted explicitly. + """ + + parameters = jacobi_parameters(r, M) + count = int(samples) + if count < 1: + raise ValueError("samples must be positive") + k = parameters.interior_dimension + full = np.empty((count, parameters.r), dtype=float) + interior = np.empty((count, k), dtype=float) + labels = np.zeros_like(full, dtype=bool) + rng = np.random.default_rng(int(seed)) + for sample in range(count): + if k: + gaussian_x = ( + rng.normal(size=(k, parameters.M)) + + 1j * rng.normal(size=(k, parameters.M)) + ) / np.sqrt(2.0) + gaussian_y = ( + rng.normal(size=(k, parameters.M)) + + 1j * rng.normal(size=(k, parameters.M)) + ) / np.sqrt(2.0) + first = gaussian_x @ gaussian_x.conj().T + second = gaussian_y @ gaussian_y.conj().T + beta_values = linalg.eigvalsh( + first, + first + second, + check_finite=False, + driver="gvd", + ) + interior[sample] = 2.0 * beta_values - 1.0 + if parameters.minus_atoms: + full[sample, : parameters.minus_atoms] = -1.0 + labels[sample, : parameters.minus_atoms] = True + start = parameters.minus_atoms + full[sample, start : start + k] = interior[sample] + if parameters.plus_atoms: + full[sample, -parameters.plus_atoms :] = 1.0 + labels[sample, -parameters.plus_atoms :] = True + return full, interior, labels diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/lattice.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/lattice.py new file mode 100644 index 000000000..574dbdf78 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/lattice.py @@ -0,0 +1,489 @@ +"""Independent Kapit--Mueller projected-contact lattice backend. + +The algorithms are task-local rewrites of the prior ``qgeom/models.py``, +``qgeom/projected.py``, ``qgeom/softcore.py``, and ``qgeom/operators.py`` +implementations at provenance commit ``e4ee4c9``. This module imports no +code or data from that implementation. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from math import floor, sqrt + +import numpy as np +from scipy import sparse + +from .combinatorics import occupation_states + + +@dataclass(frozen=True) +class Bond: + """Directed hopping record with integer torus windings.""" + + destination: int + source: int + amplitude: complex + winding_x: int + winding_y: int + + +@dataclass(frozen=True) +class BosonBasis: + """Normalized occupation basis at fixed boson number.""" + + n_orbitals: int + n_particles: int + + def __post_init__(self) -> None: + if self.n_orbitals < 1: + raise ValueError("n_orbitals must be positive") + if self.n_particles < 0: + raise ValueError("n_particles must be nonnegative") + states = tuple( + occupation_states(self.n_particles, self.n_orbitals) + ) + object.__setattr__(self, "states", states) + object.__setattr__( + self, + "index", + {state: index for index, state in enumerate(states)}, + ) + + @property + def dimension(self) -> int: + return len(self.states) + + +@dataclass(frozen=True) +class KapitLaughlinParent: + """Lowest-band frame and factorized projected contact parent.""" + + n_particles: int + n_flux: int + length: int + theta_x: float + theta_y: float + basis: BosonBasis + intermediate_basis: BosonBasis + bonds: tuple[Bond, ...] + onebody_energies: np.ndarray + orbitals: np.ndarray + constraints: sparse.csr_matrix + parent: sparse.csr_matrix + + +def _kapit_mueller_sign(displacement: complex) -> int: + x = int(round(displacement.real)) + y = int(round(displacement.imag)) + return -1 if (x + y + x * y) % 2 else 1 + + +def kapit_mueller_bonds( + length: int, + flux_density: float | None = None, + image_cutoff: int = 2, + amplitude_cutoff: float = 1e-13, +) -> tuple[Bond, ...]: + """Return magneto-periodic Kapit--Mueller hoppings on a square torus.""" + + linear_size = int(length) + density = ( + 2.0 / linear_size + if flux_density is None + else float(flux_density) + ) + if linear_size <= 2: + raise ValueError("length must exceed two") + if not 0.0 < density < 1.0: + raise ValueError("flux_density must lie in (0,1)") + if image_cutoff < 0: + raise ValueError("image_cutoff must be nonnegative") + positions = tuple( + complex(x, y) + for y in range(linear_size) + for x in range(linear_size) + ) + bonds: list[Bond] = [] + for destination, z_destination in enumerate(positions): + for source in range(destination + 1, len(positions)): + base = positions[source] - z_destination + for winding_x in range(-image_cutoff, image_cutoff + 1): + for winding_y in range( + -image_cutoff, + image_cutoff + 1, + ): + image = complex( + winding_x * linear_size, + winding_y * linear_size, + ) + displacement = base + image + if abs(displacement) < 1e-14: + continue + envelope = np.exp( + -0.5 + * np.pi + * (1.0 - density) + * abs(displacement) ** 2 + ) + gauge_phase = np.exp( + 0.5 + * np.pi + * density + * ( + z_destination + * np.conjugate(displacement) + - np.conjugate(z_destination) + * displacement + ) + ) + extension_phase = np.exp( + 0.5 + * np.pi + * density + * ( + z_destination * np.conjugate(image) + - np.conjugate(z_destination) * image + ) + ) + amplitude = ( + _kapit_mueller_sign(displacement) + * envelope + * gauge_phase + * extension_phase + ) + if abs(amplitude) >= amplitude_cutoff: + bonds.append( + Bond( + destination=destination, + source=source, + amplitude=complex(amplitude), + winding_x=winding_x, + winding_y=winding_y, + ) + ) + return tuple(bonds) + + +def one_body_hamiltonian( + n_sites: int, + bonds: tuple[Bond, ...], + theta_x: float = 0.0, + theta_y: float = 0.0, +) -> sparse.csr_matrix: + """Assemble the twist-dependent Hermitian single-particle matrix.""" + + sites = int(n_sites) + if sites < 1: + raise ValueError("n_sites must be positive") + rows: list[int] = [] + columns: list[int] = [] + data: list[complex] = [] + for bond in bonds: + if not ( + 0 <= bond.destination < sites + and 0 <= bond.source < sites + ): + raise IndexError("bond endpoint is outside the lattice") + phase = np.exp( + 1j + * ( + bond.winding_x * float(theta_x) + + bond.winding_y * float(theta_y) + ) + ) + amplitude = bond.amplitude * phase + rows.extend((bond.destination, bond.source)) + columns.extend((bond.source, bond.destination)) + data.extend((amplitude, np.conjugate(amplitude))) + matrix = sparse.coo_matrix( + (np.asarray(data, dtype=complex), (rows, columns)), + shape=(sites, sites), + ).tocsr() + matrix.sum_duplicates() + return matrix + + +def lowest_band_frame( + n_sites: int, + bonds: tuple[Bond, ...], + n_orbitals: int, + theta_x: float, + theta_y: float, +) -> tuple[np.ndarray, np.ndarray]: + """Diagonalize the one-body problem and return its lowest-band frame.""" + + orbitals = int(n_orbitals) + if not 0 < orbitals < n_sites: + raise ValueError("require 0 tuple[sparse.csr_matrix, BosonBasis]: + """Return ``C`` such that the projected contact parent is ``C^dagger C``.""" + + frame = np.asarray(orbitals, dtype=complex) + if basis.n_particles < 2: + raise ValueError("contact constraints require at least two particles") + if frame.ndim != 2 or frame.shape[1] != basis.n_orbitals: + raise ValueError("orbital frame and basis disagree") + if onsite_u <= 0.0: + raise ValueError("onsite_u must be positive") + if not np.allclose( + frame.conj().T @ frame, + np.eye(basis.n_orbitals), + atol=1e-11, + ): + raise ValueError("orbitals must have orthonormal columns") + intermediate = BosonBasis( + basis.n_orbitals, + basis.n_particles - 2, + ) + physical_sites = frame.shape[0] + rows: list[int] = [] + columns: list[int] = [] + data: list[complex] = [] + prefactor = sqrt(0.5 * float(onsite_u)) + for column, state in enumerate(basis.states): + for left in range(basis.n_orbitals): + if state[left] >= 2: + updated = list(state) + updated[left] -= 2 + intermediate_index = intermediate.index[tuple(updated)] + occupation_factor = sqrt( + state[left] * (state[left] - 1) + ) + for physical in range(physical_sites): + coefficient = ( + prefactor + * frame[physical, left] ** 2 + * occupation_factor + ) + if abs(coefficient) > amplitude_cutoff: + rows.append( + physical * intermediate.dimension + + intermediate_index + ) + columns.append(column) + data.append(coefficient) + if state[left] == 0: + continue + for right in range(left + 1, basis.n_orbitals): + if state[right] == 0: + continue + updated = list(state) + updated[left] -= 1 + updated[right] -= 1 + intermediate_index = intermediate.index[tuple(updated)] + occupation_factor = sqrt(state[left] * state[right]) + for physical in range(physical_sites): + coefficient = ( + 2.0 + * prefactor + * frame[physical, left] + * frame[physical, right] + * occupation_factor + ) + if abs(coefficient) > amplitude_cutoff: + rows.append( + physical * intermediate.dimension + + intermediate_index + ) + columns.append(column) + data.append(coefficient) + constraints = sparse.coo_matrix( + ( + np.asarray(data, dtype=complex), + (rows, columns), + ), + shape=( + physical_sites * intermediate.dimension, + basis.dimension, + ), + ).tocsr() + constraints.sum_duplicates() + return constraints, intermediate + + +def projected_contact_parent( + basis: BosonBasis, + orbitals: np.ndarray, +) -> tuple[sparse.csr_matrix, sparse.csr_matrix, BosonBasis]: + """Return the positive projected parent, its factor, and lower basis.""" + + constraints, intermediate = projected_contact_constraints( + basis, + orbitals, + ) + parent = (constraints.conj().T @ constraints).tocsr() + parent.sum_duplicates() + return parent, constraints, intermediate + + +def build_kapit_laughlin_parent( + n_particles: int, + n_flux: int, + theta_x: float, + theta_y: float, +) -> KapitLaughlinParent: + """Build a commensurate Kapit--Mueller projected-contact parent.""" + + flux = int(n_flux) + if flux % 2: + raise ValueError("the registered sequence requires even n_flux") + length = flux // 2 + if length <= 2: + raise ValueError("the registered sequence requires n_flux>=8") + bonds = kapit_mueller_bonds(length) + energies, orbitals = lowest_band_frame( + length * length, + bonds, + flux, + theta_x, + theta_y, + ) + basis = BosonBasis(flux, int(n_particles)) + parent, constraints, intermediate = projected_contact_parent( + basis, + orbitals, + ) + return KapitLaughlinParent( + n_particles=int(n_particles), + n_flux=flux, + length=length, + theta_x=float(theta_x), + theta_y=float(theta_y), + basis=basis, + intermediate_basis=intermediate, + bonds=bonds, + onebody_energies=energies, + orbitals=orbitals, + constraints=constraints, + parent=parent, + ) + + +def projected_site_potential( + orbitals: np.ndarray, + potential: np.ndarray, +) -> np.ndarray: + """Project a real physical-site potential into the Chern band.""" + + frame = np.asarray(orbitals, dtype=complex) + values = np.asarray(potential, dtype=float) + if frame.ndim != 2 or values.shape != (frame.shape[0],): + raise ValueError("potential and orbital frame disagree") + projected = frame.conj().T @ (values[:, None] * frame) + return 0.5 * (projected + projected.conj().T) + + +def manybody_one_body_operator( + basis: BosonBasis, + one_body: np.ndarray, + amplitude_cutoff: float = 1e-14, +) -> sparse.csr_matrix: + """Second-quantize a Hermitian one-body operator.""" + + matrix = np.asarray(one_body, dtype=complex) + if matrix.shape != (basis.n_orbitals, basis.n_orbitals): + raise ValueError("one-body matrix has the wrong shape") + if not np.allclose(matrix, matrix.conj().T, atol=1e-11): + raise ValueError("one-body matrix must be Hermitian") + rows: list[int] = [] + columns: list[int] = [] + data: list[complex] = [] + for column, state in enumerate(basis.states): + for source, population in enumerate(state): + if population == 0: + continue + for destination in range(basis.n_orbitals): + coefficient = matrix[destination, source] + if abs(coefficient) <= amplitude_cutoff: + continue + if destination == source: + target = state + factor = float(population) + else: + updated = list(state) + factor = sqrt( + population * (updated[destination] + 1) + ) + updated[source] -= 1 + updated[destination] += 1 + target = tuple(updated) + rows.append(basis.index[target]) + columns.append(column) + data.append(coefficient * factor) + operator = sparse.coo_matrix( + ( + np.asarray(data, dtype=complex), + (rows, columns), + ), + shape=(basis.dimension, basis.dimension), + ).tocsr() + operator.sum_duplicates() + return operator + + +def channel_matrix( + energies_p: np.ndarray, + vectors_p: np.ndarray, + energies_q: np.ndarray, + vectors_q: np.ndarray, + tangent: sparse.spmatrix, +) -> np.ndarray: + """Return the external Kubo response channel of an isolated multiplet.""" + + ep = np.asarray(energies_p, dtype=float) + eq = np.asarray(energies_q, dtype=float) + frame_p = np.asarray(vectors_p, dtype=complex) + frame_q = np.asarray(vectors_q, dtype=complex) + if ep.size == 0 or eq.size == 0: + raise ValueError("both target and external sectors must be nonempty") + reference = float(np.mean(ep)) + denominators = reference - eq + scale = max(1.0, abs(reference), float(np.max(np.abs(eq)))) + if np.any(np.abs(denominators) <= 1e-12 * scale): + raise ValueError("external denominator closes") + applied = tangent @ frame_q + elements = frame_p.conj().T @ np.asarray(applied) + return np.asarray(elements / denominators[None, :], dtype=complex) + + +def random_local_potential(n_sites: int, seed: int) -> np.ndarray: + """Return a deterministic normalized zero-mean local potential.""" + + rng = np.random.default_rng(int(seed)) + values = rng.normal(size=int(n_sites)) + values -= np.mean(values) + norm = np.linalg.norm(values) + if norm <= 0.0: + raise RuntimeError("random potential has zero norm") + return values / norm + + +def numerical_rank( + matrix: np.ndarray, + rtol: float = 1e-10, +) -> int: + """Return a scale-aware singular-value rank.""" + + values = np.linalg.svd( + np.asarray(matrix, dtype=complex), + compute_uv=False, + ) + if values.size == 0: + return 0 + return int(np.count_nonzero(values > rtol * values[0])) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/manybody_response.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/manybody_response.py new file mode 100644 index 000000000..52d413959 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/manybody_response.py @@ -0,0 +1,459 @@ +"""Sparse resolvent responses on a genuine fixed-quasihole sequence.""" + +from __future__ import annotations + +import warnings +from dataclasses import dataclass, replace + +import numpy as np +from scipy import sparse +from scipy.sparse.linalg import eigsh, lobpcg, splu + +from .combinatorics import laughlin_zero_mode_count +from .lattice import ( + KapitLaughlinParent, + build_kapit_laughlin_parent, + manybody_one_body_operator, + projected_site_potential, +) + + +@dataclass(frozen=True) +class ManyBodyCase: + """One registered physical fixed-two-quasihole system.""" + + N: int + n_flux: int + expected_rank: int + theta_x: float + theta_y: float + + +@dataclass(frozen=True) +class SmallCaseAudit: + """Reason an unregistered small physical system is excluded.""" + + N: int + n_flux: int + expected_rank: int + observed_rank: int + accepted: bool + + +@dataclass(frozen=True) +class KernelFrame: + """Numerically complete orthonormal frame for one exact zero-mode space.""" + + frame: np.ndarray + zero_eigenvalues: np.ndarray + external_gap: float + residual_norm: float + orthonormality_error: float + method: str + observed_rank: int + + +@dataclass(frozen=True) +class SiteResponseCache: + """Resolvent solutions for a selected physical-site tangent basis.""" + + case: ManyBodyCase + site_indices: tuple[int, ...] + solutions: np.ndarray + tangent_gram: np.ndarray + external_gap: float + shift_values: tuple[float, float] + maximum_relative_residual: float + maximum_shift_difference: float + maximum_kernel_leakage: float + + +def registered_fixed_two_qh_cases() -> tuple[ManyBodyCase, ...]: + """Return the preregistered genuine particle-number sequence.""" + + return tuple( + ManyBodyCase( + N=N, + n_flux=2 * N + 2, + expected_rank=laughlin_zero_mode_count(N, 2 * N + 2), + theta_x=0.17, + theta_y=0.29, + ) + for N in (3, 4, 5) + ) + + +def _zero_tolerance(eigenvalues: np.ndarray) -> float: + values = np.asarray(eigenvalues, dtype=float) + scale = max(float(np.max(np.abs(values))), 1.0) + return 1e-9 * scale + + +def audit_unregistered_small_case( + N: int, + n_flux: int, + theta_x: float, + theta_y: float, +) -> SmallCaseAudit: + """Return the exact-count audit for a proposed small physical parent.""" + + system = build_kapit_laughlin_parent( + int(N), + int(n_flux), + float(theta_x), + float(theta_y), + ) + eigenvalues = np.linalg.eigvalsh(system.parent.toarray()) + expected = laughlin_zero_mode_count(int(N), int(n_flux)) + observed = int( + np.count_nonzero(np.abs(eigenvalues) < _zero_tolerance(eigenvalues)) + ) + return SmallCaseAudit( + N=int(N), + n_flux=int(n_flux), + expected_rank=expected, + observed_rank=observed, + accepted=observed == expected, + ) + + +def _dense_kernel_frame( + system: KapitLaughlinParent, + case: ManyBodyCase, +) -> KernelFrame: + parent = system.parent.toarray() + parent = 0.5 * (parent + parent.conj().T) + eigenvalues, eigenvectors = np.linalg.eigh(parent) + tolerance = _zero_tolerance(eigenvalues) + observed = int(np.count_nonzero(np.abs(eigenvalues) < tolerance)) + if observed != case.expected_rank: + raise RuntimeError( + f"zero-mode count mismatch: expected {case.expected_rank}, " + f"observed {observed}" + ) + frame = eigenvectors[:, :observed] + gap = float(eigenvalues[observed] - eigenvalues[observed - 1]) + residual = float(np.linalg.norm(system.parent @ frame)) + orthonormality = float( + np.linalg.norm(frame.conj().T @ frame - np.eye(observed)) + ) + return KernelFrame( + frame=frame, + zero_eigenvalues=np.asarray(eigenvalues[:observed], dtype=float), + external_gap=gap, + residual_norm=residual, + orthonormality_error=orthonormality, + method="dense", + observed_rank=observed, + ) + + +def _sparse_kernel_frame( + system: KapitLaughlinParent, + case: ManyBodyCase, + seed: int, +) -> KernelFrame: + dimension = system.basis.dimension + rank = case.expected_rank + rng = np.random.default_rng(int(seed)) + initial = ( + rng.normal(size=(dimension, rank)) + + 1j * rng.normal(size=(dimension, rank)) + ) + initial, _ = np.linalg.qr(initial) + with warnings.catch_warnings(): + warnings.simplefilter("ignore", UserWarning) + values, frame = lobpcg( + system.parent, + initial, + largest=False, + tol=1e-9, + maxiter=600, + ) + frame, _ = np.linalg.qr(frame) + residual = float(np.linalg.norm(system.parent @ frame)) + orthonormality = float( + np.linalg.norm(frame.conj().T @ frame - np.eye(rank)) + ) + audit_values = eigsh( + system.parent, + k=rank + 4, + which="SM", + return_eigenvectors=False, + tol=1e-9, + maxiter=12_000, + ncv=min(dimension, max(2 * (rank + 4) + 1, 100)), + ) + audit_values = np.sort(np.real(audit_values)) + tolerance = _zero_tolerance(audit_values) + observed = int(np.count_nonzero(np.abs(audit_values) < tolerance)) + if observed != rank: + raise RuntimeError( + f"sparse zero-mode count mismatch: expected {rank}, observed {observed}" + ) + gap = float(audit_values[rank] - audit_values[rank - 1]) + if gap <= 0.0: + raise RuntimeError("sparse kernel has no open external gap") + return KernelFrame( + frame=frame, + zero_eigenvalues=np.sort(np.real(values)), + external_gap=gap, + residual_norm=residual, + orthonormality_error=orthonormality, + method="lobpcg", + observed_rank=observed, + ) + + +def solve_kernel_frame( + system: KapitLaughlinParent, + case: ManyBodyCase, + seed: int, +) -> KernelFrame: + """Return a complete target frame and a separately audited external gap.""" + + if system.n_particles != case.N or system.n_flux != case.n_flux: + raise ValueError("system and many-body case disagree") + if case.expected_rank != laughlin_zero_mode_count(case.N, case.n_flux): + raise ValueError("case rank disagrees with exact Laughlin counting") + if system.basis.dimension <= 2_000: + return _dense_kernel_frame(system, case) + return _sparse_kernel_frame(system, case, seed) + + +def _site_tangent_operators( + system: KapitLaughlinParent, + site_indices: tuple[int, ...], +) -> list[sparse.csr_matrix]: + physical_sites = int(system.orbitals.shape[0]) + operators: list[sparse.csr_matrix] = [] + for site in site_indices: + if not 0 <= site < physical_sites: + raise IndexError("physical site index is outside the lattice") + potential = np.zeros(physical_sites, dtype=float) + potential[site] = 1.0 + one_body = projected_site_potential(system.orbitals, potential) + operators.append(manybody_one_body_operator(system.basis, one_body)) + return operators + + +def _tangent_gram(operators: list[sparse.csr_matrix]) -> np.ndarray: + count = len(operators) + gram = np.empty((count, count), dtype=complex) + for left in range(count): + for right in range(left, count): + value = ( + operators[left] + .conjugate() + .multiply(operators[right]) + .sum() + ) + gram[left, right] = value + gram[right, left] = np.conjugate(value) + gram = 0.5 * (gram + gram.conj().T) + if np.max(np.abs(gram.imag)) < 1e-10: + return gram.real + return gram + + +def _project_complement(frame: np.ndarray, values: np.ndarray) -> np.ndarray: + return values - frame @ (frame.conj().T @ values) + + +def _reshape_site_solutions( + matrix: np.ndarray, + sites: int, + dimension: int, + rank: int, +) -> np.ndarray: + return ( + np.asarray(matrix) + .reshape(dimension, sites, rank) + .transpose(1, 0, 2) + ) + + +def build_site_response_cache( + system: KapitLaughlinParent, + kernel: KernelFrame, + relative_shifts: tuple[float, float] = (1e-3, 5e-4), + site_indices: tuple[int, ...] | None = None, +) -> SiteResponseCache: + """Build selected site responses by two-shift sparse extrapolation.""" + + relative = tuple(float(value) for value in relative_shifts) + if len(relative) != 2 or not (relative[0] > relative[1] > 0.0): + raise ValueError("require two positive descending relative shifts") + if not np.isclose(relative[1], 0.5 * relative[0]): + raise ValueError("Richardson extrapolation requires a half shift") + chosen = ( + tuple(range(system.orbitals.shape[0])) + if site_indices is None + else tuple(int(index) for index in site_indices) + ) + if not chosen or len(set(chosen)) != len(chosen): + raise ValueError("site indices must be nonempty and distinct") + operators = _site_tangent_operators(system, chosen) + frame = np.asarray(kernel.frame, dtype=complex) + right_hand_sides = [ + _project_complement(frame, np.asarray(operator @ frame)) + for operator in operators + ] + combined_rhs = np.concatenate(right_hand_sides, axis=1) + identity = sparse.eye( + system.basis.dimension, + format="csc", + dtype=complex, + ) + absolute = ( + relative[0] * kernel.external_gap, + relative[1] * kernel.external_gap, + ) + first_solver = splu( + (system.parent + absolute[0] * identity).tocsc() + ) + first = first_solver.solve(combined_rhs) + del first_solver + second_solver = splu( + (system.parent + absolute[1] * identity).tocsc() + ) + second = second_solver.solve(combined_rhs) + del second_solver + first = _project_complement(frame, first) + second = _project_complement(frame, second) + extrapolated = _project_complement(frame, 2.0 * second - first) + sites = len(chosen) + dimension = system.basis.dimension + rank = kernel.frame.shape[1] + solutions = _reshape_site_solutions( + extrapolated, + sites, + dimension, + rank, + ) + first_by_site = _reshape_site_solutions( + first, + sites, + dimension, + rank, + ) + second_by_site = _reshape_site_solutions( + second, + sites, + dimension, + rank, + ) + relative_residuals: list[float] = [] + shift_differences: list[float] = [] + kernel_leakage: list[float] = [] + for index, rhs in enumerate(right_hand_sides): + solution = solutions[index] + rhs_norm = float(np.linalg.norm(rhs)) + solution_norm = max(float(np.linalg.norm(solution)), 1e-30) + relative_residuals.append( + float(np.linalg.norm(system.parent @ solution - rhs)) + / rhs_norm + ) + shift_differences.append( + float( + np.linalg.norm( + second_by_site[index] - first_by_site[index] + ) + ) + / solution_norm + ) + kernel_leakage.append( + float(np.linalg.norm(frame.conj().T @ solution)) + ) + case = ManyBodyCase( + N=system.n_particles, + n_flux=system.n_flux, + expected_rank=rank, + theta_x=system.theta_x, + theta_y=system.theta_y, + ) + return SiteResponseCache( + case=case, + site_indices=chosen, + solutions=solutions, + tangent_gram=_tangent_gram(operators), + external_gap=kernel.external_gap, + shift_values=absolute, + maximum_relative_residual=max(relative_residuals), + maximum_shift_difference=max(shift_differences), + maximum_kernel_leakage=max(kernel_leakage), + ) + + +def dense_resolvent_response( + system: KapitLaughlinParent, + kernel: KernelFrame, + site_indices: tuple[int, ...] | None = None, +) -> np.ndarray: + """Return exact dense complement responses in the supplied target gauge.""" + + chosen = ( + tuple(range(system.orbitals.shape[0])) + if site_indices is None + else tuple(int(index) for index in site_indices) + ) + operators = _site_tangent_operators(system, chosen) + eigenvalues, eigenvectors = np.linalg.eigh(system.parent.toarray()) + rank = kernel.frame.shape[1] + external_values = eigenvalues[rank:] + external_frame = eigenvectors[:, rank:] + if external_values.size == 0 or external_values[0] <= 0.0: + raise RuntimeError("dense spectral inverse has no external sector") + responses: list[np.ndarray] = [] + for operator in operators: + rhs = _project_complement( + kernel.frame, + np.asarray(operator @ kernel.frame), + ) + coefficients = external_frame.conj().T @ rhs + responses.append( + external_frame + @ (coefficients / external_values[:, None]) + ) + return np.asarray(responses) + + +def response_pair_grams(solutions: np.ndarray) -> np.ndarray: + """Return all target-space products ``A_s^dagger A_t``.""" + + values = np.asarray(solutions, dtype=complex) + if values.ndim != 3: + raise ValueError("solutions must have shape (site, ambient, rank)") + return np.einsum( + "sai,taj->stij", + values.conj(), + values, + optimize=True, + ) + + +def rotate_response_target_gauge( + cache: SiteResponseCache, + unitary: np.ndarray, +) -> SiteResponseCache: + """Return the same response cache in a rotated target frame.""" + + matrix = np.asarray(unitary, dtype=complex) + rank = cache.solutions.shape[-1] + if matrix.shape != (rank, rank): + raise ValueError("target unitary has the wrong shape") + if not np.allclose( + matrix.conj().T @ matrix, + np.eye(rank), + atol=1e-10, + ): + raise ValueError("target transformation must be unitary") + return replace( + cache, + solutions=np.einsum( + "sai,ij->saj", + cache.solutions, + matrix, + optimize=True, + ), + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/root_operators.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/root_operators.py new file mode 100644 index 000000000..3f14fb3be --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/root_operators.py @@ -0,0 +1,142 @@ +"""Exact monomial one-body blocks and accessibility complexes.""" + +from __future__ import annotations + +from dataclasses import dataclass + +import numpy as np + +from .combinatorics import RootPartition, root_descendant_partition + + +@dataclass(frozen=True) +class AccessibilityComplex: + """Two-tangent root-space accessibility complex.""" + + N: int + n: int + k: int + r: int + D: int + K1: int + Pi1: int + partition: RootPartition + response_v: np.ndarray + response_w: np.ndarray + primitive_v: np.ndarray + primitive_w: np.ndarray + stacked_response: np.ndarray + syzygy: np.ndarray + + +def onebody_block( + states: tuple[tuple[int, ...], ...], + source_indices: tuple[int, ...], + target_indices: tuple[int, ...], + tangent: np.ndarray, +) -> np.ndarray: + """Return an exact monomial-basis block of a one-body representation.""" + + matrix = np.asarray(tangent) + if matrix.ndim != 2 or matrix.shape[0] != matrix.shape[1]: + raise ValueError("tangent must be square") + if not np.issubdtype(matrix.dtype, np.integer): + raise ValueError("tangent must have integer entries") + n_flux = matrix.shape[0] + if any(len(state) != n_flux for state in states): + raise ValueError("state orbital count disagrees with tangent") + index_by_state = {state: index for index, state in enumerate(states)} + target_row = { + int(basis_index): row + for row, basis_index in enumerate(target_indices) + } + block = np.zeros( + (len(target_indices), len(source_indices)), + dtype=np.int64, + ) + for column, basis_index in enumerate(source_indices): + state = states[int(basis_index)] + for source, population in enumerate(state): + if population == 0: + continue + for destination in range(n_flux): + if destination == source: + continue + updated = list(state) + updated[source] -= 1 + updated[destination] += 1 + target_index = index_by_state[tuple(updated)] + row = target_row.get(target_index) + if row is not None: + block[row, column] += ( + int(population) + * int(matrix[destination, source]) + ) + return block + + +def accessibility_complex( + n_particles: int, + n_flux: int, + tangent_v: np.ndarray, + tangent_w: np.ndarray, + k: int = 1, + r: int = 2, +) -> AccessibilityComplex: + """Construct ``P -> E+E -> Pi`` for two integer one-body tangents.""" + + partition = root_descendant_partition( + n_particles, + n_flux, + q=1, + k=k, + r=r, + ) + response_v = onebody_block( + partition.states, + partition.zero_modes, + partition.descendant_external, + tangent_v, + ) + response_w = onebody_block( + partition.states, + partition.zero_modes, + partition.descendant_external, + tangent_w, + ) + primitive_v = onebody_block( + partition.states, + partition.descendant_external, + partition.primitive, + tangent_v, + ) + primitive_w = onebody_block( + partition.states, + partition.descendant_external, + partition.primitive, + tangent_w, + ) + stacked_response = np.concatenate( + [response_v, response_w], + axis=0, + ) + syzygy = np.concatenate( + [-primitive_w, primitive_v], + axis=1, + ) + return AccessibilityComplex( + N=int(n_particles), + n=int(n_flux), + k=int(k), + r=int(r), + D=len(partition.zero_modes), + K1=len(partition.descendant_external), + Pi1=len(partition.primitive), + partition=partition, + response_v=response_v, + response_w=response_w, + primitive_v=primitive_v, + primitive_w=primitive_w, + stacked_response=stacked_response, + syzygy=syzygy, + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/statistics.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/statistics.py new file mode 100644 index 000000000..53a574a16 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/statistics.py @@ -0,0 +1,570 @@ +"""Controlled spectral estimators for active geometric statistics.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Iterable + +import numpy as np +from scipy.optimize import curve_fit, lsq_linear + + +@dataclass(frozen=True) +class BootstrapInterval: + """Bootstrap summary of a scalar sample mean.""" + + mean: float + lower: float + upper: float + standard_error: float + replicates: int + + +@dataclass(frozen=True) +class CurveBand: + """Matrix- or block-level simultaneous confidence band.""" + + mean: np.ndarray + lower: np.ndarray + upper: np.ndarray + pointwise_lower: np.ndarray + pointwise_upper: np.ndarray + standard_error: np.ndarray + critical_value: float + replicates: int + units: int + method: str + + +def sample_poisson_spectra( + samples: int, + levels: int, + seed: int, +) -> np.ndarray: + """Sample independent exponential-spacing spectra.""" + + rng = np.random.default_rng(int(seed)) + spacings = rng.exponential(size=(int(samples), int(levels))) + spectra = np.cumsum(spacings, axis=1) + spectra -= np.mean(spectra, axis=1, keepdims=True) + return spectra + + +def sample_gue_spectra( + samples: int, + levels: int, + seed: int, +) -> np.ndarray: + """Sample finite complex Hermitian Gaussian spectra.""" + + count = int(samples) + dimension = int(levels) + if count < 1 or dimension < 3: + raise ValueError("require samples>=1 and levels>=3") + rng = np.random.default_rng(int(seed)) + spectra = np.empty((count, dimension), dtype=float) + for sample in range(count): + gaussian = ( + rng.normal(size=(dimension, dimension)) + + 1j * rng.normal(size=(dimension, dimension)) + ) + matrix = (gaussian + gaussian.conj().T) / np.sqrt( + 4.0 * dimension + ) + spectra[sample] = np.linalg.eigvalsh(matrix) + return spectra + + +def bulk_gap_ratio_per_spectrum( + spectra: np.ndarray, + bulk_fraction: float = 0.7, +) -> np.ndarray: + """Return one adjacent-gap-ratio mean per spectrum.""" + + values = np.asarray(spectra, dtype=float) + if values.ndim != 2 or values.shape[1] < 3: + raise ValueError("spectra must have shape (samples, levels>=3)") + fraction = float(bulk_fraction) + if not 0.2 <= fraction <= 1.0: + raise ValueError("bulk_fraction must lie in [0.2,1]") + result = np.empty(values.shape[0], dtype=float) + trim = int(np.floor(0.5 * (1.0 - fraction) * values.shape[1])) + for sample, spectrum in enumerate(values): + ordered = np.sort(spectrum) + bulk = ordered[ + trim : values.shape[1] - trim if trim else values.shape[1] + ] + spacings = np.diff(bulk) + if spacings.size < 2 or np.any(spacings <= 0.0): + raise ValueError("bulk spectrum has degenerate or too few levels") + ratios = np.minimum(spacings[:-1], spacings[1:]) / np.maximum( + spacings[:-1], + spacings[1:], + ) + result[sample] = float(np.mean(ratios)) + return result + + +def unfold_spectra( + spectra: np.ndarray, + method: str, +) -> np.ndarray: + """Unfold spectra by pooled CDF or per-spectrum polynomial counting.""" + + values = np.asarray(spectra, dtype=float) + if values.ndim != 2 or values.shape[1] < 4: + raise ValueError("spectra must have shape (samples,levels>=4)") + ordered = np.sort(values, axis=1) + if method == "ensemble_cdf": + pooled = np.sort(ordered.ravel()) + quantiles = np.linspace( + 0.0, + float(values.shape[1]), + pooled.size, + ) + return np.asarray( + [ + np.interp(spectrum, pooled, quantiles) + for spectrum in ordered + ] + ) + if method == "polynomial": + unfolded = np.empty_like(ordered) + target = np.arange(values.shape[1], dtype=float) + degree = min(5, values.shape[1] - 1) + for sample, spectrum in enumerate(ordered): + center = float(np.mean(spectrum)) + scale = float(np.std(spectrum)) + if scale <= 0.0: + raise ValueError("cannot unfold a constant spectrum") + standardized = (spectrum - center) / scale + coefficients = np.polynomial.chebyshev.chebfit( + standardized, + target, + degree, + ) + mapped = np.polynomial.chebyshev.chebval( + standardized, + coefficients, + ) + if np.any(np.diff(mapped) <= 0.0): + raise ValueError("polynomial unfolding is not monotone") + unfolded[sample] = mapped + return unfolded + raise ValueError("unknown unfolding method") + + +def number_variance( + unfolded_spectra: np.ndarray, + lengths: Iterable[float], + windows_per_spectrum: int = 48, +) -> dict[str, float]: + """Estimate number variance from sliding unfolded windows.""" + + spectra = np.asarray(unfolded_spectra, dtype=float) + if spectra.ndim != 2: + raise ValueError("unfolded_spectra must be two-dimensional") + result: dict[str, float] = {} + for raw_length in lengths: + length = float(raw_length) + if length <= 0.0: + raise ValueError("window lengths must be positive") + counts: list[int] = [] + for spectrum in spectra: + ordered = np.sort(spectrum) + lower = float(ordered[1]) + upper = float(ordered[-2] - length) + if upper <= lower: + continue + starts = np.linspace( + lower, + upper, + int(windows_per_spectrum), + ) + for start in starts: + counts.append( + int( + np.count_nonzero( + (ordered >= start) + & (ordered < start + length) + ) + ) + ) + if not counts: + raise ValueError("no number-variance windows were available") + result[str(length)] = float(np.var(counts, ddof=1)) + return result + + +def bootstrap_mean_interval( + values: np.ndarray, + replicates: int, + seed: int, +) -> BootstrapInterval: + """Return a percentile bootstrap interval for the mean.""" + + sample = np.asarray(values, dtype=float).ravel() + draws = int(replicates) + if sample.size < 2 or draws < 100: + raise ValueError("need at least two values and 100 replicates") + rng = np.random.default_rng(int(seed)) + indices = rng.integers( + 0, + sample.size, + size=(draws, sample.size), + ) + means = np.mean(sample[indices], axis=1) + lower, upper = np.quantile(means, (0.025, 0.975)) + return BootstrapInterval( + mean=float(np.mean(sample)), + lower=float(lower), + upper=float(upper), + standard_error=float(np.std(means, ddof=1)), + replicates=draws, + ) + + +def intervals_overlap( + first: BootstrapInterval, + second: BootstrapInterval, +) -> bool: + """Return whether two closed bootstrap intervals overlap.""" + + return bool( + max(first.lower, second.lower) + <= min(first.upper, second.upper) + ) + + +def remove_labeled_atoms( + spectrum: np.ndarray, + atom_labels: np.ndarray, +) -> np.ndarray: + """Remove only levels carrying explicit algebraic atom labels.""" + + values = np.asarray(spectrum) + labels = np.asarray(atom_labels, dtype=bool) + if values.shape != labels.shape: + raise ValueError("spectrum and labels must have matching shapes") + return values[~labels] + + +def histogram_l1( + first: np.ndarray, + second: np.ndarray, + edges: np.ndarray, +) -> float: + """Return the histogram probability-density L1 distance.""" + + bins = np.asarray(edges, dtype=float) + density_first, _ = np.histogram( + np.asarray(first).ravel(), + bins=bins, + density=True, + ) + density_second, _ = np.histogram( + np.asarray(second).ravel(), + bins=bins, + density=True, + ) + return float( + np.sum( + np.abs(density_first - density_second) * np.diff(bins) + ) + ) + + +def matrix_bootstrap_band( + curves: np.ndarray, + replicates: int, + seed: int, + groups: np.ndarray | None = None, +) -> CurveBand: + """Return a simultaneous band using matrices or independent seed blocks. + + Exact resampling is used for at most 512 independent units. Larger + matrix ensembles use the Gaussian multiplier limit of the matrix-mean + process, estimated from the full between-matrix covariance. + """ + + values = np.asarray(curves, dtype=float) + draws = int(replicates) + if values.ndim != 2 or values.shape[0] < 2 or draws < 100: + raise ValueError("require curves=(units,grid), units>=2, draws>=100") + if groups is not None: + labels = np.asarray(groups) + if labels.shape != (values.shape[0],): + raise ValueError("groups must provide one label per curve") + unique = np.unique(labels) + units = np.asarray( + [np.mean(values[labels == label], axis=0) for label in unique] + ) + method = "hierarchical_seed_block_bootstrap" + else: + units = values + method = "matrix_bootstrap" + count, grid = units.shape + rng = np.random.default_rng(int(seed)) + mean = np.mean(units, axis=0) + if count <= 512: + bootstrap = np.empty((draws, grid), dtype=float) + batch = 256 + for start in range(0, draws, batch): + stop = min(start + batch, draws) + indices = rng.integers( + 0, + count, + size=(stop - start, count), + ) + bootstrap[start:stop] = np.mean(units[indices], axis=1) + else: + centered = units - mean + covariance_mean = ( + centered.T @ centered / (count * (count - 1)) + ) + eigenvalues, eigenvectors = np.linalg.eigh( + 0.5 * (covariance_mean + covariance_mean.T) + ) + keep = eigenvalues > max( + float(eigenvalues[-1]) * 1e-12, + 0.0, + ) + factor = eigenvectors[:, keep] * np.sqrt(eigenvalues[keep])[None, :] + bootstrap = mean + rng.normal( + size=(draws, int(np.count_nonzero(keep))) + ) @ factor.T + method = "matrix_gaussian_multiplier_bootstrap" + pointwise_lower, pointwise_upper = np.quantile( + bootstrap, + (0.025, 0.975), + axis=0, + ) + standard_error = np.std(bootstrap, axis=0, ddof=1) + safe_error = np.maximum(standard_error, 1e-15) + maximum = np.max( + np.abs((bootstrap - mean) / safe_error), + axis=1, + ) + critical = float(np.quantile(maximum, 0.95)) + return CurveBand( + mean=mean, + lower=mean - critical * standard_error, + upper=mean + critical * standard_error, + pointwise_lower=pointwise_lower, + pointwise_upper=pointwise_upper, + standard_error=standard_error, + critical_value=critical, + replicates=draws, + units=count, + method=method, + ) + + +def _number_variance_matrix_curves( + unfolded_spectra: np.ndarray, + lengths: np.ndarray, + windows_per_spectrum: int = 24, +) -> np.ndarray: + spectra = np.sort(np.asarray(unfolded_spectra, dtype=float), axis=1) + scales = np.asarray(lengths, dtype=float) + if spectra.ndim != 2 or spectra.shape[1] < 8: + raise ValueError("unfolded spectra require at least eight levels") + if np.any(scales <= 0.0): + raise ValueError("lengths must be positive") + curves = np.empty((spectra.shape[0], scales.size), dtype=float) + for matrix, levels in enumerate(spectra): + for column, length in enumerate(scales): + lower = float(levels[1]) + upper = float(levels[-2] - length) + if upper <= lower: + curves[matrix, column] = np.nan + continue + starts = np.linspace(lower, upper, int(windows_per_spectrum)) + left = np.searchsorted(levels, starts, side="left") + right = np.searchsorted( + levels, + starts + length, + side="left", + ) + counts = right - left + curves[matrix, column] = float(np.var(counts, ddof=1)) + if np.any(~np.isfinite(curves)): + raise ValueError("requested length exceeds the usable bulk") + return curves + + +def number_variance_matrix_curves( + unfolded_spectra: np.ndarray, + lengths: Iterable[float], + windows_per_spectrum: int = 24, +) -> np.ndarray: + """Return one number-variance curve per input matrix.""" + + return _number_variance_matrix_curves( + unfolded_spectra, + np.asarray(tuple(float(value) for value in lengths)), + windows_per_spectrum=windows_per_spectrum, + ) + + +def spectral_rigidity( + unfolded_spectra: np.ndarray, + lengths: Iterable[float], +) -> np.ndarray: + """Estimate Dyson--Mehta rigidity from the number-variance identity.""" + + scales = np.asarray(tuple(float(value) for value in lengths)) + sigma = np.mean( + _number_variance_matrix_curves(unfolded_spectra, scales), + axis=0, + ) + result = np.empty_like(scales) + extended_x = np.concatenate([[0.0], scales]) + extended_sigma = np.concatenate([[0.0], sigma]) + for index, length in enumerate(scales): + mask = extended_x <= length + x = extended_x[mask] + values = extended_sigma[mask] + kernel = length**3 - 2.0 * length * length * x + x**3 + result[index] = ( + 2.0 + / length**4 + * np.trapezoid(kernel * values, x) + ) + return result + + +def connected_form_factor( + unfolded_spectra: np.ndarray, + times: Iterable[float], +) -> np.ndarray: + """Return the connected spectral form factor normalized by level count.""" + + spectra = np.asarray(unfolded_spectra, dtype=float) + time_grid = np.asarray(tuple(float(value) for value in times)) + if spectra.ndim != 2 or spectra.shape[1] < 2: + raise ValueError("unfolded spectra must be two-dimensional") + phases = np.exp( + -2j + * np.pi + * spectra[:, :, None] + * time_grid[None, None, :] + ) + partition = np.sum(phases, axis=1) + return ( + np.mean(np.abs(partition) ** 2, axis=0) + - np.abs(np.mean(partition, axis=0)) ** 2 + ) / spectra.shape[1] + + +def fit_size_models( + dimensions: np.ndarray, + values: np.ndarray, + sigma: np.ndarray, +) -> dict[str, dict[str, float | list[float]] | str]: + """Fit offset power laws and compare them by leave-one-size-out error.""" + + D = np.asarray(dimensions, dtype=float) + y = np.asarray(values, dtype=float) + uncertainty = np.asarray(sigma, dtype=float) + if D.ndim != 1 or D.size < 5 or y.shape != D.shape: + raise ValueError("at least five one-dimensional size points required") + if uncertainty.shape != D.shape or np.any(uncertainty <= 0.0): + raise ValueError("sigma must be positive and match dimensions") + + def fixed_fit( + x: np.ndarray, + target: np.ndarray, + error: np.ndarray, + exponent: float, + ) -> tuple[np.ndarray, np.ndarray]: + design = np.column_stack([np.ones_like(x), x ** (-exponent)]) + weighted = design / error[:, None] + rhs = target / error + solution = lsq_linear( + weighted, + rhs, + bounds=(0.0, np.inf), + ) + if not solution.success: + raise RuntimeError("bounded fixed-exponent fit failed") + parameters = solution.x + covariance = np.linalg.pinv(weighted.T @ weighted) + return parameters, covariance + + models: dict[str, dict[str, float | list[float]]] = {} + for label, exponent in (("D^-1/2", 0.5), ("D^-1", 1.0)): + parameters, covariance = fixed_fit(D, y, uncertainty, exponent) + prediction = parameters[0] + parameters[1] * D ** (-exponent) + residual = (y - prediction) / uncertainty + rss = float(np.sum(residual * residual)) + loo = [] + for held_out in range(D.size): + keep = np.arange(D.size) != held_out + local, _ = fixed_fit( + D[keep], + y[keep], + uncertainty[keep], + exponent, + ) + loo.append( + y[held_out] + - ( + local[0] + + local[1] * D[held_out] ** (-exponent) + ) + ) + models[label] = { + "offset": float(parameters[0]), + "amplitude": float(parameters[1]), + "exponent": exponent, + "offset_standard_error": float(np.sqrt(covariance[0, 0])), + "weighted_rss": rss, + "loo_rmse": float(np.sqrt(np.mean(np.square(loo)))), + "prediction": prediction.tolist(), + } + + def free_model(x, offset, amplitude, exponent): + return offset + amplitude * x ** (-exponent) + + parameters, covariance = curve_fit( + free_model, + D, + y, + sigma=uncertainty, + absolute_sigma=True, + p0=(max(0.0, float(np.min(y)) * 0.5), float(y[0]), 0.5), + bounds=([0.0, 0.0, 0.1], [np.inf, np.inf, 3.0]), + maxfev=50_000, + ) + prediction = free_model(D, *parameters) + residual = (y - prediction) / uncertainty + loo = [] + for held_out in range(D.size): + keep = np.arange(D.size) != held_out + try: + local, _ = curve_fit( + free_model, + D[keep], + y[keep], + sigma=uncertainty[keep], + absolute_sigma=True, + p0=parameters, + bounds=([0.0, 0.0, 0.1], [np.inf, np.inf, 3.0]), + maxfev=50_000, + ) + loo.append(y[held_out] - free_model(D[held_out], *local)) + except RuntimeError: + loo.append(np.nan) + models["free"] = { + "offset": float(parameters[0]), + "amplitude": float(parameters[1]), + "exponent": float(parameters[2]), + "offset_standard_error": float(np.sqrt(covariance[0, 0])), + "exponent_standard_error": float(np.sqrt(covariance[2, 2])), + "weighted_rss": float(np.sum(residual * residual)), + "loo_rmse": float(np.sqrt(np.nanmean(np.square(loo)))), + "prediction": prediction.tolist(), + } + best = min(models, key=lambda key: float(models[key]["loo_rmse"])) + return {"models": models, "best_by_loo": best} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/susy_cohomology.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/susy_cohomology.py new file mode 100644 index 000000000..5f351d090 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/susy_cohomology.py @@ -0,0 +1,308 @@ +"""Charge-resolved cubic N=2 SYK cochain complexes and BPS frames.""" + +from __future__ import annotations + +from dataclasses import dataclass +from functools import lru_cache +from itertools import combinations +from math import comb + +import numpy as np +import scipy.sparse as sp + + +@dataclass(frozen=True) +class BPSFrame: + """Spectral Hodge frame for one fixed fermion-number sector.""" + + N: int + charge: int + basis: tuple[int, ...] + projector_frame: np.ndarray + complement_frame: np.ndarray + positive_energies: np.ndarray + gap: float + kernel_residual: float + orthogonality_error: float + expected_rank: int + q_in: sp.csr_matrix + q_out: sp.csr_matrix + hamiltonian: sp.csr_matrix + + +@lru_cache(maxsize=None) +def charge_basis(N: int, charge: int) -> tuple[int, ...]: + """Return sorted occupation bit strings in a fixed charge sector.""" + + modes = int(N) + particles = int(charge) + if modes < 1: + raise ValueError("N must be positive") + if particles < 0 or particles > modes: + return () + return tuple( + state + for state in range(1 << modes) + if state.bit_count() == particles + ) + + +@lru_cache(maxsize=None) +def cubic_triples(N: int) -> tuple[tuple[int, int, int], ...]: + """Return the lexicographically ordered cubic coupling coordinates.""" + + modes = int(N) + if modes < 3: + raise ValueError("a cubic supercharge requires N >= 3") + return tuple(combinations(range(modes), 3)) + + +def normalized_complex_couplings(N: int, seed: int) -> np.ndarray: + """Draw a deterministic unit-norm isotropic complex three-form.""" + + rng = np.random.default_rng(int(seed)) + values = rng.normal(size=comb(int(N), 3)) + 1j * rng.normal( + size=comb(int(N), 3) + ) + norm = float(np.linalg.norm(values)) + if norm <= 0.0: + raise RuntimeError("complex coupling draw has zero norm") + return np.asarray(values / norm, dtype=complex) + + +def _create(state: int, mode: int) -> tuple[int, int] | None: + """Apply one fermion creation operator in the occupation basis.""" + + bit = 1 << int(mode) + if int(state) & bit: + return None + parity = (int(state) & (bit - 1)).bit_count() % 2 + return int(state) | bit, (-1 if parity else 1) + + +def _apply_cubic_creation( + state: int, + triple: tuple[int, int, int], +) -> tuple[int, int] | None: + """Apply psi_i psi_j psi_k, respecting right-to-left operator order.""" + + current = int(state) + sign = 1 + for mode in reversed(triple): + result = _create(current, mode) + if result is None: + return None + current, factor = result + sign *= factor + return current, sign + + +def cubic_supercharge( + N: int, + charge: int, + couplings: np.ndarray, +) -> sp.csr_matrix: + """Return Q_r: H_r -> H_{r+3} for a cubic complex supercharge.""" + + modes = int(N) + source_charge = int(charge) + triples = cubic_triples(modes) + coefficients = np.asarray(couplings, dtype=complex) + if coefficients.shape != (len(triples),): + raise ValueError("cubic coupling vector has the wrong shape") + source = charge_basis(modes, source_charge) + target = charge_basis(modes, source_charge + 3) + target_lookup = {state: index for index, state in enumerate(target)} + rows: list[int] = [] + columns: list[int] = [] + data: list[complex] = [] + for column, state in enumerate(source): + for coordinate, triple in enumerate(triples): + applied = _apply_cubic_creation(state, triple) + if applied is None: + continue + target_state, sign = applied + row = target_lookup.get(target_state) + if row is None: + raise RuntimeError("cubic creation left the target charge sector") + amplitude = coefficients[coordinate] * sign + if amplitude != 0.0: + rows.append(row) + columns.append(column) + data.append(amplitude) + return sp.coo_matrix( + (np.asarray(data, dtype=complex), (rows, columns)), + shape=(len(target), len(source)), + dtype=complex, + ).tocsr() + + +def charge_hamiltonian( + N: int, + charge: int, + couplings: np.ndarray, +) -> sp.csr_matrix: + """Return H_r = Q Q^dagger + Q^dagger Q in one charge sector.""" + + q_in = cubic_supercharge(N, int(charge) - 3, couplings) + q_out = cubic_supercharge(N, int(charge), couplings) + return (q_in @ q_in.getH() + q_out.getH() @ q_out).tocsr() + + +def expected_generic_bps_rank(N: int, charge: int) -> int: + """Return the registered generic BPS rank for even-N central sectors.""" + + modes = int(N) + particles = int(charge) + if modes % 2: + raise ValueError("the registered rank contract requires even N") + middle = modes // 2 + if particles == middle: + return 2 * 3 ** (middle - 1) + if abs(particles - middle) == 1: + return 3 ** (middle - 1) + return 0 + + +def decomposable_couplings(N: int, alpha: float = 1.0) -> np.ndarray: + """Return C_3 = alpha e_1 wedge e_2 wedge e_3.""" + + scale = float(alpha) + if scale <= 0.0: + raise ValueError("decomposable coupling scale must be positive") + triples = cubic_triples(int(N)) + values = np.zeros(len(triples), dtype=complex) + values[triples.index((0, 1, 2))] = scale + return values + + +def decomposable_tangent(N: int, family: str, site: int) -> np.ndarray: + """Return one canonical tangent preserving the decomposable three-form locus.""" + + pairs = {"12": (0, 1), "13": (0, 2), "23": (1, 2)} + label = str(family) + if label not in pairs: + raise ValueError("decomposable tangent family must be 12, 13, or 23") + external = int(site) + if external < 3 or external >= int(N): + raise ValueError("decomposable tangent site must lie outside modes 1,2,3") + triple = tuple(sorted((*pairs[label], external))) + triples = cubic_triples(int(N)) + values = np.zeros(len(triples), dtype=complex) + values[triples.index(triple)] = 1.0 + return values + + +def _safe_combination(n: int, k: int) -> int: + return 0 if int(k) < 0 or int(k) > int(n) else comb(int(n), int(k)) + + +def decomposable_bps_rank(N: int, charge: int) -> int: + """Return 3 binom(N-2, r-1) for the decomposable model.""" + + return 3 * _safe_combination(int(N) - 2, int(charge) - 1) + + +def analytic_decomposable_curvature_multiplicities( + N: int, + charge: int, + kind: str, +) -> dict[str, int]: + """Return Appendix-D multiplicities for diagonal/off-diagonal tangents.""" + + modes = int(N) + particles = int(charge) + label = str(kind) + if label == "diagonal": + positive = _safe_combination(modes - 4, particles - 3) + negative = _safe_combination(modes - 4, particles - 1) + elif label == "off_diagonal": + positive = _safe_combination(modes - 4, particles - 2) + negative = positive + else: + raise ValueError("curvature kind must be diagonal or off_diagonal") + rank = decomposable_bps_rank(modes, particles) + zero = rank - positive - negative + if zero < 0: + raise RuntimeError("analytic curvature multiplicities exceed BPS rank") + return {"negative": negative, "zero": zero, "positive": positive} + + +def solve_bps_frame( + N: int, + charge: int, + couplings: np.ndarray, + *, + dense_cutoff: int = 4096, + relative_tolerance: float = 1e-10, + expected_rank_override: int | None = None, +) -> BPSFrame: + """Diagonalize one registered sector and certify its harmonic fiber.""" + + basis = charge_basis(int(N), int(charge)) + if not basis: + raise ValueError("registered charge sector is empty") + if len(basis) > int(dense_cutoff): + raise ValueError("charge sector exceeds the current dense cutoff") + expected = ( + expected_generic_bps_rank(N, charge) + if expected_rank_override is None + else int(expected_rank_override) + ) + if expected <= 0 or expected >= len(basis): + raise ValueError("charge sector is outside the registered BPS sequence") + q_in = cubic_supercharge(N, int(charge) - 3, couplings) + q_out = cubic_supercharge(N, int(charge), couplings) + hamiltonian = (q_in @ q_in.getH() + q_out.getH() @ q_out).tocsr() + dense = hamiltonian.toarray() + dense = 0.5 * (dense + dense.conj().T) + eigenvalues, eigenvectors = np.linalg.eigh(dense) + scale = max(1.0, float(np.max(np.abs(eigenvalues)))) + tolerance = float(relative_tolerance) * scale + if float(np.max(np.abs(eigenvalues[:expected]))) > tolerance: + raise RuntimeError("generic BPS eigenvalues exceed the registered tolerance") + if float(eigenvalues[expected]) <= tolerance: + raise RuntimeError("generic BPS nullity exceeds the registered rank") + projector_frame = np.asarray(eigenvectors[:, :expected], dtype=complex) + complement_frame = np.asarray(eigenvectors[:, expected:], dtype=complex) + positive_energies = np.asarray(eigenvalues[expected:], dtype=float) + kernel_residual = float( + np.linalg.norm(hamiltonian @ projector_frame, ord="fro") + ) + orthogonality_error = max( + float( + np.linalg.norm( + projector_frame.conj().T @ projector_frame + - np.eye(expected), + ord="fro", + ) + ), + float( + np.linalg.norm( + complement_frame.conj().T @ complement_frame + - np.eye(complement_frame.shape[1]), + ord="fro", + ) + ), + float( + np.linalg.norm( + projector_frame.conj().T @ complement_frame, + ord="fro", + ) + ), + ) + return BPSFrame( + N=int(N), + charge=int(charge), + basis=basis, + projector_frame=projector_frame, + complement_frame=complement_frame, + positive_energies=positive_energies, + gap=float(positive_energies[0]), + kernel_residual=kernel_residual, + orthogonality_error=orthogonality_error, + expected_rank=expected, + q_in=q_in, + q_out=q_out, + hamiltonian=hamiltonian, + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/twist_bundle.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/twist_bundle.py new file mode 100644 index 000000000..3aa471aad --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/twist_bundle.py @@ -0,0 +1,332 @@ +"""Physical projected-contact zero-mode bundles over the closed twist torus.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import time +from dataclasses import dataclass +from pathlib import Path +from typing import Any, Callable + +import numpy as np + +from .bundle_geometry import BundleGeometry, analyze_frame_bundle +from .lattice import BosonBasis, build_kapit_laughlin_parent + + +MODULE_ROOT = Path(__file__).resolve().parent +SCRIPT_ROOT = MODULE_ROOT.parent +DEFAULT_CHECKPOINT_ROOT = SCRIPT_ROOT / "output" / "topology_v3_checkpoints" + + +@dataclass(frozen=True) +class TwistBundle: + """One exact quasihole bundle sampled over a periodic twist mesh.""" + + N: int + n_flux: int + rank: int + mesh: int + energies: np.ndarray + kernel_bandwidth: np.ndarray + external_gap: np.ndarray + coefficient_frames: np.ndarray + orbital_frames: np.ndarray + geometry: BundleGeometry + observed_rank_min: int + observed_rank_max: int + runtime_seconds: float + identity: dict[str, Any] + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def _identity( + N: int, + n_flux: int, + rank: int, + mesh: int, +) -> dict[str, Any]: + sources = ( + MODULE_ROOT / "twist_bundle.py", + MODULE_ROOT / "bundle_geometry.py", + MODULE_ROOT / "lattice.py", + ) + return { + "version": "v3", + "N": int(N), + "n_flux": int(n_flux), + "rank": int(rank), + "mesh": int(mesh), + "sources": { + path.name: _sha256(path) + for path in sources + }, + "numpy": np.__version__, + } + + +def _identity_hash(identity: dict[str, Any]) -> str: + encoded = json.dumps( + identity, + sort_keys=True, + separators=(",", ":"), + ).encode("utf-8") + return hashlib.sha256(encoded).hexdigest() + + +def build_twist_bundle( + N: int, + n_flux: int, + rank: int, + mesh: int, + progress: Callable[[str], None] | None = None, +) -> TwistBundle: + """Diagonalize an exact projected-contact bundle on a periodic mesh.""" + + particles = int(N) + flux = int(n_flux) + target_rank = int(rank) + grid = int(mesh) + if particles < 2 or flux < 2 * particles or target_rank < 1: + raise ValueError("invalid quasihole bundle parameters") + if grid < 3: + raise ValueError("twist mesh must be at least three") + seed_system = build_kapit_laughlin_parent( + particles, + flux, + 0.0, + 0.0, + ) + basis_dimension = seed_system.basis.dimension + physical_sites = seed_system.orbitals.shape[0] + energies = np.empty((grid, grid, target_rank + 1), dtype=float) + bandwidth = np.empty((grid, grid), dtype=float) + gap = np.empty_like(bandwidth) + coefficient_frames = np.empty( + (grid, grid, basis_dimension, target_rank), + dtype=complex, + ) + orbital_frames = np.empty( + (grid, grid, physical_sites, flux), + dtype=complex, + ) + observed_ranks: list[int] = [] + twists = 2.0 * np.pi * np.arange(grid) / grid + started = time.perf_counter() + for ix, theta_x in enumerate(twists): + for iy, theta_y in enumerate(twists): + system = build_kapit_laughlin_parent( + particles, + flux, + float(theta_x), + float(theta_y), + ) + parent = system.parent.toarray() + parent = 0.5 * (parent + parent.conj().T) + values, vectors = np.linalg.eigh(parent) + tolerance = 1e-9 * max(float(np.max(np.abs(values))), 1.0) + observed = int( + np.count_nonzero(np.abs(values) < tolerance) + ) + observed_ranks.append(observed) + if observed != target_rank: + raise RuntimeError( + f"twist ({ix},{iy}) has {observed} zero modes, " + f"expected {target_rank}" + ) + energies[ix, iy] = values[: target_rank + 1] + bandwidth[ix, iy] = float(np.ptp(values[:target_rank])) + gap[ix, iy] = float( + values[target_rank] - values[target_rank - 1] + ) + coefficient_frames[ix, iy] = vectors[:, :target_rank] + orbital_frames[ix, iy] = system.orbitals + if progress is not None: + progress(f"N={particles}, mesh={grid}: row {ix + 1}/{grid}") + basis = BosonBasis(flux, particles) + geometry = analyze_frame_bundle( + coefficient_frames, + orbital_frames, + basis, + ) + return TwistBundle( + N=particles, + n_flux=flux, + rank=target_rank, + mesh=grid, + energies=energies, + kernel_bandwidth=bandwidth, + external_gap=gap, + coefficient_frames=coefficient_frames, + orbital_frames=orbital_frames, + geometry=geometry, + observed_rank_min=min(observed_ranks), + observed_rank_max=max(observed_ranks), + runtime_seconds=time.perf_counter() - started, + identity=_identity(particles, flux, target_rank, grid), + ) + + +def save_twist_bundle( + bundle: TwistBundle, + metadata_path: Path, +) -> None: + """Save a bundle and its hash-locked array checkpoint.""" + + metadata = Path(metadata_path) + arrays_path = metadata.with_suffix(".npz") + metadata.parent.mkdir(parents=True, exist_ok=True) + temporary_arrays = arrays_path.with_suffix(".npz.tmp") + with temporary_arrays.open("wb") as handle: + np.savez_compressed( + handle, + energies=bundle.energies, + kernel_bandwidth=bundle.kernel_bandwidth, + external_gap=bundle.external_gap, + coefficient_frames=bundle.coefficient_frames, + orbital_frames=bundle.orbital_frames, + ) + temporary_arrays.replace(arrays_path) + payload = { + "identity": bundle.identity, + "identity_hash": _identity_hash(bundle.identity), + "arrays": arrays_path.name, + "arrays_sha256": _sha256(arrays_path), + "observed_rank_min": bundle.observed_rank_min, + "observed_rank_max": bundle.observed_rank_max, + "runtime_seconds": bundle.runtime_seconds, + "geometry": { + "chern_determinant": bundle.geometry.chern_determinant, + "chern_trace_log": bundle.geometry.chern_trace_log, + "determinant_branch_margin": ( + bundle.geometry.determinant_branch_margin + ), + "minimum_overlap_singular_value": ( + bundle.geometry.minimum_overlap_singular_value + ), + "maximum_link_unitarity_error": ( + bundle.geometry.maximum_link_unitarity_error + ), + "maximum_plaquette_unitarity_error": ( + bundle.geometry.maximum_plaquette_unitarity_error + ), + }, + } + temporary_metadata = metadata.with_suffix(".json.tmp") + temporary_metadata.write_text( + json.dumps(payload, indent=2, sort_keys=True), + encoding="utf-8", + ) + temporary_metadata.replace(metadata) + + +def load_twist_bundle( + metadata_path: Path, + expected_N: int, + expected_n_flux: int, + expected_rank: int, + expected_mesh: int, +) -> TwistBundle: + """Load a checkpoint only if its identity and array hash match.""" + + metadata = Path(metadata_path) + payload = json.loads(metadata.read_text(encoding="utf-8")) + expected_identity = _identity( + expected_N, + expected_n_flux, + expected_rank, + expected_mesh, + ) + if ( + payload.get("identity") != expected_identity + or payload.get("identity_hash") != _identity_hash(expected_identity) + ): + raise ValueError("checkpoint identity mismatch") + arrays_path = metadata.with_name(payload["arrays"]) + if payload.get("arrays_sha256") != _sha256(arrays_path): + raise ValueError("checkpoint array hash mismatch") + with np.load(arrays_path, allow_pickle=False) as arrays: + energies = np.asarray(arrays["energies"], dtype=float) + bandwidth = np.asarray(arrays["kernel_bandwidth"], dtype=float) + gap = np.asarray(arrays["external_gap"], dtype=float) + coefficient_frames = np.asarray( + arrays["coefficient_frames"], + dtype=complex, + ) + orbital_frames = np.asarray( + arrays["orbital_frames"], + dtype=complex, + ) + basis = BosonBasis(expected_n_flux, expected_N) + geometry = analyze_frame_bundle( + coefficient_frames, + orbital_frames, + basis, + ) + return TwistBundle( + N=int(expected_N), + n_flux=int(expected_n_flux), + rank=int(expected_rank), + mesh=int(expected_mesh), + energies=energies, + kernel_bandwidth=bandwidth, + external_gap=gap, + coefficient_frames=coefficient_frames, + orbital_frames=orbital_frames, + geometry=geometry, + observed_rank_min=int(payload["observed_rank_min"]), + observed_rank_max=int(payload["observed_rank_max"]), + runtime_seconds=float(payload["runtime_seconds"]), + identity=expected_identity, + ) + + +def default_checkpoint_path( + N: int, + mesh: int, +) -> Path: + return DEFAULT_CHECKPOINT_ROOT / f"N{int(N)}_mesh{int(mesh)}_twist_bundle_v3.json" + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--N", type=int, required=True) + parser.add_argument("--n-flux", type=int, required=True) + parser.add_argument("--rank", type=int, required=True) + parser.add_argument("--mesh", type=int, required=True) + parser.add_argument("--output", type=Path) + arguments = parser.parse_args() + bundle = build_twist_bundle( + arguments.N, + arguments.n_flux, + arguments.rank, + arguments.mesh, + progress=print, + ) + output = arguments.output or default_checkpoint_path( + arguments.N, + arguments.mesh, + ) + save_twist_bundle(bundle, output) + print(json.dumps( + { + "output": str(output), + "chern_determinant": bundle.geometry.chern_determinant, + "chern_trace_log": bundle.geometry.chern_trace_log, + "minimum_gap": float(np.min(bundle.external_gap)), + "minimum_overlap_singular_value": ( + bundle.geometry.minimum_overlap_singular_value + ), + }, + indent=2, + sort_keys=True, + )) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/wick_channels.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/wick_channels.py new file mode 100644 index 000000000..89f47f39b --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/lgeth/wick_channels.py @@ -0,0 +1,442 @@ +"""Gauge-invariant covariance-matched four-channel Wick statistics.""" + +from __future__ import annotations + +from dataclasses import dataclass + +import numpy as np + +from .manybody_response import SiteResponseCache + + +@dataclass(frozen=True) +class WhitenedChannels: + """Channel tensor after exact whitening on its label support.""" + + channels: np.ndarray + covariance: np.ndarray + covariance_eigenvalues: np.ndarray + inverse_sqrt: np.ndarray + + +@dataclass(frozen=True) +class WickResult: + """Four-channel tensor, separable Wick prediction, and residual.""" + + tensor: np.ndarray + wick_tensor: np.ndarray + connected: np.ndarray + R4: float + A_left: float + B_right: float + left_eigenvalues: np.ndarray + right_eigenvalues: np.ndarray + channel_covariance_eigenvalues: np.ndarray + + +def _toroidal_distance_squared( + first: int, + second: int, + length: int, +) -> float: + ax, ay = first % length, first // length + bx, by = second % length, second // length + dx = min(abs(ax - bx), length - abs(ax - bx)) + dy = min(abs(ay - by), length - abs(ay - by)) + return float(dx * dx + dy * dy) + + +def _farthest_site_subset( + length: int, + count: int, + start: int, + tie_order: np.ndarray, +) -> tuple[int, ...]: + sites = length * length + chosen = [int(start)] + priority = {int(site): index for index, site in enumerate(tie_order)} + while len(chosen) < count: + candidates = [site for site in range(sites) if site not in chosen] + scores = { + site: min( + _toroidal_distance_squared(site, selected, length) + for selected in chosen + ) + for site in candidates + } + best_score = max(scores.values()) + best = [site for site in candidates if scores[site] == best_score] + chosen.append(min(best, key=priority.__getitem__)) + return tuple(chosen) + + +def local_density_panels( + length: int, + panel_size: int, + panels: int, + seed: int, +) -> np.ndarray: + """Return deterministic balanced panels of mean-zero site densities.""" + + linear = int(length) + size = int(panel_size) + count = int(panels) + sites = linear * linear + if linear < 2 or not 1 <= size < sites or count < 1: + raise ValueError("invalid local-density panel dimensions") + rng = np.random.default_rng(int(seed)) + result = np.empty((count, size, sites), dtype=float) + starts = np.resize(rng.permutation(sites), count) + for panel in range(count): + tie_order = rng.permutation(sites) + chosen = _farthest_site_subset( + linear, + size, + int(starts[panel]), + tie_order, + ) + for row, site in enumerate(chosen): + result[panel, row] = -np.ones(sites, dtype=float) / sites + result[panel, row, site] += 1.0 + return result + + +def fourier_density_panel( + length: int, + panel_size: int, +) -> np.ndarray: + """Return a deterministic real low-momentum density panel.""" + + linear = int(length) + size = int(panel_size) + sites = linear * linear + if linear < 2 or not 1 <= size < sites: + raise ValueError("invalid Fourier-panel dimensions") + coordinates = np.asarray( + [(x, y) for y in range(linear) for x in range(linear)], + dtype=float, + ) + momenta = [ + (kx, ky) + for ky in range(linear) + for kx in range(linear) + if (kx, ky) != (0, 0) + ] + momenta.sort( + key=lambda momentum: ( + min(momentum[0], linear - momentum[0]) ** 2 + + min(momentum[1], linear - momentum[1]) ** 2, + momentum[1], + momentum[0], + ) + ) + selected: list[np.ndarray] = [] + for kx, ky in momenta: + phase = ( + 2.0 + * np.pi + * (kx * coordinates[:, 0] + ky * coordinates[:, 1]) + / linear + ) + for candidate in (np.cos(phase), np.sin(phase)): + vector = candidate - np.mean(candidate) + for existing in selected: + vector = vector - (existing @ vector) * existing + norm = float(np.linalg.norm(vector)) + if norm <= 1e-10: + continue + selected.append(vector / norm) + if len(selected) == size: + return np.asarray(selected) + raise RuntimeError("Fourier panel did not reach the requested rank") + + +def assemble_channels( + cache: SiteResponseCache, + coefficients: np.ndarray, +) -> np.ndarray: + """Combine and tangent-normalize cached site responses.""" + + values = np.asarray(coefficients, dtype=complex) + sites = cache.solutions.shape[0] + if values.ndim != 2 or values.shape[1] != sites: + raise ValueError("coefficients and site-response cache disagree") + gram = np.asarray(cache.tangent_gram, dtype=complex) + if gram.shape != (sites, sites): + raise ValueError("tangent Gram matrix has the wrong shape") + channels = np.empty( + (values.shape[0], cache.solutions.shape[1], cache.solutions.shape[2]), + dtype=complex, + ) + for index, vector in enumerate(values): + norm_squared = float(np.real(vector.conj() @ gram @ vector)) + if norm_squared <= 1e-20: + raise ValueError("operator panel contains a null tangent") + channels[index] = np.tensordot( + vector, + cache.solutions, + axes=(0, 0), + ) / np.sqrt(norm_squared) + return channels + + +def channel_covariance(channels: np.ndarray) -> np.ndarray: + """Return ``Tr(A_mu A_nu^dagger)/D`` on channel-label space.""" + + values = np.asarray(channels, dtype=complex) + if values.ndim != 3 or min(values.shape) < 1: + raise ValueError("channels must have shape (label, ambient, rank)") + rank = values.shape[-1] + covariance = np.einsum( + "mai,nai->mn", + values, + values.conj(), + optimize=True, + ) / rank + return 0.5 * (covariance + covariance.conj().T) + + +def whiten_channel_labels( + channels: np.ndarray, + rtol: float = 1e-10, +) -> WhitenedChannels: + """Whiten the complete numerically supported channel-label covariance.""" + + values = np.asarray(channels, dtype=complex) + covariance = channel_covariance(values) + eigenvalues, eigenvectors = np.linalg.eigh(covariance) + largest = float(eigenvalues[-1]) + if largest <= 0.0: + raise ValueError("channel-label covariance has no positive support") + if float(eigenvalues[0]) <= float(rtol) * largest: + raise ValueError("channel-label support is singular") + inverse_sqrt = ( + eigenvectors * (eigenvalues ** -0.5)[None, :] + ) @ eigenvectors.conj().T + whitened = np.einsum( + "mn,nai->mai", + inverse_sqrt, + values, + optimize=True, + ) + observed = channel_covariance(whitened) + if not np.allclose( + observed, + np.eye(values.shape[0]), + atol=2e-9, + rtol=2e-9, + ): + raise RuntimeError("channel-label whitening failed") + return WhitenedChannels( + channels=whitened, + covariance=covariance, + covariance_eigenvalues=eigenvalues, + inverse_sqrt=inverse_sqrt, + ) + + +def target_covariance(channels: np.ndarray) -> np.ndarray: + """Return the mean target-space covariance ``A_mu^dagger A_mu``.""" + + values = np.asarray(channels, dtype=complex) + covariance = np.mean( + np.einsum( + "mai,maj->mij", + values.conj(), + values, + optimize=True, + ), + axis=0, + ) + return 0.5 * (covariance + covariance.conj().T) + + +def external_covariance_eigenvalues( + channels: np.ndarray, + rtol: float = 1e-12, +) -> np.ndarray: + """Return nonzero eigenvalues of the mean external covariance by Gram reduction.""" + + values = np.asarray(channels, dtype=complex) + if values.ndim != 3: + raise ValueError("channels must have shape (label, ambient, rank)") + labels, ambient, rank = values.shape + stacked = values.transpose(1, 0, 2).reshape(ambient, labels * rank) + gram = stacked.conj().T @ stacked / labels + eigenvalues = np.linalg.eigvalsh(0.5 * (gram + gram.conj().T)) + largest = max(float(eigenvalues[-1]), 0.0) + if largest <= 0.0: + raise ValueError("external covariance has no positive support") + return eigenvalues[eigenvalues > float(rtol) * largest] + + +def four_channel_tensor(channels: np.ndarray) -> np.ndarray: + """Return ``Tr(X_mu X_nu^dagger X_rho X_sigma^dagger)/D``.""" + + values = np.asarray(channels, dtype=complex) + if values.ndim != 3: + raise ValueError("channels must have shape (label, ambient, rank)") + rank = values.shape[-1] + pair_grams = np.einsum( + "mai,naj->mnij", + values.conj(), + values, + optimize=True, + ) + return np.einsum( + "mnij,rsji->mnrs", + pair_grams, + pair_grams, + optimize=True, + ) / rank + + +def covariance_matched_wick( + channels: np.ndarray, + rtol: float = 1e-10, +) -> WickResult: + """Return the separable covariance-matched Wick residual.""" + + whitened = whiten_channel_labels(channels, rtol=rtol) + values = whitened.channels + rank = values.shape[-1] + left = target_covariance(values) + left_eigenvalues = np.linalg.eigvalsh(left) + right_eigenvalues = external_covariance_eigenvalues(values) + left_trace = float(np.sum(left_eigenvalues)) + right_trace = float(np.sum(right_eigenvalues)) + A_left = ( + rank + * float(np.sum(left_eigenvalues**2)) + / (left_trace * left_trace) + ) + B_right = ( + rank + * float(np.sum(right_eigenvalues**2)) + / (right_trace * right_trace) + ) + tensor = four_channel_tensor(values) + identity = np.eye(values.shape[0]) + wick = ( + A_left * np.einsum("mn,rs->mnrs", identity, identity) + + B_right * np.einsum("ms,rn->mnrs", identity, identity) + ) + connected = tensor - wick + denominator = float(np.linalg.norm(wick)) + if denominator <= 0.0: + raise RuntimeError("Wick tensor has zero norm") + return WickResult( + tensor=tensor, + wick_tensor=wick, + connected=connected, + R4=float(np.linalg.norm(connected) / denominator), + A_left=A_left, + B_right=B_right, + left_eigenvalues=left_eigenvalues, + right_eigenvalues=right_eigenvalues, + channel_covariance_eigenvalues=whitened.covariance_eigenvalues, + ) + + +def sample_matched_gaussian_channels( + left_eigenvalues: np.ndarray, + right_eigenvalues: np.ndarray, + channel_count: int, + rng: np.random.Generator, +) -> np.ndarray: + """Draw a separable complex Gaussian response tensor.""" + + left = np.asarray(left_eigenvalues, dtype=float) + right = np.asarray(right_eigenvalues, dtype=float) + labels = int(channel_count) + if ( + left.ndim != 1 + or right.ndim != 1 + or left.size == 0 + or right.size == 0 + or labels < 1 + or np.any(left <= 0.0) + or np.any(right <= 0.0) + ): + raise ValueError("Gaussian covariance spectra must be positive vectors") + left = left / np.sum(left) + right = right / np.sum(right) + gaussian = ( + rng.normal(size=(labels, right.size, left.size)) + + 1j * rng.normal(size=(labels, right.size, left.size)) + ) / np.sqrt(2.0) + return ( + np.sqrt(right)[None, :, None] + * gaussian + * np.sqrt(left)[None, None, :] + ) + + +def _fast_covariance_matched_r4( + channels: np.ndarray, +) -> float: + """Return ``R4`` without diagonalizing the external covariance.""" + + values = whiten_channel_labels(channels).channels + labels = values.shape[0] + rank = values.shape[-1] + pair_grams = np.einsum( + "mai,naj->mnij", + values.conj(), + values, + optimize=True, + ) + left = np.mean( + pair_grams[np.arange(labels), np.arange(labels)], + axis=0, + ) + left_trace = float(np.trace(left).real) + A_left = ( + rank + * float(np.trace(left @ left).real) + / (left_trace * left_trace) + ) + right_trace = left_trace + right_trace_square = ( + float(np.sum(np.abs(pair_grams) ** 2)) / (labels * labels) + ) + B_right = ( + rank * right_trace_square / (right_trace * right_trace) + ) + tensor = np.einsum( + "mnij,rsji->mnrs", + pair_grams, + pair_grams, + optimize=True, + ) / rank + identity = np.eye(labels) + wick = ( + A_left * np.einsum("mn,rs->mnrs", identity, identity) + + B_right * np.einsum("ms,rn->mnrs", identity, identity) + ) + return float(np.linalg.norm(tensor - wick) / np.linalg.norm(wick)) + + +def gaussian_r4_reference( + left_eigenvalues: np.ndarray, + right_eigenvalues: np.ndarray, + channel_count: int, + samples: int, + seed: int, +) -> np.ndarray: + """Return finite-size covariance-matched Gaussian ``R4`` samples.""" + + count = int(samples) + if count < 1: + raise ValueError("Gaussian reference requires at least one sample") + rng = np.random.default_rng(int(seed)) + result = np.empty(count, dtype=float) + for sample in range(count): + channels = sample_matched_gaussian_channels( + left_eigenvalues, + right_eigenvalues, + channel_count, + rng, + ) + result[sample] = _fast_covariance_matched_r4(channels) + return result diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_geometric_eth_topology_assets_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_geometric_eth_topology_assets_v3.py new file mode 100644 index 000000000..eb055ee65 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_geometric_eth_topology_assets_v3.py @@ -0,0 +1,272 @@ +#!/usr/bin/env python3 +"""Generate manuscript-facing v3 macros, tables, and provenance.""" + +from __future__ import annotations + +import hashlib +import json +import subprocess +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + + +SCRIPT_ROOT = Path(__file__).resolve().parent +REPO_ROOT = SCRIPT_ROOT.parents[2] +OUTPUT = SCRIPT_ROOT / "output" +MATRIX_JSON = OUTPUT / "matrix_element_geometric_eth_v3.json" +TOPOLOGY_JSON = OUTPUT / "topological_holonomy_v3.json" +MATRIX_AUDIT = OUTPUT / "matrix_element_delivery_audit_v3.json" +TOPOLOGY_AUDIT = OUTPUT / "topological_holonomy_delivery_audit_v3.json" +FIGURE_6 = OUTPUT / "figure_6_wick_factorization_v3.pdf" +FIGURE_7 = OUTPUT / "figure_7_topological_holonomy_v3.pdf" +NUMBERS = OUTPUT / "generated_numbers_v3.tex" +TABLES = OUTPUT / "generated_tables_v3.tex" +MANIFEST = OUTPUT / "geometric_eth_topology_assets_v3.json" +OVERLEAF_GENERATED = ( + REPO_ROOT / "overleaf_sync" / "geometric_eth_large_scale" / "generated" +) + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def _atomic_text(path: Path, text: str) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(text, encoding="utf-8") + temporary.replace(path) + + +def _atomic_json(path: Path, payload: dict[str, Any]) -> None: + _atomic_text(path, json.dumps(payload, indent=2, sort_keys=True)) + + +def _fmt(value: float, digits: int = 5) -> str: + return f"{float(value):.{digits}f}" + + +def _macro(name: str, value: str) -> str: + return rf"\newcommand{{\{name}}}{{{value}}}" + + +def generate_assets() -> dict[str, Any]: + matrix = json.loads(MATRIX_JSON.read_text(encoding="utf-8")) + topology = json.loads(TOPOLOGY_JSON.read_text(encoding="utf-8")) + matrix_audit = json.loads(MATRIX_AUDIT.read_text(encoding="utf-8")) + topology_audit = json.loads( + TOPOLOGY_AUDIT.read_text(encoding="utf-8") + ) + if not matrix_audit["passed"] or not topology_audit["passed"]: + raise RuntimeError("independent v3 audits must pass before assets") + largest = matrix["cases"][-1] + top3, top4 = topology["sizes"] + macros = [ + "% Generated from audited v3 artifacts by the release pipeline.", + _macro( + "MatrixElementBranch", + matrix["result_branch"].replace("_", r"\_"), + ), + _macro( + "MatrixElementBranchText", + ( + "The four-channel residual decreases along the genuine " + "many-body sequence and retains a resolved connected " + "component at the largest size." + ), + ), + _macro("LargestManyBodyN", str(largest["N"])), + _macro("LargestManyBodyRank", str(largest["rank"])), + _macro("LargestManyBodyDimension", str(largest["basis_dimension"])), + _macro("LargestNRFour", _fmt(largest["physical_R4_median"])), + _macro("LargestGaussianRFour", _fmt(largest["gaussian_R4_interval"][1])), + _macro( + "LargestGaussianRFourLow", + _fmt(largest["gaussian_R4_interval"][0]), + ), + _macro( + "LargestGaussianRFourHigh", + _fmt(largest["gaussian_R4_interval"][2]), + ), + _macro( + "LargestRFourExcess", + _fmt(largest["physical_excess"]), + ), + _macro( + "TopologyBranch", + topology["result_branch"].replace("_", r"\_"), + ), + _macro( + "TopologyBranchText", + ( + "The Chern class and complete spectrum remain fixed while " + "Wilson statistics change significantly and occupy a " + "structured class distinct from the circular-unitary " + "reference." + ), + ), + _macro("TopologyPrimaryMesh", str(topology["configuration"]["primary_mesh"])), + _macro( + "TopologyConvergenceMesh", + str(topology["configuration"]["convergence_mesh"]), + ), + _macro("TopologyNThreeChern", str(top3["base_chern_integer"])), + _macro("TopologyNFourChern", str(top4["base_chern_integer"])), + _macro("TopologyNThreeGap", _fmt(top3["minimum_external_gap"], 6)), + _macro("TopologyNFourGap", _fmt(top4["minimum_external_gap"], 6)), + _macro( + "TopologyNThreeGapChangeLow", + _fmt(top3["gap_change_interval"][0]), + ), + _macro( + "TopologyNThreeGapChangeHigh", + _fmt(top3["gap_change_interval"][2]), + ), + _macro( + "TopologyNFourGapChangeLow", + _fmt(top4["gap_change_interval"][0]), + ), + _macro( + "TopologyNFourGapChangeHigh", + _fmt(top4["gap_change_interval"][2]), + ), + _macro( + "TopologyNThreeFinalGapRatio", + _fmt(top3["final_gap_ratio_interval"][1]), + ), + _macro( + "TopologyNFourFinalGapRatio", + _fmt(top4["final_gap_ratio_interval"][1]), + ), + _macro( + "TopologyNThreeCUERatio", + _fmt(top3["cue_gap_ratio_interval"][1]), + ), + _macro( + "TopologyNFourCUERatio", + _fmt(top4["cue_gap_ratio_interval"][1]), + ), + _macro( + "TopologyMinimumBranchMargin", + _fmt( + min( + top3["minimum_branch_margin"], + top4["minimum_branch_margin"], + ) + ), + ), + _macro( + "TopologyMinimumOverlap", + _fmt( + min( + top3["minimum_overlap_singular_value"], + top4["minimum_overlap_singular_value"], + ) + ), + ), + _macro( + "TopologyGaugeError", + f"{topology['random_gauge_errors']['wilson_phase_error']:.2e}", + ), + "", + ] + matrix_rows = [] + for case in matrix["cases"]: + matrix_rows.append( + " & ".join( + [ + str(case["N"]), + str(case["n_flux"]), + str(case["rank"]), + str(case["basis_dimension"]), + _fmt(case["external_gap"], 6), + _fmt(case["physical_R4_median"]), + _fmt(case["gaussian_R4_interval"][1]), + _fmt(case["physical_excess"]), + ] + ) + + r" \\" + ) + topology_rows = [] + for size in topology["sizes"]: + topology_rows.append( + " & ".join( + [ + str(size["N"]), + str(size["rank"]), + str(size["base_chern_integer"]), + _fmt(size["minimum_external_gap"], 6), + _fmt(size["minimum_branch_margin"]), + _fmt(size["minimum_overlap_singular_value"]), + _fmt(size["final_gap_ratio_interval"][1]), + _fmt(size["cue_gap_ratio_interval"][1]), + ] + ) + + r" \\" + ) + tables = "\n".join( + [ + "% Generated from audited v3 artifacts by the release pipeline.", + r"\newcommand{\MatrixElementResultRows}{%", + *matrix_rows, + "}", + r"\newcommand{\TopologyResultRows}{%", + *topology_rows, + "}", + "", + ] + ) + number_text = "\n".join(macros) + _atomic_text(NUMBERS, number_text) + _atomic_text(TABLES, tables) + _atomic_text(OVERLEAF_GENERATED / NUMBERS.name, number_text) + _atomic_text(OVERLEAF_GENERATED / TABLES.name, tables) + commit = subprocess.run( + ["git", "rev-parse", "HEAD"], + cwd=REPO_ROOT, + check=True, + capture_output=True, + text=True, + ).stdout.strip() + inputs = ( + MATRIX_JSON, + TOPOLOGY_JSON, + MATRIX_AUDIT, + TOPOLOGY_AUDIT, + FIGURE_6, + FIGURE_7, + ) + result = { + "version": "v3", + "generated_utc": datetime.now(timezone.utc).isoformat(), + "git_commit": commit, + "matrix_branch": matrix["result_branch"], + "topology_branch": topology["result_branch"], + "input_hashes": { + str(path.relative_to(SCRIPT_ROOT)): _sha256(path) + for path in inputs + }, + "output_hashes": { + str(path.relative_to(SCRIPT_ROOT)): _sha256(path) + for path in (NUMBERS, TABLES) + }, + "overleaf_hashes": { + str(path.relative_to(REPO_ROOT)): _sha256(path) + for path in ( + OVERLEAF_GENERATED / NUMBERS.name, + OVERLEAF_GENERATED / TABLES.name, + ) + }, + "source_sha256": _sha256(Path(__file__)), + } + _atomic_json(MANIFEST, result) + return result + + +def main() -> None: + print(json.dumps(generate_assets(), indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_large_scale_figures_v1.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_large_scale_figures_v1.py new file mode 100644 index 000000000..98154e733 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_large_scale_figures_v1.py @@ -0,0 +1,811 @@ +#!/usr/bin/env python3 +"""Create the five publication figures and generated LaTeX inputs.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +from pathlib import Path +from typing import Any + +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt +import numpy as np +from scipy.ndimage import gaussian_filter1d + + +VERSION = "v1" +FIGURE_WIDTH = 7.0 +DPI = 300 +COLORS = { + "physical": "#0072B2", + "haar": "#222222", + "deformed": "#E69F00", + "atom": "#CC79A7", + "reference": "#666666", + "accent": "#009E73", +} +LABELS = { + "physical": "physical", + "haar": "Haar--Jacobi", + "deformed": "covariance model", +} + + +def _style() -> None: + plt.rcParams.update( + { + "font.family": "serif", + "font.serif": ["STIX Two Text", "STIXGeneral", "DejaVu Serif"], + "mathtext.fontset": "stix", + "font.size": 8.2, + "axes.labelsize": 8.5, + "axes.titlesize": 9.0, + "legend.fontsize": 7.2, + "xtick.labelsize": 7.4, + "ytick.labelsize": 7.4, + "axes.linewidth": 0.75, + "lines.linewidth": 1.35, + "savefig.facecolor": "white", + "figure.facecolor": "white", + "axes.facecolor": "white", + "axes.spines.top": False, + "axes.spines.right": False, + } + ) + + +def _panel(ax, label: str, title: str) -> None: + ax.text( + -0.12, + 1.04, + f"({label})", + transform=ax.transAxes, + fontweight="bold", + va="bottom", + ) + ax.set_title(title, loc="left", pad=5.0) + + +def _band( + ax, + x: np.ndarray, + arrays: Any, + prefix: str, + color: str, + label: str, +) -> None: + mean = arrays[f"{prefix}_mean"] + lower = arrays[f"{prefix}_lower"] + upper = arrays[f"{prefix}_upper"] + ax.fill_between(x, lower, upper, color=color, alpha=0.16, linewidth=0) + ax.plot(x, mean, color=color, label=label) + + +def _save(fig, output_dir: Path, stem: str) -> dict[str, Any]: + pdf = output_dir / f"{stem}.pdf" + png = output_dir / f"{stem}.png" + fig.savefig(pdf, format="pdf") + fig.savefig(png, format="png", dpi=DPI) + plt.close(fig) + return { + "pdf": str(pdf), + "png": str(png), + "width_inches": FIGURE_WIDTH, + "png_width_pixels": int(round(FIGURE_WIDTH * DPI)), + "dpi": DPI, + } + + +def _figure_physical_law( + stat: Any, + covariance: dict[str, Any], + output_dir: Path, +) -> dict[str, Any]: + grid = stat["density_grid"] + fig = plt.figure(figsize=(FIGURE_WIDTH, 4.65), layout="constrained") + axes = fig.subplot_mosaic( + [["density", "density"], ["residual", "moments"]], + height_ratios=[1.25, 1.0], + ) + ax = axes["density"] + for name in ("haar", "deformed", "physical"): + _band( + ax, + grid, + stat, + f"{name}_density", + COLORS[name], + LABELS[name], + ) + ax.set_xlim(-1.0, 1.0) + ax.set_ylabel(r"one-point density $\rho(\lambda)$") + ax.set_xlabel(r"normalized curvature eigenvalue $\lambda$") + ax.legend(frameon=False, ncol=3, loc="upper center") + _panel(ax, "a", "High-statistics physical law") + + ax = axes["residual"] + physical = stat["physical_density_mean"] + for name in ("haar", "deformed"): + difference = physical - stat[f"{name}_density_mean"] + standard_error = np.sqrt( + stat["physical_density_standard_error"] ** 2 + + stat[f"{name}_density_standard_error"] ** 2 + ) + color = COLORS[name] + ax.fill_between( + grid, + difference - 2.5 * standard_error, + difference + 2.5 * standard_error, + color=color, + alpha=0.16, + linewidth=0, + ) + ax.plot( + grid, + difference, + color=color, + label=f"physical $-$ {LABELS[name]}", + ) + ax.axhline(0.0, color="#777777", linewidth=0.7) + ax.set_xlim(-1.0, 1.0) + ax.set_xlabel(r"$\lambda$") + ax.set_ylabel(r"density residual") + ax.legend(frameon=False, loc="upper left") + _panel(ax, "b", "Resolved global deformation") + + ax = axes["moments"] + orders = stat["moment_orders"] + width = 0.22 + positions = np.arange(orders.size) + for shift, name in zip( + (-width, 0.0, width), + ("haar", "deformed", "physical"), + strict=True, + ): + mean = stat[f"{name}_moments_mean"] + error = stat[f"{name}_moments_standard_error"] + ax.bar( + positions + shift, + mean, + width=width, + color=COLORS[name], + alpha=0.82, + label=LABELS[name], + yerr=1.96 * error, + capsize=2, + linewidth=0, + ) + ax.set_xticks(positions, [rf"$m_{{{int(order)}}}$" for order in orders]) + ax.set_ylabel(r"$D^{-1}\langle\mathrm{Tr}\,\Omega^k\rangle$") + ax.set_yscale("log") + ax.legend(frameon=False, ncol=1, loc="upper right") + _panel(ax, "c", "Moments through eighth order") + return _save(fig, output_dir, "figure_1_physical_law_v1") + + +def _figure_scale_hierarchy( + stat: Any, + output_dir: Path, +) -> dict[str, Any]: + fig, axes = plt.subplots( + 2, + 2, + figsize=(FIGURE_WIDTH, 5.2), + layout="constrained", + ) + configurations = ( + ( + axes[0, 0], + stat["ratio_centers"], + "ratio", + r"$P(r)$", + r"adjacent-gap ratio $r$", + "a", + "Local level repulsion", + ), + ( + axes[0, 1], + stat["lengths"], + "number", + r"$\Sigma^2(L)$", + r"window length $L$", + "b", + "Number variance", + ), + ( + axes[1, 0], + stat["lengths"], + "rigidity", + r"$\Delta_3(L)$", + r"window length $L$", + "c", + "Spectral rigidity", + ), + ( + axes[1, 1], + stat["form_factor_times"], + "form_factor", + r"$K_c(\tau)$", + r"scaled time $\tau$", + "d", + "Connected form factor", + ), + ) + for ax, x, metric, ylabel, xlabel, label, title in configurations: + for name in ("haar", "deformed", "physical"): + _band( + ax, + x, + stat, + f"{name}_{metric}", + COLORS[name], + LABELS[name], + ) + ax.set_xlabel(xlabel) + ax.set_ylabel(ylabel) + _panel(ax, label, title) + axes[0, 0].legend(frameon=False, loc="lower right") + axes[1, 1].set_xlim(0.0, 1.5) + axes[1, 1].set_ylim(bottom=-0.04) + return _save(fig, output_dir, "figure_2_scale_hierarchy_v1") + + +def _hist_density(values: np.ndarray, grid: np.ndarray) -> np.ndarray: + edges = np.linspace(-1.02, 1.02, 409) + density, _ = np.histogram(values.ravel(), bins=edges, density=True) + centers = 0.5 * (edges[:-1] + edges[1:]) + smoothed = gaussian_filter1d(density, 2.0) + curve = np.interp(grid, centers, smoothed) + return curve / np.trapezoid(curve, grid) + + +def _figure_atom_crossover( + scaling_json: dict[str, Any], + scaling: Any, + output_dir: Path, +) -> dict[str, Any]: + cases = scaling_json["cases"] + grid = np.linspace(-1.0, 1.0, 500) + fig, (ax, atom_ax) = plt.subplots( + 1, + 2, + figsize=(FIGURE_WIDTH, 4.7), + gridspec_kw={"width_ratios": [2.2, 1.0]}, + layout="constrained", + ) + colors = plt.cm.viridis(np.linspace(0.12, 0.9, len(cases))) + offset = 0.9 + for index, (case, color) in enumerate( + zip(cases, colors, strict=True) + ): + n = case["n"] + physical = _hist_density( + scaling[f"n{n}_interior_spectra"], + grid, + ) + reference = _hist_density( + scaling[f"n{n}_reference_interior_spectra"], + grid, + ) + baseline = index * offset + ax.fill_between( + grid, + baseline, + baseline + 0.52 * physical / np.max(physical), + color=color, + alpha=0.60, + linewidth=0, + ) + ax.plot( + grid, + baseline + 0.52 * physical / np.max(physical), + color=color, + linewidth=1.15, + ) + ax.plot( + grid, + baseline + 0.52 * reference / np.max(reference), + color=COLORS["reference"], + linewidth=0.75, + linestyle=(0, (2, 2)), + ) + ax.set_yticks( + np.arange(len(cases)) * offset + 0.16, + [ + rf"$D={case['D']}$" + ( + rf", $a={case['plus_atoms_per_matrix']}$" + if case["plus_atoms_per_matrix"] + else "" + ) + for case in cases + ], + ) + ax.set_xlabel(r"interior eigenvalue $\lambda$") + ax.set_ylabel("increasing root rank") + ax.set_xlim(-1.0, 1.0) + ax.set_ylim(-0.08, (len(cases) - 1) * offset + 0.72) + ax.plot([], [], color=COLORS["reference"], linestyle=(0, (2, 2)), + label="exact Jacobi") + ax.plot([], [], color=colors[-1], label="root response") + ax.legend( + frameon=False, + loc="center", + bbox_to_anchor=(0.53, 0.105), + ncol=2, + ) + _panel(ax, "a", "Continuous spectrum across the capacity boundary") + + D = np.asarray([case["D"] for case in cases], dtype=float) + M = np.asarray([case["M"] for case in cases], dtype=float) + atom_weight = np.asarray( + [ + 2.0 * case["plus_atoms_per_matrix"] / case["D"] + for case in cases + ] + ) + atom_ax.plot( + D, + D / M, + color=COLORS["accent"], + marker="o", + label=r"capacity ratio $D/M$", + ) + atom_ax.axhline(1.0, color="#777777", linestyle="--", linewidth=0.8) + atom_ax.set_xscale("log") + atom_ax.set_xlabel(r"active rank $D$") + atom_ax.set_ylabel(r"$D/M$") + atom_ax.set_ylim(0.0, 1.35) + twin = atom_ax.twinx() + twin.plot( + D, + atom_weight, + color=COLORS["atom"], + marker="s", + label="total atom weight", + ) + twin.set_ylabel(r"$2(D-M)_+/D$", color=COLORS["atom"]) + twin.tick_params(axis="y", colors=COLORS["atom"]) + twin.set_ylim(0.0, 0.36) + handles, labels = atom_ax.get_legend_handles_labels() + handles2, labels2 = twin.get_legend_handles_labels() + atom_ax.legend( + handles + handles2, + labels + labels2, + frameon=False, + loc="upper left", + ) + _panel(atom_ax, "b", "Exact atom onset at $D=M$") + return _save(fig, output_dir, "figure_3_atom_crossover_v1") + + +def _fit_curve(model: dict[str, Any], grid: np.ndarray) -> np.ndarray: + return ( + model["offset"] + + model["amplitude"] * grid ** (-model["exponent"]) + ) + + +def _figure_finite_size( + statistical_json: dict[str, Any], + stat: Any, + output_dir: Path, +) -> dict[str, Any]: + D = stat["scaling_D"] + grid = np.geomspace(float(np.min(D)), float(np.max(D)), 300) + fig, axes = plt.subplots( + 1, + 3, + figsize=(FIGURE_WIDTH, 2.75), + layout="constrained", + ) + panels = ( + ( + axes[0], + "density_l1", + stat["scaling_density_l1"], + stat["scaling_density_se"], + r"interior density $L^1$", + "a", + "Global density", + ), + ( + axes[1], + "gap_ratio_difference", + stat["scaling_gap_difference"], + stat["scaling_gap_se"], + r"$|\Delta\langle r\rangle|$", + "b", + "Local repulsion", + ), + ( + axes[2], + "participation_deficit", + 1.0 - stat["scaling_participation"], + stat["scaling_participation_se"], + r"$1-\mathcal{P}$", + "c", + "Channel participation", + ), + ) + atom_mask = stat["scaling_atom_weight"] > 0 + for ax, key, y, error, ylabel, label, title in panels: + fit = statistical_json["finite_size_fits"][key] + best = fit["best_by_loo"] + model = fit["models"][best] + ax.errorbar( + D[~atom_mask], + y[~atom_mask], + yerr=1.96 * error[~atom_mask], + fmt="o", + color=COLORS["physical"], + capsize=2, + label="atom free", + ) + ax.errorbar( + D[atom_mask], + y[atom_mask], + yerr=1.96 * error[atom_mask], + fmt="s", + color=COLORS["atom"], + capsize=2, + label="atom sector present", + ) + ax.plot( + grid, + _fit_curve(model, grid), + color=COLORS["haar"], + linestyle="--", + label=rf"best LOO: $p={model['exponent']:.2f}$", + ) + ax.set_xscale("log") + ax.set_yscale("log") + ax.set_xlabel(r"active rank $D$") + ax.set_ylabel(ylabel) + ax.legend(frameon=False, loc="upper right") + _panel(ax, label, title) + return _save(fig, output_dir, "figure_4_finite_size_v1") + + +def _figure_covariance_mechanism( + covariance_json: dict[str, Any], + covariance: Any, + statistical_json: dict[str, Any], + stat: Any, + output_dir: Path, +) -> dict[str, Any]: + fig, axes = plt.subplots( + 2, + 2, + figsize=(FIGURE_WIDTH, 5.0), + layout="constrained", + ) + eigenvalues = np.sort(covariance["covariance_eigenvalues"])[::-1] + eigenvalues = eigenvalues / np.mean(eigenvalues) + ax = axes[0, 0] + ax.plot( + np.arange(1, eigenvalues.size + 1), + eigenvalues, + color=COLORS["physical"], + ) + ax.axhline(1.0, color=COLORS["haar"], linestyle="--", linewidth=0.8) + ax.set_yscale("log") + ax.set_xlabel("covariance eigenvalue index") + ax.set_ylabel(r"$c_\alpha/\overline{c}$") + _panel(ax, "a", "Learned channel covariance") + + ax = axes[0, 1] + floors = np.asarray(covariance_json["candidate_floors"]) + density = np.asarray( + [ + covariance_json["validation_scores"][str(value)][ + "density_l1" + ] + for value in floors + ] + ) + gap = np.asarray( + [ + covariance_json["validation_scores"][str(value)][ + "gap_ratio_difference" + ] + for value in floors + ] + ) + ax.plot( + floors, + density, + marker="o", + color=COLORS["deformed"], + label="density $L^1$", + ) + ax.set_xscale("log") + ax.set_xlabel("eigenvalue floor") + ax.set_ylabel(r"validation density $L^1$") + twin = ax.twinx() + twin.plot( + floors, + gap, + marker="s", + color=COLORS["physical"], + label=r"$|\Delta\langle r\rangle|$", + ) + twin.set_ylabel(r"validation $|\Delta\langle r\rangle|$") + selected = covariance_json["selected_floor"] + ax.axvline(selected, color="#777777", linestyle=":", linewidth=0.9) + ax.text( + selected, + np.max(density), + f" selected {selected:g}", + ha="left", + va="top", + fontsize=7.0, + ) + handles, labels = ax.get_legend_handles_labels() + handles2, labels2 = twin.get_legend_handles_labels() + ax.legend( + handles + handles2, + labels + labels2, + frameon=False, + loc="lower left", + ) + _panel(ax, "b", "Validation-only regularization") + + ax = axes[1, 0] + orders = stat["moment_orders"] + physical = stat["physical_moments_mean"] + for name, marker in (("haar", "o"), ("deformed", "s")): + ratio = stat[f"{name}_moments_mean"] / physical + ratio_error = stat[f"{name}_moments_standard_error"] / physical + ax.errorbar( + orders, + ratio, + yerr=1.96 * ratio_error, + marker=marker, + color=COLORS[name], + capsize=2, + label=LABELS[name], + ) + ax.axhline(1.0, color=COLORS["physical"], linewidth=1.0, + label="physical target") + ax.set_xticks(orders) + ax.set_xlabel("moment order") + ax.set_ylabel("model / physical") + ax.legend(frameon=False, loc="best") + _panel(ax, "c", "Global moments") + + ax = axes[1, 1] + bandwidth = statistical_json["sensitivity"]["bandwidth"] + widths = np.asarray([float(value) for value in bandwidth]) + haar_l1 = np.asarray( + [bandwidth[str(value)]["physical_haar_l1"] for value in widths] + ) + deformed_l1 = np.asarray( + [ + bandwidth[str(value)]["physical_deformed_l1"] + for value in widths + ] + ) + ax.plot( + widths, + haar_l1, + marker="o", + color=COLORS["haar"], + label=LABELS["haar"], + ) + ax.plot( + widths, + deformed_l1, + marker="s", + color=COLORS["deformed"], + label=LABELS["deformed"], + ) + ax.set_xlabel("KDE bandwidth") + ax.set_ylabel(r"test density $L^1$") + ax.legend(frameon=False, loc="best") + _panel(ax, "d", "Bandwidth-stable improvement") + return _save(fig, output_dir, "figure_5_covariance_mechanism_v1") + + +def _sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for chunk in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def _write_generated_inputs( + output_dir: Path, + physical_json: dict[str, Any], + covariance_json: dict[str, Any], + scaling_json: dict[str, Any], + statistical_json: dict[str, Any], + stat: Any, +) -> None: + held_out = covariance_json["held_out_test"] + largest = scaling_json["cases"][-1] + physical_case = physical_json["physical_case"] + density_fit = statistical_json["finite_size_fits"]["density_l1"][ + "models" + ]["free"] + length_index = int(np.argmin(np.abs(stat["lengths"] - 8.0))) + time_index = int( + np.argmin(np.abs(stat["form_factor_times"] - 0.5)) + ) + lines = [ + rf"\newcommand{{\PhysicalMatrices}}{{{physical_json['sample_count']}}}", + rf"\newcommand{{\PhysicalTestMatrices}}{{{statistical_json['physical_test_matrices']}}}", + rf"\newcommand{{\PhysicalRank}}{{{physical_case['D']}}}", + rf"\newcommand{{\PhysicalChannels}}{{{physical_case['M']}}}", + rf"\newcommand{{\TrainingRows}}{{{covariance_json['diagnostic_training_rows']}}}", + rf"\newcommand{{\HaarMatrices}}{{{statistical_json['haar_matrices']}}}", + rf"\newcommand{{\DeformedMatrices}}{{{statistical_json['deformed_matrices']}}}", + rf"\newcommand{{\SelectedCovFloor}}{{{covariance_json['selected_floor']:.3f}}}", + rf"\newcommand{{\DensityHaarLone}}{{{held_out['density_l1']['physical_vs_haar']:.4f}}}", + rf"\newcommand{{\DensityCovLone}}{{{held_out['density_l1']['physical_vs_deformed']:.4f}}}", + rf"\newcommand{{\DensityImprovementPercent}}{{{100.0 * held_out['density_l1']['relative_improvement']:.1f}\%}}", + rf"\newcommand{{\PhysicalGapRatio}}{{{held_out['mean_gap_ratio']['physical']:.6f}}}", + rf"\newcommand{{\HaarGapRatio}}{{{held_out['mean_gap_ratio']['haar']:.6f}}}", + rf"\newcommand{{\DeformedGapRatio}}{{{held_out['mean_gap_ratio']['deformed']:.6f}}}", + rf"\newcommand{{\LargestRank}}{{{largest['D']}}}", + rf"\newcommand{{\LargestChannels}}{{{largest['M']}}}", + rf"\newcommand{{\LargestAtomMultiplicity}}{{{largest['plus_atoms_per_matrix']}}}", + rf"\newcommand{{\LargestAtomWeightPercent}}{{{100.0 * 2 * largest['plus_atoms_per_matrix'] / largest['D']:.1f}\%}}", + rf"\newcommand{{\LargestInteriorDensityLone}}{{{largest['interior_density_l1']:.4f}}}", + rf"\newcommand{{\DensityFitExponent}}{{{density_fit['exponent']:.3f}}}", + rf"\newcommand{{\BootstrapReplicates}}{{{statistical_json['bootstrap_replicates']}}}", + rf"\newcommand{{\RootMatricesTotal}}{{{sum(case['samples'] for case in scaling_json['cases'])}}}", + rf"\newcommand{{\CovarianceAnisotropy}}{{{covariance_json['training_geometry']['relative_frobenius_anisotropy']:.3f}}}", + rf"\newcommand{{\PhysicalParticipation}}{{{covariance_json['training_geometry']['mean_participation_fraction']:.3f}}}", + rf"\newcommand{{\NumberVariancePhysEight}}{{{float(stat['physical_number_mean'][length_index]):.3f}}}", + rf"\newcommand{{\NumberVarianceHaarEight}}{{{float(stat['haar_number_mean'][length_index]):.3f}}}", + rf"\newcommand{{\NumberVarianceCovEight}}{{{float(stat['deformed_number_mean'][length_index]):.3f}}}", + rf"\newcommand{{\FormFactorPhysHalf}}{{{float(stat['physical_form_factor_mean'][time_index]):.3f}}}", + rf"\newcommand{{\FormFactorHaarHalf}}{{{float(stat['haar_form_factor_mean'][time_index]):.3f}}}", + rf"\newcommand{{\FormFactorCovHalf}}{{{float(stat['deformed_form_factor_mean'][time_index]):.3f}}}", + ] + (output_dir / "generated_numbers_v1.tex").write_text( + "\n".join(lines) + "\n", + encoding="utf-8", + ) + table = [ + r"\begin{tabular}{rrrrrr}", + r"\hline\hline", + r"$D$ & $M$ & samples & atoms/edge & $\Delta\langle r\rangle$ & $L^1_{\rm int}$ \\", + r"\hline", + ] + for case in scaling_json["cases"]: + table.append( + f"{case['D']} & {case['M']} & {case['samples']} & " + f"{case['plus_atoms_per_matrix']} & " + f"{case['gap_ratio_difference']:.5f} & " + f"{case['interior_density_l1']:.5f} \\\\" + ) + table.extend([r"\hline\hline", r"\end{tabular}"]) + (output_dir / "generated_tables_v1.tex").write_text( + "\n".join(table) + "\n", + encoding="utf-8", + ) + + +def run( + output_dir: Path, + physical_json_path: Path = Path("output/physical_ensemble_v1.json"), + covariance_json_path: Path = Path("output/covariance_model_v1.json"), + covariance_npz_path: Path = Path("output/covariance_model_v1.npz"), + scaling_json_path: Path = Path("output/rank_scaling_v1.json"), + scaling_npz_path: Path = Path("output/rank_scaling_v1.npz"), + statistical_json_path: Path = Path( + "output/statistical_analysis_v1.json" + ), + statistical_npz_path: Path = Path( + "output/statistical_analysis_v1.npz" + ), +) -> dict[str, Any]: + """Generate figures, macros, tables, and a hash manifest.""" + + _style() + output_dir.mkdir(parents=True, exist_ok=True) + physical_json = json.loads( + physical_json_path.read_text(encoding="utf-8") + ) + covariance_json = json.loads( + covariance_json_path.read_text(encoding="utf-8") + ) + scaling_json = json.loads( + scaling_json_path.read_text(encoding="utf-8") + ) + statistical_json = json.loads( + statistical_json_path.read_text(encoding="utf-8") + ) + with ( + np.load(covariance_npz_path) as covariance, + np.load(scaling_npz_path) as scaling, + np.load(statistical_npz_path) as stat, + ): + figures = { + "figure_1": _figure_physical_law( + stat, + covariance_json, + output_dir, + ), + "figure_2": _figure_scale_hierarchy(stat, output_dir), + "figure_3": _figure_atom_crossover( + scaling_json, + scaling, + output_dir, + ), + "figure_4": _figure_finite_size( + statistical_json, + stat, + output_dir, + ), + "figure_5": _figure_covariance_mechanism( + covariance_json, + covariance, + statistical_json, + stat, + output_dir, + ), + } + _write_generated_inputs( + output_dir, + physical_json, + covariance_json, + scaling_json, + statistical_json, + stat, + ) + inputs = ( + physical_json_path, + covariance_json_path, + covariance_npz_path, + scaling_json_path, + scaling_npz_path, + statistical_json_path, + statistical_npz_path, + ) + manifest = { + "schema_version": 1, + "version": VERSION, + "figure_width_inches": FIGURE_WIDTH, + "png_dpi": DPI, + "inputs": { + str(path): _sha256(path) for path in inputs + }, + "figures": figures, + "atom_annotations": { + "D546_each_boundary": 6, + "D800_each_boundary": 120, + "D800_total_weight": 0.30, + }, + } + for figure in figures.values(): + figure["pdf_sha256"] = _sha256(Path(figure["pdf"])) + figure["png_sha256"] = _sha256(Path(figure["png"])) + manifest_path = output_dir / "figure_manifest_v1.json" + manifest_path.write_text( + json.dumps(manifest, indent=2) + "\n", + encoding="utf-8", + ) + return manifest + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--output-dir", + type=Path, + default=Path("output"), + ) + args = parser.parse_args() + manifest = run(args.output_dir) + print(json.dumps(manifest, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_matrix_element_geometric_eth_figure_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_matrix_element_geometric_eth_figure_v3.py new file mode 100644 index 000000000..0db8996c8 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_matrix_element_geometric_eth_figure_v3.py @@ -0,0 +1,334 @@ +#!/usr/bin/env python3 +"""Generate the publication figure for four-channel Wick factorization.""" + +from __future__ import annotations + +import hashlib +import json +from pathlib import Path +from typing import Any + +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt +import numpy as np + + +SCRIPT_ROOT = Path(__file__).resolve().parent +OUTPUT = SCRIPT_ROOT / "output" +SOURCE = OUTPUT / "matrix_element_geometric_eth_v3.json" +FIGURE_PDF = OUTPUT / "figure_6_wick_factorization_v3.pdf" +FIGURE_PNG = OUTPUT / "figure_6_wick_factorization_v3.png" +MANIFEST = OUTPUT / "figure_manifest_v3.json" + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def _atomic_json(path: Path, payload: dict[str, Any]) -> None: + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text( + json.dumps(payload, indent=2, sort_keys=True), + encoding="utf-8", + ) + temporary.replace(path) + + +def _style() -> None: + plt.rcParams.update( + { + "font.family": "serif", + "font.serif": ["STIXGeneral", "DejaVu Serif"], + "mathtext.fontset": "stix", + "font.size": 8.4, + "axes.titlesize": 9.2, + "axes.labelsize": 8.6, + "xtick.labelsize": 7.7, + "ytick.labelsize": 7.7, + "legend.fontsize": 7.1, + "axes.linewidth": 0.75, + "xtick.major.width": 0.65, + "ytick.major.width": 0.65, + "pdf.fonttype": 42, + "ps.fonttype": 42, + } + ) + + +def _panel_label(axis, label: str) -> None: + axis.text( + -0.15, + 1.08, + label, + transform=axis.transAxes, + fontsize=9.2, + fontweight="bold", + va="top", + ) + + +def make_figure() -> dict[str, Any]: + payload = json.loads(SOURCE.read_text(encoding="utf-8")) + cases = payload["cases"] + if len(cases) != 3: + raise RuntimeError("Figure 6 requires the full three-case artifact") + _style() + navy = "#24476b" + orange = "#d8752d" + teal = "#228b8d" + grey = "#6d747d" + pale = "#dfe8ef" + N = np.asarray([case["N"] for case in cases], dtype=float) + ranks = np.asarray([case["rank"] for case in cases], dtype=float) + dimensions = np.asarray( + [case["basis_dimension"] for case in cases], + dtype=float, + ) + gaps = np.asarray([case["external_gap"] for case in cases]) + physical = np.asarray( + [case["physical_R4_median"] for case in cases] + ) + physical_interval = np.asarray( + [case["physical_R4_interval"] for case in cases] + ) + structured = np.asarray([case["structured_R4"] for case in cases]) + gaussian = np.asarray( + [case["gaussian_R4_interval"] for case in cases] + ) + A_left = np.asarray([case["A_left_median"] for case in cases]) + B_right = np.asarray([case["B_right_median"] for case in cases]) + effective_external = ranks / B_right + + figure, axes = plt.subplots( + 2, + 2, + figsize=(7.0, 5.15), + constrained_layout=True, + ) + + axis = axes[0, 0] + _panel_label(axis, "(a)") + axis.plot(N, gaps, "o-", color=navy, lw=1.5, ms=4.3) + axis.set_xlabel("particle number $N$") + axis.set_ylabel("external gap $\\Delta$", color=navy) + axis.tick_params(axis="y", colors=navy) + axis.set_xticks(N) + axis.set_title("Exact fixed-two-quasihole manifolds", pad=5) + twin = axis.twinx() + twin.semilogy( + N, + dimensions, + "s--", + color=grey, + lw=1.2, + ms=4.0, + ) + twin.set_ylabel("$\\dim\\mathcal{H}$", color=grey) + twin.tick_params(axis="y", colors=grey) + annotation_offsets = ((0, 9), (0, -17), (0, 9)) + for x, gap, rank, offset in zip( + N, + gaps, + ranks, + annotation_offsets, + strict=True, + ): + axis.annotate( + f"$D={int(rank)}$", + (x, gap), + xytext=offset, + textcoords="offset points", + ha="center", + color=navy, + fontsize=7.1, + ) + axis.grid(alpha=0.18, lw=0.55) + + axis = axes[0, 1] + _panel_label(axis, "(b)") + axis.fill_between( + N, + gaussian[:, 0], + gaussian[:, 2], + color=pale, + label="covariance-matched Gaussian 95%", + zorder=1, + ) + axis.plot( + N, + gaussian[:, 1], + "-", + color=grey, + lw=1.2, + label="Gaussian median", + zorder=2, + ) + axis.errorbar( + N, + physical, + yerr=np.vstack( + [ + physical - physical_interval[:, 0], + physical_interval[:, 1] - physical, + ] + ), + fmt="o-", + color=orange, + lw=1.6, + ms=4.5, + capsize=2.5, + label="local-density panels", + zorder=4, + ) + axis.plot( + N, + structured, + "D--", + color=teal, + lw=1.25, + ms=3.8, + label="Fourier panel", + zorder=3, + ) + axis.set_xlabel("particle number $N$") + axis.set_ylabel("four-channel residual $R_4$") + axis.set_xticks(N) + axis.set_title("Finite-size Wick test", pad=5) + axis.legend(frameon=False, loc="upper right") + axis.grid(alpha=0.18, lw=0.55) + + axis = axes[1, 0] + _panel_label(axis, "(c)") + physical_excess = physical - gaussian[:, 1] + structured_excess = structured - gaussian[:, 1] + axis.axhline(0.0, color="black", lw=0.7, alpha=0.55) + axis.plot( + N, + physical_excess, + "o-", + color=orange, + lw=1.6, + ms=4.5, + label="local-density excess", + ) + axis.plot( + N, + structured_excess, + "D--", + color=teal, + lw=1.25, + ms=3.8, + label="Fourier excess", + ) + axis.set_xlabel("particle number $N$") + axis.set_ylabel("$R_4-\\mathrm{median}(R_4^{\\rm G})$") + axis.set_xticks(N) + axis.set_title("Connected channel memory", pad=5) + axis.legend(frameon=False) + axis.grid(alpha=0.18, lw=0.55) + axis.text( + 0.04, + 0.08, + "resolved connected component at $N=5$", + transform=axis.transAxes, + color=orange, + fontsize=7.3, + ) + + axis = axes[1, 1] + _panel_label(axis, "(d)") + axis.plot( + N, + A_left - 1.0, + "o-", + color=navy, + lw=1.5, + ms=4.2, + ) + axis.set_xlabel("particle number $N$") + axis.set_ylabel("target anisotropy $A_L-1$", color=navy) + axis.tick_params(axis="y", colors=navy) + axis.set_xticks(N) + twin = axis.twinx() + twin.plot( + N, + effective_external, + "s--", + color=grey, + lw=1.25, + ms=4.0, + ) + twin.set_ylabel( + "effective external dimension $M_{\\rm eff}=D/B_R$", + color=grey, + ) + twin.tick_params(axis="y", colors=grey) + axis.set_title("Covariance envelope", pad=5) + axis.grid(alpha=0.18, lw=0.55) + axis.text( + 0.04, + 0.86, + "registered branch:\n$\\bf{deformed\\ geometric\\ ETH}$", + transform=axis.transAxes, + color=orange, + fontsize=7.5, + va="top", + bbox={ + "facecolor": "white", + "edgecolor": "none", + "alpha": 0.88, + "pad": 1.5, + }, + ) + axis.text( + 0.04, + 0.10, + "$N=3,4,5$ finite-size baseline", + transform=axis.transAxes, + color="#444444", + fontsize=6.9, + bbox={ + "facecolor": "white", + "edgecolor": "none", + "alpha": 0.82, + "pad": 1.2, + }, + ) + + figure.savefig(FIGURE_PDF) + figure.savefig(FIGURE_PNG, dpi=300) + plt.close(figure) + manifest = ( + json.loads(MANIFEST.read_text(encoding="utf-8")) + if MANIFEST.exists() + else {} + ) + manifest["figure_6_wick_factorization_v3"] = { + "source": str(SOURCE.relative_to(SCRIPT_ROOT)), + "source_sha256": _sha256(SOURCE), + "pdf": str(FIGURE_PDF.relative_to(SCRIPT_ROOT)), + "pdf_sha256": _sha256(FIGURE_PDF), + "png": str(FIGURE_PNG.relative_to(SCRIPT_ROOT)), + "png_sha256": _sha256(FIGURE_PNG), + "width_inches": 7.0, + "png_width_pixels": 2100, + "result_branch": payload["result_branch"], + "panels": [ + "genuine_manybody_sequence", + "four_channel_residual", + "non_gaussian_excess", + "covariance_geometry", + ], + } + _atomic_json(MANIFEST, manifest) + return manifest["figure_6_wick_factorization_v3"] + + +def main() -> None: + print(json.dumps(make_figure(), indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_release_manifest_v1.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_release_manifest_v1.py new file mode 100644 index 000000000..25d813dd3 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_release_manifest_v1.py @@ -0,0 +1,232 @@ +#!/usr/bin/env python3 +"""Build the machine-readable public release contract for task 05.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import subprocess +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + + +SCRIPT_ROOT = Path(__file__).resolve().parent +DEFAULT_REPO_ROOT = SCRIPT_ROOT.parents[2] +DEFAULT_OUTPUT = SCRIPT_ROOT / "output" +DEFAULT_MANIFEST = DEFAULT_OUTPUT / "release_manifest_v1.json" + +FIGURES = tuple( + f"figure_{index}_{name}" + for index, name in ( + (1, "spectral_silence_v2.png"), + (2, "falsification_triangle_v2.png"), + (3, "independent_channels_v2.png"), + (4, "geometric_hierarchy_v2.png"), + (5, "jacobi_atoms_v2.png"), + (6, "wick_factorization_v3.png"), + (7, "topological_holonomy_v3.png"), + ) +) + +COMPACT_ARTIFACTS = ( + "citation_audit_v1.json", + "geometric_eth_topology_assets_v3.json", + "geometric_eth_topology_delivery_audit_v3.json", + "matrix_element_delivery_audit_v3.json", + "matrix_element_geometric_eth_v3.json", + "matrix_element_geometric_eth_v3.npz", + "matrix_element_topology_theory_v3.json", + "spectral_silence_delivery_audit_v2.json", + "spectral_silence_statistics_v2.json", + "spectral_silence_statistics_v2.npz", + "spectral_silence_v2.json", + "topological_holonomy_delivery_audit_v3.json", + "topological_holonomy_v3.json", + "topological_holonomy_v3.npz", +) + + +def _sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for block in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(block) + return digest.hexdigest() + + +def _record(path: Path, repo_root: Path) -> dict[str, Any]: + return { + "path": path.relative_to(repo_root).as_posix(), + "size_bytes": path.stat().st_size, + "sha256": _sha256(path), + } + + +def _producer_for(relative: str) -> str: + if relative.startswith(("physical_ensemble", "covariance_model")): + return "bash run_large_scale_article_v1.sh" + if relative.startswith(("rank_scaling", "statistical_analysis")): + return "bash run_large_scale_article_v1.sh" + if relative.startswith("spectral_silence"): + return "bash run_spectral_silence_article_v2.sh" + if "matrix_element" in relative: + return "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh" + if "topology" in relative or "topological_holonomy" in relative: + return "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh" + return "Run the registered task-05 production pipeline" + + +def _tracked_relative_paths(repo_root: Path) -> set[str]: + result = subprocess.run( + ["git", "ls-files", "-z"], + cwd=repo_root, + check=True, + capture_output=True, + ) + return { + item.decode("utf-8") + for item in result.stdout.split(b"\0") + if item + } + + +def build_manifest( + *, + repo_root: Path, + bulk_output: Path, + generated_utc: str | None = None, +) -> dict[str, Any]: + """Build a release manifest from current compact and optional bulk data.""" + repo_root = repo_root.resolve() + compact_output = ( + repo_root / "01_task_folder" / "task_05" / "script" / "output" + ) + matrix = json.loads( + (compact_output / "matrix_element_geometric_eth_v3.json").read_text( + encoding="utf-8" + ) + ) + topology = json.loads( + (compact_output / "topological_holonomy_v3.json").read_text( + encoding="utf-8" + ) + ) + audit = json.loads( + ( + compact_output / "geometric_eth_topology_delivery_audit_v3.json" + ).read_text(encoding="utf-8") + ) + paper = compact_output / "spectral_silence_and_geometric_chaos_v3.pdf" + + figures = [] + for name in FIGURES: + record = _record(compact_output / name, repo_root) + record["role"] = ( + "principal_result" + if name.startswith("figure_1_") + else "main_figure" + ) + figures.append(record) + + compact = [ + {**_record(compact_output / name, repo_root), "storage_class": "git"} + for name in COMPACT_ARTIFACTS + ] + + external = [] + tracked = _tracked_relative_paths(repo_root) + bulk_output = bulk_output.resolve() + if bulk_output.is_dir(): + for source in sorted(bulk_output.rglob("*.npz")): + relative = source.relative_to(bulk_output) + compact_path = compact_output / relative + compact_relative = compact_path.relative_to(repo_root).as_posix() + if ( + compact_relative in tracked + and compact_path.is_file() + and _sha256(compact_path) == _sha256(source) + ): + continue + external.append( + { + "path": ( + "01_task_folder/task_05/script/output/" + + relative.as_posix() + ), + "size_bytes": source.stat().st_size, + "sha256": _sha256(source), + "storage_class": "recompute_or_release_asset", + "producer": _producer_for(relative.as_posix()), + } + ) + + existing_manifest = compact_output / "release_manifest_v1.json" + existing: dict[str, Any] = {} + if existing_manifest.is_file(): + existing = json.loads(existing_manifest.read_text(encoding="utf-8")) + if not external: + external = existing.get("external_artifacts", []) + + timestamp = ( + generated_utc + or existing.get("generated_utc") + or datetime.now(timezone.utc).isoformat() + ) + return { + "schema_version": 1, + "release_id": "task05-geometric-chaos-v1", + "generated_utc": timestamp, + "headline": "Exact degeneracy turns quantum geometry into the signal.", + "result_branches": { + "matrix_element": matrix["result_branch"], + "topology": topology["result_branch"], + }, + "paper": { + **_record(paper, repo_root), + "page_count": audit["page_count"], + "title": ( + "Spectral Silence and Geometric Chaos in an Exactly " + "Degenerate Topological Manifold" + ), + }, + "figures": figures, + "compact_artifacts": compact, + "external_artifacts": external, + "verification": { + "quick": "bash run_quick_verify_v1.sh", + "article": "bash run_geometric_eth_topology_article_v3.sh", + "full": "bash run_full_recompute_v1.sh", + }, + "scientific_scope": [ + "exact-degeneracy projector geometry", + "finite-rank local Jacobi universality", + "structured matrix-element and Wilson correlations", + ], + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--repo-root", type=Path, default=DEFAULT_REPO_ROOT) + parser.add_argument("--bulk-output", type=Path, default=DEFAULT_OUTPUT) + parser.add_argument("--output", type=Path, default=DEFAULT_MANIFEST) + parser.add_argument("--generated-utc") + args = parser.parse_args() + + manifest = build_manifest( + repo_root=args.repo_root, + bulk_output=args.bulk_output, + generated_utc=args.generated_utc, + ) + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text( + json.dumps(manifest, indent=2, sort_keys=True) + "\n", + encoding="utf-8", + ) + print(args.output) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_spectral_silence_figures_v2.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_spectral_silence_figures_v2.py new file mode 100644 index 000000000..842e34339 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_spectral_silence_figures_v2.py @@ -0,0 +1,1088 @@ +#!/usr/bin/env python3 +"""Create the argument-ordered v2 publication figures and TeX inputs.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import shutil +from pathlib import Path +from typing import Any + +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt +from matplotlib.colors import TwoSlopeNorm +import numpy as np + + +VERSION = "v2" +FIGURE_WIDTH = 7.0 +DPI = 300 +COLORS = { + "structured": "#CC79A7", + "physical": "#0072B2", + "haar": "#222222", + "jacobi": "#009E73", + "spectral": "#E69F00", + "residual": "#D55E00", + "gray": "#777777", + "light": "#D9D9D9", +} + + +def _style() -> None: + plt.rcParams.update( + { + "font.family": "serif", + "font.serif": [ + "STIX Two Text", + "STIXGeneral", + "DejaVu Serif", + ], + "mathtext.fontset": "stix", + "font.size": 8.2, + "axes.labelsize": 8.5, + "axes.titlesize": 9.0, + "legend.fontsize": 7.0, + "xtick.labelsize": 7.3, + "ytick.labelsize": 7.3, + "axes.linewidth": 0.75, + "lines.linewidth": 1.35, + "savefig.facecolor": "white", + "figure.facecolor": "white", + "axes.facecolor": "white", + "axes.spines.top": False, + "axes.spines.right": False, + } + ) + + +def _panel(ax, label: str, title: str) -> None: + ax.text( + -0.12, + 1.04, + f"({label})", + transform=ax.transAxes, + fontweight="bold", + va="bottom", + ) + ax.set_title(title, loc="left", pad=5.0) + + +def _band( + ax, + x: np.ndarray, + arrays: Any, + prefix: str, + color: str, + label: str, + alpha: float = 0.16, + linestyle: str = "-", +) -> None: + ax.fill_between( + x, + arrays[f"{prefix}_lower"], + arrays[f"{prefix}_upper"], + color=color, + alpha=alpha, + linewidth=0, + ) + ax.plot( + x, + arrays[f"{prefix}_mean"], + color=color, + label=label, + linestyle=linestyle, + ) + + +def _sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for block in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(block) + return digest.hexdigest() + + +def _save( + fig, + output_dir: Path, + stem: str, +) -> dict[str, Any]: + pdf = (output_dir / f"{stem}.pdf").resolve() + png = (output_dir / f"{stem}.png").resolve() + fig.savefig(pdf, format="pdf") + fig.savefig(png, format="png", dpi=DPI) + plt.close(fig) + return { + "pdf": str(pdf), + "png": str(png), + "pdf_sha256": _sha256(pdf), + "png_sha256": _sha256(png), + "width_inches": FIGURE_WIDTH, + "png_width_pixels": int(round(FIGURE_WIDTH * DPI)), + "dpi": DPI, + } + + +def _combined_legend(ax, twin=None, **kwargs) -> None: + handles, labels = ax.get_legend_handles_labels() + if twin is not None: + twin_handles, twin_labels = twin.get_legend_handles_labels() + handles += twin_handles + labels += twin_labels + ax.legend(handles, labels, frameon=False, **kwargs) + + +def _figure_spectral_silence( + source: Any, + stat: Any, + output_dir: Path, +) -> dict[str, Any]: + times = stat["times"] + fig, axes = plt.subplots( + 2, + 2, + figsize=(FIGURE_WIDTH, 5.15), + layout="constrained", + ) + ax = axes[0, 0] + ax.plot( + times, + source["energy_raw"], + color=COLORS["haar"], + label=r"raw energy SFF $K_{E,\rm raw}=D$", + ) + ax.plot( + times, + source["energy_connected"], + color=COLORS["residual"], + label=r"connected energy SFF $K_{E,c}=0$", + ) + ax.scatter( + np.linspace(0.25, 2.75, 22), + np.full(22, 43.0), + marker="_", + color=COLORS["gray"], + s=18, + linewidths=0.75, + label=r"$E_a=E_0$ (exactly degenerate)", + ) + ax.set_xlim(0.0, 3.0) + ax.set_ylim(-2.0, 54.0) + ax.set_xlabel(r"Fourier variable $t$") + ax.set_ylabel(r"$K_E(t)$") + ax.legend(frameon=False, loc="center right") + _panel(ax, "a", "Exact degeneracy: spectral silence") + + ax = axes[0, 1] + rows = ( + ( + source["structured_spectra"][0], + 2.0, + COLORS["structured"], + "structured Fourier", + ), + ( + source["physical_test_spectra"][0], + 1.0, + COLORS["physical"], + "physical random local", + ), + ( + source["haar_spectra"][0], + 0.0, + COLORS["haar"], + "Haar--Jacobi", + ), + ) + for spectrum, baseline, color, label in rows: + ax.eventplot( + np.asarray(spectrum, dtype=float), + lineoffsets=baseline, + linelengths=0.62, + linewidths=0.72, + colors=color, + label=label, + ) + ax.set_yticks([0, 1, 2], ["Jacobi", "physical", "structured"]) + ax.set_xlim(-1.02, 1.02) + ax.set_ylim(-0.55, 2.55) + ax.set_xlabel(r"metric-normalized curvature eigenvalue $\lambda$") + _panel(ax, "b", "Same rank, different geometry") + + ax = axes[1, 0] + _band( + ax, + times, + stat, + "physical_form", + COLORS["physical"], + "physical", + ) + ax.plot( + times, + stat["jacobi_connected_D50"], + color=COLORS["jacobi"], + linestyle="--", + label="finite-$D$ Jacobi", + ) + ax.set_xlim(0.0, 1.5) + ax.set_ylim(-0.04, 1.12) + ax.set_xlabel(r"dimensionless Fourier scale $\tau$") + ax.set_ylabel(r"$K_{F,c}(\tau)$") + twin = ax.twinx() + twin.plot( + times, + stat["structured_form_mean"], + color=COLORS["structured"], + alpha=0.82, + label="structured (right axis)", + ) + twin.fill_between( + times, + stat["structured_form_lower"], + stat["structured_form_upper"], + color=COLORS["structured"], + alpha=0.10, + linewidth=0, + ) + twin.set_ylim(-0.2, 6.2) + twin.set_ylabel( + r"structured $K_{F,c}$", + color=COLORS["structured"], + ) + twin.tick_params(axis="y", colors=COLORS["structured"]) + _combined_legend(ax, twin, loc="lower right") + _panel(ax, "c", "Geometry restores a correlation ramp") + + ax = axes[1, 1] + _band( + ax, + times, + stat, + "physical_form_residual", + COLORS["residual"], + r"physical $-$ finite-$D$ Jacobi", + alpha=0.18, + ) + ax.axhline(0.0, color=COLORS["gray"], linewidth=0.75) + ax.axvspan(0.25, 1.5, color=COLORS["jacobi"], alpha=0.06) + ax.set_xlim(0.0, 1.55) + ax.set_xlabel(r"$\tau$") + ax.set_ylabel(r"$\delta K_{F,c}$") + ax.legend(frameon=False, loc="upper right") + inset = ax.inset_axes([0.50, 0.12, 0.47, 0.42]) + inset.fill_between( + stat["lengths"], + stat["physical_haar_number_residual_lower"], + stat["physical_haar_number_residual_upper"], + color=COLORS["physical"], + alpha=0.18, + linewidth=0, + ) + inset.plot( + stat["lengths"], + stat["physical_haar_number_residual_mean"], + color=COLORS["physical"], + linewidth=1.0, + ) + inset.axhline(0.0, color=COLORS["gray"], linewidth=0.6) + inset.axvline(1.0, color=COLORS["residual"], linestyle=":", linewidth=0.8) + inset.set_xlabel(r"$L$", fontsize=6.8) + inset.set_ylabel(r"$\Delta\Sigma^2$", fontsize=6.8) + inset.tick_params(labelsize=6.2) + _panel(ax, "d", "Ramp universal, long range nonuniversal") + return _save( + fig, + output_dir, + "figure_1_spectral_silence_v2", + ) + + +def _figure_falsification_triangle( + stat: Any, + output_dir: Path, +) -> dict[str, Any]: + fig, axes = plt.subplots( + 1, + 3, + figsize=(FIGURE_WIDTH, 2.75), + layout="constrained", + ) + ax = axes[0] + for prefix, color, label in ( + ("structured", COLORS["structured"], "structured"), + ("physical", COLORS["physical"], "physical"), + ("haar", COLORS["haar"], "Haar--Jacobi"), + ): + _band( + ax, + stat["ratio_centers"], + stat, + f"{prefix}_ratio", + color, + label, + alpha=0.13, + ) + ax.set_yscale("log") + ax.set_ylim(2e-2, 80) + ax.set_xlabel(r"adjacent-gap ratio $r$") + ax.set_ylabel(r"$P(r)$") + ax.legend(frameon=False, loc="upper right") + _panel(ax, "a", "Local repulsion") + + ax = axes[1] + for prefix, color, label in ( + ("physical", COLORS["physical"], "physical"), + ("haar", COLORS["haar"], "Haar--Jacobi"), + ): + _band( + ax, + stat["times"], + stat, + f"{prefix}_form", + color, + label, + alpha=0.13, + ) + ax.plot( + stat["times"], + stat["jacobi_connected_D50"], + color=COLORS["jacobi"], + linestyle="--", + label="exact finite-$D$", + ) + twin = ax.twinx() + twin.plot( + stat["times"], + stat["structured_form_mean"], + color=COLORS["structured"], + label="structured (right)", + ) + twin.set_ylim(-0.2, 6.2) + twin.tick_params(axis="y", colors=COLORS["structured"]) + ax.set_xlim(0.0, 1.5) + ax.set_ylim(-0.04, 1.12) + ax.set_xlabel(r"$\tau$") + ax.set_ylabel(r"$K_{F,c}(\tau)$") + _combined_legend(ax, twin, loc="lower right") + _panel(ax, "b", "Connected curvature SFF") + + ax = axes[2] + for prefix, color, label in ( + ("structured", COLORS["structured"], "structured"), + ("physical", COLORS["physical"], "physical"), + ("haar", COLORS["haar"], "Haar--Jacobi"), + ): + _band( + ax, + stat["lengths"], + stat, + f"{prefix}_number", + color, + label, + alpha=0.13, + ) + ax.set_yscale("log") + ax.set_xlabel(r"window length $L$") + ax.set_ylabel(r"$\Sigma^2(L)$") + ax.legend(frameon=False, loc="lower right") + _panel(ax, "c", "Long-range memory") + return _save( + fig, + output_dir, + "figure_2_falsification_triangle_v2", + ) + + +def _figure_independent_channels( + stat: Any, + statistical_json: dict[str, Any], + output_dir: Path, +) -> dict[str, Any]: + fig, axes = plt.subplots( + 2, + 2, + figsize=(FIGURE_WIDTH, 5.0), + layout="constrained", + ) + alpha = stat["alpha_values"] + ax = axes[0, 0] + ax.fill_between( + alpha, + stat["energy_gap_ratio_lower"], + stat["energy_gap_ratio_upper"], + color=COLORS["spectral"], + alpha=0.18, + linewidth=0, + ) + ax.plot( + alpha, + stat["energy_gap_ratio_mean"], + color=COLORS["spectral"], + marker="o", + markersize=3.3, + label=r"energy spectrum of $PHP$", + ) + ax.axhspan( + float(stat["haar_ratio_mean_lower"][0]), + float(stat["haar_ratio_mean_upper"][0]), + color=COLORS["haar"], + alpha=0.10, + label="Haar/GUE interval", + ) + ax.axvline(0.5, color=COLORS["gray"], linestyle=":", linewidth=0.8) + ax.set_xlabel(r"intrafiber interpolation $\alpha$") + ax.set_ylabel(r"$\langle r_E\rangle$") + ax.legend(frameon=False, loc="lower right") + _panel(ax, "a", r"Spectral channel: change $PHP$") + + ax = axes[0, 1] + projector = np.maximum(stat["projector_distance_alpha"], 1e-18) + curvature = np.maximum(stat["curvature_error_alpha"], 1e-18) + ax.plot( + alpha, + projector, + color=COLORS["physical"], + marker="o", + markersize=3.0, + label=r"$\|P_\alpha-P_0\|_F$", + ) + ax.plot( + alpha, + curvature, + color=COLORS["jacobi"], + marker="s", + markersize=3.0, + label=r"curvature-spectrum error", + ) + ax.set_yscale("log") + ax.set_ylim(3e-19, 3e-13) + ax.set_xlabel(r"$\alpha$") + ax.set_ylabel("invariance error") + ax.legend(frameon=False, loc="upper left") + _panel(ax, "b", "Projector geometry does not move") + + ax = axes[1, 0] + g = np.concatenate([[0.0], stat["g_values"]]) + structured_ratio = float(stat["structured_ratio_mean_mean"][0]) + mean = np.concatenate( + [[structured_ratio], stat["g_ratio_scalar_mean"]] + ) + lower = np.concatenate( + [[structured_ratio], stat["g_ratio_scalar_lower"]] + ) + upper = np.concatenate( + [[structured_ratio], stat["g_ratio_scalar_upper"]] + ) + ax.fill_between( + g, + lower, + upper, + color=COLORS["physical"], + alpha=0.18, + linewidth=0, + ) + ax.plot( + g, + mean, + color=COLORS["physical"], + marker="o", + markersize=3.3, + label=r"curvature spectrum", + ) + ax.axhspan( + float(stat["haar_ratio_mean_lower"][0]), + float(stat["haar_ratio_mean_upper"][0]), + color=COLORS["haar"], + alpha=0.10, + label="Haar--Jacobi interval", + ) + ax.axvline( + 0.2, + color=COLORS["jacobi"], + linestyle=":", + linewidth=0.9, + label=r"$g_{\rm local}=0.20$", + ) + ax.axvline( + 0.4, + color=COLORS["residual"], + linestyle="--", + linewidth=0.9, + label=r"$g_{\rm ramp}=0.40$", + ) + ax.set_xlabel(r"geometric scrambling $g$") + ax.set_ylabel(r"$\langle r_F\rangle$") + ax.legend(frameon=False, loc="lower right") + _panel(ax, "c", r"Geometric channel: change $P(\partial H)Q$") + + ax = axes[1, 1] + ax.set_xlim(0.0, 1.0) + ax.set_ylim(0.0, 1.0) + ax.axvline(0.5, color="white", linewidth=1.3) + ax.axhline(0.4, color="white", linewidth=1.3) + colors = np.asarray( + [ + [ + matplotlib.colors.to_rgb("#ECECEC"), + matplotlib.colors.to_rgb("#F7DFB1"), + ], + [ + matplotlib.colors.to_rgb("#B9DDED"), + matplotlib.colors.to_rgb("#C9E9D9"), + ], + ] + ) + ax.imshow( + colors, + origin="lower", + extent=(0, 1, 0, 1), + aspect="auto", + ) + labels = ( + (0.25, 0.20, "neither"), + (0.75, 0.20, "spectral only"), + (0.25, 0.70, "geometric only"), + (0.75, 0.70, "both"), + ) + for x, y, label in labels: + ax.text(x, y, label, ha="center", va="center", fontweight="bold") + ax.set_xticks([0.25, 0.75], ["regular", "GUE-like"]) + ax.set_yticks([0.20, 0.70], ["structured", "Jacobi-like"]) + ax.set_xlabel(r"intrafiber spectral channel $PHP$") + ax.set_ylabel(r"projector-geometric channel") + _panel(ax, "d", "Two independent notions of chaos") + return _save( + fig, + output_dir, + "figure_3_independent_channels_v2", + ) + + +def _figure_geometric_hierarchy( + source: Any, + stat: Any, + statistical_json: dict[str, Any], + output_dir: Path, +) -> dict[str, Any]: + times = stat["times"] + all_g = np.concatenate([[0.0], stat["g_values"]]) + residual = np.vstack( + [ + stat["structured_form_mean"] + - stat["jacobi_connected_D50"], + stat["g_form_mean"] + - stat["jacobi_connected_D50"][None, :], + ] + ) + fig, axes = plt.subplots( + 2, + 2, + figsize=(FIGURE_WIDTH, 5.0), + layout="constrained", + ) + ax = axes[0, 0] + mask = times <= 1.5 + image = ax.imshow( + residual[:, mask], + origin="lower", + aspect="auto", + extent=( + float(times[mask][0]), + float(times[mask][-1]), + -0.5, + all_g.size - 0.5, + ), + cmap="RdBu_r", + norm=TwoSlopeNorm(vmin=-0.25, vcenter=0.0, vmax=0.25), + ) + ax.set_yticks(np.arange(all_g.size), [f"{value:g}" for value in all_g]) + ax.set_xlabel(r"$\tau$") + ax.set_ylabel(r"scrambling $g$") + colorbar = fig.colorbar(image, ax=ax, pad=0.02) + colorbar.set_label(r"$K_{F,c}-K_{J,c}$") + _panel(ax, "a", "Residual flow toward finite-$D$ Jacobi") + + ax = axes[0, 1] + registered_mask = (times >= 0.25) & (times <= 1.5) + rms_residual = np.sqrt( + np.mean( + ( + stat["g_form_mean"][:, registered_mask] + - stat["jacobi_connected_D50"][ + None, + registered_mask, + ] + ) + ** 2, + axis=1, + ) + ) + ax.plot( + stat["g_values"], + rms_residual, + color=COLORS["residual"], + marker="o", + markersize=3.4, + label=r"RMS SFF residual, $0.25\leq\tau\leq1.5$", + ) + ax.axvline( + 0.2, + color=COLORS["jacobi"], + linestyle=":", + label=r"local $P(r)$ onset", + ) + ax.axvline( + 0.4, + color=COLORS["residual"], + linestyle="--", + label=r"first registered ramp window", + ) + ax.set_xlim(0.0, 1.02) + ax.set_yscale("log") + ax.set_xlabel(r"$g$") + ax.set_ylabel(r"RMS$(K_{F,c}-K_{J,c})$") + ax.legend(frameon=False, loc="upper right") + _panel(ax, "b", "Local correlations precede the ramp") + + ax = axes[1, 0] + _band( + ax, + times, + stat, + "physical_form_residual", + COLORS["residual"], + "physical $-$ finite-$D$ Jacobi", + ) + ax.axhline(0.0, color=COLORS["gray"], linewidth=0.75) + ax.axvspan(0.25, 1.5, color=COLORS["jacobi"], alpha=0.07) + ax.set_xlim(0.0, 1.55) + ax.set_xlabel(r"$\tau$") + ax.set_ylabel(r"$\delta K_{F,c}$") + ax.legend(frameon=False, loc="upper right") + _panel(ax, "c", r"Physical ramp: compatible for $\tau\geq0.25$") + + ax = axes[1, 1] + _band( + ax, + stat["lengths"], + stat, + "physical_haar_number_residual", + COLORS["physical"], + r"physical $-$ Haar--Jacobi", + ) + ax.axhline(0.0, color=COLORS["gray"], linewidth=0.75) + ax.axvline( + 1.0, + color=COLORS["residual"], + linestyle=":", + label=r"$L_{\rm universal}=1$", + ) + ax.set_xlabel(r"window length $L$") + ax.set_ylabel(r"$\Delta\Sigma^2(L)$") + ax.legend(frameon=False, loc="upper left") + _panel(ax, "d", "Long-range memory survives") + return _save( + fig, + output_dir, + "figure_4_geometric_hierarchy_v2", + ) + + +def _figure_jacobi_atoms( + source: Any, + output_dir: Path, +) -> dict[str, Any]: + times = source["times"] + D = np.asarray(source["rank_D"], dtype=float) + k = np.asarray(source["rank_interior"], dtype=float) + atoms = np.asarray(source["rank_atom_each"], dtype=float) + fig, axes = plt.subplots( + 2, + 2, + figsize=(FIGURE_WIDTH, 5.0), + layout="constrained", + ) + for ax, index, label, title in ( + (axes[0, 0], 5, "a", r"$D=546$: six atoms per edge"), + (axes[0, 1], 6, "b", r"$D=800$: 120 atoms per edge"), + ): + ax.plot( + times, + source["rank_physical_connected_full"][index], + color=COLORS["physical"], + label="physical full spectrum", + ) + ax.plot( + times, + source["rank_reference_connected_full"][index], + color=COLORS["haar"], + label="Jacobi full spectrum", + ) + if index == 6: + ax.plot( + times, + source["rank_reference_connected_continuous"][index], + color=COLORS["jacobi"], + linestyle="--", + label="atom-stripped continuous", + ) + plateau = k[index] / D[index] + ax.axhline( + plateau, + color=COLORS["structured"], + linestyle=":", + label=rf"full plateau $k/D={plateau:.3f}$", + ) + ax.set_xlim(0.0, 2.0) + ax.set_ylim(-0.04, 1.08) + ax.set_xlabel(r"$\tau$") + ax.set_ylabel(r"$K_{F,c}(\tau)$") + ax.legend(frameon=False, loc="lower right") + _panel(ax, label, title) + + ax = axes[1, 0] + plateau = k / D + ax.plot( + D, + plateau, + color=COLORS["jacobi"], + marker="o", + label=r"exact full connected plateau $k/D$", + ) + ax.plot( + D, + 2.0 * atoms / D, + color=COLORS["structured"], + marker="s", + label=r"total atom weight $2(D-M)_+/D$", + ) + ax.set_xscale("log") + ax.set_xlabel(r"active rank $D$") + ax.set_ylabel("spectral weight") + ax.set_ylim(-0.03, 1.06) + ax.legend(frameon=False, loc="center left") + _panel(ax, "c", "Exact atom suppression of connected SFF") + + ax = axes[1, 1] + index = 6 + for key, color, label, linestyle in ( + ( + "rank_reference_raw_full", + COLORS["haar"], + "full raw SFF", + "-", + ), + ( + "rank_reference_raw_atom_atom", + COLORS["structured"], + "atom--atom", + "--", + ), + ( + "rank_reference_raw_atom_continuum", + COLORS["residual"], + "atom--continuum", + "-.", + ), + ( + "rank_reference_raw_continuum_continuum", + COLORS["physical"], + "continuum--continuum", + ":", + ), + ): + ax.plot( + times, + source[key][index], + color=color, + label=label, + linestyle=linestyle, + ) + ax.set_xlim(0.0, 1.5) + ax.set_xlabel(r"raw Fourier scale $\tau$") + ax.set_ylabel(r"raw $K_F(\tau)$") + ax.legend(frameon=False, loc="upper right") + _panel(ax, "d", "Raw atom decomposition closes exactly") + return _save( + fig, + output_dir, + "figure_5_jacobi_atoms_v2", + ) + + +def _write_generated_inputs( + output_dir: Path, + source_json: dict[str, Any], + statistical_json: dict[str, Any], + source: Any, + stat: Any, +) -> None: + outcomes = statistical_json["outcomes"] + tau_half = int(np.argmin(np.abs(stat["times"] - 0.5))) + residual = outcomes["number_variance_L8_residual"] + energy = outcomes["energy_gap_ratio_endpoints"] + lines = [ + r"\newcommand{\EnergyRawSFF}{50}", + r"\newcommand{\EnergyConnectedSFF}{0}", + rf"\newcommand{{\StructuredFormHalf}}{{{float(stat['structured_form_mean'][tau_half]):.3f}}}", + rf"\newcommand{{\PhysicalFormHalf}}{{{float(stat['physical_form_mean'][tau_half]):.3f}}}", + rf"\newcommand{{\JacobiFormHalf}}{{{float(stat['jacobi_connected_D50'][tau_half]):.3f}}}", + rf"\newcommand{{\GeometricTauOnset}}{{{outcomes['physical_tau_compatibility_onset']:.2f}}}", + rf"\newcommand{{\GeometricLocalOnset}}{{{outcomes['first_g_with_haar_gap_ratio_interval']:.2f}}}", + rf"\newcommand{{\GeometricRampOnset}}{{{outcomes['first_g_with_registered_jacobi_window']:.2f}}}", + rf"\newcommand{{\NumberVarianceExtent}}{{{outcomes['number_variance_compatibility_extent']:.1f}}}", + rf"\newcommand{{\NumberResidualEight}}{{{residual['mean']:.5f}}}", + rf"\newcommand{{\NumberResidualEightLower}}{{{residual['lower']:.5f}}}", + rf"\newcommand{{\NumberResidualEightUpper}}{{{residual['upper']:.5f}}}", + rf"\newcommand{{\PoissonEndpointRatio}}{{{energy['poisson']:.6f}}}", + rf"\newcommand{{\GUEEndpointRatio}}{{{energy['gue']:.6f}}}", + rf"\newcommand{{\StructuredMomenta}}{{{source_json['sample_counts']['structured_momenta']}}}", + rf"\newcommand{{\StructuredOrbits}}{{{source_json['sample_counts']['structured_orbits']}}}", + rf"\newcommand{{\GeometricSamplesPerPoint}}{{{source_json['sample_counts']['per_positive_g']}}}", + rf"\newcommand{{\SpectralSamplesPerPoint}}{{{source_json['sample_counts']['fixed_projector_per_alpha']}}}", + rf"\newcommand{{\BootstrapReplicatesVTwo}}{{{statistical_json['bootstrap_replicates']}}}", + rf"\newcommand{{\LargestRankVTwo}}{{{int(source['rank_D'][-1])}}}", + rf"\newcommand{{\LargestAtomEachVTwo}}{{{int(source['rank_atom_each'][-1])}}}", + rf"\newcommand{{\LargestConnectedPlateau}}{{{float(source['rank_interior'][-1] / source['rank_D'][-1]):.1f}}}", + ] + (output_dir / "generated_numbers_v2.tex").write_text( + "\n".join(lines) + "\n", + encoding="utf-8", + ) + table = [ + r"\begin{tabular}{rrrr}", + r"\hline\hline", + r"$g$ & $\langle r_F\rangle$ & lower & upper \\", + r"\hline", + ] + for index, g in enumerate(stat["g_values"]): + table.append( + f"{float(g):.2f} & " + f"{float(stat['g_ratio_scalar_mean'][index]):.6f} & " + f"{float(stat['g_ratio_scalar_lower'][index]):.6f} & " + f"{float(stat['g_ratio_scalar_upper'][index]):.6f} \\\\" + ) + table.extend([r"\hline\hline", r"\end{tabular}"]) + (output_dir / "generated_tables_v2.tex").write_text( + "\n".join(table) + "\n", + encoding="utf-8", + ) + + +def run( + output_dir: Path, + source_json_path: Path | None = None, + source_npz_path: Path | None = None, + statistical_json_path: Path | None = None, + statistical_npz_path: Path | None = None, + sync_overleaf: bool = False, +) -> dict[str, Any]: + """Generate five figures, generated TeX, and a hash manifest.""" + + _style() + script_dir = Path(__file__).resolve().parent + output_dir = output_dir.resolve() + output_dir.mkdir(parents=True, exist_ok=True) + source_json_path = ( + script_dir / "output" / "spectral_silence_v2.json" + if source_json_path is None + else source_json_path + ) + source_npz_path = ( + script_dir / "output" / "spectral_silence_v2.npz" + if source_npz_path is None + else source_npz_path + ) + statistical_json_path = ( + script_dir + / "output" + / "spectral_silence_statistics_v2.json" + if statistical_json_path is None + else statistical_json_path + ) + statistical_npz_path = ( + script_dir + / "output" + / "spectral_silence_statistics_v2.npz" + if statistical_npz_path is None + else statistical_npz_path + ) + source_json = json.loads( + source_json_path.read_text(encoding="utf-8") + ) + statistical_json = json.loads( + statistical_json_path.read_text(encoding="utf-8") + ) + if not source_json["all_checks_pass"]: + raise RuntimeError("source scientific artifact failed") + if not statistical_json["all_checks_pass"]: + raise RuntimeError("statistical scientific artifact failed") + with ( + np.load(source_npz_path, allow_pickle=False) as source, + np.load(statistical_npz_path, allow_pickle=False) as stat, + ): + figures = { + "figure_1": _figure_spectral_silence( + source, + stat, + output_dir, + ), + "figure_2": _figure_falsification_triangle( + stat, + output_dir, + ), + "figure_3": _figure_independent_channels( + stat, + statistical_json, + output_dir, + ), + "figure_4": _figure_geometric_hierarchy( + source, + stat, + statistical_json, + output_dir, + ), + "figure_5": _figure_jacobi_atoms( + source, + output_dir, + ), + } + _write_generated_inputs( + output_dir, + source_json, + statistical_json, + source, + stat, + ) + annotations = { + "energy_raw": float(source["energy_raw"][0]), + "energy_connected": float(source["energy_connected"][0]), + "local_g": round( + statistical_json["outcomes"][ + "first_g_with_haar_gap_ratio_interval" + ], + 2, + ), + "ramp_g": round( + statistical_json["outcomes"][ + "first_g_with_registered_jacobi_window" + ], + 2, + ), + "number_extent": float( + statistical_json["outcomes"][ + "number_variance_compatibility_extent" + ] + ), + "D800_atom_each": int(source["rank_atom_each"][-1]), + "D800_connected_plateau": float( + source["rank_interior"][-1] / source["rank_D"][-1] + ), + } + if sync_overleaf: + project = ( + script_dir.parents[2] + / "overleaf_sync" + / "geometric_eth_large_scale" + ) + figure_target = project / "figures" + generated_target = project / "generated" + figure_target.mkdir(parents=True, exist_ok=True) + generated_target.mkdir(parents=True, exist_ok=True) + for figure in figures.values(): + shutil.copy2(figure["pdf"], figure_target) + shutil.copy2( + output_dir / "generated_numbers_v2.tex", + generated_target / "generated_numbers_v2.tex", + ) + shutil.copy2( + output_dir / "generated_tables_v2.tex", + generated_target / "generated_tables_v2.tex", + ) + inputs = { + str(path.resolve()): _sha256(path) + for path in ( + source_json_path, + source_npz_path, + statistical_json_path, + statistical_npz_path, + ) + } + checks = { + "source_artifacts_pass": bool( + source_json["all_checks_pass"] + and statistical_json["all_checks_pass"] + ), + "five_figures_generated": len(figures) == 5, + "all_pdf_png_pairs_exist": all( + Path(figure["pdf"]).is_file() + and Path(figure["png"]).is_file() + for figure in figures.values() + ), + "registered_annotations_exact": bool( + annotations["energy_raw"] == 50.0 + and annotations["energy_connected"] == 0.0 + and annotations["local_g"] == 0.2 + and annotations["ramp_g"] == 0.4 + and annotations["number_extent"] == 1.0 + and annotations["D800_atom_each"] == 120 + and abs( + annotations["D800_connected_plateau"] - 0.7 + ) + < 1e-12 + ), + } + manifest = { + "schema_version": 2, + "version": VERSION, + "inputs": inputs, + "figures": figures, + "generated_tex": { + "numbers": str( + (output_dir / "generated_numbers_v2.tex").resolve() + ), + "tables": str( + (output_dir / "generated_tables_v2.tex").resolve() + ), + }, + "scientific_annotations": annotations, + "checks": checks, + "all_checks_pass": bool(all(checks.values())), + } + manifest_path = output_dir / "figure_manifest_v2.json" + manifest_path.write_text( + json.dumps(manifest, indent=2) + "\n", + encoding="utf-8", + ) + return manifest + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--output-dir", + type=Path, + default=Path(__file__).resolve().parent / "output", + ) + parser.add_argument( + "--no-sync-overleaf", + action="store_true", + ) + args = parser.parse_args() + result = run( + args.output_dir, + sync_overleaf=not args.no_sync_overleaf, + ) + print(json.dumps(result, indent=2)) + if not result["all_checks_pass"]: + raise SystemExit("v2 figure audit failed") + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_susy_hodge_figure_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_susy_hodge_figure_v7.py new file mode 100644 index 000000000..b12ce8f76 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_susy_hodge_figure_v7.py @@ -0,0 +1,552 @@ +#!/usr/bin/env python3 +"""Generate the Hodge-resolved SUSY response inference figure and report.""" + +from __future__ import annotations + +import hashlib +import json +from pathlib import Path +from typing import Any + +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt +import numpy as np +from matplotlib.lines import Line2D +from matplotlib.patches import FancyBboxPatch + +from merge_susy_hodge_pilot_v7 import OUTPUT_JSON as PILOT_JSON + + +SCRIPT_ROOT = Path(__file__).resolve().parent +OUTPUT_ROOT = SCRIPT_ROOT / "output" +INFERENCE_JSON = OUTPUT_ROOT / "susy_hodge_v7_N14_inference.json" +FIGURE_PDF = OUTPUT_ROOT / "figure_susy_hodge_geometric_eth_v7.pdf" +FIGURE_PNG = OUTPUT_ROOT / "figure_susy_hodge_geometric_eth_v7.png" +MANIFEST_JSON = OUTPUT_ROOT / "figure_susy_hodge_geometric_eth_v7.json" +REPORT_MD = OUTPUT_ROOT / "susy_hodge_geometric_eth_report_v7.md" +ALLOWED_BRANCHES = { + "strong_covariance_universality", + "hodge_resolved_geometric_eth", + "cohomological_non_gaussian_class", + "structured_cohomology", + "feasibility_failure", +} + + +def sha256(path: Path) -> str: + digest = hashlib.sha256() + with Path(path).open("rb") as handle: + for block in iter(lambda: handle.read(1 << 20), b""): + digest.update(block) + return digest.hexdigest() + + +def _atomic_json(path: Path, payload: dict[str, Any]) -> None: + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text( + json.dumps(payload, indent=2, sort_keys=True), + encoding="utf-8", + ) + temporary.replace(path) + + +def _atomic_text(path: Path, value: str) -> None: + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(value, encoding="utf-8") + temporary.replace(path) + + +def _load(path: Path) -> dict[str, Any]: + payload = json.loads(Path(path).read_text(encoding="utf-8")) + if payload.get("version") != "v7": + raise ValueError(f"figure source has the wrong version: {path}") + if not payload.get("passed") or not all(payload.get("checks", {}).values()): + raise ValueError(f"figure source failed its checks: {path}") + return payload + + +def _style() -> None: + plt.rcParams.update( + { + "font.family": "serif", + "font.serif": ["STIXGeneral", "DejaVu Serif"], + "mathtext.fontset": "stix", + "font.size": 8.3, + "axes.titlesize": 9.1, + "axes.labelsize": 8.5, + "xtick.labelsize": 7.4, + "ytick.labelsize": 7.4, + "legend.fontsize": 6.8, + "axes.linewidth": 0.75, + "xtick.major.width": 0.65, + "ytick.major.width": 0.65, + "pdf.fonttype": 42, + "ps.fonttype": 42, + } + ) + + +def _panel_label(axis: Any, label: str) -> None: + axis.text( + -0.12, + 1.08, + label, + transform=axis.transAxes, + fontsize=9.3, + fontweight="bold", + va="top", + ) + + +def _interval_error(interval: list[float]) -> tuple[float, np.ndarray]: + values = np.asarray(interval, dtype=float) + if values.shape == (2,): + center = float(np.mean(values)) + return center, np.asarray([[center - values[0]], [values[1] - center]]) + if values.shape == (3,): + center = float(values[1]) + return center, np.asarray([[center - values[0]], [values[2] - center]]) + raise ValueError("interval must contain two or three values") + + +def _draw_interval( + axis: Any, + x: float, + interval: list[float], + *, + color: str, + marker: str, + zorder: int, +) -> None: + center, errors = _interval_error(interval) + axis.errorbar( + [x], + [center], + yerr=errors, + fmt=marker, + color=color, + ms=4.0, + lw=1.15, + capsize=2.0, + zorder=zorder, + ) + + +def _branch_statement(branch: str) -> str: + statements = { + "strong_covariance_universality": ( + "Both covariance-only nulls cover the held-out sparse pair; the " + "current data support strong finite-size covariance universality." + ), + "hodge_resolved_geometric_eth": ( + "Only the branch-resolved null covers the held-out pair; the Hodge " + "decomposition supplies predictive information beyond collapsed covariance." + ), + "cohomological_non_gaussian_class": ( + "Neither covariance-only null covers the held-out pair, and the " + "complete-realization uncertainty remains separated; a reproducible " + "cohomological four-point memory survives the registered separable " + "Hodge-covariance matching." + ), + "structured_cohomology": ( + "The generic response is not separated from the decomposable control " + "under the frozen diagnostics." + ), + "feasibility_failure": ( + "At least one numerical, sealing, or preregistered inference gate failed; " + "no scientific universality branch is claimed." + ), + } + return statements[branch] + + +def _write_report( + path: Path, + pilot: dict[str, Any], + inference: dict[str, Any], + pilot_hash: str, + inference_hash: str, +) -> None: + branch = str(inference["selected_branch"]) + primary_lines = [] + for item in sorted(inference["primary_pair"], key=lambda value: value["sector"]): + primary_lines.append( + "- {sector}: observed median {observed:.8f}, physical bootstrap " + "[{physical_low:.8f}, {physical_high:.8f}], collapsed prediction " + "[{collapsed_low:.8f}, {collapsed_high:.8f}], Hodge prediction " + "[{hodge_low:.8f}, {hodge_high:.8f}].".format( + sector=item["sector"], + observed=float(item["observed_median"]), + physical_low=float(item["physical_bootstrap_interval"][0]), + physical_high=float(item["physical_bootstrap_interval"][1]), + collapsed_low=float(item["collapsed_prediction_interval"][0]), + collapsed_high=float(item["collapsed_prediction_interval"][-1]), + hodge_low=float(item["hodge_prediction_interval"][0]), + hodge_high=float(item["hodge_prediction_interval"][-1]), + ) + ) + report = f"""# Hodge-resolved Geometric ETH result report + +## Verdict + +Selected frozen branch: `{branch}`. + +{_branch_statement(branch)} + +## Established + +- The charge-resolved cubic $\\mathcal N=2$ SYK BPS response splits into numerically orthogonal exact and coexact branches and agrees with the direct resolvent response under the registered tests. +- The pilot contains {len(pilot['groups'])} complete size/sector/panel groups and uses complete disorder realizations as its uncertainty unit. +- The held-out central/adjacent sparse pair was scored only after validating prediction SHA-256 `{inference['prediction_sha256']}`. + +{chr(10).join(primary_lines)} + +## Not established + +- This is not conventional energy-resolved ETH, a real-time chaos result, or a thermodynamic-limit theorem. +- Generic $\\mathcal N=2$ SYK is an independent supersymmetric protection mechanism, but it is not a spatially local model; locality universality requires a later nilpotent lattice-supercharge benchmark. +- Berry-curvature chaos in this model is prior art. The contribution tested here is the pre-outcome response-complex/two-point prediction of a gauge-invariant four-channel statistic. +- The Gaussian nulls match the registered collapsed or branch-resolved marginal covariance data, not the complete entrywise covariance operator. Rejection therefore establishes failure of the frozen separable Hodge-Gaussian response law; by itself it does not distinguish intrinsic non-Gaussianity from unmodeled nonseparable two-point structure. + +## Relation to prior work + +- [Fu, Gaiotto, Maldacena, and Sachdev, *Supersymmetric SYK models*](https://arxiv.org/abs/1610.08917). +- [Chen, Colin-Ellerin, Mamroud, and Papadodimas, *Chaos of Berry curvature for BPS microstates*](https://arxiv.org/abs/2604.23287). +- [Chen, Lin, and Shenker, *BPS Chaos*](https://arxiv.org/abs/2407.19387). +- [Huijse and Schoutens, *Supersymmetry, lattice fermions, independence complexes and cohomology theory*](https://arxiv.org/abs/0903.0784). + +## Provenance + +- Pilot JSON SHA-256: `{pilot_hash}`. +- Held-out inference JSON SHA-256: `{inference_hash}`. +- Uncertainty unit: `{pilot['uncertainty_unit']}`. +""" + _atomic_text(path, report) + + +def make_figure( + *, + pilot_json: Path = PILOT_JSON, + inference_json: Path = INFERENCE_JSON, + output_pdf: Path = FIGURE_PDF, + output_png: Path = FIGURE_PNG, + manifest_json: Path = MANIFEST_JSON, + report_md: Path = REPORT_MD, +) -> dict[str, Any]: + """Generate the final four-panel evidence figure and Markdown report.""" + + pilot = _load(pilot_json) + inference = _load(inference_json) + branch = str(inference.get("selected_branch")) + if branch not in ALLOWED_BRANCHES: + raise ValueError("held-out inference has an unknown branch") + groups = pilot.get("groups", []) + expected_grid = { + (N, sector, panel) + for N in (8, 10, 12) + for sector in ("central", "adjacent") + for panel in ("sparse", "isotropic") + } + observed_grid = { + (int(item["N"]), str(item["sector"]), str(item["panel_kind"])) + for item in groups + } + if observed_grid != expected_grid: + raise ValueError("pilot figure grid is incomplete") + primary = inference.get("primary_pair", []) + if { + (int(item["N"]), str(item["sector"]), str(item["panel_kind"])) + for item in primary + } != {(14, "central", "sparse"), (14, "adjacent", "sparse")}: + raise ValueError("held-out primary pair is incomplete") + group_map = { + (int(item["N"]), str(item["sector"]), str(item["panel_kind"])): item + for item in groups + } + + _style() + colors = { + "physical": "#1A1A1A", + "collapsed": "#0072B2", + "hodge": "#7A4EAB", + "central": "#D55E00", + "adjacent": "#009E73", + } + figure, axes = plt.subplots(2, 2, figsize=(7.0, 5.25), constrained_layout=True) + + axis = axes[0, 0] + _panel_label(axis, "(a)") + axis.set_axis_off() + boxes = [ + (0.02, 0.58, 0.25, 0.25, "Laughlin parent\n" r"$B^\dagger B$", "#E8F2FA"), + (0.39, 0.58, 0.23, 0.25, "protected fiber\n" r"$P(\lambda)$", "#F2F2F2"), + (0.72, 0.70, 0.24, 0.18, "$X_-$ exact", "#FBE8DD"), + (0.72, 0.44, 0.24, 0.18, "$X_+$ coexact", "#E3F3EC"), + ] + for x, y, width, height, label, color in boxes: + patch = FancyBboxPatch( + (x, y), + width, + height, + boxstyle="round,pad=0.015", + linewidth=0.8, + edgecolor="#5C626A", + facecolor=color, + transform=axis.transAxes, + ) + axis.add_patch(patch) + axis.text( + x + width / 2, + y + height / 2, + label, + ha="center", + va="center", + transform=axis.transAxes, + ) + axis.annotate( + "", + xy=(0.39, 0.705), + xytext=(0.27, 0.705), + xycoords=axis.transAxes, + textcoords=axis.transAxes, + arrowprops={"arrowstyle": "->", "lw": 1.0, "color": "#5C626A"}, + ) + axis.text( + 0.33, + 0.86, + "one-sided", + ha="center", + va="bottom", + transform=axis.transAxes, + fontsize=7.2, + color="#4F5660", + ) + for y in (0.79, 0.53): + axis.annotate( + "", + xy=(0.72, y), + xytext=(0.62, 0.705), + xycoords=axis.transAxes, + textcoords=axis.transAxes, + arrowprops={"arrowstyle": "->", "lw": 1.0, "color": "#5C626A"}, + ) + axis.text( + 0.50, + 0.24, + r"$Q^2=0:\quad X=X_-\oplus X_+,\qquad X_-^\dagger X_+=0$", + ha="center", + transform=axis.transAxes, + fontsize=8.8, + ) + axis.text( + 0.50, + 0.08, + "safe two-point Hodge data $\\longrightarrow$ sealed four-channel test", + ha="center", + transform=axis.transAxes, + fontsize=7.4, + color="#4F5660", + ) + axis.set_title("Protection mechanism becomes a response complex", pad=5) + + axis = axes[0, 1] + _panel_label(axis, "(b)") + for sector in ("central", "adjacent"): + for panel, linestyle, marker in ( + ("sparse", "-", "o"), + ("isotropic", "--", "s"), + ): + values = [ + group_map[(N, sector, panel)]["median_hodge_balance"] + for N in (8, 10, 12) + ] + axis.plot( + (8, 10, 12), + values, + color=colors[sector], + ls=linestyle, + marker=marker, + lw=1.25, + ms=3.8, + ) + axis.set_xticks((8, 10, 12)) + axis.set_ylim(-0.03, 1.05) + axis.set_xlabel("number of complex fermions $N$") + axis.set_ylabel("median Hodge balance $\\eta_H$") + axis.set_title("Two-point geometry resolves charge structure", pad=5) + handles = [ + Line2D([0], [0], color=colors["central"], lw=1.3, label="central"), + Line2D([0], [0], color=colors["adjacent"], lw=1.3, label="adjacent"), + Line2D([0], [0], color="#555", ls="-", marker="o", lw=1.1, label="sparse"), + Line2D([0], [0], color="#555", ls="--", marker="s", lw=1.1, label="isotropic"), + ] + axis.legend(handles=handles, frameon=False, ncol=2, loc="center right") + + axis = axes[1, 0] + _panel_label(axis, "(c)") + pilot_primary = [ + group_map[(N, sector, "sparse")] + for N in (8, 10, 12) + for sector in ("central", "adjacent") + ] + x_values = np.arange(len(pilot_primary), dtype=float) + for x, item in zip(x_values, pilot_primary, strict=True): + _draw_interval( + axis, + x - 0.17, + item["physical_bootstrap_interval"], + color=colors["physical"], + marker="o", + zorder=4, + ) + _draw_interval( + axis, + x, + item["collapsed_prediction_interval"], + color=colors["collapsed"], + marker="s", + zorder=3, + ) + _draw_interval( + axis, + x + 0.17, + item["hodge_prediction_interval"], + color=colors["hodge"], + marker="^", + zorder=3, + ) + axis.set_xticks( + x_values, + [ + f"{item['N']}\n{'C' if item['sector'] == 'central' else 'A'}" + for item in pilot_primary + ], + ) + axis.set_ylabel("normalized four-channel memory") + axis.set_xlabel("pilot sparse panels: size / sector") + axis.set_ylim(bottom=0.0) + axis.set_title("Pilot: safe covariance does not fix four points", pad=5) + axis.legend( + handles=[ + Line2D([0], [0], color=colors["physical"], marker="o", lw=1.1, label="physical 95% bootstrap"), + Line2D([0], [0], color=colors["collapsed"], marker="s", lw=1.1, label="collapsed 97.5%"), + Line2D([0], [0], color=colors["hodge"], marker="^", lw=1.1, label="Hodge 97.5%"), + ], + frameon=False, + loc="upper right", + ) + + axis = axes[1, 1] + _panel_label(axis, "(d)") + ordered_primary = sorted(primary, key=lambda item: item["sector"], reverse=True) + for x, item in enumerate(ordered_primary): + _draw_interval( + axis, + x - 0.17, + item["physical_bootstrap_interval"], + color=colors["physical"], + marker="o", + zorder=4, + ) + _draw_interval( + axis, + x, + item["collapsed_prediction_interval"], + color=colors["collapsed"], + marker="s", + zorder=3, + ) + _draw_interval( + axis, + x + 0.17, + item["hodge_prediction_interval"], + color=colors["hodge"], + marker="^", + zorder=3, + ) + axis.set_xticks( + np.arange(2), + [str(item["sector"]) for item in ordered_primary], + ) + axis.set_xlim(-0.55, 1.55) + axis.set_ylim(bottom=0.0) + axis.set_ylabel("normalized four-channel memory") + axis.set_title("Held-out $N=14$: prediction sealed before opening", pad=5) + axis.text( + 0.50, + 0.97, + branch.replace("_", " "), + transform=axis.transAxes, + ha="center", + va="top", + fontsize=7.6, + fontweight="bold", + color="#8B1A1A" if branch != "strong_covariance_universality" else "#1B6E3C", + ) + + output_pdf = Path(output_pdf) + output_png = Path(output_png) + output_pdf.parent.mkdir(parents=True, exist_ok=True) + output_png.parent.mkdir(parents=True, exist_ok=True) + figure.savefig(output_pdf, bbox_inches="tight") + figure.savefig(output_png, dpi=300, bbox_inches="tight") + plt.close(figure) + + pilot_hash = sha256(pilot_json) + inference_hash = sha256(inference_json) + _write_report( + report_md, + pilot, + inference, + pilot_hash, + inference_hash, + ) + checks = { + "complete_pilot_grid": observed_grid == expected_grid, + "complete_heldout_pair": len(primary) == 2, + "known_selected_branch": branch in ALLOWED_BRANCHES, + "figure_outputs_exist": output_pdf.is_file() and output_png.is_file(), + "source_backed_report_exists": Path(report_md).is_file(), + } + manifest = { + "version": "v7", + "selected_branch": branch, + "pilot_group_count": len(groups), + "inputs": { + Path(pilot_json).name: pilot_hash, + Path(inference_json).name: inference_hash, + }, + "outputs": { + Path(output_pdf).name: sha256(output_pdf), + Path(output_png).name: sha256(output_png), + Path(report_md).name: sha256(report_md), + }, + "plotted_values": { + "pilot_groups": groups, + "heldout_primary_pair": primary, + }, + "caption": ( + "Hodge-resolved response-complex test across generic cubic " + "supersymmetric cohomology: safe two-point charge structure, " + "complete-realization pilot inference, and sealed held-out verdict." + ), + "checks": checks, + "passed": all(checks.values()), + } + _atomic_json(manifest_json, manifest) + return manifest + + +def main() -> None: + manifest = make_figure() + print(json.dumps(manifest, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_susy_hodge_manuscript_assets_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_susy_hodge_manuscript_assets_v7.py new file mode 100644 index 000000000..87916cb0a --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_susy_hodge_manuscript_assets_v7.py @@ -0,0 +1,286 @@ +#!/usr/bin/env python3 +"""Build result-conditioned manuscript assets from audited v7 artifacts.""" + +from __future__ import annotations + +import argparse +import json +import shutil +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from merge_susy_hodge_pilot_v7 import OUTPUT_JSON as PILOT_JSON +from make_susy_hodge_figure_v7 import ( + FIGURE_PDF, + MANIFEST_JSON as FIGURE_MANIFEST_JSON, +) +from run_susy_hodge_geometric_eth_v7 import _atomic_json, sha256 +from analyze_susy_hodge_geometric_eth_v7 import N14_INFERENCE_JSON + + +SCRIPT_ROOT = Path(__file__).resolve().parent +REPO_ROOT = SCRIPT_ROOT.parents[2] +OUTPUT_ROOT = SCRIPT_ROOT / "output" +MANUSCRIPT_ROOT = REPO_ROOT / "overleaf_sync" / "cohomological_geometric_eth" +RESULTS_TEX = MANUSCRIPT_ROOT / "generated" / "results_v7.tex" +FIGURE_TARGET = MANUSCRIPT_ROOT / "figures" / FIGURE_PDF.name +MANIFEST_JSON = OUTPUT_ROOT / "susy_hodge_manuscript_assets_v7.json" +PUBLISHABLE_BRANCHES = { + "strong_covariance_universality", + "hodge_resolved_geometric_eth", + "cohomological_non_gaussian_class", + "structured_cohomology", +} + + +def _load_passed(path: Path) -> dict[str, Any]: + payload = json.loads(Path(path).read_text(encoding="utf-8")) + if ( + payload.get("version") != "v7" + or not payload.get("passed") + or not all(payload.get("checks", {}).values()) + ): + raise ValueError(f"manuscript source failed its audit: {path}") + return payload + + +def _atomic_text(path: Path, value: str) -> None: + target = Path(path) + target.parent.mkdir(parents=True, exist_ok=True) + temporary = target.with_suffix(target.suffix + ".tmp") + temporary.write_text(value, encoding="utf-8") + temporary.replace(target) + + +def _atomic_copy(source: Path, target: Path) -> None: + destination = Path(target) + destination.parent.mkdir(parents=True, exist_ok=True) + temporary = destination.with_suffix(destination.suffix + ".tmp") + shutil.copyfile(source, temporary) + temporary.replace(destination) + + +def _macro(name: str, value: str) -> str: + return rf"\newcommand{{\{name}}}{{{value}}}" + + +def _expected_pilot_grid(groups: list[dict[str, Any]]) -> bool: + observed = { + (int(item["N"]), str(item["sector"]), str(item["panel_kind"])) + for item in groups + } + expected = { + (size, sector, panel) + for size in (8, 10, 12) + for sector in ("central", "adjacent") + for panel in ("sparse", "isotropic") + } + return observed == expected + + +def _expected_primary_pair(records: list[dict[str, Any]]) -> bool: + return { + (int(item["N"]), str(item["sector"]), str(item["panel_kind"])) + for item in records + } == {(14, "central", "sparse"), (14, "adjacent", "sparse")} + + +def _branch_abstract(branch: str, rejected_groups: int) -> str: + opening = ( + "Exactly degenerate quantum manifolds have no internal level statistics, " + "but their projectors move over coupling space. We formulate this motion as " + "a response complex and compare one-sided frustration-free constraints with " + "the orthogonal exact/coexact response of charge-resolved cubic " + r"$\mathcal N=2$ Sachdev--Ye--Kitaev cohomology. " + f"In the sequential $N=8,10,12$ pilot, {rejected_groups} of 12 " + "size/sector/panel groups reject both registered separable covariance nulls. " + ) + endings = { + "strong_covariance_universality": ( + "A prediction sealed before the held-out $N=14$ opening covers the " + "central/adjacent sparse pair under both nulls, supporting a finite-size " + "covariance-universal response law." + ), + "hodge_resolved_geometric_eth": ( + "A prediction sealed before the held-out $N=14$ opening covers the " + "central/adjacent sparse pair only after resolving the Hodge branches, " + "establishing predictive mechanism dependence beyond collapsed covariance." + ), + "cohomological_non_gaussian_class": ( + "A prediction sealed before the held-out $N=14$ opening is rejected by " + "both nulls for the central/adjacent sparse pair, establishing structured " + "four-point memory beyond the frozen separable Hodge-covariance law, " + "without claiming complete entrywise covariance matching." + ), + "structured_cohomology": ( + "The held-out $N=14$ response remains statistically indistinguishable " + "from the registered decomposable cohomological control, selecting a " + "structured rather than covariance-universal response class." + ), + } + return opening + endings[branch] + + +def _interval_macro(interval: list[float]) -> str: + return rf"$[{float(interval[0]):.6f},\,{float(interval[-1]):.6f}]$" + + +def build_manuscript_assets( + *, + pilot_json: Path = PILOT_JSON, + inference_json: Path = N14_INFERENCE_JSON, + figure_manifest_json: Path = FIGURE_MANIFEST_JSON, + figure_pdf: Path = FIGURE_PDF, + results_tex: Path = RESULTS_TEX, + figure_target: Path = FIGURE_TARGET, + manifest_json: Path = MANIFEST_JSON, +) -> dict[str, Any]: + """Enable result prose only after all compact sources and hashes pass.""" + + pilot = _load_passed(pilot_json) + inference = _load_passed(inference_json) + figure_manifest = _load_passed(figure_manifest_json) + groups = list(pilot.get("groups", [])) + primary = list(inference.get("primary_pair", [])) + branch = str(inference.get("selected_branch")) + if not _expected_pilot_grid(groups): + raise ValueError("manuscript pilot grid is incomplete") + if not _expected_primary_pair(primary): + raise ValueError("manuscript held-out primary pair is incomplete") + if branch not in PUBLISHABLE_BRANCHES: + raise ValueError("held-out branch is not publishable") + if ( + figure_manifest.get("inputs", {}).get(Path(pilot_json).name) + != sha256(pilot_json) + or figure_manifest.get("inputs", {}).get(Path(inference_json).name) + != sha256(inference_json) + or figure_manifest.get("outputs", {}).get(Path(figure_pdf).name) + != sha256(figure_pdf) + or figure_manifest.get("selected_branch") != branch + ): + raise ValueError("figure manifest does not match manuscript sources") + + rejected_groups = sum( + not bool(item.get("collapsed_covered")) + and not bool(item.get("hodge_covered")) + for item in groups + ) + primary_by_sector = {str(item["sector"]): item for item in primary} + adjacent = primary_by_sector["adjacent"] + central = primary_by_sector["central"] + pilot_sentence = ( + f"Across the complete $N=8,10,12$ pilot, {rejected_groups} of 12 " + "groups reject both registered separable covariance nulls under " + "complete-realization resampling." + ) + result_sentence = ( + "The held-out adjacent and central medians are " + f"{float(adjacent['observed_median']):.6f} and " + f"{float(central['observed_median']):.6f}; their complete-realization " + "confidence intervals do not overlap either sealed covariance prediction." + ) + prediction_sha = str(inference.get("prediction_sha256", "")) + if len(prediction_sha) != 64: + raise ValueError("inference does not contain a full prediction hash") + lines = [ + "% Generated from audited v7 inference; do not edit.", + r"\newif\ifheldoutcomplete", + r"\heldoutcompletetrue", + _macro("HeldoutAbstract", _branch_abstract(branch, rejected_groups)), + _macro("HeldoutBranch", branch.replace("_", r"\_")), + _macro("HeldoutResultSentence", result_sentence), + _macro("PilotResultSentence", pilot_sentence), + _macro("HeldoutSeal", prediction_sha[:12]), + _macro( + "HeldoutAdjacentObserved", + f"{float(adjacent['observed_median']):.6f}", + ), + _macro( + "HeldoutAdjacentPhysical", + _interval_macro(adjacent["physical_bootstrap_interval"]), + ), + _macro( + "HeldoutAdjacentCollapsed", + _interval_macro(adjacent["collapsed_prediction_interval"]), + ), + _macro( + "HeldoutAdjacentHodge", + _interval_macro(adjacent["hodge_prediction_interval"]), + ), + _macro( + "HeldoutCentralObserved", + f"{float(central['observed_median']):.6f}", + ), + _macro( + "HeldoutCentralPhysical", + _interval_macro(central["physical_bootstrap_interval"]), + ), + _macro( + "HeldoutCentralCollapsed", + _interval_macro(central["collapsed_prediction_interval"]), + ), + _macro( + "HeldoutCentralHodge", + _interval_macro(central["hodge_prediction_interval"]), + ), + ] + _atomic_text(results_tex, "\n".join(lines) + "\n") + _atomic_copy(figure_pdf, figure_target) + checks = { + "complete_pilot_grid": _expected_pilot_grid(groups), + "complete_primary_pair": _expected_primary_pair(primary), + "publishable_registered_branch": branch in PUBLISHABLE_BRANCHES, + "figure_manifest_matches_sources": True, + "result_macro_enabled": r"\heldoutcompletetrue" + in Path(results_tex).read_text(encoding="utf-8"), + "figure_copy_exact": sha256(figure_target) == sha256(figure_pdf), + } + manifest = { + "version": "v7", + "generated_utc": datetime.now(timezone.utc).isoformat(), + "selected_branch": branch, + "prediction_sha256": prediction_sha, + "inputs": { + Path(pilot_json).name: sha256(pilot_json), + Path(inference_json).name: sha256(inference_json), + Path(figure_manifest_json).name: sha256(figure_manifest_json), + Path(figure_pdf).name: sha256(figure_pdf), + }, + "outputs": { + str(Path(results_tex).name): sha256(results_tex), + str(Path(figure_target).name): sha256(figure_target), + }, + "checks": checks, + "passed": all(checks.values()), + } + if not manifest["passed"]: + raise RuntimeError(f"manuscript asset build failed: {checks}") + _atomic_json(manifest_json, manifest) + return manifest + + +def _parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--pilot-json", type=Path, default=PILOT_JSON) + parser.add_argument("--inference-json", type=Path, default=N14_INFERENCE_JSON) + parser.add_argument( + "--figure-manifest-json", type=Path, default=FIGURE_MANIFEST_JSON + ) + parser.add_argument("--figure-pdf", type=Path, default=FIGURE_PDF) + return parser + + +def main() -> None: + args = _parser().parse_args() + payload = build_manuscript_assets( + pilot_json=args.pilot_json, + inference_json=args.inference_json, + figure_manifest_json=args.figure_manifest_json, + figure_pdf=args.figure_pdf, + ) + print(json.dumps(payload, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_topological_holonomy_figure_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_topological_holonomy_figure_v3.py new file mode 100644 index 000000000..49a2c1a2d --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/make_topological_holonomy_figure_v3.py @@ -0,0 +1,454 @@ +#!/usr/bin/env python3 +"""Generate the fixed-Chern Wilson-holonomy publication figure.""" + +from __future__ import annotations + +import hashlib +import json +from pathlib import Path +from typing import Any + +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt +import numpy as np + +from lgeth.bundle_geometry import analyze_frame_bundle +from lgeth.holonomy import deform_orbital_mesh +from lgeth.lattice import BosonBasis +from lgeth.twist_bundle import default_checkpoint_path, load_twist_bundle + + +SCRIPT_ROOT = Path(__file__).resolve().parent +OUTPUT = SCRIPT_ROOT / "output" +SOURCE_JSON = OUTPUT / "topological_holonomy_v3.json" +SOURCE_NPZ = OUTPUT / "topological_holonomy_v3.npz" +FIGURE_PDF = OUTPUT / "figure_7_topological_holonomy_v3.pdf" +FIGURE_PNG = OUTPUT / "figure_7_topological_holonomy_v3.png" +MANIFEST = OUTPUT / "figure_manifest_v3.json" + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def _atomic_json(path: Path, payload: dict[str, Any]) -> None: + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text( + json.dumps(payload, indent=2, sort_keys=True), + encoding="utf-8", + ) + temporary.replace(path) + + +def _style() -> None: + plt.rcParams.update( + { + "font.family": "serif", + "font.serif": ["STIXGeneral", "DejaVu Serif"], + "mathtext.fontset": "stix", + "font.size": 8.4, + "axes.titlesize": 9.2, + "axes.labelsize": 8.6, + "xtick.labelsize": 7.7, + "ytick.labelsize": 7.7, + "legend.fontsize": 7.0, + "axes.linewidth": 0.75, + "xtick.major.width": 0.65, + "ytick.major.width": 0.65, + "pdf.fonttype": 42, + "ps.fonttype": 42, + } + ) + + +def _panel_label(axis, label: str) -> None: + axis.text( + -0.15, + 1.08, + label, + transform=axis.transAxes, + fontsize=9.2, + fontweight="bold", + va="top", + ) + + +def _determinant_flow( + plaquettes: np.ndarray, +) -> tuple[np.ndarray, np.ndarray]: + flux_by_transverse_slice = np.sum( + np.angle(np.linalg.det(np.asarray(plaquettes))), + axis=0, + ) + transverse = np.arange(flux_by_transverse_slice.size + 1) + transverse = transverse / flux_by_transverse_slice.size + flow = np.concatenate( + [[0.0], np.cumsum(flux_by_transverse_slice)] + ) / (2.0 * np.pi) + return transverse, flow + + +def _n4_determinant_flows( + mesh: int, + seed: int, +) -> tuple[np.ndarray, np.ndarray, np.ndarray, dict[str, str]]: + bundle = load_twist_bundle( + default_checkpoint_path(4, mesh), + expected_N=4, + expected_n_flux=10, + expected_rank=25, + expected_mesh=mesh, + ) + final_geometry = analyze_frame_bundle( + bundle.coefficient_frames, + deform_orbital_mesh( + bundle.orbital_frames, + g=1.0, + seed=seed, + commuting=False, + ), + BosonBasis(10, 4), + ) + transverse, base_flow = _determinant_flow( + bundle.geometry.plaquette + ) + final_transverse, final_flow = _determinant_flow( + final_geometry.plaquette + ) + if not np.array_equal(transverse, final_transverse): + raise RuntimeError("base and deformed determinant grids disagree") + checkpoint_json = default_checkpoint_path(4, mesh) + checkpoint_npz = checkpoint_json.with_suffix(".npz") + return ( + transverse, + base_flow, + final_flow, + { + str(checkpoint_json.relative_to(SCRIPT_ROOT)): _sha256( + checkpoint_json + ), + str(checkpoint_npz.relative_to(SCRIPT_ROOT)): _sha256( + checkpoint_npz + ), + }, + ) + + +def make_figure() -> dict[str, Any]: + payload = json.loads(SOURCE_JSON.read_text(encoding="utf-8")) + if payload["result_branch"] != "fixed_chern_deformed_holonomy": + raise RuntimeError("Figure 7 requires the accepted deformed branch") + configuration = payload["configuration"] + g_values = np.asarray(configuration["g_values"], dtype=float) + seeds = np.asarray(configuration["generator_seeds"], dtype=np.int64) + transverse, base_flow, final_flow, checkpoint_hashes = ( + _n4_determinant_flows( + mesh=int(configuration["primary_mesh"]), + seed=int(seeds[0]), + ) + ) + with np.load(SOURCE_NPZ, allow_pickle=False) as arrays: + gap_mean = [ + np.asarray(arrays[f"size_{index}_gap_mean"]) + for index in range(2) + ] + form_mean = [ + np.asarray(arrays[f"size_{index}_form_mean"]) + for index in range(2) + ] + commuting_gap = [ + np.asarray(arrays[f"size_{index}_commuting_gap"]) + for index in range(2) + ] + commuting_form = [ + np.asarray(arrays[f"size_{index}_commuting_form"]) + for index in range(2) + ] + cue_gap = [ + np.asarray(arrays[f"size_{index}_cue_gap"]) + for index in range(2) + ] + cue_form = [ + np.asarray(arrays[f"size_{index}_cue_form"]) + for index in range(2) + ] + cue_lower = [ + np.asarray( + arrays[f"size_{index}_cue_form_simultaneous_lower"] + ) + for index in range(2) + ] + cue_upper = [ + np.asarray( + arrays[f"size_{index}_cue_form_simultaneous_upper"] + ) + for index in range(2) + ] + + _style() + navy = "#24476b" + orange = "#d8752d" + teal = "#228b8d" + grey = "#666b73" + pale_navy = "#dce7f0" + pale_orange = "#f3e3d7" + figure, axes = plt.subplots( + 2, + 2, + figsize=(7.0, 5.25), + constrained_layout=True, + ) + + axis = axes[0, 0] + _panel_label(axis, "(a)") + for index, (size, color, marker) in enumerate( + zip(payload["sizes"], (navy, orange), ("o", "s"), strict=True) + ): + chern = float(size["base_chern_integer"]) + axis.plot( + g_values, + np.full_like(g_values, chern), + marker=marker, + color=color, + lw=1.45, + ms=3.7, + label=rf"$N={size['N']}$: $C_1={int(chern)}$", + ) + axis.set_xlabel("isospectral deformation $g$") + axis.set_ylabel("first Chern number $C_1$") + axis.set_ylim(4.9, 11.0) + axis.set_title("Topology and spectrum remain fixed", pad=5) + axis.grid(alpha=0.18, lw=0.55) + twin = axis.twinx() + for size, color in zip( + payload["sizes"], + (navy, orange), + strict=True, + ): + twin.plot( + g_values, + np.full_like(g_values, size["minimum_external_gap"]), + ":", + color=color, + lw=1.1, + alpha=0.75, + ) + twin.set_ylabel("external gap $\\Delta$", color=grey) + twin.tick_params(axis="y", colors=grey) + axis.legend(frameon=False, loc="center left") + axis.text( + 0.98, + 0.08, + "$H_g=\\mathcal{U}_g H_0\\mathcal{U}_g^\\dagger$", + transform=axis.transAxes, + ha="right", + color=grey, + fontsize=7.2, + ) + + axis = axes[0, 1] + _panel_label(axis, "(b)") + axis.plot( + transverse, + base_flow, + color=navy, + lw=1.65, + label="$g=0$", + ) + axis.plot( + transverse, + final_flow, + color=orange, + lw=1.65, + label="$g=1$", + ) + axis.axhline(10.0, color=grey, lw=0.7, ls=":") + axis.set_xlabel("transverse twist $\\theta_y/2\\pi$") + axis.set_ylabel( + "$\\frac{1}{2\\pi}\\sum_{y' None: + print(json.dumps(make_figure(), indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/merge_susy_hodge_pilot_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/merge_susy_hodge_pilot_v7.py new file mode 100644 index 000000000..36999ead6 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/merge_susy_hodge_pilot_v7.py @@ -0,0 +1,195 @@ +#!/usr/bin/env python3 +"""Merge independently opened v7 pilot sizes into one audited artifact.""" + +from __future__ import annotations + +import argparse +import json +from datetime import datetime, timezone +from pathlib import Path +from typing import Any, Sequence + +import numpy as np + +from run_susy_hodge_geometric_eth_v7 import _atomic_json, _atomic_npz, sha256 + + +SCRIPT_ROOT = Path(__file__).resolve().parent +OUTPUT_ROOT = SCRIPT_ROOT / "output" +DEFAULT_JSONS = ( + OUTPUT_ROOT / "susy_hodge_v7_outcomes_pilot_banked.json", + OUTPUT_ROOT / "susy_hodge_v7_outcomes_pilot_N10_banked.json", + OUTPUT_ROOT / "susy_hodge_v7_outcomes_pilot_N12_banked.json", +) +DEFAULT_NPZS = ( + OUTPUT_ROOT / "susy_hodge_v7_outcomes_pilot_banked.npz", + OUTPUT_ROOT / "susy_hodge_v7_outcomes_pilot_N10_banked.npz", + OUTPUT_ROOT / "susy_hodge_v7_outcomes_pilot_N12_banked.npz", +) +OUTPUT_JSON = OUTPUT_ROOT / "susy_hodge_v7_outcomes_pilot_combined.json" +OUTPUT_NPZ = OUTPUT_ROOT / "susy_hodge_v7_outcomes_pilot_combined.npz" + + +def _load_passed(path: Path) -> dict[str, Any]: + payload = json.loads(Path(path).read_text(encoding="utf-8")) + if ( + payload.get("version") != "v7" + or not payload.get("passed") + or not all(payload.get("checks", {}).values()) + ): + raise ValueError(f"pilot source failed its audit: {path}") + return payload + + +def merge_pilot_artifacts( + json_paths: Sequence[Path], + npz_paths: Sequence[Path], + *, + output_json: Path = OUTPUT_JSON, + output_npz: Path = OUTPUT_NPZ, + expected_sizes: Sequence[int] = (8, 10, 12), +) -> dict[str, Any]: + """Merge compact per-size artifacts without reopening raw outcome sidecars.""" + + json_sources = tuple(Path(path) for path in json_paths) + npz_sources = tuple(Path(path) for path in npz_paths) + sizes = tuple(int(size) for size in expected_sizes) + if not json_sources or len(json_sources) != len(npz_sources): + raise ValueError("pilot merge requires paired JSON and NPZ sources") + if len(sizes) != len(set(sizes)): + raise ValueError("expected pilot sizes must be unique") + + payloads = [_load_passed(path) for path in json_sources] + uncertainty_units = {item.get("uncertainty_unit") for item in payloads} + null_counts = {int(item.get("null_replicates", -1)) for item in payloads} + bootstrap_counts = { + int(item.get("physical_bootstrap_replicates", -1)) for item in payloads + } + coverages = {float(item.get("prediction_coverage", -1.0)) for item in payloads} + if ( + len(uncertainty_units) != 1 + or len(null_counts) != 1 + or len(bootstrap_counts) != 1 + or len(coverages) != 1 + ): + raise ValueError("pilot source protocols disagree") + + groups: list[dict[str, Any]] = [] + arrays: dict[str, np.ndarray] = {} + source_records: list[dict[str, Any]] = [] + for json_path, npz_path, payload in zip( + json_sources, npz_sources, payloads, strict=True + ): + if payload.get("arrays_sha256") != sha256(npz_path): + raise ValueError(f"pilot NPZ hash mismatch: {npz_path}") + with np.load(npz_path, allow_pickle=False) as source_arrays: + for key in source_arrays.files: + if key in arrays: + raise ValueError(f"duplicate pilot array key: {key}") + arrays[key] = np.asarray(source_arrays[key]).copy() + groups.extend(list(payload.get("groups", []))) + source_records.append( + { + "json_file": json_path.name, + "json_sha256": sha256(json_path), + "npz_file": npz_path.name, + "npz_sha256": sha256(npz_path), + "safe_covariates_sha256": payload.get("safe_covariates_sha256"), + } + ) + + identities = [ + (int(item["N"]), str(item["sector"]), str(item["panel_kind"])) + for item in groups + ] + if len(identities) != len(set(identities)): + raise ValueError("pilot merge contains duplicate size/sector/panel groups") + expected_grid = { + (size, sector, panel) + for size in sizes + for sector in ("central", "adjacent") + for panel in ("sparse", "isotropic") + } + observed_grid = set(identities) + expected_array_keys = { + f"N{size}_{sector}_{panel}_{suffix}" + for size, sector, panel in expected_grid + for suffix in ( + "physical", + "physical_bootstrap", + "collapsed_null", + "hodge_null", + ) + } + if observed_grid != expected_grid: + raise ValueError("pilot merge does not match the registered size grid") + if set(arrays) != expected_array_keys: + raise ValueError("pilot merge arrays do not match the registered groups") + + _atomic_npz(output_npz, **arrays) + checks = { + "all_sources_passed": all( + payload.get("passed") and all(payload.get("checks", {}).values()) + for payload in payloads + ), + "complete_registered_grid": observed_grid == expected_grid, + "unique_group_identities": len(identities) == len(set(identities)), + "complete_array_grid": set(arrays) == expected_array_keys, + "finite_arrays": all(np.all(np.isfinite(value)) for value in arrays.values()), + "common_complete_realization_protocol": uncertainty_units + == {"complete_disorder_realization"}, + "positive_registered_counts": next(iter(null_counts)) > 0 + and next(iter(bootstrap_counts)) > 0, + } + result = { + "version": "v7", + "generated_utc": datetime.now(timezone.utc).isoformat(), + "uncertainty_unit": next(iter(uncertainty_units)), + "null_replicates": next(iter(null_counts)), + "physical_bootstrap_replicates": next(iter(bootstrap_counts)), + "prediction_coverage": next(iter(coverages)), + "registered_sizes": list(sizes), + "groups": sorted( + groups, + key=lambda item: ( + int(item["N"]), + str(item["sector"]), + str(item["panel_kind"]), + ), + ), + "source_pilot_artifacts": source_records, + "arrays_sha256": sha256(output_npz), + "sources": {Path(__file__).name: sha256(Path(__file__))}, + "checks": checks, + "passed": all(checks.values()), + } + if not result["passed"]: + raise RuntimeError(f"pilot merge failed: {checks}") + _atomic_json(output_json, result) + return result + + +def _parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--jsons", type=Path, nargs="+", default=list(DEFAULT_JSONS)) + parser.add_argument("--npzs", type=Path, nargs="+", default=list(DEFAULT_NPZS)) + parser.add_argument("--output-json", type=Path, default=OUTPUT_JSON) + parser.add_argument("--output-npz", type=Path, default=OUTPUT_NPZ) + parser.add_argument("--sizes", type=int, nargs="+", default=[8, 10, 12]) + return parser + + +def main() -> None: + args = _parser().parse_args() + payload = merge_pilot_artifacts( + args.jsons, + args.npzs, + output_json=args.output_json, + output_npz=args.output_npz, + expected_sizes=args.sizes, + ) + print(json.dumps(payload, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/citation_audit_v1.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/citation_audit_v1.json new file mode 100644 index 000000000..3068ede90 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/citation_audit_v1.json @@ -0,0 +1,1266 @@ +{ + "all_checks_pass": true, + "article": "From Local Repulsion to Global Geometry: Large-Scale Tests of Geometric ETH", + "bibliography": "overleaf_sync/geometric_eth_large_scale/references.bib", + "bibliography_records": 35, + "errors": [], + "missing_bibliography_keys": [], + "records": [ + { + "arxiv": null, + "author_matches": { + "Berry": true + }, + "authors": [ + "Berry" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1098/rspa.1984.0023", + "key": "berry1984", + "observed": { + "authors": [ + "Michael Berry" + ], + "identifier": "https://doi.org/10.1098/rspa.1984.0023", + "metadata_source": "OpenAlex DOI resolution", + "title": "Quantal phase factors accompanying adiabatic changes", + "year": 1984 + }, + "section": "geometric foundations", + "title": "Quantal phase factors accompanying adiabatic changes", + "title_similarity": 1.0, + "verified": true, + "year": 1984 + }, + { + "arxiv": null, + "author_matches": { + "Wilczek": true, + "Zee": true + }, + "authors": [ + "Wilczek", + "Zee" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevLett.52.2111", + "key": "wilczekzee1984", + "observed": { + "authors": [ + "Frank Wilczek", + "A. Zee" + ], + "identifier": "https://doi.org/10.1103/physrevlett.52.2111", + "metadata_source": "OpenAlex DOI resolution", + "title": "Appearance of Gauge Structure in Simple Dynamical Systems", + "year": 1984 + }, + "section": "geometric foundations", + "title": "Appearance of gauge structure in simple dynamical systems", + "title_similarity": 1.0, + "verified": true, + "year": 1984 + }, + { + "arxiv": null, + "author_matches": { + "Provost": true, + "Vallee": true + }, + "authors": [ + "Provost", + "Vallee" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1007/BF02193559", + "key": "provostvallee1980", + "observed": { + "authors": [ + "Jean-Pierre Provost", + "G. Vall\u00e9e" + ], + "identifier": "https://doi.org/10.1007/bf02193559", + "metadata_source": "OpenAlex DOI resolution", + "title": "Riemannian structure on manifolds of quantum states", + "year": 1980 + }, + "section": "geometric foundations", + "title": "Riemannian structure on manifolds of quantum states", + "title_similarity": 1.0, + "verified": true, + "year": 1980 + }, + { + "arxiv": null, + "author_matches": { + "Kato": true + }, + "authors": [ + "Kato" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1143/JPSJ.5.435", + "key": "kato1950", + "observed": { + "authors": [ + "Tosio Kato" + ], + "identifier": "https://doi.org/10.1143/jpsj.5.435", + "metadata_source": "OpenAlex DOI resolution", + "title": "On the Adiabatic Theorem of Quantum Mechanics", + "year": 1950 + }, + "section": "isolated-projector formalism", + "title": "On the adiabatic theorem of quantum mechanics", + "title_similarity": 1.0, + "verified": true, + "year": 1950 + }, + { + "arxiv": "2604.23287", + "author_matches": { + "Chen": true, + "Colin-Ellerin": true, + "Mamroud": true, + "Papadodimas": true + }, + "authors": [ + "Chen", + "Colin-Ellerin", + "Mamroud", + "Papadodimas" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": null, + "key": "chen2026", + "observed": { + "authors": [ + "Yiming Chen", + "Sean Colin-Ellerin", + "Ohad Mamroud", + "Kyriakos Papadodimas" + ], + "identifier": "https://arxiv.org/abs/2604.23287", + "metadata_source": "arXiv Atom API", + "title": "Chaos of Berry curvature for BPS microstates", + "year": 2026 + }, + "section": "geometric chaos motivation", + "title": "Chaos of Berry curvature for BPS microstates", + "title_similarity": 1.0, + "verified": true, + "year": 2026 + }, + { + "arxiv": null, + "author_matches": { + "Laughlin": true + }, + "authors": [ + "Laughlin" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevLett.50.1395", + "key": "laughlin1983", + "observed": { + "authors": [ + "R. B. Laughlin" + ], + "identifier": "https://doi.org/10.1103/physrevlett.50.1395", + "metadata_source": "OpenAlex DOI resolution", + "title": "Anomalous Quantum Hall Effect: An Incompressible Quantum Fluid with Fractionally Charged Excitations", + "year": 1983 + }, + "section": "Laughlin zero modes", + "title": "Anomalous quantum Hall effect: An incompressible quantum fluid with fractionally charged excitations", + "title_similarity": 1.0, + "verified": true, + "year": 1983 + }, + { + "arxiv": null, + "author_matches": { + "Haldane": true + }, + "authors": [ + "Haldane" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevLett.51.605", + "key": "haldane1983", + "observed": { + "authors": [ + "F. D. M. Haldane" + ], + "identifier": "https://doi.org/10.1103/physrevlett.51.605", + "metadata_source": "OpenAlex DOI resolution", + "title": "Fractional Quantization of the Hall Effect: A Hierarchy of Incompressible Quantum Fluid States", + "year": 1983 + }, + "section": "fractional quantum Hall hierarchy", + "title": "Fractional quantization of the Hall effect: A hierarchy of incompressible quantum fluid states", + "title_similarity": 1.0, + "verified": true, + "year": 1983 + }, + { + "arxiv": null, + "author_matches": { + "Bernevig": true, + "Haldane": true + }, + "authors": [ + "Bernevig", + "Haldane" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevLett.100.246802", + "key": "bernevighaldane2008", + "observed": { + "authors": [ + "B. Andrei Bernevig", + "F. D. M. Haldane" + ], + "identifier": "https://doi.org/10.1103/physrevlett.100.246802", + "metadata_source": "OpenAlex DOI resolution", + "title": "Model Fractional Quantum Hall States and Jack Polynomials", + "year": 2008 + }, + "section": "generalized exclusion rules", + "title": "Model fractional quantum Hall states and Jack polynomials", + "title_similarity": 1.0, + "verified": true, + "year": 2008 + }, + { + "arxiv": null, + "author_matches": { + "Chen": true, + "Seidel": true + }, + "authors": [ + "Chen", + "Seidel" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevB.91.085103", + "key": "chenseidel2015", + "observed": { + "authors": [ + "Li Chen", + "Alexander Seidel" + ], + "identifier": "https://doi.org/10.1103/physrevb.91.085103", + "metadata_source": "OpenAlex DOI resolution", + "title": "Algebraic approach to the study of zero modes of Haldane pseudopotentials", + "year": 2015 + }, + "section": "zero-mode algebra", + "title": "Algebraic approach to the study of zero modes of Haldane pseudopotentials", + "title_similarity": 1.0, + "verified": true, + "year": 2015 + }, + { + "arxiv": null, + "author_matches": { + "Moore": true, + "Read": true + }, + "authors": [ + "Moore", + "Read" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1016/0550-3213(91)90407-O", + "key": "mooreread1991", + "observed": { + "authors": [ + "Gregory Moore", + "Nicholas Read" + ], + "identifier": "https://doi.org/10.1016/0550-3213(91)90407-o", + "metadata_source": "OpenAlex DOI resolution", + "title": "Nonabelions in the fractional quantum hall effect", + "year": 1991 + }, + "section": "higher clustering", + "title": "Nonabelions in the fractional quantum Hall effect", + "title_similarity": 1.0, + "verified": true, + "year": 1991 + }, + { + "arxiv": null, + "author_matches": { + "Read": true, + "Rezayi": true + }, + "authors": [ + "Read", + "Rezayi" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevB.59.8084", + "key": "readrezayi1999", + "observed": { + "authors": [ + "N. Read", + "E. H. Rezayi" + ], + "identifier": "https://doi.org/10.1103/physrevb.59.8084", + "metadata_source": "OpenAlex DOI resolution", + "title": "Beyond paired quantum Hall states: Parafermions and incompressible states in the first excited Landau level", + "year": 1999 + }, + "section": "higher clustering", + "title": "Beyond paired quantum Hall states: Parafermions and incompressible states in the first excited Landau level", + "title_similarity": 1.0, + "verified": true, + "year": 1999 + }, + { + "arxiv": null, + "author_matches": { + "Chen": true, + "Fanmao Zhang": true, + "Matheus Schossler": true, + "Seidel": true + }, + "authors": [ + "Fanmao Zhang", + "Matheus Schossler", + "Seidel", + "Chen" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevB.108.075142", + "key": "zhang2023", + "observed": { + "authors": [ + "Fanmao Zhang", + "Matheus Schossler", + "Alexander Seidel", + "Li Chen" + ], + "identifier": "https://doi.org/10.1103/physrevb.108.075142", + "metadata_source": "OpenAlex DOI resolution", + "title": "From frustration-free parent Hamiltonians to off-diagonal long-range order: Moore-Read and related states in second quantization", + "year": 2023 + }, + "section": "clustered root spaces", + "title": "From frustration-free parent Hamiltonians to off-diagonal long-range order: Moore-Read and related states in second quantization", + "title_similarity": 1.0, + "verified": true, + "year": 2023 + }, + { + "arxiv": null, + "author_matches": { + "Mazaheri": true, + "Nussinov": true, + "Ortiz": true, + "Seidel": true + }, + "authors": [ + "Mazaheri", + "Ortiz", + "Nussinov", + "Seidel" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevB.91.085115", + "key": "mazaheri2015", + "observed": { + "authors": [ + "Tahereh Mazaheri", + "Gerardo Ort\u00edz", + "Zohar Nussinov", + "Alexander Seidel" + ], + "identifier": "https://doi.org/10.1103/physrevb.91.085115", + "metadata_source": "OpenAlex DOI resolution", + "title": "Zero modes, bosonization, and topological quantum order: The Laughlin state in second quantization", + "year": 2015 + }, + "section": "zero-mode algebra", + "title": "Zero modes, bosonization, and topological quantum order: The Laughlin state in second quantization", + "title_similarity": 1.0, + "verified": true, + "year": 2015 + }, + { + "arxiv": null, + "author_matches": { + "Kapit": true, + "Mueller": true + }, + "authors": [ + "Kapit", + "Mueller" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevLett.105.215303", + "key": "kapitmueller2010", + "observed": { + "authors": [ + "Eliot Kapit", + "Erich J. Mueller" + ], + "identifier": "https://doi.org/10.1103/physrevlett.105.215303", + "metadata_source": "OpenAlex DOI resolution", + "title": "Exact Parent Hamiltonian for the Quantum Hall States in a Lattice", + "year": 2010 + }, + "section": "lattice validation", + "title": "Exact parent Hamiltonian for the quantum Hall states in a lattice", + "title_similarity": 1.0, + "verified": true, + "year": 2010 + }, + { + "arxiv": null, + "author_matches": { + "Lee": true, + "Qi": true + }, + "authors": [ + "Lee", + "Qi" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevB.90.085103", + "key": "leeqi2014", + "observed": { + "authors": [ + "Ching Hua Lee", + "Xiao-Liang Qi" + ], + "identifier": "https://doi.org/10.1103/physrevb.90.085103", + "metadata_source": "OpenAlex DOI resolution", + "title": "Lattice construction of pseudopotential Hamiltonians for fractional Chern insulators", + "year": 2014 + }, + "section": "lattice pseudopotentials", + "title": "Lattice construction of pseudopotential Hamiltonians for fractional Chern insulators", + "title_similarity": 1.0, + "verified": true, + "year": 2014 + }, + { + "arxiv": null, + "author_matches": { + "Chamon": true, + "Mudry": true, + "Neupert": true, + "Santos": true + }, + "authors": [ + "Neupert", + "Santos", + "Chamon", + "Mudry" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevLett.106.236804", + "key": "neupert2011", + "observed": { + "authors": [ + "Titus Neupert", + "Luiz H. Santos", + "Claudio Chamon", + "Christopher Mudry" + ], + "identifier": "https://doi.org/10.1103/physrevlett.106.236804", + "metadata_source": "OpenAlex DOI resolution", + "title": "Fractional Quantum Hall States at Zero Magnetic Field", + "year": 2011 + }, + "section": "fractional Chern insulators", + "title": "Fractional quantum Hall states at zero magnetic field", + "title_similarity": 1.0, + "verified": true, + "year": 2011 + }, + { + "arxiv": null, + "author_matches": { + "Bravyi": true, + "Hastings": true, + "Michalakis": true + }, + "authors": [ + "Bravyi", + "Hastings", + "Michalakis" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1063/1.3490195", + "key": "bravyi2010", + "observed": { + "authors": [ + "Sergey Bravyi", + "Matthew B. Hastings", + "Spyridon Michalakis" + ], + "identifier": "https://doi.org/10.1063/1.3490195", + "metadata_source": "OpenAlex DOI resolution", + "title": "Topological quantum order: Stability under local perturbations", + "year": 2010 + }, + "section": "gapped-phase stability", + "title": "Topological quantum order: Stability under local perturbations", + "title_similarity": 1.0, + "verified": true, + "year": 2010 + }, + { + "arxiv": null, + "author_matches": { + "Bachmann": true, + "Michalakis": true, + "Nachtergaele": true, + "Sims": true + }, + "authors": [ + "Bachmann", + "Michalakis", + "Nachtergaele", + "Sims" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1007/s00220-011-1380-0", + "key": "bachmann2011", + "observed": { + "authors": [ + "Sven Bachmann", + "Spyridon Michalakis", + "Bruno Nachtergaele", + "Robert Sims" + ], + "identifier": "https://doi.org/10.1007/s00220-011-1380-0", + "metadata_source": "OpenAlex DOI resolution", + "title": "Automorphic Equivalence within Gapped Phases of Quantum Lattice Systems", + "year": 2011 + }, + "section": "gapped-phase transport", + "title": "Automorphic equivalence within gapped phases of quantum lattice systems", + "title_similarity": 1.0, + "verified": true, + "year": 2011 + }, + { + "arxiv": null, + "author_matches": { + "Cirac": true, + "David Perez": true, + "Schuch": true + }, + "authors": [ + "Schuch", + "David Perez", + "Cirac" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevB.84.165139", + "key": "schuch2011", + "observed": { + "authors": [ + "Norbert Schuch", + "David P\u00e9rez-Garc\u0131\u0301a", + "J. I. Cirac" + ], + "identifier": "https://doi.org/10.1103/physrevb.84.165139", + "metadata_source": "OpenAlex DOI resolution", + "title": "Classifying quantum phases using matrix product states and projected entangled pair states", + "year": 2011 + }, + "section": "phase classification", + "title": "Classifying quantum phases using matrix product states and projected entangled pair states", + "title_similarity": 1.0, + "verified": true, + "year": 2011 + }, + { + "arxiv": null, + "author_matches": { + "Hastings": true, + "Wen": true + }, + "authors": [ + "Hastings", + "Wen" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevB.72.045141", + "key": "hastingswen2005", + "observed": { + "authors": [ + "M. B. Hastings", + "Xiao-Gang Wen" + ], + "identifier": "https://doi.org/10.1103/physrevb.72.045141", + "metadata_source": "OpenAlex DOI resolution", + "title": "Quasiadiabatic continuation of quantum states: The stability of topological ground-state degeneracy and emergent gauge invariance", + "year": 2005 + }, + "section": "gapped-projector transport", + "title": "Quasiadiabatic continuation of quantum states: The stability of topological ground-state degeneracy and emergent gauge invariance", + "title_similarity": 1.0, + "verified": true, + "year": 2005 + }, + { + "arxiv": null, + "author_matches": { + "Collins": true + }, + "authors": [ + "Collins" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1007/s00440-005-0428-5", + "key": "collins2005", + "observed": { + "authors": [ + "Beno\u00eet Collins" + ], + "identifier": "https://doi.org/10.1007/s00440-005-0428-5", + "metadata_source": "OpenAlex DOI resolution", + "title": "Product of random projections, Jacobi ensembles and universality problems arising from free probability", + "year": 2005 + }, + "section": "Jacobi null model", + "title": "Product of random projections, Jacobi ensembles and universality problems arising from free probability", + "title_similarity": 1.0, + "verified": true, + "year": 2005 + }, + { + "arxiv": null, + "author_matches": { + "Sommers": true, + "Zyczkowski": true + }, + "authors": [ + "Zyczkowski", + "Sommers" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1088/0305-4470/33/10/307", + "key": "zyczkowski2000", + "observed": { + "authors": [ + "Karol Zyczkowski", + "Hans-J\u00fcrgen Sommers" + ], + "identifier": "https://doi.org/10.1088/0305-4470/33/10/307", + "metadata_source": "OpenAlex DOI resolution", + "title": "Truncations of random unitary matrices", + "year": 2000 + }, + "section": "Haar compressions", + "title": "Truncations of random unitary matrices", + "title_similarity": 1.0, + "verified": true, + "year": 2000 + }, + { + "arxiv": null, + "author_matches": { + "Atas": true, + "Bogomolny": true, + "Giraud": true, + "Roux": true + }, + "authors": [ + "Atas", + "Bogomolny", + "Giraud", + "Roux" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevLett.110.084101", + "key": "atas2013", + "observed": { + "authors": [ + "Y. Y. Atas", + "E. Bogomolny", + "Olivier Giraud", + "Guillaume Roux" + ], + "identifier": "https://doi.org/10.1103/physrevlett.110.084101", + "metadata_source": "OpenAlex DOI resolution", + "title": "Distribution of the Ratio of Consecutive Level Spacings in Random Matrix Ensembles", + "year": 2013 + }, + "section": "local spectral statistics", + "title": "Distribution of the ratio of consecutive level spacings in random matrix ensembles", + "title_similarity": 1.0, + "verified": true, + "year": 2013 + }, + { + "arxiv": null, + "author_matches": { + "Niu": true, + "Thouless": true, + "Wu": true + }, + "authors": [ + "Niu", + "Thouless", + "Wu" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevB.31.3372", + "key": "niuthoulesswu1985", + "observed": { + "authors": [ + "Qian Niu", + "D. J. Thouless", + "Yong-Shi Wu" + ], + "identifier": "https://doi.org/10.1103/physrevb.31.3372", + "metadata_source": "OpenAlex DOI resolution", + "title": "Quantized Hall conductance as a topological invariant", + "year": 1985 + }, + "section": "many-body topology", + "title": "Quantized Hall conductance as a topological invariant", + "title_similarity": 1.0, + "verified": true, + "year": 1985 + }, + { + "arxiv": null, + "author_matches": { + "Kolodrubetz": true, + "Mehta": true, + "Polkovnikov": true, + "Sels": true + }, + "authors": [ + "Kolodrubetz", + "Sels", + "Mehta", + "Polkovnikov" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1016/j.physrep.2017.07.001", + "key": "kolodrubetz2017", + "observed": { + "authors": [ + "Michael Kolodrubetz", + "Dries Sels", + "Pankaj Mehta", + "Anatoli Polkovnikov" + ], + "identifier": "https://doi.org/10.1016/j.physrep.2017.07.001", + "metadata_source": "OpenAlex DOI resolution", + "title": "Geometry and non-adiabatic response in quantum and classical systems", + "year": 2017 + }, + "section": "quantum geometric response", + "title": "Geometry and non-adiabatic response in quantum and classical systems", + "title_similarity": 1.0, + "verified": true, + "year": 2017 + }, + { + "arxiv": null, + "author_matches": { + "Bohigas": true, + "Giannoni": true, + "Schmit": true + }, + "authors": [ + "Bohigas", + "Giannoni", + "Schmit" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevLett.52.1", + "key": "bohigas1984", + "observed": { + "authors": [ + "O. Bohigas", + "M.J. Giannoni", + "C. Schmit" + ], + "identifier": "https://doi.org/10.1103/physrevlett.52.1", + "metadata_source": "OpenAlex DOI resolution", + "title": "Characterization of Chaotic Quantum Spectra and Universality of Level Fluctuation Laws", + "year": 1984 + }, + "section": "random-matrix quantum chaos", + "title": "Characterization of chaotic quantum spectra and universality of level fluctuation laws", + "title_similarity": 1.0, + "verified": true, + "year": 1984 + }, + { + "arxiv": null, + "author_matches": { + "Deutsch": true + }, + "authors": [ + "Deutsch" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevA.43.2046", + "key": "deutsch1991", + "observed": { + "authors": [ + "J. M. Deutsch" + ], + "identifier": "https://doi.org/10.1103/physreva.43.2046", + "metadata_source": "OpenAlex DOI resolution", + "title": "Quantum statistical mechanics in a closed system", + "year": 1991 + }, + "section": "eigenstate thermalization", + "title": "Quantum statistical mechanics in a closed system", + "title_similarity": 1.0, + "verified": true, + "year": 1991 + }, + { + "arxiv": null, + "author_matches": { + "Srednicki": true + }, + "authors": [ + "Srednicki" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevE.50.888", + "key": "srednicki1994", + "observed": { + "authors": [ + "Mark Srednicki" + ], + "identifier": "https://doi.org/10.1103/physreve.50.888", + "metadata_source": "OpenAlex DOI resolution", + "title": "Chaos and quantum thermalization", + "year": 1994 + }, + "section": "eigenstate thermalization", + "title": "Chaos and quantum thermalization", + "title_similarity": 1.0, + "verified": true, + "year": 1994 + }, + { + "arxiv": null, + "author_matches": { + "D'Alessio": true, + "Kafri": true, + "Polkovnikov": true, + "Rigol": true + }, + "authors": [ + "D'Alessio", + "Kafri", + "Polkovnikov", + "Rigol" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1080/00018732.2016.1198134", + "key": "dalessio2016", + "observed": { + "authors": [ + "Luca D'Alessio", + "Yariv Kafri", + "Anatoli Polkovnikov", + "Marcos Rigol" + ], + "identifier": "https://doi.org/10.1080/00018732.2016.1198134", + "metadata_source": "OpenAlex DOI resolution", + "title": "From quantum chaos and eigenstate thermalization to statistical mechanics and thermodynamics", + "year": 2016 + }, + "section": "ETH review", + "title": "From quantum chaos and eigenstate thermalization to statistical mechanics and thermodynamics", + "title_similarity": 1.0, + "verified": true, + "year": 2016 + }, + { + "arxiv": null, + "author_matches": { + "Foini": true, + "Kurchan": true + }, + "authors": [ + "Foini", + "Kurchan" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevE.99.042139", + "key": "foinikurchan2019", + "observed": { + "authors": [ + "Laura Foini", + "Jorge Kurchan" + ], + "identifier": "https://doi.org/10.1103/physreve.99.042139", + "metadata_source": "OpenAlex DOI resolution", + "title": "Eigenstate thermalization hypothesis and out of time order correlators", + "year": 2019 + }, + "section": "higher matrix-element correlations", + "title": "Eigenstate thermalization hypothesis and out of time order correlators", + "title_similarity": 1.0, + "verified": true, + "year": 2019 + }, + { + "arxiv": null, + "author_matches": { + "Foini": true, + "Kurchan": true, + "Pappalardi": true + }, + "authors": [ + "Pappalardi", + "Foini", + "Kurchan" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevLett.129.170603", + "key": "pappalardi2022", + "observed": { + "authors": [ + "Silvia Pappalardi", + "Laura Foini", + "Jorge Kurchan" + ], + "identifier": "https://doi.org/10.1103/physrevlett.129.170603", + "metadata_source": "OpenAlex DOI resolution", + "title": "Eigenstate Thermalization Hypothesis and Free Probability", + "year": 2022 + }, + "section": "full ETH and free cumulants", + "title": "Eigenstate Thermalization Hypothesis and Free Probability", + "title_similarity": 1.0, + "verified": true, + "year": 2022 + }, + { + "arxiv": null, + "author_matches": { + "Fukui": true, + "Hatsugai": true, + "Suzuki": true + }, + "authors": [ + "Fukui", + "Hatsugai", + "Suzuki" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1143/JPSJ.74.1674", + "key": "fukui2005", + "observed": { + "authors": [ + "Takahiro Fukui", + "Yasuhiro Hatsugai", + "Hiroshi Suzuki" + ], + "identifier": "https://doi.org/10.1143/jpsj.74.1674", + "metadata_source": "OpenAlex DOI resolution", + "title": "Chern Numbers in Discretized Brillouin Zone: Efficient Method of Computing (Spin) Hall Conductances", + "year": 2005 + }, + "section": "discrete Chern links", + "title": "Chern Numbers in Discretized Brillouin Zone: Efficient Method of Computing (Spin) Hall Conductances", + "title_similarity": 1.0, + "verified": true, + "year": 2005 + }, + { + "arxiv": null, + "author_matches": { + "Chen": true, + "Ludwig": true + }, + "authors": [ + "Chen", + "Ludwig" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevB.98.064309", + "key": "chenludwig2018", + "observed": { + "authors": [ + "Xiao Chen", + "Andreas W. W. Ludwig" + ], + "identifier": "https://doi.org/10.1103/physrevb.98.064309", + "metadata_source": "OpenAlex DOI resolution", + "title": "Universal spectral correlations in the chaotic wave function and the development of quantum chaos", + "year": 2018 + }, + "section": "non-energy spectral correlations", + "title": "Universal spectral correlations in the chaotic wave function, and the development of quantum chaos", + "title_similarity": 1.0, + "verified": true, + "year": 2018 + }, + { + "arxiv": null, + "author_matches": { + "Campbell": true, + "Claeys": true, + "Pandey": true, + "Polkovnikov": true, + "Sels": true + }, + "authors": [ + "Pandey", + "Claeys", + "Campbell", + "Polkovnikov", + "Sels" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": "10.1103/PhysRevX.10.041017", + "key": "pandey2020", + "observed": { + "authors": [ + "Mohit Pandey", + "Pieter W. Claeys", + "David Campbell", + "Anatoli Polkovnikov", + "Dries Sels" + ], + "identifier": "https://doi.org/10.1103/physrevx.10.041017", + "metadata_source": "OpenAlex DOI resolution", + "title": "Adiabatic Eigenstate Deformations as a Sensitive Probe for Quantum Chaos", + "year": 2020 + }, + "section": "adiabatic deformation chaos diagnostic", + "title": "Adiabatic eigenstate deformations as a sensitive probe for quantum chaos", + "title_similarity": 1.0, + "verified": true, + "year": 2020 + }, + { + "arxiv": "2411.11968", + "author_matches": { + "Gorsky": true, + "Gritsev": true, + "Polkovnikov": true, + "Sharipov": true, + "Tiutiakina": true + }, + "authors": [ + "Sharipov", + "Tiutiakina", + "Gorsky", + "Gritsev", + "Polkovnikov" + ], + "checks": { + "authors": true, + "identifier_in_bib": true, + "title": true, + "year": true + }, + "doi": null, + "key": "sharipov2024", + "observed": { + "authors": [ + "Rustem Sharipov", + "Anastasiia Tiutiakina", + "Alexander Gorsky", + "Vladimir Gritsev", + "Anatoli Polkovnikov" + ], + "identifier": "https://arxiv.org/abs/2411.11968", + "metadata_source": "arXiv Atom API", + "title": "Hilbert space geometry and quantum chaos", + "year": 2024 + }, + "section": "Hilbert-space geometry", + "title": "Hilbert space geometry and quantum chaos", + "title_similarity": 1.0, + "verified": true, + "year": 2024 + } + ], + "registered_records": 35, + "schema_version": 1, + "unregistered_bibliography_keys": [] +} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/covariance_model_v1.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/covariance_model_v1.json new file mode 100644 index 000000000..1c90f49b1 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/covariance_model_v1.json @@ -0,0 +1,108 @@ +{ + "schema_version": 1, + "version": "v1", + "generated_utc": "2026-07-28T08:35:01.334711+00:00", + "physical_source": "output/physical_ensemble_v1.npz", + "rank": 50, + "ambient_channel_dimension": 340, + "diagnostic_training_rows": 1024, + "validation_model_samples_per_floor": 500, + "haar_samples": 10000, + "deformed_samples": 10000, + "candidate_floors": [ + 0.002, + 0.005, + 0.01, + 0.02, + 0.05 + ], + "validation_scores": { + "0.002": { + "density_l1": 0.14054999999999995, + "gap_ratio_difference": 0.0001337885374536052, + "selection_score": 0.14061689426872676 + }, + "0.005": { + "density_l1": 0.14185, + "gap_ratio_difference": 0.0013064576588432963, + "selection_score": 0.14250322882942165 + }, + "0.01": { + "density_l1": 0.1407, + "gap_ratio_difference": 0.0011040805555783129, + "selection_score": 0.14125204027778915 + }, + "0.02": { + "density_l1": 0.13401999999999997, + "gap_ratio_difference": 0.0010018203538736392, + "selection_score": 0.1345209101769368 + }, + "0.05": { + "density_l1": 0.13036999999999999, + "gap_ratio_difference": 0.0032966862379868456, + "selection_score": 0.1320183431189934 + } + }, + "selected_floor": 0.05, + "training_geometry": { + "relative_frobenius_anisotropy": 0.8674296800010756, + "mean_participation_fraction": 0.6249384337585719, + "mean_absolute_polarization": 0.10582485400941818, + "mean_frame_overlap": 12.838378948780079, + "haar_frame_overlap": 7.352941176470588, + "mean_principal_angle": 1.090552974857078, + "entry_fourth_ratio": 3.3265653199216167 + }, + "held_out_test": { + "density_l1": { + "physical_vs_haar": 0.290988, + "physical_vs_deformed": 0.12372, + "relative_improvement": 0.5748278279516682 + }, + "mean_gap_ratio": { + "physical": 0.5998059753041982, + "haar": 0.5993947881902579, + "deformed": 0.5992000762838173, + "physical_deformed_absolute_difference": 0.0006058990203808845 + }, + "moments": { + "2": { + "physical": 0.21333728237401392, + "haar": 0.1470329624468636, + "deformed": 0.2288735165413742 + }, + "4": { + "physical": 0.08526589406637701, + "haar": 0.04006200648662462, + "deformed": 0.09085355137498939 + }, + "6": { + "physical": 0.04124804321462224, + "haar": 0.013230352490666987, + "deformed": 0.04258851856463834 + }, + "8": { + "physical": 0.021965666304063044, + "haar": 0.004816973570731376, + "deformed": 0.021708694165391427 + } + }, + "result_branch": "leading_covariance_capture" + }, + "checks": { + "train_validation_test_disjoint": true, + "covariance_fit_uses_requested_training_rows": true, + "all_candidate_floors_scored": true, + "selected_floor_is_registered": true, + "model_shapes_match": true, + "all_spectra_bounded": true, + "branch_registered": true + }, + "all_checks_pass": true, + "runtime_seconds": 76.13895270897774, + "environment": { + "python": "3.12.11", + "numpy": "2.3.5", + "platform": "macOS-15.6-arm64-arm-64bit" + } +} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_1_physical_law_v1.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_1_physical_law_v1.pdf new file mode 100644 index 000000000..d898137fb Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_1_physical_law_v1.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_1_physical_law_v1.png b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_1_physical_law_v1.png new file mode 100644 index 000000000..bcf7d1be2 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_1_physical_law_v1.png differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_1_spectral_silence_v2.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_1_spectral_silence_v2.pdf new file mode 100644 index 000000000..4c8d2d395 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_1_spectral_silence_v2.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_1_spectral_silence_v2.png b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_1_spectral_silence_v2.png new file mode 100644 index 000000000..276fa2003 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_1_spectral_silence_v2.png differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_2_falsification_triangle_v2.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_2_falsification_triangle_v2.pdf new file mode 100644 index 000000000..80c19edb0 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_2_falsification_triangle_v2.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_2_falsification_triangle_v2.png b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_2_falsification_triangle_v2.png new file mode 100644 index 000000000..0516c76b7 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_2_falsification_triangle_v2.png differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_2_scale_hierarchy_v1.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_2_scale_hierarchy_v1.pdf new file mode 100644 index 000000000..e8a1ea81a Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_2_scale_hierarchy_v1.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_2_scale_hierarchy_v1.png b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_2_scale_hierarchy_v1.png new file mode 100644 index 000000000..6e1599ec7 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_2_scale_hierarchy_v1.png differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_3_atom_crossover_v1.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_3_atom_crossover_v1.pdf new file mode 100644 index 000000000..173e56f14 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_3_atom_crossover_v1.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_3_atom_crossover_v1.png b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_3_atom_crossover_v1.png new file mode 100644 index 000000000..04799fc17 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_3_atom_crossover_v1.png differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_3_independent_channels_v2.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_3_independent_channels_v2.pdf new file mode 100644 index 000000000..5287ee30e Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_3_independent_channels_v2.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_3_independent_channels_v2.png b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_3_independent_channels_v2.png new file mode 100644 index 000000000..f1008c81e Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_3_independent_channels_v2.png differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_4_finite_size_v1.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_4_finite_size_v1.pdf new file mode 100644 index 000000000..5436e997d Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_4_finite_size_v1.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_4_finite_size_v1.png b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_4_finite_size_v1.png new file mode 100644 index 000000000..24545c68d Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_4_finite_size_v1.png differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_4_geometric_hierarchy_v2.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_4_geometric_hierarchy_v2.pdf new file mode 100644 index 000000000..5ed7caa28 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_4_geometric_hierarchy_v2.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_4_geometric_hierarchy_v2.png b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_4_geometric_hierarchy_v2.png new file mode 100644 index 000000000..f8274c7a3 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_4_geometric_hierarchy_v2.png differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_5_covariance_mechanism_v1.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_5_covariance_mechanism_v1.pdf new file mode 100644 index 000000000..0089e74e4 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_5_covariance_mechanism_v1.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_5_covariance_mechanism_v1.png b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_5_covariance_mechanism_v1.png new file mode 100644 index 000000000..015a2f201 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_5_covariance_mechanism_v1.png differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_5_jacobi_atoms_v2.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_5_jacobi_atoms_v2.pdf new file mode 100644 index 000000000..348c1b853 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_5_jacobi_atoms_v2.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_5_jacobi_atoms_v2.png b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_5_jacobi_atoms_v2.png new file mode 100644 index 000000000..6214928c8 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_5_jacobi_atoms_v2.png differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_6_wick_factorization_v3.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_6_wick_factorization_v3.pdf new file mode 100644 index 000000000..1bc7ae8c2 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_6_wick_factorization_v3.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_6_wick_factorization_v3.png b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_6_wick_factorization_v3.png new file mode 100644 index 000000000..54f4749a3 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_6_wick_factorization_v3.png differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_7_topological_holonomy_v3.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_7_topological_holonomy_v3.pdf new file mode 100644 index 000000000..7915b1e9a Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_7_topological_holonomy_v3.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_7_topological_holonomy_v3.png b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_7_topological_holonomy_v3.png new file mode 100644 index 000000000..b025ce222 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_7_topological_holonomy_v3.png differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_manifest_v1.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_manifest_v1.json new file mode 100644 index 000000000..f3fb47d37 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_manifest_v1.json @@ -0,0 +1,67 @@ +{ + "schema_version": 1, + "version": "v1", + "figure_width_inches": 7.0, + "png_dpi": 300, + "inputs": { + "output/physical_ensemble_v1.json": "f0f0c97483f66800b8da208fd3dad7259fc30a7650b7360060499f9326ad4000", + "output/covariance_model_v1.json": "7183934946be50deb9973755dc189360b9f8aaabcdbd7107860980b15ae859a0", + "output/covariance_model_v1.npz": "7581adc06ceeb6afb3d5bb5f58f1ca91a1ae9398e45dc09869751989f86a4836", + "output/rank_scaling_v1.json": "46be556194eac79ff29017c9b969146e32b6e0a08a1407a6cfe4e2a924cf77e7", + "output/rank_scaling_v1.npz": "0373a6b0ddef31ea0208f0acc3d6feee0bda372058eb2a0d689b0eed92cd4338", + "output/statistical_analysis_v1.json": "5f18f62a9ad65f21ee5474c74454c0e39e800e584e391c2545484e4d961f709d", + "output/statistical_analysis_v1.npz": "0146d0c1680cd31095ab568906e25d8c0504b53a398b80b87009a54031baf063" + }, + "figures": { + "figure_1": { + "pdf": "output/figure_1_physical_law_v1.pdf", + "png": "output/figure_1_physical_law_v1.png", + "width_inches": 7.0, + "png_width_pixels": 2100, + "dpi": 300, + "pdf_sha256": "350b914657fcabac8d3d67b0eb1b3109688805ca975e6b555a34a986105343ae", + "png_sha256": "81a9ef1ad11470cb715589c079a8041dbe785fe74b11309812a50ddbb2387da3" + }, + "figure_2": { + "pdf": "output/figure_2_scale_hierarchy_v1.pdf", + "png": "output/figure_2_scale_hierarchy_v1.png", + "width_inches": 7.0, + "png_width_pixels": 2100, + "dpi": 300, + "pdf_sha256": "37bc3317c79119b384b7925e423ade7ba5657c371e050235e33ca4e51f78a39d", + "png_sha256": "4bff81589676c1c7f583c88d2373ea883b28f4fd9059206c56d45d26f85104ef" + }, + "figure_3": { + "pdf": "output/figure_3_atom_crossover_v1.pdf", + "png": "output/figure_3_atom_crossover_v1.png", + "width_inches": 7.0, + "png_width_pixels": 2100, + "dpi": 300, + "pdf_sha256": "9a85f844a9c8d99148afc126e09081ece9ed831b59b71bcecb2162396eb61593", + "png_sha256": "ee8eb2408ee641e2c2d0cbaf5f9afa068284c7a38180b65c913b42e7a81ab406" + }, + "figure_4": { + "pdf": "output/figure_4_finite_size_v1.pdf", + "png": "output/figure_4_finite_size_v1.png", + "width_inches": 7.0, + "png_width_pixels": 2100, + "dpi": 300, + "pdf_sha256": "60a7ca479c14db4beb351788eaef4aece94418d7433f327d45e7d7f4d313a293", + "png_sha256": "e277868a30987ad70318a61722990b355bd5558e284ca6c55e2febed3cded08d" + }, + "figure_5": { + "pdf": "output/figure_5_covariance_mechanism_v1.pdf", + "png": "output/figure_5_covariance_mechanism_v1.png", + "width_inches": 7.0, + "png_width_pixels": 2100, + "dpi": 300, + "pdf_sha256": "039718bd9db982bb702dba14dcd8000834f259bc316c72640353619ae7eec36d", + "png_sha256": "5a03ea042d7fcf9501e44d2e591b9c03a1b31b51f73c32cd57fd48edf83abb45" + } + }, + "atom_annotations": { + "D546_each_boundary": 6, + "D800_each_boundary": 120, + "D800_total_weight": 0.3 + } +} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_manifest_v2.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_manifest_v2.json new file mode 100644 index 000000000..612ec73c9 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_manifest_v2.json @@ -0,0 +1,77 @@ +{ + "schema_version": 2, + "version": "v2", + "inputs": { + "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/spectral_silence_v2.json": "5a2da65d83ded56a0fbebb23f69d5c26bd41382ebaa5f32a333fb239bffd5778", + "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/spectral_silence_v2.npz": "f85e2fe87b8a21aa8b0961e962c84557276020d80bc7a06cfab5464da187bcd9", + "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/spectral_silence_statistics_v2.json": "2808020357176fa6f60d0280c509e2dea18b8d472c8a9090f8b6f619a1dfe706", + "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/spectral_silence_statistics_v2.npz": "ef2bf7bdfea65e595def17d8b08ac0786a86afeb4e57aea71c7472504b7c773e" + }, + "figures": { + "figure_1": { + "pdf": "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/figure_1_spectral_silence_v2.pdf", + "png": "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/figure_1_spectral_silence_v2.png", + "pdf_sha256": "b3c5967fb225d6a3adaa52adff34017bec1034111fa9cc669d33af661aa70d8a", + "png_sha256": "5c02927662ca4b2b1c7a9a072873ac49c76f02df7d06537fdac4cf3f34c35167", + "width_inches": 7.0, + "png_width_pixels": 2100, + "dpi": 300 + }, + "figure_2": { + "pdf": "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/figure_2_falsification_triangle_v2.pdf", + "png": "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/figure_2_falsification_triangle_v2.png", + "pdf_sha256": "3a573402c85fb6c39dfd3439f468a5c9a5369bbd8379b23fdd6cec68c1b31658", + "png_sha256": "8227f7fee24eeb038a1f85bd2cc27b6be8c7221d402d3ff92a81029041a64dbf", + "width_inches": 7.0, + "png_width_pixels": 2100, + "dpi": 300 + }, + "figure_3": { + "pdf": "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/figure_3_independent_channels_v2.pdf", + "png": "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/figure_3_independent_channels_v2.png", + "pdf_sha256": "28bad44f157c0fdc418d9c56ba218e245890d6e3bea327bcd8ff5f0dfa145d95", + "png_sha256": "c1d14697b983bf1fb18c3e21a37a8f3bb564a35ff3a155ee749410b2c85a62b8", + "width_inches": 7.0, + "png_width_pixels": 2100, + "dpi": 300 + }, + "figure_4": { + "pdf": "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/figure_4_geometric_hierarchy_v2.pdf", + "png": "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/figure_4_geometric_hierarchy_v2.png", + "pdf_sha256": "56367dc2c3d2cd1c9d9c5af0e5b6a1b62bb635c8d9115dffb71d2f633b5aeef2", + "png_sha256": "c6dec6fe962dedc72aa75134883791bc72b0c9dda2ee8eed9bcc29edbb4a0f99", + "width_inches": 7.0, + "png_width_pixels": 2100, + "dpi": 300 + }, + "figure_5": { + "pdf": "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/figure_5_jacobi_atoms_v2.pdf", + "png": "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/figure_5_jacobi_atoms_v2.png", + "pdf_sha256": "80f9a9ed0073ca4bc2253417ccba816875469a6bfef5c3217353c77eaa7bc1f8", + "png_sha256": "d96c8889f31c2dd9a31de8706d18f19fc6e1f8ad9847782da12ed3523d1fb278", + "width_inches": 7.0, + "png_width_pixels": 2100, + "dpi": 300 + } + }, + "generated_tex": { + "numbers": "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/generated_numbers_v2.tex", + "tables": "/Users/thomasjwang/Documents/GitHub/Chaos-of-Quantum-Geometry/01_task_folder/task_05/script/output/generated_tables_v2.tex" + }, + "scientific_annotations": { + "energy_raw": 50.0, + "energy_connected": 0.0, + "local_g": 0.2, + "ramp_g": 0.4, + "number_extent": 1.0, + "D800_atom_each": 120, + "D800_connected_plateau": 0.7 + }, + "checks": { + "source_artifacts_pass": true, + "five_figures_generated": true, + "all_pdf_png_pairs_exist": true, + "registered_annotations_exact": true + }, + "all_checks_pass": true +} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_manifest_v3.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_manifest_v3.json new file mode 100644 index 000000000..264f9ee97 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_manifest_v3.json @@ -0,0 +1,42 @@ +{ + "figure_6_wick_factorization_v3": { + "panels": [ + "genuine_manybody_sequence", + "four_channel_residual", + "non_gaussian_excess", + "covariance_geometry" + ], + "pdf": "output/figure_6_wick_factorization_v3.pdf", + "pdf_sha256": "57efed4dfd0fb77858c52980e50c468d064300505dcdfb0a635ce47f89ce0c1e", + "png": "output/figure_6_wick_factorization_v3.png", + "png_sha256": "7cf914a353f9849b86299669c99577c16c9994d7d7814c6dad2e2537698035ce", + "png_width_pixels": 2100, + "result_branch": "deformed_geometric_eth", + "source": "output/matrix_element_geometric_eth_v3.json", + "source_sha256": "bbacad6f795559f417c1e39c034a6fe51669fd509a983099c10965fb68ee34a3", + "width_inches": 7.0 + }, + "figure_7_topological_holonomy_v3": { + "checkpoint_hashes": { + "output/topology_v3_checkpoints/N4_mesh16_twist_bundle_v3.json": "cba044e2b0171b4fc59a4226d59ed21e6cdb828e89d9fd6f95c5ee7fc83a9129", + "output/topology_v3_checkpoints/N4_mesh16_twist_bundle_v3.npz": "1fba58f6126a2f9a52d08c175871c52a912e6cdcc409d67aafe2c3a7ac02b46d" + }, + "panels": [ + "fixed_chern_and_gap", + "determinant_winding", + "wilson_gap_ratio", + "wilson_form_factor" + ], + "pdf": "output/figure_7_topological_holonomy_v3.pdf", + "pdf_sha256": "11e101309d975a61a3efedb1025c2552149c7f1a6f72433594f4adb1c0a16258", + "png": "output/figure_7_topological_holonomy_v3.png", + "png_sha256": "4c19bc37413ea4cdbece1ef84023b505d3d279264e2107601907cb72d2d731ff", + "png_width_pixels": 2100, + "result_branch": "fixed_chern_deformed_holonomy", + "source_json": "output/topological_holonomy_v3.json", + "source_json_sha256": "ff15e7cd2f947b43da5a5973bb82c50319b164877883d187c7c46b2a073823c6", + "source_npz": "output/topological_holonomy_v3.npz", + "source_npz_sha256": "f459fa37facf82c6f67c44f4961749095fb0817516ff16d6ca6814bbaf952208", + "width_inches": 7.0 + } +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.json new file mode 100644 index 000000000..7cf88f031 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.json @@ -0,0 +1,3269 @@ +{ + "caption": "Hodge-resolved response-complex test across generic cubic supersymmetric cohomology: safe two-point charge structure, complete-realization pilot inference, and sealed held-out verdict.", + "checks": { + "complete_heldout_pair": true, + "complete_pilot_grid": true, + "figure_outputs_exist": true, + "known_selected_branch": true, + "source_backed_report_exists": true + }, + "inputs": { + "susy_hodge_v7_N14_inference.json": "177643e07fc6cf210362fc1077070bd1f0ba316b6805042a626de3f96c55a627", + "susy_hodge_v7_outcomes_pilot_combined.json": "152084fc502e38074ed0d8163f8582c01b9e5de46c12a53d2ced4994d1a74617" + }, + "outputs": { + "figure_susy_hodge_geometric_eth_v7.pdf": "f081c5f162778e5e45a48adba1ea08c37e8521c725725922a0ec3a35bda74a54", + "figure_susy_hodge_geometric_eth_v7.png": "252c337189afb6f0adea8142573e2e459a41e7226932e5954711ff0c7f5eb341", + "susy_hodge_geometric_eth_report_v7.md": "a085aedfbb2ce48ff26804d8be02334dac8447ff3d899056285db2eab8930cdf" + }, + "passed": true, + "pilot_group_count": 12, + "plotted_values": { + "heldout_primary_pair": [ + { + "N": 14, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11178894327406741, + 0.11182073355743845, + 0.11185243656607288 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.11234396147287215, + 0.11242666326099385, + 0.11251284962232763 + ], + "observed_median": 0.3015287195325017, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.2915274750468075, + 0.3120611443736316 + ], + "realizations": 24, + "robust_outside_both": true, + "sector": "adjacent" + }, + { + "N": 14, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.1113377289462959, + 0.11134480106449174, + 0.11135301768590472 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.11133252105193724, + 0.11133957071189352, + 0.11134819894894332 + ], + "observed_median": 0.3749925716126603, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3689804933327322, + 0.38047305142967947 + ], + "realizations": 24, + "robust_outside_both": true, + "sector": "central" + } + ], + "pilot_groups": [ + { + "N": 8, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.28774443822769635, + 0.2923719696932815, + 0.29747553580253777 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.3059263591384163, + 0.312032433068657, + 0.31831694112765746 + ], + "median_hodge_balance": 0.07040982426906839, + "null_banks": [ + { + "arrays_sha256": "7e4e820c450f1e3921d889e56fd5dd8f1cc0b85efebb0e01082f72896eadd975", + "metadata_sha256": "3dfd016bb6cffc1bb3cea44405bd5280344c764350ac059703b2cd7af9449afc", + "realization": 0 + }, + { + "arrays_sha256": "5f2b5ee2045d7e634ea2eb75be49f59d044c694db0d31dd96b554075d16baf64", + "metadata_sha256": "426b5d1187b3c2609ffc029b233659fa5d7f51dbceb53049b1411582ce42a2c7", + "realization": 1 + }, + { + "arrays_sha256": "e821d455d25eeb8440515614400268c3f0091781c64cc042d2447b8056df6259", + "metadata_sha256": "b2ecdc748cb7bafdf6ae3709e2a4a32fc1db34ed18e5074f5a9d103d7131f2b0", + "realization": 2 + }, + { + "arrays_sha256": "a7a8d2092c29178d35912a48018e334d1d8e025a24288af6ba3a3e2ce65eaec2", + "metadata_sha256": "3206a8d888f29b824c67418a84a5c7b7dd7c2d2318c431a9eb358fbe52609375", + "realization": 3 + }, + { + "arrays_sha256": "8eebc9f3ff729229002bbff88eb1599faae9681fd7aec883a3c73e0559a2a826", + "metadata_sha256": "728581e912fe0ee4cbdf3066fdd0dc6160bdbb82dbf258e515e0d11e28d73fd8", + "realization": 4 + }, + { + "arrays_sha256": "c613197503272fc266f8aea0f6746f3a16c0e9c4845ba71c91f5e4d9df165997", + "metadata_sha256": "16357f2902cfb4cacaa672f9bec6c8882756684d39de8ec27ee3f0739abdd840", + "realization": 5 + }, + { + "arrays_sha256": "584c834366b823aee9effb07a037b555f39fe7efc3a24bda79004f52557d8c4b", + "metadata_sha256": "8f3bacf052da6950912eb5ebc5776e397806bdcb25928e68e8774c94d1465592", + "realization": 6 + }, + { + "arrays_sha256": "71a95506502428f05bdbd1fed08f5bace55dac555c8975f99f53ea65f0bd2e87", + "metadata_sha256": "9e05a0d39b40afca583d4950bd7fc0df1cbdc15b38406ad50e28fb2846b21a3b", + "realization": 7 + }, + { + "arrays_sha256": "85c77b070a9c54276bc752de236c1c658f3f999cd1b92f0ecc53f0a8649ea71b", + "metadata_sha256": "3dce74e5717170ecad93c4de0e68a4454cb19be3df4706c8ea024a4241faaba6", + "realization": 8 + }, + { + "arrays_sha256": "a9b039b58718984c9643c6984dd524ebc9bbedcaa82140b530ae5f698f755b36", + "metadata_sha256": "0e4f603d7eee9972673ae54f75878e0534dfe5defac2f785ff60de1648baa301", + "realization": 9 + }, + { + "arrays_sha256": "90e82fda00d060444958a4b38f7fa5b2728e91e7b4fffbc69aca75f50ad852fc", + "metadata_sha256": "574932aeb9b422627ba393a783a7fb8924128448d0d1ac51302e1900c60df1ba", + "realization": 10 + }, + { + "arrays_sha256": "95b821b9a32ae48211a34b3b8819e6c0758a041f7a6cbb471148d0fabebdaa2b", + "metadata_sha256": "217223c8912f1bbe708dadb2e0a12ba9fa5e6b36e3a6bd583d4f864bf0c41637", + "realization": 11 + }, + { + "arrays_sha256": "f182e61e5d9880bdfe13b1e7b148ddebf13bf12e00e018798fe85fda84f00490", + "metadata_sha256": "2c9453e6cbeb420dc8a6cf80a7bcb33221f23a7594610310369a79a30c358e1a", + "realization": 12 + }, + { + "arrays_sha256": "d9634ea5aa3830b539c122ffc2024ceb09ec73398d23f785baae66b001b66fcb", + "metadata_sha256": "ba0d05489fc8d01eed51fc4c1eecd10ac981e9df32b9080cd80cc4578ac2edff", + "realization": 13 + }, + { + "arrays_sha256": "85e233efd41b6223f3988f25135d922407ad1f0c288f2bef39b718f1d529e35f", + "metadata_sha256": "5b1ce1bd4f1e6fbab140cec48b0b62bc2f914b10b4ccd43efdef40181eb4b469", + "realization": 14 + }, + { + "arrays_sha256": "e4289b64b3dce047b9fd985f6adcdc0a3e3252f7ff3b8281da3d939092b94900", + "metadata_sha256": "cac306e55cc899f1bf75bc99ccf1c649e342b09c325229724acae01529109365", + "realization": 15 + }, + { + "arrays_sha256": "a63b9e21218662bebf0c4d088c4b2c839e6bfd28fe3bbc0261f6d01fd5006249", + "metadata_sha256": "744076addebecf804a815872fc7e81114ad6a9d71ca6f28a81c111e8d3788ef7", + "realization": 16 + }, + { + "arrays_sha256": "b66785aa3497256bb2cea0b6a986c3bca2fa26266184862c65f90112421a555c", + "metadata_sha256": "5bf89be8cd9fd3f57a2618cc003767bb31981e2f968b6ca07e529643b6ec5b36", + "realization": 17 + }, + { + "arrays_sha256": "11e79fc31c5cc3e182f8ef0f562a2c87ccf634d12a1db3076bac07470d44dcb1", + "metadata_sha256": "9e739c2f1ed1871341c81027a95e84a55be69b335b8a7b140a0419cfcf409c7d", + "realization": 18 + }, + { + "arrays_sha256": "d97a9e0429300a547d19779538fd414a0e9d2c2d5bfdaa67cb1b3ca5cb2a6b33", + "metadata_sha256": "6fe0176819c9e58364ef790a9eae7e6611961f7bfcef945880306110dd915f65", + "realization": 19 + }, + { + "arrays_sha256": "ea18c6209433f98d01e626e32adb32e7f3746ead049030007824f8354f678ba5", + "metadata_sha256": "aed9b8af87dac7d5a7a957998217221d289301db393cccdbca049f515bb0d80e", + "realization": 20 + }, + { + "arrays_sha256": "dce799fb13a12d2b60416f3ab8cbae52488cbaeb416c3d66a81d394eb1ebc824", + "metadata_sha256": "db22fcb0c7126ef751ffca375878c37f5fdf4885e3e2c62f4b2c01b50cf9cd3c", + "realization": 21 + }, + { + "arrays_sha256": "7f139c15fecfd3bd6aef20c2dac7990b820632f4746dd896582be8ddef362150", + "metadata_sha256": "85b3979fb070e3c863d83fb7fd6d2a37d342a1f26e70c6e09da64eab06496d6f", + "realization": 22 + }, + { + "arrays_sha256": "e4a16f1648a879ea59b7cd2d115741020af65ebcbc8ebf27af067ff935a3a25e", + "metadata_sha256": "3201185d7b672b7e48ce3eae311a5236305d989e99b6ee377ebad0f474f91270", + "realization": 23 + }, + { + "arrays_sha256": "b33c0d85db8c3dfdcf3abbfe84699e963fd790b9108b8488790c7cc18e95dc12", + "metadata_sha256": "29a56b3311a1f6afa2af8b5b9d69aa752523c44103d9a6652b0ed4e033b4282c", + "realization": 24 + }, + { + "arrays_sha256": "69eaf9db38244cbab7e0a89673366293c994f5c8bdeeee19927d6d3e5d8c5535", + "metadata_sha256": "1714c7aa1d0d396fce816046490428fca0685ff2bce1a98558195430dded6c97", + "realization": 25 + }, + { + "arrays_sha256": "99c7786255d17f345a12fed9a1bc5e14f9fef6038df201c4d6b45b6bc3c026c0", + "metadata_sha256": "8d815aaccdec229e70760c18f4dee8a588faf9b6607b6a865cdedbc2e936ef3a", + "realization": 26 + }, + { + "arrays_sha256": "1a0ac3542fa92251ff91ea6d34b14feb35b747aa9bda371a5e70acde9aaf422b", + "metadata_sha256": "8c5c71f09ed0e9515336909c215494c03cc31c4bb93364fe5f2f980bc59743a2", + "realization": 27 + }, + { + "arrays_sha256": "7ca331246d1467e2c96f4097f5ffe5d72d2960e6e25c4a19dc56c9e9d0bd6868", + "metadata_sha256": "c93aed73436e1fc63abcf3ada6bc560fa2b424a83fedd38333198e5419f117bd", + "realization": 28 + }, + { + "arrays_sha256": "4863b7c2f3e14f69b89b42cd8cc2c1f1fe9c59f3a8b70ea9c38245277cbd881a", + "metadata_sha256": "2262f4eb6f11bf168573f431e63f5c9f508b1a05002f60a8bae31bf994f41383", + "realization": 29 + }, + { + "arrays_sha256": "415755781cb1e33e7765b8ea14cd908c4d7beca78546123e66b0c04e1953c20d", + "metadata_sha256": "f28edfd549d07cf345b7e14cc4d213776cdaaf53d1d30679f938611c0bb35ce6", + "realization": 30 + }, + { + "arrays_sha256": "a3750fd2d886546440304c53b32133fde8d98a063935cbd6e235d34d58284ae8", + "metadata_sha256": "b14943201c15195b67b2bafefee856ab80fd1ffe1356d97792056818b85ebf5c", + "realization": 31 + }, + { + "arrays_sha256": "d02260472d42a4842285518d8e1c98c576c0b1463ebad8c4b215da7332450566", + "metadata_sha256": "46970f4a17ccd61a3b30029bdd6f96e2b5dbd806f17d7c14abc80d2996ca7c1a", + "realization": 32 + }, + { + "arrays_sha256": "81ff3b0e0317c3bbef179366f3349b5c1244b5b2a2082a3a7d0b62ea5195666c", + "metadata_sha256": "411acdf5488a70841b15c5e89dee4c7c3b2c2592b8a5a78cc5f89703fd5bd547", + "realization": 33 + }, + { + "arrays_sha256": "d081b259e270deddfec2893fd445246d6a0664f9da9bbdecb8496867d30ff8f7", + "metadata_sha256": "eb281ffe125c7ae297d34e8892686e788c10cc5626d42d8566b02dfd8a499658", + "realization": 34 + }, + { + "arrays_sha256": "fe7caf952a54586ad05bca871603d0d73281ec9ed7d7d87854d92a87ec0641a4", + "metadata_sha256": "f94011e8d522a44a8bf42e8a38c92efe8102a5ea01ba84b5f4a2d37e7853a13e", + "realization": 35 + }, + { + "arrays_sha256": "2166c1c4df9f59ed10da26646934950916dff33df3e780103e2701cb5d88d619", + "metadata_sha256": "305b266fd5ce59d2fe2f204db5fa402211862ac10b5c0c6482112f61e6c111cb", + "realization": 36 + }, + { + "arrays_sha256": "ef1ac6691de4fd6cb8e48a888e60d68e01125e554bc24f22e100e89e04b6a08f", + "metadata_sha256": "246e59a96bd94cb8ba7c3dd19ea8c3d57e0392f24145d7b99088762e0ae59301", + "realization": 37 + }, + { + "arrays_sha256": "fdf76204d2d7f24750a9fef68c19e4a56a5754b97dd0586a6fdb3aa11209488c", + "metadata_sha256": "59cae7517ada9bfeb4a2f20f20560e9eaf41dcfbc8d228090cbb4a2df9211fbd", + "realization": 38 + }, + { + "arrays_sha256": "f73e711baec36161053aecf09d3a427c3180bd8c28d6aa81eaa466d866c7aa68", + "metadata_sha256": "5a85797032a5e103652761faef137c1567f74aff1a8efb394c08a043916b5a02", + "realization": 39 + }, + { + "arrays_sha256": "9ef7f26b96c37b046e48911784430b468b31f2c1e5c07f7d54c30efc572141c7", + "metadata_sha256": "3d6aec77022cf4a9d9e2949973e2883dfb0bf0a10ac855efa7ca9db6fd049318", + "realization": 40 + }, + { + "arrays_sha256": "4b34e6df5d11668e4f57bf92290d53f537978023ccf8f7fbc1f19798d5e952b0", + "metadata_sha256": "4d3cff581ee92d10c2686166a66ee7c6ed8f5d301b0ab2db1e21b484112019e0", + "realization": 41 + }, + { + "arrays_sha256": "f0ab0be182f4e781204bd2b458e07b76db9754719ddaf4cf3955b22b6c2511c9", + "metadata_sha256": "d317a01ab9e55a558685feb6257548d668ff19d87bf7103ad2f65b00e120b4b8", + "realization": 42 + }, + { + "arrays_sha256": "221b995bf5de99c432d7846a34e9850f17e9506e01bd67e7a451c218114f4e27", + "metadata_sha256": "d7de9f96ebe541888c47333d513a9a67e1d7e34e807734574df294c68246f92e", + "realization": 43 + }, + { + "arrays_sha256": "c4221bacaed1027386e3acdbaa64e01130af7c2fcad5751167760d3835698569", + "metadata_sha256": "d45d62a5818b7d58e51f7208ad437731e39a33cf70c044e344b31c53bf303558", + "realization": 44 + }, + { + "arrays_sha256": "3a3fafe51d483d7e40202a2dfc1b460f340bed00ec9a9d9d9c400835179ad1c8", + "metadata_sha256": "a326da978a071e34046484e268cabb488ca18f8969246b748971520050cba300", + "realization": 45 + }, + { + "arrays_sha256": "cab548f23cb10decca232fae69b30a41403b925e8a4c444fddce5bb69c711818", + "metadata_sha256": "99aa1416434f28cbc606b0048e495a80788435e87927e8d812f9db55c26689a5", + "realization": 46 + }, + { + "arrays_sha256": "b7fcc506e264de69b2ad4b9a74bc3b1385c04650099eda48f4a5639d8562f4fd", + "metadata_sha256": "a842c741f0121fde7462cae5bf009b388cdb4e7156257c6d82cec863671df4fc", + "realization": 47 + }, + { + "arrays_sha256": "51253eab4bed3429e76c4e9ee66d1d6468ffb1d562121511f7bc30db76f7e2e4", + "metadata_sha256": "3e23a7e3ad54c83a17abcb6124210f1ec9781ce83e3872db68de32cb337380f4", + "realization": 48 + }, + { + "arrays_sha256": "3daff8369b98eb6fd41cde8dc3b215120335a180a61e2b79248387a650e3cf01", + "metadata_sha256": "8047d6dddc4a9ac99a247c9898d573650d37256efd8e83213549aa952ab3700a", + "realization": 49 + }, + { + "arrays_sha256": "aa704cd81fddfa33539ec459f4fdea4a0582708f77c78f6543b4e599a1fb611b", + "metadata_sha256": "2b748867ac598bc7389fa696c1739ac6d24f7250861cd0efa2ab1dad1faed673", + "realization": 50 + }, + { + "arrays_sha256": "e8560a879d50cc5b66a80eacfde868b7000e220494a1dc553f5f5c88974d7605", + "metadata_sha256": "cbd0ab6f3732bbb36f7304f235f204f0046b6a18c190a468587be3b4e4a8e37f", + "realization": 51 + }, + { + "arrays_sha256": "cada546af06194ccddaa2142fd30c1d14329661c3bda7aa3404840ea46e5537b", + "metadata_sha256": "0e8dec3026aaec22885686ae085e8a1a8bcd0748c082980e5681d88d19f235c6", + "realization": 52 + }, + { + "arrays_sha256": "df6001e2388006de4aacbf7f32756703d75148aadda915402e96593003bbadfe", + "metadata_sha256": "da5584cbdc11b39ef50f8d0ebbc7bec11cd29cd49c69808dd69076ca56944469", + "realization": 53 + }, + { + "arrays_sha256": "25d9143238813a04dbd6b7d7c9ee342b45b51396232506b2ddf0ab5a83530e77", + "metadata_sha256": "e199dc888ea7b2de2fdbc5c77b18e75fd57f0baace859d05467a01c5885e66be", + "realization": 54 + }, + { + "arrays_sha256": "34fecbd9e49b031a2b65ddea5df32c8d71cff5aff67ddd276f188cb6db1f7209", + "metadata_sha256": "b63c590a9d8f2d1f6ebdb8e61bb2442957cb9dbae5c8ca5ef1dfc979db8a6a45", + "realization": 55 + }, + { + "arrays_sha256": "fd50eee8d0f350f485ca0db54f3cd3a9cbd5e1ca732b5834c5412e8bd35dd93d", + "metadata_sha256": "36a333cce5f66ca8dbc8a63e605984c180decc4afe1663b8f3f2d5fa169dca38", + "realization": 56 + }, + { + "arrays_sha256": "e715721223022dc3f2ab7f1d23a1f72b288e4bc522442d0e60fd60fdc5e64e61", + "metadata_sha256": "0fd84230852654f9dd0ddf0cf48ca2b15e10fdb7b7c3f5490bf0549af3e850a6", + "realization": 57 + }, + { + "arrays_sha256": "0a942be9b78844be357d2fb991b7e5ed179137a1163e5529c0606e6f32cd136f", + "metadata_sha256": "52852b5de3339bd8c87aa38f4f06c36e0bc3c2e4a46bd1f9c6b5ea70887c937e", + "realization": 58 + }, + { + "arrays_sha256": "6150f9dfbe18411bb31643e60184a91df5f3df4ac00c693b9cb085957696fd01", + "metadata_sha256": "0480543c0f755af003017ae43b9a9ed13704be65511a22b572ef833e49785107", + "realization": 59 + }, + { + "arrays_sha256": "754135a046b184931081182a8fd0dda67a61a0378621372d6b960d682910ba1c", + "metadata_sha256": "984d2758dd685732330d632f32d08cec2861a32abbc4d09e5bef6ac6af7f302a", + "realization": 60 + }, + { + "arrays_sha256": "a344747a67f2f0e6d54f6b94e94ecea6db7b9e5a12c384f618ac5ea7c29e9aac", + "metadata_sha256": "9565a1766c17b1daa4f63f5c831e7d4881d93119824c342711ee83a6752ca797", + "realization": 61 + }, + { + "arrays_sha256": "515a473de52604c2933aeb366b8fafc1579882b73e8636df2aeba9c89491d03c", + "metadata_sha256": "97b75282143c51c703db365b08703b5858be2c7cab60d654d96728cedc84c140", + "realization": 62 + }, + { + "arrays_sha256": "1b5d28ce95123d9ec301ecbd28149273f82867bf85eb5d1aa948907beaf532df", + "metadata_sha256": "d694f1efcc1aac6fb6cfed8814335d0962501b5d7c3697a9fa3de2bbce443611", + "realization": 63 + } + ], + "observed_median": 0.3473456476442244, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.33998881412401927, + 0.35539578968897517 + ], + "realizations": 64, + "sector": "adjacent" + }, + { + "N": 8, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.3057881860688608, + 0.31137835043300116, + 0.31677833243100345 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.3277032710171455, + 0.3343214104998873, + 0.3415163074349069 + ], + "median_hodge_balance": 0.07146412252958581, + "null_banks": [ + { + "arrays_sha256": "4a71f07c0e5c660fbbbecc1f47560e70bcaf094ac5aad34213c481dd63d63294", + "metadata_sha256": "2d3ccaf2c6495436f3a35cdea0812600ffd81e86c601ad8ed1c938639e62fc1e", + "realization": 0 + }, + { + "arrays_sha256": "71293782f040eb92223ec4d01a28404b5008dcfa128d6e8fb218c61465cb0451", + "metadata_sha256": "be74bf29116fbc56ec295a1612ff586d6f5e660193ff9897816f40390c3f33ef", + "realization": 1 + }, + { + "arrays_sha256": "5da89d02f9a43808e2ecce2523bf58d48aad6721fe0b212e81302ff86f15ceaa", + "metadata_sha256": "766c99cd710239e31c833166c802c4e4ec87b32ddb94d8d0d36e2ef068dc59fc", + "realization": 2 + }, + { + "arrays_sha256": "85e3546836f0001004d949eadd2408875ce0afd28b7a0c0eab0c4fad24ba6379", + "metadata_sha256": "77dbc140d21ba6ce0ec0c0fbea9c0a50653cb1cd36c8eb92f75fdea196fdad8a", + "realization": 3 + }, + { + "arrays_sha256": "5e648686ba4cf787a59890896b28e778e5e4d36c2ea299280f0ff7b5b969be45", + "metadata_sha256": "f5d3c4c863059880f5c7a7478fa1c0a0ce8363c8db3981f081ceeccac7d147eb", + "realization": 4 + }, + { + "arrays_sha256": "36e67c8fbd0e1dbb536f780b285868edcaaf99a8155e16c0f02180cc74425d5d", + "metadata_sha256": "81335e0b0b365050aba8478008d953bdcabdb6dcfd51363a40f2328fed6c6ded", + "realization": 5 + }, + { + "arrays_sha256": "854b09042971e52f3e3a6cbfe343df9e5e84b0de0a6cee10dccc0f37689ba587", + "metadata_sha256": "6e50701efbf8d41c1fbe14c8f6b4c81625d58d81937fa80c6691a2762942b66f", + "realization": 6 + }, + { + "arrays_sha256": "2d856a13d486125679df3ca6ae055f9f9565e45ef13947bb6fa73d51a3ce33ba", + "metadata_sha256": "5f4ac976f9c23ec39e601484388f0e1a377d296db0da1e6260eaac6f35cde5dc", + "realization": 7 + }, + { + "arrays_sha256": "9ab3247bb2cb415755fef35d838e6c40f1d4715e314f2638f9e3ed86c54ae530", + "metadata_sha256": "96371d7cc16c6dd229bb9caa4e5d4b3c6b98f4d1663b4ce04cd3baa03787cc74", + "realization": 8 + }, + { + "arrays_sha256": "7a9032658a36ba78f329a12d1700cc2806756a21ddfbf130162086e5142e1b1b", + "metadata_sha256": "5ac1a7bdaa6a10b315e9ff0fa5a4e5f93a03b10fb43b0e213daee09ba1a14f79", + "realization": 9 + }, + { + "arrays_sha256": "883b7a5c0accdc3e3102c37aecbc208be1700269c96d9c8c27358b079cf3e1c4", + "metadata_sha256": "5050035111c33e4037fa8fae7490ad4ef89635de318e7dbb03b01e5eaf65fbb9", + "realization": 10 + }, + { + "arrays_sha256": "c60391692b0e21eab4ed30fb335b2e9952fdefdd3575a4b69f1091363c2eb967", + "metadata_sha256": "676f25bb5e1c501e7ab60abe68588a30ce885de0e9495692e81face631258aae", + "realization": 11 + }, + { + "arrays_sha256": "67d18ec337994ced9e8dfc5bd417346909c28ad3e97e40c7e9a1341c118e76cf", + "metadata_sha256": "d2d7c71deb94e0dca633ca8c85bc0a8bca18eec3f2bac16dc8300cc3b33d6465", + "realization": 12 + }, + { + "arrays_sha256": "048b43a21cb45cd4db4e0b5f218630ddad6b0d937f08e029b02a129a953db586", + "metadata_sha256": "0f0dcc77b32704680feb62cbff1ccee998f7ba7f549381bf06957cb663ad54a6", + "realization": 13 + }, + { + "arrays_sha256": "a1d17f2a560975a58f9c08ab70de6a906c75bac9877393b3484fed7ec84278fc", + "metadata_sha256": "fbbca5c43e077a2e5649f3d20cffeed888cd8fe19a7d0cb0b3385f32a447a465", + "realization": 14 + }, + { + "arrays_sha256": "6b95ee27b4ae3e3d6b92e3a4c8f102cf805b75131c3a8137ffd5c09d444088f1", + "metadata_sha256": "660681f42644933e010b18e927695dadf0c048b5cd9ebfe0649d2ae127aa9e55", + "realization": 15 + }, + { + "arrays_sha256": "1926c8b15068394570738a1656f75f03278b170272297027b72658e7f92bb9b6", + "metadata_sha256": "1bff2ab792c4c59212bb23a9ed74172f74bc86c9260053eca764457601269404", + "realization": 16 + }, + { + "arrays_sha256": "e3877490b22de8e07031d5c1326703e02000e33f00603a9527d4e0f7f075b009", + "metadata_sha256": "6a705795ef1a8f1ddcded46205c8a0f361c8bb864a2bbad0c48cbd1f79e0624a", + "realization": 17 + }, + { + "arrays_sha256": "30648db876acc8fb837a4cd3aedd9d01dcd4e5f3eae06695399fefa16f72a337", + "metadata_sha256": "370424291a045c2088bb953660c41ac0a00b45852c0073b3726782220ebe3bb7", + "realization": 18 + }, + { + "arrays_sha256": "830e11ada74fd2232d183f3128fb2323e12923fe6599ed5fb3a2c31e2914a965", + "metadata_sha256": "4bd0ae8e314541c0a57d8427f62d112db826a7f420f6488167a4e4aa884c5357", + "realization": 19 + }, + { + "arrays_sha256": "fb28182556675c28c562b9921f81398f38fe2288ae0cef95bbe4e8ba8104dd91", + "metadata_sha256": "b3f913f534d0039d253811b87aa249dcef919862c9cd843a78a748d948aacb73", + "realization": 20 + }, + { + "arrays_sha256": "cafc794c81de01d75221ec8e5e04453f88b6260ed8698fe22fb9388be7dc4beb", + "metadata_sha256": "a89860cdf5ab27770cda88f8ffaa8e91c3239a0bf778aae36bfe37709391eaa8", + "realization": 21 + }, + { + "arrays_sha256": "f8c520c802db0344ba4ecc5f04797156888b27ce8e2e443b64a5beea9ab8ffb5", + "metadata_sha256": "4ae10ba66002e7264b46586865f800f71daf912a49b62194fcd10562ba065d0d", + "realization": 22 + }, + { + "arrays_sha256": "b0e5b55b581e8b83429860a79c6bac5e4ba31c54363028ce6df12becf3f9c7cb", + "metadata_sha256": "d176cf6e32b5d8da3f398d54ca4a7da5e761862a9b511e9ba0484cd5c077dc10", + "realization": 23 + }, + { + "arrays_sha256": "e1871217326e24894fd7979a0adc93d9e7e5eb522c817d356ee034884f2c340a", + "metadata_sha256": "41147a25149bbac289fc3ce85896df3292dcf0b96da150be08b32507e1cfa39c", + "realization": 24 + }, + { + "arrays_sha256": "7b6ee2739bf964c26b53f7aa0a6107c87e8735a322a35dc7e0cae13fd362ed48", + "metadata_sha256": "2ca911d5db2e76a761f8182fa78eb910ef9d6d4ba13d520862270bc63837bf0f", + "realization": 25 + }, + { + "arrays_sha256": "6e36550760f983b784d91913f0e33cf63731524d733bbc02e4659e075c059c7e", + "metadata_sha256": "47b4beb8e00359eac1597ae2e5d2f00ec38b07b99067da95d3a510a7d43a2922", + "realization": 26 + }, + { + "arrays_sha256": "47ebf84fc14e2501b327381dfd72b607a1410c9a393689b94e228b426b4bb0b0", + "metadata_sha256": "985de16d4de9458e4508dac8f5ed320128da9e0444ff1395b9c49e3d36247287", + "realization": 27 + }, + { + "arrays_sha256": "8044ae04c63c5ae91aca8ba0727df048a5c42dfa3842f07aba4ce3fad5f233e2", + "metadata_sha256": "6f9444612258ea287649cf740c2ff5c852b202bd1174fea90b3ce241689211e5", + "realization": 28 + }, + { + "arrays_sha256": "3ad4725c4eb7adc0a285ac023d7e16bf86e5484289b7eea98bc8489f24fc9620", + "metadata_sha256": "1a17091f3c4413ea11d279392fefe449118916d182f0a0fefd0170cff50e3540", + "realization": 29 + }, + { + "arrays_sha256": "0508f3451d86dbc83644b0d1038e907e4b69583fc7fe67c1ae56f9c91a1a25f1", + "metadata_sha256": "6c269bfb3c0da730cd21a6b710ddbeed5291ea7ff6c544dfee4a187baf47d469", + "realization": 30 + }, + { + "arrays_sha256": "ede2af9c679a4dc56fe8e04456b22be63cc670bfb16f232bed03b2d9da6b3e6b", + "metadata_sha256": "337af29b23b6796f323957973aa4cec9b984a892d6a4ef5c8fb0790ca93d0883", + "realization": 31 + }, + { + "arrays_sha256": "877bf57b09521f48281d5787407f7d2f314ebf3ff3f15ba1e5cb6f4cd8847cee", + "metadata_sha256": "745b03a843845805c647a68f9bfd560ace63977dc16d403d1af873cbf52a4f0d", + "realization": 32 + }, + { + "arrays_sha256": "940e0a63b669409e96d27719aa68a72d310a4a5ddecedc95ee977432b305cbab", + "metadata_sha256": "dc2baa2c57d7025583c4fd5fec662d4c62bcc71deab16a92e63bb1b49bcb7e74", + "realization": 33 + }, + { + "arrays_sha256": "d1252f6fca445850490cdf30336cd3f9dbd46cb9b94bcf24f238c5fc40d58b3a", + "metadata_sha256": "a8dda9eba86ae7727e06579cdc58647479a62e56abac704696087d4481ebad01", + "realization": 34 + }, + { + "arrays_sha256": "545d66c31365b447227cdc45be506612f80faadd9b33685dfef55f43007085b1", + "metadata_sha256": "5f484c7998e6ee1d0b63d20529195b3c8c330729a9c3a227d1065cb33fab91a0", + "realization": 35 + }, + { + "arrays_sha256": "b8d563285328141baf014e8e8dc9f3cc07d191152431f59f89af28c45d54def3", + "metadata_sha256": "eb17c4d64cb62bb1fe9e3bde0d356a9a398b0ffc0a1b634f349d43084150cb55", + "realization": 36 + }, + { + "arrays_sha256": "9bf4a76d9eea5e204ff4b2c39871bf99242ad0f7caacc55e7eabe6b5930b32d4", + "metadata_sha256": "966fc585eacc07eb7c41bff39b298e86eb27c58de6843a0693b4332376db599d", + "realization": 37 + }, + { + "arrays_sha256": "08a07b3bfb555a2b53be899f2406b04941c04ad6edd19d75d75de4c7e870489e", + "metadata_sha256": "8e85e56064dde10e9f23c6d6832f1011b67629fee054fbf888712a1a87b586d0", + "realization": 38 + }, + { + "arrays_sha256": "8b5ce38c72f93f46b35383cf0c781b20b047049a73151bc9247619e933b5ef0e", + "metadata_sha256": "df895563293f8804eb5ec1bef8d1740684901d65d0adc7a995ab06f4435591d2", + "realization": 39 + }, + { + "arrays_sha256": "6ef9ab76b970220bbd5a939f2ba28f0c8156616ddcf1fcd16a63099e83a5af87", + "metadata_sha256": "41e1842062ace61dce876c064795aa1bacb2469020239beb3f243bb92ff44c91", + "realization": 40 + }, + { + "arrays_sha256": "bb0d34594d5f28ef805b7b48b47bff9b7f204348c48cf09f6412d79bcfc11ba3", + "metadata_sha256": "128914394ebe3c26e3798286f61319fb80fbaf17fe387aeea3bb1f00bc837a5a", + "realization": 41 + }, + { + "arrays_sha256": "7fae870ce113fb69b68a7f09233e9cc0953ef670f179014c787dc274a1470943", + "metadata_sha256": "1825a199194734513c110c6907428ab7126b7fbb7750dc42965fbbb4a3d9877c", + "realization": 42 + }, + { + "arrays_sha256": "f231dd3c56b519e6f19c16cc505bd4012d8b44c7805acc65f7d0d1d8bed5eef5", + "metadata_sha256": "f2c1e8fb9e3fdd7ec4ffdcd7d8d24f156b95254f72017b0d0c40a6ece2170325", + "realization": 43 + }, + { + "arrays_sha256": "8312b13d0966dba8c161678045f4b10d48b4b20000d12d7203bd3e0af492f880", + "metadata_sha256": "7abd64b7926e50ff8237d84e5e2ba5ff85211782614b50f3d269ec0c191c9896", + "realization": 44 + }, + { + "arrays_sha256": "e13fdeec074bf12340591e141d7aa5b035599f46f94d33abb59a272bbbd7f9f5", + "metadata_sha256": "44665ee402f48e34370430573403e1789fd34d26e015f53a2ff314baa1bf9f0d", + "realization": 45 + }, + { + "arrays_sha256": "b9b3855171bd8aee849bfd82f00097e8c87eed110cdd59692615bc116a3c91b0", + "metadata_sha256": "bb959d40badad7e308bf92f92aa096a5fc6f7110c49c8548868f91e0559c9033", + "realization": 46 + }, + { + "arrays_sha256": "121028fca73cb5466fe18322cccd403d03904362f6c4be61fac578fd5378015f", + "metadata_sha256": "0dec90287014a239220a4c335fcdd032b57b3618a8ab6925a4e267dd16b4b798", + "realization": 47 + }, + { + "arrays_sha256": "0985ec641e15f3372ee2f9a9e6a83d803cb804cd879371973f96412056ccbdc5", + "metadata_sha256": "05c1e0e1c870cb12064fd202042be1043d74f785721d3cc7359b02f370f750dc", + "realization": 48 + }, + { + "arrays_sha256": "f3f90cb07be47d9cef4d3dbe21d966dac8bc288fbb4c39447ded5f9cb21c8f82", + "metadata_sha256": "b053665662bf973cbf23053ed13584ca61a4611181413c72852bd873a3eb58c1", + "realization": 49 + }, + { + "arrays_sha256": "92d3838792b70f9f2cc610ccb22891232fb3cd7b7cb0dd37bf7e7b1d8a3e42ab", + "metadata_sha256": "f7b6b329f1a234a076a1b161ff589968118ed508113a188bf5557573155929c2", + "realization": 50 + }, + { + "arrays_sha256": "222e397b309ab4e370422d7cfe66d7d6af76055b0defb8d06db489151342baa3", + "metadata_sha256": "24549e52791fe9bfc7c58aa967221b9baf1fcb422adf16b2a2bcdef57d9465c4", + "realization": 51 + }, + { + "arrays_sha256": "421f29ddc2d25f8c03924a07b11c392f72b9e72ceb7d98fc223f70a68671ad8f", + "metadata_sha256": "530433411091f70dbcb6a72a02d0bf45a0681960359390efd389b0a3b3100647", + "realization": 52 + }, + { + "arrays_sha256": "fac5026cd3be96db586dcc977cdc5d10e03aa7c7dd28e20fd4d3110d8f5c968c", + "metadata_sha256": "fb270f11dfb1e2b2d5dd85af0c88ad69a0bd7f729db80d06f2d82606fc6e0a0c", + "realization": 53 + }, + { + "arrays_sha256": "d81f2390caa9cf828b460ba0c05e70a05c4e5d584f161bda49f21cd176278516", + "metadata_sha256": "9c581c3df5632594c4f542b8151449311f2b988571e8c62af96a85643d5ca85e", + "realization": 54 + }, + { + "arrays_sha256": "20ce2893c4fb83e995b5af8787d6f3eb8c8b906a408f27526249faaa54f80611", + "metadata_sha256": "7c12c9a634629df706a0d83acdff4413e4c4094a14654a1796011f5a0374b348", + "realization": 55 + }, + { + "arrays_sha256": "485ba5ecb5e8214afa7bda46800265e0083749dba1a0f89fe4dc9a1ca5debb54", + "metadata_sha256": "50677b1b657750e9386865b2abbf1addce2df70d55b87aea0ccd8c6c21ea0b5d", + "realization": 56 + }, + { + "arrays_sha256": "e58223be2ba03a84a19c89ef5410550fa86b303c37d561c366dfc27f740de3f8", + "metadata_sha256": "43b81610fd756f101bf1bf9e2cea9557721b933ae32f8f77abb3e16f8ff3a59c", + "realization": 57 + }, + { + "arrays_sha256": "ecd33f3b8d1cf44be4b7fbe54a1e04960f9e3cecb679f0982b4d51b94f7ac69e", + "metadata_sha256": "f83cb466b82214aa7e5c236c5cc166ea2c50ba78c6dd107bab46596f13ca6acb", + "realization": 58 + }, + { + "arrays_sha256": "92a2f5c466bd7c23c6716cff431ecf591c9f6e64f0f77bce6605b07d108002df", + "metadata_sha256": "4e7db9ad1306bf8710a130fe887b68b2269d847bb37aa4b4d71553cfc8fbcc06", + "realization": 59 + }, + { + "arrays_sha256": "d1396b8a7d4c52f5a509c9595d05ea9af8c99dfc856760e6a5cb12102dcc2ed4", + "metadata_sha256": "fdfe0c0adff0469cb0a8dbbcece9108ba967d1b5fdf8a15f71ec7c60840f1519", + "realization": 60 + }, + { + "arrays_sha256": "7219dc4e7cb59aa46f623b12f988f53e67a9b1cd947df03fc44d44ffe77fac59", + "metadata_sha256": "435d13b0b26dfffa8140431d0fd6c462e1ea12fcd7bd5df73af06f658c6a1b93", + "realization": 61 + }, + { + "arrays_sha256": "2215a26700357d3641feea8a23bc78e6ea56ef7a53695318409c2a815b1d7dd0", + "metadata_sha256": "e7fa05cfd42a4a9da6f55a1d6411862408dbf2315c995b89ec18f768f6cadc8c", + "realization": 62 + }, + { + "arrays_sha256": "3dc7322f0cbf9b3a60be4e6dccb42393c1ce96e46f1c9e1c72a48194732aa63f", + "metadata_sha256": "a7f702bdc28bc4663549d7f40643812f9b070afa64bd708c1c0712af896941e4", + "realization": 63 + } + ], + "observed_median": 0.4214201895221874, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.4126581626544304, + 0.43022143872255464 + ], + "realizations": 64, + "sector": "adjacent" + }, + { + "N": 8, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.208296575246959, + 0.2098604897075424, + 0.21141356711284964 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.21919373485072516, + 0.2211378800339962, + 0.22312587488350194 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "fde5ede4a59f43f00ba6dc0b588d722178bad5f7b7ab99fcfbc0b68f2bbf7dbb", + "metadata_sha256": "51a4dcda1ce78dd288476c8e2228580df2b58be891dc8f9e65c61d89d9a77aad", + "realization": 0 + }, + { + "arrays_sha256": "52261414a7fd29a83debecda4717dd48ed12328091f1726c3e07422bf71e6553", + "metadata_sha256": "74cd99598253e60d8ab4ec67711abe6cfb7a06e4818ecaa36ea06fcccfab55d5", + "realization": 1 + }, + { + "arrays_sha256": "72add21bb254f9c8d8b1caea0d5bf799ab27bcdc065ed2cde0a327ce003353f4", + "metadata_sha256": "454073ed6158a7dc8166c8be4f4751b25d919d7378676777c25d2db3a1464864", + "realization": 2 + }, + { + "arrays_sha256": "cf4b73e3e148de0744cb6489a7c218cb1ca75aa2dc0b3b25d7e88816b304036b", + "metadata_sha256": "b72680320d254397c4c6f9e835e93615286ad78e2baeb974676e92e15680253c", + "realization": 3 + }, + { + "arrays_sha256": "c768bfa190967ddfe631fd371e733bf207b83730d1a6c2836241bb35460b521b", + "metadata_sha256": "fe2c2b430e867598db55743f90cacb28ce56f6ce791cc76a84d63ab1ba787624", + "realization": 4 + }, + { + "arrays_sha256": "665b1537e6ac516146cfa88d0eb05d037ff1555b380f008c04748172db3c3069", + "metadata_sha256": "44c53d66db5ebf0f690e3c3834b706f65f70f0a04012f08983b9a1dcd8b93994", + "realization": 5 + }, + { + "arrays_sha256": "4742b0cce2a636cd1816a941d05d21b44988f4e3707a4ab0cb01f911fef6e4a4", + "metadata_sha256": "8591f30826700b51d0ad808cc301773df9ade23422db6045a3e56086512e7f3a", + "realization": 6 + }, + { + "arrays_sha256": "72f8f4bac4c29bcbc0e929c8b308f41ef87deb6f3816fd542b49843ba37e3f6a", + "metadata_sha256": "4871372cbcc2d4fce599b8911f13df19b87d0e66ce8f6ffd6241e09f5d8c6161", + "realization": 7 + }, + { + "arrays_sha256": "bc80d180ae42e4213f17ec6b57a84dec68423861672ce0f3fd7ba97a7e7da8eb", + "metadata_sha256": "2fdffa958856463941f496d4a9b8ee982edb72e3e796f1d90b590c65a80a98f3", + "realization": 8 + }, + { + "arrays_sha256": "465b7936550fe0face0801c9befe5e760bca85e5c9b2ee296673efa7d67120b2", + "metadata_sha256": "8321d2a3ef0cf370ceba6e65923a875ae45c49f1ce3a2c66e41eaac2eb86a67d", + "realization": 9 + }, + { + "arrays_sha256": "3821ef0fb3bd0885b4443995a9fbea2535dddf8c8759edfef498a279c89e5583", + "metadata_sha256": "11f1bcb9faad4383eddec5a7fd3da09178953ff1ab707adab53443985c40e263", + "realization": 10 + }, + { + "arrays_sha256": "b53125476970423b1e20b67e518c5f67a3a8dc57221eda2e211866667e1d2225", + "metadata_sha256": "65bf2f7c428badc22e9c1e80e7c4ece59458607b0d0045be75b3f06346e8047a", + "realization": 11 + }, + { + "arrays_sha256": "1a209fbf7af04aca31745929b41244330177794c224d2442c850aaea2762dc50", + "metadata_sha256": "fee41d68cfedd677158962cef0beecd69d15043b8ebbf0d922778c70137cec9c", + "realization": 12 + }, + { + "arrays_sha256": "cc224a42c513cfa026acc8db966de63488d96c4b7c56df8c21adb4ba794f70b0", + "metadata_sha256": "e8ba8dfed10b10a527c3138907eaa70b50f7d01ccf1ce24920193fc6f4ee229e", + "realization": 13 + }, + { + "arrays_sha256": "08b5225283a6a0dab2635a96fd24a3a0f3a79cc75c376a20942e56e2a1e0c1bd", + "metadata_sha256": "0e7a688adf0c7e8ce8f9c35bf4553da7d7123cb55fd7101217d7bc5c87947b03", + "realization": 14 + }, + { + "arrays_sha256": "ec340bc932bc40dbcc68f85954b8365158d4683fe793a52a8ce63ea87076c602", + "metadata_sha256": "c16eef248530e1f650b8838648ea97c9296ff4b2eff3f720884a9338d9343fe3", + "realization": 15 + }, + { + "arrays_sha256": "5e7c62a4ac53ef6e746ae28fb9b1a3d6f791e925968ee1f7e14f2c92f86543da", + "metadata_sha256": "edfdf871cf2110b9de1dd47fa5d9b92d4f3783686c322ff2c6a63485aead27ba", + "realization": 16 + }, + { + "arrays_sha256": "bd0261138dc45cbcf33a785582e115d0a1582c64da52e6c141cedc30ee0cf403", + "metadata_sha256": "979903a48202ad39cf133dab5d6c45cd6498f9fa7953ba66e16c3c2e194ea9a8", + "realization": 17 + }, + { + "arrays_sha256": "c66915ceb189d9035bff7f23adbfce23a2f3ddce34352ca60c7e029030e7b99c", + "metadata_sha256": "4658a666874da2b0733128cf56f86ea6a2b2eb84772352a19aa319e24b1f4da8", + "realization": 18 + }, + { + "arrays_sha256": "aa27db6cd06f0e9252e16849858f0fee89855e0947a3aabe949967a13559fc54", + "metadata_sha256": "918da874db63db0fe8f56740da067a75ad7cd6f32add723a1c5419138657adcf", + "realization": 19 + }, + { + "arrays_sha256": "3b057101264cec1335042b560a3dff962e09e7e166fa50aa0a2e2a0bd0b0ec09", + "metadata_sha256": "551acc16f91112a1cee4e013196df48d18f28eccae4f6ad36538e04577344c90", + "realization": 20 + }, + { + "arrays_sha256": "a09e6f0dc9a7d5b8bd1f64c7846b72db36a460346965b5a3b35ce069dbcee56b", + "metadata_sha256": "14131cdfb12ee6d2dee42764e3c290cb1f0706030bede65d2de156f3bd170c15", + "realization": 21 + }, + { + "arrays_sha256": "3f43b7157e5cdf0075d21f41cd3688448dced7bfe313ab8166f1e6f9d556400c", + "metadata_sha256": "26c61228962ce71e95961b0fd12b6644ca29d1f4880f0e5d9302ea780b6b01aa", + "realization": 22 + }, + { + "arrays_sha256": "4985f3a2f89057ed9acc86722c5843979cacfed6381f86f88cafe9253f12f4a6", + "metadata_sha256": "20d01f226a631285015d8306452ef1d23971f1bc22045adb26eb36dd11e2f340", + "realization": 23 + }, + { + "arrays_sha256": "4e3f6c91a3b4cb6c8d5bfb703580d0d7baf0ad6b1ba986bfc0753286d6b618df", + "metadata_sha256": "6a2a1106a9202dfbca97be29fa11fbd78092d01bf8a7fbed300e61cb2729e47c", + "realization": 24 + }, + { + "arrays_sha256": "9f0c59896b76ed346d625bd014ae79e4bf45106aa3b8e79d34825b127722c915", + "metadata_sha256": "3f409b78502aa9cb76e2cbfbf2e93a5eb61bbd5a74207b0fad75c973ba3f15ba", + "realization": 25 + }, + { + "arrays_sha256": "e7be39ffd2e9af41d491bd502aa54809137075f3c877702aed6b5088c7896e1d", + "metadata_sha256": "1e012adf8c247c337091d79c7266a39ccac2bf2e8f0af0c542e6c285e26b5a64", + "realization": 26 + }, + { + "arrays_sha256": "3149fed9666452bdd15d6b9a77491b268649434cf7fe3a46b958b910f309ce1d", + "metadata_sha256": "215c6dd3016833725d34b8acb5fc0acd0712aa9ed660fcc97ff5d7dae0f0db19", + "realization": 27 + }, + { + "arrays_sha256": "23227feae2a51ee786df7c9ee6f130f25802426f1fb14f9af6d41019798aea40", + "metadata_sha256": "8e02e515f20d409292c3cc7c03f61cba306ce725ae0b110229e5d04a5fee628f", + "realization": 28 + }, + { + "arrays_sha256": "55289c5fa377817987b2f29168e8d2f39c0d5838a79d43b9d71d874737e02d0a", + "metadata_sha256": "c93db0becc09dfec535fc07e6e7067166707d84045a38700487a7fd4250ab6c2", + "realization": 29 + }, + { + "arrays_sha256": "d367bc791ba0fac1539e830cc30047571b0ae38efdc634d19425490c77e6d36e", + "metadata_sha256": "94d35178eb56c5db88fe5f5cd4f6bb4714c2782a6eaf087ba63d539735547bc5", + "realization": 30 + }, + { + "arrays_sha256": "029a9ef702fad719c402458a535460b8ed44dfae1debc1f33b838f67b30fec7b", + "metadata_sha256": "048a8c3f740c3afdb1dbfdea74456fc5322aa01c3fd73f3d99c3cc1bb7ee0768", + "realization": 31 + }, + { + "arrays_sha256": "d2cc653c229c0a8ca5f0450e9c87e0bd0e2d2bbdc4266de0633940bb2f7a9633", + "metadata_sha256": "337056bd55242a282adf09d7356a7af589bc92c954ec27bec6c415cae538c370", + "realization": 32 + }, + { + "arrays_sha256": "5a325cb514453d8518f2fc9c7b37cd8dabfe65f2473709805bfc823ac3aaad06", + "metadata_sha256": "b3cd1650e85e65f9e7c15277656faa124d3f926a41a57a26310b40adf4dce809", + "realization": 33 + }, + { + "arrays_sha256": "2e4a8e7e27f2f01c8882a5dc617cb9231b2f6644476f4e316ccf6d914d1e88ec", + "metadata_sha256": "ec65aaf2406f8dc6cef73da323e92b17c3d1053f65e79459ad51d813739c84e1", + "realization": 34 + }, + { + "arrays_sha256": "6ad6d35f1fec93316bf3181c925edbed0e1dcfb0e49049b4293c249c97b7d35a", + "metadata_sha256": "4a8ce45b29299a64bcc01f7384e8faf21bd386f4daf90cf5aeb2c9800c5d1757", + "realization": 35 + }, + { + "arrays_sha256": "e550d7a159f867511a0a2684cab01106adaf898097567e9c4c0779812e8f823a", + "metadata_sha256": "3ec26df79db08062bd09f2f3348ee5ebc6dd6bd1df490ff94ab264975da1d1a6", + "realization": 36 + }, + { + "arrays_sha256": "0d7d3190076a9251eb1ba5ac8b9ffee3f539fc1f36b2d809f9d9cecaac865673", + "metadata_sha256": "869ca0075b3536be689428c4db907acf93230a71fe6f400f67d00d90e0735e2f", + "realization": 37 + }, + { + "arrays_sha256": "909aff89c5682973789b304f1259292efdbd7888b12bb02ad0a861b0d244c489", + "metadata_sha256": "03206d1869dd502b17ecb2512942936ab1395249143b6d4846936d2d6a4773de", + "realization": 38 + }, + { + "arrays_sha256": "b967f61248f39144f47dbb0feed2390ddafab896ed22d696f44c00203cbe2153", + "metadata_sha256": "481c483f26bb07a69197232574d40298b223c098608dce98d3a247001ddbce0f", + "realization": 39 + }, + { + "arrays_sha256": "2a523da657ba7866e59c634b6a0094153f85600ab55b9741d419c6f79dc94ae3", + "metadata_sha256": "3d006bc1e2b18c2f5d84d652fb0a413f0a0eb5954bc2ed270ac3a146d1e2c791", + "realization": 40 + }, + { + "arrays_sha256": "263d83f1c45ae8cc46940adb3ba8108071efb69879f3134208eab26d33bf8b8f", + "metadata_sha256": "57178de22de1a744e75b220d690bacaf74b07c1ae3b5d8941130a437e817fef5", + "realization": 41 + }, + { + "arrays_sha256": "3546e809af5123b25edc34deab9dca56a47bdeaf668b2a23a9e3fa07985b4b21", + "metadata_sha256": "2d37703a3dadaef904b74a0ebcd201373364497529cbfda985ea1229a49d1d2a", + "realization": 42 + }, + { + "arrays_sha256": "e0b81731b73e657d9db5859220f71c57844a541970954c2870bf29ac44b21746", + "metadata_sha256": "ebfe80a36ae044b18f1891ddfdeb43958fc7c7e30c870022892c9dc432e794ea", + "realization": 43 + }, + { + "arrays_sha256": "554d17b9f19de8275b8cdc2877f2f573e4bd409c328d37012604eeb012ac19c4", + "metadata_sha256": "1751795936b20fe7f16bb1718101bf832598ce01b133b4b1ef6fea9fb492890e", + "realization": 44 + }, + { + "arrays_sha256": "8faa2921a6fe3cc12372f46a7feecf3d880ddae469cfb57087f6ccda8c26aac6", + "metadata_sha256": "6ad8f1777e4ec50e7d81a0473c373dd1763ec0e2b2fd5fa1c465f5af9153b1ce", + "realization": 45 + }, + { + "arrays_sha256": "4d29ca7077894e11bc32edfe779630d552c036b774f57f591db46dd5e07a343c", + "metadata_sha256": "dbe3358d98a8d289c822d621e782051c4414a4f99d553b5ef4f5523419d8314f", + "realization": 46 + }, + { + "arrays_sha256": "92755041495ed91494c38caa2c0e5347238c059064a8578bae4c835b0c090cfd", + "metadata_sha256": "298300ff56d969bd0c062c20208e8443690e56b6150c2e291f1a6758d2d2a51e", + "realization": 47 + }, + { + "arrays_sha256": "57a6040a352113e12f35811900ed7a11c3448d34cd2bd3172b36a1e611710c39", + "metadata_sha256": "7262d060424f208b32c5fe6a4c7d56b635bbe12160ecf1286784c706f49a0f72", + "realization": 48 + }, + { + "arrays_sha256": "a564cc62aff47ac40d4155f729b15d1a942ce6af9e00979195031765e9011980", + "metadata_sha256": "d68c735f3309cec2845a34b3aee3952f5852d61aed07089da98d48fb1ee905de", + "realization": 49 + }, + { + "arrays_sha256": "b0a837dfc2d3858f4faf4adccbfbd6d4f428f87b3556d35fa8258c436650f826", + "metadata_sha256": "14f1ca8bf693bbe590af2d2509fb4c26432241b12033a5030d2f0b891c34b437", + "realization": 50 + }, + { + "arrays_sha256": "70c2eb395ee7b57f33673d9c833b663414eb11e877e23ec4635eba3a2516b7b5", + "metadata_sha256": "96a342d3ca7afc6b5bef5e4a7d4dafe92047059c9840e9114990f60e8db8f203", + "realization": 51 + }, + { + "arrays_sha256": "f7fb6f25ce15d1067b0c10745340c1c8d67b2a8b0ad3157724524a6f01e1aa2e", + "metadata_sha256": "fdfa7363c7e4a74f4ff1babfb8c5b68aeee7068e2cf366d3419c106df2cd6859", + "realization": 52 + }, + { + "arrays_sha256": "0bdee0ac4955619b553924f5216d01e95ad3085ae5896c72a5cefe7fb6047030", + "metadata_sha256": "c08d09e0e44c481250bf70d99050a518a8fe2f47dca17ac16474481ab290d534", + "realization": 53 + }, + { + "arrays_sha256": "f413fea322287b9ce8b837f75fa66b9f09d4e6bc2a4eb25e086fcdd3a33a40d3", + "metadata_sha256": "12fd82adf8714c52725d652ce9f53a0c8a3be1a093b4461b9b8546841cfd84b1", + "realization": 54 + }, + { + "arrays_sha256": "7850e99d056c8f54a2256d47ebc89b562489d117391ea398accc6d50a9f8a1e6", + "metadata_sha256": "c9b58ba30e699acc5bfd1b47934564bac2d02fb5c8b5da8dd7353bc45004d750", + "realization": 55 + }, + { + "arrays_sha256": "ba76d6efbbc1592f108a3689dcf16a12f0242def9c44a89256d22b1ae9fc6df4", + "metadata_sha256": "ff4c71b85ddd2306cb83699cb2d7f974c809980e6cb22d29329a70fcde8ba772", + "realization": 56 + }, + { + "arrays_sha256": "5500930cef24dd9376340c008e9930f693992f7a50eeb61f55fab36b7a11fef0", + "metadata_sha256": "dd1c5f0c2028293780cedc3608886e6ea78e94faf8aec5aff2c507d59946ee58", + "realization": 57 + }, + { + "arrays_sha256": "8ae7ba7246d4e551219cf603d2f2cf0ea99220cf81e1535cefeeafea47e640c8", + "metadata_sha256": "44047c9c85b677944199e175fafaa3a5c47dcca5f0b07e8d536430cc0e7834cd", + "realization": 58 + }, + { + "arrays_sha256": "edda91a20e337e516430a5e86f047f1ae83af016117193a8c0b8abd45bbb9ad9", + "metadata_sha256": "96d67509278bb4702d62d5fdf8b27d2e1ca2c6d6b07133a7296abf5a597f6354", + "realization": 59 + }, + { + "arrays_sha256": "028337035f3f2c341d1a227f16a9cf98d06506e9e2d2850c58471f7ef69f9378", + "metadata_sha256": "a3c6f482fc99ffb8b121a4066ba8950738481b433b202fcad8c4d5ca549271e3", + "realization": 60 + }, + { + "arrays_sha256": "622992b845f8f90587d9331233f351684a961c9f1f6fdc914eeb7851ca70d89e", + "metadata_sha256": "ec4206ed0e3832e3af3f79ab1de6b34bcb50876abd5fc79bfcd4094d843c1968", + "realization": 61 + }, + { + "arrays_sha256": "98dcab22df1ace436c31711268e2dda1a46dcc7b8ef64e6459a8cc04c7ca7a14", + "metadata_sha256": "3c8c16b2eac8b332a0d26f4bcba007f84f8b0e07ba7e25d5e82fb6e3e1c612d6", + "realization": 62 + }, + { + "arrays_sha256": "c34c72dc428e7715ec81111ad1c8bcfb5697b0aab7f5c2012750619d56fa5976", + "metadata_sha256": "d617d0cabe81a8cbd5f600b60a91b7983b5a55ff2328d6f9f4bee2f710e01387", + "realization": 63 + } + ], + "observed_median": 0.2144978352258034, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.2119918398218324, + 0.21709852949971428 + ], + "realizations": 64, + "sector": "central" + }, + { + "N": 8, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.2230705351105154, + 0.2253842662139643, + 0.2279418505155369 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.2414682892862224, + 0.2446097093216335, + 0.24767586208084383 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "87f4b818b585e91973b0f7e61a8727f9c53a607924082a6b44f4504c846d7302", + "metadata_sha256": "e1d34054700f403531c33aad208b2be2a664f5c02488efb39dbaac28c40169ac", + "realization": 0 + }, + { + "arrays_sha256": "a323ae57cab1876a48bcb0c29ccef6e1d8f6b82eb96a6e18424bf6ca7239bd68", + "metadata_sha256": "20bb8f1d3c0587086c8a67a86e7c0bbad222826f28eaf42c37cc199f5a58e4c2", + "realization": 1 + }, + { + "arrays_sha256": "d9f3889e07c00ccc4f581329306a145e3715d2d47d2f1f2b0dcf3252471f0a5c", + "metadata_sha256": "35d041a4687e48216505036a20721f43625e34c7075c7865932078e1325c88f0", + "realization": 2 + }, + { + "arrays_sha256": "e1e26346e3957fe5e04b2c21c093c1cf52f28ec0b34d164f412451d7d1bcfc15", + "metadata_sha256": "576a93de8ca0638d13775909009aa0c4af578619c842dc832657340770663920", + "realization": 3 + }, + { + "arrays_sha256": "99ea13b632a4adb89461189589c50f47cc8b89cc29c3751c8e99c63b5f55f24c", + "metadata_sha256": "cb047d7bdb5cb7c40a007745023476bfebb4b4ce327e4766ff12b12b04c0e28e", + "realization": 4 + }, + { + "arrays_sha256": "1170696596d1c129416db581c00aa912a2d3b840ee5123cb87e8e546f55f9dda", + "metadata_sha256": "845979e19a18e3fcce34737b49edba413d543599316e976ac07e4feb40a3a0bb", + "realization": 5 + }, + { + "arrays_sha256": "6c83e35b540c6697e4e9dfcc67ba60e325e9ae6a2c5101e8d874b05866a50db1", + "metadata_sha256": "810465a253290b03cb73e84adfe98618a9462c2cf52d07d2304f06159861b719", + "realization": 6 + }, + { + "arrays_sha256": "2daa35ffd3aacad0a4248b443d05921ef33e140ded627cd6197c4a53f9bcb158", + "metadata_sha256": "3335f2adc9d293a10fcf8a8cb73d05abe82a988df2f9a07db0cec24f17dc4241", + "realization": 7 + }, + { + "arrays_sha256": "b931272609f3eb15020e66e401100582a71c7a9292888d3fedca410c236b7f2c", + "metadata_sha256": "fe18e4ec7936202125b779892a2a87c2a61cee51c4d63cf7f4c73dd8aab98005", + "realization": 8 + }, + { + "arrays_sha256": "408e946141c6f329f80bdc35ed9e1edad6ac6c22ba4a5e1b24d2c4e3beb7581e", + "metadata_sha256": "7fb358b2d50756f677c2ddc85df95c9d5ac1ded2f5aca13a129988db7591bf71", + "realization": 9 + }, + { + "arrays_sha256": "db02f0e93d4fc12a99b91559827397088461c55b6e72dfd12d97cb79338b0d5f", + "metadata_sha256": "4e07b5fe0348c45353edf16a294585f844d564379ef29b4e2b3b17ec8fd98c7d", + "realization": 10 + }, + { + "arrays_sha256": "3de270bea118329e8b723da7ccafbab298eabe715129085467ff54c3a494c6e6", + "metadata_sha256": "21d9d2f04ebf122dbbd94da79454bb6a56a6e539c44ac71dadf64ff7167de035", + "realization": 11 + }, + { + "arrays_sha256": "e6711bdb0face28fd3ca87cc9ea19b3ed8a747ea366e32724b46bcb5a9fca613", + "metadata_sha256": "de987752e9375901157e3af3bd16c698823974671b81d32566a69ac0ac44b647", + "realization": 12 + }, + { + "arrays_sha256": "fca154901f7dd4d268829d7413e22874f1e5a3a2efd7231f8a0b208a914567db", + "metadata_sha256": "e93be2c5389d6d241af82086921285a723062cba715b150c04f709502d0f56ab", + "realization": 13 + }, + { + "arrays_sha256": "c31dc61f02b6199c0ac8cd79a799354a0fe1f6a803e3dd42a295c35819e7aa4d", + "metadata_sha256": "99ab8d207c4b250444103927595837b6240f1172f7554a784584dbbafb33a80e", + "realization": 14 + }, + { + "arrays_sha256": "0d4a7ad82648c7ee29c65e559ee9292ba65b54c8a354fb4f9f68cec6af66c3d2", + "metadata_sha256": "30495313fa1f672c65be246b221e0554eec8b6030968d198c3c7f0a3d76d75a2", + "realization": 15 + }, + { + "arrays_sha256": "431439e7d8ad73f3a568678d9c855d77b457c28770eb52719f3f6d6a5e64c8a0", + "metadata_sha256": "c276e6ca46c2dd94001d3c1648308cf868878b1de68c1f16c6425b6beda4b750", + "realization": 16 + }, + { + "arrays_sha256": "99e0bd87edc55310aae8af1997c94fdbbade63ecea068f614d34f1ec15810315", + "metadata_sha256": "0f82ca3f9c65d5b1850b0e44bf5478a7abf457648218f576bba819d1cfd69fec", + "realization": 17 + }, + { + "arrays_sha256": "a92c415feadc8dc6c2ad654cf83b647b959f5e91252163afdbde00f7f9258b45", + "metadata_sha256": "ab67138b59e947cd5c4bb07d7e309cc471c6acd6cd250a0c8cfb99b5ca1e6361", + "realization": 18 + }, + { + "arrays_sha256": "1b92631e9fad6ee80b6b185e0caa23dcf06097fcf9483383637585d49944f45f", + "metadata_sha256": "a3df9828871df88b4e77be73512662c7e36e5ac13340e20285ab225701af7094", + "realization": 19 + }, + { + "arrays_sha256": "1b4975d38023701021c4b115916373da82bdb86ec99013cf4f24a5e74f0dcd0b", + "metadata_sha256": "d96e8c451541829f2d9b6644dc6c188bed0b274341dd48e01b5b9424e2155c93", + "realization": 20 + }, + { + "arrays_sha256": "49f1dbca6d4054412c5b75865561f484334181c756c5898d7ca641aec58b402f", + "metadata_sha256": "b689c5fb6eafa195a71d522a19db4e89193bbe75fc373fa14d092379a55cb2cc", + "realization": 21 + }, + { + "arrays_sha256": "3adb50b877d659a188affbe1284705bed52acab0e3f86c067fa404b616892700", + "metadata_sha256": "da153de75d222415d97486bcb1072f194cc2d37d7b002e6ed8127a0661e67acd", + "realization": 22 + }, + { + "arrays_sha256": "47a695f672164f3a33699ce2e1b99b5727afab3ca9b942edfe879d001da2fc56", + "metadata_sha256": "7a10118815bda349a676618c0341cda6d46839bbf7c80de58aca22fe0e87a4e1", + "realization": 23 + }, + { + "arrays_sha256": "029a04422d219b68839f8df27c804ebad59161b86cc0263bf41546ef0e1d9162", + "metadata_sha256": "a9ff3e7876960b9f275385115075d1ba5003878e7546812ba78ac3b4fcf417cd", + "realization": 24 + }, + { + "arrays_sha256": "13c5d8529e9535ea39d263bfff5412f996f02792f38f7863e38470ad1cc024c6", + "metadata_sha256": "6a6433f5f5de958514078c81778b8f07a46d9c34d65fb986ca9eb3c4c643be86", + "realization": 25 + }, + { + "arrays_sha256": "ccb747c0009d0273f1c0858563676dc02dc77d54d6bd6a75e9a175098ab1260e", + "metadata_sha256": "890df8232a0b26508205d59e67fe2595f20514544716e0107d876dc80af689ce", + "realization": 26 + }, + { + "arrays_sha256": "5eb3ccdc4edcbc1a74bf156eba59be0570dd80caa9e655670261501783214875", + "metadata_sha256": "24dfcfb26a7e37e869a6f629ea46011e453c832bfcf58a423094600aacd0bd6b", + "realization": 27 + }, + { + "arrays_sha256": "b2f1a88df71f88090bc07c02974a2c6a89fe25cd476c2c7145fc33e354514925", + "metadata_sha256": "78573b337ff8ed27d60c39ec7636fc7e908248f24a16e1215c60937c7eadd349", + "realization": 28 + }, + { + "arrays_sha256": "9c01e1528b5e71a631c210c2924804fcbe429e8b152430473ea02a004e415d8f", + "metadata_sha256": "486f28c8b25cfcc6e82b5d8297246a096c9cdf6feba2275367313ac8bf32758d", + "realization": 29 + }, + { + "arrays_sha256": "de925274f03b6822c95e9a9e60c6865792d51c754d1372b926e1589548b5a906", + "metadata_sha256": "85212b60b75a5fcf320fd5bd071d243d3f9ea1cf0a66c1a263fef1ae328d7332", + "realization": 30 + }, + { + "arrays_sha256": "73abc7fadc5943f3e371fe39510a1a8cfb42a588fd99feea7c47f3be9a36c9b7", + "metadata_sha256": "ad175bf90bd2d22242111e38d8e108046fe80d4144214a16a4652e96f28b848e", + "realization": 31 + }, + { + "arrays_sha256": "330023e7777fa868dc2f3be5ee110db29f6d0db3ebf47275a153ec3a8d99b2fd", + "metadata_sha256": "68dd4b41c27313c60b61519cb1efc4e00ae42476b0ceb2f65d13e379805dfc66", + "realization": 32 + }, + { + "arrays_sha256": "9890d5deca1a463a25e0b99b8f8eee8243bca48591eb93a51b18d5944bda3159", + "metadata_sha256": "9c49f1854906b0d06c2a732c1a8c830517c9f06d0ee51d58d6b32f80e100bf23", + "realization": 33 + }, + { + "arrays_sha256": "a665c418bcddb1b8d132761326c9224dc5d5d770ec78fafd7ee0726d62c6e13d", + "metadata_sha256": "984bca1c4e65275c31ff37e24dca3f09d1cf1f606ca7dadb4889a9491056705f", + "realization": 34 + }, + { + "arrays_sha256": "9a77fc8739d04810d259338f393bf5854a0530f99031c85b93d05831c7c53352", + "metadata_sha256": "5fc39987664b517a7eddc8128483052c39f398c2a5578081435dece2c72d0f84", + "realization": 35 + }, + { + "arrays_sha256": "7bb2f7f95c2d0f1b9cb5a65c24ef6f8c616426e3b1be11642304c03e0b5ad301", + "metadata_sha256": "fdfadff76f8e0ae41223c5e3629e11c4e8bd2f29edbc29a38a51a66dc19af58f", + "realization": 36 + }, + { + "arrays_sha256": "5fd163805b1740e204e0dc27289e10706058f5cd1101a08506d9810311391786", + "metadata_sha256": "d549454affa56557a08bad26cf9d11cbac684cbfd629becebc5782e863915630", + "realization": 37 + }, + { + "arrays_sha256": "23a195b563acb5097dd19c7ed8afe2365ab3f58bb3de245ba56e9749e6fbd489", + "metadata_sha256": "74f57255fce8100d6c56387a71bc1b3c8b65b7354547668dd71446c0deb8662d", + "realization": 38 + }, + { + "arrays_sha256": "5f9a5e23263a1732804da280b7126a174b4a79061df4964c1fdd21ce8c00aca8", + "metadata_sha256": "f9325d6f93cf3e7a8e4b5c175aa49307e879726321d34dbb65eca00767c6ac60", + "realization": 39 + }, + { + "arrays_sha256": "d49a73f12de2f91f7d4440fb6e4c5e94c2c0bfedfd01f2dbe5c6bacf786cfe04", + "metadata_sha256": "0db556c44018f4a8b0662f5be51e26456826dc7df0ac43ff87bf2d8adb089d32", + "realization": 40 + }, + { + "arrays_sha256": "f7f425f0a8da29e6455aa475c978f69f0e1916f8cf2617330205bf9bc47d0d67", + "metadata_sha256": "a2072d8f9c039bea203f5166f2b34c50e3290b7c7c773ba34a1e4ff04868685a", + "realization": 41 + }, + { + "arrays_sha256": "1e7f29486b734ccdd688356d935e82fcd0a593f1b6129f08b6dba8c73ffea436", + "metadata_sha256": "36a7b08cc0099af10daf95be5f2d27dede343b2dca97c04b93e340773457ce20", + "realization": 42 + }, + { + "arrays_sha256": "6908b8506dd5d7004148252d16789a9d65e17edf980d8adaa5cbf03d13ff079c", + "metadata_sha256": "eb1a31d36e18f5a6642387f4dd20fc860f9f26889284f6eb7a2e1ee8d387942c", + "realization": 43 + }, + { + "arrays_sha256": "569ae8f1a16d1639a788ee6e8f1fc2c2eaab934fe1acc5fafa9704638c8e4e55", + "metadata_sha256": "8d77cf21133a784cec69b3e0c65ff646aa72ce6e5cbff8cb907f5566c71b7ee2", + "realization": 44 + }, + { + "arrays_sha256": "734c979a770f410286b73cd76db4fabf6d194c27a7ed6a6b2185c08e84cbde3d", + "metadata_sha256": "396056b5b183bca93e3aed9444b3009810871894d7799d8e67bd6b7985b0a53d", + "realization": 45 + }, + { + "arrays_sha256": "cfba4ff746bae2892104da8654780901c9ab7ce808670337c3ce2528b62da246", + "metadata_sha256": "9c1ba26d020bdbf63d27a1038448c40c850068ee4f77d81b4b3390c24c9000ad", + "realization": 46 + }, + { + "arrays_sha256": "ed24695abbe170efa0613f9fdf240971a98a0f5a40782a6a92f8e6100d6c17c7", + "metadata_sha256": "969215461bf3db8badb6daaeb9001dd0f7374ce68410370b1651a03513cbe121", + "realization": 47 + }, + { + "arrays_sha256": "866cb66208a82809f74bb0a409d39b569e53e318f5265cad2db3acfc43e89fa3", + "metadata_sha256": "b7aeda3dc42b53110c706f52751318bba5b10392de07774d34aed63c3f758cb3", + "realization": 48 + }, + { + "arrays_sha256": "72db63adfd1167ecc2e5912f48d701073f6f8f4e5db61c712e7d7543fc8194b7", + "metadata_sha256": "298ceb76d555665228110ce4252bd971356e8931cf71a1d36c308ae7aeabb356", + "realization": 49 + }, + { + "arrays_sha256": "863268d37866f152cd5c9a2becef7237daadfbc2122f71c0e5ec10a4352c0ab8", + "metadata_sha256": "5dd525c35dca35439cc25619dae9a790ce36725c5096d8ff2991c70783e0ecf5", + "realization": 50 + }, + { + "arrays_sha256": "f85893e26963276b8367fd1a8b875204e6a7e891a887a9aa89f135b00c0ddf7f", + "metadata_sha256": "c56e1082b6f2084ca9efc53ec5eab9c96384bc55f86f84c353170fb4d2f89077", + "realization": 51 + }, + { + "arrays_sha256": "39448bccbc2120e74ac49370c97ad34efa9ff633431a29bf3fdfe55244c03e1e", + "metadata_sha256": "2a7df86b4bd372607301f9187c8acb4ac9bdfbe408f20be652494e65a0be55b4", + "realization": 52 + }, + { + "arrays_sha256": "f740c7eeebf10fb013180c1b2ba47d00456b6eccf1325a6733b4a301927a65f7", + "metadata_sha256": "ac8e0688e14e20e491e302f7d9a97b181238945e7c5b9cce0b53e0876a852b66", + "realization": 53 + }, + { + "arrays_sha256": "f12ef37df82b1182aed31c4092cacf8dff81a1645182fb3ff27f45d61b78adc7", + "metadata_sha256": "c650cd63c8c8c9e8ade52427356f9f598e7444ad6ced2c90d36382233e8ead3d", + "realization": 54 + }, + { + "arrays_sha256": "98aef7e4fb60148cc5e2cc3a7e2ae6a2c9c9af24b750e6f48438f35c3d25322a", + "metadata_sha256": "f149bee8d3985b364990d9f8f9ac5c928ea93199dc7ff01c84164b43a2a03a89", + "realization": 55 + }, + { + "arrays_sha256": "246d697b95feac151aa56b3c677bdf5c2b47a0143f05d110b1d17170c826a218", + "metadata_sha256": "cbecad8c707eee086fd9ff9e4dd96ad0c6c7e811b07277335b4359eaafcb0305", + "realization": 56 + }, + { + "arrays_sha256": "2c34ebd25a6d40d48060e94f157dcb4414994f131fb8f538c152580cee4afb2c", + "metadata_sha256": "703a4c7260a8e1371a4e25175d4769fd7b6bf50898cbe0fd8f5bc486ab24ad16", + "realization": 57 + }, + { + "arrays_sha256": "0c54da30c345a8193ca7073bfe6fdf8cc9ea93d6400e82cb4ad10f6bd1124e18", + "metadata_sha256": "1601c5a36a2db031792a851eb1f1e685c0213e9311747f46d19c169163dd8951", + "realization": 58 + }, + { + "arrays_sha256": "99ebfd4d0242ce2b513912e6253afb679c1f7ae184ad27e14866b4c09e9a931b", + "metadata_sha256": "d4de7ad8ba0200770e9612579dd6b13509aee46f62a1048be7ca9c29a7df1aa6", + "realization": 59 + }, + { + "arrays_sha256": "1fe481efd484f2edb5dfeb41cb670e5f0cc45274a4ea658be68ec9e67354a467", + "metadata_sha256": "466d3a9e1530fdd4e8d5dd51a7f855f8e151a158cd0c6ff60f6e6696430d781c", + "realization": 60 + }, + { + "arrays_sha256": "07a1df017c333c5b97c1500decd094e483ed5a7d767d5e8b5cc54007174b6b66", + "metadata_sha256": "e2eab424a3fde3a834bd6d89104efa1b4a3a6e6ee7152236817e57362b313e5f", + "realization": 61 + }, + { + "arrays_sha256": "0de1e1d2fc2d0cddf34f63904886e2ba75934e5f6b7eb1b1a797fadb8462bcf8", + "metadata_sha256": "fac4cbd109650d742ef61413b323d2d307e9958157a076cad34a50ae4c14d686", + "realization": 62 + }, + { + "arrays_sha256": "5b9fdf05a75a1655f2b2e86193142792bd62056eaf28955c087b3debd67f8a9d", + "metadata_sha256": "94aad428ec867a5a63956a87b0f4018e2012703493d2058b9a0fdbaf0276ea65", + "realization": 63 + } + ], + "observed_median": 0.3588778773960463, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3467447519390082, + 0.3720889925062879 + ], + "realizations": 64, + "sector": "central" + }, + { + "N": 10, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.14697176523695696, + 0.14827234254140156, + 0.15000030229188152 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.14946543883393287, + 0.15121420848794176, + 0.15313133957932945 + ], + "median_hodge_balance": 0.13837041292214186, + "null_banks": [ + { + "arrays_sha256": "12b2aea8b0f25d4e37de54a2d8d7d2c4eab4a5721066207ae19f1480d3cce29e", + "metadata_sha256": "096385775c25a0eaa3a603e27cb8fd7ac40ece03b484beb6e00b12d3cbacf7d3", + "realization": 0 + }, + { + "arrays_sha256": "46f8aa51afa24cf2599da43c40b1867acbe3f789b59474dd54c4630574a10afb", + "metadata_sha256": "1821f05c1a7c6d57ee6764f7f4520455b91baea5ac8370f1919fff8435964d2f", + "realization": 1 + }, + { + "arrays_sha256": "35369ce2d8ed039f0d3c43a487a0cd8fad32756db09b3e57922a8f41f6cb6dc5", + "metadata_sha256": "0fc09bfecc1047f3b80bd0bfe5ee945418912653bcbf3357472961927c0cd2d1", + "realization": 2 + }, + { + "arrays_sha256": "21c2d40a659ba81b86721a70df0a7fccaf088add28eb68f7d5105678eb214d39", + "metadata_sha256": "36e2341865c3e6f7f2d4b93e57eacf2d9f22ae6f3402fe6dea7c1321659d6704", + "realization": 3 + }, + { + "arrays_sha256": "eb2ea0964a7946271b4c379ea54739ee1a7667b18027c3457a0aea317ade17b4", + "metadata_sha256": "27eb716e8664878422bbe1bea34354fb381ddd73d1d2f7bc2c5bf215169296b8", + "realization": 4 + }, + { + "arrays_sha256": "2f56598860334e79718b478f3e760fbc5498ccd52b9a9be8c6dbf12e0383de5b", + "metadata_sha256": "5f98739127ab1b8e3185ef3bb0c7bd3980cc767f518845713ab17fefe85d1e32", + "realization": 5 + }, + { + "arrays_sha256": "e0c4657781c703a93d9e18adb77043aa4ccfc10c647bcddf6a1e450a13ad40ec", + "metadata_sha256": "2a4529ad49e2a12f83adac46a550d5475678119bc984e2490fcf55d5f3732e53", + "realization": 6 + }, + { + "arrays_sha256": "a9208214fc80ff18c84db0e4f9f940ef484bb3c626ff78dd89c985fe051d5593", + "metadata_sha256": "15818f4a5e7578535140ed773bfe9e7657940c977b8405238ee6ad570e642f51", + "realization": 7 + }, + { + "arrays_sha256": "4655a42985cf1632a52b851bb70da181a9853a293546270b2835679a4455e4c5", + "metadata_sha256": "6909efd1dc3805aa49aec5e178f30ca82fc5a387784e10b30ab6733b0efe3e1a", + "realization": 8 + }, + { + "arrays_sha256": "6779e66eb68f4ba8104f14e5cb8df25bb8845da890063b10988d4e0db92efe1c", + "metadata_sha256": "a9c64b326dc93b79acb345e091e61ea5f5f634621a9c70ae9978c51b35baedb5", + "realization": 9 + }, + { + "arrays_sha256": "125a562cd836a4d7e5df7bebd2623c1d6ea9b1a351a3e4b200f76233bb03ff4b", + "metadata_sha256": "53b2a48dd9d44e76cf1dc64b140a89aadb6af05c5265456c45b770efe9e9130b", + "realization": 10 + }, + { + "arrays_sha256": "a9b8f1359bd4d4f579390d73ae60f19ea0ed84ba8c5bfe2d45e0a71c4937c54d", + "metadata_sha256": "b2eca6bf52b5fc3480a2699e421433e0bc1e6cc097402db9a23ae081942fb6a4", + "realization": 11 + }, + { + "arrays_sha256": "643a1f5e202504105ba23fd2885f3d57d1519733037a7bac0c014de5ccd30e33", + "metadata_sha256": "90d9af159dde8837be965e349cd0d43912456379d5b6c3e38d252d45f39ea072", + "realization": 12 + }, + { + "arrays_sha256": "73fd5f5fd3d4b517002edb8e2917611ac3e2813e0073744818654716b93ed467", + "metadata_sha256": "dee843cdb1e4ed715e375c408a2c9293692f98dbd17fb399d3654ad152f30fc1", + "realization": 13 + }, + { + "arrays_sha256": "3d353a7b7538336d4bdf3e417d0fbb635db61d18f469a796a53a9d924ebbf297", + "metadata_sha256": "235074e0e468591ba3c42143ebcdd7f7f812b2c38da0421c8983b1a890138f5a", + "realization": 14 + }, + { + "arrays_sha256": "84c1934f9942559ed2cf61ccab2a0d7e6682d207f307a8c6cbefb8a7265a2481", + "metadata_sha256": "becb88118dd130f5bdceb85177e0053d4bda7915d3e389f00b85bd33f552c12a", + "realization": 15 + }, + { + "arrays_sha256": "f1b0ed773d79f7627c346c502cedd57363b6d385b53439edc2d67b0f6fe2383e", + "metadata_sha256": "49c789a1cf1f9d325b20bdafddd3cdf388f425f5faf3ff518aece922b5cef0e2", + "realization": 16 + }, + { + "arrays_sha256": "9d66ca2b1a01bffbc965a800bba375fa78d6e5f375c7b578de70e02f6913df9c", + "metadata_sha256": "26e262c8f7330a88d4e90321b567d1f20b6088c5bee43651f429802086591a78", + "realization": 17 + }, + { + "arrays_sha256": "0b7a13297ff2de604fb35e78b6384d13884c1d2237df1438df2c2ee7582a05b4", + "metadata_sha256": "2d195514c0099cf9c60f963fd03bc41febb77b6ced96d6c7c1d1074bb0f50000", + "realization": 18 + }, + { + "arrays_sha256": "a50aa65e007d522b09c6fd88a06c5fafbf7f280346b93ff6c110aba26864d9fa", + "metadata_sha256": "f0540a55516c8f7357048cd8d056b6536e854af5acdaed34a57e83d0f2bba69f", + "realization": 19 + }, + { + "arrays_sha256": "3aea56f3a003fa536ff7544db6befa5293c5e9a33ad0fc38c4bad822bbf070e9", + "metadata_sha256": "d7b0ec3efdfe5deae363edf73dd578709c960ef012bb54e15f72a63863c67d07", + "realization": 20 + }, + { + "arrays_sha256": "7c63441cbe5176bde7cd5047779cf302c6ff1ee181e83d25f8e40326a8a60626", + "metadata_sha256": "cead2e8046c8a7d9acaf3963e7a36fcc1e137631a2570e8fbe387bce86f9da86", + "realization": 21 + }, + { + "arrays_sha256": "baff01a4bc494c022271ce839415f394934e2e168bb5f2242e02999dda80178a", + "metadata_sha256": "93e404a4d338456dc53915eb62900b48b9cf6bb84fd956d696aae6ccf82b9e91", + "realization": 22 + }, + { + "arrays_sha256": "1c8c864a57671e3696ee65b8139d551c6c20c89f67224fa5afaa7c4356a26129", + "metadata_sha256": "72d822e26e0acc8c7fcc36be1a878ac76106a829100957ed1021eb94146f6664", + "realization": 23 + }, + { + "arrays_sha256": "e73f5723452c5fdf7e6b5d083bf6ebdb3e313a1cc58306e3d0bc5024e4177bf7", + "metadata_sha256": "01e2110361d9282aa2c2cfe557f71d70ecdfd244c2f06baed9b8c4aff115e9e3", + "realization": 24 + }, + { + "arrays_sha256": "5994338ed1cbb199452ce037ba54633ec67d3d09c81f1fdb2832969e32f8eef8", + "metadata_sha256": "65285447d52e355e3a46c3f656ff7c954f01c4ffe021ed41dfeeb232a5a4b4c5", + "realization": 25 + }, + { + "arrays_sha256": "a01cd7dbc759687fb8081d8429f858c58ed1a13f7fbc3186fd6ac4f525f9fc45", + "metadata_sha256": "3c3c2f024c9508d008a93ea6f5018e676992f65c72aee9e3c75d4ea36f4f4c9a", + "realization": 26 + }, + { + "arrays_sha256": "8ac0174c32277478e1e0e49f713daf70933c78f1f7fa603a172428e8b752f7bd", + "metadata_sha256": "60e5b08074bade17c6db643599ae62c24e7b826a587392c73666ee11c7939585", + "realization": 27 + }, + { + "arrays_sha256": "33a54db642b75d74ebbd68033f821e80ab769bee32c034dde78839721dfaa0a3", + "metadata_sha256": "9e747bd372473e73784b6eddb6435effa68d62127977ca1d608701cef7603eb0", + "realization": 28 + }, + { + "arrays_sha256": "4cd17fd2a37474dc639544d7ba76d2b6aaf20e8beec166885e4f3379ae2eab9a", + "metadata_sha256": "298899d5aff126f7710415e5a5655b12f88aa84c2ba7e62f9726bc3dc6a56bfe", + "realization": 29 + }, + { + "arrays_sha256": "e1ac23ac06bbef305b635e0d7642d002daacf36fe3e23bf569971c1770bce06a", + "metadata_sha256": "6c58bce1fad03b486bfee9784757e351f84efd3ad435d552a58e194e9e3ba4e7", + "realization": 30 + }, + { + "arrays_sha256": "b48cc123dd7b5fe89424c0cbfac81904f57d65255aded8ead256b5bb3ef36d46", + "metadata_sha256": "2593d5a3cdae4a757977a2c8446a0f0059df3ce69bae0dc78a6072fcd1fa6cfa", + "realization": 31 + }, + { + "arrays_sha256": "dcd780bab03e7857cad3cb893ca35c7ec2989d5283396ab6d651ac887e78f71d", + "metadata_sha256": "602356df0e9730daf183a2df12b18e50803d6b7e139a1fc4379684c835cd4311", + "realization": 32 + }, + { + "arrays_sha256": "7c47c83c5e7fa702563caa395391cdd77cfa0a23eb27ed9f218a936c0e7b170e", + "metadata_sha256": "5382638aff28a7e32ce3758fd3363d90c4831a992dcae1bd8938b6a06584518d", + "realization": 33 + }, + { + "arrays_sha256": "297f960c6acd0c6c81f6c86ed9ba1f8a722d38ff02104a797100b1fdcbb98864", + "metadata_sha256": "b37e364d071123fa78f76035d7049ec267991ec86615b9521d084a4dcbb1ed21", + "realization": 34 + }, + { + "arrays_sha256": "eb43158636cb7c8f7c63ee53b48d901c482b2edc9ab0068bcfb5176376742357", + "metadata_sha256": "b182b4485873baacc32c8a40e02b691e4400b213954dfbc1a5edba2cebf383ab", + "realization": 35 + }, + { + "arrays_sha256": "573d56f236645e14b69be907fd1f25e95b416cbfe9495fa101544cd37ca181a5", + "metadata_sha256": "57450a3a5cfdaa4b5f4ed4d92c17c082922f23e557ad03b0bfe501b6242e800a", + "realization": 36 + }, + { + "arrays_sha256": "de7a464082ccb24cc5a9732e4ac6af7f07e75e0f5c1225ce09ad434216816c4f", + "metadata_sha256": "4b36f182676a476416eaab660e3e10fd5450f20e4db7b375e935a56fc3ba6b86", + "realization": 37 + }, + { + "arrays_sha256": "7790c42e0d60d1253b52372fe6534e78150d62e8e863193183b77dfdf071f492", + "metadata_sha256": "aa74167d2c442181a19226b63888ef47660a8344dbd6828abb38edca4c85c397", + "realization": 38 + }, + { + "arrays_sha256": "50194676cf04da95725523f000510e099ff84459a9fb425fc674eeff997c1be2", + "metadata_sha256": "a9befda5e75d86a9530a96c1919656a72edface805ccfe06be00b84132c78cb6", + "realization": 39 + }, + { + "arrays_sha256": "dba4a33e5d8b98c3152b608a887bd662a6506efab93af68ca3b14d9f4daa1dab", + "metadata_sha256": "321c767d66e8690c733002e0b9ed6c6e0065fe93c4940137d38033b559608f21", + "realization": 40 + }, + { + "arrays_sha256": "b9dfbe2b3b469f9a9342dc463daeacdb8159c00faef6468b60345b90ce25c195", + "metadata_sha256": "a694ab12cf08d0e90d8b1b7500ffe84d4095a2bdbff8ce04cfe0d199f206f9f3", + "realization": 41 + }, + { + "arrays_sha256": "46a72d1f3510973b530e41c4185a2cc175fd7d77e8d212d04c998739084e62a6", + "metadata_sha256": "9ac2b100796565d2a18723a238d97d35967d95c97da67b1dd4bf15c9b99648a7", + "realization": 42 + }, + { + "arrays_sha256": "998435fc797756740e9c356514ab57421def6afa44cad1602434aca00e0af02b", + "metadata_sha256": "e934eda31f8536240aeb2a8a9f63b3ebdd340b81c3b22db26fa378695abe293f", + "realization": 43 + }, + { + "arrays_sha256": "4c02b0338af7f0737b94a983dee910f57a18e3ad21dd2e914e66aaa8486559e5", + "metadata_sha256": "69cf288c57dc179287144e7f9085ce5a4cb199c39fcbc3730674f7d214591f4f", + "realization": 44 + }, + { + "arrays_sha256": "d42b6fb27daef5ce654f9bcbbbf9fe9caf8a79152300f7d742ae84d992e676a1", + "metadata_sha256": "9d9dffab2d3a1a67bef4be9e9c67dc12078e9dd0103c1ea8b30a341a00fce9cb", + "realization": 45 + }, + { + "arrays_sha256": "189ecdd332b5e2b886d2700e61a5621d5dcaee5790e2dfeaecdd6b627eada25e", + "metadata_sha256": "d5a3ce2064579f826c627f8db5463179013eb8867720a9eda5324598a30dbc38", + "realization": 46 + }, + { + "arrays_sha256": "09ecc6dce5f394701cc3b7db5846bcd7b35242987eb14aea390cd0ab6a6c3c28", + "metadata_sha256": "22057d2289101a80946968abe9d3ef2965f352e3a4bc4eb8ffeaaaf32bd2a426", + "realization": 47 + } + ], + "observed_median": 0.20073119910082154, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.19694060198755714, + 0.2082583902883576 + ], + "realizations": 48, + "sector": "adjacent" + }, + { + "N": 10, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.15280228203687626, + 0.15413349564490572, + 0.15571959826527199 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.15816799904416937, + 0.15990057317658485, + 0.16185676188209575 + ], + "median_hodge_balance": 0.14001760189653722, + "null_banks": [ + { + "arrays_sha256": "9284b0988e141ae56c0026e6ce6eacbefd7ffb819b35c41b1ace35e41c0f7f6e", + "metadata_sha256": "01b84ef06849f03e7dd25bf0ade77ff412d37ee4fdddddd85e2ed9b5aedd1c2b", + "realization": 0 + }, + { + "arrays_sha256": "a01168139ad924c7fc9a3ffd576bb2d96112baccc77661db17a0d27e9c6900c5", + "metadata_sha256": "c7ebf0eb554286b929f1505ba3eac087d89c5956660cf07449c310534c0ab4d7", + "realization": 1 + }, + { + "arrays_sha256": "658d113bc8e2bbb899076269de7c799258fe24d3e66d133bea080c6fc18ea630", + "metadata_sha256": "296402f3f52312ff3c3dad2b9af8c548d72171ab8bb15fb638218e38356fc370", + "realization": 2 + }, + { + "arrays_sha256": "5077f1c54c410375e423304a662cc3fa271dd08d1816f88167ae97764056e729", + "metadata_sha256": "b9d7a99db92f769e01466f196ccfa48b1626aa7799e0a621cd1d8642df3bb2a1", + "realization": 3 + }, + { + "arrays_sha256": "5929350d2b8f6ea0cd44dd0ab7faef26a2969c9940448254d2d14243f5c2125f", + "metadata_sha256": "4d4e2bb8aa8502b1dc381702ad4cc9886b7d06669babfd3c7d18fbc12118a278", + "realization": 4 + }, + { + "arrays_sha256": "c902f47c3f8042f3775a0678cbfd3af42f9e6003e5e99b8d13a611faaa456447", + "metadata_sha256": "749a3feba16ba6331fdeceaaaac6260d26b623dae9a5bc2d356281afe626d1e5", + "realization": 5 + }, + { + "arrays_sha256": "035e11dcdbfbdd8cc93c812d36633f43e84a0ceffb8c50ff7f3d9c4b9d1e5383", + "metadata_sha256": "de60a45c4c800a18fe524f3efee7ac5c3e353d0f8f403427de7c2ce754a7b2d1", + "realization": 6 + }, + { + "arrays_sha256": "04426533bee5b502955ca337218ed5945da95d41db81fa37a10d880ad0638b9d", + "metadata_sha256": "294d142e6b88328a0c02283477e034cc87dc146e05b2ac022078b70918ccd0c6", + "realization": 7 + }, + { + "arrays_sha256": "f52a0e1dd1840a51d4b9b66d868b468375738af500b11bf9f2b78ad1ec4bd9f9", + "metadata_sha256": "5195af065e67b5f4d9697ad4a89356fe1dabce2920d40819d0f8c172437f8a24", + "realization": 8 + }, + { + "arrays_sha256": "e37416e0afc53e319ab094692423c64702515de576610439f440b13985a27c0a", + "metadata_sha256": "0f904de501c6d61338ed2a4e125c72029dbe23fcf140c90e49a7fe0199a7739d", + "realization": 9 + }, + { + "arrays_sha256": "7bed9b3267715f633a1cd739a63f7db710732236581378bc8c7e5dee0c0223e0", + "metadata_sha256": "52fba6e27c671a5e2962c8c868de81bafce9add722c1097db7dbf8c922febcf7", + "realization": 10 + }, + { + "arrays_sha256": "607e69bea29a108b0ee850c1b22d53e1ee6a3f6a20856e2020babd6f755bd576", + "metadata_sha256": "10e5cabc68d1a1d1f684a8e15d19c048ceaa9a1c3f0394d1616c7fbdefc1acd0", + "realization": 11 + }, + { + "arrays_sha256": "c90bf2f85926ae5fd48ca48a7d5787f534ea1085d065b58cc939ec0b1cc4d5bd", + "metadata_sha256": "48f0f3f167281aab5fb56209e57a3a60c1ab8e651407166e5c7f25bc2618e0ae", + "realization": 12 + }, + { + "arrays_sha256": "cdda9d36d01cc1ff0dd7e9a044cf207b734543bbe715358653baa4e2b8a71e75", + "metadata_sha256": "6abf55a0b06e14b6cd882757a76a4b1261993b49c2a231ca3ceaecb91477ed8c", + "realization": 13 + }, + { + "arrays_sha256": "8f6b685360a1bab4bfc4866803a5f7fd6de701fa300589bee517133d7437fda6", + "metadata_sha256": "cf6322789dd38a3ac11f8d6c428606aaffb97d279659f40d7ae84b5f40042ea5", + "realization": 14 + }, + { + "arrays_sha256": "49c25d7c03ad18b07d4e8366e72d17406eb92a6498cd107e32bac7d1026a1dbc", + "metadata_sha256": "5c4acb3040ae5931242e53076f34e8aa9e7d5da2d7e6223e70c0dfb6c4e2bd9e", + "realization": 15 + }, + { + "arrays_sha256": "c962154657743aefab10f9faf2cff2439b94fc719e9bab63cc7da5e8a85902ef", + "metadata_sha256": "54604647a600a266a8f8cb8ff0f9c3406701211235e596041e4aa574ab4190e6", + "realization": 16 + }, + { + "arrays_sha256": "9e20c99cbd03ccc3da32e5378c364e10e7edec86a4ea840ac72c19331cc66448", + "metadata_sha256": "43d578481b58774f81e3dd08b0dd9c6f8edd7f1c84dd14fd4d0f3dd97513d9bd", + "realization": 17 + }, + { + "arrays_sha256": "0feb5c975d261997277ed835d26bca8051c1a45f11bade2cf1409fcd7ad6f0de", + "metadata_sha256": "8acdbb6edd84569a809269b4a0eecf082cce1f74e638706a3a828cf7978e244e", + "realization": 18 + }, + { + "arrays_sha256": "818362eb96103350295ec264bef0d1a9547ef189d55b07179314e850bd9b68f0", + "metadata_sha256": "ed9089926a588ad54f459aa50ce2e328b010d065ff4ee7e5f8bfede56a863aa2", + "realization": 19 + }, + { + "arrays_sha256": "90592b7e8fa4af46e9fcb117a5fa7265bcead6a481322a76bc94dd94c1732e08", + "metadata_sha256": "ab72fa4a80d5eb28b43979883887761649bc08a105e3fed64e4c8539d619aa86", + "realization": 20 + }, + { + "arrays_sha256": "3f1f9324f167d052f4289e7e5ddcf33f65d7c39b11618f312e147231aaec867d", + "metadata_sha256": "9cc5e663816defedd1eb59387048caee601a5fc8406f7f8a27f0d1f967fada47", + "realization": 21 + }, + { + "arrays_sha256": "f63b537796ff5d845243aebad44802c3381b086e136eeb91eef38007826c916c", + "metadata_sha256": "3677817b98650cd8087d33a4cf9e6d33a0f58360ddc297b5919ac11bc88dd3c1", + "realization": 22 + }, + { + "arrays_sha256": "700414986e6d4f26d021911ad70ea4a67843e71664780f59d74d7d4c7fb66a55", + "metadata_sha256": "07070d6beb67c0c657e7c53ac975534e94a3077b311ad4cae3f15e9810486198", + "realization": 23 + }, + { + "arrays_sha256": "2101284eb1e9d396974baa01bd416e5e36b119168155c0b59e36dc3d5674c6f5", + "metadata_sha256": "a373793fb6734c03cb792bccfdcf15e2d66137bc8be04114603f5cd62ead705e", + "realization": 24 + }, + { + "arrays_sha256": "0989fd6202ce8f9d0dabae7fb6a0e9ae64e525eea6e918b75d28758995fc24b0", + "metadata_sha256": "696e4f615e611d90bf58c7b2d1f0777f41dc6f723b36608b5d5bd20f09537bac", + "realization": 25 + }, + { + "arrays_sha256": "049ed873cd174af091791aee7484e33ba91e647eb7dec835181021e6d4be8b89", + "metadata_sha256": "7461d273c379665c3073d0a42b54a2d55a4d280cc6999c181324dce3aaccf3e6", + "realization": 26 + }, + { + "arrays_sha256": "858274e0c651a71986a394fd336dfe4719cd051eccc8fd3c423afc2602e61423", + "metadata_sha256": "2e2871109167deed5011dd915b96135a1f7ff5d1ded0b76092228fe85c2a184a", + "realization": 27 + }, + { + "arrays_sha256": "079bdfe07d0d8231b875e7f44180d09b66c4614a7fd265af91c24a906ec8b9b8", + "metadata_sha256": "c003a6854f0b9f4c0f6865e63e9a24c77df96928d8e5605466881fde92c66f6f", + "realization": 28 + }, + { + "arrays_sha256": "eb6b1211b970e9f20486b1b89e8a7be00b8b34cca7e526610c103b0dd60a96c4", + "metadata_sha256": "b426dab9aebdeb2327c61b29ee3a0453fe4e2b28af5041d5fed2bd9c85838c32", + "realization": 29 + }, + { + "arrays_sha256": "5c0463d69525bbfe1477475715aeccc940d2b5a4b3c6b4aa6e42cc6ae7e3a51d", + "metadata_sha256": "152c947701d398229f057ecf8e43dd1e002a035f97599a14e361d88adac4b371", + "realization": 30 + }, + { + "arrays_sha256": "6daedbda474fc23d7bfa0e1919c439ee45c58dda62827e79b2cc79a6bd2ec974", + "metadata_sha256": "aab528d9c184ffcbd8081fc3e6ad7cb81912d104e918b0b7ea69f2c539f44b29", + "realization": 31 + }, + { + "arrays_sha256": "e10d99e2d6db4fc6925d16bcd2a0daf60ac308ec9dacdc982bec0c02be55ba3d", + "metadata_sha256": "e4c056f6bdc271e01ca95a47706a32f1ae148d120bd95004bba31dc16922ecb8", + "realization": 32 + }, + { + "arrays_sha256": "4d568cf6af94de66c10f34e3fc2e6d140ef9654d791ca7fa3461f5f065b80c64", + "metadata_sha256": "48ae8699d8da1de246622fb23cb1477a01cbbf39e04fc218d5952a0e9829e901", + "realization": 33 + }, + { + "arrays_sha256": "178af73ce22f57312650c04c92f9709938bad45a5ada2c9070a3adf24c56ae52", + "metadata_sha256": "ce51eaa85723eb5dad748757e8a7eccd69132141407e78a0ca0e20b03cd90ae7", + "realization": 34 + }, + { + "arrays_sha256": "0fee466b906b2527352e900b7d0440e130e674c72d9013e14549c15a89d93450", + "metadata_sha256": "e07d1cf107aa6e20bd135edb834c78de6ccf1110b588a5f72a423e6a66d47afa", + "realization": 35 + }, + { + "arrays_sha256": "8b891db7614e7de597b408500e86d58c6510139ae270a54ee2634da5f6eb5732", + "metadata_sha256": "8fa56343dd6dcef976534166a9a6351e365a8c983e8570c014372761cd6ab5da", + "realization": 36 + }, + { + "arrays_sha256": "46ec153442ecdbeb89ed7569ab3bcb6ab896e5b8f31be5a881b011a7cf5e4cae", + "metadata_sha256": "3f7b72641781c099b16498c62362f84fea37fa9a7cc7ade54e6ca60501cf0667", + "realization": 37 + }, + { + "arrays_sha256": "40567e7e2644fe53ba0942c4a36f6320444767f932c3c032644d455605e3c703", + "metadata_sha256": "fcb4bb80a664c323dc49bd525d810ec7c25212933aa3731638efa4e6c3ac9710", + "realization": 38 + }, + { + "arrays_sha256": "1fdcc452e4d83c1dd47505fec52dd70aac613661ccd4e8dd53621ec5eff5d0be", + "metadata_sha256": "1185a5d5673dabfa92bfcf44bd41fa685aea9f34ac827e9d0aac6575be6124ea", + "realization": 39 + }, + { + "arrays_sha256": "23cedf88e7d817442583d36f62ab42928b5987bd435e64eae49ce7aaaeaae2ba", + "metadata_sha256": "ef9cb09abc726166efaf8d7cf4f175c5a5dad10ea260b800b8ee080fe426ec29", + "realization": 40 + }, + { + "arrays_sha256": "4bed72f2e140b59acaf13cff58c06edf0591278a84d0fab475d4c340e14b104c", + "metadata_sha256": "2b7d00e86392808900d473163590ce0183efe75e0bb4dd91873005a729473253", + "realization": 41 + }, + { + "arrays_sha256": "6d9ebad14f6b3a70a1348ecbd83c75249d8203ef54b0eeac64b66e353104958e", + "metadata_sha256": "28fb4135a013b7c93e0dcf14e1c9fc405d1a38b5f7936a1075690fd59e44fb51", + "realization": 42 + }, + { + "arrays_sha256": "d12b9fe842d164e1e3101431b94ad88f8c68a3f07f56a3a13490f74db467bb9d", + "metadata_sha256": "37856a4f2af8f7b4b44f644f881ec6f0e81f574addb0563f0005d4dd0ad788bc", + "realization": 43 + }, + { + "arrays_sha256": "23920433bec92791aa605dd22008504727bfdce1913220b6ae4461649a022967", + "metadata_sha256": "86b04efb41dcbb82b2789fe63d3d147acc936e156f25917a4ae788b5fc5d528c", + "realization": 44 + }, + { + "arrays_sha256": "3bbfa7124542fd0bb3d6215df3dbea093e904797c203ec153fc143c38724ea16", + "metadata_sha256": "7f64057f0f5e27334b4d76276dd4016957d912a4ad0e45f6ad6c50b71f93e07d", + "realization": 45 + }, + { + "arrays_sha256": "09b0bc3b06a04f12a8f67fb8eb4afd2ae98e4ebab403205ec913b03aa230f480", + "metadata_sha256": "053e10c4e695dabff57de936a06090fc06a846dc4e6951a7b74cb64fb00e8799", + "realization": 46 + }, + { + "arrays_sha256": "5e9dbdd6e6cdd0d004befd8d761e1ea006cb6d52e43eee453913e1240c9bdeca", + "metadata_sha256": "337c99f8f2ee3597085605255e4c9a2fd5493b988b16819d5bfe8ac332a0b614", + "realization": 47 + } + ], + "observed_median": 0.3326829386707436, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3277302349036726, + 0.3365367304550048 + ], + "realizations": 48, + "sector": "adjacent" + }, + { + "N": 10, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.12354756576977215, + 0.12380059338068258, + 0.12405028033654811 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.12469691271184806, + 0.12496969707954547, + 0.12524599110490295 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "e374e8a2465a8ff0971bfcbc083a0e0b76f35299864d606abd0aa9d0ec3fecc5", + "metadata_sha256": "bb886102b81857a37cd6452c9f15eccae77638db27aa1cbad6550316a8b4fec2", + "realization": 0 + }, + { + "arrays_sha256": "eaba9a3efe1db6e0d0a4161cd6934427f172d8b422e9ee5c625f048f8326fe64", + "metadata_sha256": "3a2ee0389be1e8700b8990435c8c7fcdf8467a5706755ccee810aee1c9de85ed", + "realization": 1 + }, + { + "arrays_sha256": "6780c8f83e0eaaac3d588e847cd4fab6ded83fb0c871714cc6630fce1be31c18", + "metadata_sha256": "9b7b1124c8663f220639155e5f36301614b4f1857200fa86039879a76b10202f", + "realization": 2 + }, + { + "arrays_sha256": "58371ece7bb623d456192257b6ff64d928d23ed5401939be394210d1f775452f", + "metadata_sha256": "27b22b34f5a870f10042de975a200bb0b2e5e4372e99a15d17511948fccadec0", + "realization": 3 + }, + { + "arrays_sha256": "396f64ea281b2fb856d9a5237b9acf332a6ffae6a750f181df27e0fd3f56dbe9", + "metadata_sha256": "f3a49baea40391394f249070b2875c4a5701ca68b5b83527686c362d121fc45d", + "realization": 4 + }, + { + "arrays_sha256": "48cd57eecc72be0537f9b7be14ee306b28729e2a8a1f5fbd0d79957405650eed", + "metadata_sha256": "39778696c9f6bbf34c7e45d8134ebd90eaaa99e56d81b84bd8422c4af7a97d57", + "realization": 5 + }, + { + "arrays_sha256": "8a033441ca6b320af8319b70c25731a2b2c729091a734323faef8396fe886e1e", + "metadata_sha256": "762c5f846837dc9a50b8bd6ce978179c23626f78b52ad7665eb2754964f075aa", + "realization": 6 + }, + { + "arrays_sha256": "afbb53e999493fad74e3c698a6f04bd21b06c3da9d43bf372b7213d191c7c67d", + "metadata_sha256": "1844b88e7d30a3abe21c8e0eeeeb6889beb148b6dc2ce91defe756353b6351db", + "realization": 7 + }, + { + "arrays_sha256": "9d3f0988f65a5f85349cd27707e4ef6c3f630b19e4be3f67ef28e4009d50e8d9", + "metadata_sha256": "e98d06856ef6eec0d7d3c56bf9bd9bb07d14a80c4206f743283b1940e847e5cc", + "realization": 8 + }, + { + "arrays_sha256": "778fb26f430cab935d6a13d35d6758c5e3f005f8116942b6f8498dad2743a979", + "metadata_sha256": "c0c8450313a916287b689c036e07ac2276383f488b51bce5d64638dfec5ec514", + "realization": 9 + }, + { + "arrays_sha256": "250e1b91c4c6a52348c930d503f45970801ec8bad0d2baa59277137834d0344f", + "metadata_sha256": "cf3ceec74aa9feb31dc352f79588d1341c90bfd2cb7e0425794e0169206a25f7", + "realization": 10 + }, + { + "arrays_sha256": "b23bcb928cd09156e6c53d5e940a914fc41cf2324c1f60e64b9753fcd2558d24", + "metadata_sha256": "4f83281cd78b619d2d2f3c6b003a28f72fa587cb6399e18ee33fab7aa9fee2c2", + "realization": 11 + }, + { + "arrays_sha256": "9e19c2403c197ba3d19b6d8535846d3af0d3e6eceb0c6e0222f7aee429d1aed3", + "metadata_sha256": "f90a4cd6190d3aacecfa4f14b95944a6c37797bed1c5a5a60f3df0f64c786b5e", + "realization": 12 + }, + { + "arrays_sha256": "14dc37e540fccfeaeac4c2937cc97aefa139a9343c92478853766047b6f80c8c", + "metadata_sha256": "914098114a1f6bf6519db2093f7714b2ff18e91a69672630f62553d504e5dacc", + "realization": 13 + }, + { + "arrays_sha256": "3a5e6262da3c7543d61c82f6ec01824746bb650bcb373d642226fe75cd8e0e7c", + "metadata_sha256": "eca5dc3575173b540305de3fbb2515d344ebc9f66a6349398a7c86a7de8f2e46", + "realization": 14 + }, + { + "arrays_sha256": "1cbeefe4f3e98e71baec74ae793c910b34a84651f3ec0b888be4a38e9edce29d", + "metadata_sha256": "53f945951e3645a7e1825d31129fbaf1e5c922737277f7f025e0036b0dccc8a2", + "realization": 15 + }, + { + "arrays_sha256": "312c29c4c288ed3c10202de685dbeaea53a8a5af6454353ebf1eefe005d68fdb", + "metadata_sha256": "8ddafc6922d0f286f006b447e65a315d5b2a11c9cbae7d383bedd8ffe2579e29", + "realization": 16 + }, + { + "arrays_sha256": "ff1168237887749e564d1c1c4d824e334bb8b064f856e795b130418575ba2f38", + "metadata_sha256": "22c2b2396f085e89b802987872d10a87ef3e73517193c993eab025c15fedd998", + "realization": 17 + }, + { + "arrays_sha256": "74bc5811f2e04ad11e8d96f9e6c2a4319920479fe194232821d67ac62b785e8e", + "metadata_sha256": "065204689624be34c89cf390b45912efd1ece4de39339fdd81852c1f819b2875", + "realization": 18 + }, + { + "arrays_sha256": "3bb10d1c8becd00726dc0f72c2c1ae212aee5f0439f0cef8a188fa096bd3f4ed", + "metadata_sha256": "34e88643883a522771adbc853d857c958bf27837cb952c55d01b70d07ef10040", + "realization": 19 + }, + { + "arrays_sha256": "51f28a66f9ad9df092bb987e7a97b6c110c1319a41e9ea2c617aef7ea1027cd5", + "metadata_sha256": "5faddffe805980894ed92d3b23ba9678fed329ac14154c390faa6d534f1548ce", + "realization": 20 + }, + { + "arrays_sha256": "bcc77dfc9e93cea79930fb88056a7c0106744fff4d0e06e814555c83d58c4de7", + "metadata_sha256": "a9c3aaa98ecf5bdd8bd4ab8e7d226b10c087a9e056a9edcaf7953118f648d0a6", + "realization": 21 + }, + { + "arrays_sha256": "ffe8c6959e54860c70bd939c592316f3517cd1243412df64f1181078b8ca3c76", + "metadata_sha256": "60adc1f14ac0b418a037bbb96a24f818c7e635056cd374b1d6b8fe6ddeb6ff08", + "realization": 22 + }, + { + "arrays_sha256": "c9544bd44b9103d9cc01153a31747317f52674997b156c8adda63017eb1f57d6", + "metadata_sha256": "7fbe5c7a8622cc86c8ec043217d0e2be9a3a56a5b93eafddf951ea49b4cf8719", + "realization": 23 + }, + { + "arrays_sha256": "a025c6197225c1d5d5175de6e005e5baae1699b06c43989d3fefcfb863abc6ec", + "metadata_sha256": "40c7cfdd5e431c14935eaf3e0e2af39249a2448a9ac3c7328584fb4c099a10b6", + "realization": 24 + }, + { + "arrays_sha256": "5265ae4b5e9e24e6e8376ca10e056f454375548e162d5f6175f6bd0ae69137c3", + "metadata_sha256": "138cd48bd79f156f2b02fae3e5aba74788195487810b0a64448f17ffc7b5c271", + "realization": 25 + }, + { + "arrays_sha256": "2e128e809b610e9fe0556061ca92df05fbf5af78cc4a22552a74366fd28768ac", + "metadata_sha256": "c80860c3db0e5c9af4f91a99f34f692f0dc607b60741325caea295924e8561e7", + "realization": 26 + }, + { + "arrays_sha256": "6ea77a0ff7d413aa4fbf26d920a27bb5cc8e49613584c8f1e3fb160005df72a3", + "metadata_sha256": "ce7878fd47ccf3a5d80f66e3e494472cf3469a5ecc8b6e40d8cd967d94dffe95", + "realization": 27 + }, + { + "arrays_sha256": "32418286a65666117d98720a86a8f9013251306dc797ec4477f0d87898b255ee", + "metadata_sha256": "878ada5a52c2aac8323c4494afb2e228e127f262ae14bc273bb97c5c0a12622a", + "realization": 28 + }, + { + "arrays_sha256": "ac8b92464cec21c1d1114791662a5391a77dc76472174ed7f6724d38138fe1c6", + "metadata_sha256": "35e3259c604818000290ccca6748cd4439200e9de8beceaee4a88da56408f9f8", + "realization": 29 + }, + { + "arrays_sha256": "12670943bd38c8bb3b2713c1277b56b81b4b446888774df319510e0f7eb53cdd", + "metadata_sha256": "793b528b771502d4870a261e84c577ad40bd5b2d2976defaf3100b9991083dbd", + "realization": 30 + }, + { + "arrays_sha256": "55960c3bb024ec551437e03cd27e69583784bf2d2e3e2dfd45df5d3bde584d0d", + "metadata_sha256": "fe896a8f67a2c9b010a835cb1b841d783c561eedc916f3b298ae2fb817dd5fa0", + "realization": 31 + }, + { + "arrays_sha256": "c58f82bc7c9f0f013deddffe9a4e97e0c9c0c8c8a2360d4eb3906324eb3405a6", + "metadata_sha256": "c26ab338b7cc894cbb84e05fc277afe838f4283a747209f8a2796006e4ad4335", + "realization": 32 + }, + { + "arrays_sha256": "5bfa17ed40d66293267c04ae2b566add94c00b46e0bce35ff5e68943de0cdd99", + "metadata_sha256": "3cbfe9e7fcd592d8185ef198882629662a2bf05c1ffce62d2cd0517b2324ed0c", + "realization": 33 + }, + { + "arrays_sha256": "76b172330e9341e4a48a5db47738e61d4b8f0b0e31926e1fd892cd0edc744e02", + "metadata_sha256": "a5bf0b90b79a5e38b68462e71b5f5aae5c41d9bf720d85ec7d61c5dca9697b00", + "realization": 34 + }, + { + "arrays_sha256": "98880f7f9a07c61b87fea38ae14d16de6c6409f528025ead4797ce7f523e1faa", + "metadata_sha256": "085ed88c153c478648f370ea158faa5c0570a0532407d830bde23f7ac6f6e1ef", + "realization": 35 + }, + { + "arrays_sha256": "2ce91cc906c21847d5bb14efa4d8b96dd1c8eed5edba64301db20e2396960b02", + "metadata_sha256": "5fb0b6d81c87ff320839a8f4a164ca269ecbb26275c6c6fc0a9faa1758d01235", + "realization": 36 + }, + { + "arrays_sha256": "a3891c1985bf14574a0a6c7cc4453bcb0f1c758e7bb4f53313a113524bbf087f", + "metadata_sha256": "eaad75ab2b69839c7c1a3490dda86cab1e78edd8786bb696ba01fb72060f95b0", + "realization": 37 + }, + { + "arrays_sha256": "9bacbc48e6b1873c7fa8cf1c4ca7fb9bb3b2c1b7ca0691ace64ab093cde20666", + "metadata_sha256": "031a1e0bbf2f80c81224e1ae001de3a970228c60fd6f887ae19809b1fe59bf90", + "realization": 38 + }, + { + "arrays_sha256": "e8160da407915bcf201080004cce8f1339fd0c4b5a6e5416de849983388021aa", + "metadata_sha256": "598841639bf4cc92cc20067a55b3d7d6d02835676f5f1031212416065f64f6aa", + "realization": 39 + }, + { + "arrays_sha256": "6ada7e0ccdbe1b1b58825ce6e5b938b9ef43a893b3d14f0e9e7bcec2dd8258fc", + "metadata_sha256": "250345c90a0039abf1ae28d6ff9597cfc0bc6415c849fa70c6e976b2f6bc78dc", + "realization": 40 + }, + { + "arrays_sha256": "a28a23913180bfe39a0bd3b7b3f15e2b9580ccb0c4ba2c0a92954d477f322c00", + "metadata_sha256": "2e2a90bf9122ffae79d5265917233e9ecf6d9bb528ce555c8bd938e7a0052f97", + "realization": 41 + }, + { + "arrays_sha256": "86f40423a2040dcfb1efb28bd13e9b1bb15d3cb701844ba4e0e204ef0dc17c40", + "metadata_sha256": "933b4d31ef2678ab5bd115dac8cb08b3f5eac769410bd93faa6b0e74059d48c2", + "realization": 42 + }, + { + "arrays_sha256": "d18ea3ce9aecc5007f983d539196105ae72b262c632f40057829decd6ccec0f0", + "metadata_sha256": "055f3c606758b5eb37a8b2fc327a04406ad37b1103717f1c17c5761c1ce68696", + "realization": 43 + }, + { + "arrays_sha256": "1c17df8e6d4af3ef7e01025473ae14bb7f892edcf10c88355b33fd92c3be679b", + "metadata_sha256": "7a3fc77882896c9f926def21fb9548cb58e8992fca5ccf8d2eb73420c00fa5fd", + "realization": 44 + }, + { + "arrays_sha256": "b74faa75df7585ccd3211d2de3ffb4f309e3a2dfcfbfcaceda2da6dcbe9b0468", + "metadata_sha256": "83e9669bad211f3a217487ad0a8d7f15079e41d1b9bea359febd9bddc62f2a46", + "realization": 45 + }, + { + "arrays_sha256": "4c7b2ecfdecaa715c1d5781462c6fc05937ef0a229ee3d15ccf6d5014b466d95", + "metadata_sha256": "d8012490610fe667c0d9c5dc1273577400f80855596cdb01f5ca83ff53277328", + "realization": 46 + }, + { + "arrays_sha256": "73672df8b422e7a80f34e2faba193f95b1f9bef08efb5020aadab7de50ab9048", + "metadata_sha256": "2b4910be086f22647812de67a919a90669697eb2ec8a622fefaa2debb677d08e", + "realization": 47 + } + ], + "observed_median": 0.18385937035136762, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.18307874781812727, + 0.18436442290778826 + ], + "realizations": 48, + "sector": "central" + }, + { + "N": 10, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.12719097687925934, + 0.1275507134996125, + 0.12791357917909646 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.13031001749502513, + 0.13087028005219342, + 0.13143794811300344 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "e8bc5cf8c42d760cb0e01aa72c959c2ccdbae8a513899aa6edf715589cb81d7e", + "metadata_sha256": "73465ebe969142f5f7f931eb90893d6d1a48a573ac5422397ab321f295591efc", + "realization": 0 + }, + { + "arrays_sha256": "6b5c8e95b379ba6ce62a17e8c91f2ca613ced06bdf4a2f65edbc38d7cd379c4f", + "metadata_sha256": "62a03dc6a70a6aadb09f9125977a76eced0617a88f5a25423cd8d0abc9efc540", + "realization": 1 + }, + { + "arrays_sha256": "8956a56500f112f4441c2cd62fe8dc2fda5fee3f824feffae388f96763fda793", + "metadata_sha256": "c76389d496a0c1110faea57a806129c3f7e07ffcac8df9d75bbd9317acb15e8d", + "realization": 2 + }, + { + "arrays_sha256": "450b275af961fc110d170e061a7c38f58e8ba6a55fe2cd0ba3282d3052ccc8f4", + "metadata_sha256": "99f6f1bf8e9158612916fd947484e42153413fb32b63b6c4701f9feab6baddee", + "realization": 3 + }, + { + "arrays_sha256": "198fc065df71e865d266b05fd06f9461c8fdad9aac086b1d3fdfbc8d8ce38941", + "metadata_sha256": "7830c99f9ebc50f4b3c6c76042bdc26ac640cbeacba6ecaa67ec848071a8b632", + "realization": 4 + }, + { + "arrays_sha256": "0d7551808d971cf3be0715863943a3603cd98b96d44de5c3a648a1f79214b328", + "metadata_sha256": "ce8573370a89ee7e3e052ba4c7ab7fc146523cbfbeef3f8eeace1eb9d2fd8bf3", + "realization": 5 + }, + { + "arrays_sha256": "a0bb1093426b4637039f5247c6cd77b988ebc952f06cb53d871ac3e7ec59173a", + "metadata_sha256": "e355e05d6826f10b2d8d7ac70bab68a9a0250ee9330f173c303274a68175b5c6", + "realization": 6 + }, + { + "arrays_sha256": "4d93211bf9df5b205b561d3aa4c3f9476f0659ab438649e6ef2851f00d9a679e", + "metadata_sha256": "001d4a52c63f96d782511375e89222890273ca2b077c0e4c227fb4011c786b11", + "realization": 7 + }, + { + "arrays_sha256": "af99d83e08d4b7d6aca685149d8e0e649597feff8c3deb4ffb1541cfa1693397", + "metadata_sha256": "eee4e84a6b28f99de9263e2a68898de6d7156be7d86e8eee4b99d47d72a4a11a", + "realization": 8 + }, + { + "arrays_sha256": "54cf02030b055f806066b98cd7d6983eefed5f06d43a36126bd049218e29f04e", + "metadata_sha256": "242d08aee58cb3272eaa457a3dd1a1c1f9f39750658084dd6859ee3402c4e81b", + "realization": 9 + }, + { + "arrays_sha256": "48beaa7d146c6b9f1da93b649c3fdecd24ca5f7910622db359aa473cda9386d3", + "metadata_sha256": "f0abcc47b3f3b0106b1280898b2353d3b9f611d531851ff0d69252c10915a951", + "realization": 10 + }, + { + "arrays_sha256": "3ca8dfde3f04597fe6662d556811b9d5b7f8dce25dbb32b3e6f4c85c0f8915ff", + "metadata_sha256": "664c4adf6b250f757106b1329cd39a339092a1f20cb6bf74eb4ef45689f287a4", + "realization": 11 + }, + { + "arrays_sha256": "46d8cc1895dfb3f23a3d38d9a472afa2949ccc30248ab2fe873c68ae7f98e664", + "metadata_sha256": "77f84d1e54e9d0e3f0c8322a9bfd7e3c209fcae6ed18a25eb61a1071b34c3d13", + "realization": 12 + }, + { + "arrays_sha256": "e5c0fec56248acde29cd89410e250d383b71d481d3f1722cbe38b724bf196db9", + "metadata_sha256": "a7ecd7067d634a64885b7f99fb0f2ae2af9293c6a4203508d9ac11b5ca8b9ed1", + "realization": 13 + }, + { + "arrays_sha256": "1dc7a051012e609eb64a4b4813d77a41a313ad4e9edaa4ce51c0137324a640e8", + "metadata_sha256": "1c0108ba74a8a36050ca56813ee0679f8904f54e230dc1751efd1b30b1a2992a", + "realization": 14 + }, + { + "arrays_sha256": "f1109359c382de232a439da5bef4e85d577e06abfe8af875fa7fdf0c879b4fe2", + "metadata_sha256": "953134a936a077362d02c4a157d2a4f33041dec10f7098a123e094bb1fbd239a", + "realization": 15 + }, + { + "arrays_sha256": "934d4737a8942f93b32e8cd6cd1e623c843f52c1ad6e288d6e12f0f9f4fa96ce", + "metadata_sha256": "96de573f87b2c77acce78e1be1f9807b44cd40a3b428306b7f6370e23f233e10", + "realization": 16 + }, + { + "arrays_sha256": "425c0d1a3fcbc46a4b5be6c286822d593b67c43cb58332787c24337f0d2588df", + "metadata_sha256": "2e1a5cce290bf92a5c16bbf0910ba0b1bb1d08bbca18d23ee44de213c6ecf2a6", + "realization": 17 + }, + { + "arrays_sha256": "1a7c690565b7825e40058b77a81e64e0099451c96a5ce8a04a912a77ea277abf", + "metadata_sha256": "5e234d6fafee06dc8c97636f00fb881df8b3d12d97e22945d45c1674dc2a6a23", + "realization": 18 + }, + { + "arrays_sha256": "622db28294606fb68eebd8c5f76a4f9e1a7508db4d680774b9421958b228c600", + "metadata_sha256": "aec6cf217d44ad645bc846c60563ae3044153037c7fba0fc109d150c43209e86", + "realization": 19 + }, + { + "arrays_sha256": "60ab74e6ef0fda9076a27e8b6402096c501e4b1ee538841a4dfd85736a4ba28f", + "metadata_sha256": "bd525e264973ae0a1d72890d57e46ef7dc79aa77825b099b9075d4bc30ff3d4e", + "realization": 20 + }, + { + "arrays_sha256": "a1999dd5d461e9a45c50ebbaf73dfa0ac20e1ac1242d121df31a9a136274c15d", + "metadata_sha256": "a8f2c9fa5373b0d5724406c6174b5054a7a9c374cf2dc0dbd04f3f9c8218be1c", + "realization": 21 + }, + { + "arrays_sha256": "eda483fcded719e92057a7a2e688825f9956b1d15ae7c393dfd055b89ab78f49", + "metadata_sha256": "0fc36ff07ac83af3e95c79ac8758b1f04e2eafd0a854ab18d398c425b5f16fc8", + "realization": 22 + }, + { + "arrays_sha256": "8d1f4f3419e34687600952535105ee8313e81802d820453142780987d3327587", + "metadata_sha256": "b6e02c0d88b3b2a51bc35b47bf488d53e2f83c385c7961244eec9d06675aef3d", + "realization": 23 + }, + { + "arrays_sha256": "574443475f30c4f74137b52867f3ac235567afdd54606a68bf9d7e5f41296a02", + "metadata_sha256": "b022708b6cfd0fb83789311ae6419f30f851727b1a4fbbcf59ec14b38aec8c36", + "realization": 24 + }, + { + "arrays_sha256": "50dbb09d43115b50eb103bd8fb3a842e9ab049dba540558885e5339a437e66be", + "metadata_sha256": "ef749b035ebee5975475f77fdf52c95986fc023ccdc45f6eef84410477db79f4", + "realization": 25 + }, + { + "arrays_sha256": "37a22b1857100c3051ac16c9db1e31bdc755e1eec007ad18e2716bd7bd6f9f15", + "metadata_sha256": "419739b2c2a5df421a5fa4fb36d2547fa98d14f7ee4904f5c4dece525a12480e", + "realization": 26 + }, + { + "arrays_sha256": "742ffbb35f93e329392ba0f68d9b87b95124f33328cf38a7eee3f4ddedd43062", + "metadata_sha256": "1ef3dcdda3a84bfdd2b81cd75310aba12c3cf8ae21b68d6810ebb99113c3b81b", + "realization": 27 + }, + { + "arrays_sha256": "de16266cc8e3b6e9f9a805fd71de1938b33c1a048380dfeea379513c8c5b9bdb", + "metadata_sha256": "b3beeb2016c9931ae284da4411cd0fb14fd03c24ba21d897f97b23e9e0861e67", + "realization": 28 + }, + { + "arrays_sha256": "f0959d0f67625631ce773370c842366ec8e1e207cd348f839e5140d9fcea0f9f", + "metadata_sha256": "a747cb15799af4e29a6464e1ffa59cc80cede8431d1b72e5bd089d63e41d06d3", + "realization": 29 + }, + { + "arrays_sha256": "ee6cb7c61e0feaa273072c6efdbf083855c543ef75322985f8f67d6096e998a0", + "metadata_sha256": "e5c7bd9368ec0ab05c201abacec36b26c01760f30b47fc1ce907d5c721fbf53a", + "realization": 30 + }, + { + "arrays_sha256": "96131c59729d37e14c5c231bb55af959fd7e752457f8944693014273688bc3a4", + "metadata_sha256": "cd7fbccdbb67c085e475b9f23d50bb894df690af26df91e12aecda445b2f77be", + "realization": 31 + }, + { + "arrays_sha256": "e1cb330a378218d9a2c8662e68d30432a8d39c49bb4287ecb14cb8860ea3210e", + "metadata_sha256": "167b3adedb0dd4faa38f19e21624bb69b22dd74f281b12793d3ac932a2aa5256", + "realization": 32 + }, + { + "arrays_sha256": "1f4588e27c5250c8739ea7779f484d530d10c7324c118cdb52c49bf199bd3341", + "metadata_sha256": "12041de07e2ec847d06fc913f85f799481b373ee69f6c8fd379cdc3ac7c49587", + "realization": 33 + }, + { + "arrays_sha256": "9508b3d29b035b052cd0b833184b5f561d602f866b1b94d93953ae93d76cc671", + "metadata_sha256": "a62764a175dcb9ea011fcf3b78e67222f7b3a7516d1ff99022a94793e0bc43bb", + "realization": 34 + }, + { + "arrays_sha256": "4fc4048bc8025533554a5361170a547485f3b01f0a78df39a39abbc1cc6d4c23", + "metadata_sha256": "56562fe44733faaf01b794eb5d320e4e7eeca8a55666da527d935a517b963d16", + "realization": 35 + }, + { + "arrays_sha256": "e3c09f44d876120672c7ba532a4c7966bc9d2779b81cfee38906b6f24cde4306", + "metadata_sha256": "84227258376bea3397226dc58c131fd51fcf02afa6839818e9650d8819025b72", + "realization": 36 + }, + { + "arrays_sha256": "918a655e3cf0a94801cd58db45867ac93fde3d4f41dd93ae6ef25aba6f52843e", + "metadata_sha256": "3b2d352484ee3cade8f4fe26ef0e2a10e07974648cddd87c84bbe2c2b232d98b", + "realization": 37 + }, + { + "arrays_sha256": "fc65c6d147c9cf7e35bbfdce5c61c2f8f4ca4d83ff8f88444ec00f5b64cc670d", + "metadata_sha256": "eae43330f5f8a16d995fcd38a77f4a07abc4ab74991b3ef8deff49d6204eac6c", + "realization": 38 + }, + { + "arrays_sha256": "68f2314e3bd8f8bcaf87f7abcc18cef52e358f2927f314f297b4c1097057e9f0", + "metadata_sha256": "f402656bd6cfab25dd0b0588e00a489f47ace4748f47bfbff874c78176c1e9cd", + "realization": 39 + }, + { + "arrays_sha256": "386a7ce2113cc7e42b0fea5a2f1af1b57d30fe3a3aedf4421049af49ee3020c2", + "metadata_sha256": "9823f4ad451bd2523f8a7a80926695fed362ad680c7f5d0213eb38264ae6c214", + "realization": 40 + }, + { + "arrays_sha256": "b5ef0c039fb776b6d608963ceeec7ba2ef44fc519deaf4bbdb445858b55275d7", + "metadata_sha256": "c5371542145184132678a66beaa37ee5f7cd91dc80ede7f79a294cd968c78fa7", + "realization": 41 + }, + { + "arrays_sha256": "8ce3c00c027a013721e874577df5c8b0a2224ccd0e5fc4bfcff5c06835dd9d76", + "metadata_sha256": "999c0c47a671534e88c56f3af44bb6eb962916fb93fc8cbdbfedd1e9c6fb9f14", + "realization": 42 + }, + { + "arrays_sha256": "2aa7acb0a245bcc214c33826ff220bfc8aa946ae9694354774b5acb84ecbcd8c", + "metadata_sha256": "bb7a5514bd5c8c0740f88b16afbd016537ab4ca38b6ce22c10f50df814c81e21", + "realization": 43 + }, + { + "arrays_sha256": "d0afd59d3d4819fbb06d2c8f2a2f7edc3da79b1cd59283dc2a437713c3619031", + "metadata_sha256": "4e060cc1326a22a98805f26544ec876440a6ed0a0d93e6c52866bac4bd843ee7", + "realization": 44 + }, + { + "arrays_sha256": "603c9cdcb9ad8a9603bf50f019d2511eaddc007b52177ce088e96fad73942637", + "metadata_sha256": "d35be8cacd2f02eb35e81edd105360b644c9e705b6fecbe4cab9c889894a3748", + "realization": 45 + }, + { + "arrays_sha256": "65014e6a66107c96520182aca41d42b590e89d59faaf9cdc2649eef641ec9161", + "metadata_sha256": "020b951bb93a1bcb954099b36ef45bbf5d1cc24eb74ddfc39ad09cb59d6fe442", + "realization": 46 + }, + { + "arrays_sha256": "a688ba332ca0daa68e8b9ab79c8f08c5392400c1f3439495b2a9a0ed8469018f", + "metadata_sha256": "eb0b60a32b2977e8ee6a30693a78cb365eca34976b85168517fdec4d736b6210", + "realization": 47 + } + ], + "observed_median": 0.36508816908827135, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3582300374035172, + 0.3713071794566596 + ], + "realizations": 48, + "sector": "central" + }, + { + "N": 12, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11562674375749774, + 0.11581594627090835, + 0.11600493311726734 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.11611791021218781, + 0.11632422011274265, + 0.11653906977745362 + ], + "median_hodge_balance": 0.1998799111975706, + "null_banks": [ + { + "arrays_sha256": "93d72c73c5e31331e12f449e06cb5365c1702e3b81f20db5e468eaa5531240bd", + "metadata_sha256": "dc2cfc5198680dff6f223a5005749c3dfcfd471cd61d0bc792fedba891fc655a", + "realization": 0 + }, + { + "arrays_sha256": "c3428dd0691ea750ba1c23ae9c658ed4863104ab412cb5258e68c7fedb86cf49", + "metadata_sha256": "f4972db7ae54385a429a5cd2b5638beaf0464f589b163f50265b05842b90fe92", + "realization": 1 + }, + { + "arrays_sha256": "e241474759e36f62783ca8556f6ae3bcf3b1950e52df1c7713fde53e9d0d2646", + "metadata_sha256": "8e4593cd3f16d85ba82831a82bab506cd40890a4e02de3b9771404922d5fc517", + "realization": 2 + }, + { + "arrays_sha256": "2e15ceac6522ae21b2ab72df051f7072b095361533b8f59631f9d6681d3b80fd", + "metadata_sha256": "88f28a8089ccb1aba4a3bd8aa7c001e9fdb2c21d06d8151aff8ade27a5ba1ead", + "realization": 3 + }, + { + "arrays_sha256": "f91a8b9a79fad2bea7a9320ec7f7afc5dc7651d54ad18ea09d2d37a7fc5f4252", + "metadata_sha256": "3f823e16a883b25f2ca66877b7065d06a7bb0fdc033d13df088c6a0f406e8b8f", + "realization": 4 + }, + { + "arrays_sha256": "6070427ef1a9b78e035f0b23921edc4f102d49e024e5a27d989b8aa568f730f2", + "metadata_sha256": "00c620be7ecd2a2055ce662cc77b5a04d012c9bf6bcae6a38abc5f30d0ceb1fd", + "realization": 5 + }, + { + "arrays_sha256": "3d76b4800427953738ca8c0890eab15e23137a4d93658ddd23ec0ace3d8399a3", + "metadata_sha256": "5470df773938b67174c13718a35bb66f0ea1ba59b801684064728221d528661e", + "realization": 6 + }, + { + "arrays_sha256": "5e0a165956addfe1c46e649a4afe1fe0b7a6dde713f4bed6e92bfa0d9674f68f", + "metadata_sha256": "9d4768232d40f6a2f1e28e1fa58a728c13816345d74e1a004d947d3a31a19abd", + "realization": 7 + }, + { + "arrays_sha256": "8d14c10d7c3d231a2178d9e9e00515a49dd8e61dc1b99408c17c791f1a5dcf34", + "metadata_sha256": "1fe7f2439738fdfe83bd37e58bd4fc63b586d6e34b22a259643b8fe8407f0b3c", + "realization": 8 + }, + { + "arrays_sha256": "83fb2c1e7beccf62ea01bae3f640919341355ad2563697680b5cf57f50976d13", + "metadata_sha256": "1285f2ae7e696d2278f25092acd4630958ea3b1ad929562eac43fd7deb863d8f", + "realization": 9 + }, + { + "arrays_sha256": "28f7faf83e6f99a94a3bbd5f79424788beccfa0894c6ffbd8b073f6a1ced4b76", + "metadata_sha256": "c60a98c887a2f8b31575ca4736d1a2ad5e78095dcc49dd87d5e5dc1718382346", + "realization": 10 + }, + { + "arrays_sha256": "e76207bd5e10487998161cbc4b96051e7929d3c5efaa5d663b1869ebd93b6d94", + "metadata_sha256": "68954d49eb3100c05182cb5652caabf4ab1f654f6e5857d063ef2ef1e258c6df", + "realization": 11 + }, + { + "arrays_sha256": "0b530ffbaf6f99ffb7b328b2a52fef6fa34fb66d65ceaef842803bf5a4dade0c", + "metadata_sha256": "7a9266933b4f0ffa09044306375222493d09d0d3c1c77fcd3cc4e043f575ae51", + "realization": 12 + }, + { + "arrays_sha256": "9b6169629c4faf0a65bac93fbbdebb6655a8680c946d3e299a67ca5de6da54e2", + "metadata_sha256": "1b8bf635647c16106911c411f88313afd0fafb8f1b5a8979f9d68e5eec4bdd4d", + "realization": 13 + }, + { + "arrays_sha256": "ddd2540f7e807153a6c9fa26a890000310e6d5ad5b8884f64b416d88aa1ec23c", + "metadata_sha256": "688de65b8d820e9c00842d3e3f0e848e829ddde9c4f8335187f8e78a89c518f4", + "realization": 14 + }, + { + "arrays_sha256": "ba0aebeacef9058229f823e48fab18589bd5330b1871ed0ebbcb79a4d1a33281", + "metadata_sha256": "8f0372c83dc97e09050802202372f2ea68ff31941118a26e137ac05785d7ef02", + "realization": 15 + }, + { + "arrays_sha256": "a241fa203dd94f24dd6571cd8bf76baf6b671f69abf4bde3f959b9bdb01de28b", + "metadata_sha256": "ea84a77ef39c908274192fba1b81f5be027281386a3ee2ad6ee2c8f2bc360df5", + "realization": 16 + }, + { + "arrays_sha256": "14125d7c36948181c3f787b6a1e7478e7d8e553ec85f33bae31a3646d7163315", + "metadata_sha256": "6e6fa9131efa931c670e72c7f877e684dce4a6d5dd07ec82fb47e93420592d97", + "realization": 17 + }, + { + "arrays_sha256": "ddb142966a372b37702ecc47a7df9a4127a25fe4438f3f48163c4f10470157bf", + "metadata_sha256": "7829ed0c9048cc6bd3300724341d28bb5556ed28cc6c20bab19e778888241489", + "realization": 18 + }, + { + "arrays_sha256": "0fa055f8e3075822aba6c1d5dbcb340ef5120bf94ca74faf9971b9ecb240a292", + "metadata_sha256": "040eb8fe2e71457af216cac0c5548778e85e10f0388dae9d8ccbbe5c6072af47", + "realization": 19 + }, + { + "arrays_sha256": "bd1707dfab836451c49bb2109e0cd99ede1fca912f935c7bceaa0e086149dac3", + "metadata_sha256": "c02c41ada79ae62e1dd4e24680e28cd3453f0ddc04341095abf1899c7e579124", + "realization": 20 + }, + { + "arrays_sha256": "5d97bf01a9ffb5186e67a5f51e94b186c7c3fb4f2fb823467ad1a7677eebe069", + "metadata_sha256": "e536a54c53124e32cc37143f4210a2d1f130d4b2e2fa3d84c547dad322853dca", + "realization": 21 + }, + { + "arrays_sha256": "5af6cc78890bf3fc85941c71a16bccd5137e24ec02f6e8846c78e9f64956f1ed", + "metadata_sha256": "9bc106cf162f8651bbaa5f6da2165895a5550f2153ad4c3caa6e152e4aaeadff", + "realization": 22 + }, + { + "arrays_sha256": "8b5817b70d0c8866cb5942f8dc3ead508141310764d15676db3e5ba34e275a5f", + "metadata_sha256": "b4c751ba5066ea15a2c8408ce92d4e3f960e0837aaa827cfb21cccdc7d643512", + "realization": 23 + }, + { + "arrays_sha256": "a9ce7d42abaccc0e2ff454b2220a2c1965addd037d6a79fdb8555f8f53490450", + "metadata_sha256": "90813298e72ef653194a2cb85cb74d4cad29103a2aec98b878bc2a36bf85fb19", + "realization": 24 + }, + { + "arrays_sha256": "c65e5c84de88659e989d45fec7851d1bb6bca407e399af0f079daa114da2ad31", + "metadata_sha256": "e0b9807c895876ceaf90fdd8c6fb2c71a0d2ebeccd96ecf8126003cbfca79724", + "realization": 25 + }, + { + "arrays_sha256": "2965dcde2597c69758ab6dc94711e088d65336de04d6911a8e95186be19493b5", + "metadata_sha256": "bb178d3e32b0b8c4e321b503806282f8130606313f12c3046e412a94133d2815", + "realization": 26 + }, + { + "arrays_sha256": "49e3a10b9759e93e295ef60a623998325928e3b2244833fd241c627f940ba01b", + "metadata_sha256": "0808dc618f8903b1855a9771d6352f46b8bf0118beedac800a8eb268d2309d43", + "realization": 27 + }, + { + "arrays_sha256": "c87cba77f96e96de0c54d49cc98d4589bdbce28283f5b0a964bec922862594e8", + "metadata_sha256": "9cfe4557efec36237e39fc77cc151d9cdccb13dd7f49062a038078e577adeaec", + "realization": 28 + }, + { + "arrays_sha256": "eb1dccd7afa5a727958e1cdf15666dee8094aa14194a72a5b65d889772a9ac47", + "metadata_sha256": "b1f67ef785d977496be6bb346f53dcc602d73ed9043ed8fd1946a1b9c9ca3b85", + "realization": 29 + }, + { + "arrays_sha256": "a0bceba2f4a233215e922bc7c8d08dc1cfce005b23ed8ad6e2070cc491b5980f", + "metadata_sha256": "ed99cbd2a63f57179597675590fcf0df84faa39016df477badde1fdf29b82d65", + "realization": 30 + }, + { + "arrays_sha256": "d76bba82b2799e3d7727e7e6a0e6e1726e1858ec79a5610530dd11970a84dd8f", + "metadata_sha256": "9a83de6ffed3e4bc5f39c9ae1342f98a539208827bf59e479641ae83f3520467", + "realization": 31 + } + ], + "observed_median": 0.1455538020363032, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.14303643414095735, + 0.1475576386964763 + ], + "realizations": 32, + "sector": "adjacent" + }, + { + "N": 12, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11653550918409035, + 0.11677938950236749, + 0.11704279833978756 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.11754400876960917, + 0.11785329696356348, + 0.11816821284249375 + ], + "median_hodge_balance": 0.20304955102017233, + "null_banks": [ + { + "arrays_sha256": "6295e43d8b066e587de5eb0081e9e35534a13fac7e41d976e051c1e5fd65bc17", + "metadata_sha256": "d3ccaf826ee7c2db7a09aff5e316c0a58fda1783348ff3dc110ef861e13e6b6e", + "realization": 0 + }, + { + "arrays_sha256": "27a297e1100d86adc18773e93406182c724504092eca903627cabb570705dd00", + "metadata_sha256": "973adb32e9df0e77051c809031081b45717a0c6ecb194175a2a61fea3ea7e2d9", + "realization": 1 + }, + { + "arrays_sha256": "b113c827bdf362d17bace67d13b8b941651063d17eca813a7594741f9d1199e5", + "metadata_sha256": "ab6b133a2fd225b02dd815239e851b8ec9d5466439e99f9508a8dd2ac69eb644", + "realization": 2 + }, + { + "arrays_sha256": "7c7cc27dad0a1dea57c16ee78bd51285fe7557a2c9a7cf4a0d26a33d012d135a", + "metadata_sha256": "0834559c9abf99744717b8fb660ba49da469cff33914afc16dfa43ab598b1e1a", + "realization": 3 + }, + { + "arrays_sha256": "a331c9611bf4e6404c67cec2c6fb3a0db2b2d6e7aaab53dd5bd50c8a8bf241a8", + "metadata_sha256": "cfe366ef911f84f87ba519ed5d97d5e473d05bbce91400dcfd4c512fe388248f", + "realization": 4 + }, + { + "arrays_sha256": "9af07ba8527b2969d0738bcaf2a2d77bec3dccbeb6d3b12c02fd4496d304c2b6", + "metadata_sha256": "155c6a82e749c2e93d85e00da213a3ab0ee7f98a60c1944c1fb9bed34bb760ee", + "realization": 5 + }, + { + "arrays_sha256": "274acda5a9d51241a73e49318934cb8a22896fdaa1c3c14540813b6354f1631a", + "metadata_sha256": "7ffbf33870caa20fff28b18cdf887ef014eb198a782393fdd91142f7748729e5", + "realization": 6 + }, + { + "arrays_sha256": "a00c0d087274c20f267d39b4b4cb5c148b749c0c6d52f80f13f3bcf5db6f3954", + "metadata_sha256": "b4b5b3271dc1bbf8cc43e1ea0b37f441bc8fe23111bbb58266bfd3874f6e2213", + "realization": 7 + }, + { + "arrays_sha256": "c4cc4284cbae78865dd8eec113fcd8fb2437246548b2b613e49cddb3625e9585", + "metadata_sha256": "7e45fe031db32016f502101819d4cf91613fb9b9f1e5aa17860abf71c7779a50", + "realization": 8 + }, + { + "arrays_sha256": "673f3c19d0d36037bf7d0a55654c2c19553a6b7467047d63bd3a1754c46ea4b8", + "metadata_sha256": "8e4744ebaec126005471c500ce9d274fdd255b0095d6157b3b7181e3cdde8c05", + "realization": 9 + }, + { + "arrays_sha256": "de2c8dcd9a3a47d7335d0af37fc390ce13b3dc5f748034f9e3fab1fbba5996bd", + "metadata_sha256": "f2bddccb651e2c23031f42ab1e78360e2e5a876255babb43100c0006057c2f1d", + "realization": 10 + }, + { + "arrays_sha256": "1306ed2f1f1b38a4f574cbdeb4d522f1b6edb447eca3c85a33ca319907236277", + "metadata_sha256": "dc2f48e993727e64ad32954077329ea6fe12f226eca787d190a7359c8639e9e2", + "realization": 11 + }, + { + "arrays_sha256": "f1721dda5d7d20af93e11192dbddc7c1b437c58952c14d0f46aae0b0ccdc95fe", + "metadata_sha256": "9084e131eb07d404a52545fa7184d5b954a8992d198498b865bd26355a9ee304", + "realization": 12 + }, + { + "arrays_sha256": "55c41e0db6b603fa392718dbdacdbbaf2bb9b12344db3b7ff7a9ffdd9a1ea4d1", + "metadata_sha256": "1223b4af181929db6e5dd514cc1783ef4948ebb618205a62acfd7e540643f96a", + "realization": 13 + }, + { + "arrays_sha256": "f845550590021742adb988cc35d0ba87780c776063b1d035606c3c412b243205", + "metadata_sha256": "f5da11a1c2c31851a0db5d3790e403d2c6a400beff3cde15b53151ee76c833db", + "realization": 14 + }, + { + "arrays_sha256": "dfe01d14a160e3ba3a8debaadb41c40ab101b928303773358a4ac88eaa5ff396", + "metadata_sha256": "77983323fbe61608095651a3f599ba2edb97b1f1b05fff922ae978f18c000ad9", + "realization": 15 + }, + { + "arrays_sha256": "b8d81ae843c89287ff6476caa1831e81b680c1a16f9a0cf919bff2e27719f94a", + "metadata_sha256": "1f982ec22dd4a17d312a03ed534ba53a8d614b2cdf9af9827df4e05d0e51d8e0", + "realization": 16 + }, + { + "arrays_sha256": "bab482952e5ed39928387bc94cf9f2a0b45be95c39738a54f6e6a7056421139c", + "metadata_sha256": "f5ce915e3b0e94b506673e7f75448c080ffcd3d3661ec9c030e56493805fa5f4", + "realization": 17 + }, + { + "arrays_sha256": "7d2998d5654f4caaf74599ad5c3dce3a64e269f4a2b193a7e0c07af38f66c962", + "metadata_sha256": "8e7e3e100087a8fb23e96f80ff603f2285666ec223ee65ffdf9fee1a704f7cf4", + "realization": 18 + }, + { + "arrays_sha256": "d3adb10b6f8cba653f2e2b4a6b2b614282550e54a8001a2826c1ed6089872b69", + "metadata_sha256": "cfd412db593d795cc07dfe2c0166b4fd2e9802e359d0a4c37579b4683e00357f", + "realization": 19 + }, + { + "arrays_sha256": "349f6d329d978da2b6ec1d1d9739e3347f8e35c880a837e2998d7116a6176a83", + "metadata_sha256": "0c35c4824a64b1cf1e42799d8a4a4df92e1b2dfb11b61008ec76d1afc5d9f241", + "realization": 20 + }, + { + "arrays_sha256": "119ecdfb9b5e238cd44b73d0d13f6b8fb8df57242510cddf20e39fe2f9d5f518", + "metadata_sha256": "9d0772100999d60a3277e297b15d7e247d0bfe228a8ac6d4a945d929818e1894", + "realization": 21 + }, + { + "arrays_sha256": "1eea7811e2771b0c42e22c83ad898431d92f76f0b7cffdc3a22c1f24a29eb522", + "metadata_sha256": "1ac4d5b8a4846fa38d236b8b3ca9b8db3d28a9c8be5563a70d101b54629ed688", + "realization": 22 + }, + { + "arrays_sha256": "5e47af01b7c9c15e3e5aba1df3c83f13f069e5c8c539ff8036853a5f1ff95f9b", + "metadata_sha256": "497afb80aa6cd8627763ce3a44825f5d661914078a034bb222ddea97ba154bc5", + "realization": 23 + }, + { + "arrays_sha256": "2894fe2a6198e17bad873c598c60feed9cc8d1dffbe2cca584a5c8bf1796edcd", + "metadata_sha256": "369a4a569fe45b87c779a047f675fff62d3c25dc4599c5eff7323bd3f6bfb1af", + "realization": 24 + }, + { + "arrays_sha256": "edc2ba31774ec0a0b536e4be78e65a9a1196ef9644d42b507e44419b6300d85b", + "metadata_sha256": "d943b0bd0ac1f2753302c13b3a79d642d851b926907b719242b6b5fa05066de9", + "realization": 25 + }, + { + "arrays_sha256": "add66316095507864a2384d7a37bca01f7cfe4d8d17a975edf5071ee32107f6f", + "metadata_sha256": "f1dcf67b305703c6ac79dfe12c343d150dbcf3e8c39b4c3f7961e8872a89413d", + "realization": 26 + }, + { + "arrays_sha256": "898c638319878397dd788dac8da53b1dbabeb98e2c260284b135ff7b9da3c795", + "metadata_sha256": "0fab88d8124736c1a99400fb696aa73a051240a860aa206208326ccfe8b78bf5", + "realization": 27 + }, + { + "arrays_sha256": "90211f72e94b91e7f57a41b936082c1c1aaf8382325bd00e4a9cdf4d3c642cc1", + "metadata_sha256": "7d5f48933c2aba3d0d5fb9ad4b1936635d46274a77ce87078807850f0dc80ca6", + "realization": 28 + }, + { + "arrays_sha256": "2d6230c3e95f28ffa75ee250d98a8214d2c06e193d8b3d8b0062fff10757bb98", + "metadata_sha256": "ecefbf7a0d3deb9da88a32a948636ee4065a571ec3c94274d716c77449781a4c", + "realization": 29 + }, + { + "arrays_sha256": "05d12aedca05111de31469d758084d80dc48b432d06190ebd84327adc64894e3", + "metadata_sha256": "2131d684fa42e5ff2a089053172c482142a4608d15fb5385447c452c354fdbfc", + "realization": 30 + }, + { + "arrays_sha256": "3e0ba8253ca91d2cfe7a4230f7b94bbaafd0a43614d0c0a29b9430b6b0c91c2e", + "metadata_sha256": "8914737f638888b05ec83eb7e231ed9d8e51caf5e3a5000236453950bdbe2f59", + "realization": 31 + } + ], + "observed_median": 0.30799929044283475, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3017947804697443, + 0.3137684915691576 + ], + "realizations": 32, + "sector": "adjacent" + }, + { + "N": 12, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11279238387872889, + 0.11282147828827586, + 0.11285685034000596 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.1127383177366043, + 0.11277130222361338, + 0.1128063131866758 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "39eabf0716d5f70ab54f3d8a7986b5e6bf53cbc678601044e30c1fa72c5ebcde", + "metadata_sha256": "c483781d54be8115cb6b1636f07470161b30b60301b441c4a669bee7aa23f32d", + "realization": 0 + }, + { + "arrays_sha256": "0a1bede9ca227a0be9ae8994babbcc68c6f43d8b289bdf7ceead7110f59ceced", + "metadata_sha256": "a8f749bb2b254d3a48501af8c8ee49c2b73a7049e0ed4b085bc30e76746e2f68", + "realization": 1 + }, + { + "arrays_sha256": "2c95b9b23c4f1789b49eb4f9da845f59c630e6f37c94089a9adb254122fd36e4", + "metadata_sha256": "d03167484e3e072cd72e651d80e3ce11f22e65e568be1a30ecf7d5053441627e", + "realization": 2 + }, + { + "arrays_sha256": "5031a362d6b78e203e0cdde730a124def9522f734d859844df37e656f26ae1e5", + "metadata_sha256": "59492d5db4ab2b536b245c4c2e32d61ae238522075f1e1decd80be18039fc189", + "realization": 3 + }, + { + "arrays_sha256": "f796cec58355e5a217ed19b7fedc24cca9c7231d68604c9164a071eabbf69a2f", + "metadata_sha256": "9caf8f23d001caf3ce782e8475cbcebc6dca291eaff911d2edd6f14077bffe1b", + "realization": 4 + }, + { + "arrays_sha256": "43cc763a595e604a4e08e2ffa16b364ee0685c0011d4e9bd78ecc8f162b35df1", + "metadata_sha256": "53250a11910f15412121ba64dc7e9e9aadb0ca17f3e066facea8f2280d00d942", + "realization": 5 + }, + { + "arrays_sha256": "5eb12d4efe1d5ffeaf8c98ee32d3bf9af49b61fd90e0641fe74cc13e9d730d39", + "metadata_sha256": "149235b0dc6c49dc55c07f34483c6b92cc3c9600130bd6e4158edab936df10fd", + "realization": 6 + }, + { + "arrays_sha256": "99b381c67c4a3be2f098f1ae7dddf5c11d841d49b84a2a7be96514e9cfacec2a", + "metadata_sha256": "788d17e4c84b11b42f27a1e59e5f39ba13d5f28adf95151a8e527cc3d85ae02a", + "realization": 7 + }, + { + "arrays_sha256": "ed0b9309c6d7d0f4081432ebae7f0df4b3244e51ebe6cd49034b65b4c3494781", + "metadata_sha256": "ba6255d5ad211f1a02a20c60f3856925e4d0c4ae479c0e9aa5ca725d9bac7d8d", + "realization": 8 + }, + { + "arrays_sha256": "8dcbba96f6ce35299c702f2ca8239a5388ec4e28c057341038b4134dcdde8828", + "metadata_sha256": "c5fbd6dc542ee5fcb4070e7676781cd92ef2dd2062897562d55c9cf6211268bc", + "realization": 9 + }, + { + "arrays_sha256": "a8e505e41ba60163db39036bbb026e4e4ff07788e6b5fca3747f8489da46f099", + "metadata_sha256": "3440dee8c812e29bb0d65517f05cac624f0902e3fee45af9a713f71b036b0bff", + "realization": 10 + }, + { + "arrays_sha256": "0720b141a9452923373f8a6fcc37805177b0ef0bde9303771b78ceea49628ba7", + "metadata_sha256": "c21c7f6184d187d3f047de2ad86f198d2a5824fdb681c40b18d89b8948e55ff4", + "realization": 11 + }, + { + "arrays_sha256": "5ed8d947c24c093a2338bcdf72e1f7157b98bd0b4309cc2ccf65c067f61093ab", + "metadata_sha256": "fcc433308daf020805cf0a4f07075f82d0466e0d5c8202e39741af6ea89532d9", + "realization": 12 + }, + { + "arrays_sha256": "b801592e7c1b9566d8091370221ecd29c5489e0c049f1f08b87f2256dd9305c4", + "metadata_sha256": "471935e03b4679706020953efdb355b0602ac562830929e68de5fb9233123530", + "realization": 13 + }, + { + "arrays_sha256": "3910156a6de0e7c6c33d2ff6bc17da0c141202d04ffac58d0d04581fb6ee39ad", + "metadata_sha256": "4378c43c64e652ed1a7c9f783e28b589ad05c283e7a59dcd9dc2a7e9fcb2b5f4", + "realization": 14 + }, + { + "arrays_sha256": "1540d7fe3a5bb912c56286fff51264aefeca3f3f3298efc95e478b9db4394e60", + "metadata_sha256": "8270b7ce104a4ed6e743deb16c188384516afa1ac3b8f2b71f7016a344633d9d", + "realization": 15 + }, + { + "arrays_sha256": "783b385a237d23444303dd72be753bcdb081498d00a06d97234934823aa5c511", + "metadata_sha256": "5d3392ff9794175c6622a797f6505ad29ea74399107a4fa6dcfdaae39bdeb704", + "realization": 16 + }, + { + "arrays_sha256": "b587d854136db8b51e99fbe4686bfe67c8876d5aaeec8e43e02cb2f2b0c239c6", + "metadata_sha256": "da7b442102cac0dc638ce7767c44b51559bbca1c42009d9577030281e68da253", + "realization": 17 + }, + { + "arrays_sha256": "c9af54614b2d32d5c1651b90cb2b94ef3079f756194d45e08b88750849e8fcb5", + "metadata_sha256": "9a32fd40f74602cafd55736b7ad2612d942969eab356e25ab928fc40e90e03f2", + "realization": 18 + }, + { + "arrays_sha256": "69bfe64bfe84686e782e99545f14b495e26b8a06d192f114f177a97aab47ee42", + "metadata_sha256": "fab0cbe18dacdae282ccff6fc26a2f2c255fd3141fb95cdfdc8f4b17555b0eb2", + "realization": 19 + }, + { + "arrays_sha256": "71540460007eb40ea4463188b8c6c2fa8876ac0657e1a79e94ea57382d99eace", + "metadata_sha256": "ae47f705bac8f00e785029e5d1d8e7d07063f2a7953b1bb6fce29339e8dbc8f4", + "realization": 20 + }, + { + "arrays_sha256": "a5c34b53b815d20f9ba52ac32f51e23d0a70a9f1807b1baf822232c5b08a6dc2", + "metadata_sha256": "d77dff93869446433482d6de448b6f3a543ab18f7708ab7cb1b14fa31d72bf29", + "realization": 21 + }, + { + "arrays_sha256": "18d1616cbf1945652d4e75e211f9499ad57abd64a3361fdef3a2deb68b29d776", + "metadata_sha256": "025349b10cea8c5094acd4a2d6d2c3d54f6f56076c5e28788a3d6f105f61abaf", + "realization": 22 + }, + { + "arrays_sha256": "8515493492410dde08f2599233f50bc2a779d7ced1c359b9681c3640afebb377", + "metadata_sha256": "b492d5319ccc6f1d6e9e9275f5114f3b0adf4c20a414fe7cd5d92d36d9573f24", + "realization": 23 + }, + { + "arrays_sha256": "0da5ade0ba2c79dc549b303ffb19c633228bf4f9cb0ff3a4be72175e477618e7", + "metadata_sha256": "a40b2500a6aa9a9b8bceb254c932c64715692dd4550d8c8b88839496a72efeae", + "realization": 24 + }, + { + "arrays_sha256": "98fca051c41014460206b61be3a79075d6eb02f9a2a3cfd578ef6d91f8ed2859", + "metadata_sha256": "9070764e76f06d92da44ef838939f97bafccb807ae3826b85da93f4945f0f51b", + "realization": 25 + }, + { + "arrays_sha256": "5d7da8a4e388c3cd7fac108b432ec9802dc39a8ac4a15b2a5135cc15d8bead02", + "metadata_sha256": "73c61ef0b3f3d213c79b5a02ada91ba7f83b10ac285995ba60b93cc68aba91d2", + "realization": 26 + }, + { + "arrays_sha256": "3c4091d2eafef1887e3c0b357b92b79910fdf67752b7799534876ae9c28bcb34", + "metadata_sha256": "70277620e91df611d95d4b03d6423eb0606c838c81c77771307c134f701a2375", + "realization": 27 + }, + { + "arrays_sha256": "e2d34183de8270bcffd3949f0bf48de4b77ecf35cfc0eca1be28e19a87e9dec4", + "metadata_sha256": "96360e14e6bb6e28088373504b22d6344475aee688edfd5197f67f456d906e1a", + "realization": 28 + }, + { + "arrays_sha256": "430711e8f5a8496884e7d42f006efbb8c98eb55ca122f741b7209866032435c4", + "metadata_sha256": "f822f62296da8f225d9b92d103752641f57f59867306617f0984a820a15effad", + "realization": 29 + }, + { + "arrays_sha256": "5f75b9b6d20dab158273e0da76d484f48525adc94f59d5f7cc4a9aec3547155e", + "metadata_sha256": "aa746965caf49c907df3bdfd028aafa7f6868d0c584fc0a02e5b0af221a7b976", + "realization": 30 + }, + { + "arrays_sha256": "99ce32aff5c3d13eba4fc9f2f3a3661aafffd23365a2df3bb67b6f1a89a90dec", + "metadata_sha256": "56b68c7c5a89fa2cb853f0d3eff9a025a0641b1f6a1479236d864a26effb0fa1", + "realization": 31 + } + ], + "observed_median": 0.1758398360594558, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.17501819690750547, + 0.1762804126020616 + ], + "realizations": 32, + "sector": "central" + }, + { + "N": 12, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11302005029615277, + 0.11306530368482279, + 0.11311431333015237 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.11320492572703314, + 0.11325918904630874, + 0.11331421373353018 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "71707e9992e64d86525ad773fb28849585213f6381803b2b0777ece4727a5701", + "metadata_sha256": "c4ca211323853dc572c47b93d85f73789beb13eed9df8e626d87dcdfcf8bcc6b", + "realization": 0 + }, + { + "arrays_sha256": "ddceab7e434f07d728d20c1ffe6b4067e8ec468349282c0b38f7bb5ef7e9ac93", + "metadata_sha256": "59180248a4412e7519816ca85b7772ed819d0dd0f0fecb1ccae7d84eeac9a58f", + "realization": 1 + }, + { + "arrays_sha256": "cc6dd0cd91fe05ab3ec8f7495cb00bf3a04c4c885207de44ddd892b3abf91d9b", + "metadata_sha256": "32de84ca7e7505f0e6c9f78a284c452d7c1959d79a957d7c4c764901598076e3", + "realization": 2 + }, + { + "arrays_sha256": "1d2ca7c9a81079cc338cb2e78969456019e98a6749885691fb34c600210748b2", + "metadata_sha256": "0be5a8ac9a2d86222df74bef9724b61f68b24f5fbd844a69053fec70f18843d6", + "realization": 3 + }, + { + "arrays_sha256": "9ee9923ad88a32db01c58a74a8fccd4e189681592a9b871dc1833472b0a8f6d6", + "metadata_sha256": "042f35c6092ec0dc81c1d41d219cd7b26dd44ca81748e21d6397a758bab1749f", + "realization": 4 + }, + { + "arrays_sha256": "bb0d0df8ea03892e4f7496520ca9635b70639f7f7f30a77302b01e648da810e4", + "metadata_sha256": "2ec162d2f94a1d7ce0573144a06e0410054096ea7128aff06f6e376ea4ffd364", + "realization": 5 + }, + { + "arrays_sha256": "44329461a9b5a1ccb1df747a669d42d1a6f38d720a7872d42ce71cfd3239dddd", + "metadata_sha256": "7ded7fc66837459cc2314252cadfe450d69309b20d3eb6942e02f423280b26d8", + "realization": 6 + }, + { + "arrays_sha256": "ee5ea78b28f637ac2a19939a748f4703cdd576902bd12b8b12e5bede786695f2", + "metadata_sha256": "7a5887b3088b4d7446af34f09291e564c928df6d4fbda305167ef67b84a37cef", + "realization": 7 + }, + { + "arrays_sha256": "4dad209b278d4e2dca484f5a631c280ded9d41eeb8616d5df4b5a5da004e075f", + "metadata_sha256": "3c0386cf66a6bef718f7c50d4a35517a403f7fce3f67b0760ea43baffaea49b9", + "realization": 8 + }, + { + "arrays_sha256": "076de75110454679d5cd40dcfac8e74807f0f22cfd1dc32a2f1725b3a8082cef", + "metadata_sha256": "adc5fd58b95ab02fd56b031d7a4df7d7d61c277e3865382f3082e0a38c96227b", + "realization": 9 + }, + { + "arrays_sha256": "f74afe2ad85b5aba89e40ce7757a5dedcfa6c9d7d9d3a925b3781f0089520ca1", + "metadata_sha256": "14cd5b9006a3ffbe2db46238bceffd7727e0082414ddc9868bbb6a5bf9a096fa", + "realization": 10 + }, + { + "arrays_sha256": "24e49082ecdecddeafac8c627e4d9bf472a8855754a74d6f995db3eef5b49b2b", + "metadata_sha256": "d7d9f35a9c5673d4d01fb30a6f5d40aca84820529be473fc80d5601a185b565f", + "realization": 11 + }, + { + "arrays_sha256": "860ed34e094dfe214ed93abaae02c681177e64018c11ea8ef8a127ccb6682248", + "metadata_sha256": "f15a1ec151f1e3f6849ad65a82580bbcdcddd80b3c722f8ed664108453da5820", + "realization": 12 + }, + { + "arrays_sha256": "266b470e4809dd1429646fb1d1aa85c4efaaf1086d53eaf10c2735efe13506ee", + "metadata_sha256": "236bc6f90c3334ffb41ce6aa5f36d8fbd314e4eef526ddb63e256955a02d0636", + "realization": 13 + }, + { + "arrays_sha256": "e69a34ea0d55dd1984fcc4f95b79df188e7062b87de8cb6d6fa7f2b26d5d6410", + "metadata_sha256": "96332f6cc786eefe03913c81876e94d4f9370f5eda80100ea2c363d59c72b24c", + "realization": 14 + }, + { + "arrays_sha256": "54b1a0616752d9df4b9fc2596d9d7de82b5d44d22bb7d1906b661f492921d271", + "metadata_sha256": "482b21be326cb8136006c217a5ea5c809678319e0acfa3e032db3234c6d18bd6", + "realization": 15 + }, + { + "arrays_sha256": "9b5ae475eec7cc10700c330f9f9cae5e4445dca38c9aabd1005a39ff28228166", + "metadata_sha256": "67324ba73faf7acebcf56ac70dfad572c98f5fe617195099a34cd0f266f73030", + "realization": 16 + }, + { + "arrays_sha256": "67e221dafd6bc2984560cdce1fe08bebfe9b77843ab4788465cc5809756703f2", + "metadata_sha256": "c07e531884d8e430cdfb0de8689407c69d8bc00899f7cb7da0d702bd45208a9c", + "realization": 17 + }, + { + "arrays_sha256": "0b4fc80a2e252782c750d1101295d9ba9858d5d7db1ac93dbe5f39092707c981", + "metadata_sha256": "2f98ba35a7460da11856a9caf03ba21b69edbcc86c8fa730991a1f6b85c2b7e6", + "realization": 18 + }, + { + "arrays_sha256": "d0271f89f765a3dd14ef72e60a04a05ebd36f0f8f44f9fc334e0d983669c0073", + "metadata_sha256": "11f91f529f5aff15edb1831393a00ef78f1355568f1461ab2eb8f8877d43c45b", + "realization": 19 + }, + { + "arrays_sha256": "29326e8d5ea015856d4725405b6c006246fd0851ae11046554c5d4af5da23fef", + "metadata_sha256": "780b40e217cfe9dc7f48e4e6290faf227fea210b46f544c381a9610c133740d0", + "realization": 20 + }, + { + "arrays_sha256": "88a56dfd95877efa47f5cf835f980e496b1e89ea384672729a4b398295d7607c", + "metadata_sha256": "ccfa25b213a0b12d34b6244945383a1aa6fcc78ec561b5655246d8fda1215ad3", + "realization": 21 + }, + { + "arrays_sha256": "759b4a0eeff52d56840a4f555f8b1487f7a0ae6fe2b0851beac285da6a3b32de", + "metadata_sha256": "5a1020671739db14ff00792ab81ff6bf1ac2186d1f71bd96e42c2d2ea59a7360", + "realization": 22 + }, + { + "arrays_sha256": "b3f3bbe3e5b2ba39532f9f2dd7a911d580ecbcf73d35d993fe73dc941e0e6dc1", + "metadata_sha256": "ca4ed10744865e489863326067e9fcbcb7209b249eda108676684f8d881709cf", + "realization": 23 + }, + { + "arrays_sha256": "c96b940385f6f9ed97e6676066ffa4b27c20fdfbad67e333dffebd0fac9484ff", + "metadata_sha256": "b453d086109da994599b0ffe2d90c187e50b6342e3f47f3aa5c6356833b1fadb", + "realization": 24 + }, + { + "arrays_sha256": "660ca562eca25d5db05925e45a03f4180c8153e15463ae774f997ebfa09c7614", + "metadata_sha256": "a4583fc4be9b25f8e7ba25f2d01e1b70a278da2c1e2117910873ac07e2f9bcd0", + "realization": 25 + }, + { + "arrays_sha256": "9bdb7328ac028ee09a3c2b707857fb8ce24dd638f2f558cd8cfa9028fe86fd63", + "metadata_sha256": "4a2596a9d545ea020ebe2e542affe16c98649bfd164f19cdcda0880d38a3bf9f", + "realization": 26 + }, + { + "arrays_sha256": "ae9049ce7fe0e152e28e89fda236abcd3e663fc03c6d2edec20bfe7807a5b433", + "metadata_sha256": "f147e1f90205fe09a859505f789600ab83e89077b365db3c9e3936e7a44f4b1a", + "realization": 27 + }, + { + "arrays_sha256": "35758b032d95c843ae5a0496933bf57ccad7ad523b597a01a490cac699c2990b", + "metadata_sha256": "92a19b3d6054f81d92820573384e09a5016ee5c6f81204ed691c5dba09dc6234", + "realization": 28 + }, + { + "arrays_sha256": "aedfa0b0f7ef46297d0996d4a398daf8558c811f7bac355b2b974383ca98b72f", + "metadata_sha256": "2926123a3539b397af98d24335fdf41b70bcb967e83ca52b83f9f334c7d70fa0", + "realization": 29 + }, + { + "arrays_sha256": "f3dabf9c509cb6e96cb5d6df46a0ed8bb60671ffbc89aa04ced7b4e625a7e9c8", + "metadata_sha256": "d897321b0d03a3621c83f343f6cd6dbe121dd59f79c7c62f69ef89adfb85dca4", + "realization": 30 + }, + { + "arrays_sha256": "5263d4c66a1b6614df17e0e37b3b71a4d155c8455333b6292169f768dbcfde98", + "metadata_sha256": "e2f4c35b0de80e0c418a0f83eaab5f4e0f265382e439d1a7c56fe95e3a96e36d", + "realization": 31 + } + ], + "observed_median": 0.37696338917315897, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3695751849042101, + 0.3793322651479647 + ], + "realizations": 32, + "sector": "central" + } + ] + }, + "selected_branch": "cohomological_non_gaussian_class", + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.pdf new file mode 100644 index 000000000..86717f6c4 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.png b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.png new file mode 100644 index 000000000..e5285ee80 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.png differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/from_local_repulsion_to_global_geometry_v1.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/from_local_repulsion_to_global_geometry_v1.pdf new file mode 100644 index 000000000..bc61c9313 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/from_local_repulsion_to_global_geometry_v1.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_numbers_v1.tex b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_numbers_v1.tex new file mode 100644 index 000000000..7edcf9088 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_numbers_v1.tex @@ -0,0 +1,30 @@ +\newcommand{\PhysicalMatrices}{20000} +\newcommand{\PhysicalTestMatrices}{4000} +\newcommand{\PhysicalRank}{50} +\newcommand{\PhysicalChannels}{170} +\newcommand{\TrainingRows}{1024} +\newcommand{\HaarMatrices}{10000} +\newcommand{\DeformedMatrices}{10000} +\newcommand{\SelectedCovFloor}{0.050} +\newcommand{\DensityHaarLone}{0.2910} +\newcommand{\DensityCovLone}{0.1237} +\newcommand{\DensityImprovementPercent}{57.5\%} +\newcommand{\PhysicalGapRatio}{0.599806} +\newcommand{\HaarGapRatio}{0.599395} +\newcommand{\DeformedGapRatio}{0.599200} +\newcommand{\LargestRank}{800} +\newcommand{\LargestChannels}{680} +\newcommand{\LargestAtomMultiplicity}{120} +\newcommand{\LargestAtomWeightPercent}{30.0\%} +\newcommand{\LargestInteriorDensityLone}{0.0523} +\newcommand{\DensityFitExponent}{0.593} +\newcommand{\BootstrapReplicates}{10000} +\newcommand{\RootMatricesTotal}{8750} +\newcommand{\CovarianceAnisotropy}{0.867} +\newcommand{\PhysicalParticipation}{0.625} +\newcommand{\NumberVariancePhysEight}{0.696} +\newcommand{\NumberVarianceHaarEight}{0.570} +\newcommand{\NumberVarianceCovEight}{0.570} +\newcommand{\FormFactorPhysHalf}{0.502} +\newcommand{\FormFactorHaarHalf}{0.495} +\newcommand{\FormFactorCovHalf}{0.502} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_numbers_v2.tex b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_numbers_v2.tex new file mode 100644 index 000000000..5f3b57ce1 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_numbers_v2.tex @@ -0,0 +1,22 @@ +\newcommand{\EnergyRawSFF}{50} +\newcommand{\EnergyConnectedSFF}{0} +\newcommand{\StructuredFormHalf}{4.476} +\newcommand{\PhysicalFormHalf}{0.502} +\newcommand{\JacobiFormHalf}{0.501} +\newcommand{\GeometricTauOnset}{0.25} +\newcommand{\GeometricLocalOnset}{0.20} +\newcommand{\GeometricRampOnset}{0.40} +\newcommand{\NumberVarianceExtent}{1.0} +\newcommand{\NumberResidualEight}{0.12582} +\newcommand{\NumberResidualEightLower}{0.11428} +\newcommand{\NumberResidualEightUpper}{0.13736} +\newcommand{\PoissonEndpointRatio}{0.385645} +\newcommand{\GUEEndpointRatio}{0.598677} +\newcommand{\StructuredMomenta}{24} +\newcommand{\StructuredOrbits}{12} +\newcommand{\GeometricSamplesPerPoint}{4000} +\newcommand{\SpectralSamplesPerPoint}{4000} +\newcommand{\BootstrapReplicatesVTwo}{10000} +\newcommand{\LargestRankVTwo}{800} +\newcommand{\LargestAtomEachVTwo}{120} +\newcommand{\LargestConnectedPlateau}{0.7} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_numbers_v3.tex b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_numbers_v3.tex new file mode 100644 index 000000000..b3c34e8c3 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_numbers_v3.tex @@ -0,0 +1,30 @@ +% Generated from audited v3 artifacts by the release pipeline. +\newcommand{\MatrixElementBranch}{deformed\_geometric\_eth} +\newcommand{\MatrixElementBranchText}{The four-channel residual decreases along the genuine many-body sequence and retains a resolved connected component at the largest size.} +\newcommand{\LargestManyBodyN}{5} +\newcommand{\LargestManyBodyRank}{36} +\newcommand{\LargestManyBodyDimension}{4368} +\newcommand{\LargestNRFour}{0.20906} +\newcommand{\LargestGaussianRFour}{0.12723} +\newcommand{\LargestGaussianRFourLow}{0.12657} +\newcommand{\LargestGaussianRFourHigh}{0.12797} +\newcommand{\LargestRFourExcess}{0.08183} +\newcommand{\TopologyBranch}{fixed\_chern\_deformed\_holonomy} +\newcommand{\TopologyBranchText}{The Chern class and complete spectrum remain fixed while Wilson statistics change significantly and occupy a structured class distinct from the circular-unitary reference.} +\newcommand{\TopologyPrimaryMesh}{16} +\newcommand{\TopologyConvergenceMesh}{20} +\newcommand{\TopologyNThreeChern}{6} +\newcommand{\TopologyNFourChern}{10} +\newcommand{\TopologyNThreeGap}{0.051741} +\newcommand{\TopologyNFourGap}{0.094695} +\newcommand{\TopologyNThreeGapChangeLow}{0.02777} +\newcommand{\TopologyNThreeGapChangeHigh}{0.05068} +\newcommand{\TopologyNFourGapChangeLow}{0.01805} +\newcommand{\TopologyNFourGapChangeHigh}{0.02835} +\newcommand{\TopologyNThreeFinalGapRatio}{0.32115} +\newcommand{\TopologyNFourFinalGapRatio}{0.33175} +\newcommand{\TopologyNThreeCUERatio}{0.60153} +\newcommand{\TopologyNFourCUERatio}{0.60079} +\newcommand{\TopologyMinimumBranchMargin}{1.17980} +\newcommand{\TopologyMinimumOverlap}{0.83693} +\newcommand{\TopologyGaugeError}{6.85e-15} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_tables_v1.tex b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_tables_v1.tex new file mode 100644 index 000000000..0c6cc0d80 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_tables_v1.tex @@ -0,0 +1,13 @@ +\begin{tabular}{rrrrrr} +\hline\hline +$D$ & $M$ & samples & atoms/edge & $\Delta\langle r\rangle$ & $L^1_{\rm int}$ \\ +\hline +16 & 80 & 2000 & 0 & 0.03023 & 0.43375 \\ +50 & 140 & 2000 & 0 & 0.00767 & 0.22916 \\ +112 & 216 & 2000 & 0 & 0.00403 & 0.14094 \\ +210 & 308 & 1000 & 0 & 0.00173 & 0.09624 \\ +352 & 416 & 1000 & 0 & 0.00290 & 0.06866 \\ +546 & 540 & 500 & 6 & 0.00024 & 0.05149 \\ +800 & 680 & 250 & 120 & 0.00423 & 0.05226 \\ +\hline\hline +\end{tabular} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_tables_v2.tex b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_tables_v2.tex new file mode 100644 index 000000000..9e38a3fb2 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_tables_v2.tex @@ -0,0 +1,13 @@ +\begin{tabular}{rrrr} +\hline\hline +$g$ & $\langle r_F\rangle$ & lower & upper \\ +\hline +0.02 & 0.577596 & 0.575437 & 0.579755 \\ +0.05 & 0.590540 & 0.589162 & 0.591919 \\ +0.10 & 0.594497 & 0.592683 & 0.596310 \\ +0.20 & 0.598927 & 0.597464 & 0.600390 \\ +0.40 & 0.599034 & 0.597900 & 0.600167 \\ +0.70 & 0.599670 & 0.597824 & 0.601517 \\ +1.00 & 0.600307 & 0.598866 & 0.601749 \\ +\hline\hline +\end{tabular} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_tables_v3.tex b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_tables_v3.tex new file mode 100644 index 000000000..aad5da441 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/generated_tables_v3.tex @@ -0,0 +1,10 @@ +% Generated from audited v3 artifacts by the release pipeline. +\newcommand{\MatrixElementResultRows}{% +3 & 8 & 16 & 120 & 0.055872 & 0.37093 & 0.21708 & 0.15385 \\ +4 & 10 & 25 & 715 & 0.103502 & 0.24715 & 0.14638 & 0.10078 \\ +5 & 12 & 36 & 4368 & 0.093593 & 0.20906 & 0.12723 & 0.08183 \\ +} +\newcommand{\TopologyResultRows}{% +3 & 16 & 6 & 0.051741 & 2.06643 & 0.85325 & 0.32115 & 0.60153 \\ +4 & 25 & 10 & 0.094695 & 1.17980 & 0.83693 & 0.33175 & 0.60079 \\ +} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/geometric_eth_topology_assets_v3.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/geometric_eth_topology_assets_v3.json new file mode 100644 index 000000000..adca74dc2 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/geometric_eth_topology_assets_v3.json @@ -0,0 +1,24 @@ +{ + "generated_utc": "2026-07-30T11:23:45.133228+00:00", + "git_commit": "854fe38e71d93c24fa02ec3db3f8363db27067d6", + "input_hashes": { + "output/figure_6_wick_factorization_v3.pdf": "214191d7b885e6638758df3d6d245efada7b67e17dddf9362b89aa6f16639ade", + "output/figure_7_topological_holonomy_v3.pdf": "11e101309d975a61a3efedb1025c2552149c7f1a6f72433594f4adb1c0a16258", + "output/matrix_element_delivery_audit_v3.json": "64974e1b3db8bc15dccd16041ce06912c076281cba2234c557868ef72bbf4769", + "output/matrix_element_geometric_eth_v3.json": "bbacad6f795559f417c1e39c034a6fe51669fd509a983099c10965fb68ee34a3", + "output/topological_holonomy_delivery_audit_v3.json": "224d546389ccd4cec53343c6db789d449b988eda88f8b8efee84628b8892f42b", + "output/topological_holonomy_v3.json": "ff15e7cd2f947b43da5a5973bb82c50319b164877883d187c7c46b2a073823c6" + }, + "matrix_branch": "deformed_geometric_eth", + "output_hashes": { + "output/generated_numbers_v3.tex": "c2be6699d9f461342c2b320aa647628dd28ddde05cc7d41b15e74d5cd135e5dd", + "output/generated_tables_v3.tex": "de39deac3dcac0b9bcc84f51b46d94dbfcf47f094ad457cdf3c4835ae940e6c8" + }, + "overleaf_hashes": { + "overleaf_sync/geometric_eth_large_scale/generated/generated_numbers_v3.tex": "c2be6699d9f461342c2b320aa647628dd28ddde05cc7d41b15e74d5cd135e5dd", + "overleaf_sync/geometric_eth_large_scale/generated/generated_tables_v3.tex": "de39deac3dcac0b9bcc84f51b46d94dbfcf47f094ad457cdf3c4835ae940e6c8" + }, + "source_sha256": "0eeeba6cafe8bee7b706e29c707170503be13beb200809afc4b2c0bc482c9824", + "topology_branch": "fixed_chern_deformed_holonomy", + "version": "v3" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/geometric_eth_topology_delivery_audit_v3.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/geometric_eth_topology_delivery_audit_v3.json new file mode 100644 index 000000000..fd68eb262 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/geometric_eth_topology_delivery_audit_v3.json @@ -0,0 +1,191 @@ +{ + "archived_pdf_sha256": "a75377f76acd78eb3354e186a57933abdf11abbbe5e9a8abd43482ca8c4e05ad", + "checks": { + "affiliations_visible": true, + "all_pages_rendered_180dpi": true, + "asset_branches_exact": true, + "citation_audit_passes": true, + "code_and_data_availability_visible": true, + "condensed_matter_mechanism_visible": true, + "generated_assets_synchronized": true, + "latex_boxes_within_width": true, + "latex_citations_resolved": true, + "latex_control_sequences_resolved": true, + "latex_floats_placed": true, + "latex_references_resolved": true, + "matrix_audit_passes": true, + "matrix_branch_exact": true, + "matrix_result_visible": true, + "pdf_archive_byte_identical": true, + "pdf_author_metadata": true, + "pdf_page_count": true, + "pdf_title_metadata": true, + "scientific_scope_visible": true, + "seven_figures_present_and_synchronized": true, + "theory_audit_passes": true, + "topology_audit_passes": true, + "topology_branch_exact": true, + "topology_result_visible": true + }, + "figures": [ + { + "exists": true, + "name": "figure_1_spectral_silence_v2.pdf", + "sha256": "b3c5967fb225d6a3adaa52adff34017bec1034111fa9cc669d33af661aa70d8a", + "source_hash_matches": true + }, + { + "exists": true, + "name": "figure_2_falsification_triangle_v2.pdf", + "sha256": "3a573402c85fb6c39dfd3439f468a5c9a5369bbd8379b23fdd6cec68c1b31658", + "source_hash_matches": true + }, + { + "exists": true, + "name": "figure_3_independent_channels_v2.pdf", + "sha256": "28bad44f157c0fdc418d9c56ba218e245890d6e3bea327bcd8ff5f0dfa145d95", + "source_hash_matches": true + }, + { + "exists": true, + "name": "figure_4_geometric_hierarchy_v2.pdf", + "sha256": "56367dc2c3d2cd1c9d9c5af0e5b6a1b62bb635c8d9115dffb71d2f633b5aeef2", + "source_hash_matches": true + }, + { + "exists": true, + "name": "figure_5_jacobi_atoms_v2.pdf", + "sha256": "80f9a9ed0073ca4bc2253417ccba816875469a6bfef5c3217353c77eaa7bc1f8", + "source_hash_matches": true + }, + { + "exists": true, + "name": "figure_6_wick_factorization_v3.pdf", + "sha256": "57efed4dfd0fb77858c52980e50c468d064300505dcdfb0a635ce47f89ce0c1e", + "source_hash_matches": true + }, + { + "exists": true, + "name": "figure_7_topological_holonomy_v3.pdf", + "sha256": "11e101309d975a61a3efedb1025c2552149c7f1a6f72433594f4adb1c0a16258", + "source_hash_matches": true + } + ], + "generated_utc": "2026-07-28T17:56:25.073072+00:00", + "main_pdf_sha256": "a75377f76acd78eb3354e186a57933abdf11abbbe5e9a8abd43482ca8c4e05ad", + "matrix_branch": "deformed_geometric_eth", + "page_count": 17, + "passed": true, + "rendered_pages": [ + { + "height": 1980, + "page": 1, + "sha256": "9bea520991372f8dfe6bc823d71f475b1ec5f90148ba78b49c39907c733d38af", + "width": 1530 + }, + { + "height": 1980, + "page": 2, + "sha256": "c1041945968ceb54fe736585414d6369f489589b2c84caa856aa6f25ec4209c3", + "width": 1530 + }, + { + "height": 1980, + "page": 3, + "sha256": "46d310514722ff1162231e77d8a992956c64eaf2666b33c65a434d5d7209772e", + "width": 1530 + }, + { + "height": 1980, + "page": 4, + "sha256": "a1cf60f8a747c2bb108b5a7e59f56fcb92be05be5139998fd2301b9ce2ee02d5", + "width": 1530 + }, + { + "height": 1980, + "page": 5, + "sha256": "3b059a18b797e5ff71aca74d3b5f052f30849b295246cc0a87c75fdef15e6108", + "width": 1530 + }, + { + "height": 1980, + "page": 6, + "sha256": "4c50fe354fbe90baca936139a682d45e0f8b52ba13ab5c6aec451c5ba6f7f17a", + "width": 1530 + }, + { + "height": 1980, + "page": 7, + "sha256": "726f3feabc501c57f6f3f5b1b5d57771a256f9cb235d079f5c32fef828a361ee", + "width": 1530 + }, + { + "height": 1980, + "page": 8, + "sha256": "10552afcd0e4f62875f835f34c1bbca96d2e8385b3edddeb406978c396d6a34c", + "width": 1530 + }, + { + "height": 1980, + "page": 9, + "sha256": "c0b7e4951b8bdd83f7b9ca572468dcfbb1a0b05ed64e1129ad38d289413c7075", + "width": 1530 + }, + { + "height": 1980, + "page": 10, + "sha256": "5bcbf2270ea5b896f77d50366bbdb2deb56e09ea0093322f2dd5c1b8cce1698d", + "width": 1530 + }, + { + "height": 1980, + "page": 11, + "sha256": "d3e66b6142c34ff99c114301931f3f512bdce63a2fe99c99c6fcc7bc9ac28ed7", + "width": 1530 + }, + { + "height": 1980, + "page": 12, + "sha256": "d50fd9311b0b0c24ec23d48c51c254e19ca25ed017f6ce54e91662ad92dcd4b0", + "width": 1530 + }, + { + "height": 1980, + "page": 13, + "sha256": "2ead3f1c9124366142d201d870519b78fddcb087461c570cc5ce914e3dbbaa9b", + "width": 1530 + }, + { + "height": 1980, + "page": 14, + "sha256": "aa814376a5e0b0641e49c08e4d2358925b5b1da851b356f74dccc1392acb5a53", + "width": 1530 + }, + { + "height": 1980, + "page": 15, + "sha256": "3b5be1f1448f69ba571edd18af599ed21f53e419284c08a9fce4d7fbb52f8d4b", + "width": 1530 + }, + { + "height": 1980, + "page": 16, + "sha256": "4e7511ef8a4698e3696d0c7728230b1f44262acba439399cddf1a5d108779aa8", + "width": 1530 + }, + { + "height": 1980, + "page": 17, + "sha256": "31811a36736f793937f5e030655edb700cdaa87e2222a609f5857f4e1a5d06a9", + "width": 1530 + } + ], + "source_hashes": { + "overleaf_sync/geometric_eth_large_scale/appendices/matrix-element-topology-v3.tex": "353063581810778af33a48926f91c99ec61ef06793ee18f50cea986cb559c1df", + "overleaf_sync/geometric_eth_large_scale/main.tex": "8ecbe5e96c7e2607593550aa7ea4be31b278b23c07c0e4d64fa2bbcc9ebb5ffb", + "overleaf_sync/geometric_eth_large_scale/references.bib": "06f716aa69d80021030ff8683c18b7521d792d1ae6851b73e2e17eb1c93cb9bf", + "overleaf_sync/geometric_eth_large_scale/sections/08-matrix-elements-topology.tex": "4ce73de2129c97a608e94ecc85cedd89310207f5389ac43e67424624194bee32" + }, + "topology_branch": "fixed_chern_deformed_holonomy", + "version": "v3" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/large_scale_delivery_audit_v1.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/large_scale_delivery_audit_v1.json new file mode 100644 index 000000000..114fff03c --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/large_scale_delivery_audit_v1.json @@ -0,0 +1,111 @@ +{ + "schema_version": 1, + "article": "From Local Repulsion to Global Geometry: Large-Scale Tests of Geometric ETH", + "checks": { + "physical_registered_scale": true, + "covariance_registered_scale": true, + "rank_cases_and_samples_exact": true, + "largest_rank_present": true, + "exact_atom_counts": true, + "interior_statistics_strip_atoms": true, + "matrix_level_inference_only": true, + "statistics_checks_pass": true, + "figure_inputs_hashed": true, + "figure_outputs_hashed": true, + "figures_synchronized": true, + "generated_inputs_synchronized": true, + "citation_metadata_verified": true, + "all_citation_keys_resolve": true, + "chen_seed_is_cited": true, + "article_pdf_archived": true, + "pdf_page_count_in_contract": true, + "pdf_title_metadata": true, + "pdf_author_metadata": true, + "pdf_affiliations_visible": true, + "all_pdf_pages_rendered": true, + "no_undefined_control_sequence": true, + "no_undefined_references": true, + "no_undefined_citations": true, + "no_overfull_boxes": true, + "no_stuck_floats": true, + "pytest_complete_if_recorded": true + }, + "all_checks_pass": true, + "pdf": { + "path": "overleaf_sync/geometric_eth_large_scale/main.pdf", + "sha256": "aae68de7569aae83c7ff500718ab0e3635595f050f5b7afc0d60a0e63db55417", + "pages": 10, + "title": "From Local Repulsion to Global Geometry: Large-Scale Tests of Geometric ETH", + "author": "Thomas J. Wang; OKongOYangO" + }, + "rendered_pages": [ + { + "page": 1, + "width": 1275, + "height": 1650, + "sha256": "aa0fb67735805e9f5e3d754193608fec935428e67b981cb3cd50a93b2b4d3152" + }, + { + "page": 2, + "width": 1275, + "height": 1650, + "sha256": "a812221603d15a3f8b584d32bb93af67d81176bd619f0dc5596ec804b9eebdf8" + }, + { + "page": 3, + "width": 1275, + "height": 1650, + "sha256": "99cbec18f7249447f0abbc5d764a2af5b37222f3e33e7779a30e34bb5f4130ac" + }, + { + "page": 4, + "width": 1275, + "height": 1650, + "sha256": "f0ed164a3680a6ba2f90f6c084267d4e11998a5b64118b81cd0185d0d174fbfb" + }, + { + "page": 5, + "width": 1275, + "height": 1650, + "sha256": "2178d837d24cdb6202eb6b2505b90822fe892327387760728e101fdeaf59ce1e" + }, + { + "page": 6, + "width": 1275, + "height": 1650, + "sha256": "067f12f179f909026b765c6306e870a2a60a331c34e1a435a51dec9c4683d4f9" + }, + { + "page": 7, + "width": 1275, + "height": 1650, + "sha256": "9e867911fd9c3f9da19cbffaa2ba6f0755672741bf144637d5c24725cba042a2" + }, + { + "page": 8, + "width": 1275, + "height": 1650, + "sha256": "6cb4e03169e76dbf4f326b7d6e361a76b33f1b8823b53682be96f3cd30128575" + }, + { + "page": 9, + "width": 1275, + "height": 1650, + "sha256": "cf4085b74db94bf62e56842c23ccf9ff5c72a7d5c2d0021bd46588cd2d1b972a" + }, + { + "page": 10, + "width": 1275, + "height": 1650, + "sha256": "dbab6f650e5083bc73b2ecc954a84ed49e8bb97ef6a651b561e06eb72c0a988c" + } + ], + "pytest_passed": 14, + "registered_scale": { + "physical_matrices": 20000, + "haar_matrices": 10000, + "deformed_matrices": 10000, + "root_matrices": 8750, + "maximum_rank": 800 + } +} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/matrix_element_delivery_audit_v3.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/matrix_element_delivery_audit_v3.json new file mode 100644 index 000000000..1e6086c86 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/matrix_element_delivery_audit_v3.json @@ -0,0 +1,59 @@ +{ + "arrays_sha256": "c817a758fd03710483883840758a28ba2d5d9c74270a8f30ad71874a6336262c", + "checkpoint_hashes": { + "output/matrix_element_v3_checkpoints/N3_site_response_v3.json": "dfb2aeb2d03b1a0ffaff37a4c3b275142bb8d1747e7793c31843e520567cc842", + "output/matrix_element_v3_checkpoints/N3_site_response_v3.npz": "3c3736d0b00d5406dc7eae33a532c2d014ce7af4551bbf9df865e3aa0d94e7db", + "output/matrix_element_v3_checkpoints/N4_site_response_v3.json": "1efc0052ea61c84ff5a7ef88fe3f46c3d997dd5dd5ee116314cfc523144e820f", + "output/matrix_element_v3_checkpoints/N4_site_response_v3.npz": "b0211c60560b60e1d2355bc8b839e38fa44232d8e2f5cf0481dcb479d912b0cc", + "output/matrix_element_v3_checkpoints/N5_site_response_v3.json": "2e850a0e13807a99b138af22d0c5d5bb81c7f907adc46689051927021708683c", + "output/matrix_element_v3_checkpoints/N5_site_response_v3.npz": "c974be5d3a89167b20f12c0119b0ab85cffad0bb94a484bac182974cbe2d1690" + }, + "checks": { + "all_case_checks": true, + "all_runner_checks": true, + "branch_recomputed": true, + "checkpoint_provenance": true, + "figure_pdf_hash": true, + "figure_png_hash": true, + "figure_source_hash": true, + "fixed_two_quasiholes": true, + "gauge_invariance": true, + "kernel_residuals": true, + "n2_exclusion": true, + "npz_hash": true, + "panel_counts": true, + "panel_size": true, + "reference_counts": true, + "registered_sequence": true, + "resolvent_residuals": true, + "task_isolation": true + }, + "figure": { + "pdf": "output/figure_6_wick_factorization_v3.pdf", + "pdf_sha256": "57efed4dfd0fb77858c52980e50c468d064300505dcdfb0a635ce47f89ce0c1e", + "png": "output/figure_6_wick_factorization_v3.png", + "png_sha256": "7cf914a353f9849b86299669c99577c16c9994d7d7814c6dad2e2537698035ce" + }, + "generated_utc": "2026-07-28T17:53:50.429230+00:00", + "passed": true, + "registered_cases": [ + [ + 3, + 8, + 16 + ], + [ + 4, + 10, + 25 + ], + [ + 5, + 12, + 36 + ] + ], + "result_branch": "deformed_geometric_eth", + "result_sha256": "bbacad6f795559f417c1e39c034a6fe51669fd509a983099c10965fb68ee34a3", + "version": "v3" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/matrix_element_geometric_eth_v3.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/matrix_element_geometric_eth_v3.json new file mode 100644 index 000000000..434cc2402 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/matrix_element_geometric_eth_v3.json @@ -0,0 +1,260 @@ +{ + "cases": [ + { + "A_left_median": 1.0337871767487445, + "B_right_median": 0.4591201707656233, + "N": 3, + "basis_dimension": 120, + "channel_condition_maximum": 1.9230573075703374, + "checkpoint_identity_hash": "1afa67e9b13f549fc9f0c827dcc8121a04819cef8355a4f66dad95bd871c1b17", + "checkpoint_reused": true, + "checks": { + "channel_support": true, + "external_gap": true, + "gauge_invariance": true, + "kernel_count": true, + "kernel_leakage": true, + "kernel_orthonormality": true, + "kernel_residual": true, + "reference_reproducibility": true, + "resolvent_residual": true, + "resolvent_shift_stability": true + }, + "external_gap": 0.05587158457606091, + "gauge_invariance_error": 1.1102230246251565e-16, + "gaussian_R4_interval": [ + 0.21035268425907352, + 0.2170768049327242, + 0.2240311017060241 + ], + "kernel_method": "dense", + "kernel_orthonormality_error": 5.064070131460184e-15, + "kernel_residual_norm": 1.8364549518527542e-15, + "lattice_length": 4, + "maximum_kernel_leakage": 3.4813493349969177e-16, + "maximum_relative_residual": 4.205947063973937e-08, + "maximum_shift_difference": 0.0001682088682599058, + "n_flux": 8, + "physical_R4": [ + 0.37092804021869497, + 0.3709280402186949, + 0.3709280402186955, + 0.3709280402186954, + 0.3709280402186953, + 0.37092804021869524, + 0.37092804021869497, + 0.3709280402186953, + 0.3709280402186955, + 0.37092804021869513, + 0.37092804021869535, + 0.3709280402186952, + 0.3709280402186952, + 0.370928040218695, + 0.3709280402186955, + 0.37092804021869524, + 0.3709280402186952, + 0.3709280402186953, + 0.3709280402186951, + 0.37092804021869535, + 0.37092804021869513, + 0.37092804021869524, + 0.37092804021869547, + 0.3709280402186953 + ], + "physical_R4_interval": [ + 0.37092804021869497, + 0.3709280402186955 + ], + "physical_R4_median": 0.37092804021869524, + "physical_excess": 0.15385123528597106, + "physical_sites": 16, + "rank": 16, + "structured_R4": 0.31620553613980085 + }, + { + "A_left_median": 1.0306625500884357, + "B_right_median": 0.32679230068826104, + "N": 4, + "basis_dimension": 715, + "channel_condition_maximum": 2.4531105998959397, + "checkpoint_identity_hash": "466daf03ecb07cd6f047ebe127c6b4e5df5ebc328fa928728bd09969cf51acc8", + "checkpoint_reused": false, + "checks": { + "channel_support": true, + "external_gap": true, + "gauge_invariance": true, + "kernel_count": true, + "kernel_leakage": true, + "kernel_orthonormality": true, + "kernel_residual": true, + "reference_reproducibility": true, + "resolvent_residual": true, + "resolvent_shift_stability": true + }, + "external_gap": 0.10350201769468284, + "gauge_invariance_error": 2.7755575615628914e-16, + "gaussian_R4_interval": [ + 0.14435085299826975, + 0.1463765411819804, + 0.14846039310052878 + ], + "kernel_method": "dense", + "kernel_orthonormality_error": 6.797387329201048e-15, + "kernel_residual_norm": 5.863505236909703e-15, + "lattice_length": 5, + "maximum_kernel_leakage": 5.802433938271523e-16, + "maximum_relative_residual": 2.3039558436378714e-07, + "maximum_shift_difference": 0.000368294971499318, + "n_flux": 10, + "physical_R4": [ + 0.24715443908737408, + 0.24715439786029716, + 0.24803483410453325, + 0.2508999674715549, + 0.24893505628320103, + 0.2503588517789534, + 0.24967707748618723, + 0.24715439786029678, + 0.24715439786029714, + 0.24890400854185118, + 0.2471543978602974, + 0.24715443908737364, + 0.24715443908737345, + 0.2480738027546365, + 0.24715443908737456, + 0.2489350562832004, + 0.24936812447484447, + 0.2488742848205509, + 0.2471543978602974, + 0.2503570733487909, + 0.2471543978602974, + 0.24715443908737375, + 0.24715439786029736, + 0.24715443908737375 + ], + "physical_R4_interval": [ + 0.24715439786029697, + 0.25058882594830906 + ], + "physical_R4_median": 0.24715443908737433, + "physical_excess": 0.10077789790539393, + "physical_sites": 25, + "rank": 25, + "structured_R4": 0.18299079904955376 + }, + { + "A_left_median": 1.027415764452215, + "B_right_median": 0.2616908324642291, + "N": 5, + "basis_dimension": 4368, + "channel_condition_maximum": 2.665825661555895, + "checkpoint_identity_hash": "3642c3b9df55cd1ef476b1846409492d3335a958175367472c0a4c31a369051e", + "checkpoint_reused": false, + "checks": { + "channel_support": true, + "external_gap": true, + "gauge_invariance": true, + "kernel_count": true, + "kernel_leakage": true, + "kernel_orthonormality": true, + "kernel_residual": true, + "reference_reproducibility": true, + "resolvent_residual": true, + "resolvent_shift_stability": true + }, + "external_gap": 0.09359267473728361, + "gauge_invariance_error": 6.106226635438361e-16, + "gaussian_R4_interval": [ + 0.12656949892693797, + 0.1272320116226513, + 0.1279674613944359 + ], + "kernel_method": "lobpcg", + "kernel_orthonormality_error": 1.4734332105949315e-14, + "kernel_residual_norm": 3.5939635755216004e-09, + "lattice_length": 6, + "maximum_kernel_leakage": 1.835217417999543e-15, + "maximum_relative_residual": 2.748495196784207e-07, + "maximum_shift_difference": 0.000394220850344771, + "n_flux": 12, + "physical_R4": [ + 0.20799889727542145, + 0.209384918240283, + 0.20793744717157228, + 0.2133435127370933, + 0.20729291165496086, + 0.20924566982926673, + 0.2081836905905184, + 0.21334406431145198, + 0.20728121751787829, + 0.2093831466795674, + 0.2074267007564119, + 0.2079272854299863, + 0.20821798058122704, + 0.20954108370663413, + 0.20715603698955812, + 0.2067732358120536, + 0.209046025352302, + 0.2090725293206072, + 0.20936645071815296, + 0.2092456698276862, + 0.20954658865536369, + 0.20924405800421947, + 0.20765104911542387, + 0.20907837481209515 + ], + "physical_R4_interval": [ + 0.20699334648911868, + 0.21334374715619572 + ], + "physical_R4_median": 0.20905927733645457, + "physical_excess": 0.08182726571380328, + "physical_sites": 36, + "rank": 36, + "structured_R4": 0.14494761427530609 + } + ], + "checks": { + "channel_support": true, + "external_gap": true, + "gauge_invariance": true, + "kernel_count": true, + "n2_excluded_before_production": true, + "reference_reproducibility": true, + "resolvent_residual": true + }, + "configuration": { + "case_indices": [ + 0, + 1, + 2 + ], + "gaussian_samples": 2000, + "panel_size": 8, + "panels": 24, + "production": true, + "relative_shifts": [ + 0.001, + 0.0005 + ], + "seed": 20260728320 + }, + "descriptive_slope_per_particle": -0.08093438144112026, + "environment": { + "numpy": "2.3.5", + "platform": "macOS-15.6-arm64-arm-64bit", + "python": "3.12.11" + }, + "excluded_small_case": { + "N": 2, + "accepted": false, + "expected_rank": 9, + "n_flux": 6, + "observed_rank": 12 + }, + "generated_utc": "2026-07-28T15:42:01.770489+00:00", + "npz_sha256": "c817a758fd03710483883840758a28ba2d5d9c74270a8f30ad71874a6336262c", + "result_branch": "deformed_geometric_eth", + "runtime_seconds": 267.24987595900166, + "version": "v3" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/matrix_element_geometric_eth_v3.npz b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/matrix_element_geometric_eth_v3.npz new file mode 100644 index 000000000..1917300bf Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/matrix_element_geometric_eth_v3.npz differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/matrix_element_topology_theory_v3.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/matrix_element_topology_theory_v3.json new file mode 100644 index 000000000..7f8ba3b95 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/matrix_element_topology_theory_v3.json @@ -0,0 +1,30 @@ +{ + "checks": { + "chern_branch": true, + "chern_isomorphism": true, + "gauge_R4": true, + "gauge_tensor": true, + "gram_reduction": true, + "wick_monte_carlo": true + }, + "gauge_and_gram": { + "R4_error": 1.1102230246251565e-16, + "gram_spectrum_error": 6.661338147750939e-16, + "tensor_error": 3.3306690738754696e-15 + }, + "generated_utc": "2026-07-28T17:54:45.183871+00:00", + "passed": true, + "topology": { + "chern_after": -0.9999999999999991, + "chern_before": -0.9999999999999994, + "chern_error": 3.3306690738754696e-16, + "minimum_branch_margin": 3.0518857391907717 + }, + "version": "v3", + "wick": { + "A_left": 1.0850661625708886, + "B_right": 0.6469893742621016, + "maximum_absolute_error": 0.00937106043678515, + "relative_error": 0.007298791405822385 + } +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/physical_ensemble_v1.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/physical_ensemble_v1.json new file mode 100644 index 000000000..4fbd4088f --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/physical_ensemble_v1.json @@ -0,0 +1,49 @@ +{ + "schema_version": 1, + "version": "v1", + "generated_utc": "2026-07-28T08:33:44.010905+00:00", + "physical_case": { + "N": 3, + "n": 10, + "D": 50, + "M": 170 + }, + "sample_count": 20000, + "seed": 20260728110, + "seed_blocks": 8, + "split": { + "train": 12000, + "validation": 4000, + "test": 4000, + "split_seed": 20260728111 + }, + "parent": { + "kernel_bandwidth": 5.782554623436307e-16, + "external_gap": 0.10667223401027637 + }, + "jacobi_parameters": { + "interior_dimension": 50, + "exponent": 120, + "plus_atoms": 0, + "minus_atoms": 0 + }, + "observed_exact_atoms": 0, + "checks": { + "registered_rank_is_50": true, + "parent_kernel_exact": true, + "parent_gap_open": true, + "all_active_ranks_are_full": true, + "all_curvature_ranks_are_full": true, + "normalized_spectra_bounded": true, + "no_exact_atoms": true, + "split_complete_and_disjoint": true, + "all_seed_blocks_nonempty": true + }, + "all_checks_pass": true, + "runtime_seconds": 60.13297541701468, + "environment": { + "python": "3.12.11", + "numpy": "2.3.5", + "platform": "macOS-15.6-arm64-arm-64bit" + } +} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/pytest_v1.txt b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/pytest_v1.txt new file mode 100644 index 000000000..877921d81 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/pytest_v1.txt @@ -0,0 +1,2 @@ +.............. [100%] +14 passed in 11.17s diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/pytest_v2.txt b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/pytest_v2.txt new file mode 100644 index 000000000..99f723bb6 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/pytest_v2.txt @@ -0,0 +1,2 @@ +.................................. [100%] +34 passed in 272.07s (0:04:32) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/rank_scaling_v1.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/rank_scaling_v1.json new file mode 100644 index 000000000..868a54c0a --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/rank_scaling_v1.json @@ -0,0 +1,256 @@ +{ + "schema_version": 1, + "version": "v1", + "generated_utc": "2026-07-28T08:35:02.824333+00:00", + "registered_cases": [ + { + "n": 8, + "samples": 2000 + }, + { + "n": 10, + "samples": 2000 + }, + { + "n": 12, + "samples": 2000 + }, + { + "n": 14, + "samples": 1000 + }, + { + "n": 16, + "samples": 1000 + }, + { + "n": 18, + "samples": 500 + }, + { + "n": 20, + "samples": 250 + } + ], + "response_entry_ceiling": 1200000, + "cases": [ + { + "algorithm_version": 1, + "status": "computed", + "N": 3, + "n": 8, + "D": 16, + "M": 80, + "samples": 2000, + "ambient_hilbert_dimension": 120, + "response_entries": 2560, + "response_nonzero_terms": 264, + "interior_dimension": 16, + "plus_atoms_per_matrix": 0, + "minus_atoms_per_matrix": 0, + "observed_plus_atoms_per_matrix": 0, + "observed_minus_atoms_per_matrix": 0, + "maximum_atom_residual": 0.0, + "mean_gap_ratio": 0.5674868848544262, + "reference_mean_gap_ratio": 0.5977145859796825, + "gap_ratio_difference": 0.0302277011252563, + "interior_density_l1": 0.43374999999999997, + "mean_participation": 0.7739430069923401, + "mean_polarization": 0.08836133033037186, + "mean_frame_overlap": 1.8609070777893066, + "minimum_condition_indicator": 0.5486060976982117, + "seed_blocks": 8, + "frame_pairs": 64, + "runtime_seconds": 0.5367333339527249 + }, + { + "algorithm_version": 1, + "status": "computed", + "N": 3, + "n": 10, + "D": 50, + "M": 140, + "samples": 2000, + "ambient_hilbert_dimension": 220, + "response_entries": 14000, + "response_nonzero_terms": 850, + "interior_dimension": 50, + "plus_atoms_per_matrix": 0, + "minus_atoms_per_matrix": 0, + "observed_plus_atoms_per_matrix": 0, + "observed_minus_atoms_per_matrix": 0, + "maximum_atom_residual": 0.0, + "mean_gap_ratio": 0.5913950982731334, + "reference_mean_gap_ratio": 0.5990684049135373, + "gap_ratio_difference": 0.0076733066404038874, + "interior_density_l1": 0.22915999999999997, + "mean_participation": 0.8541274666786194, + "mean_polarization": 0.06554102152585983, + "mean_frame_overlap": 10.027185440063477, + "minimum_condition_indicator": 0.50236976146698, + "seed_blocks": 8, + "frame_pairs": 64, + "runtime_seconds": 1.8429892919957638 + }, + { + "algorithm_version": 1, + "status": "computed", + "N": 3, + "n": 12, + "D": 112, + "M": 216, + "samples": 2000, + "ambient_hilbert_dimension": 364, + "response_entries": 48384, + "response_nonzero_terms": 1932, + "interior_dimension": 112, + "plus_atoms_per_matrix": 0, + "minus_atoms_per_matrix": 0, + "observed_plus_atoms_per_matrix": 0, + "observed_minus_atoms_per_matrix": 0, + "maximum_atom_residual": 0.0, + "mean_gap_ratio": 0.5955983903319454, + "reference_mean_gap_ratio": 0.5996246403468026, + "gap_ratio_difference": 0.0040262500148572355, + "interior_density_l1": 0.1409375, + "mean_participation": 0.8947614431381226, + "mean_polarization": 0.04753073304891586, + "mean_frame_overlap": 31.290069580078125, + "minimum_condition_indicator": 0.39761537313461304, + "seed_blocks": 8, + "frame_pairs": 64, + "runtime_seconds": 10.332598124979995 + }, + { + "algorithm_version": 1, + "status": "computed", + "N": 3, + "n": 14, + "D": 210, + "M": 308, + "samples": 1000, + "ambient_hilbert_dimension": 560, + "response_entries": 129360, + "response_nonzero_terms": 3654, + "interior_dimension": 210, + "plus_atoms_per_matrix": 0, + "minus_atoms_per_matrix": 0, + "observed_plus_atoms_per_matrix": 0, + "observed_minus_atoms_per_matrix": 0, + "maximum_atom_residual": 0.0, + "mean_gap_ratio": 0.598245476096163, + "reference_mean_gap_ratio": 0.5999740549930559, + "gap_ratio_difference": 0.0017285788968929294, + "interior_density_l1": 0.09623809523809523, + "mean_participation": 0.9212465882301331, + "mean_polarization": 0.036290060728788376, + "mean_frame_overlap": 76.02349090576172, + "minimum_condition_indicator": 0.4134574234485626, + "seed_blocks": 8, + "frame_pairs": 64, + "runtime_seconds": 20.69240291696042 + }, + { + "algorithm_version": 1, + "status": "computed", + "N": 3, + "n": 16, + "D": 352, + "M": 416, + "samples": 1000, + "ambient_hilbert_dimension": 816, + "response_entries": 292864, + "response_nonzero_terms": 6160, + "interior_dimension": 352, + "plus_atoms_per_matrix": 0, + "minus_atoms_per_matrix": 0, + "observed_plus_atoms_per_matrix": 0, + "observed_minus_atoms_per_matrix": 0, + "maximum_atom_residual": 0.0, + "mean_gap_ratio": 0.5971383403929288, + "reference_mean_gap_ratio": 0.6000358759105635, + "gap_ratio_difference": 0.0028975355176347195, + "interior_density_l1": 0.06866477272727273, + "mean_participation": 0.9409668445587158, + "mean_polarization": 0.02879468910396099, + "mean_frame_overlap": 155.65829467773438, + "minimum_condition_indicator": 0.38474777340888977, + "seed_blocks": 8, + "frame_pairs": 64, + "runtime_seconds": 69.71186254202621 + }, + { + "algorithm_version": 1, + "status": "computed", + "N": 3, + "n": 18, + "D": 546, + "M": 540, + "samples": 500, + "ambient_hilbert_dimension": 1140, + "response_entries": 589680, + "response_nonzero_terms": 9594, + "interior_dimension": 534, + "plus_atoms_per_matrix": 6, + "minus_atoms_per_matrix": 6, + "observed_plus_atoms_per_matrix": 6, + "observed_minus_atoms_per_matrix": 6, + "maximum_atom_residual": 0.0, + "mean_gap_ratio": 0.5989738714766181, + "reference_mean_gap_ratio": 0.5992133759201933, + "gap_ratio_difference": 0.0002395044435752336, + "interior_density_l1": 0.05149063670411985, + "mean_participation": 0.9570626020431519, + "mean_polarization": 0.021711314097046852, + "mean_frame_overlap": 284.7558898925781, + "minimum_condition_indicator": 0.3249030113220215, + "seed_blocks": 8, + "frame_pairs": 24, + "runtime_seconds": 139.20574812497944 + }, + { + "algorithm_version": 1, + "status": "computed", + "N": 3, + "n": 20, + "D": 800, + "M": 680, + "samples": 250, + "ambient_hilbert_dimension": 1540, + "response_entries": 1088000, + "response_nonzero_terms": 14100, + "interior_dimension": 560, + "plus_atoms_per_matrix": 120, + "minus_atoms_per_matrix": 120, + "observed_plus_atoms_per_matrix": 120, + "observed_minus_atoms_per_matrix": 120, + "maximum_atom_residual": 0.0, + "mean_gap_ratio": 0.5964631307343461, + "reference_mean_gap_ratio": 0.6006896617152083, + "gap_ratio_difference": 0.004226530980862231, + "interior_density_l1": 0.05225714285714285, + "mean_participation": 0.9699990153312683, + "mean_polarization": 0.015024334192276001, + "mean_frame_overlap": 480.8501892089844, + "minimum_condition_indicator": 0.29457762837409973, + "seed_blocks": 8, + "frame_pairs": 24, + "runtime_seconds": 145.6758758330252 + } + ], + "checks": { + "registered_dimensions_match": true, + "statuses_explicit": true, + "registered_run_has_no_rejections": true, + "registered_sample_counts_unchanged": true, + "atom_counts_match_intersection_theorem": true, + "atom_residual_below_tolerance": true + }, + "all_checks_pass": true, + "runtime_seconds": 0.3101562079973519, + "environment": { + "python": "3.12.11", + "numpy": "2.3.5", + "platform": "macOS-15.6-arm64-arm-64bit" + } +} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/release_manifest_v1.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/release_manifest_v1.json new file mode 100644 index 000000000..7c188d57d --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/release_manifest_v1.json @@ -0,0 +1,334 @@ +{ + "compact_artifacts": [ + { + "path": "01_task_folder/task_05/script/output/citation_audit_v1.json", + "sha256": "fc6ae93ea34a683ca3ded4cb66439a569cddf4b44d0763b3819fa89e62e33e60", + "size_bytes": 35012, + "storage_class": "git" + }, + { + "path": "01_task_folder/task_05/script/output/geometric_eth_topology_assets_v3.json", + "sha256": "5b94879aba1a8c58b9e2d130b4cc5f9539de74b40d666c6acc00308c4406504e", + "size_bytes": 1622, + "storage_class": "git" + }, + { + "path": "01_task_folder/task_05/script/output/geometric_eth_topology_delivery_audit_v3.json", + "sha256": "e1e51369fd919175b22ae3bb00f83480a882c3e0dc299555e868eae87ea34c39", + "size_bytes": 6085, + "storage_class": "git" + }, + { + "path": "01_task_folder/task_05/script/output/matrix_element_delivery_audit_v3.json", + "sha256": "c627de3bb3c7d65b2aab603f8ac01be8314557f740c919990b03748c75d3f715", + "size_bytes": 2163, + "storage_class": "git" + }, + { + "path": "01_task_folder/task_05/script/output/matrix_element_geometric_eth_v3.json", + "sha256": "bbacad6f795559f417c1e39c034a6fe51669fd509a983099c10965fb68ee34a3", + "size_bytes": 7960, + "storage_class": "git" + }, + { + "path": "01_task_folder/task_05/script/output/matrix_element_geometric_eth_v3.npz", + "sha256": "c817a758fd03710483883840758a28ba2d5d9c74270a8f30ad71874a6336262c", + "size_bytes": 53248, + "storage_class": "git" + }, + { + "path": "01_task_folder/task_05/script/output/matrix_element_topology_theory_v3.json", + "sha256": "0d4d13ecb7771e76354f798d3d9e4f3c097be64f6afea6542f2b1236489479a5", + "size_bytes": 808, + "storage_class": "git" + }, + { + "path": "01_task_folder/task_05/script/output/spectral_silence_delivery_audit_v2.json", + "sha256": "11a2730c44fe1a88f414393e88e370ac952659fed9476953acb7570f1b44bf88", + "size_bytes": 4588, + "storage_class": "git" + }, + { + "path": "01_task_folder/task_05/script/output/spectral_silence_statistics_v2.json", + "sha256": "2808020357176fa6f60d0280c509e2dea18b8d472c8a9090f8b6f619a1dfe706", + "size_bytes": 4101, + "storage_class": "git" + }, + { + "path": "01_task_folder/task_05/script/output/spectral_silence_statistics_v2.npz", + "sha256": "ef2bf7bdfea65e595def17d8b08ac0786a86afeb4e57aea71c7472504b7c773e", + "size_bytes": 86073, + "storage_class": "git" + }, + { + "path": "01_task_folder/task_05/script/output/spectral_silence_v2.json", + "sha256": "5a2da65d83ded56a0fbebb23f69d5c26bd41382ebaa5f32a333fb239bffd5778", + "size_bytes": 2792, + "storage_class": "git" + }, + { + "path": "01_task_folder/task_05/script/output/topological_holonomy_delivery_audit_v3.json", + "sha256": "224d546389ccd4cec53343c6db789d449b988eda88f8b8efee84628b8892f42b", + "size_bytes": 2593, + "storage_class": "git" + }, + { + "path": "01_task_folder/task_05/script/output/topological_holonomy_v3.json", + "sha256": "ff15e7cd2f947b43da5a5973bb82c50319b164877883d187c7c46b2a073823c6", + "size_bytes": 10000, + "storage_class": "git" + }, + { + "path": "01_task_folder/task_05/script/output/topological_holonomy_v3.npz", + "sha256": "f459fa37facf82c6f67c44f4961749095fb0817516ff16d6ca6814bbaf952208", + "size_bytes": 3785530, + "storage_class": "git" + } + ], + "external_artifacts": [ + { + "path": "01_task_folder/task_05/script/output/covariance_model_v1.npz", + "producer": "bash run_large_scale_article_v1.sh", + "sha256": "7581adc06ceeb6afb3d5bb5f58f1ca91a1ae9398e45dc09869751989f86a4836", + "size_bytes": 7937484, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/matrix_element_v3_checkpoints/N3_site_response_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "3c3736d0b00d5406dc7eae33a532c2d014ce7af4551bbf9df865e3aa0d94e7db", + "size_bytes": 472086, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/matrix_element_v3_checkpoints/N4_site_response_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "b0211c60560b60e1d2355bc8b839e38fa44232d8e2f5cf0481dcb479d912b0cc", + "size_bytes": 6853101, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/matrix_element_v3_checkpoints/N5_site_response_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "c974be5d3a89167b20f12c0119b0ab85cffad0bb94a484bac182974cbe2d1690", + "size_bytes": 86799435, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/physical_ensemble_v1.npz", + "producer": "bash run_large_scale_article_v1.sh", + "sha256": "cf44e830188f6a7252ff692c0db33ea3f2cd3ce604a37e31b49a80d37ad70652", + "size_bytes": 14416568, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/rank_scaling_v1.npz", + "producer": "bash run_large_scale_article_v1.sh", + "sha256": "0373a6b0ddef31ea0208f0acc3d6feee0bda372058eb2a0d689b0eed92cd4338", + "size_bytes": 17817643, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/rank_scaling_v1_checkpoints/n10_v1.npz", + "producer": "bash run_large_scale_article_v1.sh", + "sha256": "894a8b6f4cdf0ee3815f3e9ac9bffa0496cb1ed0b851e2df9413ff9d498edbe8", + "size_bytes": 1347389, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/rank_scaling_v1_checkpoints/n12_v1.npz", + "producer": "bash run_large_scale_article_v1.sh", + "sha256": "36cd0b76c91176b3735ed36e11f9ec923e938dda556a64bf55cd10e164a2fe49", + "size_bytes": 3002769, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/rank_scaling_v1_checkpoints/n14_v1.npz", + "producer": "bash run_large_scale_article_v1.sh", + "sha256": "d1001f8d2cabe32a31df0b88bf7216ed445c0bf64cec8137e7a095b01c6b1b9a", + "size_bytes": 2817874, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/rank_scaling_v1_checkpoints/n16_v1.npz", + "producer": "bash run_large_scale_article_v1.sh", + "sha256": "0f363271e0c0d116d0078cf679fdfc799117f74cd52d3f89b50d8c3e28fe1caf", + "size_bytes": 4720431, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/rank_scaling_v1_checkpoints/n18_v1.npz", + "producer": "bash run_large_scale_article_v1.sh", + "sha256": "bfd81f652fe2a5a2cc067307e9464bd533e8dd27e3551d7c41e258023e997f6b", + "size_bytes": 3581467, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/rank_scaling_v1_checkpoints/n20_v1.npz", + "producer": "bash run_large_scale_article_v1.sh", + "sha256": "1b645babf65da6069642d57d3e3eba9f5b1c81d2567fcf4b4adc3b5bd3978d21", + "size_bytes": 1900507, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/rank_scaling_v1_checkpoints/n8_v1.npz", + "producer": "bash run_large_scale_article_v1.sh", + "sha256": "50e86cee177f173f9e6f25ad2d449efd9f6e934020837ab38fb382c7a8b82959", + "size_bytes": 446636, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/spectral_silence_v2.npz", + "producer": "bash run_spectral_silence_article_v2.sh", + "sha256": "f85e2fe87b8a21aa8b0961e962c84557276020d80bc7a06cfab5464da187bcd9", + "size_bytes": 13772014, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/topological_holonomy_mesh12_alias_audit_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "06c649b89a6e3760a817807283dce4f0f7f3c474dd324e86433844ca2b781bae", + "size_bytes": 3666138, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/topology_v3_checkpoints/N3_mesh12_twist_bundle_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "2957b7cffebb2da83c31e4dec0d8d586861b3b904fb35f10e973b0d101067ff1", + "size_bytes": 4508114, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/topology_v3_checkpoints/N3_mesh16_twist_bundle_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "3618cca495411df6d1e6811e66fe7e108a17e6f81605cca6af4b3c09cf0541d8", + "size_bytes": 8013038, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/topology_v3_checkpoints/N3_mesh20_twist_bundle_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "db1a4af4eb28a79df92369463ca00dc0c131535b01ec0483ee0214d2b73fb6e6", + "size_bytes": 12519524, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/topology_v3_checkpoints/N3_mesh6_twist_bundle_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "cfa7affea3177f4c694d4d9c0faeddd76c7addfa97a9caf08f7d069202a45c06", + "size_bytes": 1127865, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/topology_v3_checkpoints/N3_mesh8_twist_bundle_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "70448f58e0483ae9e324886e69b151a131892236b302f5a73da25cd6529b097b", + "size_bytes": 2004305, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/topology_v3_checkpoints/N4_mesh12_twist_bundle_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "712a49732df613a1514f9e2ab9a9c1be8d54a7bb4bcab4ffafaa192e85fb8e4e", + "size_bytes": 39997177, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/topology_v3_checkpoints/N4_mesh16_twist_bundle_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "1fba58f6126a2f9a52d08c175871c52a912e6cdcc409d67aafe2c3a7ac02b46d", + "size_bytes": 71104774, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/topology_v3_checkpoints/N4_mesh20_twist_bundle_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "d756a5ef23d8ac6e4f77e556ad4694e4724abd9711a7f4565ae43540c22b4f30", + "size_bytes": 111101102, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/topology_v3_checkpoints/N4_mesh6_twist_bundle_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "92167af8d52e724d50b2a8b3b6ec54c6835c42e7f86da6a654376fb6db88e1f2", + "size_bytes": 9999850, + "storage_class": "recompute_or_release_asset" + }, + { + "path": "01_task_folder/task_05/script/output/topology_v3_checkpoints/N4_mesh8_twist_bundle_v3.npz", + "producer": "FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh", + "sha256": "b9a8fd496721b9a02e685b93a108627805a9c61ded297f47ebb3f67efb557322", + "size_bytes": 17777502, + "storage_class": "recompute_or_release_asset" + } + ], + "figures": [ + { + "path": "01_task_folder/task_05/script/output/figure_1_spectral_silence_v2.png", + "role": "principal_result", + "sha256": "5c02927662ca4b2b1c7a9a072873ac49c76f02df7d06537fdac4cf3f34c35167", + "size_bytes": 318452 + }, + { + "path": "01_task_folder/task_05/script/output/figure_2_falsification_triangle_v2.png", + "role": "main_figure", + "sha256": "8227f7fee24eeb038a1f85bd2cc27b6be8c7221d402d3ff92a81029041a64dbf", + "size_bytes": 201455 + }, + { + "path": "01_task_folder/task_05/script/output/figure_3_independent_channels_v2.png", + "role": "main_figure", + "sha256": "c1d14697b983bf1fb18c3e21a37a8f3bb564a35ff3a155ee749410b2c85a62b8", + "size_bytes": 217515 + }, + { + "path": "01_task_folder/task_05/script/output/figure_4_geometric_hierarchy_v2.png", + "role": "main_figure", + "sha256": "c6dec6fe962dedc72aa75134883791bc72b0c9dda2ee8eed9bcc29edbb4a0f99", + "size_bytes": 256963 + }, + { + "path": "01_task_folder/task_05/script/output/figure_5_jacobi_atoms_v2.png", + "role": "main_figure", + "sha256": "d96c8889f31c2dd9a31de8706d18f19fc6e1f8ad9847782da12ed3523d1fb278", + "size_bytes": 332956 + }, + { + "path": "01_task_folder/task_05/script/output/figure_6_wick_factorization_v3.png", + "role": "main_figure", + "sha256": "7cf914a353f9849b86299669c99577c16c9994d7d7814c6dad2e2537698035ce", + "size_bytes": 346911 + }, + { + "path": "01_task_folder/task_05/script/output/figure_7_topological_holonomy_v3.png", + "role": "main_figure", + "sha256": "4c19bc37413ea4cdbece1ef84023b505d3d279264e2107601907cb72d2d731ff", + "size_bytes": 289213 + } + ], + "generated_utc": "2026-07-30T06:31:04.730833+00:00", + "headline": "Exact degeneracy turns quantum geometry into the signal.", + "paper": { + "page_count": 17, + "path": "01_task_folder/task_05/script/output/spectral_silence_and_geometric_chaos_v3.pdf", + "sha256": "a75377f76acd78eb3354e186a57933abdf11abbbe5e9a8abd43482ca8c4e05ad", + "size_bytes": 672204, + "title": "Spectral Silence and Geometric Chaos in an Exactly Degenerate Topological Manifold" + }, + "release_id": "task05-geometric-chaos-v1", + "result_branches": { + "matrix_element": "deformed_geometric_eth", + "topology": "fixed_chern_deformed_holonomy" + }, + "schema_version": 1, + "scientific_scope": [ + "exact-degeneracy projector geometry", + "finite-rank local Jacobi universality", + "structured matrix-element and Wilson correlations" + ], + "verification": { + "article": "bash run_geometric_eth_topology_article_v3.sh", + "full": "bash run_full_recompute_v1.sh", + "quick": "bash run_quick_verify_v1.sh" + } +} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/response_complex_memory_supplement_v7.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/response_complex_memory_supplement_v7.pdf new file mode 100644 index 000000000..dd5186db4 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/response_complex_memory_supplement_v7.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/response_complex_memory_v7.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/response_complex_memory_v7.pdf new file mode 100644 index 000000000..35906be92 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/response_complex_memory_v7.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_and_geometric_chaos_v2.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_and_geometric_chaos_v2.pdf new file mode 100644 index 000000000..f3c1cd1d3 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_and_geometric_chaos_v2.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_and_geometric_chaos_v3.pdf b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_and_geometric_chaos_v3.pdf new file mode 100644 index 000000000..8e41beb23 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_and_geometric_chaos_v3.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_delivery_audit_v2.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_delivery_audit_v2.json new file mode 100644 index 000000000..7d352fe17 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_delivery_audit_v2.json @@ -0,0 +1,147 @@ +{ + "schema_version": 2, + "article": "Spectral Silence and Geometric Chaos in an Exactly Degenerate Topological Manifold", + "checks": { + "source_artifact_passes": true, + "statistical_artifact_passes": true, + "figure_manifest_passes": true, + "exact_energy_silence": true, + "same_rank_structured_control": true, + "registered_geometry_axis": true, + "registered_spectral_axis": true, + "spectral_endpoint_confidence_separated": true, + "finite_jacobi_numerics_pass": true, + "atom_plateau_data_exact": true, + "registered_hierarchy_resolved": true, + "statistical_arrays_complete": true, + "bootstrap_replicates_exact": true, + "v1_large_scale_evidence_retained": true, + "figure_inputs_hashed": true, + "figure_outputs_hashed": true, + "figures_synchronized": true, + "generated_inputs_synchronized": true, + "all_citation_keys_resolve": true, + "new_reference_metadata_registered": true, + "chen_program_positioned": true, + "no_cross_task_v2_runtime_dependency": true, + "article_pdf_archived": true, + "pdf_page_count_in_contract": true, + "pdf_title_metadata": true, + "pdf_author_metadata": true, + "pdf_affiliations_visible": true, + "headline_claim_visible": true, + "time_caveat_visible": true, + "non_susy_scope_visible": true, + "all_pdf_pages_rendered": true, + "no_undefined_control_sequence": true, + "no_undefined_references": true, + "no_undefined_citations": true, + "no_overfull_boxes": true, + "no_stuck_floats": true, + "pytest_complete_if_recorded": true + }, + "all_checks_pass": true, + "pdf": { + "path": "overleaf_sync/geometric_eth_large_scale/main.pdf", + "archived_path": "01_task_folder/task_05/script/output/spectral_silence_and_geometric_chaos_v2.pdf", + "sha256": "5d51ad4997a8cc95fa60fdafa02ef5aa13ad86cd31f10764b61a8f8903c2895c", + "pages": 12, + "title": "Spectral Silence and Geometric Chaos in an Exactly Degenerate Topological Manifold", + "author": "Thomas J. Wang; OKongOYangO" + }, + "rendered_pages": [ + { + "page": 1, + "width": 1275, + "height": 1650, + "sha256": "9dae24ba1ba37821574e5868df7cf5a3fcb93c2904d362494fbbc9a4606d3fbc" + }, + { + "page": 2, + "width": 1275, + "height": 1650, + "sha256": "ddb783aa2f35cfa313837f6db8b662b6e5cec9197ec979bb1f678405acd6c189" + }, + { + "page": 3, + "width": 1275, + "height": 1650, + "sha256": "46636d057b18843669b4fd2c0366f2b0f03e364dfedbe488b812089b18ce41b7" + }, + { + "page": 4, + "width": 1275, + "height": 1650, + "sha256": "f1746ee40c4ad19fa0b4b80cab084d37404da2fa24631a5212e2c2a428043deb" + }, + { + "page": 5, + "width": 1275, + "height": 1650, + "sha256": "6e18d587ae4a3dfbc7316d14d556876fe28a9afa01226e3bec21a581f330ccc7" + }, + { + "page": 6, + "width": 1275, + "height": 1650, + "sha256": "ae560c77c41e59532930fd4caa9ee7d4e52cec6486010a21a6fa1655258ee3e0" + }, + { + "page": 7, + "width": 1275, + "height": 1650, + "sha256": "f398d005d850aeebc597be9f3f2860c67e2377bca8e86b72e8a90071152df117" + }, + { + "page": 8, + "width": 1275, + "height": 1650, + "sha256": "5558b1accf8d922a1ee9c8d11965683e300a3dd425b3be6d45badac386271d63" + }, + { + "page": 9, + "width": 1275, + "height": 1650, + "sha256": "79b69fe3c56c1c711dbb3457653022a11acb746e4c2702ebdad4335dbc03b266" + }, + { + "page": 10, + "width": 1275, + "height": 1650, + "sha256": "44e22dd987bd2669d7f2f583de2d258493f1f14ab1e149d34e7ae7c764a186dc" + }, + { + "page": 11, + "width": 1275, + "height": 1650, + "sha256": "f0e86de09dbe57320a6ad97debbf66a077e5e1c26c81e425a2fd9f0a718d32be" + }, + { + "page": 12, + "width": 1275, + "height": 1650, + "sha256": "655079db805d87572ca145d6753b4e08f5810fa01a623032178759c9f82c918e" + } + ], + "pytest_passed": 34, + "registered_scale": { + "physical_matrices": 20000, + "physical_test_matrices": 4000, + "structured_momenta": 24, + "structured_orbits": 12, + "geometric_interpolation_matrices": 28000, + "spectral_interpolation_matrices": 32000, + "haar_matrices": 10000, + "root_matrices": 8750, + "maximum_rank": 800, + "bootstrap_replicates": 10000 + }, + "supported_conclusion": { + "energy_connected_sff": 0.0, + "physical_jacobi_tau_onset": 0.25, + "geometric_local_onset": 0.20000000298023224, + "geometric_ramp_onset": 0.4000000059604645, + "number_variance_compatibility_extent": 1.0, + "D800_connected_plateau": 0.7 + } +} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_statistics_v2.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_statistics_v2.json new file mode 100644 index 000000000..72d097378 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_statistics_v2.json @@ -0,0 +1,141 @@ +{ + "schema_version": 2, + "version": "v2", + "generated_utc": "2026-07-28T11:29:38.897180+00:00", + "source_sha256": { + "json": "5a2da65d83ded56a0fbebb23f69d5c26bd41382ebaa5f32a333fb239bffd5778", + "npz": "f85e2fe87b8a21aa8b0961e962c84557276020d80bc7a06cfab5464da187bcd9" + }, + "bootstrap_replicates": 10000, + "registered_windows": { + "tau_minimum": 0.25, + "tau_maximum": 1.5, + "number_minimum": 0.25, + "number_maximum": 8.0 + }, + "outcomes": { + "physical_tau_compatibility_onset": 0.25, + "number_variance_compatibility_extent": 1.0, + "g_tau_compatibility_onsets": [ + null, + 1.399999976158142, + 1.5, + 1.4500000476837158, + 1.024999976158142, + 0.2750000059604645, + 0.8999999761581421 + ], + "first_g_with_registered_jacobi_window": 0.4000000059604645, + "first_g_with_haar_gap_ratio_interval": 0.20000000298023224, + "haar_gap_ratio_interval": { + "mean": 0.5993947881902579, + "lower": 0.598440251571675, + "upper": 0.6003493248088408 + }, + "tau_0p5": { + "structured": 4.476404067904201, + "physical": 0.5017409899698693, + "haar": 0.4948949510949673, + "analytic_jacobi": 0.5011683106422424 + }, + "number_variance_L8_residual": { + "mean": 0.12582170628628764, + "lower": 0.11427897037387218, + "upper": 0.13736444219870309 + }, + "energy_gap_ratio_endpoints": { + "poisson": 0.3856450915336609, + "poisson_lower": 0.38392218947410583, + "poisson_upper": 0.38736799359321594, + "gue": 0.598677396774292, + "gue_lower": 0.5972064733505249, + "gue_upper": 0.6001482605934143 + } + }, + "band_metadata": { + "structured": { + "form": { + "units": 12, + "method": "hierarchical_seed_block_bootstrap", + "critical_value": 3.4960832643510504 + }, + "ratio": { + "units": 12, + "method": "hierarchical_seed_block_bootstrap", + "critical_value": 0.0 + }, + "ratio_mean": { + "units": 12, + "method": "hierarchical_seed_block_bootstrap", + "critical_value": 0.0 + }, + "number": { + "units": 12, + "method": "hierarchical_seed_block_bootstrap", + "critical_value": 2.8067219883324737 + } + }, + "physical": { + "form": { + "units": 8, + "method": "hierarchical_seed_block_bootstrap", + "critical_value": 3.1830849400111756 + }, + "ratio": { + "units": 8, + "method": "hierarchical_seed_block_bootstrap", + "critical_value": 3.090094391348137 + }, + "ratio_mean": { + "units": 8, + "method": "hierarchical_seed_block_bootstrap", + "critical_value": 1.9471131504449375 + }, + "number": { + "units": 8, + "method": "hierarchical_seed_block_bootstrap", + "critical_value": 2.94711193455672 + } + }, + "haar": { + "form": { + "units": 10000, + "method": "matrix_gaussian_multiplier_bootstrap", + "critical_value": 3.540496824229081 + }, + "ratio": { + "units": 10000, + "method": "matrix_gaussian_multiplier_bootstrap", + "critical_value": 3.354487268047646 + }, + "ratio_mean": { + "units": 10000, + "method": "matrix_gaussian_multiplier_bootstrap", + "critical_value": 1.9407651464529883 + }, + "number": { + "units": 10000, + "method": "matrix_gaussian_multiplier_bootstrap", + "critical_value": 3.0706918319132255 + } + } + }, + "checks": { + "source_artifact_passes": true, + "structured_control_rejects_jacobi": true, + "physical_has_registered_jacobi_window": true, + "geometry_axis_crossover_resolved": true, + "local_to_ramp_hierarchy_resolved": true, + "spectral_axis_confidence_separated": true, + "fixed_projector_invariance_retained": true, + "long_range_memory_resolved": true, + "atom_plateau_data_retained": true + }, + "all_checks_pass": true, + "runtime_seconds": 101.95342445799997, + "environment": { + "python": "3.12.11", + "numpy": "2.3.5", + "platform": "macOS-15.6-arm64-arm-64bit" + } +} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_statistics_v2.npz b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_statistics_v2.npz new file mode 100644 index 000000000..96412dc71 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_statistics_v2.npz differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_v2.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_v2.json new file mode 100644 index 000000000..505d729fd --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/spectral_silence_v2.json @@ -0,0 +1,103 @@ +{ + "schema_version": 2, + "version": "v2", + "generated_utc": "2026-07-28T11:27:53.666915+00:00", + "registered_seed": 20260728210, + "sample_counts": { + "structured_momenta": 24, + "structured_orbits": 12, + "per_positive_g": 4000, + "fixed_projector_per_alpha": 4000, + "rank_form_factor_requested": 500, + "rank_form_factor_actual": [ + 500, + 500, + 500, + 500, + 500, + 500, + 250 + ], + "physical_test": 4000, + "haar_reference": 10000 + }, + "grids": { + "g": [ + 0.0, + 0.02, + 0.05, + 0.1, + 0.2, + 0.4, + 0.7, + 1.0 + ], + "alpha": [ + 0.0, + 0.1, + 0.2, + 0.35, + 0.5, + 0.7, + 0.85, + 1.0 + ], + "times": { + "minimum": 0.0, + "maximum": 3.0, + "points": 121 + } + }, + "physical_case": { + "N": 3, + "n": 10, + "D": 50, + "M": 170, + "kernel_bandwidth": 5.782554623436307e-16, + "external_gap": 0.10667223401027637 + }, + "structured_control": { + "minimum_active_rank": 50, + "maximum_distinct_eigenvalues": 10 + }, + "fixed_projector_control": { + "poisson_endpoint_gap_ratio": 0.3856450915646395, + "gue_endpoint_gap_ratio": 0.598677371645903, + "maximum_projector_distance": 1.1483897216095898e-14, + "maximum_curvature_spectrum_error": 0.0 + }, + "finite_jacobi": { + "quadrature_order": 512, + "mass_error": 4.192202140984591e-13, + "orthogonality_error": 4.177769241664464e-13, + "atom_relation_error": 0.0, + "raw_atom_closure_error": 1.1368683772161603e-13 + }, + "inputs": { + "output/physical_ensemble_v1.npz": "cf44e830188f6a7252ff692c0db33ea3f2cd3ce604a37e31b49a80d37ad70652", + "output/physical_ensemble_v1.json": "f0f0c97483f66800b8da208fd3dad7259fc30a7650b7360060499f9326ad4000", + "output/covariance_model_v1.npz": "7581adc06ceeb6afb3d5bb5f58f1ca91a1ae9398e45dc09869751989f86a4836", + "output/covariance_model_v1.json": "7183934946be50deb9973755dc189360b9f8aaabcdbd7107860980b15ae859a0", + "output/rank_scaling_v1.npz": "0373a6b0ddef31ea0208f0acc3d6feee0bda372058eb2a0d689b0eed92cd4338", + "output/rank_scaling_v1.json": "46be556194eac79ff29017c9b969146e32b6e0a08a1407a6cfe4e2a924cf77e7" + }, + "checks": { + "input_v1_artifacts_pass": true, + "exact_energy_silence": true, + "structured_control_full_rank": true, + "structured_control_multiplets": true, + "geometry_axis_full_rank": true, + "geometry_axis_exact_parent": true, + "fixed_projector_invariance": true, + "spectral_axis_resolved": true, + "finite_jacobi_mass_and_basis": true, + "atom_plateau_theorem": true + }, + "all_checks_pass": true, + "runtime_seconds": 342.8376511250008, + "environment": { + "python": "3.12.11", + "numpy": "2.3.5", + "platform": "macOS-15.6-arm64-arm-64bit" + } +} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/statistical_analysis_v1.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/statistical_analysis_v1.json new file mode 100644 index 000000000..1abe3e033 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/statistical_analysis_v1.json @@ -0,0 +1,399 @@ +{ + "schema_version": 1, + "version": "v1", + "generated_utc": "2026-07-28T08:35:27.297185+00:00", + "sources": { + "physical": "output/physical_ensemble_v1.npz", + "covariance": "output/covariance_model_v1.npz", + "scaling_json": "output/rank_scaling_v1.json", + "scaling_npz": "output/rank_scaling_v1.npz" + }, + "bootstrap_replicates": 10000, + "kde_bandwidth": 0.025, + "bulk_fraction": 0.7, + "unfolding": "ensemble_cdf", + "physical_test_matrices": 4000, + "haar_matrices": 10000, + "deformed_matrices": 10000, + "ensemble_inference": { + "physical": { + "density": { + "method": "hierarchical_seed_block_bootstrap", + "units": 8, + "replicates": 10000, + "critical_value": 3.20338214267544 + }, + "ratio": { + "method": "hierarchical_seed_block_bootstrap", + "units": 8, + "replicates": 10000, + "critical_value": 3.0832997163539098 + }, + "number": { + "method": "hierarchical_seed_block_bootstrap", + "units": 8, + "replicates": 10000, + "critical_value": 2.93361552097013 + }, + "rigidity": { + "method": "hierarchical_seed_block_bootstrap", + "units": 8, + "replicates": 10000, + "critical_value": 2.4258957632023197 + }, + "form_factor": { + "method": "hierarchical_seed_block_bootstrap", + "units": 8, + "replicates": 10000, + "critical_value": 3.119216763022093 + }, + "moments": { + "method": "hierarchical_seed_block_bootstrap", + "units": 8, + "replicates": 10000, + "critical_value": 2.0712875866961724 + } + }, + "haar": { + "density": { + "method": "matrix_gaussian_multiplier_bootstrap", + "units": 10000, + "replicates": 10000, + "critical_value": 3.496117356219921 + }, + "ratio": { + "method": "matrix_gaussian_multiplier_bootstrap", + "units": 10000, + "replicates": 10000, + "critical_value": 3.3269343403439935 + }, + "number": { + "method": "matrix_gaussian_multiplier_bootstrap", + "units": 10000, + "replicates": 10000, + "critical_value": 3.072114654056266 + }, + "rigidity": { + "method": "matrix_gaussian_multiplier_bootstrap", + "units": 10000, + "replicates": 10000, + "critical_value": 2.5803117901830324 + }, + "form_factor": { + "method": "matrix_gaussian_multiplier_bootstrap", + "units": 10000, + "replicates": 10000, + "critical_value": 3.332542228935703 + }, + "moments": { + "method": "matrix_gaussian_multiplier_bootstrap", + "units": 10000, + "replicates": 10000, + "critical_value": 2.2001004874536636 + } + }, + "deformed": { + "density": { + "method": "matrix_gaussian_multiplier_bootstrap", + "units": 10000, + "replicates": 10000, + "critical_value": 3.504655558936284 + }, + "ratio": { + "method": "matrix_gaussian_multiplier_bootstrap", + "units": 10000, + "replicates": 10000, + "critical_value": 3.31320817913214 + }, + "number": { + "method": "matrix_gaussian_multiplier_bootstrap", + "units": 10000, + "replicates": 10000, + "critical_value": 3.0768485442365634 + }, + "rigidity": { + "method": "matrix_gaussian_multiplier_bootstrap", + "units": 10000, + "replicates": 10000, + "critical_value": 2.5903174878666997 + }, + "form_factor": { + "method": "matrix_gaussian_multiplier_bootstrap", + "units": 10000, + "replicates": 10000, + "critical_value": 3.306019333609717 + }, + "moments": { + "method": "matrix_gaussian_multiplier_bootstrap", + "units": 10000, + "replicates": 10000, + "critical_value": 2.168573586332979 + } + } + }, + "sensitivity": { + "bandwidth": { + "0.015": { + "physical_haar_l1": 0.2897552812148236, + "physical_deformed_l1": 0.11925885317861315 + }, + "0.02": { + "physical_haar_l1": 0.2890566597095776, + "physical_deformed_l1": 0.1171495215074651 + }, + "0.025": { + "physical_haar_l1": 0.288139806709111, + "physical_deformed_l1": 0.11496766292027316 + }, + "0.035": { + "physical_haar_l1": 0.28561721500638493, + "physical_deformed_l1": 0.11068893240177029 + }, + "0.05": { + "physical_haar_l1": 0.28003252938851136, + "physical_deformed_l1": 0.1049230997005546 + } + }, + "bulk_fraction": { + "0.5": { + "physical": 0.6003157300811033, + "haar": 0.5996822463592252, + "deformed": 0.5990315721255308 + }, + "0.6": { + "physical": 0.5999422924577897, + "haar": 0.5995455819841864, + "deformed": 0.5993426191682945 + }, + "0.7": { + "physical": 0.5998059753041982, + "haar": 0.5993947881902579, + "deformed": 0.5992000762838173 + }, + "0.8": { + "physical": 0.599727711873032, + "haar": 0.5994696812918004, + "deformed": 0.5991753696779304 + }, + "0.9": { + "physical": 0.5997151649619297, + "haar": 0.5995203341794094, + "deformed": 0.5991788297224815 + } + }, + "unfolding": { + "ensemble_cdf": { + "physical": 0.599832009518958, + "haar": 0.599404451204649, + "deformed": 0.5991995692807472 + }, + "polynomial": { + "physical": 0.5998390697704098, + "haar": 0.5993986311163013, + "deformed": 0.5992531443200949 + } + }, + "ratio_binning": { + "30": { + "physical_haar_l1": 0.008883333333333328, + "physical_deformed_l1": 0.009641666666666679 + }, + "50": { + "physical_haar_l1": 0.013162500000000028, + "physical_deformed_l1": 0.013350000000000013 + }, + "70": { + "physical_haar_l1": 0.015739583333333335, + "physical_deformed_l1": 0.014724999999999988 + } + } + }, + "finite_size_fits": { + "density_l1": { + "models": { + "D^-1/2": { + "offset": 1.6667053205509537e-26, + "amplitude": 1.4614965615076556, + "exponent": 0.5, + "offset_standard_error": 0.0004963817861996122, + "weighted_rss": 2891.442910814757, + "loo_rmse": 0.034660129227237164, + "prediction": [ + 0.3653741403769139, + 0.2066868258645771, + 0.13809844441875968, + 0.10085284421937078, + 0.07789802846617341, + 0.0625462788265822, + 0.051671706466144274 + ] + }, + "D^-1": { + "offset": 0.05148978706046747, + "amplitude": 6.8213708154014725, + "exponent": 1.0, + "offset_standard_error": 0.000264295186581437, + "weighted_rss": 4526.5892991329065, + "loo_rmse": 0.11475470893223697, + "prediction": [ + 0.4778254630230595, + 0.18791720336849693, + 0.11239488362655205, + 0.08397250522904592, + 0.07086868142240348, + 0.06398314020222841, + 0.060016500579719315 + ] + }, + "free": { + "offset": 7.454752309592727e-18, + "amplitude": 2.2680489602906104, + "exponent": 0.5928672289325054, + "offset_standard_error": 0.0013518350982931982, + "exponent_standard_error": 0.005815311562728218, + "weighted_rss": 206.59855840284953, + "loo_rmse": 0.021877548856190882, + "prediction": [ + 0.4382976559321891, + 0.22304309709333994, + 0.13827326405369, + 0.09525432573380731, + 0.0701278837144649, + 0.0540580789595275, + 0.043102802602347896 + ] + } + }, + "best_by_loo": "free" + }, + "gap_ratio_difference": { + "models": { + "D^-1/2": { + "offset": 2.2095563788202477e-17, + "amplitude": 0.05826727156844323, + "exponent": 0.5, + "offset_standard_error": 0.0007067359024412413, + "weighted_rss": 63.08735283320601, + "loo_rmse": 0.0077758086970606335, + "prediction": [ + 0.01456681789211083, + 0.00824023656945689, + 0.005505739648013066, + 0.004020823734623085, + 0.00310565600961977, + 0.00249360902376983, + 0.002060059142364239 + ] + }, + "D^-1": { + "offset": 0.0009268891235324555, + "amplitude": 0.4224132072039323, + "exponent": 1.0, + "offset_standard_error": 0.00039172194388101587, + "weighted_rss": 19.67912233098509, + "loo_rmse": 0.004853533410891864, + "prediction": [ + 0.027327714573778222, + 0.0093751532676111, + 0.004698435616424708, + 0.002938380586408324, + 0.002126926643998172, + 0.0017005396861770202, + 0.0014549056325373708 + ] + }, + "free": { + "offset": 0.0020703667001237412, + "amplitude": 1.6968325987737591, + "exponent": 1.4765676600076514, + "offset_standard_error": 0.0004892027465701063, + "exponent_standard_error": 0.24779108727448396, + "weighted_rss": 13.18696218410215, + "loo_rmse": 0.008100869175413155, + "prediction": [ + 0.03036306535263875, + 0.00733047680995051, + 0.0036692984946185094, + 0.0027023783577071765, + 0.002365145643177657, + 0.0022245327921723967, + 0.0021580728829987787 + ] + } + }, + "best_by_loo": "D^-1" + }, + "participation_deficit": { + "models": { + "D^-1/2": { + "offset": 0.0006986501281554937, + "amplitude": 1.0222401999472197, + "exponent": 0.5, + "offset_standard_error": 0.00015442710062179112, + "weighted_rss": 7170.950197400536, + "loo_rmse": 0.01682487910648122, + "prediction": [ + 0.25625870011496044, + 0.14526524560498974, + 0.09729126974362999, + 0.07123992566403732, + 0.05518423585721792, + 0.04444649207154212, + 0.03684029899736406 + ] + }, + "D^-1": { + "offset": 0.04303281657000455, + "amplitude": 3.710942190947265, + "exponent": 1.0, + "offset_standard_error": 8.659665035357202e-05, + "weighted_rss": 48684.63639312415, + "loo_rmse": 0.1103934918337845, + "prediction": [ + 0.2749667035042086, + 0.11725166038894985, + 0.07616622898917655, + 0.06070396986022962, + 0.053575265976104736, + 0.049829413989321884, + 0.04767149430868863 + ] + }, + "free": { + "offset": 5.086266769807968e-15, + "amplitude": 0.9255415658178124, + "exponent": 0.47750056107292504, + "offset_standard_error": 0.0006001684363802755, + "exponent_standard_error": 0.003251116326187298, + "weighted_rss": 6479.237840635457, + "loo_rmse": 0.02907716929733699, + "prediction": [ + 0.24627932820097742, + 0.14293441128872927, + 0.09725079762674695, + 0.07203356541561141, + 0.05628859091001392, + 0.04564412698307686, + 0.0380337221893311 + ] + } + }, + "best_by_loo": "D^-1/2" + } + }, + "checks": { + "registered_bootstrap_count": true, + "physical_uses_seed_block_hierarchy": true, + "reference_uses_matrix_level_inference": true, + "covariance_improvement_bandwidth_stable": true, + "all_size_fits_registered": true, + "all_curves_finite": true + }, + "all_checks_pass": true, + "runtime_seconds": 22.81690737500321, + "environment": { + "python": "3.12.11", + "numpy": "2.3.5", + "platform": "macOS-15.6-arm64-arm-64bit" + } +} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/statistical_analysis_v1.npz b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/statistical_analysis_v1.npz new file mode 100644 index 000000000..10e8b7fb4 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/statistical_analysis_v1.npz differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_delivery_audit_v7.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_delivery_audit_v7.json new file mode 100644 index 000000000..98dce0db2 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_delivery_audit_v7.json @@ -0,0 +1,51 @@ +{ + "artifact_hashes": { + "controls_json": "854e782121ad9bfbe6dfb6fc2e4d24fa4e1deab0f61812c96618cfa1c6851861", + "figure_manifest": "c7e1e142242c2481cb8346af72b8ff8d2b6ef40a4f4c04943890f504eb70949d", + "figure_pdf": "f081c5f162778e5e45a48adba1ea08c37e8521c725725922a0ec3a35bda74a54", + "figure_png": "252c337189afb6f0adea8142573e2e459a41e7226932e5954711ff0c7f5eb341", + "inference_json": "177643e07fc6cf210362fc1077070bd1f0ba316b6805042a626de3f96c55a627", + "pilot_json": "152084fc502e38074ed0d8163f8582c01b9e5de46c12a53d2ced4994d1a74617", + "pilot_npz": "d1061c85fda0fb91b2974fe7389f577b6b657173b1f906e41868674b12d0cc6b", + "prediction_json": "fc300dc7e4bdc1be157919e458ac868d3468533cce31108f23c9fba4f7e9f102", + "prediction_npz": "f8b2dde1c8563c39caa2b800b7c4e2595c8f1c3365a3d851b06e252279dbd903", + "prediction_seal": "8e9bbd6e248cc8034ce3f118db518257b4face2fbb028f2fd133ff3c04b9cd44", + "report_md": "a085aedfbb2ce48ff26804d8be02334dac8447ff3d899056285db2eab8930cdf", + "safe_json": "dbf51fe8d19864fb499ae9a83b2683fbecf3aed1209ae9fbb787ede0c212a7bb", + "unsealed_json": "372229acd39d7b8a30d5ca5bc1460fd62b81a589b5c68f707d8bccade6e70faf" + }, + "checks": { + "all_required_files_exist": true, + "analytic_controls_passed": true, + "complete_inference_primary_pair": true, + "complete_pilot_grid": true, + "complete_prediction_primary_pair": true, + "curvature_atom_control": true, + "figure_and_report_hashes": true, + "figure_branch_matches_inference": true, + "figure_manifest_passed": true, + "inference_passed": true, + "inference_references_prediction": true, + "one_sided_control": true, + "pilot_array_hash": true, + "pilot_passed": true, + "prediction_array_hash": true, + "prediction_has_no_outcome_leakage": true, + "prediction_passed": true, + "prediction_precedes_unseal": true, + "prediction_safe_covariate_hash": true, + "report_has_claim_boundary_and_sources": true, + "safe_covariates_have_no_outcome_leakage": true, + "safe_covariates_passed": true, + "selected_branch_recomputed": true, + "unsealed_passed": true, + "unsealed_references_prediction": true, + "valid_prediction_seal": true + }, + "generated_utc": "2026-08-04T01:57:42.244273+00:00", + "passed": true, + "prediction_sha256": "fc300dc7e4bdc1be157919e458ac868d3468533cce31108f23c9fba4f7e9f102", + "recomputed_branch": "cohomological_non_gaussian_class", + "selected_branch": "cohomological_non_gaussian_class", + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_geometric_eth_report_v7.md b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_geometric_eth_report_v7.md new file mode 100644 index 000000000..f2a49c668 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_geometric_eth_report_v7.md @@ -0,0 +1,36 @@ +# Hodge-resolved Geometric ETH result report + +## Verdict + +Selected frozen branch: `cohomological_non_gaussian_class`. + +Neither covariance-only null covers the held-out pair, and the complete-realization uncertainty remains separated; a reproducible cohomological four-point memory survives the registered separable Hodge-covariance matching. + +## Established + +- The charge-resolved cubic $\mathcal N=2$ SYK BPS response splits into numerically orthogonal exact and coexact branches and agrees with the direct resolvent response under the registered tests. +- The pilot contains 12 complete size/sector/panel groups and uses complete disorder realizations as its uncertainty unit. +- The held-out central/adjacent sparse pair was scored only after validating prediction SHA-256 `fc300dc7e4bdc1be157919e458ac868d3468533cce31108f23c9fba4f7e9f102`. + +- adjacent: observed median 0.30152872, physical bootstrap [0.29152748, 0.31206114], collapsed prediction [0.11178894, 0.11185244], Hodge prediction [0.11234396, 0.11251285]. +- central: observed median 0.37499257, physical bootstrap [0.36898049, 0.38047305], collapsed prediction [0.11133773, 0.11135302], Hodge prediction [0.11133252, 0.11134820]. + +## Not established + +- This is not conventional energy-resolved ETH, a real-time chaos result, or a thermodynamic-limit theorem. +- Generic $\mathcal N=2$ SYK is an independent supersymmetric protection mechanism, but it is not a spatially local model; locality universality requires a later nilpotent lattice-supercharge benchmark. +- Berry-curvature chaos in this model is prior art. The contribution tested here is the pre-outcome response-complex/two-point prediction of a gauge-invariant four-channel statistic. +- The Gaussian nulls match the registered collapsed or branch-resolved marginal covariance data, not the complete entrywise covariance operator. Rejection therefore establishes failure of the frozen separable Hodge-Gaussian response law; by itself it does not distinguish intrinsic non-Gaussianity from unmodeled nonseparable two-point structure. + +## Relation to prior work + +- [Fu, Gaiotto, Maldacena, and Sachdev, *Supersymmetric SYK models*](https://arxiv.org/abs/1610.08917). +- [Chen, Colin-Ellerin, Mamroud, and Papadodimas, *Chaos of Berry curvature for BPS microstates*](https://arxiv.org/abs/2604.23287). +- [Chen, Lin, and Shenker, *BPS Chaos*](https://arxiv.org/abs/2407.19387). +- [Huijse and Schoutens, *Supersymmetry, lattice fermions, independence complexes and cohomology theory*](https://arxiv.org/abs/0903.0784). + +## Provenance + +- Pilot JSON SHA-256: `152084fc502e38074ed0d8163f8582c01b9e5de46c12a53d2ced4994d1a74617`. +- Held-out inference JSON SHA-256: `177643e07fc6cf210362fc1077070bd1f0ba316b6805042a626de3f96c55a627`. +- Uncertainty unit: `complete_disorder_realization`. diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_manuscript_assets_v7.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_manuscript_assets_v7.json new file mode 100644 index 000000000..380ff98ba --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_manuscript_assets_v7.json @@ -0,0 +1,25 @@ +{ + "checks": { + "complete_pilot_grid": true, + "complete_primary_pair": true, + "figure_copy_exact": true, + "figure_manifest_matches_sources": true, + "publishable_registered_branch": true, + "result_macro_enabled": true + }, + "generated_utc": "2026-08-04T01:30:55.991534+00:00", + "inputs": { + "figure_susy_hodge_geometric_eth_v7.json": "c7e1e142242c2481cb8346af72b8ff8d2b6ef40a4f4c04943890f504eb70949d", + "figure_susy_hodge_geometric_eth_v7.pdf": "f081c5f162778e5e45a48adba1ea08c37e8521c725725922a0ec3a35bda74a54", + "susy_hodge_v7_N14_inference.json": "177643e07fc6cf210362fc1077070bd1f0ba316b6805042a626de3f96c55a627", + "susy_hodge_v7_outcomes_pilot_combined.json": "152084fc502e38074ed0d8163f8582c01b9e5de46c12a53d2ced4994d1a74617" + }, + "outputs": { + "figure_susy_hodge_geometric_eth_v7.pdf": "f081c5f162778e5e45a48adba1ea08c37e8521c725725922a0ec3a35bda74a54", + "results_v7.tex": "a1257d1744f1085ee518a36ca9ed2574dec608cb7f71c766a082745f3acc858d" + }, + "passed": true, + "prediction_sha256": "fc300dc7e4bdc1be157919e458ac868d3468533cce31108f23c9fba4f7e9f102", + "selected_branch": "cohomological_non_gaussian_class", + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_manuscript_audit_v7.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_manuscript_audit_v7.json new file mode 100644 index 000000000..084fa1579 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_manuscript_audit_v7.json @@ -0,0 +1,35 @@ +{ + "artifact_hashes": { + "figure_susy_hodge_geometric_eth_v7.pdf": "f081c5f162778e5e45a48adba1ea08c37e8521c725725922a0ec3a35bda74a54", + "main.log": "2824219cd62b920c6198485f423ed60eaf87506f801be1d2b3de92dc8448f4df", + "main.pdf": "9fe357a5bfce5e6efd60a3c8bf0a1b73a4eac4ee15f9bb8844f51d2f7e1252ee", + "main.tex": "a03ad4b46ae9431b509c025909dfc9a307e4709de3c2047980f346179a612ab5", + "response_complex_memory_supplement_v7.pdf": "e43a5a2f62494bb7595f790de5643d6244d782402478f36fdcc7c511176b79c5", + "response_complex_memory_v7.pdf": "9fe357a5bfce5e6efd60a3c8bf0a1b73a4eac4ee15f9bb8844f51d2f7e1252ee", + "results_v7.tex": "a1257d1744f1085ee518a36ca9ed2574dec608cb7f71c766a082745f3acc858d", + "supplement.log": "4a3bd359b9d5ed024bed900b9b1291fd789489aeff9a4d06d94cea4bc18ec4f8", + "supplement.pdf": "e43a5a2f62494bb7595f790de5643d6244d782402478f36fdcc7c511176b79c5", + "supplement.tex": "91a5edd3e299ca97348ffee8c25ac0049e3e169c42adbc59a5cb76e734d63a38", + "susy_hodge_manuscript_assets_v7.json": "ccf63b88ce4fe8a71bd87c3a4c97ee8b55645dad3a808a693f2daa044b8e3092" + }, + "checks": { + "archived_pdf_exact": true, + "archived_supplement_exact": true, + "asset_manifest_passed": true, + "clean_latex_log": true, + "clean_supplement_log": true, + "compiled_pdf_structure": true, + "compiled_supplement_structure": true, + "figure_source_hash": true, + "heldout_result_enabled": true, + "main_uses_generated_results": true, + "result_source_hash": true, + "selected_branch_in_source": true, + "supplement_uses_generated_results": true + }, + "generated_utc": "2026-08-04T01:57:42.639708+00:00", + "passed": true, + "prediction_sha256": "fc300dc7e4bdc1be157919e458ac868d3468533cce31108f23c9fba4f7e9f102", + "selected_branch": "cohomological_non_gaussian_class", + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_covariates.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_covariates.json new file mode 100644 index 000000000..e39c5f8b0 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_covariates.json @@ -0,0 +1,6155 @@ +{ + "checks": { + "all_safe_checks": true, + "complete_requested_grid": true, + "no_outcome_leakage": true + }, + "passed": true, + "records": [ + { + "arrays_sha256": "ccc702aa83f8021eb3aa2f67dc3949798abcb5a44efacf3dae527c696861fa90", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:42:00.253660+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "80bcec06366a7329d97cee0e4b8e13093e1157315a6c26b1671f7a252e72e2fe", + "panel_kind": "sparse", + "panel_seed": 1763853356421777176, + "realization": 0, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "44f17703002e5d8496af042ae29f3602f4c4998705aa400167d7ef572d12e12f", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05948871912595825, + "kernel_residual": 1.9751282882134734e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 447.4535423449929, + "minus_external_entropy": 0.9350657955366082, + "minus_target_effective_rank": 747.7840119457769, + "minus_target_entropy": 0.9353314755810783, + "minus_weight": 5219.474068767745, + "orthogonality_relative_error": 1.0791710079627175e-16, + "plus_external_effective_rank": 447.45354234499297, + "plus_external_entropy": 0.9350657955366082, + "plus_target_effective_rank": 747.7840119457766, + "plus_target_entropy": 0.9353314755810784, + "plus_weight": 5219.474068767739, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 913, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 913, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "19a0e93f9bb71ac87be3e6be0fffbeaf3f76ccfee8081d0dd7d0dd71710883ee", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:05:25.242541+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "80bcec06366a7329d97cee0e4b8e13093e1157315a6c26b1671f7a252e72e2fe", + "panel_kind": "isotropic", + "panel_seed": 1763853356421777176, + "realization": 0, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "0d4791237862afc32e310c96a07fcfeeeeb7c2f8679f5e52f43725cae516c654", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05948871912595825, + "kernel_residual": 1.9751282882134734e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 550.8376669580704, + "minus_external_entropy": 0.9498412545534854, + "minus_target_effective_rank": 1098.4653975426324, + "minus_target_entropy": 0.9786750518688452, + "minus_weight": 5224.644193738161, + "orthogonality_relative_error": 1.0909117209404492e-16, + "plus_external_effective_rank": 550.8376669580705, + "plus_external_entropy": 0.9498412545534857, + "plus_target_effective_rank": 1098.465397542632, + "plus_target_entropy": 0.9786750518688453, + "plus_weight": 5224.644193738168, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "feba2e32a13c40c9cb74870eea11ec959326795370df60e6313affbc7a8649d4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:46:43.912064+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "2d5bdab4ad7a6a48f430dd4f05f8b9a828d3cf63d11c5f4c1d8ce9251ed3fa0c", + "panel_kind": "sparse", + "panel_seed": 14003215479391922300, + "realization": 1, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "914baba0c350a9536fd535e9c676f79c1779d0e3f39dd7b0dac175fb714c2c7b", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.042139127275221254, + "kernel_residual": 2.043279549857005e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 407.78836719309834, + "minus_external_entropy": 0.9245722847681224, + "minus_target_effective_rank": 749.7330658164313, + "minus_target_entropy": 0.9379954919988556, + "minus_weight": 5749.243671890005, + "orthogonality_relative_error": 1.3739778366188629e-16, + "plus_external_effective_rank": 407.788367193099, + "plus_external_entropy": 0.9245722847681223, + "plus_target_effective_rank": 749.7330658164312, + "plus_target_entropy": 0.9379954919988557, + "plus_weight": 5749.2436718899935, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 954, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 954, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "b1d6da391eae4575bfc3a5905469115b65d18151b77c85f30e2b8d849a5618c2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:12:38.480762+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "2d5bdab4ad7a6a48f430dd4f05f8b9a828d3cf63d11c5f4c1d8ce9251ed3fa0c", + "panel_kind": "isotropic", + "panel_seed": 14003215479391922300, + "realization": 1, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "74f9a8d2563f8fa41a7ecf2fdc43fadad205567b3782a48a136136b6cdee95c6", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.042139127275221254, + "kernel_residual": 2.043279549857005e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 506.7206421368502, + "minus_external_entropy": 0.9438300226971456, + "minus_target_effective_rank": 1064.171938799976, + "minus_target_entropy": 0.97639291305631, + "minus_weight": 5543.409415049093, + "orthogonality_relative_error": 1.3214767252441513e-16, + "plus_external_effective_rank": 506.7206421368506, + "plus_external_entropy": 0.9438300226971457, + "plus_target_effective_rank": 1064.1719387999763, + "plus_target_entropy": 0.9763929130563102, + "plus_weight": 5543.4094150491255, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "dbd19fb49be1a0bf936701c66282ce2d47e49492034640a51486ce530a2b157c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:41:12.005774+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "ea64a55cc579f5fe2e011a2f7515e582fc370f5b75e2e87a7a0f8165102d1b4c", + "panel_kind": "sparse", + "panel_seed": 4994935149739756518, + "realization": 2, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "5e32ddbe4b9b52b35a198165c3a028da71a9d2b5b0bd906c16b55a020b611f09", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.054995849898366554, + "kernel_residual": 2.0162735976440567e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 497.76039783110707, + "minus_external_entropy": 0.9405905711033204, + "minus_target_effective_rank": 881.1938159465766, + "minus_target_entropy": 0.9538370071372049, + "minus_weight": 5196.015398837346, + "orthogonality_relative_error": 1.1392625618315609e-16, + "plus_external_effective_rank": 497.76039783110696, + "plus_external_entropy": 0.9405905711033204, + "plus_target_effective_rank": 881.1938159465763, + "plus_target_entropy": 0.9538370071372049, + "plus_weight": 5196.015398837353, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 976, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 976, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "aed0e71bed049cc5b90b39396759899eb9583b13f26ae5a92c67b863fde42dc7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:04:06.387525+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "ea64a55cc579f5fe2e011a2f7515e582fc370f5b75e2e87a7a0f8165102d1b4c", + "panel_kind": "isotropic", + "panel_seed": 4994935149739756518, + "realization": 2, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "ce6021aa7355d4b79ff7daef94ac1f6887e341672454b0780ba5456d27abaaa7", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.054995849898366554, + "kernel_residual": 2.0162735976440567e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 540.6494256668444, + "minus_external_entropy": 0.9485777429976546, + "minus_target_effective_rank": 1094.1690787780776, + "minus_target_entropy": 0.9784423580388469, + "minus_weight": 5253.1110776070545, + "orthogonality_relative_error": 1.147926774916353e-16, + "plus_external_effective_rank": 540.6494256668449, + "plus_external_entropy": 0.9485777429976546, + "plus_target_effective_rank": 1094.1690787780778, + "plus_target_entropy": 0.9784423580388469, + "plus_weight": 5253.111077607046, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "aef463ec47c52d828afca3104b76e5c7f0a6064eb2dfe6c04fe6da7efad3c36c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:42:08.735934+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "cfafc92df174043c8965b87ec4c53403a44e6bfc7988ca83c0be10aa111b46e9", + "panel_kind": "sparse", + "panel_seed": 2475508203188307491, + "realization": 3, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "2fc8acde41f905e05791e66403e3cf3cd07404f23cb44318c51089d7b9f5fb83", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05356061258764, + "kernel_residual": 2.023301969699826e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 456.8933358639944, + "minus_external_entropy": 0.9353482533624459, + "minus_target_effective_rank": 843.7385351176739, + "minus_target_entropy": 0.9487322207360465, + "minus_weight": 5351.615989837032, + "orthogonality_relative_error": 1.1396167819438761e-16, + "plus_external_effective_rank": 456.8933358639943, + "plus_external_entropy": 0.9353482533624458, + "plus_target_effective_rank": 843.7385351176741, + "plus_target_entropy": 0.9487322207360463, + "plus_weight": 5351.615989837042, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 951, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 951, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "1d86d31d8ddad6ccacb79aad1403866ab8cd2508aced6a8b97061a538ee2dc60", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:05:08.283492+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "cfafc92df174043c8965b87ec4c53403a44e6bfc7988ca83c0be10aa111b46e9", + "panel_kind": "isotropic", + "panel_seed": 2475508203188307491, + "realization": 3, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "7da6c3230714f0b4c4b0be849717242f14acddb52f068d67916a996886ae24a7", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05356061258764, + "kernel_residual": 2.023301969699826e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 529.2339384757496, + "minus_external_entropy": 0.9467742731940657, + "minus_target_effective_rank": 1085.1102769467102, + "minus_target_entropy": 0.9777789626157133, + "minus_weight": 5374.913719837153, + "orthogonality_relative_error": 1.1406925412184375e-16, + "plus_external_effective_rank": 529.2339384757493, + "plus_external_entropy": 0.9467742731940657, + "plus_target_effective_rank": 1085.11027694671, + "plus_target_entropy": 0.9777789626157134, + "plus_weight": 5374.913719837154, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "574efe54da3efc84c12d6d619fb6856a96a62dae488e1b1e62cf793a8b90e88a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:39:41.937701+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "2d15e1416b61bebc47382807891f2e4d733a0b85216d44f1e76ac46cd934c3ca", + "panel_kind": "sparse", + "panel_seed": 13016877966896066155, + "realization": 4, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "dca1a9dffd70a04f941d436794a7f87f6ef19b5fc1b21e624d92bb15ddf826d3", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.04809601880767759, + "kernel_residual": 2.034150795660813e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 441.9085882653787, + "minus_external_entropy": 0.9361841441897655, + "minus_target_effective_rank": 749.6426025437222, + "minus_target_entropy": 0.9357070583524099, + "minus_weight": 5307.4635847786585, + "orthogonality_relative_error": 1.2076718706535377e-16, + "plus_external_effective_rank": 441.9085882653786, + "plus_external_entropy": 0.9361841441897657, + "plus_target_effective_rank": 749.6426025437222, + "plus_target_entropy": 0.9357070583524097, + "plus_weight": 5307.463584778665, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 897, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 897, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "6925da0cf9a8843510093d3ddc61514c102584a61860e089dfb3a7326794a851", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:01:06.767015+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "2d15e1416b61bebc47382807891f2e4d733a0b85216d44f1e76ac46cd934c3ca", + "panel_kind": "isotropic", + "panel_seed": 13016877966896066155, + "realization": 4, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "2d6699c85ed7a82c3b5874c359675b2f0448ceefe13b39ca5eb3111f4d4ebba7", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.04809601880767759, + "kernel_residual": 2.034150795660813e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 529.5386723164141, + "minus_external_entropy": 0.9469349374238254, + "minus_target_effective_rank": 1081.565175885706, + "minus_target_entropy": 0.9775435230585435, + "minus_weight": 5380.355201249859, + "orthogonality_relative_error": 1.220152733927499e-16, + "plus_external_effective_rank": 529.5386723164142, + "plus_external_entropy": 0.9469349374238254, + "plus_target_effective_rank": 1081.5651758857064, + "plus_target_entropy": 0.9775435230585435, + "plus_weight": 5380.355201249846, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "3964e81032c90ed2d4fde3cdb92ece1fc5f1a406d1a7177409230d746cf9100f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:39:00.596918+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "492314913b4ed80daff2fa4627cf92aa13d35bfb477101f63428070a9af006df", + "panel_kind": "sparse", + "panel_seed": 7694621895931233280, + "realization": 5, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "1f80e37a3f63496451d5b8cbd8d89de55b4ac56f3af9e29071fdd19335997380", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.04257792682338606, + "kernel_residual": 2.0231209191931407e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 368.7631186891428, + "minus_external_entropy": 0.9265400401480702, + "minus_target_effective_rank": 642.5478003652474, + "minus_target_entropy": 0.9171737877925906, + "minus_weight": 5431.804081156406, + "orthogonality_relative_error": 1.3134551056455693e-16, + "plus_external_effective_rank": 368.76311868914297, + "plus_external_entropy": 0.9265400401480703, + "plus_target_effective_rank": 642.5478003652476, + "plus_target_entropy": 0.9171737877925905, + "plus_weight": 5431.804081156397, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 817, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 817, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "09d13a31871ae32438d7ba976a0441f8c232e632470020fdccbfe0c4ac99e4d1", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:58:19.255308+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "492314913b4ed80daff2fa4627cf92aa13d35bfb477101f63428070a9af006df", + "panel_kind": "isotropic", + "panel_seed": 7694621895931233280, + "realization": 5, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "7c06fb69236dd498650adc8428e6f74adc1bcfd28dbdc8de66b808e93a1d4d75", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.04257792682338606, + "kernel_residual": 2.0231209191931407e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 529.968386486889, + "minus_external_entropy": 0.9475161197430595, + "minus_target_effective_rank": 1077.8509976265855, + "minus_target_entropy": 0.977390548162922, + "minus_weight": 5352.177425728154, + "orthogonality_relative_error": 1.2480404945353476e-16, + "plus_external_effective_rank": 529.9683864868892, + "plus_external_entropy": 0.9475161197430596, + "plus_target_effective_rank": 1077.850997626586, + "plus_target_entropy": 0.9773905481629219, + "plus_weight": 5352.177425728147, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "771b4cf6f513e2e6cabe67632fd2f8c5f70174b7dbc765f49741be93c363f821", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:39:01.761468+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "f0df22d84c285f5caaa5bcbb0f182f8d438b0cfae0ecf8ce6062e399b930664c", + "panel_kind": "sparse", + "panel_seed": 15935061106643251543, + "realization": 6, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "88450f458ab81c9b7c34da073b0ab606c9463406a381c05b02690bfb921b9bcd", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.054114936306462566, + "kernel_residual": 2.0253813826263597e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 469.44827521195015, + "minus_external_entropy": 0.9356972129150244, + "minus_target_effective_rank": 818.5979061399196, + "minus_target_entropy": 0.9464296977434802, + "minus_weight": 5332.496653291844, + "orthogonality_relative_error": 1.2454772613052806e-16, + "plus_external_effective_rank": 469.44827521195003, + "plus_external_entropy": 0.9356972129150247, + "plus_target_effective_rank": 818.5979061399194, + "plus_target_entropy": 0.9464296977434802, + "plus_weight": 5332.496653291836, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 966, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 966, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "e7b5bee29e261c5ae67bc349d9c523c472d0d42a5b19d7c86ba8f7da3eb77d08", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:57:52.930411+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "f0df22d84c285f5caaa5bcbb0f182f8d438b0cfae0ecf8ce6062e399b930664c", + "panel_kind": "isotropic", + "panel_seed": 15935061106643251543, + "realization": 6, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "da060556f2c028fec37b4320ceeb6a021532044855e3157d95e4e2807e7d34dc", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.054114936306462566, + "kernel_residual": 2.0253813826263597e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 526.31814683542, + "minus_external_entropy": 0.9464105692610406, + "minus_target_effective_rank": 1088.5465007153052, + "minus_target_entropy": 0.9780023569212943, + "minus_weight": 5362.514649100586, + "orthogonality_relative_error": 1.2451255592594443e-16, + "plus_external_effective_rank": 526.3181468354207, + "plus_external_entropy": 0.9464105692610402, + "plus_target_effective_rank": 1088.5465007153052, + "plus_target_entropy": 0.9780023569212943, + "plus_weight": 5362.5146491006, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "799c8449464256036f74c24b9b2765881874ecf7a476dadf3347c1fec534b0c3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:41:56.149783+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "ff0429817752e456daabcd6c1fca06fc0fb36f8a7b89e1161d04ac0592fd97f1", + "panel_kind": "sparse", + "panel_seed": 14814302419033325208, + "realization": 7, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "b880feacc95eb699002cca3f738209a095bca28f3b0bc99fd929cb5d64e05e3b", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05733120220700862, + "kernel_residual": 2.0349895557438313e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 469.0446352998335, + "minus_external_entropy": 0.935537177635258, + "minus_target_effective_rank": 862.8995484223097, + "minus_target_entropy": 0.9519589189969071, + "minus_weight": 5480.036234460374, + "orthogonality_relative_error": 1.1990058159819224e-16, + "plus_external_effective_rank": 469.04463529983326, + "plus_external_entropy": 0.9355371776352577, + "plus_target_effective_rank": 862.8995484223101, + "plus_target_entropy": 0.951958918996907, + "plus_weight": 5480.036234460383, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 970, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 970, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "94db06daaa50b508200f064755f007b4210b8609570a3a74f462dba5b45278e1", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:09:17.589394+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "ff0429817752e456daabcd6c1fca06fc0fb36f8a7b89e1161d04ac0592fd97f1", + "panel_kind": "isotropic", + "panel_seed": 14814302419033325208, + "realization": 7, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "4dce16ae33abb350f1e501d746a3a539e6de24eb260572f51d6b8645370fff96", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05733120220700862, + "kernel_residual": 2.0349895557438313e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 532.8052734101343, + "minus_external_entropy": 0.9471149651007641, + "minus_target_effective_rank": 1089.2700316335665, + "minus_target_entropy": 0.9780283266050459, + "minus_weight": 5385.039687046543, + "orthogonality_relative_error": 1.1752771334595326e-16, + "plus_external_effective_rank": 532.8052734101341, + "plus_external_entropy": 0.947114965100764, + "plus_target_effective_rank": 1089.2700316335663, + "plus_target_entropy": 0.9780283266050458, + "plus_weight": 5385.039687046519, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "b5f06e639d41c803952d6614128f8cc2d5b12206110ecbe1376743c9eb506570", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:29:04.194035+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "05a3c7dff3b04753f7be64384ef875d2eeaed2c7897ee1889f6e7c9e60b2e459", + "panel_kind": "sparse", + "panel_seed": 4142177471754558599, + "realization": 8, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "36dd27e02b35a9fad7c1a3e1c128264e88635c619a4dd9869bd06ee31d15b42c", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05116147398193962, + "kernel_residual": 2.0246156004963573e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 457.66156837228635, + "minus_external_entropy": 0.933335170010793, + "minus_target_effective_rank": 839.2131108588326, + "minus_target_entropy": 0.9489503192437932, + "minus_weight": 5543.689491517089, + "orthogonality_relative_error": 1.2081620274996964e-16, + "plus_external_effective_rank": 457.6615683722864, + "plus_external_entropy": 0.9333351700107927, + "plus_target_effective_rank": 839.2131108588326, + "plus_target_entropy": 0.9489503192437931, + "plus_weight": 5543.689491517083, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 969, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 969, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "d28ac8231ea6959e71b0417958e3070a1b25cf4e381ce1840674d933c211f7f3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:50:37.822975+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "05a3c7dff3b04753f7be64384ef875d2eeaed2c7897ee1889f6e7c9e60b2e459", + "panel_kind": "isotropic", + "panel_seed": 4142177471754558599, + "realization": 8, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "fff54dad82bb0f4df72ebffa1d5b236528850dc5aca79c13e92199937d3657bc", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05116147398193962, + "kernel_residual": 2.0246156004963573e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 520.0686317751044, + "minus_external_entropy": 0.9451775350356153, + "minus_target_effective_rank": 1072.3452015456235, + "minus_target_entropy": 0.9768798215320101, + "minus_weight": 5510.334875614345, + "orthogonality_relative_error": 1.2066706729935328e-16, + "plus_external_effective_rank": 520.0686317751048, + "plus_external_entropy": 0.9451775350356153, + "plus_target_effective_rank": 1072.3452015456232, + "plus_target_entropy": 0.9768798215320101, + "plus_weight": 5510.334875614343, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "c06b8a00e487cffc4da1d1bc69ea74932a63d0b1ff0601bdc1c191d1e9ff527a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:38:56.458421+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "6f775ce05dec30aa96543c1cea7a63a1e78ec85641d96c9ee6eed8258af5e536", + "panel_kind": "sparse", + "panel_seed": 17103850960652368818, + "realization": 9, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "38d3a582d5336b9f45e20df40a37e12ee1e37e9dc570a3ce1a6b1c847cfcc873", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.0539465356405254, + "kernel_residual": 2.0218628859634226e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 468.85558592113426, + "minus_external_entropy": 0.9352274232265977, + "minus_target_effective_rank": 851.7908112171555, + "minus_target_entropy": 0.9505862146184952, + "minus_weight": 5356.895166903518, + "orthogonality_relative_error": 1.1573586106535861e-16, + "plus_external_effective_rank": 468.8555859211342, + "plus_external_entropy": 0.935227423226598, + "plus_target_effective_rank": 851.790811217155, + "plus_target_entropy": 0.9505862146184952, + "plus_weight": 5356.895166903506, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 975, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 975, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "4ced6e8f3de30f6642379b8c0ac9b89ab9110243c9691728e359fb3e97a857de", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:08:45.986210+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "6f775ce05dec30aa96543c1cea7a63a1e78ec85641d96c9ee6eed8258af5e536", + "panel_kind": "isotropic", + "panel_seed": 17103850960652368818, + "realization": 9, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "26ad28d2e0213f9817b4ee9e0c91f1cb972db23aefec6a7c9db8458583ac979b", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.0539465356405254, + "kernel_residual": 2.0218628859634226e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 541.910281119769, + "minus_external_entropy": 0.9485630174567605, + "minus_target_effective_rank": 1095.0352535827863, + "minus_target_entropy": 0.9784355320923172, + "minus_weight": 5270.548134531802, + "orthogonality_relative_error": 1.1347526421544015e-16, + "plus_external_effective_rank": 541.9102811197689, + "plus_external_entropy": 0.9485630174567605, + "plus_target_effective_rank": 1095.0352535827858, + "plus_target_entropy": 0.9784355320923173, + "plus_weight": 5270.548134531812, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "83179c942410992dc9babd2e4918a755166f6e383612012f6a77b6269ca14cdb", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:25:58.061512+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "2a853ca9533f17c53ba916ab1d6e511964fb89cfc1c7775ea712ef78316a3787", + "panel_kind": "sparse", + "panel_seed": 11005332186274908488, + "realization": 10, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "c3b7a6f2cf411b58bdd851befe54253d0522dc5e8934e872836197923840d01f", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05021032043937933, + "kernel_residual": 2.0307460493131833e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 429.2287421751439, + "minus_external_entropy": 0.9309921582580493, + "minus_target_effective_rank": 738.88824278514, + "minus_target_entropy": 0.9365859762731226, + "minus_weight": 5351.813723338523, + "orthogonality_relative_error": 1.2550171341359185e-16, + "plus_external_effective_rank": 429.22874217514374, + "plus_external_entropy": 0.9309921582580493, + "plus_target_effective_rank": 738.8882427851398, + "plus_target_entropy": 0.9365859762731226, + "plus_weight": 5351.813723338519, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 942, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 942, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "3bec147afdce729899c6d61351ea493f284e77ac6b05b85ce93bba10c0d2f443", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:48:03.330159+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "2a853ca9533f17c53ba916ab1d6e511964fb89cfc1c7775ea712ef78316a3787", + "panel_kind": "isotropic", + "panel_seed": 11005332186274908488, + "realization": 10, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "e864c5e25743a171096f7084b4e08a01f210177dd04881f025ff3290dfa310e6", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05021032043937933, + "kernel_residual": 2.0307460493131833e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 529.5233188347987, + "minus_external_entropy": 0.9472056421762743, + "minus_target_effective_rank": 1083.1494077423752, + "minus_target_entropy": 0.9776973754397015, + "minus_weight": 5317.050398072279, + "orthogonality_relative_error": 1.2304016044635305e-16, + "plus_external_effective_rank": 529.5233188347981, + "plus_external_entropy": 0.9472056421762743, + "plus_target_effective_rank": 1083.1494077423754, + "plus_target_entropy": 0.9776973754397016, + "plus_weight": 5317.050398072265, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "7e544be73528c578b85b20559d3ddc60aaf948c4169f5547b2aa1acc3fb49ddf", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:28:40.195263+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "d44be07074bc474775a05362412f5fb3dd27b9f8e1a7ae2b777a4bb8ea0696a0", + "panel_kind": "sparse", + "panel_seed": 2365108071897194445, + "realization": 11, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "9a44375078698edff90fb0325d86edabe740419287b1ac1bc46a21099688799f", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.051457402514771065, + "kernel_residual": 2.028716071375538e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 446.1357290546362, + "minus_external_entropy": 0.9323400659383176, + "minus_target_effective_rank": 782.8081892180695, + "minus_target_entropy": 0.9429979481435431, + "minus_weight": 5444.607218696584, + "orthogonality_relative_error": 1.1533582272258727e-16, + "plus_external_effective_rank": 446.1357290546362, + "plus_external_entropy": 0.9323400659383175, + "plus_target_effective_rank": 782.8081892180699, + "plus_target_entropy": 0.942997948143543, + "plus_weight": 5444.607218696574, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 956, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 956, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "095ede8d23cbae8515b113e5b095b198216ea083eab77f119718ad2df701020a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:52:27.539689+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "d44be07074bc474775a05362412f5fb3dd27b9f8e1a7ae2b777a4bb8ea0696a0", + "panel_kind": "isotropic", + "panel_seed": 2365108071897194445, + "realization": 11, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "d3aa276ea9dc7fd630543ea2f63c9e60b942ffb267bb9762748e337e48a698b2", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.051457402514771065, + "kernel_residual": 2.028716071375538e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 524.3232695069232, + "minus_external_entropy": 0.946234432921221, + "minus_target_effective_rank": 1085.143300878201, + "minus_target_entropy": 0.977804665448331, + "minus_weight": 5357.206139275149, + "orthogonality_relative_error": 1.1530972133289012e-16, + "plus_external_effective_rank": 524.3232695069235, + "plus_external_entropy": 0.9462344329212211, + "plus_target_effective_rank": 1085.1433008782008, + "plus_target_entropy": 0.977804665448331, + "plus_weight": 5357.206139275172, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "0dd3434b12a2cdfddb673c435ee62f550351c03a143c08b9ccae907809a8936f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:24:59.408977+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "bc4e1bb931f8e8881eab4af119beb202afa5d2810aad73f3dc52be60c49c9fee", + "panel_kind": "sparse", + "panel_seed": 6350266238866333025, + "realization": 12, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "3a60b9a64a8c35cdad445bb78206481946cec88d7ba63cf517689b1d8fb3631d", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.04434812534905368, + "kernel_residual": 2.0596456843667354e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 413.88149243044586, + "minus_external_entropy": 0.9274850968770271, + "minus_target_effective_rank": 757.9919402230264, + "minus_target_entropy": 0.9376209101647964, + "minus_weight": 5666.75844010537, + "orthogonality_relative_error": 1.3066914086376625e-16, + "plus_external_effective_rank": 413.88149243044575, + "plus_external_entropy": 0.9274850968770273, + "plus_target_effective_rank": 757.9919402230263, + "plus_target_entropy": 0.9376209101647965, + "plus_weight": 5666.758440105334, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 934, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 934, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "d039a3d01eeb9628fdbf8dba1d5f1d0afdcb0597ae0988b596316152da1becd6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:45:34.616758+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "bc4e1bb931f8e8881eab4af119beb202afa5d2810aad73f3dc52be60c49c9fee", + "panel_kind": "isotropic", + "panel_seed": 6350266238866333025, + "realization": 12, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "b2955973a9c0b568c60d3098d2d2f187e42aed278a82ca339cd4257abcf3ca5b", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.04434812534905368, + "kernel_residual": 2.0596456843667354e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 510.0016924004695, + "minus_external_entropy": 0.943789364902641, + "minus_target_effective_rank": 1076.0208876476738, + "minus_target_entropy": 0.9772026697435944, + "minus_weight": 5559.629973301265, + "orthogonality_relative_error": 1.2853070460464166e-16, + "plus_external_effective_rank": 510.0016924004696, + "plus_external_entropy": 0.943789364902641, + "plus_target_effective_rank": 1076.0208876476743, + "plus_target_entropy": 0.9772026697435944, + "plus_weight": 5559.629973301254, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "16bae4343be0cb4d87ad5d23754745fa62def1eded2eb40336ea75248b9e73a8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:17:50.040918+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "fff9eaaef2792345ac018b3c9dc43d6b3b404b4a5c227f321208202605f4410c", + "panel_kind": "sparse", + "panel_seed": 8100605094943718972, + "realization": 13, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "6fbb467efa51ffc94611e185b502b805a074c615b14556e09fb4cc5b6fba0dc6", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.04059423234040642, + "kernel_residual": 2.0115973259767153e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 443.92680487267256, + "minus_external_entropy": 0.9326007231924396, + "minus_target_effective_rank": 775.8487348555977, + "minus_target_entropy": 0.942237648040771, + "minus_weight": 5541.171976360908, + "orthogonality_relative_error": 1.313676493091427e-16, + "plus_external_effective_rank": 443.92680487267273, + "plus_external_entropy": 0.9326007231924396, + "plus_target_effective_rank": 775.8487348555981, + "plus_target_entropy": 0.9422376480407709, + "plus_weight": 5541.171976360913, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 960, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 960, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "5607813687d360997450efb8e6f9c3e5c2af745af8f82c3fd7ee945c9a274859", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:36:57.228677+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "fff9eaaef2792345ac018b3c9dc43d6b3b404b4a5c227f321208202605f4410c", + "panel_kind": "isotropic", + "panel_seed": 8100605094943718972, + "realization": 13, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "8c53b56a65e6afbb3f6a79b280dff23ba76fd29cfc4362704c0ed5fb5f8f0b48", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.04059423234040642, + "kernel_residual": 2.0115973259767153e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 517.7762138810147, + "minus_external_entropy": 0.9458116993303789, + "minus_target_effective_rank": 1076.866540409009, + "minus_target_entropy": 0.9773309534285426, + "minus_weight": 5374.3089334535325, + "orthogonality_relative_error": 1.2793244185636964e-16, + "plus_external_effective_rank": 517.7762138810148, + "plus_external_entropy": 0.9458116993303788, + "plus_target_effective_rank": 1076.8665404090088, + "plus_target_entropy": 0.9773309534285426, + "plus_weight": 5374.308933453541, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "a05a3b11670077c04baf8e73bb7193051cd852a297dc3f8a9125cc7b74849f71", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:17:07.980290+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "6c92b28102bbcf1442b8ed8065fca23fba5e7a0991d1c0508cdc39be52d68842", + "panel_kind": "sparse", + "panel_seed": 7163823160260522681, + "realization": 14, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "3413d476a0cabfcc3c3b95882c0a5b10014994cfe2e2788473f96ad522117967", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05380525083555529, + "kernel_residual": 2.0081106837553405e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 456.9198602602739, + "minus_external_entropy": 0.934825238621028, + "minus_target_effective_rank": 816.3558855118623, + "minus_target_entropy": 0.9460957362723001, + "minus_weight": 5346.154176220797, + "orthogonality_relative_error": 1.1519644151344797e-16, + "plus_external_effective_rank": 456.9198602602739, + "plus_external_entropy": 0.9348252386210278, + "plus_target_effective_rank": 816.355885511863, + "plus_target_entropy": 0.9460957362723001, + "plus_weight": 5346.154176220804, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 958, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 958, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "e2b109acfa1fabfedaa8563e43d6b182f9f7e53ee49aa5ba534eab8eefed09b4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:36:59.522302+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "6c92b28102bbcf1442b8ed8065fca23fba5e7a0991d1c0508cdc39be52d68842", + "panel_kind": "isotropic", + "panel_seed": 7163823160260522681, + "realization": 14, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "fcebe564f4e8c7acb81d4b7f8364206824bcdc35928f16c36d8d1a96ba61f803", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05380525083555529, + "kernel_residual": 2.0081106837553405e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 523.890803419177, + "minus_external_entropy": 0.946152879202728, + "minus_target_effective_rank": 1081.1869679342499, + "minus_target_entropy": 0.9775448738830784, + "minus_weight": 5381.745107491028, + "orthogonality_relative_error": 1.1463806257253315e-16, + "plus_external_effective_rank": 523.8908034191768, + "plus_external_entropy": 0.946152879202728, + "plus_target_effective_rank": 1081.1869679342503, + "plus_target_entropy": 0.9775448738830782, + "plus_weight": 5381.745107491026, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "a54c3f7e9bd5317d372925f40a2b4d4926b121fd557a0727aac7fb8e2532a43e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:37:35.582429+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "050d693832d62c4c52b18bb0162e623e6e5f51b8f67784a4e2e76f77bc8f8454", + "panel_kind": "sparse", + "panel_seed": 8551270917045007699, + "realization": 15, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "bfdf67cdc972f9a2db7c95e40b2903c1233eac6405c58ef8958732a671d52a74", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.048455501446502756, + "kernel_residual": 2.0185403733846895e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 465.11336601249934, + "minus_external_entropy": 0.9353674535584685, + "minus_target_effective_rank": 813.137565727844, + "minus_target_entropy": 0.9458092567470114, + "minus_weight": 5463.669177645148, + "orthogonality_relative_error": 1.1858143310309938e-16, + "plus_external_effective_rank": 465.1133660124994, + "plus_external_entropy": 0.9353674535584687, + "plus_target_effective_rank": 813.1375657278443, + "plus_target_entropy": 0.9458092567470113, + "plus_weight": 5463.669177645155, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 962, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 962, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "265da19e69d3f44b36b0465c3e3b5a3d464dc3d51801a4162ad6abfe8424c776", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:05:49.984109+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "050d693832d62c4c52b18bb0162e623e6e5f51b8f67784a4e2e76f77bc8f8454", + "panel_kind": "isotropic", + "panel_seed": 8551270917045007699, + "realization": 15, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "557a356533f223d143ba112c30bea569dfdddb248cea3b6a4d382a1a6bc2bac8", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.048455501446502756, + "kernel_residual": 2.0185403733846895e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 521.5009079372453, + "minus_external_entropy": 0.9455988777638299, + "minus_target_effective_rank": 1078.5270665864543, + "minus_target_entropy": 0.9773552581459046, + "minus_weight": 5413.567153084498, + "orthogonality_relative_error": 1.2016565249401803e-16, + "plus_external_effective_rank": 521.5009079372455, + "plus_external_entropy": 0.94559887776383, + "plus_target_effective_rank": 1078.5270665864546, + "plus_target_entropy": 0.9773552581459048, + "plus_weight": 5413.5671530845075, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "daf0d346aef0e6ec7f3bca4aeb781e86b1741aea6b80da8b69b3a086ebd08040", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:12:38.440256+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "1d73b934bbecf58691552168106d23bfb4499de4ae8aa2ef12c934baef83783e", + "panel_kind": "sparse", + "panel_seed": 17109517842045410926, + "realization": 16, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "b5e07ed713a2dae09b9206fd2df04bea90194c5469ebae36bd62c082fc086e4b", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.04299984969638454, + "kernel_residual": 2.0288532137332152e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 428.45316491581656, + "minus_external_entropy": 0.9310910763262888, + "minus_target_effective_rank": 747.7187201428059, + "minus_target_entropy": 0.9365124385272557, + "minus_weight": 5439.287301316646, + "orthogonality_relative_error": 1.2750169138425381e-16, + "plus_external_effective_rank": 428.45316491581593, + "plus_external_entropy": 0.9310910763262887, + "plus_target_effective_rank": 747.7187201428059, + "plus_target_entropy": 0.9365124385272556, + "plus_weight": 5439.287301316645, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 930, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 930, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "b9de388f6cdf881025f184d7487cb90ba839c42fe7785320e14235e2e11ad2ef", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:34:09.948653+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "1d73b934bbecf58691552168106d23bfb4499de4ae8aa2ef12c934baef83783e", + "panel_kind": "isotropic", + "panel_seed": 17109517842045410926, + "realization": 16, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "c56b992771ab76f030b3bf31c68953fd195ad7051423ebec7c34d877a6318281", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.04299984969638454, + "kernel_residual": 2.0288532137332152e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 507.1668604069142, + "minus_external_entropy": 0.9436108719643319, + "minus_target_effective_rank": 1068.6769334310188, + "minus_target_entropy": 0.9766768745949397, + "minus_weight": 5534.3773469951275, + "orthogonality_relative_error": 1.2664371787367256e-16, + "plus_external_effective_rank": 507.16686040691377, + "plus_external_entropy": 0.9436108719643319, + "plus_target_effective_rank": 1068.6769334310184, + "plus_target_entropy": 0.9766768745949397, + "plus_weight": 5534.377346995147, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "82edf8ccd3ebd61ac80d818e9b61e10db9613f81e60ae0eb52ae34cfb8a22523", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:35:52.527150+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "9f8972ea0ef088d59e449c76501d3559196c460fa85a6ab5d453f55a320bcb68", + "panel_kind": "sparse", + "panel_seed": 17641055589641598951, + "realization": 17, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "cbf8b3416071dabecdb0b8b36ca5ffed52d2ee8371a5de5f61ec7e30ff03ee35", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.06042421665690982, + "kernel_residual": 2.0113416129949864e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 453.505158056613, + "minus_external_entropy": 0.9336548818784132, + "minus_target_effective_rank": 831.7487534249443, + "minus_target_entropy": 0.947233186117139, + "minus_weight": 5326.892003838845, + "orthogonality_relative_error": 1.161097394990852e-16, + "plus_external_effective_rank": 453.50515805661297, + "plus_external_entropy": 0.9336548818784133, + "plus_target_effective_rank": 831.7487534249447, + "plus_target_entropy": 0.9472331861171389, + "plus_weight": 5326.89200383885, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 955, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 955, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "f14dd2dc8f17d531fe2e385043d63c8c38dd9397a556e08e3bfd5287d2f4e570", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T19:01:47.841301+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "9f8972ea0ef088d59e449c76501d3559196c460fa85a6ab5d453f55a320bcb68", + "panel_kind": "isotropic", + "panel_seed": 17641055589641598951, + "realization": 17, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "48541a79d370895d4afa8f0fb6eb7e9c55583df9467f34f95c8539e08d6d0e69", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.06042421665690982, + "kernel_residual": 2.0113416129949864e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 534.1709775819642, + "minus_external_entropy": 0.9474476319312268, + "minus_target_effective_rank": 1092.983888847004, + "minus_target_entropy": 0.9782522546050376, + "minus_weight": 5312.0286325175275, + "orthogonality_relative_error": 1.1439454704939594e-16, + "plus_external_effective_rank": 534.170977581964, + "plus_external_entropy": 0.9474476319312269, + "plus_target_effective_rank": 1092.983888847004, + "plus_target_entropy": 0.9782522546050374, + "plus_weight": 5312.028632517512, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "9c052e3fa9d7a42a0b779fa31a37084afe2b9385b5fcdbab1150f20716a638e3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:10:27.893379+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "36169ae30bdaaa26955353932ef5337a5b458b892fa026ce5697453fce888a16", + "panel_kind": "sparse", + "panel_seed": 18286260929351224896, + "realization": 18, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "8e9b301ab9620784f9a2c920d578e9c5befdacaa25c1d2adedf1a7f9527cc11a", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05414329480928646, + "kernel_residual": 2.0379565026930427e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 479.17263741241106, + "minus_external_entropy": 0.9373104747445434, + "minus_target_effective_rank": 867.3722577752873, + "minus_target_entropy": 0.9524439305754954, + "minus_weight": 5361.017194166276, + "orthogonality_relative_error": 1.1463748460705414e-16, + "plus_external_effective_rank": 479.1726374124112, + "plus_external_entropy": 0.9373104747445434, + "plus_target_effective_rank": 867.3722577752878, + "plus_target_entropy": 0.9524439305754955, + "plus_weight": 5361.017194166248, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 974, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 974, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "24b479ee88ae6094e7aecaa72b8d24ccb828871a9716a1c14edfc304f74febb4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:32:54.249125+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "36169ae30bdaaa26955353932ef5337a5b458b892fa026ce5697453fce888a16", + "panel_kind": "isotropic", + "panel_seed": 18286260929351224896, + "realization": 18, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "c19e3beac0b79bedbbb3f99578076a32bed7adc42bcd5a9ed9a40117a3da3a20", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05414329480928646, + "kernel_residual": 2.0379565026930427e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 531.0078606654299, + "minus_external_entropy": 0.947396783903698, + "minus_target_effective_rank": 1085.9806890733907, + "minus_target_entropy": 0.9778122646335361, + "minus_weight": 5305.997788262899, + "orthogonality_relative_error": 1.1363866817085658e-16, + "plus_external_effective_rank": 531.0078606654303, + "plus_external_entropy": 0.9473967839036981, + "plus_target_effective_rank": 1085.9806890733912, + "plus_target_entropy": 0.977812264633536, + "plus_weight": 5305.997788262897, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "431ff0499fb50eb9bf13cc21a6f47b1e2ba2a4a83143971bd1d6b30d9881ea29", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:15:46.854310+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "7ddfa6c1be36c608992b476c8bf9cd173f19614fe34c40c500ccfcafcf40937c", + "panel_kind": "sparse", + "panel_seed": 13423086526050934516, + "realization": 19, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "52240d364e706821e0e65f0547da607e04d9fbb2f95c0e744ad81bfe8e565d30", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05274803239695124, + "kernel_residual": 2.0361538547483723e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 471.4738719552589, + "minus_external_entropy": 0.9369041028816704, + "minus_target_effective_rank": 807.6566934082598, + "minus_target_entropy": 0.9457693490451358, + "minus_weight": 5171.049772532923, + "orthogonality_relative_error": 1.134971063523454e-16, + "plus_external_effective_rank": 471.4738719552589, + "plus_external_entropy": 0.9369041028816704, + "plus_target_effective_rank": 807.6566934082598, + "plus_target_entropy": 0.9457693490451357, + "plus_weight": 5171.0497725329105, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 966, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 966, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "93bb2eb7035a2efff9ef0f9176e5c53f76b5d03a795df702df9586dff828de95", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:37:38.413470+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "7ddfa6c1be36c608992b476c8bf9cd173f19614fe34c40c500ccfcafcf40937c", + "panel_kind": "isotropic", + "panel_seed": 13423086526050934516, + "realization": 19, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "6da86d401f6d472eae3cf2b0ab0477715082288256568560af2f4c43e507efdc", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05274803239695124, + "kernel_residual": 2.0361538547483723e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 534.4639203834039, + "minus_external_entropy": 0.9477696170742975, + "minus_target_effective_rank": 1082.3886421439645, + "minus_target_entropy": 0.9776317206778146, + "minus_weight": 5321.815393836576, + "orthogonality_relative_error": 1.1482510753905044e-16, + "plus_external_effective_rank": 534.463920383404, + "plus_external_entropy": 0.9477696170742976, + "plus_target_effective_rank": 1082.388642143965, + "plus_target_entropy": 0.9776317206778146, + "plus_weight": 5321.81539383658, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "2235f7438088a226e52a6bd88eda29bc1b38ce01514b885ef5e4169512a9e810", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:05:58.267415+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "7b15a5ff0a48f00b32d618b4baaaf8f25943466897f65d52196ceb288a4ecc12", + "panel_kind": "sparse", + "panel_seed": 4342592235867677898, + "realization": 20, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "7068a89386e2feba5c88d977fbc07a41a2f1d85f5be3f072ed048ee7bcb1e1b3", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.057031588939388915, + "kernel_residual": 2.0212750734006714e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 471.50288629688254, + "minus_external_entropy": 0.9371121813667526, + "minus_target_effective_rank": 811.3886172940041, + "minus_target_entropy": 0.9454104343322552, + "minus_weight": 5088.28772251783, + "orthogonality_relative_error": 1.1039051045384901e-16, + "plus_external_effective_rank": 471.50288629688265, + "plus_external_entropy": 0.9371121813667527, + "plus_target_effective_rank": 811.3886172940042, + "plus_target_entropy": 0.9454104343322552, + "plus_weight": 5088.2877225178045, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 954, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 954, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "e265b8f79f897f206a5e3a497f5a6e35f52169b240a19e4a99d9e7c557399afe", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:27:32.892154+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "7b15a5ff0a48f00b32d618b4baaaf8f25943466897f65d52196ceb288a4ecc12", + "panel_kind": "isotropic", + "panel_seed": 4342592235867677898, + "realization": 20, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "b10de13986c72d8d70ae7f1cb6ebf2716a03e5e4fc1da47a80033942e2c39d82", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.057031588939388915, + "kernel_residual": 2.0212750734006714e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 543.3566129536273, + "minus_external_entropy": 0.9487546109371938, + "minus_target_effective_rank": 1094.8727125036396, + "minus_target_entropy": 0.9784196740974644, + "minus_weight": 5288.581149668991, + "orthogonality_relative_error": 1.129685631603152e-16, + "plus_external_effective_rank": 543.3566129536276, + "plus_external_entropy": 0.948754610937194, + "plus_target_effective_rank": 1094.8727125036396, + "plus_target_entropy": 0.9784196740974646, + "plus_weight": 5288.581149669001, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "9a93c2255885fbce993ca78639133e65a9053b7403c8d6c317d593119434d815", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:56:39.327356+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "fff32bf4f05d0c39a5890613d6802d19b5618f8033f275ffabceb6dbd62d38d9", + "panel_kind": "sparse", + "panel_seed": 16369240777551081220, + "realization": 21, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "d7316df9a49721b9df80e7bf9f160cb6163977912b89d6bfa4af0ae58aa5e901", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05254324570858018, + "kernel_residual": 2.034908980273059e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 461.6067115497896, + "minus_external_entropy": 0.9359223796958578, + "minus_target_effective_rank": 826.8978681328341, + "minus_target_entropy": 0.946889782504661, + "minus_weight": 5295.24810004259, + "orthogonality_relative_error": 1.1429101763691482e-16, + "plus_external_effective_rank": 461.6067115497898, + "plus_external_entropy": 0.9359223796958577, + "plus_target_effective_rank": 826.8978681328346, + "plus_target_entropy": 0.9468897825046609, + "plus_weight": 5295.248100042608, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 956, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 956, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "412a43aa50155fafc1df631a2c22aecc40731ca19b9aa6e147e4c4cf90c01904", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:15:44.579183+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "fff32bf4f05d0c39a5890613d6802d19b5618f8033f275ffabceb6dbd62d38d9", + "panel_kind": "isotropic", + "panel_seed": 16369240777551081220, + "realization": 21, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "1ae86087f09e3f997b662b72fb25a7bc18d316d98e690f5a7f029ca096c97b61", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05254324570858018, + "kernel_residual": 2.034908980273059e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 536.4765061690975, + "minus_external_entropy": 0.9477825122330631, + "minus_target_effective_rank": 1086.9308866079343, + "minus_target_entropy": 0.9779004880154502, + "minus_weight": 5320.348304558419, + "orthogonality_relative_error": 1.1214796188514838e-16, + "plus_external_effective_rank": 536.4765061690972, + "plus_external_entropy": 0.947782512233063, + "plus_target_effective_rank": 1086.930886607934, + "plus_target_entropy": 0.9779004880154502, + "plus_weight": 5320.348304558439, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "5634dc72c342377a59fa8306527b02bd45c87530e08a079c5ae4e152728cecf9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:56:28.268926+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "d8411cfa5ec9462cde78d7e94c441ec6c24630a1d260a23eda07a256f844c44e", + "panel_kind": "sparse", + "panel_seed": 385086368628158531, + "realization": 22, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "2c3990ad5ae0bd9aa51700dac3c33d9d5262e5d38793161615d66fcef819db8d", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.051107535257629136, + "kernel_residual": 2.0205467152062442e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 436.51548994218996, + "minus_external_entropy": 0.9305849788436784, + "minus_target_effective_rank": 757.2057673143532, + "minus_target_entropy": 0.9384852363869705, + "minus_weight": 5441.352514600651, + "orthogonality_relative_error": 1.1823762324382985e-16, + "plus_external_effective_rank": 436.51548994218973, + "plus_external_entropy": 0.9305849788436785, + "plus_target_effective_rank": 757.2057673143534, + "plus_target_entropy": 0.9384852363869705, + "plus_weight": 5441.352514600647, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 950, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 950, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "4359c53367c93a61d31135387b4b3dafa269c1d32f387c6fd3976c31d2d68790", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:15:33.545030+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "d8411cfa5ec9462cde78d7e94c441ec6c24630a1d260a23eda07a256f844c44e", + "panel_kind": "isotropic", + "panel_seed": 385086368628158531, + "realization": 22, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "5c5f8a113b1a6a8a0a5eae90ec3bfd3353e5a5e8ec1b4dcda9615bf327433da6", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.051107535257629136, + "kernel_residual": 2.0205467152062442e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 531.6616627667321, + "minus_external_entropy": 0.9472803605697858, + "minus_target_effective_rank": 1085.4034866637228, + "minus_target_entropy": 0.9778083632579141, + "minus_weight": 5338.813182722601, + "orthogonality_relative_error": 1.161095926683848e-16, + "plus_external_effective_rank": 531.6616627667323, + "plus_external_entropy": 0.9472803605697858, + "plus_target_effective_rank": 1085.4034866637232, + "plus_target_entropy": 0.9778083632579142, + "plus_weight": 5338.8131827226025, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "30343d38ada3cf85b92a28ddd27caf11f11fb9a10f77c6c8d9a5c35c87e1aeb7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:30:19.419977+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "4866af8455f9f56c157442e3ecfc937a4cd6ab20317feaaf4fb01995c6b299a3", + "panel_kind": "sparse", + "panel_seed": 3717881926686875612, + "realization": 23, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "2831e5bca71067320fff0d610c9d6db80ea27035c9e434dbb2f575112e02c28e", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05607387928082041, + "kernel_residual": 2.034110242105376e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 494.1014447944366, + "minus_external_entropy": 0.9393758872625899, + "minus_target_effective_rank": 912.8900120862354, + "minus_target_entropy": 0.9580130874892999, + "minus_weight": 5350.169396202246, + "orthogonality_relative_error": 1.150765454685868e-16, + "plus_external_effective_rank": 494.1014447944366, + "plus_external_entropy": 0.9393758872625899, + "plus_target_effective_rank": 912.8900120862355, + "plus_target_entropy": 0.9580130874892999, + "plus_weight": 5350.169396202257, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "9ffcb2ffeb5fdb343b2aa1e11a2a44d1a70b4f156ab47f461995d47292aaf4e8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T19:00:21.652120+00:00", + "identity": { + "N": 14, + "charge": 7, + "kernel_identity_hash": "4866af8455f9f56c157442e3ecfc937a4cd6ab20317feaaf4fb01995c6b299a3", + "panel_kind": "isotropic", + "panel_seed": 3717881926686875612, + "realization": 23, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "9ee2222252809ab3c2fd0ea54358bb75aa92c12dcf92e110079258e36459bb3d", + "kernel": { + "bps_rank": 1458, + "complement_rank": 1974, + "gap": 0.05607387928082041, + "kernel_residual": 2.034110242105376e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 537.46869777537, + "minus_external_entropy": 0.9479449789359091, + "minus_target_effective_rank": 1091.825379603063, + "minus_target_entropy": 0.9782380429919589, + "minus_weight": 5282.4002129137625, + "orthogonality_relative_error": 1.1414056339091536e-16, + "plus_external_effective_rank": 537.4686977753701, + "plus_external_entropy": 0.9479449789359092, + "plus_target_effective_rank": 1091.8253796030635, + "plus_target_entropy": 0.9782380429919588, + "plus_weight": 5282.400212913754, + "target_rank": 1458 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 987, + "minus_target_eigenvalues": 1458, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 987, + "plus_target_eigenvalues": 1458 + } + }, + { + "arrays_sha256": "6fae6f46bc5e3dec9455a6d7517fe35c1f4d23fc90a0d3f2e2c7d5a5a3e3ff19", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:12:53.527416+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "7d7d86e11ddfde4488299b94a45c7e9c4324e964594c8400fa2e22b1678c6f6a", + "panel_kind": "sparse", + "panel_seed": 11315907620672301939, + "realization": 0, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "2beff8669c29f2697c9cb68894f593581fec373ea0ebe0e3c330a46f18fed468", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.00447657383963012, + "kernel_residual": 1.6898592337787596e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2624286424999286, + "minus_external_effective_rank": 207.53811584908524, + "minus_external_entropy": 0.9436415429972322, + "minus_target_effective_rank": 400.0858326345294, + "minus_target_entropy": 0.9394012312898994, + "minus_weight": 909.3613585055305, + "orthogonality_relative_error": 5.446191020728178e-16, + "plus_external_effective_rank": 412.8786680020735, + "plus_external_entropy": 0.8753343959816835, + "plus_target_effective_rank": 502.4808646247554, + "plus_target_entropy": 0.9672697727501625, + "plus_weight": 11972.912726121736, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 362, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1693, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "d71471c76bb163238938ba6b5faf19440a7a402a713a59ff7878da0bc9dbb7c3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:17:58.720486+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "7d7d86e11ddfde4488299b94a45c7e9c4324e964594c8400fa2e22b1678c6f6a", + "panel_kind": "isotropic", + "panel_seed": 11315907620672301939, + "realization": 0, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "2d89a5dcbb5bc7a85e6e2fbb9948482bd32cec24296d8f318e170515a8a67822", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.00447657383963012, + "kernel_residual": 1.6898592337787596e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.25244696225093516, + "minus_external_effective_rank": 225.65398758725684, + "minus_external_entropy": 0.9527678098820875, + "minus_target_effective_rank": 526.2698217776306, + "minus_target_entropy": 0.9719848551050781, + "minus_weight": 891.1246054778022, + "orthogonality_relative_error": 5.419132225991778e-16, + "plus_external_effective_rank": 474.50100536606357, + "plus_external_entropy": 0.8812931960212326, + "plus_target_effective_rank": 594.444502703337, + "plus_target_entropy": 0.9839597715964461, + "plus_weight": 12272.837981151877, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "325730f24aa56c32929c27fee3fc2f38d87696805c11933840057f3cac4ae95f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:14:45.971168+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "71191c1d6a83008d86d7552e449c6903f89efa4fde5b3c2d7fb79b96c82abfa8", + "panel_kind": "sparse", + "panel_seed": 6523632372641523166, + "realization": 1, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "3c462c55fa9d30e08df0d03da1ea90b11a4c9cc69a169bf06a359bf1663ed4d6", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004462159732556592, + "kernel_residual": 1.687854486323663e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24224100378224844, + "minus_external_effective_rank": 192.84609248631747, + "minus_external_entropy": 0.9364410067481374, + "minus_target_effective_rank": 387.9052206692356, + "minus_target_entropy": 0.9355986512310237, + "minus_weight": 888.9247001038369, + "orthogonality_relative_error": 5.974860017126117e-16, + "plus_external_effective_rank": 401.30210942702365, + "plus_external_entropy": 0.8728897579261141, + "plus_target_effective_rank": 500.62856530023396, + "plus_target_entropy": 0.9669336846205496, + "plus_weight": 12838.95686886112, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 361, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1665, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "79ae7338595544da0699d5a56f96ce43d106f5fa262961f4dabf615e7c340284", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:20:46.269876+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "71191c1d6a83008d86d7552e449c6903f89efa4fde5b3c2d7fb79b96c82abfa8", + "panel_kind": "isotropic", + "panel_seed": 6523632372641523166, + "realization": 1, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "aa6fd7c5cfeef794bca8776c8277fbdd67c87bcbc09b01120b5400b830168246", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004462159732556592, + "kernel_residual": 1.687854486323663e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24985906088459783, + "minus_external_effective_rank": 224.74024318133104, + "minus_external_entropy": 0.9523920027572653, + "minus_target_effective_rank": 525.082533954741, + "minus_target_entropy": 0.9717784596908444, + "minus_weight": 902.5092116881775, + "orthogonality_relative_error": 5.922089815001468e-16, + "plus_external_effective_rank": 464.4908807769349, + "plus_external_entropy": 0.8791954973832945, + "plus_target_effective_rank": 588.4660591316353, + "plus_target_entropy": 0.9831117913020502, + "plus_weight": 12578.519213196074, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "d6e006d63e56e7bedd5c3fa5d4b9df431cc66fa47599f962e68756e8b7db367c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:13:29.925924+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "d9501ab118d39daf9c041ec7043641ba87bde8f6a6fe19e32be2ea7b61cf9f06", + "panel_kind": "sparse", + "panel_seed": 8628668977036442449, + "realization": 2, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "e337bc257a477640eec1d52544f23d5710acbd9e45965ed5d46d9c9f6dc100ac", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004647795297821999, + "kernel_residual": 1.7074945993025352e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.22836776087975164, + "minus_external_effective_rank": 185.05420048804754, + "minus_external_entropy": 0.9321364955044726, + "minus_target_effective_rank": 392.1441477315482, + "minus_target_entropy": 0.9367394784998652, + "minus_weight": 887.1408869111556, + "orthogonality_relative_error": 5.896359578173185e-16, + "plus_external_effective_rank": 391.0589147787084, + "plus_external_entropy": 0.870120695537894, + "plus_target_effective_rank": 504.972810113187, + "plus_target_entropy": 0.9681545850426022, + "plus_weight": 13707.112715677891, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 360, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1672, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "e3d00d849297062b9d7f5ea37a68379be1f20a5e5fe1ee0cdc02646b147d2f22", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:18:32.062464+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "d9501ab118d39daf9c041ec7043641ba87bde8f6a6fe19e32be2ea7b61cf9f06", + "panel_kind": "isotropic", + "panel_seed": 8628668977036442449, + "realization": 2, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "f12792543f158476bef95769f73050ebfd4fffd45535f5556603bf750b7d56bd", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004647795297821999, + "kernel_residual": 1.7074945993025352e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2497488885622179, + "minus_external_effective_rank": 223.12569595683638, + "minus_external_entropy": 0.9514682588849425, + "minus_target_effective_rank": 524.6116658385369, + "minus_target_entropy": 0.9717524519848161, + "minus_weight": 921.0776966370363, + "orthogonality_relative_error": 5.794109580892232e-16, + "plus_external_effective_rank": 459.4333148636056, + "plus_external_entropy": 0.8783212925502059, + "plus_target_effective_rank": 590.4787424556382, + "plus_target_entropy": 0.983435630423155, + "plus_weight": 12843.851682333283, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "607c04a3c87fe709848b7310c877bce3d150e8aea4ce6290c5fd3bed6b21e8e0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:12:43.855456+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "47af019433690b0ae23ca3e6373691d1afb405707ec9595a407cc29834437658", + "panel_kind": "sparse", + "panel_seed": 3663025868112947357, + "realization": 3, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "2f051bc1a67fd43d7532054276199147fa13651233734b6a5077e995ce58ed4c", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004007521106691197, + "kernel_residual": 1.6968324038592153e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24864528074310266, + "minus_external_effective_rank": 196.5325933509409, + "minus_external_entropy": 0.9389144438886575, + "minus_target_effective_rank": 393.3576745982429, + "minus_target_entropy": 0.9377351300869976, + "minus_weight": 886.5135012864403, + "orthogonality_relative_error": 6.177337095464055e-16, + "plus_external_effective_rank": 400.982855567515, + "plus_external_entropy": 0.8724349557858931, + "plus_target_effective_rank": 506.2434428692595, + "plus_target_entropy": 0.9684225852780275, + "plus_weight": 12425.219428165597, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 362, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1706, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "a5ae04f9b354f94c4086320e216801d6b3864ff4964cbdc153d4310fbadaff24", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:17:24.050420+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "47af019433690b0ae23ca3e6373691d1afb405707ec9595a407cc29834437658", + "panel_kind": "isotropic", + "panel_seed": 3663025868112947357, + "realization": 3, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "aacf15e112900c7f1524cf27b998d9aa40f2b693122e5ce8a97e5e03d4cdaec7", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004007521106691197, + "kernel_residual": 1.6968324038592153e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2433522547455551, + "minus_external_effective_rank": 222.98432050186, + "minus_external_entropy": 0.9515940073777213, + "minus_target_effective_rank": 525.7527409580713, + "minus_target_entropy": 0.9718650065928235, + "minus_weight": 887.9625043482893, + "orthogonality_relative_error": 6.256624711757226e-16, + "plus_external_effective_rank": 443.7987124210699, + "plus_external_entropy": 0.8765053357675346, + "plus_target_effective_rank": 587.9207149292193, + "plus_target_entropy": 0.9831317432933432, + "plus_weight": 12757.780311317221, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "34501f71d63cb90035b11d45b8b833a16e104e4148dbbac3ede45ff004ab6f1e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:12:31.704083+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "c88dc1acfce2f1cc9051af83d5daec3c136ef182a4d24ae8e46b36f5f5065615", + "panel_kind": "sparse", + "panel_seed": 8543133560199270471, + "realization": 4, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "5b07d375e30d6eb605a4b14bcc7c1a10a13fa440d0022b5f8e6c89b8b5e3e9cf", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.005742886323751588, + "kernel_residual": 1.6951287704090425e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2678106638543567, + "minus_external_effective_rank": 209.6770939334271, + "minus_external_entropy": 0.9446142204824857, + "minus_target_effective_rank": 394.79795821817174, + "minus_target_entropy": 0.9380505481450022, + "minus_weight": 879.5380798063088, + "orthogonality_relative_error": 4.308203682031149e-16, + "plus_external_effective_rank": 437.06634697311716, + "plus_external_entropy": 0.8810428810585361, + "plus_target_effective_rank": 507.28290063137257, + "plus_target_entropy": 0.9680014413990222, + "plus_weight": 11309.2355282849, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 360, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1663, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "0b6c2ac6da00238376bb9f11637b3b634e111af945d98815243003f9a728e231", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:17:05.426797+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "c88dc1acfce2f1cc9051af83d5daec3c136ef182a4d24ae8e46b36f5f5065615", + "panel_kind": "isotropic", + "panel_seed": 8543133560199270471, + "realization": 4, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "54ce746836b7dccba24fd6a2e2e84d2be1817fa0af47440de0582d24cd1189d0", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.005742886323751588, + "kernel_residual": 1.6951287704090425e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2609275246784515, + "minus_external_effective_rank": 236.4758034022816, + "minus_external_entropy": 0.956850139486468, + "minus_target_effective_rank": 533.6776700310456, + "minus_target_entropy": 0.9731745692015441, + "minus_weight": 869.5855433612394, + "orthogonality_relative_error": 4.357668181987097e-16, + "plus_external_effective_rank": 496.4461488286429, + "plus_external_entropy": 0.8858061513290076, + "plus_target_effective_rank": 603.2853823603845, + "plus_target_entropy": 0.9851325761791976, + "plus_weight": 11525.905218618493, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "c890c1d5bf871e5f1c09c4bc6589167a0c1863758d88d608fd997b84fe2f2f33", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:20:31.023125+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "5d494c86d192a4bf981cbf98f2dd70753099eb4f7b75d14dec7f0810fa7095b5", + "panel_kind": "sparse", + "panel_seed": 16579931707330176506, + "realization": 5, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "e941f22f39c99aa8ee9bfb0a408ac6d57837ebb4ac984b796b1c39acaaed9db0", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004339171901431506, + "kernel_residual": 1.693871089198311e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.25023373300788687, + "minus_external_effective_rank": 190.72035969980294, + "minus_external_entropy": 0.9355322423644794, + "minus_target_effective_rank": 348.574439264987, + "minus_target_entropy": 0.923824380588871, + "minus_weight": 908.8337836434565, + "orthogonality_relative_error": 5.695503773459466e-16, + "plus_external_effective_rank": 391.196011944451, + "plus_external_entropy": 0.8738985087433313, + "plus_target_effective_rank": 472.0438780734595, + "plus_target_entropy": 0.9609031594890182, + "plus_weight": 12644.768721022581, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 357, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1588, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "0e7e4554293776fa22d914699925fa271697dd0dcce5a695df2325d21fa80847", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:24:58.624382+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "5d494c86d192a4bf981cbf98f2dd70753099eb4f7b75d14dec7f0810fa7095b5", + "panel_kind": "isotropic", + "panel_seed": 16579931707330176506, + "realization": 5, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "4575251dff194dd3e23dd35eb4666819ca7257781dc84dc4d83bdd3952d45b8e", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004339171901431506, + "kernel_residual": 1.693871089198311e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2582991334701273, + "minus_external_effective_rank": 227.76249616807686, + "minus_external_entropy": 0.953705476739896, + "minus_target_effective_rank": 526.6573373553496, + "minus_target_entropy": 0.972155828102377, + "minus_weight": 918.3793631473262, + "orthogonality_relative_error": 5.709264989930015e-16, + "plus_external_effective_rank": 472.11441084040666, + "plus_external_entropy": 0.880494960903728, + "plus_target_effective_rank": 587.4792388824656, + "plus_target_entropy": 0.9829947154605408, + "plus_weight": 12316.713893554319, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "5e6f906e05ff39f09a187d1bbf6589c279d484dd6d3956fbf908ccd1045aa8fd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:20:16.982158+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "5d9236bca61624345b9d09bc2ec314fbce6dedf913659a3ca709b2294aa3ddbd", + "panel_kind": "sparse", + "panel_seed": 10842859000516131574, + "realization": 6, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "da7259da2a77705e3f6e8bba5072b9b6ae4fa2cc7666be0fe1b4b04b42820613", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004131238670759399, + "kernel_residual": 1.6677961519919614e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2704913437431147, + "minus_external_effective_rank": 188.65869058343972, + "minus_external_entropy": 0.9346109988657864, + "minus_target_effective_rank": 359.78814236296205, + "minus_target_entropy": 0.928861246916324, + "minus_weight": 927.5257320512617, + "orthogonality_relative_error": 5.990848501682588e-16, + "plus_external_effective_rank": 400.35883617587365, + "plus_external_entropy": 0.8741815449635336, + "plus_target_effective_rank": 470.891333679927, + "plus_target_entropy": 0.9608219407158395, + "plus_weight": 11788.129401922573, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 360, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1623, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "7fe89f0afd57163def66dbc90d01a41eb1d44c4cac3630dfeb11f47bc2507a34", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:24:35.259103+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "5d9236bca61624345b9d09bc2ec314fbce6dedf913659a3ca709b2294aa3ddbd", + "panel_kind": "isotropic", + "panel_seed": 10842859000516131574, + "realization": 6, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "df2b48fd815b22cbf84dc1043e26b50dd0afa4d4b0ef021108473f52bcb90a56", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004131238670759399, + "kernel_residual": 1.6677961519919614e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2397698747027001, + "minus_external_effective_rank": 217.3579924340052, + "minus_external_entropy": 0.9491633696420558, + "minus_target_effective_rank": 521.58551586541, + "minus_target_entropy": 0.971162118947424, + "minus_weight": 912.4729017977776, + "orthogonality_relative_error": 6.190052941760201e-16, + "plus_external_effective_rank": 439.93719184526543, + "plus_external_entropy": 0.8740568097734631, + "plus_target_effective_rank": 582.4160314868788, + "plus_target_entropy": 0.9822845904951037, + "plus_weight": 13335.09478699313, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "af881008fda724be35af01f253f043a2486f3e6d44135c0f012ac97c28be91a8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:13:16.079444+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "eb9db68ce0fc0121c464f818228bee5a892ad9b25a7bc1e65f85d27ea5fdb42a", + "panel_kind": "sparse", + "panel_seed": 507211971998319045, + "realization": 7, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "e19eefced5a1b06fc9da78d048d25ae67814e25276faa84aa080fab0f824541f", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004224113173589308, + "kernel_residual": 1.6708781319930912e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.23018854731600213, + "minus_external_effective_rank": 187.1383515973761, + "minus_external_entropy": 0.9335608959273313, + "minus_target_effective_rank": 388.52147453131545, + "minus_target_entropy": 0.9357876302906136, + "minus_weight": 909.3537229581033, + "orthogonality_relative_error": 5.818861499054396e-16, + "plus_external_effective_rank": 376.00844759822587, + "plus_external_entropy": 0.8661313901419858, + "plus_target_effective_rank": 496.4576469014815, + "plus_target_entropy": 0.9663947653377271, + "plus_weight": 13923.796701715013, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 362, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1688, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "cc5909f562cdef4fb36200948803d6b7e4e9d31838f4bae7fb337dec02829410", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:18:44.413119+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "eb9db68ce0fc0121c464f818228bee5a892ad9b25a7bc1e65f85d27ea5fdb42a", + "panel_kind": "isotropic", + "panel_seed": 507211971998319045, + "realization": 7, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "7e32cea818ad9c5e29886e8a251143969a8c39e73f760569054b40d5404bd397", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004224113173589308, + "kernel_residual": 1.6708781319930912e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2445456193168836, + "minus_external_effective_rank": 218.77700978178908, + "minus_external_entropy": 0.9502824299400697, + "minus_target_effective_rank": 520.1583634942483, + "minus_target_entropy": 0.9709656295395359, + "minus_weight": 912.9492131891865, + "orthogonality_relative_error": 5.830416182895366e-16, + "plus_external_effective_rank": 449.6580209248583, + "plus_external_entropy": 0.8761483171120917, + "plus_target_effective_rank": 586.1467881354789, + "plus_target_entropy": 0.9827900897908692, + "plus_weight": 13043.188528145749, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "62936b121a82c939eb1101ddde4f5801e546a5681b5a12eb278b6a6801cd02c1", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:52:02.743665+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "712d46d5f216ba50e2956d751b02d89e24f583f910ee97607bc5e50b334d6a4b", + "panel_kind": "sparse", + "panel_seed": 12181992498764151658, + "realization": 8, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "3c090da39c2eeace2503c7b02ef114986285a8fae44513f449eadd9256123a72", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004952101467067646, + "kernel_residual": 1.6795432717461427e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.264532633446461, + "minus_external_effective_rank": 196.91914560360115, + "minus_external_entropy": 0.9385721732878353, + "minus_target_effective_rank": 380.711266722665, + "minus_target_entropy": 0.9342552744976231, + "minus_weight": 893.3418034118008, + "orthogonality_relative_error": 4.840697757302224e-16, + "plus_external_effective_rank": 420.56070594725753, + "plus_external_entropy": 0.8769668688704854, + "plus_target_effective_rank": 498.94212172513386, + "plus_target_entropy": 0.9669372563954004, + "plus_weight": 11653.059743146781, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1666, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "3893880f9170173b53e9451a95ef36aa097285f9842b08330dde1d9f760b06f2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:57:21.589785+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "712d46d5f216ba50e2956d751b02d89e24f583f910ee97607bc5e50b334d6a4b", + "panel_kind": "isotropic", + "panel_seed": 12181992498764151658, + "realization": 8, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "a621a6e0ed82ef138a64d606aa770a674402c7e7175dc32175448e5af80481ee", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004952101467067646, + "kernel_residual": 1.6795432717461427e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2539263121704872, + "minus_external_effective_rank": 230.51595512449106, + "minus_external_entropy": 0.9549058330630267, + "minus_target_effective_rank": 529.4826410815524, + "minus_target_entropy": 0.9725235004410429, + "minus_weight": 899.8782410619804, + "orthogonality_relative_error": 4.926043644699075e-16, + "plus_external_effective_rank": 467.6891799323181, + "plus_external_entropy": 0.8799973477904965, + "plus_target_effective_rank": 592.5518712046523, + "plus_target_entropy": 0.9836897475317272, + "plus_weight": 12309.883846153916, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "7af8e2ee528bd3359211e790a2920e30642aab9048f6f476287398c0f97c86fd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:53:23.786868+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "43e4f67fbb85cc523c9d8f649148ef35b03529dec4632f648e60d589b492fbdb", + "panel_kind": "sparse", + "panel_seed": 10739125050814602517, + "realization": 9, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "33661a9073ea94e3577aa6a623e73046632a3dc4db8599e6487ea8f277328f30", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.003908597357232877, + "kernel_residual": 1.6936274288962523e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2729374401248743, + "minus_external_effective_rank": 202.92772510022178, + "minus_external_entropy": 0.940790341425509, + "minus_target_effective_rank": 385.21733558052756, + "minus_target_entropy": 0.9365643733261481, + "minus_weight": 927.437038187686, + "orthogonality_relative_error": 5.663962029349636e-16, + "plus_external_effective_rank": 407.58655926995135, + "plus_external_entropy": 0.8738440928757383, + "plus_target_effective_rank": 484.3664909665322, + "plus_target_entropy": 0.9642148566270755, + "plus_weight": 11663.314253182241, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1693, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "c0f86f1c4be5dc79e6bb0306fa525ffc737bb78ce73be3c3c09954185f6d5233", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:00:37.519456+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "43e4f67fbb85cc523c9d8f649148ef35b03529dec4632f648e60d589b492fbdb", + "panel_kind": "isotropic", + "panel_seed": 10739125050814602517, + "realization": 9, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "d967c99bf195ee6824ac3aa1e3d4e22658652fb4a665da437ab9fdd11f67c393", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.003908597357232877, + "kernel_residual": 1.6936274288962523e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2543709713135262, + "minus_external_effective_rank": 225.38797573592583, + "minus_external_entropy": 0.9527832042198292, + "minus_target_effective_rank": 527.6745062718134, + "minus_target_entropy": 0.9721952425172421, + "minus_weight": 903.4351520589827, + "orthogonality_relative_error": 5.711351214140944e-16, + "plus_external_effective_rank": 452.44511345206587, + "plus_external_entropy": 0.8786001691627329, + "plus_target_effective_rank": 583.5495132208857, + "plus_target_entropy": 0.9825297975851158, + "plus_weight": 12333.529050421514, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "44bf81fa40d371a7c3f1562c3c3c8dbad3dc70d9975221747f5dcfd337b093ae", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:52:38.385873+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "38894eea972bce5762ececcdab386308459601259db14fcc08f5e7f3c0680512", + "panel_kind": "sparse", + "panel_seed": 3451300366954357602, + "realization": 10, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "418ca098e87d0788b3b0ac01f0719cbcb1b6a61e155bbc7d792d65ad3d333009", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.005191036445526835, + "kernel_residual": 1.6750206481289455e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.25393989479340956, + "minus_external_effective_rank": 203.38558327388262, + "minus_external_entropy": 0.9418759292813533, + "minus_target_effective_rank": 387.121506436251, + "minus_target_entropy": 0.9361336908586669, + "minus_weight": 906.2601300560657, + "orthogonality_relative_error": 4.526310676674746e-16, + "plus_external_effective_rank": 423.00975197185943, + "plus_external_entropy": 0.8764637681916208, + "plus_target_effective_rank": 505.15528567451423, + "plus_target_entropy": 0.9676111542867055, + "plus_weight": 12396.417204169, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 361, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1678, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "1aad9fc483ac613dfad8f24c8d7253d743bf031c84089704672d46112663661e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:58:34.451230+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "38894eea972bce5762ececcdab386308459601259db14fcc08f5e7f3c0680512", + "panel_kind": "isotropic", + "panel_seed": 3451300366954357602, + "realization": 10, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "44235a21a4f4ee1dc44cfd23222a74ed0b46644cd12a85b3b3df0ccf8bbebe4b", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.005191036445526835, + "kernel_residual": 1.6750206481289455e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2580543390062984, + "minus_external_effective_rank": 228.3296283760207, + "minus_external_entropy": 0.9538181613514952, + "minus_target_effective_rank": 529.2039356170536, + "minus_target_entropy": 0.9725168118052265, + "minus_weight": 914.6327273818446, + "orthogonality_relative_error": 4.564888285305189e-16, + "plus_external_effective_rank": 485.0780803679393, + "plus_external_entropy": 0.8822533451965938, + "plus_target_effective_rank": 596.7449372716738, + "plus_target_entropy": 0.9841506479975787, + "plus_weight": 12279.97758833093, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "2fd122fca6ac2a7c5cacd6a0183316cd02c68d186b15a3b1920ab67c0df95a0a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:51:34.032270+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "b7fb1e9b64381a27bdb88d548f4e7ec1b2397d3f75fe5d8c7f22a12607ad8835", + "panel_kind": "sparse", + "panel_seed": 16976177981620289904, + "realization": 11, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "755fc313c196d8a92647066b0737fb8a0927370de088d77b20342458a7c481fa", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004049058731580823, + "kernel_residual": 1.7014056654195375e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2799635948797133, + "minus_external_effective_rank": 203.61687765990197, + "minus_external_entropy": 0.9415354911815516, + "minus_target_effective_rank": 372.1164598163955, + "minus_target_entropy": 0.9330139011136163, + "minus_weight": 949.0228140785961, + "orthogonality_relative_error": 5.846555738064778e-16, + "plus_external_effective_rank": 417.15443341037576, + "plus_external_entropy": 0.875920083934601, + "plus_target_effective_rank": 481.8943752252511, + "plus_target_entropy": 0.963359103345376, + "plus_weight": 11583.433298596023, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 362, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1673, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "111d8a85916ca779bbed0856dafe1ce58e28b5f9166c00d4fcd02e66266bcbfc", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:56:59.091090+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "b7fb1e9b64381a27bdb88d548f4e7ec1b2397d3f75fe5d8c7f22a12607ad8835", + "panel_kind": "isotropic", + "panel_seed": 16976177981620289904, + "realization": 11, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "59b47632041fed4897fdab7b1236547b1364efdb2cfecee21dfd78923b3a5602", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004049058731580823, + "kernel_residual": 1.7014056654195375e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24560527175314023, + "minus_external_effective_rank": 221.4466363251211, + "minus_external_entropy": 0.9508671812470059, + "minus_target_effective_rank": 524.6985523063144, + "minus_target_entropy": 0.9717057264516958, + "minus_weight": 921.4560054349864, + "orthogonality_relative_error": 6.133866751181002e-16, + "plus_external_effective_rank": 449.6352455314626, + "plus_external_entropy": 0.8758335568318533, + "plus_target_effective_rank": 584.7380212687498, + "plus_target_entropy": 0.9825671840468205, + "plus_weight": 13099.374210476457, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "5dc325962da89f55953fa7f335408ab2f82de01c2726b29dc3f6050e51dd89c1", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:51:40.152178+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "9b28d2ab83926eefc5b828a668af407f1d0cfb913a6e204df7cabe9a94835934", + "panel_kind": "sparse", + "panel_seed": 844601651688833423, + "realization": 12, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "33e894bde09e178fa7d42c62a458ca59f5416a83c92872b4663b60b78f790cc6", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004987698421740948, + "kernel_residual": 1.6756975884685523e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24658309306818454, + "minus_external_effective_rank": 194.67063279098184, + "minus_external_entropy": 0.9372072939560167, + "minus_target_effective_rank": 385.33632310721106, + "minus_target_entropy": 0.9353809054362375, + "minus_weight": 884.5491629945714, + "orthogonality_relative_error": 5.204068028016736e-16, + "plus_external_effective_rank": 393.91712820348073, + "plus_external_entropy": 0.8718891874368072, + "plus_target_effective_rank": 490.6688227937779, + "plus_target_entropy": 0.9651576975235266, + "plus_weight": 12517.296046698319, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 360, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1647, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "3a1bca5f8e3d82f15f5e9f9803fe47385d4f1f16317961d920f96f3351a3a7a3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:57:16.466568+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "9b28d2ab83926eefc5b828a668af407f1d0cfb913a6e204df7cabe9a94835934", + "panel_kind": "isotropic", + "panel_seed": 844601651688833423, + "realization": 12, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "6ae762782e454b55ccff8d8a64443a289770fdd13d8b3c3d645d5e5eb2f90c04", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004987698421740948, + "kernel_residual": 1.6756975884685523e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2582281042501938, + "minus_external_effective_rank": 230.89025636614846, + "minus_external_entropy": 0.9549220780740396, + "minus_target_effective_rank": 530.0896050110626, + "minus_target_entropy": 0.9726650700540385, + "minus_weight": 891.4815237224473, + "orthogonality_relative_error": 5.14816838390758e-16, + "plus_external_effective_rank": 480.37177862951614, + "plus_external_entropy": 0.8826892964340921, + "plus_target_effective_rank": 594.5493327841349, + "plus_target_entropy": 0.9839785269576851, + "plus_weight": 11959.79594870582, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "9b99686756fdbaba2353a305d6be4f30c90b64bb892cfc5336171e8d23e94dd0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:51:29.359152+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "1f4f2081c1a3948c896dc6cd6dc02be3bba67c08ecdf79b670b4d7e324446d1e", + "panel_kind": "sparse", + "panel_seed": 40593663491519228, + "realization": 13, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "1961c6c9a25f001e6e7fac755d13955cac497941fd775e03c682f3c3b1f1cd10", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.003850776685929571, + "kernel_residual": 1.69266542764803e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.23473371120035288, + "minus_external_effective_rank": 198.21907385625218, + "minus_external_entropy": 0.9387123774862824, + "minus_target_effective_rank": 396.5605363583815, + "minus_target_entropy": 0.9376148184978575, + "minus_weight": 878.4885307367589, + "orthogonality_relative_error": 5.744881344598511e-16, + "plus_external_effective_rank": 388.9593512683886, + "plus_external_entropy": 0.8706554704178336, + "plus_target_effective_rank": 515.8039189378289, + "plus_target_entropy": 0.9701210648152017, + "plus_weight": 13154.313958015104, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1706, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "0a33d6948d3352028edbe114fb4a19c961d06edccacda83ca5e40ad163246e23", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:56:22.108136+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "1f4f2081c1a3948c896dc6cd6dc02be3bba67c08ecdf79b670b4d7e324446d1e", + "panel_kind": "isotropic", + "panel_seed": 40593663491519228, + "realization": 13, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "2859a133fef366e2c8ea47ca2d7d6f933640c8893d4d10f66f8e9c5c911645c5", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.003850776685929571, + "kernel_residual": 1.69266542764803e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2513620215241684, + "minus_external_effective_rank": 226.0883582000902, + "minus_external_entropy": 0.9531529461495919, + "minus_target_effective_rank": 528.4541682386291, + "minus_target_entropy": 0.9723264324804378, + "minus_weight": 887.1821871011957, + "orthogonality_relative_error": 5.560777970962912e-16, + "plus_external_effective_rank": 454.2459099519799, + "plus_external_entropy": 0.8790898040498737, + "plus_target_effective_rank": 586.9928523764706, + "plus_target_entropy": 0.9830252550969134, + "plus_weight": 12279.536668616243, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "0c53f77fb2db84baa9667a0be69a13db4a22dd00fb35fac11b01d59c81fe3546", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:51:22.904703+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "b220643d8cbf319668c11c711564dbc207de3a20fcb0f9ebc4b416c751210e01", + "panel_kind": "sparse", + "panel_seed": 16718489534373418319, + "realization": 14, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "21ef98bfcfb34b3c82b5839a6d48788011d8e9e1658984fc442e32eb299b6cf9", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004292481412610861, + "kernel_residual": 1.6840512757925532e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24855161818338312, + "minus_external_effective_rank": 182.30388513614778, + "minus_external_entropy": 0.9311676833105558, + "minus_target_effective_rank": 374.35066100316106, + "minus_target_entropy": 0.931423541653739, + "minus_weight": 930.5459397979733, + "orthogonality_relative_error": 5.496371091139441e-16, + "plus_external_effective_rank": 380.7661546355301, + "plus_external_entropy": 0.8725694464235035, + "plus_target_effective_rank": 472.06837393650375, + "plus_target_entropy": 0.960249673273368, + "plus_weight": 13048.04043942154, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 354, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1561, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "85102b350476e4fd23ed8cd2e11e9c67ee42725787ee6c1a106c5070168162c2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:56:12.113329+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "b220643d8cbf319668c11c711564dbc207de3a20fcb0f9ebc4b416c751210e01", + "panel_kind": "isotropic", + "panel_seed": 16718489534373418319, + "realization": 14, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "947269efd7e8d47f59105a0172608db4de990a2c15ed5237cf874357d932b05b", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004292481412610861, + "kernel_residual": 1.6840512757925532e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2496428790806166, + "minus_external_effective_rank": 223.45201433005357, + "minus_external_entropy": 0.9519289228521675, + "minus_target_effective_rank": 524.653404956519, + "minus_target_entropy": 0.9717062049304901, + "minus_weight": 911.255911267215, + "orthogonality_relative_error": 5.603412801168322e-16, + "plus_external_effective_rank": 454.9034263973697, + "plus_external_entropy": 0.8777853540665226, + "plus_target_effective_rank": 587.2840496173867, + "plus_target_entropy": 0.9829932661303955, + "plus_weight": 12713.122640493819, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "da21597f44e09f1dc9033f92c2d910c3f3900912f73b16a1d2881a3549fec209", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:53:08.522351+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "fe6cd295395cc871d5e8f298b9e9f7ed7f5d34878b5944545344cd77503b1937", + "panel_kind": "sparse", + "panel_seed": 5907119261916166493, + "realization": 15, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "0ef6e4a0ccd858638d4f86c2e298844b52513d60cbdfd712b709f5a8ae423fcd", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004582105143394325, + "kernel_residual": 1.6818800089381285e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2494117593578277, + "minus_external_effective_rank": 202.58324411152503, + "minus_external_entropy": 0.9415599464347155, + "minus_target_effective_rank": 412.52929628135524, + "minus_target_entropy": 0.9431541629191054, + "minus_weight": 897.7562117780882, + "orthogonality_relative_error": 5.345632372793925e-16, + "plus_external_effective_rank": 405.819414458767, + "plus_external_entropy": 0.870819196006288, + "plus_target_effective_rank": 506.3225864568435, + "plus_target_entropy": 0.9687134850766909, + "plus_weight": 12538.183929159413, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1758, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "01255a1f131e778598f7b26464a7dd903f4515abdca05690d13dc811d31b125f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:59:18.542060+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "fe6cd295395cc871d5e8f298b9e9f7ed7f5d34878b5944545344cd77503b1937", + "panel_kind": "isotropic", + "panel_seed": 5907119261916166493, + "realization": 15, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "a1cff0e9e6f52f1eb39abe0a7c53492ff4ab068a03487d04a1cd723998a8636e", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004582105143394325, + "kernel_residual": 1.6818800089381285e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2552636649924062, + "minus_external_effective_rank": 227.4150076349983, + "minus_external_entropy": 0.9534622793007893, + "minus_target_effective_rank": 526.2558725281349, + "minus_target_entropy": 0.9719523749452676, + "minus_weight": 896.4518379681936, + "orthogonality_relative_error": 5.380011616194901e-16, + "plus_external_effective_rank": 460.347728496306, + "plus_external_entropy": 0.8793566339669112, + "plus_target_effective_rank": 583.9980600672822, + "plus_target_entropy": 0.9824984814118398, + "plus_weight": 12188.628707416812, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "f89c1175dae34a10ee5446eb14ad6a61118da786f7a1e2a9f86aa6f544b8414f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:54:34.691581+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "d87a63b93271cdb0d9567edab8c8a077ab6029434105067270ae9fba9d605342", + "panel_kind": "sparse", + "panel_seed": 6683896610288120545, + "realization": 16, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "e8a3b9c2ec197ee4953a218f2147661365667f1c9c31deb3ef90f0d8cae874a0", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.0035107673814062383, + "kernel_residual": 1.690428556711783e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.23206680515663264, + "minus_external_effective_rank": 189.16621399041807, + "minus_external_entropy": 0.9352045544853074, + "minus_target_effective_rank": 415.212952520198, + "minus_target_entropy": 0.9433487030470906, + "minus_weight": 905.8948292213687, + "orthogonality_relative_error": 6.703114448999358e-16, + "plus_external_effective_rank": 388.85102902253686, + "plus_external_entropy": 0.8661033339740157, + "plus_target_effective_rank": 517.4526904482991, + "plus_target_entropy": 0.9709982076943131, + "plus_weight": 13742.876253518478, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1780, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "39631d2ab6c32ded74fe17dfb1e0610711e30f4ea98917975ed54453f87efb6c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:59:44.035603+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "d87a63b93271cdb0d9567edab8c8a077ab6029434105067270ae9fba9d605342", + "panel_kind": "isotropic", + "panel_seed": 6683896610288120545, + "realization": 16, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "2f00a3bda2a87dda2e88560a3952c97d71b156557accc41c4d193f0f5fd15993", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.0035107673814062383, + "kernel_residual": 1.690428556711783e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2437973598929058, + "minus_external_effective_rank": 219.5802010414096, + "minus_external_entropy": 0.950219492528136, + "minus_target_effective_rank": 520.1485944717555, + "minus_target_entropy": 0.9710306503602454, + "minus_weight": 920.4113983209207, + "orthogonality_relative_error": 6.693636317275408e-16, + "plus_external_effective_rank": 432.4240842090684, + "plus_external_entropy": 0.8735511093779631, + "plus_target_effective_rank": 577.9466818435312, + "plus_target_entropy": 0.9817185495709975, + "plus_weight": 13196.233233971938, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "2f79a2c3f65b7763add919b47631485952dfdf3fd867c8b1a3be60103dc126e7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:56:09.428325+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "b2c23b76128a516297ee1054a30cdcf75119d2f61308feae16140caddaf46f32", + "panel_kind": "sparse", + "panel_seed": 3070948522824079961, + "realization": 17, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "5db473f83a16417728c909162b9fc6cbd1310918dacd67d3ab8262b27059e27d", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.0032673612043962316, + "kernel_residual": 1.6850607863196818e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24095144389828663, + "minus_external_effective_rank": 195.74399137996264, + "minus_external_entropy": 0.9388335373234431, + "minus_target_effective_rank": 404.216650485419, + "minus_target_entropy": 0.9409656658103287, + "minus_weight": 892.5521156206441, + "orthogonality_relative_error": 6.758972218458331e-16, + "plus_external_effective_rank": 394.54631462659637, + "plus_external_entropy": 0.8714563895247576, + "plus_target_effective_rank": 510.72603838522315, + "plus_target_entropy": 0.9692262933675615, + "plus_weight": 12970.604490733826, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 360, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1707, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "98535b4710a8a2bb246219e1b3546a284fadf58ac8207e5d4fedbd906c801939", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:02:38.118351+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "b2c23b76128a516297ee1054a30cdcf75119d2f61308feae16140caddaf46f32", + "panel_kind": "isotropic", + "panel_seed": 3070948522824079961, + "realization": 17, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "7679325f5b4810adb8f5b9671705c70128fe9df8df560b6b7cdfd463cb5defb5", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.0032673612043962316, + "kernel_residual": 1.6850607863196818e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24957739050548788, + "minus_external_effective_rank": 222.5951713329834, + "minus_external_entropy": 0.9517498504912808, + "minus_target_effective_rank": 524.9445357455902, + "minus_target_entropy": 0.9718115338706547, + "minus_weight": 900.7127633218888, + "orthogonality_relative_error": 6.775449564938777e-16, + "plus_external_effective_rank": 439.5356467953295, + "plus_external_entropy": 0.876515768379421, + "plus_target_effective_rank": 577.2149795510361, + "plus_target_entropy": 0.9816868000701078, + "plus_weight": 12569.839451055937, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "521a0c5bd527528ef4fa178591b5373e424de7c771d120b6b6f244b70773fcdd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:54:54.842469+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "17a6c1b052d9530912026835b7e3bbbacce400b176a07add06f51e22bc751b74", + "panel_kind": "sparse", + "panel_seed": 13565948178723679850, + "realization": 18, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "e32c8cd0c34e53a21dca84e140eaaa914c34cf02e03f7b2e87fd4a43689af857", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.0035021155630075023, + "kernel_residual": 1.6751943091671915e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.25013888710148413, + "minus_external_effective_rank": 196.05598544321984, + "minus_external_entropy": 0.9383222206506289, + "minus_target_effective_rank": 387.72810730241434, + "minus_target_entropy": 0.9357038505763828, + "minus_weight": 909.6124528831454, + "orthogonality_relative_error": 6.067143678923191e-16, + "plus_external_effective_rank": 392.29328554192347, + "plus_external_entropy": 0.8714922113196992, + "plus_target_effective_rank": 492.83007029133273, + "plus_target_entropy": 0.9658551427246349, + "plus_weight": 12661.14435606569, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 361, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1679, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "177f89a2b0b90e6dc53fac068250c78a2002aabc3d1cc0969d0d9cb7e6ac6060", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:00:24.354068+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "17a6c1b052d9530912026835b7e3bbbacce400b176a07add06f51e22bc751b74", + "panel_kind": "isotropic", + "panel_seed": 13565948178723679850, + "realization": 18, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "5d57840828c0517a68cdc5d20c2355ecb014d3990a91c9995999bddcfe2e81b3", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.0035021155630075023, + "kernel_residual": 1.6751943091671915e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24328003465345585, + "minus_external_effective_rank": 217.6835068722723, + "minus_external_entropy": 0.9497173642342766, + "minus_target_effective_rank": 521.4588432439427, + "minus_target_entropy": 0.9712383514862394, + "minus_weight": 910.5602544835248, + "orthogonality_relative_error": 6.136423298583387e-16, + "plus_external_effective_rank": 442.4976667169782, + "plus_external_entropy": 0.8754380581436622, + "plus_target_effective_rank": 582.7583438439522, + "plus_target_entropy": 0.9824439012199058, + "plus_weight": 13086.917661726056, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "a83dcc6d56d737dfe3e3fa7798c132e48f36a33f152bee5bd4a1e0a414201d3a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:54:31.258601+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "74a355d10d0f060bd6acf8075fe02ddff98507b33189ddf8551bc908dbef99ac", + "panel_kind": "sparse", + "panel_seed": 5964332557448801311, + "realization": 19, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "947a8114b86536753bca9de87b15e500b355a02719b9248203b0c775004e96ab", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.005599329223439752, + "kernel_residual": 1.6972640881001538e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.25201228174830065, + "minus_external_effective_rank": 188.9591248128784, + "minus_external_entropy": 0.9347001625034671, + "minus_target_effective_rank": 364.79550611395314, + "minus_target_entropy": 0.9287407540933103, + "minus_weight": 885.2845811777739, + "orthogonality_relative_error": 5.068678196314836e-16, + "plus_external_effective_rank": 405.25355392241653, + "plus_external_entropy": 0.8775282092982901, + "plus_target_effective_rank": 485.6333708385555, + "plus_target_entropy": 0.96316543812868, + "plus_weight": 12216.730128321396, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 357, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1574, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "9e6def7b6e7b0030fd44b7b36b908560c07d8b5d73007a141ab5899e0ed24129", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:59:54.120238+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "74a355d10d0f060bd6acf8075fe02ddff98507b33189ddf8551bc908dbef99ac", + "panel_kind": "isotropic", + "panel_seed": 5964332557448801311, + "realization": 19, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "a91ad6776d7a5aa3b399603e9fdf7bba53b1fc1c27780c17bd6f28bbb5a9a3bd", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.005599329223439752, + "kernel_residual": 1.6972640881001538e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2572312805645478, + "minus_external_effective_rank": 231.51690871545827, + "minus_external_entropy": 0.9550491517333198, + "minus_target_effective_rank": 530.4820249077, + "minus_target_entropy": 0.972622116302215, + "minus_weight": 897.3013158142458, + "orthogonality_relative_error": 5.060802769513295e-16, + "plus_external_effective_rank": 493.7383280841184, + "plus_external_entropy": 0.8839749205298306, + "plus_target_effective_rank": 603.8210944237998, + "plus_target_entropy": 0.9851739916675761, + "plus_weight": 12092.034631737173, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "09ab8aca3eeb3d3a3cff610d194d54bcb2f2dc76abb82848d759ed5222535511", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:54:06.166165+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "97c63bd492c12759505e53d057a0a9a7cdcf7e20897848772c5f5f9dd9262f31", + "panel_kind": "sparse", + "panel_seed": 5116590047739337967, + "realization": 20, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "91e38e992c88d0f9dc51c205f122436c048af7765b03202b0691127de30ec851", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.0031009895665443437, + "kernel_residual": 1.6944416337910495e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2329353339421636, + "minus_external_effective_rank": 181.9724290648261, + "minus_external_entropy": 0.9304766245968625, + "minus_target_effective_rank": 365.6410692869829, + "minus_target_entropy": 0.9286970330827556, + "minus_weight": 924.7237482695062, + "orthogonality_relative_error": 7.592069350622446e-16, + "plus_external_effective_rank": 367.452245692172, + "plus_external_entropy": 0.8664346103486428, + "plus_target_effective_rank": 472.9246057375518, + "plus_target_entropy": 0.9616943716823843, + "plus_weight": 13968.829586443113, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 359, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1619, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "e5302abb0f43102845a0960bbfdf27bb6bd082a5cc99ba92b5ffea772bc0074a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:00:14.233238+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "97c63bd492c12759505e53d057a0a9a7cdcf7e20897848772c5f5f9dd9262f31", + "panel_kind": "isotropic", + "panel_seed": 5116590047739337967, + "realization": 20, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "e5f175ef8a712bf1a0f375bd8dbc64bd7710f0a956af401b55498845eba7b31c", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.0031009895665443437, + "kernel_residual": 1.6944416337910495e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24318014220362885, + "minus_external_effective_rank": 219.4227317378753, + "minus_external_entropy": 0.950202697592334, + "minus_target_effective_rank": 521.1605429312625, + "minus_target_entropy": 0.9712834191367479, + "minus_weight": 925.9263080876174, + "orthogonality_relative_error": 7.584689828139335e-16, + "plus_external_effective_rank": 423.285364199607, + "plus_external_entropy": 0.8714174736602014, + "plus_target_effective_rank": 570.0061942789295, + "plus_target_entropy": 0.9805259508832728, + "plus_weight": 13314.048488440718, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "d2ba36cb89e27471c0f320009a634556450fb02ffcb76bca839556a2edb698cb", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:53:51.796962+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "9b4c5d8236040ef4d5e9dc107b7d5fdb1b6ecccf7b04e0021c34fc3141e5fbac", + "panel_kind": "sparse", + "panel_seed": 7532407415813755705, + "realization": 21, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "84815ba140a3529e9853686c04bee86607b31b0112783fe99ecedfaa6782884a", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004440100587375846, + "kernel_residual": 1.694115413691959e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24086587123702283, + "minus_external_effective_rank": 185.11746410118158, + "minus_external_entropy": 0.9322131786193375, + "minus_target_effective_rank": 379.7636109266507, + "minus_target_entropy": 0.9330835377518284, + "minus_weight": 914.9879436025567, + "orthogonality_relative_error": 5.51616522429592e-16, + "plus_external_effective_rank": 381.4687856132305, + "plus_external_entropy": 0.8694621135765956, + "plus_target_effective_rank": 486.596183839478, + "plus_target_entropy": 0.964295416078423, + "plus_weight": 13302.064959607973, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 361, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1658, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "4688ace5caa4696cf663ffa681e026c177c0710f2c6f7700a025071e55d559ae", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:58:39.320479+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "9b4c5d8236040ef4d5e9dc107b7d5fdb1b6ecccf7b04e0021c34fc3141e5fbac", + "panel_kind": "isotropic", + "panel_seed": 7532407415813755705, + "realization": 21, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "a928ce8f3dae52e54f4949a32386bb131943f7f842f39f22fb82a62051604eaa", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.004440100587375846, + "kernel_residual": 1.694115413691959e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24781015263980938, + "minus_external_effective_rank": 219.21681998703488, + "minus_external_entropy": 0.9502719575827803, + "minus_target_effective_rank": 522.515284247724, + "minus_target_entropy": 0.9713874321068803, + "minus_weight": 920.4076261399317, + "orthogonality_relative_error": 5.557015019519239e-16, + "plus_external_effective_rank": 465.57497349325075, + "plus_external_entropy": 0.8789230122970392, + "plus_target_effective_rank": 591.2255416350911, + "plus_target_entropy": 0.9834637689547239, + "plus_weight": 12950.427166769192, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "4ba6f1a823c9e00e2220b4c7ba38013a0c07aef290ce4b9cbca343d7cdbfc7a3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:53:55.459882+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "f6a627d29b0f2e5ec47c0df093d6c732f4b982f0c735538ebb478563e3ceb76a", + "panel_kind": "sparse", + "panel_seed": 12487628631542986208, + "realization": 22, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "855d38cfc708aefc6279e9cbd7662fa7c2a7a8182c11175284cd82e2cf269f0a", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.0037456920466905747, + "kernel_residual": 1.6992134137279095e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.22798990426879864, + "minus_external_effective_rank": 185.39106627309857, + "minus_external_entropy": 0.9322499071332229, + "minus_target_effective_rank": 393.57387428217515, + "minus_target_entropy": 0.9369361874104356, + "minus_weight": 892.3148544690237, + "orthogonality_relative_error": 6.305220484758565e-16, + "plus_external_effective_rank": 374.37420077800294, + "plus_external_entropy": 0.8669381305994962, + "plus_target_effective_rank": 496.48801603894776, + "plus_target_entropy": 0.96686295412992, + "plus_weight": 13813.067131696584, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 361, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1686, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "8131af64da5a200c301d1b19a7d9a98798261217eeaa9d5ada2ef846864ddae3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:58:41.104488+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "f6a627d29b0f2e5ec47c0df093d6c732f4b982f0c735538ebb478563e3ceb76a", + "panel_kind": "isotropic", + "panel_seed": 12487628631542986208, + "realization": 22, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "5dacb97ad31e24930af4262f6ddd7e2307101a0fc5de6b807c795b66c779640f", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.0037456920466905747, + "kernel_residual": 1.6992134137279095e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.25035669452495907, + "minus_external_effective_rank": 222.61039733835173, + "minus_external_entropy": 0.9516425907959359, + "minus_target_effective_rank": 524.8205423884684, + "minus_target_entropy": 0.9718431179076744, + "minus_weight": 901.4574373011654, + "orthogonality_relative_error": 6.238369668506485e-16, + "plus_external_effective_rank": 445.5061584426201, + "plus_external_entropy": 0.8766143102685597, + "plus_target_effective_rank": 578.3671326817848, + "plus_target_entropy": 0.9817782880903644, + "plus_weight": 12535.026180559207, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "79be6be1d02f72821ad761cc7327f17f206fed4aae3ba1a74abe00016624fd28", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:55:27.223830+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "bed468670f91f10cde4817291c2f45607125b314ac32849115056e40dd62cb05", + "panel_kind": "sparse", + "panel_seed": 6404668591680953092, + "realization": 23, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "eda4fff0f68cd8fb9bedcff161e988d4748f8c5a67dfc5fe2cd4e45a9b8f7938", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.0036199246482235, + "kernel_residual": 1.6893229647681227e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24100934126640663, + "minus_external_effective_rank": 196.15862126153303, + "minus_external_entropy": 0.9384082362108744, + "minus_target_effective_rank": 384.91506295681387, + "minus_target_entropy": 0.9355353713847413, + "minus_weight": 899.7506199459922, + "orthogonality_relative_error": 5.778855526533578e-16, + "plus_external_effective_rank": 378.7312341394484, + "plus_external_entropy": 0.8673682772166423, + "plus_target_effective_rank": 491.3506985610843, + "plus_target_entropy": 0.9654664682769195, + "plus_weight": 13071.608170818718, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 361, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1677, + "plus_target_eigenvalues": 729 + } + }, + { + "arrays_sha256": "cad00b6d5a6d292790f2935cabcda313cc892f37fdce08891c2c9d7d594b631d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T18:01:51.696415+00:00", + "identity": { + "N": 14, + "charge": 6, + "kernel_identity_hash": "bed468670f91f10cde4817291c2f45607125b314ac32849115056e40dd62cb05", + "panel_kind": "isotropic", + "panel_seed": 6404668591680953092, + "realization": 23, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a" + }, + "version": "v7" + }, + "identity_hash": "7f15fc8450ea436c6df0c45f95c49eab7e06a83559af7cabc1bde9811f594591", + "kernel": { + "bps_rank": 729, + "complement_rank": 2274, + "gap": 0.0036199246482235, + "kernel_residual": 1.6893229647681227e-14 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.24104699493711373, + "minus_external_effective_rank": 220.66248399753357, + "minus_external_entropy": 0.9507906405843841, + "minus_target_effective_rank": 523.685169129522, + "minus_target_entropy": 0.9715734919608754, + "minus_weight": 908.6168218543256, + "orthogonality_relative_error": 5.888502124278056e-16, + "plus_external_effective_rank": 429.35136725555833, + "plus_external_entropy": 0.8725991346922122, + "plus_target_effective_rank": 575.4671610326973, + "plus_target_entropy": 0.9813054786535857, + "plus_weight": 13198.0497838504, + "target_rank": 729 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 363, + "minus_target_eigenvalues": 729, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 1911, + "plus_target_eigenvalues": 729 + } + } + ], + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_inference.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_inference.json new file mode 100644 index 000000000..fa41f1a4e --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_inference.json @@ -0,0 +1,72 @@ +{ + "checks": { + "complete_primary_pair": true, + "complete_realization_uncertainty": true, + "prediction_precedes_unseal": true, + "registered_branch_resolved": true, + "valid_prediction_seal": true + }, + "pair_coverage": { + "collapsed": false, + "hodge": false + }, + "passed": true, + "physical_bootstrap_replicates": 10000, + "prediction_sha256": "fc300dc7e4bdc1be157919e458ac868d3468533cce31108f23c9fba4f7e9f102", + "primary_pair": [ + { + "N": 14, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11178894327406741, + 0.11182073355743845, + 0.11185243656607288 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.11234396147287215, + 0.11242666326099385, + 0.11251284962232763 + ], + "observed_median": 0.3015287195325017, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.2915274750468075, + 0.3120611443736316 + ], + "realizations": 24, + "robust_outside_both": true, + "sector": "adjacent" + }, + { + "N": 14, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.1113377289462959, + 0.11134480106449174, + 0.11135301768590472 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.11133252105193724, + 0.11133957071189352, + 0.11134819894894332 + ], + "observed_median": 0.3749925716126603, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3689804933327322, + 0.38047305142967947 + ], + "realizations": 24, + "robust_outside_both": true, + "sector": "central" + } + ], + "robust_non_gaussian_excess": true, + "scored_utc": "2026-08-04T01:18:16.350778+00:00", + "selected_branch": "cohomological_non_gaussian_class", + "structured_indistinguishable": false, + "unsealed_utc": "2026-08-04T01:18:16.227834+00:00", + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_prediction.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_prediction.json new file mode 100644 index 000000000..916cff993 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_prediction.json @@ -0,0 +1,733 @@ +{ + "checks": { + "complete_realization_unit": true, + "complete_requested_grid": true, + "finite_prediction_arrays": true, + "no_outcome_leakage": true, + "registered_primary_pair": true, + "safe_covariates_preexist": true + }, + "generated_utc": "2026-08-02T03:33:49.214466+00:00", + "groups": [ + { + "N": 14, + "collapsed_array_sha256": "d6bd3fab9d6cec1d155f8d3e099991cd9d7e69aa45e9177d18094f089b47d759", + "collapsed_interval": [ + 0.11168168098654796, + 0.1117066700773818, + 0.11173170450892318 + ], + "hodge_array_sha256": "c6d10bc45fa015b28fa1832f82c7c313ae7370039b703d0f3669f44dd25709bf", + "hodge_interval": [ + 0.11184927806177311, + 0.11189003830955453, + 0.11192687592249242 + ], + "null_banks": [ + { + "arrays_sha256": "66f0355ea1e62d6f36108051768bbc56da46e8be3172e91e2b4201e6456c525a", + "metadata_sha256": "65cbeda8031ff44b06d6d2a86e8369c05cb4963cc8b3332ae153718f9c24e32e", + "realization": 0 + }, + { + "arrays_sha256": "1d379f439005b9e8d01a05e5f1b94aa45f5fd902805e77706b9e18a69e2aff84", + "metadata_sha256": "130074cc78fe41696af6e3ac382db6909414cf306e58a1ca2f20f736ae3631e4", + "realization": 1 + }, + { + "arrays_sha256": "f14ea8e2e531078f38e4cd0310649ac341a86bdff46e628579fa009c33ddface", + "metadata_sha256": "ced7ea1db5d010a634445ba353a2c8c0d83d4440b2eaf9788d845ee5981e6733", + "realization": 2 + }, + { + "arrays_sha256": "901192a6c1292a42115bfe8cecd97d758ceedd1726e092ea14d7fe0efb85f687", + "metadata_sha256": "c5601fa4a54ee6e2bf3452b5bf2f7a39e9cc62b110a21e9656ee7da7e0aa87cf", + "realization": 3 + }, + { + "arrays_sha256": "a387137c3e4d104da68a737ae2a2f7b8747e622b906e33ebbec1ebea51f8a0f0", + "metadata_sha256": "b118d7a755451e4bf9887f41070f794d0c523ad2bce2f7200843ccdc1e7a0bb9", + "realization": 4 + }, + { + "arrays_sha256": "9db64d70fc4dad0c093049e7632e1b2ca18358fac654720b1baaaeeb9290866e", + "metadata_sha256": "3ef5a68e4d01921073852b544124c013c72e8532e45edaf6ffab868a5e281ebb", + "realization": 5 + }, + { + "arrays_sha256": "2bbf69f90589c1b67c99278c3d85d93a8fd995acb7dd88a71e222ab99d017a59", + "metadata_sha256": "c5fbc02cabcce4210b17afa2fe837f5cf3418948d1c6374d87a73760c17467e5", + "realization": 6 + }, + { + "arrays_sha256": "c344760288bed8908e74e82042a9c150b4feec91e6d642a409c76e70a2c74673", + "metadata_sha256": "4bf518fd2ce87c114f8dc55552c8b5bd5cfbbb7ebc248771660bdf8b6a3b7f79", + "realization": 7 + }, + { + "arrays_sha256": "d4eae2abbed3766592b66e62b67831d5d5713f65526641ea6725cdf19cee54d9", + "metadata_sha256": "e90c8594d7d19ed36716cf0a951015dd9b506214e4f545ced3083b21e83c11be", + "realization": 8 + }, + { + "arrays_sha256": "3840f6231b5bb1d4559e87a8899c5f1c372721f548122ba79546a97d459da404", + "metadata_sha256": "162272cda5f8e3f20bec80b58b4f7b575008a7f7799907e83145e48772271778", + "realization": 9 + }, + { + "arrays_sha256": "db9500b67eacd19dd91dc7352a904aaaadcb2999aeece49c842b51207e7590dd", + "metadata_sha256": "2109a015da1f3c82a9a285c75af680e6dba134a4784268723d1c4956d6c70c44", + "realization": 10 + }, + { + "arrays_sha256": "84e388e8b3c4777aebc8cdb1e2b637e4dfd1f6b9438468c5564624531102f5c8", + "metadata_sha256": "bf96d414c43d89914979804ec948ac7d86bfee5140eb852a1b89ae38f725b863", + "realization": 11 + }, + { + "arrays_sha256": "f6a1de55f8fce06b1d9fb2d5941a53bbf9013cede0762c38a28185e0a4101927", + "metadata_sha256": "e8380b5c28d7ce6ef37616108933323d4355911a1662130e2727ed216efca8fb", + "realization": 12 + }, + { + "arrays_sha256": "7e69b02a7164da60edb6135b14052675cfc5ae871250abe42516c4d0c9c325c5", + "metadata_sha256": "39b7d65e84b2fe90da4ef7f85f3c1219e7d15fddda65fcaa9f26ed1cb186bd89", + "realization": 13 + }, + { + "arrays_sha256": "ce71cacbb57fc256f60676c621a25e44aef55f8d1276f706b68263b81f4fdf89", + "metadata_sha256": "7579596584a68cf3cebd19d8ab13e38d8fa5b8ee7fe1f4744501594a9476edc1", + "realization": 14 + }, + { + "arrays_sha256": "7a0564da83b5175c39d7606c1867992de8fbc233fccd87f3ee7153fac53d0b54", + "metadata_sha256": "3284b393f094ff6845ad6635520aa4423fab9706236ed86300ea896b1b2b0c2d", + "realization": 15 + }, + { + "arrays_sha256": "c0925d70593ca2aba982a2b502f28bb2821ce76e2331d39bb210eb0858006305", + "metadata_sha256": "264fef7b6ed91fd07cd7041287741fea13305d402914ad70d215e0dac4e1e68a", + "realization": 16 + }, + { + "arrays_sha256": "f738d65d2035e9f2ab348bafb1d08849e83399e5865bb81f0bb18bd8b799e061", + "metadata_sha256": "3a0e3ea91b00bddb80e01fdc8e42f8039065584d9806cdb095deb5cff788f42c", + "realization": 17 + }, + { + "arrays_sha256": "477228d7e602c94d0c666590e7c6b67b5053c47e4d895429b7755ea513995214", + "metadata_sha256": "a6dbc0b82f95e273b069f8f85ccdadfb1d9102534ac97a457d62f0af755c370f", + "realization": 18 + }, + { + "arrays_sha256": "5416fb8ad28ce285c0046f4e39e9ef2bb902311745870bd2b4887c60a9e2fe1c", + "metadata_sha256": "86eeb7f92d7eff3c853a02d4da86f27f9cbd86132dc824ea58eda9767862003a", + "realization": 19 + }, + { + "arrays_sha256": "8dd7f0ac3dcfe6f134e58452b1e6e8aad1adc14037ba8f92d0b769c8eb610568", + "metadata_sha256": "9d45634d3ea411c04ad2920572fb719748f1608e2b9a6c37a8ea21c36ee37b06", + "realization": 20 + }, + { + "arrays_sha256": "a3d80c56b0b1960daba11f1e87ded2929bcff6bdd18d7d81912be00fbd56e75e", + "metadata_sha256": "d681a18788062e4bd7f6d430ab7a750f9fbc7687a387522a5a775d14c0ede5a0", + "realization": 21 + }, + { + "arrays_sha256": "723e39b3b360137ec5c0b9cf6b30f40a726de34525eb58ab782d70b8320ae26e", + "metadata_sha256": "3c8da7b38d197be8db951c1c9143b000dc35d14b1d8098b3247fbaafbf83f874", + "realization": 22 + }, + { + "arrays_sha256": "7c45e3eea49fea1210045653812184b38503cb683eaa7063b3ac2dce2fbb6a90", + "metadata_sha256": "74f6ae9806622c9013dfcf3c1207ff08b14c59bc172c0557479161b82376d11f", + "realization": 23 + } + ], + "panel_kind": "isotropic", + "realization_ids": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23 + ], + "realizations": 24, + "sector": "adjacent" + }, + { + "N": 14, + "collapsed_array_sha256": "8f898088d7160771a2f35f178accb339f6dcd483da951f0c18245aecd45503ff", + "collapsed_interval": [ + 0.11178894327406741, + 0.11182073355743845, + 0.11185243656607288 + ], + "hodge_array_sha256": "faf3d0e655aa86f2bec7967fead956d5c7c9cb3d94b58b30f3ec656bcb4ea2cf", + "hodge_interval": [ + 0.11234396147287215, + 0.11242666326099385, + 0.11251284962232763 + ], + "null_banks": [ + { + "arrays_sha256": "e12d43ec0c572a5bbd84737ad23cd0691bfe128dcffc80d4e2697f74c77abd7b", + "metadata_sha256": "a7419bb915057a318689c6ee489511612872313c66ef53e9d5d1b9ead04283c8", + "realization": 0 + }, + { + "arrays_sha256": "09d68156c14ef198e2a0c7793d1bc6f282bfd24e27d4bed4b25e6b5bb46fe4d0", + "metadata_sha256": "927695dd7a068165919f61716814e6a5f7048868c6a1b76d192d35b5c2b156ca", + "realization": 1 + }, + { + "arrays_sha256": "4c01daa1b253a7833ee97a36bc42d38ef9b00c837946acf4746c3d774934ce71", + "metadata_sha256": "39fe063d9a96b2d8a5268f731386c62e5f87f08da478aeb48f864feebd53bc9e", + "realization": 2 + }, + { + "arrays_sha256": "cd570496a419a40cbde76bc8560d396635b9f4b052363254884c8deb8c70e3fd", + "metadata_sha256": "15c439d79b546c26042a3f3fdd349eeab8d6102a13aef12e0e8291e7fb34fffc", + "realization": 3 + }, + { + "arrays_sha256": "d456866cf9d7267a7d3f1cefbc17602283d732715764910dd8d05f292c129654", + "metadata_sha256": "a423b50c07da833be81689a65c36028cb843731428cd27e37c14af91a7972624", + "realization": 4 + }, + { + "arrays_sha256": "799445f6c7c1bd603c2c7d6da8979f7775aea8ddba11d90a5874bb54aa8becb2", + "metadata_sha256": "b7434a2e86ecde816f61c6ee6d8c256c92f69316716843feaede793c45c33c4e", + "realization": 5 + }, + { + "arrays_sha256": "6a13d97d9050b345d501e9dcb54d2634faee9cd36010f2dbde8038d43cc0d779", + "metadata_sha256": "1913f0d356bdf7e04afd66eaf573cdd02fc0ff0b8e1dee4e3fd9ade38d93630c", + "realization": 6 + }, + { + "arrays_sha256": "7bfddc00dabcffb07fb7f438c7201a0436b49b44f6a3f4e2d3f2d0aaf6a1c5d6", + "metadata_sha256": "f6c0e4c77d3bd958643975bf0e4c9538110843e1906fb9db590fde16d5098a1d", + "realization": 7 + }, + { + "arrays_sha256": "d04cc02bac75cb972376a677f2c61914755768e00ebc8bb551752bb455d48ddb", + "metadata_sha256": "b0e7cc20b8b9357f44a67b456b2a1126de52cb242f52040c4d127f6ac6cd14c0", + "realization": 8 + }, + { + "arrays_sha256": "fd6b92be7611deb5d9505b7cab350f3396eaa4a1c2e7bc43fbaaec3389be4a19", + "metadata_sha256": "59e69b2777bd863ecc294ac0374fe6008fb62512a21204b6e78e0173275cf47a", + "realization": 9 + }, + { + "arrays_sha256": "7eefa6af4d9f2925c21011048e6bee3e568707328acdc55989ea10e6c45bd586", + "metadata_sha256": "4a4630103cc0c5fc683fbee3c98119ea7c1faa9620ecc6e72eeb55f1fa4abd6c", + "realization": 10 + }, + { + "arrays_sha256": "708cc293676f18c7676d7a840ed6f81e53242b73041924ce0e7b8f6cc4597a8c", + "metadata_sha256": "214a320842cd805578bad90bcbcf4f914f2c5ef0ef1038254b0d0dda719d4ab3", + "realization": 11 + }, + { + "arrays_sha256": "a5beb167ed35885803b0c7ae59954982658df121bfa699953a2a65c60559f3d1", + "metadata_sha256": "be47fe4843120d9de4b6624d153969f9e0b3ceb40f4289724c80a955f5826d30", + "realization": 12 + }, + { + "arrays_sha256": "a6b28898e57275f56dd70b58288341f3942655fb83f2af1e0cfd73e00d98f96c", + "metadata_sha256": "d88b2ebd4ebfb4e077bd1781b3f20d737c20e0b57e31f08e77225bf83136852f", + "realization": 13 + }, + { + "arrays_sha256": "f625bf244030507399a606ef45aa1693193000eccaac15710f535e58199d7db7", + "metadata_sha256": "a6de4236d2824f50c8bf66693f8bd8e3bfd57a55a59545d1225dd17b52a873dc", + "realization": 14 + }, + { + "arrays_sha256": "ce995cbb330b8408d3d4163cc9356f890e91152aff92fe3f5431a280ffecae19", + "metadata_sha256": "ed9bf90a0d0ad2e38c873c21eedc89826625cd28ab6978f28b95dd49153a7f0a", + "realization": 15 + }, + { + "arrays_sha256": "e349710d82c111a647b9d8fe2e3cf2adc0adc550fc3c95a50a5fae77b6681ce6", + "metadata_sha256": "84ba500b65db6f2428f5ed1c66da0803506fa5e65cdbb00ff16477aab6e2e7aa", + "realization": 16 + }, + { + "arrays_sha256": "c3486ea5722a0b42ddb7a769b87300d517397f07fb49a41419a642a2118c70fa", + "metadata_sha256": "463850a7885950f564a268901ebc707ade924bb70c05506cfa60b1b7d9dcf2fe", + "realization": 17 + }, + { + "arrays_sha256": "87e3b3d3b00e7a1e482a0015b309dabe5f4100c643ca93fb1dbcf04b1b7d099d", + "metadata_sha256": "595e88b5a0b3b7f604e9e89b273e4e783b02c678e403a6339848d56749be1b67", + "realization": 18 + }, + { + "arrays_sha256": "54cd7550a1e81da702cc72ed99148fea8f543c06133bd1d5b32b4583947ad0b6", + "metadata_sha256": "5c847b4ac8638fadc8b8b732cae7bfb60d1106a241e37a8ae5cb1052aa47a978", + "realization": 19 + }, + { + "arrays_sha256": "12cc1219c90d70cf4f7c48b374c9d6c7d4603ce758e8ba300db3bd386e68fa89", + "metadata_sha256": "a7c152259ac937b666f7303f263d610165aaf49c79c67c7ca0c37fc6d05cdd2b", + "realization": 20 + }, + { + "arrays_sha256": "06ac7ae8cc344ac132568dedf4ba71d6a572f3107c405dcea478c7e859e9391e", + "metadata_sha256": "10b3d8274c34036272a833de12b16b5a31c52085192a41d4a0b8ca1a01540556", + "realization": 21 + }, + { + "arrays_sha256": "70e4c69b38d2a0e2f448c0877f04f8fccda71ae3ac1704030e9ac7e549015906", + "metadata_sha256": "11260b464bc46f3e5e9dca1da97290729251292740f13330fd7b159a59e74db5", + "realization": 22 + }, + { + "arrays_sha256": "5cd762e43609fbe61ed9e0812b0177380f9682c3d6007109bfee2eac73ae3e5f", + "metadata_sha256": "636649ccb62c40031c2de8aa363e8ca839570e3d45f3c04492b4879bc4b4b48e", + "realization": 23 + } + ], + "panel_kind": "sparse", + "realization_ids": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23 + ], + "realizations": 24, + "sector": "adjacent" + }, + { + "N": 14, + "collapsed_array_sha256": "8f47b5e5160502b00c8fba8f5b9a0d3d89fda3c6b1d02d3855f5cc8c861324e8", + "collapsed_interval": [ + 0.11139532733557483, + 0.11139967762724433, + 0.1114044561901041 + ], + "hodge_array_sha256": "9385d513f36de01d046111d4fcf8a8f7721ef903afbbee3f876f7ba8f350f42e", + "hodge_interval": [ + 0.11131508567368009, + 0.1113192335079616, + 0.11132428787594247 + ], + "null_banks": [ + { + "arrays_sha256": "d5dc65acaed447bd3e38bfbdafa08d75e7322d54f0516b2882b183efe79d7184", + "metadata_sha256": "1802721c8a5d028f485bd36f036d5eb4bb0c66d6b1d821c687d9d7f690e19137", + "realization": 0 + }, + { + "arrays_sha256": "e25a4da48c40bd79d69e98f3a53c77d37edca41a89948243f0d83469d356bb09", + "metadata_sha256": "f08fb0b87e45e541376ab9dfdc0a7664ff5fd4be94b0af5046e7eafbfa734f1f", + "realization": 1 + }, + { + "arrays_sha256": "980cdce1ff56ab259acfb3b38557c626e0b1be4490ac91f827bb7e6d830d4d25", + "metadata_sha256": "e206333b2062832b66d2e88486917e81d51354d32cd38c4b4872212a166e739b", + "realization": 2 + }, + { + "arrays_sha256": "d1b3f9f4bd298932cc75312d2d5b187dec4b4c42acd240056f750f713f1204a6", + "metadata_sha256": "c264cff41f6d0ece5d1b746aa3750d3b7819eeccfca53ae5791f7eae6948e8b4", + "realization": 3 + }, + { + "arrays_sha256": "07d67b60cb3756e7d619aa95686cb27eaa2f7da0b23480e2dbad10bae9aa6f92", + "metadata_sha256": "a2a60cbbd5c54c16b43f7b42849d60fbdf3b823f056323982203dfdd21eb51bc", + "realization": 4 + }, + { + "arrays_sha256": "3cfd004498451f7e5674f700ee42d17680240680b1c3ee53f19b2935c6728fd9", + "metadata_sha256": "dac5c8b55278f7e438095e7fa18edc2f2600ce29320bad592d999a330448f7cc", + "realization": 5 + }, + { + "arrays_sha256": "aa96574474c478cec93effea2261956382700af8cacf8bd0fe07688f378182ef", + "metadata_sha256": "760a8ba00b5438db095f0f83ad2adf328cbc1c268305cb86fd3e5b95586dc123", + "realization": 6 + }, + { + "arrays_sha256": "87a29469761037b3a5fae2d49b4bb6ec96f4c5446b4c2304b3656026e5d4ea16", + "metadata_sha256": "d6591246b8084fa70726071ceb8dd07daae8de46edff9da028c8f8186037f460", + "realization": 7 + }, + { + "arrays_sha256": "1e3dc013a4f186df0e32b3ed7f2a24d193ea3dda932e81c82eb8c429b272c636", + "metadata_sha256": "0d00bc75d0a0264cb396e7d1b883da24bbf20c2f1f137d8eec8de86105d89f8b", + "realization": 8 + }, + { + "arrays_sha256": "5f284b8d56a118f6c00b65a64c97dd54db02ba88cb9cd76bc040b35f657975b3", + "metadata_sha256": "39f6fd50aefb98d1c5de2d935c79582a0506418f47c8a12f023ca345222694fa", + "realization": 9 + }, + { + "arrays_sha256": "f3cc0dee0093be8f4197983617efc5527326d780f79e3787e793a301452a5775", + "metadata_sha256": "7bbf9dc8902a0da8f1ad38f68e0cdbc3187511a44494c51e22f335eef01c33ce", + "realization": 10 + }, + { + "arrays_sha256": "528e67ace09ce1f2d3907defdf134a26b1fa7d0a3812ae2af6cb29b385ee7bb7", + "metadata_sha256": "7cd6c1194efbdedabe5206589833f3c74465bec4f4d64bbfdf6b581c0da6bd21", + "realization": 11 + }, + { + "arrays_sha256": "15eae1e19eeb102daf64ff6f3c5bcf3bf2192857e0bd2e1ee948c31ff2ee1496", + "metadata_sha256": "9931f27896364b237d61637bd3b2a5e41002f9167c575fd660a52d0556bb908d", + "realization": 12 + }, + { + "arrays_sha256": "c125d08dfb24c1f6e827c8692a327d6360474d6d295da99e28f118faa37fdd49", + "metadata_sha256": "200b765283905d1dde7dd0b64add45f22e118781f3f3a9f6a8c5899119feef75", + "realization": 13 + }, + { + "arrays_sha256": "58b53bdffef7dc7821711be034d242138d8f1d7acbdd958beed0cd7c57975da8", + "metadata_sha256": "5312ec77198867679e544a10c681bc6dfa8dda333cee2c3142c7f99de93827d4", + "realization": 14 + }, + { + "arrays_sha256": "24c1ec5c00a330863416eb3141a9ac9841857bdbb2532255e7502c9bc1968414", + "metadata_sha256": "02b450172883b2ae09210f5e5973d2f5e50674de1a95759fb78db7ef30edb15e", + "realization": 15 + }, + { + "arrays_sha256": "cd91e4dc2ed59fdf6a2b445a9f404d68164f07b5c173a3fd6cf2a906c009437b", + "metadata_sha256": "51d081222f49a32248b5e3e74bc76bb96270c7f4c5d0437858096c0559cbd66a", + "realization": 16 + }, + { + "arrays_sha256": "fe41e9e3b4b201925efcf17e640a3a97021a74f0271265b8211476c321fbb2a6", + "metadata_sha256": "b6577f1af367b3d48ec3508c0e6922810610d17614d1f95ff7a600a228f6e35b", + "realization": 17 + }, + { + "arrays_sha256": "4ff1544afa0c266075fdb7239d56464cfc2a8056d746bfd18dc903edb5d07eaa", + "metadata_sha256": "226c132e3b617843217e51fb2330c7760c73ead01d81ad1b62c2dec76b43fe2d", + "realization": 18 + }, + { + "arrays_sha256": "e86f5f8d1930ae31c29cfa191dc378cc8dd2417bf9b902038e26be95b935768d", + "metadata_sha256": "668172f466edf0ac6e1dd5034e6898d12e94857624d7112dced2ce6957ff2386", + "realization": 19 + }, + { + "arrays_sha256": "5d32895607748e7d8bec3ff7906edccf40174671e69437c97fc39f4b60d6bcb0", + "metadata_sha256": "81cba816e59cb27bce7a42eee278b6f3911db9a5659b8f5e2f84a5ef32578ea2", + "realization": 20 + }, + { + "arrays_sha256": "659ccd4a7edc82be6bbc225993ae1e565ea31879fc725de0be1695fd742d46b6", + "metadata_sha256": "83d62680031f4e9d24fea302ccc1ab99561a984d0877036f01760f3d1256449a", + "realization": 21 + }, + { + "arrays_sha256": "dbdab952de56fce395b0589b3048244268af0893647611009faf1900db53ed13", + "metadata_sha256": "f1bd4fd550d18ce2c28d3d1d6b78717140bdda2f30af9d896fb878d1e00f433a", + "realization": 22 + }, + { + "arrays_sha256": "1d8428347833830b7816d67d47ebb653dadc684a710c8d9f80ad191870b27768", + "metadata_sha256": "3f2326c5ccc54f5f29550a65842c8064805893f07f3e8a2934afad8ca3fd6320", + "realization": 23 + } + ], + "panel_kind": "isotropic", + "realization_ids": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23 + ], + "realizations": 24, + "sector": "central" + }, + { + "N": 14, + "collapsed_array_sha256": "94fb3b445bc40023debd2313f35cdd13452b1366e360f03ad026629dfa8fa1ff", + "collapsed_interval": [ + 0.1113377289462959, + 0.11134480106449174, + 0.11135301768590472 + ], + "hodge_array_sha256": "497ca9f0fee50b42a7c71db7b4bb2b4d75bff1c43f2fc8eea47bace61ae82fd1", + "hodge_interval": [ + 0.11133252105193724, + 0.11133957071189352, + 0.11134819894894332 + ], + "null_banks": [ + { + "arrays_sha256": "3bf9fcc707afbae11c1baa63ff590f4eac70db17f8c3b79cac5619730322aa2a", + "metadata_sha256": "118866da7ac4fc927f86293629a9cfbbac0a298524b8eff90bac1ee3ebb9697f", + "realization": 0 + }, + { + "arrays_sha256": "ec4c4c0f92945b00403ec3912938171936ff8809aee9487744392db4d53833e7", + "metadata_sha256": "b347819d7b4a30cf8d7d76c9d77880966dddc1bf6dbf09db26fd4548e311e212", + "realization": 1 + }, + { + "arrays_sha256": "6de6f49041b8370c0f8ca8d430402fdada03c99b582d825081d3c0e5a00a3cbd", + "metadata_sha256": "ef22496f38ce87e81779ab481d4c77ef740be23d8a7edd5e0c2e9dd261a50199", + "realization": 2 + }, + { + "arrays_sha256": "8ab393a6690604e4467a8f5519244b4d7afcb246491a72b0d98cd0551890fdac", + "metadata_sha256": "6e2738d34bad8274d5018b9021149de8a81ada9ce149e263109db31471cfa36e", + "realization": 3 + }, + { + "arrays_sha256": "d55c58ecc4d0661a8afd067fbc34ec14080f0522ef88314e970533577a1f2976", + "metadata_sha256": "1697fb6bf3e1cfb49d40633455af36a189103d13d881db27dc2fa0ca9ec4a99c", + "realization": 4 + }, + { + "arrays_sha256": "3e2978041b011341af94f5eb0d282d118c940edc64e931fd90a3d2d0b30f3338", + "metadata_sha256": "1d7cd150c99bfc7a116cab122d183dc8c0cc09cdabcb18fe37c53bfdb73c1eb6", + "realization": 5 + }, + { + "arrays_sha256": "b615d92d4a40c3ed2f990523ad2999b85be62c3a9382fc2e408b3140abd454d1", + "metadata_sha256": "1ae5c73e48ae98d470cd162640aca54f102961ead35c0e8f721d376e4c3c7206", + "realization": 6 + }, + { + "arrays_sha256": "45fe6a089656996d30e3c394795360d96f9b1c50ef2470af789613571488f5b7", + "metadata_sha256": "e390c7016da84c79304f7021e70e1bf3e42950c41e9d593decaa84a37f156e50", + "realization": 7 + }, + { + "arrays_sha256": "7e05678b8064ac0ecdadc4fad34029037fb32f8610aaef06813f0bd3cad49b0e", + "metadata_sha256": "733f395b46023e8cda0d2701aada788ffaf68295fee830f0f08d9128bb7b17f9", + "realization": 8 + }, + { + "arrays_sha256": "a4016000970afef0e982a5f8cf5b08a40f8ccbecbd42349f9339a0582617ea7f", + "metadata_sha256": "109467e0712bd12db0067886f756dc882971f2034136654fe1fa1a9306aec8b1", + "realization": 9 + }, + { + "arrays_sha256": "05fe82dcaad79c8bd605860041d9b49b7717c93cbc1f8b90a9af6b3f27328dbe", + "metadata_sha256": "b7000fbb67f6d4ad14f74084aefb59cc7a42ea07a53e3de5dfb63eaf5df83ac9", + "realization": 10 + }, + { + "arrays_sha256": "becad1516fbbcb7ff46bd2c3d5ded05333f88d57f641cce58aebec3db88db5d7", + "metadata_sha256": "684e45fe363e82d63031c5290fd41e8872cd31531e242c3a0f810359f3e39cae", + "realization": 11 + }, + { + "arrays_sha256": "b8dbf11e30077a20f030986e2a836e92e4910b441c1cb75802ca68ca2e2c586d", + "metadata_sha256": "cd194cc0a7e9ff309afae94def0caab32b13ba09d9a383f08b5037167b93ddc0", + "realization": 12 + }, + { + "arrays_sha256": "4038b268ed5933addb248c06261e088c94a6b461d1c8cd47bcfaa3307d99471a", + "metadata_sha256": "50e9532aa1d608efe23b4c5b3bf33732bfaee57f54e6297e43874440eb823dca", + "realization": 13 + }, + { + "arrays_sha256": "28c1ce2c4ce0a16a0a6b9bc8dad93949fc8cdbb258e28c3b6fbfc61027a28c9a", + "metadata_sha256": "db95fb775ff30587f69fe0f25d38827cc0f0f749f3233c63863fd5454f083789", + "realization": 14 + }, + { + "arrays_sha256": "fbd6f6e31d17fe473ca07f45c175d83da2ee8334f79685d5f10d88177d43554c", + "metadata_sha256": "58ce628b6c821daa3f10cc74a68e3f25827b580f1dbdd07f092c3c567b6956e5", + "realization": 15 + }, + { + "arrays_sha256": "5a27f448ec711a8ac8abb2b334c1a6c1d65475cb5efeab22c672aa76571de0b9", + "metadata_sha256": "7df952b0f40ad3552350ceda0c2bc8d92a92c76a8296450c29f7456eeb8b2903", + "realization": 16 + }, + { + "arrays_sha256": "c406b6b897a84d18b6fe92dd889c01d43cddea7718502280fbba5fcc2cb5bccb", + "metadata_sha256": "9b574c67d9e44220f2b2c9e4c720569336d302fe0bb9b5dae00aa85a4cc00996", + "realization": 17 + }, + { + "arrays_sha256": "9522f4b5cfb5bdd68fb809f98f80fd384eaddcc8ba1a1b365d4defb62cb86c3b", + "metadata_sha256": "fa79bc441c2d14bae988fe686803bdd6f4dd705cad31f701d4d13aeb4f8516df", + "realization": 18 + }, + { + "arrays_sha256": "804ab0f403cb6e9b618bd30fa6787f9b3a003b43608e72d4aa653c86496dbb90", + "metadata_sha256": "dc274ff3cd033336c229be515ebf2a2b5479b8685a805c3949b02f6fd404d1c5", + "realization": 19 + }, + { + "arrays_sha256": "e5046af18f2d7292f3f31e997f592662a6e998045bab8faf5cda19336d513574", + "metadata_sha256": "ef5e0d36f5b2b7eafe8d6f06795ee0dbba77a09578c84f3712a62eee22976b6f", + "realization": 20 + }, + { + "arrays_sha256": "36e6f9d034084f346f9f6539e79d0d6c74a632ff101fc51b25c52265634d9c98", + "metadata_sha256": "de3dcfe5d0b77e78fbfd2500e34fb3044101eba00e1dfd08908d61901e05c923", + "realization": 21 + }, + { + "arrays_sha256": "2f52ac944143600d09ce6ee9e0f968535ef358d2f9f402ccb2ee2026acb049e7", + "metadata_sha256": "9afc313620a3ce72da9483ff3e4c483ec4ce0422accffd4cf1c8d64cb8b80ce3", + "realization": 22 + }, + { + "arrays_sha256": "19f976c3bce2403161ec58e209908e8739680d84106df41e1f4dc8580a57f8e3", + "metadata_sha256": "9e529c57872883412871abc1fc96bce1975278ea96508ae4ca3f1a58612a5873", + "realization": 23 + } + ], + "panel_kind": "sparse", + "realization_ids": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23 + ], + "realizations": 24, + "sector": "central" + } + ], + "null_replicates": 2000, + "observable": "normalized_response_memory", + "passed": true, + "prediction_arrays_file": "susy_hodge_v7_N14_prediction.npz", + "prediction_arrays_sha256": "f8b2dde1c8563c39caa2b800b7c4e2595c8f1c3365a3d851b06e252279dbd903", + "prediction_coverage": 0.975, + "prediction_quantiles": [ + 0.0125, + 0.5, + 0.9875 + ], + "primary_pair": [ + { + "N": 14, + "collapsed_interval": [ + 0.11178894327406741, + 0.11182073355743845, + 0.11185243656607288 + ], + "hodge_interval": [ + 0.11234396147287215, + 0.11242666326099385, + 0.11251284962232763 + ], + "panel_kind": "sparse", + "realizations": 24, + "sector": "adjacent" + }, + { + "N": 14, + "collapsed_interval": [ + 0.1113377289462959, + 0.11134480106449174, + 0.11135301768590472 + ], + "hodge_interval": [ + 0.11133252105193724, + 0.11133957071189352, + 0.11134819894894332 + ], + "panel_kind": "sparse", + "realizations": 24, + "sector": "central" + } + ], + "safe_covariates_sha256": "dbf51fe8d19864fb499ae9a83b2683fbecf3aed1209ae9fbb787ede0c212a7bb", + "sources": { + "analyze_susy_hodge_geometric_eth_v7.py": "ddaf04888905bdaca031c1e4a6119fa1cfbf4b126fd115ba775ae6c0a6a9338b", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "781b1e40594405697bdff010bb2a433496fd2cd1c6400acd288103a86a6abe0a", + "run_susy_hodge_null_bank_v7.py": "ce16015e03e721852c73be952f24990b02e45cf787545881b96f42c1271dbc98" + }, + "system_size": 14, + "uncertainty_unit": "complete_disorder_realization", + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_prediction.npz b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_prediction.npz new file mode 100644 index 000000000..ef41b96f3 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_prediction.npz differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_prediction.sha256 b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_prediction.sha256 new file mode 100644 index 000000000..0ee04cf7c --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_prediction.sha256 @@ -0,0 +1 @@ +fc300dc7e4bdc1be157919e458ac868d3468533cce31108f23c9fba4f7e9f102 susy_hodge_v7_N14_prediction.json diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_unsealed.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_unsealed.json new file mode 100644 index 000000000..5010436c2 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_unsealed.json @@ -0,0 +1,973 @@ +{ + "arrays_sha256": "b4e6be65cf594525a7a6bfe62f5fb2d3b1f940ebc7d9500acef354273c9c05b6", + "checks": { + "complete_requested_grid": true, + "finite_outcomes": true + }, + "passed": true, + "prediction_sha256": "fc300dc7e4bdc1be157919e458ac868d3468533cce31108f23c9fba4f7e9f102", + "records": [ + { + "N": 14, + "R4": 0.35738087103395144, + "panel_kind": "sparse", + "realization": 0, + "safe_arrays_sha256": "ccc702aa83f8021eb3aa2f67dc3949798abcb5a44efacf3dae527c696861fa90", + "safe_identity_hash": "44f17703002e5d8496af042ae29f3602f4c4998705aa400167d7ef572d12e12f", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17784779903500372, + "panel_kind": "isotropic", + "realization": 0, + "safe_arrays_sha256": "19a0e93f9bb71ac87be3e6be0fffbeaf3f76ccfee8081d0dd7d0dd71710883ee", + "safe_identity_hash": "0d4791237862afc32e310c96a07fcfeeeeb7c2f8679f5e52f43725cae516c654", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.36156114676424866, + "panel_kind": "sparse", + "realization": 1, + "safe_arrays_sha256": "feba2e32a13c40c9cb74870eea11ec959326795370df60e6313affbc7a8649d4", + "safe_identity_hash": "914baba0c350a9536fd535e9c676f79c1779d0e3f39dd7b0dac175fb714c2c7b", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17264436610862055, + "panel_kind": "isotropic", + "realization": 1, + "safe_arrays_sha256": "b1d6da391eae4575bfc3a5905469115b65d18151b77c85f30e2b8d849a5618c2", + "safe_identity_hash": "74f9a8d2563f8fa41a7ecf2fdc43fadad205567b3782a48a136136b6cdee95c6", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3870282436850503, + "panel_kind": "sparse", + "realization": 2, + "safe_arrays_sha256": "dbd19fb49be1a0bf936701c66282ce2d47e49492034640a51486ce530a2b157c", + "safe_identity_hash": "5e32ddbe4b9b52b35a198165c3a028da71a9d2b5b0bd906c16b55a020b611f09", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17962495188847405, + "panel_kind": "isotropic", + "realization": 2, + "safe_arrays_sha256": "aed0e71bed049cc5b90b39396759899eb9583b13f26ae5a92c67b863fde42dc7", + "safe_identity_hash": "ce6021aa7355d4b79ff7daef94ac1f6887e341672454b0780ba5456d27abaaa7", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.35335360962176876, + "panel_kind": "sparse", + "realization": 3, + "safe_arrays_sha256": "aef463ec47c52d828afca3104b76e5c7f0a6064eb2dfe6c04fe6da7efad3c36c", + "safe_identity_hash": "2fc8acde41f905e05791e66403e3cf3cd07404f23cb44318c51089d7b9f5fb83", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17682737630018416, + "panel_kind": "isotropic", + "realization": 3, + "safe_arrays_sha256": "1d86d31d8ddad6ccacb79aad1403866ab8cd2508aced6a8b97061a538ee2dc60", + "safe_identity_hash": "7da6c3230714f0b4c4b0be849717242f14acddb52f068d67916a996886ae24a7", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3733305321446736, + "panel_kind": "sparse", + "realization": 4, + "safe_arrays_sha256": "574efe54da3efc84c12d6d619fb6856a96a62dae488e1b1e62cf793a8b90e88a", + "safe_identity_hash": "dca1a9dffd70a04f941d436794a7f87f6ef19b5fc1b21e624d92bb15ddf826d3", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17299753135963708, + "panel_kind": "isotropic", + "realization": 4, + "safe_arrays_sha256": "6925da0cf9a8843510093d3ddc61514c102584a61860e089dfb3a7326794a851", + "safe_identity_hash": "2d6699c85ed7a82c3b5874c359675b2f0448ceefe13b39ca5eb3111f4d4ebba7", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3054741153801766, + "panel_kind": "sparse", + "realization": 5, + "safe_arrays_sha256": "3964e81032c90ed2d4fde3cdb92ece1fc5f1a406d1a7177409230d746cf9100f", + "safe_identity_hash": "1f80e37a3f63496451d5b8cbd8d89de55b4ac56f3af9e29071fdd19335997380", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17202793561968174, + "panel_kind": "isotropic", + "realization": 5, + "safe_arrays_sha256": "09d13a31871ae32438d7ba976a0441f8c232e632470020fdccbfe0c4ac99e4d1", + "safe_identity_hash": "7c06fb69236dd498650adc8428e6f74adc1bcfd28dbdc8de66b808e93a1d4d75", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.39378886094784715, + "panel_kind": "sparse", + "realization": 6, + "safe_arrays_sha256": "771b4cf6f513e2e6cabe67632fd2f8c5f70174b7dbc765f49741be93c363f821", + "safe_identity_hash": "88450f458ab81c9b7c34da073b0ab606c9463406a381c05b02690bfb921b9bcd", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17365048254574816, + "panel_kind": "isotropic", + "realization": 6, + "safe_arrays_sha256": "e7b5bee29e261c5ae67bc349d9c523c472d0d42a5b19d7c86ba8f7da3eb77d08", + "safe_identity_hash": "da060556f2c028fec37b4320ceeb6a021532044855e3157d95e4e2807e7d34dc", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3829784311641927, + "panel_kind": "sparse", + "realization": 7, + "safe_arrays_sha256": "799c8449464256036f74c24b9b2765881874ecf7a476dadf3347c1fec534b0c3", + "safe_identity_hash": "b880feacc95eb699002cca3f738209a095bca28f3b0bc99fd929cb5d64e05e3b", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17484069799632418, + "panel_kind": "isotropic", + "realization": 7, + "safe_arrays_sha256": "94db06daaa50b508200f064755f007b4210b8609570a3a74f462dba5b45278e1", + "safe_identity_hash": "4dce16ae33abb350f1e501d746a3a539e6de24eb260572f51d6b8645370fff96", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3682406571219608, + "panel_kind": "sparse", + "realization": 8, + "safe_arrays_sha256": "b5f06e639d41c803952d6614128f8cc2d5b12206110ecbe1376743c9eb506570", + "safe_identity_hash": "36dd27e02b35a9fad7c1a3e1c128264e88635c619a4dd9869bd06ee31d15b42c", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17557097557649112, + "panel_kind": "isotropic", + "realization": 8, + "safe_arrays_sha256": "d28ac8231ea6959e71b0417958e3070a1b25cf4e381ce1840674d933c211f7f3", + "safe_identity_hash": "fff54dad82bb0f4df72ebffa1d5b236528850dc5aca79c13e92199937d3657bc", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3749339514508324, + "panel_kind": "sparse", + "realization": 9, + "safe_arrays_sha256": "c06b8a00e487cffc4da1d1bc69ea74932a63d0b1ff0601bdc1c191d1e9ff527a", + "safe_identity_hash": "38d3a582d5336b9f45e20df40a37e12ee1e37e9dc570a3ce1a6b1c847cfcc873", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17565647148553196, + "panel_kind": "isotropic", + "realization": 9, + "safe_arrays_sha256": "4ced6e8f3de30f6642379b8c0ac9b89ab9110243c9691728e359fb3e97a857de", + "safe_identity_hash": "26ad28d2e0213f9817b4ee9e0c91f1cb972db23aefec6a7c9db8458583ac979b", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3755985900897959, + "panel_kind": "sparse", + "realization": 10, + "safe_arrays_sha256": "83179c942410992dc9babd2e4918a755166f6e383612012f6a77b6269ca14cdb", + "safe_identity_hash": "c3b7a6f2cf411b58bdd851befe54253d0522dc5e8934e872836197923840d01f", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17322059785557328, + "panel_kind": "isotropic", + "realization": 10, + "safe_arrays_sha256": "3bec147afdce729899c6d61351ea493f284e77ac6b05b85ce93bba10c0d2f443", + "safe_identity_hash": "e864c5e25743a171096f7084b4e08a01f210177dd04881f025ff3290dfa310e6", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.37505119177448815, + "panel_kind": "sparse", + "realization": 11, + "safe_arrays_sha256": "7e544be73528c578b85b20559d3ddc60aaf948c4169f5547b2aa1acc3fb49ddf", + "safe_identity_hash": "9a44375078698edff90fb0325d86edabe740419287b1ac1bc46a21099688799f", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17361341459735252, + "panel_kind": "isotropic", + "realization": 11, + "safe_arrays_sha256": "095ede8d23cbae8515b113e5b095b198216ea083eab77f119718ad2df701020a", + "safe_identity_hash": "d3aa276ea9dc7fd630543ea2f63c9e60b942ffb267bb9762748e337e48a698b2", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.35560571487423864, + "panel_kind": "sparse", + "realization": 12, + "safe_arrays_sha256": "0dd3434b12a2cdfddb673c435ee62f550351c03a143c08b9ccae907809a8936f", + "safe_identity_hash": "3a60b9a64a8c35cdad445bb78206481946cec88d7ba63cf517689b1d8fb3631d", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.1728496666289138, + "panel_kind": "isotropic", + "realization": 12, + "safe_arrays_sha256": "d039a3d01eeb9628fdbf8dba1d5f1d0afdcb0597ae0988b596316152da1becd6", + "safe_identity_hash": "b2955973a9c0b568c60d3098d2d2f187e42aed278a82ca339cd4257abcf3ca5b", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.39262767708164387, + "panel_kind": "sparse", + "realization": 13, + "safe_arrays_sha256": "16bae4343be0cb4d87ad5d23754745fa62def1eded2eb40336ea75248b9e73a8", + "safe_identity_hash": "6fbb467efa51ffc94611e185b502b805a074c615b14556e09fb4cc5b6fba0dc6", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17393288077805835, + "panel_kind": "isotropic", + "realization": 13, + "safe_arrays_sha256": "5607813687d360997450efb8e6f9c3e5c2af745af8f82c3fd7ee945c9a274859", + "safe_identity_hash": "8c53b56a65e6afbb3f6a79b280dff23ba76fd29cfc4362704c0ed5fb5f8f0b48", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.38292520124145757, + "panel_kind": "sparse", + "realization": 14, + "safe_arrays_sha256": "a05a3b11670077c04baf8e73bb7193051cd852a297dc3f8a9125cc7b74849f71", + "safe_identity_hash": "3413d476a0cabfcc3c3b95882c0a5b10014994cfe2e2788473f96ad522117967", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.1772420131813431, + "panel_kind": "isotropic", + "realization": 14, + "safe_arrays_sha256": "e2b109acfa1fabfedaa8563e43d6b182f9f7e53ee49aa5ba534eab8eefed09b4", + "safe_identity_hash": "fcebe564f4e8c7acb81d4b7f8364206824bcdc35928f16c36d8d1a96ba61f803", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.38047305142967947, + "panel_kind": "sparse", + "realization": 15, + "safe_arrays_sha256": "a54c3f7e9bd5317d372925f40a2b4d4926b121fd557a0727aac7fb8e2532a43e", + "safe_identity_hash": "bfdf67cdc972f9a2db7c95e40b2903c1233eac6405c58ef8958732a671d52a74", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17321653150494515, + "panel_kind": "isotropic", + "realization": 15, + "safe_arrays_sha256": "265da19e69d3f44b36b0465c3e3b5a3d464dc3d51801a4162ad6abfe8424c776", + "safe_identity_hash": "557a356533f223d143ba112c30bea569dfdddb248cea3b6a4d382a1a6bc2bac8", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3508410161962601, + "panel_kind": "sparse", + "realization": 16, + "safe_arrays_sha256": "daf0d346aef0e6ec7f3bca4aeb781e86b1741aea6b80da8b69b3a086ebd08040", + "safe_identity_hash": "b5e07ed713a2dae09b9206fd2df04bea90194c5469ebae36bd62c082fc086e4b", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17299275662283617, + "panel_kind": "isotropic", + "realization": 16, + "safe_arrays_sha256": "b9de388f6cdf881025f184d7487cb90ba839c42fe7785320e14235e2e11ad2ef", + "safe_identity_hash": "c56b992771ab76f030b3bf31c68953fd195ad7051423ebec7c34d877a6318281", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3689804933327322, + "panel_kind": "sparse", + "realization": 17, + "safe_arrays_sha256": "82edf8ccd3ebd61ac80d818e9b61e10db9613f81e60ae0eb52ae34cfb8a22523", + "safe_identity_hash": "cbf8b3416071dabecdb0b8b36ca5ffed52d2ee8371a5de5f61ec7e30ff03ee35", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17772425219044896, + "panel_kind": "isotropic", + "realization": 17, + "safe_arrays_sha256": "f14dd2dc8f17d531fe2e385043d63c8c38dd9397a556e08e3bfd5287d2f4e570", + "safe_identity_hash": "48541a79d370895d4afa8f0fb6eb7e9c55583df9467f34f95c8539e08d6d0e69", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.38157147210305253, + "panel_kind": "sparse", + "realization": 18, + "safe_arrays_sha256": "9c052e3fa9d7a42a0b779fa31a37084afe2b9385b5fcdbab1150f20716a638e3", + "safe_identity_hash": "8e9b301ab9620784f9a2c920d578e9c5befdacaa25c1d2adedf1a7f9527cc11a", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.174837029906894, + "panel_kind": "isotropic", + "realization": 18, + "safe_arrays_sha256": "24b479ee88ae6094e7aecaa72b8d24ccb828871a9716a1c14edfc304f74febb4", + "safe_identity_hash": "c19e3beac0b79bedbbb3f99578076a32bed7adc42bcd5a9ed9a40117a3da3a20", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3767635710505377, + "panel_kind": "sparse", + "realization": 19, + "safe_arrays_sha256": "431ff0499fb50eb9bf13cc21a6f47b1e2ba2a4a83143971bd1d6b30d9881ea29", + "safe_identity_hash": "52240d364e706821e0e65f0547da607e04d9fbb2f95c0e744ad81bfe8e565d30", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17352036640016832, + "panel_kind": "isotropic", + "realization": 19, + "safe_arrays_sha256": "93bb2eb7035a2efff9ef0f9176e5c53f76b5d03a795df702df9586dff828de95", + "safe_identity_hash": "6da86d401f6d472eae3cf2b0ab0477715082288256568560af2f4c43e507efdc", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3703837719348199, + "panel_kind": "sparse", + "realization": 20, + "safe_arrays_sha256": "2235f7438088a226e52a6bd88eda29bc1b38ce01514b885ef5e4169512a9e810", + "safe_identity_hash": "7068a89386e2feba5c88d977fbc07a41a2f1d85f5be3f072ed048ee7bcb1e1b3", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.1773061493829299, + "panel_kind": "isotropic", + "realization": 20, + "safe_arrays_sha256": "e265b8f79f897f206a5e3a497f5a6e35f52169b240a19e4a99d9e7c557399afe", + "safe_identity_hash": "b10de13986c72d8d70ae7f1cb6ebf2716a03e5e4fc1da47a80033942e2c39d82", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3790791465470712, + "panel_kind": "sparse", + "realization": 21, + "safe_arrays_sha256": "9a93c2255885fbce993ca78639133e65a9053b7403c8d6c317d593119434d815", + "safe_identity_hash": "d7316df9a49721b9df80e7bf9f160cb6163977912b89d6bfa4af0ae58aa5e901", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17389091844276466, + "panel_kind": "isotropic", + "realization": 21, + "safe_arrays_sha256": "412a43aa50155fafc1df631a2c22aecc40731ca19b9aa6e147e4c4cf90c01904", + "safe_identity_hash": "1ae86087f09e3f997b662b72fb25a7bc18d316d98e690f5a7f029ca096c97b61", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.37098275110500467, + "panel_kind": "sparse", + "realization": 22, + "safe_arrays_sha256": "5634dc72c342377a59fa8306527b02bd45c87530e08a079c5ae4e152728cecf9", + "safe_identity_hash": "2c3990ad5ae0bd9aa51700dac3c33d9d5262e5d38793161615d66fcef819db8d", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.17508357627544904, + "panel_kind": "isotropic", + "realization": 22, + "safe_arrays_sha256": "4359c53367c93a61d31135387b4b3dafa269c1d32f387c6fd3976c31d2d68790", + "safe_identity_hash": "5c5f8a113b1a6a8a0a5eae90ec3bfd3353e5a5e8ec1b4dcda9615bf327433da6", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3908256350115379, + "panel_kind": "sparse", + "realization": 23, + "safe_arrays_sha256": "30343d38ada3cf85b92a28ddd27caf11f11fb9a10f77c6c8d9a5c35c87e1aeb7", + "safe_identity_hash": "2831e5bca71067320fff0d610c9d6db80ea27035c9e434dbb2f575112e02c28e", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.1758571701165521, + "panel_kind": "isotropic", + "realization": 23, + "safe_arrays_sha256": "9ffcb2ffeb5fdb343b2aa1e11a2a44d1a70b4f156ab47f461995d47292aaf4e8", + "safe_identity_hash": "9ee2222252809ab3c2fd0ea54358bb75aa92c12dcf92e110079258e36459bb3d", + "sector": "central", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3093983768322815, + "panel_kind": "sparse", + "realization": 0, + "safe_arrays_sha256": "6fae6f46bc5e3dec9455a6d7517fe35c1f4d23fc90a0d3f2e2c7d5a5a3e3ff19", + "safe_identity_hash": "2beff8669c29f2697c9cb68894f593581fec373ea0ebe0e3c330a46f18fed468", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12560895160204338, + "panel_kind": "isotropic", + "realization": 0, + "safe_arrays_sha256": "d71471c76bb163238938ba6b5faf19440a7a402a713a59ff7878da0bc9dbb7c3", + "safe_identity_hash": "2d89a5dcbb5bc7a85e6e2fbb9948482bd32cec24296d8f318e170515a8a67822", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3036963440366127, + "panel_kind": "sparse", + "realization": 1, + "safe_arrays_sha256": "325730f24aa56c32929c27fee3fc2f38d87696805c11933840057f3cac4ae95f", + "safe_identity_hash": "3c462c55fa9d30e08df0d03da1ea90b11a4c9cc69a169bf06a359bf1663ed4d6", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.1281428056843278, + "panel_kind": "isotropic", + "realization": 1, + "safe_arrays_sha256": "79ae7338595544da0699d5a56f96ce43d106f5fa262961f4dabf615e7c340284", + "safe_identity_hash": "aa6fd7c5cfeef794bca8776c8277fbdd67c87bcbc09b01120b5400b830168246", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3120611443736316, + "panel_kind": "sparse", + "realization": 2, + "safe_arrays_sha256": "d6e006d63e56e7bedd5c3fa5d4b9df431cc66fa47599f962e68756e8b7db367c", + "safe_identity_hash": "e337bc257a477640eec1d52544f23d5710acbd9e45965ed5d46d9c9f6dc100ac", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12635744038991573, + "panel_kind": "isotropic", + "realization": 2, + "safe_arrays_sha256": "e3d00d849297062b9d7f5ea37a68379be1f20a5e5fe1ee0cdc02646b147d2f22", + "safe_identity_hash": "f12792543f158476bef95769f73050ebfd4fffd45535f5556603bf750b7d56bd", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.2915274750468075, + "panel_kind": "sparse", + "realization": 3, + "safe_arrays_sha256": "607c04a3c87fe709848b7310c877bce3d150e8aea4ce6290c5fd3bed6b21e8e0", + "safe_identity_hash": "2f051bc1a67fd43d7532054276199147fa13651233734b6a5077e995ce58ed4c", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12874957859834524, + "panel_kind": "isotropic", + "realization": 3, + "safe_arrays_sha256": "a5ae04f9b354f94c4086320e216801d6b3864ff4964cbdc153d4310fbadaff24", + "safe_identity_hash": "aacf15e112900c7f1524cf27b998d9aa40f2b693122e5ce8a97e5e03d4cdaec7", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.31714774586224, + "panel_kind": "sparse", + "realization": 4, + "safe_arrays_sha256": "34501f71d63cb90035b11d45b8b833a16e104e4148dbbac3ede45ff004ab6f1e", + "safe_identity_hash": "5b07d375e30d6eb605a4b14bcc7c1a10a13fa440d0022b5f8e6c89b8b5e3e9cf", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12499854542884234, + "panel_kind": "isotropic", + "realization": 4, + "safe_arrays_sha256": "0b6c2ac6da00238376bb9f11637b3b634e111af945d98815243003f9a728e231", + "safe_identity_hash": "54ce746836b7dccba24fd6a2e2e84d2be1817fa0af47440de0582d24cd1189d0", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3131837409695154, + "panel_kind": "sparse", + "realization": 5, + "safe_arrays_sha256": "c890c1d5bf871e5f1c09c4bc6589167a0c1863758d88d608fd997b84fe2f2f33", + "safe_identity_hash": "e941f22f39c99aa8ee9bfb0a408ac6d57837ebb4ac984b796b1c39acaaed9db0", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12783158924560867, + "panel_kind": "isotropic", + "realization": 5, + "safe_arrays_sha256": "0e7e4554293776fa22d914699925fa271697dd0dcce5a695df2325d21fa80847", + "safe_identity_hash": "4575251dff194dd3e23dd35eb4666819ca7257781dc84dc4d83bdd3952d45b8e", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.2830795039685373, + "panel_kind": "sparse", + "realization": 6, + "safe_arrays_sha256": "5e6f906e05ff39f09a187d1bbf6589c279d484dd6d3956fbf908ccd1045aa8fd", + "safe_identity_hash": "da7259da2a77705e3f6e8bba5072b9b6ae4fa2cc7666be0fe1b4b04b42820613", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12799475920263093, + "panel_kind": "isotropic", + "realization": 6, + "safe_arrays_sha256": "7fe89f0afd57163def66dbc90d01a41eb1d44c4cac3630dfeb11f47bc2507a34", + "safe_identity_hash": "df2b48fd815b22cbf84dc1043e26b50dd0afa4d4b0ef021108473f52bcb90a56", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.29880270063952924, + "panel_kind": "sparse", + "realization": 7, + "safe_arrays_sha256": "af881008fda724be35af01f253f043a2486f3e6d44135c0f012ac97c28be91a8", + "safe_identity_hash": "e19eefced5a1b06fc9da78d048d25ae67814e25276faa84aa080fab0f824541f", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12722955479537765, + "panel_kind": "isotropic", + "realization": 7, + "safe_arrays_sha256": "cc5909f562cdef4fb36200948803d6b7e4e9d31838f4bae7fb337dec02829410", + "safe_identity_hash": "7e32cea818ad9c5e29886e8a251143969a8c39e73f760569054b40d5404bd397", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.32416692946677433, + "panel_kind": "sparse", + "realization": 8, + "safe_arrays_sha256": "62936b121a82c939eb1101ddde4f5801e546a5681b5a12eb278b6a6801cd02c1", + "safe_identity_hash": "3c090da39c2eeace2503c7b02ef114986285a8fae44513f449eadd9256123a72", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12797032243588755, + "panel_kind": "isotropic", + "realization": 8, + "safe_arrays_sha256": "3893880f9170173b53e9451a95ef36aa097285f9842b08330dde1d9f760b06f2", + "safe_identity_hash": "a621a6e0ed82ef138a64d606aa770a674402c7e7175dc32175448e5af80481ee", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.30160261885011713, + "panel_kind": "sparse", + "realization": 9, + "safe_arrays_sha256": "7af8e2ee528bd3359211e790a2920e30642aab9048f6f476287398c0f97c86fd", + "safe_identity_hash": "33661a9073ea94e3577aa6a623e73046632a3dc4db8599e6487ea8f277328f30", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12650077536750345, + "panel_kind": "isotropic", + "realization": 9, + "safe_arrays_sha256": "c0f86f1c4be5dc79e6bb0306fa525ffc737bb78ce73be3c3c09954185f6d5233", + "safe_identity_hash": "d967c99bf195ee6824ac3aa1e3d4e22658652fb4a665da437ab9fdd11f67c393", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.31665150889008703, + "panel_kind": "sparse", + "realization": 10, + "safe_arrays_sha256": "44bf81fa40d371a7c3f1562c3c3c8dbad3dc70d9975221747f5dcfd337b093ae", + "safe_identity_hash": "418ca098e87d0788b3b0ac01f0719cbcb1b6a61e155bbc7d792d65ad3d333009", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12486718470697158, + "panel_kind": "isotropic", + "realization": 10, + "safe_arrays_sha256": "1aad9fc483ac613dfad8f24c8d7253d743bf031c84089704672d46112663661e", + "safe_identity_hash": "44235a21a4f4ee1dc44cfd23222a74ed0b46644cd12a85b3b3df0ccf8bbebe4b", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3150172274088173, + "panel_kind": "sparse", + "realization": 11, + "safe_arrays_sha256": "2fd122fca6ac2a7c5cacd6a0183316cd02c68d186b15a3b1920ab67c0df95a0a", + "safe_identity_hash": "755fc313c196d8a92647066b0737fb8a0927370de088d77b20342458a7c481fa", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12648186917582072, + "panel_kind": "isotropic", + "realization": 11, + "safe_arrays_sha256": "111d8a85916ca779bbed0856dafe1ce58e28b5f9166c00d4fcd02e66266bcbfc", + "safe_identity_hash": "59b47632041fed4897fdab7b1236547b1364efdb2cfecee21dfd78923b3a5602", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.30930882837092594, + "panel_kind": "sparse", + "realization": 12, + "safe_arrays_sha256": "5dc325962da89f55953fa7f335408ab2f82de01c2726b29dc3f6050e51dd89c1", + "safe_identity_hash": "33e894bde09e178fa7d42c62a458ca59f5416a83c92872b4663b60b78f790cc6", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12473903801862468, + "panel_kind": "isotropic", + "realization": 12, + "safe_arrays_sha256": "3a1bca5f8e3d82f15f5e9f9803fe47385d4f1f16317961d920f96f3351a3a7a3", + "safe_identity_hash": "6ae762782e454b55ccff8d8a64443a289770fdd13d8b3c3d645d5e5eb2f90c04", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.3187092233316881, + "panel_kind": "sparse", + "realization": 13, + "safe_arrays_sha256": "9b99686756fdbaba2353a305d6be4f30c90b64bb892cfc5336171e8d23e94dd0", + "safe_identity_hash": "1961c6c9a25f001e6e7fac755d13955cac497941fd775e03c682f3c3b1f1cd10", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12311679093164661, + "panel_kind": "isotropic", + "realization": 13, + "safe_arrays_sha256": "0a33d6948d3352028edbe114fb4a19c961d06edccacda83ca5e40ad163246e23", + "safe_identity_hash": "2859a133fef366e2c8ea47ca2d7d6f933640c8893d4d10f66f8e9c5c911645c5", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.2869840786512777, + "panel_kind": "sparse", + "realization": 14, + "safe_arrays_sha256": "0c53f77fb2db84baa9667a0be69a13db4a22dd00fb35fac11b01d59c81fe3546", + "safe_identity_hash": "21ef98bfcfb34b3c82b5839a6d48788011d8e9e1658984fc442e32eb299b6cf9", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12546110242529254, + "panel_kind": "isotropic", + "realization": 14, + "safe_arrays_sha256": "85102b350476e4fd23ed8cd2e11e9c67ee42725787ee6c1a106c5070168162c2", + "safe_identity_hash": "947269efd7e8d47f59105a0172608db4de990a2c15ed5237cf874357d932b05b", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.30145482021488623, + "panel_kind": "sparse", + "realization": 15, + "safe_arrays_sha256": "da21597f44e09f1dc9033f92c2d910c3f3900912f73b16a1d2881a3549fec209", + "safe_identity_hash": "0ef6e4a0ccd858638d4f86c2e298844b52513d60cbdfd712b709f5a8ae423fcd", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12410893255261685, + "panel_kind": "isotropic", + "realization": 15, + "safe_arrays_sha256": "01255a1f131e778598f7b26464a7dd903f4515abdca05690d13dc811d31b125f", + "safe_identity_hash": "a1cff0e9e6f52f1eb39abe0a7c53492ff4ab068a03487d04a1cd723998a8636e", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.2818005333067515, + "panel_kind": "sparse", + "realization": 16, + "safe_arrays_sha256": "f89c1175dae34a10ee5446eb14ad6a61118da786f7a1e2a9f86aa6f544b8414f", + "safe_identity_hash": "e8a3b9c2ec197ee4953a218f2147661365667f1c9c31deb3ef90f0d8cae874a0", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12906197590591661, + "panel_kind": "isotropic", + "realization": 16, + "safe_arrays_sha256": "39631d2ab6c32ded74fe17dfb1e0610711e30f4ea98917975ed54453f87efb6c", + "safe_identity_hash": "2f00a3bda2a87dda2e88560a3952c97d71b156557accc41c4d193f0f5fd15993", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.2896988545076108, + "panel_kind": "sparse", + "realization": 17, + "safe_arrays_sha256": "2f79a2c3f65b7763add919b47631485952dfdf3fd867c8b1a3be60103dc126e7", + "safe_identity_hash": "5db473f83a16417728c909162b9fc6cbd1310918dacd67d3ab8262b27059e27d", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12991968510069635, + "panel_kind": "isotropic", + "realization": 17, + "safe_arrays_sha256": "98535b4710a8a2bb246219e1b3546a284fadf58ac8207e5d4fedbd906c801939", + "safe_identity_hash": "7679325f5b4810adb8f5b9671705c70128fe9df8df560b6b7cdfd463cb5defb5", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.28449340190852845, + "panel_kind": "sparse", + "realization": 18, + "safe_arrays_sha256": "521a0c5bd527528ef4fa178591b5373e424de7c771d120b6b6f244b70773fcdd", + "safe_identity_hash": "e32c8cd0c34e53a21dca84e140eaaa914c34cf02e03f7b2e87fd4a43689af857", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.1288786398203198, + "panel_kind": "isotropic", + "realization": 18, + "safe_arrays_sha256": "177f89a2b0b90e6dc53fac068250c78a2002aabc3d1cc0969d0d9cb7e6ac6060", + "safe_identity_hash": "5d57840828c0517a68cdc5d20c2355ecb014d3990a91c9995999bddcfe2e81b3", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.29311383113002976, + "panel_kind": "sparse", + "realization": 19, + "safe_arrays_sha256": "a83dcc6d56d737dfe3e3fa7798c132e48f36a33f152bee5bd4a1e0a414201d3a", + "safe_identity_hash": "947a8114b86536753bca9de87b15e500b355a02719b9248203b0c775004e96ab", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12593911102405952, + "panel_kind": "isotropic", + "realization": 19, + "safe_arrays_sha256": "9e6def7b6e7b0030fd44b7b36b908560c07d8b5d73007a141ab5899e0ed24129", + "safe_identity_hash": "a91ad6776d7a5aa3b399603e9fdf7bba53b1fc1c27780c17bd6f28bbb5a9a3bd", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.285266176958073, + "panel_kind": "sparse", + "realization": 20, + "safe_arrays_sha256": "09ab8aca3eeb3d3a3cff610d194d54bcb2f2dc76abb82848d759ed5222535511", + "safe_identity_hash": "91e38e992c88d0f9dc51c205f122436c048af7765b03202b0691127de30ec851", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.1264565795005598, + "panel_kind": "isotropic", + "realization": 20, + "safe_arrays_sha256": "e5302abb0f43102845a0960bbfdf27bb6bd082a5cc99ba92b5ffea772bc0074a", + "safe_identity_hash": "e5f175ef8a712bf1a0f375bd8dbc64bd7710f0a956af401b55498845eba7b31c", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.31760948481702245, + "panel_kind": "sparse", + "realization": 21, + "safe_arrays_sha256": "d2ba36cb89e27471c0f320009a634556450fb02ffcb76bca839556a2edb698cb", + "safe_identity_hash": "84815ba140a3529e9853686c04bee86607b31b0112783fe99ecedfaa6782884a", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.1273439972529156, + "panel_kind": "isotropic", + "realization": 21, + "safe_arrays_sha256": "4688ace5caa4696cf663ffa681e026c177c0710f2c6f7700a025071e55d559ae", + "safe_identity_hash": "a928ce8f3dae52e54f4949a32386bb131943f7f842f39f22fb82a62051604eaa", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.2933414888869676, + "panel_kind": "sparse", + "realization": 22, + "safe_arrays_sha256": "4ba6f1a823c9e00e2220b4c7ba38013a0c07aef290ce4b9cbca343d7cdbfc7a3", + "safe_identity_hash": "855d38cfc708aefc6279e9cbd7662fa7c2a7a8182c11175284cd82e2cf269f0a", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12410061262322138, + "panel_kind": "isotropic", + "realization": 22, + "safe_arrays_sha256": "8131af64da5a200c301d1b19a7d9a98798261217eeaa9d5ada2ef846864ddae3", + "safe_identity_hash": "5dacb97ad31e24930af4262f6ddd7e2307101a0fc5de6b807c795b66c779640f", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.2914180000397658, + "panel_kind": "sparse", + "realization": 23, + "safe_arrays_sha256": "79be6be1d02f72821ad761cc7327f17f206fed4aae3ba1a74abe00016624fd28", + "safe_identity_hash": "eda4fff0f68cd8fb9bedcff161e988d4748f8c5a67dfc5fe2cd4e45a9b8f7938", + "sector": "adjacent", + "version": "v7" + }, + { + "N": 14, + "R4": 0.12704309933319832, + "panel_kind": "isotropic", + "realization": 23, + "safe_arrays_sha256": "cad00b6d5a6d292790f2935cabcda313cc892f37fdce08891c2c9d7d594b631d", + "safe_identity_hash": "7f15fc8450ea436c6df0c45f95c49eab7e06a83559af7cabc1bde9811f594591", + "sector": "adjacent", + "version": "v7" + } + ], + "unsealed_utc": "2026-08-04T01:18:16.227834+00:00", + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_unsealed.npz b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_unsealed.npz new file mode 100644 index 000000000..71396cae0 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_N14_unsealed.npz differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_controls.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_controls.json new file mode 100644 index 000000000..d2e0d1ee6 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_controls.json @@ -0,0 +1,87 @@ +{ + "checks": { + "N6_curvature_atoms": true, + "N6_diagonal_multiplicities": true, + "N6_off_diagonal_multiplicities": true, + "N8_decomposable_rank": true, + "N8_open_gap": true, + "one_sided_exact_regression": true + }, + "decomposable_N6": { + "alpha": 1.7, + "bps_rank": 18, + "diagonal_eigenvalues": [ + -0.34602076124567477, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.34602076124567477 + ], + "diagonal_max_atom_error": 0.0, + "diagonal_multiplicities": { + "negative": 1, + "positive": 1, + "zero": 16 + }, + "gap": 2.8899999999999997, + "off_diagonal_eigenvalues": [ + -0.34602076124567477, + -0.34602076124567477, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.34602076124567477, + 0.34602076124567477 + ], + "off_diagonal_max_atom_error": 0.0, + "off_diagonal_multiplicities": { + "negative": 2, + "positive": 2, + "zero": 14 + } + }, + "decomposable_N8": { + "bps_rank": 60, + "expected_rank": 60, + "gap": 2.8899999999999997, + "kernel_residual": 0.0 + }, + "one_sided_regression": { + "max_absolute_difference": 0.0, + "samples": 32, + "seed": 211 + }, + "passed": true, + "sources": { + "generate_susy_hodge_controls_v7.py": "0ef460da3541e242af5ed569cec6d2ef5cf54cd360e847e7bd3172447dac1d82", + "lgeth/hodge_response.py": "dad431f6a3873b2cb5542c07efd9b9c29f96f0375947f81947998783f362469e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b" + }, + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_covariates_pilot.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_covariates_pilot.json new file mode 100644 index 000000000..ace3e87f8 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_covariates_pilot.json @@ -0,0 +1,16395 @@ +{ + "checks": { + "all_safe_checks": true, + "complete_requested_grid": true, + "no_outcome_leakage": true + }, + "passed": true, + "records": [ + { + "arrays_sha256": "d279db2f7d4cf50bdbfddc47b5ecf396eb7bfb8902bad7a21d768f343791b487", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:58.818301+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "d2de21b595fda6b3d91f1f507c6902cd690051cce7b2cea7fcd30fd79364a68c", + "panel_kind": "sparse", + "panel_seed": 6712381035597109010, + "realization": 0, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2553c466e83e20d6183d243b38d6b899a21420e6f2eb66d3c77feae31c410db4", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31989749891442076, + "kernel_residual": 1.0031638903585107e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.906310061891147, + "minus_external_entropy": 0.9631286314909848, + "minus_target_effective_rank": 26.561920821356804, + "minus_target_entropy": 0.954378948880504, + "minus_weight": 56.164849021787994, + "orthogonality_relative_error": 1.4480188977902597e-16, + "plus_external_effective_rank": 6.906310061891147, + "plus_external_entropy": 0.9631286314909853, + "plus_target_effective_rank": 26.561920821356818, + "plus_target_entropy": 0.9543789488805039, + "plus_weight": 56.164849021788044, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "99f907ead50362f3b55b83ebd4872f119a4f96ca76766d7e4041aadd287de30f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:58.925816+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "d2de21b595fda6b3d91f1f507c6902cd690051cce7b2cea7fcd30fd79364a68c", + "panel_kind": "isotropic", + "panel_seed": 6712381035597109010, + "realization": 0, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "783cfe3ae8dc692ef7face1ffa4c861b4ba4059f3c957088216651d839a04621", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31989749891442076, + "kernel_residual": 1.0031638903585107e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.892615486864619, + "minus_external_entropy": 0.9633991313758382, + "minus_target_effective_rank": 29.737000287600384, + "minus_target_entropy": 0.897049430206789, + "minus_weight": 56.876805558765525, + "orthogonality_relative_error": 1.410917552015928e-16, + "plus_external_effective_rank": 6.892615486864621, + "plus_external_entropy": 0.9633991313758384, + "plus_target_effective_rank": 29.737000287600384, + "plus_target_entropy": 0.8970494302067888, + "plus_weight": 56.87680555876557, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "02830def174e2f17aedc22c5c39a3819efb2ea079fa96a19e6d56e8163875075", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.039084+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "feb4fbe8f2183b83c4e852401cc33698e53567ca9882d0d5257e7b5232496d68", + "panel_kind": "sparse", + "panel_seed": 4494313612115535194, + "realization": 1, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "dc3fdd4069a1090447a49ec3784ec239034af7772c85915dba8565d6ac60aa4e", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.33348932379770296, + "kernel_residual": 1.000574811034804e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.727303230971197, + "minus_external_entropy": 0.9553987333898606, + "minus_target_effective_rank": 24.80016052897615, + "minus_target_entropy": 0.9494422263062948, + "minus_weight": 55.47706362251138, + "orthogonality_relative_error": 1.5776406367338692e-16, + "plus_external_effective_rank": 6.727303230971191, + "plus_external_entropy": 0.9553987333898606, + "plus_target_effective_rank": 24.800160528976136, + "plus_target_entropy": 0.9494422263062947, + "plus_weight": 55.47706362251134, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "f2bf28bb5835cbac8183af5c89881caef6c6cd6d1effc31f593a42bcf1074874", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.145784+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "feb4fbe8f2183b83c4e852401cc33698e53567ca9882d0d5257e7b5232496d68", + "panel_kind": "isotropic", + "panel_seed": 4494313612115535194, + "realization": 1, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f147fd2c691a1b500bb22d7109356c69b26f6206adf997c5c26eb7c8eef7b42e", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.33348932379770296, + "kernel_residual": 1.000574811034804e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.192184176210985, + "minus_external_entropy": 0.974796383646619, + "minus_target_effective_rank": 29.937255885235057, + "minus_target_entropy": 0.8972636008609922, + "minus_weight": 55.389587447323976, + "orthogonality_relative_error": 1.6278568872994446e-16, + "plus_external_effective_rank": 7.19218417621097, + "plus_external_entropy": 0.9747963836466188, + "plus_target_effective_rank": 29.937255885235043, + "plus_target_entropy": 0.897263600860992, + "plus_weight": 55.38958744732395, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "3429a4223488309787f962140cbd5fe9030a8c6038763c3e71468d998a057284", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.255616+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "894f0a1e62fa9cb87a75932a8b7fb66e936c2e43c67ed1228fc333c69db1f21d", + "panel_kind": "sparse", + "panel_seed": 11196775874684465776, + "realization": 2, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "34244965454c2d58776def768d33aecd23c0cea1db5f410ac88b5af47fae7a11", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29317024715248113, + "kernel_residual": 9.717750587981882e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 5.934532170897461, + "minus_external_entropy": 0.9182116407072981, + "minus_target_effective_rank": 22.63709126325537, + "minus_target_entropy": 0.9507528246191665, + "minus_weight": 60.738040056089204, + "orthogonality_relative_error": 1.7716601985572866e-16, + "plus_external_effective_rank": 5.934532170897461, + "plus_external_entropy": 0.918211640707298, + "plus_target_effective_rank": 22.63709126325537, + "plus_target_entropy": 0.9507528246191664, + "plus_weight": 60.73804005608921, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "06c4e28a758a322a3f5d1380ea51db7690bfbea9ebb976782f6d1a49ef405da0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.359139+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "894f0a1e62fa9cb87a75932a8b7fb66e936c2e43c67ed1228fc333c69db1f21d", + "panel_kind": "isotropic", + "panel_seed": 11196775874684465776, + "realization": 2, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b16d562ac212c8484d3e9b28c7ab9e7b07083c2c88834fbbdcd63477cfd04252", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29317024715248113, + "kernel_residual": 9.717750587981882e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.528043216281279, + "minus_external_entropy": 0.9490436967366969, + "minus_target_effective_rank": 28.95498241088932, + "minus_target_entropy": 0.8915963307462438, + "minus_weight": 59.94207719323898, + "orthogonality_relative_error": 1.846505404050576e-16, + "plus_external_effective_rank": 6.528043216281283, + "plus_external_entropy": 0.949043696736697, + "plus_target_effective_rank": 28.95498241088933, + "plus_target_entropy": 0.8915963307462433, + "plus_weight": 59.942077193239, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "127e78754212c972d3b3a3a251948a9e31a9e4eee9abf8cf897a2f21b8383f29", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.468612+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e8c9a44b73c8c29edb1481b7d99e22d72f0f449a86cd35f8070f48f775f4564f", + "panel_kind": "sparse", + "panel_seed": 16173911803461271316, + "realization": 3, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e06eabd66a0ae7b30c213a62a66fb7f148dc9467f87ec12770bda2f122e5764d", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3162335021455887, + "kernel_residual": 9.72197053917316e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.957512334528189, + "minus_external_entropy": 0.9653810253041193, + "minus_target_effective_rank": 26.541713210397397, + "minus_target_entropy": 0.9536613676007686, + "minus_weight": 56.1628258884668, + "orthogonality_relative_error": 2.04559035992696e-16, + "plus_external_effective_rank": 6.9575123345281895, + "plus_external_entropy": 0.9653810253041195, + "plus_target_effective_rank": 26.541713210397415, + "plus_target_entropy": 0.9536613676007684, + "plus_weight": 56.162825888466834, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "25ece3b52de35f4565370707195f7f6617c6f4497f47722acef0579bc3906b95", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.571715+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e8c9a44b73c8c29edb1481b7d99e22d72f0f449a86cd35f8070f48f775f4564f", + "panel_kind": "isotropic", + "panel_seed": 16173911803461271316, + "realization": 3, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2cf55f7b7312e562f3db98961f61773d7d5f1c48fe6326a229acfb22c4f70ff3", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3162335021455887, + "kernel_residual": 9.72197053917316e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.05168165317988, + "minus_external_entropy": 0.9699826989414064, + "minus_target_effective_rank": 29.9386637366093, + "minus_target_entropy": 0.8979618220134903, + "minus_weight": 56.073059454639186, + "orthogonality_relative_error": 1.9547205995833357e-16, + "plus_external_effective_rank": 7.051681653179883, + "plus_external_entropy": 0.9699826989414069, + "plus_target_effective_rank": 29.938663736609318, + "plus_target_entropy": 0.8979618220134903, + "plus_weight": 56.07305945463921, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "901c2f4a20fbd2ab870e84cd4d6a637a3e32e0b1a0a856e4f448a166dd48ef25", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.676438+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e21720f59c201483c3fc7fb34bb9651353c50804138a49024537d2644684976d", + "panel_kind": "sparse", + "panel_seed": 7300569131601052580, + "realization": 4, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c824a4215b46eeea1684238401b0ac6504a782567654418c60b30a15ba29384e", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3782966553874937, + "kernel_residual": 9.923846259980019e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.307755143797807, + "minus_external_entropy": 0.97828950857954, + "minus_target_effective_rank": 28.799599595450115, + "minus_target_entropy": 0.9635901948488405, + "minus_weight": 53.81216059059692, + "orthogonality_relative_error": 1.5282756889323535e-16, + "plus_external_effective_rank": 7.307755143797808, + "plus_external_entropy": 0.9782895085795398, + "plus_target_effective_rank": 28.799599595450108, + "plus_target_entropy": 0.9635901948488408, + "plus_weight": 53.81216059059694, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6be941a43ae7c7d45637a7ff0b5a59c936c82e1d4565f48b698e51fe8c8bb722", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.772039+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e21720f59c201483c3fc7fb34bb9651353c50804138a49024537d2644684976d", + "panel_kind": "isotropic", + "panel_seed": 7300569131601052580, + "realization": 4, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "05e1516c316993285585d7981bcfb2eed629035bce2e7e0a1cf7ae84b2c5c929", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3782966553874937, + "kernel_residual": 9.923846259980019e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.276226763789925, + "minus_external_entropy": 0.977035439001372, + "minus_target_effective_rank": 30.289373806358032, + "minus_target_entropy": 0.8994323956834662, + "minus_weight": 53.4670790210558, + "orthogonality_relative_error": 1.5336658913890028e-16, + "plus_external_effective_rank": 7.276226763789928, + "plus_external_entropy": 0.9770354390013718, + "plus_target_effective_rank": 30.289373806358025, + "plus_target_entropy": 0.8994323956834662, + "plus_weight": 53.467079021055824, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "85397b700a2ee75489411a7ebeaeb08269809e28ecb46b469f94e8f59cf594c3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.913189+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "0b25f8bb64f02aaf69c7de7e0d63a70a4ba38def6d4f83cd7e9aeaf816c70877", + "panel_kind": "sparse", + "panel_seed": 6401611679012054544, + "realization": 5, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1bdee3b35338f519c1684880d21f5f1fee958de04410c9b7879d4a21d85593d2", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2753987560855047, + "kernel_residual": 1.0055587865485858e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.281767827736662, + "minus_external_entropy": 0.9354692787104288, + "minus_target_effective_rank": 23.56252533718206, + "minus_target_entropy": 0.9426960964435014, + "minus_weight": 59.84599594894605, + "orthogonality_relative_error": 2.1102440323989682e-16, + "plus_external_effective_rank": 6.281767827736659, + "plus_external_entropy": 0.9354692787104287, + "plus_target_effective_rank": 23.562525337182045, + "plus_target_entropy": 0.9426960964435014, + "plus_weight": 59.84599594894606, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "f67927f7be4d62437d4af61351d33fe914fab282e50658d05154555396e8ed9e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:00.085688+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "0b25f8bb64f02aaf69c7de7e0d63a70a4ba38def6d4f83cd7e9aeaf816c70877", + "panel_kind": "isotropic", + "panel_seed": 6401611679012054544, + "realization": 5, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ad41fbf86bccb98211036f57488e321e3f2ce5ade8c2fffef4c66ea62e5b2ae3", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2753987560855047, + "kernel_residual": 1.0055587865485858e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.536550662430953, + "minus_external_entropy": 0.9498941407349833, + "minus_target_effective_rank": 28.78335891438232, + "minus_target_entropy": 0.8911110584471464, + "minus_weight": 59.21735436244465, + "orthogonality_relative_error": 2.0481812623994773e-16, + "plus_external_effective_rank": 6.5365506624309475, + "plus_external_entropy": 0.9498941407349833, + "plus_target_effective_rank": 28.783358914382305, + "plus_target_entropy": 0.8911110584471464, + "plus_weight": 59.217354362444674, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e7762161bb39ba201ec8e0e69be43cb409d33921ce5aaed5c30b61d927780249", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:00.265397+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "8a995cf82e9837e64c813ea356da3ccd7760e72e7b112c47a56ca92371a9995a", + "panel_kind": "sparse", + "panel_seed": 4546943701502790165, + "realization": 6, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7e9d7b2221b1a76c3d8c5a1e04e2b692e8fc27aad359bc8bebe78f7b3f8a16a3", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30267053027854063, + "kernel_residual": 9.816159958283208e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 5.908054785530005, + "minus_external_entropy": 0.9243590019097366, + "minus_target_effective_rank": 21.77898127439201, + "minus_target_entropy": 0.9481536248143324, + "minus_weight": 56.59885373425371, + "orthogonality_relative_error": 1.7917953010406818e-16, + "plus_external_effective_rank": 5.908054785530001, + "plus_external_entropy": 0.9243590019097365, + "plus_target_effective_rank": 21.778981274392013, + "plus_target_entropy": 0.9481536248143325, + "plus_weight": 56.59885373425371, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "3c1cdb49c2fcb75699db6c108f83a88fe4b49564520fbe2586e65425cdcc8233", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:00.453380+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "8a995cf82e9837e64c813ea356da3ccd7760e72e7b112c47a56ca92371a9995a", + "panel_kind": "isotropic", + "panel_seed": 4546943701502790165, + "realization": 6, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d138d7ea668bc77119f5e63e2e44891cc72af46449588f537b76cbafa3c72933", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30267053027854063, + "kernel_residual": 9.816159958283208e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.959116559977406, + "minus_external_entropy": 0.9677150661838805, + "minus_target_effective_rank": 29.499601100406426, + "minus_target_entropy": 0.8962867153219757, + "minus_weight": 56.0277251296167, + "orthogonality_relative_error": 1.776709110947721e-16, + "plus_external_effective_rank": 6.959116559977404, + "plus_external_entropy": 0.9677150661838805, + "plus_target_effective_rank": 29.49960110040642, + "plus_target_entropy": 0.8962867153219757, + "plus_weight": 56.027725129616684, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "0a93aebcd9d827bacfa7f54f58c39038c888bbd97b0ac44a0d2dac26674e943f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:00.613599+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1e5525a2dc8f510a9a340529ca785c4c393f8b63f7005d170f3b99696b3c0ced", + "panel_kind": "sparse", + "panel_seed": 5127668464502805323, + "realization": 7, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "55627b33168c3e0c24cf570a30092f8324bd9fee26fd7cda0464a5e226e34ec9", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3236910654405299, + "kernel_residual": 1.0886305064312513e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.84514389871164, + "minus_external_entropy": 0.9614402878966052, + "minus_target_effective_rank": 25.22841155638714, + "minus_target_entropy": 0.9540264989342846, + "minus_weight": 55.51731320937134, + "orthogonality_relative_error": 2.3912175068837956e-16, + "plus_external_effective_rank": 6.845143898711643, + "plus_external_entropy": 0.9614402878966053, + "plus_target_effective_rank": 25.228411556387144, + "plus_target_entropy": 0.9540264989342846, + "plus_weight": 55.51731320937131, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "5b4ffad75d00fc706b0c4f8e7f0f804b60c00bd7bf23a3c40bdd6ee73155766e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:00.780357+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1e5525a2dc8f510a9a340529ca785c4c393f8b63f7005d170f3b99696b3c0ced", + "panel_kind": "isotropic", + "panel_seed": 5127668464502805323, + "realization": 7, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "df8e3523ac98f1cd026d33f218a5ead804dc69c8fa9541c52b291e6f9459cdbe", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3236910654405299, + "kernel_residual": 1.0886305064312513e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.940219922286247, + "minus_external_entropy": 0.9649233821964273, + "minus_target_effective_rank": 29.305381419913793, + "minus_target_entropy": 0.893494855383621, + "minus_weight": 56.865431205900165, + "orthogonality_relative_error": 2.378335514725826e-16, + "plus_external_effective_rank": 6.94021992228625, + "plus_external_entropy": 0.9649233821964275, + "plus_target_effective_rank": 29.3053814199138, + "plus_target_entropy": 0.893494855383621, + "plus_weight": 56.86543120590014, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "1927b7c601da4bd3bb7da0fa622a17c07421d49474f137646d8e47d99fd2f0f4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:00.934330+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "08128ffa8e7479b0726ac3ce8647800e682e7da0ea649e6ab7cfaa41a6ae5350", + "panel_kind": "sparse", + "panel_seed": 10421454225035959596, + "realization": 8, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "35de11d4f5289cb15b2292288f002490cefe8b9b412c6ce012995d3832401af0", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3078495649877013, + "kernel_residual": 9.753541343150522e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.593672618768767, + "minus_external_entropy": 0.9537281510279926, + "minus_target_effective_rank": 26.31722185658438, + "minus_target_entropy": 0.9499774493106804, + "minus_weight": 57.40918823341669, + "orthogonality_relative_error": 1.7697300811257965e-16, + "plus_external_effective_rank": 6.593672618768766, + "plus_external_entropy": 0.9537281510279925, + "plus_target_effective_rank": 26.317221856584382, + "plus_target_entropy": 0.9499774493106804, + "plus_weight": 57.40918823341672, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "fbc9c2706df2bb8d8044e457eddc24f66ade0a7ad79a4714913ee4dd369cdc72", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.065042+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "08128ffa8e7479b0726ac3ce8647800e682e7da0ea649e6ab7cfaa41a6ae5350", + "panel_kind": "isotropic", + "panel_seed": 10421454225035959596, + "realization": 8, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8b622b20baf5bb448700bb62c08aa51cda88b104eccb454c698c83e309aac4ed", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3078495649877013, + "kernel_residual": 9.753541343150522e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.922712441026345, + "minus_external_entropy": 0.9650180796929784, + "minus_target_effective_rank": 29.324054424645094, + "minus_target_entropy": 0.8952083798223981, + "minus_weight": 56.93823496517609, + "orthogonality_relative_error": 1.7148754376301312e-16, + "plus_external_effective_rank": 6.922712441026345, + "plus_external_entropy": 0.9650180796929784, + "plus_target_effective_rank": 29.324054424645098, + "plus_target_entropy": 0.8952083798223984, + "plus_weight": 56.93823496517612, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "503784456880fe732b271fc58f64d1f5551404421acb2b4d30ddd3009c5f8086", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.204397+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "29bad6fb772d0aea3833ecbccffb1ed6fc9946dd82a1a119d552e7360a0c305d", + "panel_kind": "sparse", + "panel_seed": 17241178783425349627, + "realization": 9, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3d19c6b7b57a85c15691e4bd045f31ebdc7213ad3477c237ed97bc6a1ee66f74", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3258893617669939, + "kernel_residual": 9.726884288410461e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.639970549197485, + "minus_external_entropy": 0.9541303560176388, + "minus_target_effective_rank": 24.833260538918683, + "minus_target_entropy": 0.9512535494063864, + "minus_weight": 55.638207976692115, + "orthogonality_relative_error": 2.4882555254331784e-16, + "plus_external_effective_rank": 6.639970549197494, + "plus_external_entropy": 0.9541303560176391, + "plus_target_effective_rank": 24.83326053891869, + "plus_target_entropy": 0.9512535494063864, + "plus_weight": 55.6382079766921, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "102ccebc9c55d4a364657db8f96a600abd052a68798c4e0ac19087eecdc951a8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.334347+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "29bad6fb772d0aea3833ecbccffb1ed6fc9946dd82a1a119d552e7360a0c305d", + "panel_kind": "isotropic", + "panel_seed": 17241178783425349627, + "realization": 9, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ea6a9300b16da1754149f2f94456da49e839246d1b23720a4e8e2cc1b7ab5e72", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3258893617669939, + "kernel_residual": 9.726884288410461e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.15626459317449, + "minus_external_entropy": 0.9739365922584264, + "minus_target_effective_rank": 29.141448750674986, + "minus_target_entropy": 0.8928980976617124, + "minus_weight": 55.78324517684163, + "orthogonality_relative_error": 2.4842143043235153e-16, + "plus_external_effective_rank": 7.156264593174494, + "plus_external_entropy": 0.9739365922584267, + "plus_target_effective_rank": 29.141448750674986, + "plus_target_entropy": 0.8928980976617125, + "plus_weight": 55.78324517684164, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "eabfb43c5efdcd49bb5de6e330171f7398fc8444740828f4fcab02dd7f1b9eba", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.459157+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ca2082cf7b35356da5701538d258cef01a4dbf8e11ff8bbc0b3b316ee0228cd2", + "panel_kind": "sparse", + "panel_seed": 9825404631407848744, + "realization": 10, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b0612ba48b1139547ba3ad571c1cb2257e5ad7cd13c172eedfc0ad1a8eca53ef", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3297372007939848, + "kernel_residual": 9.682562591081158e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.889192871151712, + "minus_external_entropy": 0.9622446729325163, + "minus_target_effective_rank": 27.980747589057152, + "minus_target_entropy": 0.9591429450224473, + "minus_weight": 57.28054251693665, + "orthogonality_relative_error": 2.5605639121142206e-16, + "plus_external_effective_rank": 6.889192871151712, + "plus_external_entropy": 0.9622446729325163, + "plus_target_effective_rank": 27.980747589057135, + "plus_target_entropy": 0.9591429450224476, + "plus_weight": 57.28054251693672, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "7f62a54a1163686ce18d6cd4c5a5cf299af72379cf896d151371bd452cb52c95", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.559612+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ca2082cf7b35356da5701538d258cef01a4dbf8e11ff8bbc0b3b316ee0228cd2", + "panel_kind": "isotropic", + "panel_seed": 9825404631407848744, + "realization": 10, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5758f3adaafa262dd2a38781a439862ee2f72fb0c7645e2ad22944af891651b3", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3297372007939848, + "kernel_residual": 9.682562591081158e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.21998336338748, + "minus_external_entropy": 0.9749699630505838, + "minus_target_effective_rank": 29.67770334465231, + "minus_target_entropy": 0.8963176411673427, + "minus_weight": 55.0276352256857, + "orthogonality_relative_error": 2.5072411491300566e-16, + "plus_external_effective_rank": 7.219983363387481, + "plus_external_entropy": 0.9749699630505838, + "plus_target_effective_rank": 29.677703344652304, + "plus_target_entropy": 0.8963176411673427, + "plus_weight": 55.027635225685756, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "61f0459572d55f6d91f134ca5f5d882f34ad9eb12757cd5eacde5dada31029e8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.660401+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "59cc1e84c890292bd75f76a89c3306bd159cdad33972ee3edf73b55bd088275e", + "panel_kind": "sparse", + "panel_seed": 9402798246654180518, + "realization": 11, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8f5bec25a773bf5032d7795c57a39f2dc747c307e3eae0c00b2381928db19f20", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3149905638416165, + "kernel_residual": 9.786310277580935e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.487921588974767, + "minus_external_entropy": 0.9460158723410904, + "minus_target_effective_rank": 22.562144227135345, + "minus_target_entropy": 0.9464431643557163, + "minus_weight": 54.157512314790736, + "orthogonality_relative_error": 1.586787555744292e-16, + "plus_external_effective_rank": 6.487921588974772, + "plus_external_entropy": 0.9460158723410905, + "plus_target_effective_rank": 22.562144227135352, + "plus_target_entropy": 0.9464431643557163, + "plus_weight": 54.15751231479074, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "58e57c6ca110ee11ae7c74b5b87a0b8445c1f22eb35f84b4522f2ea1c1a912dd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.771103+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "59cc1e84c890292bd75f76a89c3306bd159cdad33972ee3edf73b55bd088275e", + "panel_kind": "isotropic", + "panel_seed": 9402798246654180518, + "realization": 11, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6a4240ca04aa0580fa6a3c7b464c98110326c3cc0f2ccf85630d2d3371fefdf5", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3149905638416165, + "kernel_residual": 9.786310277580935e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.0251970107069575, + "minus_external_entropy": 0.9687626872980408, + "minus_target_effective_rank": 29.95195113476132, + "minus_target_entropy": 0.8988151261186589, + "minus_weight": 55.531890118776985, + "orthogonality_relative_error": 1.5021574662605767e-16, + "plus_external_effective_rank": 7.025197010706962, + "plus_external_entropy": 0.968762687298041, + "plus_target_effective_rank": 29.95195113476133, + "plus_target_entropy": 0.8988151261186591, + "plus_weight": 55.53189011877697, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "41f26bec2b2ecf9e74d0f9c8b78a55854c1b8166646b271900189976949d1daa", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.872904+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "6396c67d571e4cc8b5f49740e0f368d0b6b9be364ef59f9eba07462a24b92299", + "panel_kind": "sparse", + "panel_seed": 10157656434833357907, + "realization": 12, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "38d3e88a6eb9a417e0d91c0832a6be7da731e61bb9b442568e8e31579022e173", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.35501599290416397, + "kernel_residual": 1.0080867797627542e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.126924809159419, + "minus_external_entropy": 0.9711186138325061, + "minus_target_effective_rank": 25.250727321936594, + "minus_target_entropy": 0.9564415407544424, + "minus_weight": 55.58407579277957, + "orthogonality_relative_error": 1.8250257389113238e-16, + "plus_external_effective_rank": 7.126924809159415, + "plus_external_entropy": 0.9711186138325059, + "plus_target_effective_rank": 25.250727321936598, + "plus_target_entropy": 0.9564415407544424, + "plus_weight": 55.58407579277961, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "8fc5ead67ed3e37d1917aa7d2225a8865ccc74d21223ef407d3aa69559bf82b2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.969693+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "6396c67d571e4cc8b5f49740e0f368d0b6b9be364ef59f9eba07462a24b92299", + "panel_kind": "isotropic", + "panel_seed": 10157656434833357907, + "realization": 12, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8593641c3f2074b7a11ed3cd854e2788753ee578747e5166d7b6a5acf9ad6bf3", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.35501599290416397, + "kernel_residual": 1.0080867797627542e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.255904704227948, + "minus_external_entropy": 0.9759793563090019, + "minus_target_effective_rank": 29.717109724275424, + "minus_target_entropy": 0.8960492479767079, + "minus_weight": 54.31742212678941, + "orthogonality_relative_error": 1.812760995641023e-16, + "plus_external_effective_rank": 7.255904704227944, + "plus_external_entropy": 0.9759793563090019, + "plus_target_effective_rank": 29.717109724275417, + "plus_target_entropy": 0.896049247976708, + "plus_weight": 54.31742212678945, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "cd1e887098de3dbe1b993b9e154f6db1afff84859772394c61c6a692b4b7b067", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.070714+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "46356196c710a71ea94560434c094b6881e8780506d85649c80fa120009fa54b", + "panel_kind": "sparse", + "panel_seed": 15760182665437088626, + "realization": 13, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "81770893861224f1016a34a4833dd057c216ae5be504e7d071325d873f2865dd", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29751308707747204, + "kernel_residual": 9.746051942499644e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.17814196328533, + "minus_external_entropy": 0.9330278785103996, + "minus_target_effective_rank": 22.09720335824965, + "minus_target_entropy": 0.94840712288873, + "minus_weight": 57.802178361334846, + "orthogonality_relative_error": 1.522698165943653e-16, + "plus_external_effective_rank": 6.178141963285328, + "plus_external_entropy": 0.9330278785103996, + "plus_target_effective_rank": 22.097203358249647, + "plus_target_entropy": 0.94840712288873, + "plus_weight": 57.802178361334825, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e44b2e83a78ede465410eb365a9bb3d5129f377ff908d3a70e51fecb29a03047", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.171153+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "46356196c710a71ea94560434c094b6881e8780506d85649c80fa120009fa54b", + "panel_kind": "isotropic", + "panel_seed": 15760182665437088626, + "realization": 13, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "496d157777258d04d5a7c697f17b55bf6fb0d3ad467a22d1a278b5bf906d25e5", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29751308707747204, + "kernel_residual": 9.746051942499644e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.693639674536681, + "minus_external_entropy": 0.9591282230083537, + "minus_target_effective_rank": 29.055198585954013, + "minus_target_entropy": 0.8918098103059912, + "minus_weight": 56.71173312362145, + "orthogonality_relative_error": 1.5362853473346955e-16, + "plus_external_effective_rank": 6.693639674536677, + "plus_external_entropy": 0.9591282230083537, + "plus_target_effective_rank": 29.055198585954003, + "plus_target_entropy": 0.8918098103059913, + "plus_weight": 56.71173312362143, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "904bf25d746772113885320727f70c6e2f785956c9a46aba6cbb71e2826d8064", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.281188+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ed2ada199f4d5abec7b2d776045da39349d8b63ffac723d75a6e30ae21509759", + "panel_kind": "sparse", + "panel_seed": 1502686167259042665, + "realization": 14, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4d4c89a54d24ab0301420a7cf966ed0ca1b93750aee8ad658cab3b4f3027310a", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3157620242317473, + "kernel_residual": 9.987387410199076e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.129258855030907, + "minus_external_entropy": 0.9714070460021546, + "minus_target_effective_rank": 25.290137649331985, + "minus_target_entropy": 0.9575001430781045, + "minus_weight": 56.4615567023274, + "orthogonality_relative_error": 1.887864137173779e-16, + "plus_external_effective_rank": 7.129258855030906, + "plus_external_entropy": 0.9714070460021546, + "plus_target_effective_rank": 25.290137649331985, + "plus_target_entropy": 0.9575001430781045, + "plus_weight": 56.4615567023274, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "679657b775cfb9804796af95a8b4d6574dc3fd01b422f60564366c7931c5cebf", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.385295+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ed2ada199f4d5abec7b2d776045da39349d8b63ffac723d75a6e30ae21509759", + "panel_kind": "isotropic", + "panel_seed": 1502686167259042665, + "realization": 14, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e2fc9acb66e438833673c6febe3165d47b4f143a25bc9c64ce4b2b5376041ceb", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3157620242317473, + "kernel_residual": 9.987387410199076e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.018121391938885, + "minus_external_entropy": 0.9686508026446035, + "minus_target_effective_rank": 29.68610679294233, + "minus_target_entropy": 0.896647677251689, + "minus_weight": 55.316125284755586, + "orthogonality_relative_error": 1.8139186632981392e-16, + "plus_external_effective_rank": 7.018121391938886, + "plus_external_entropy": 0.9686508026446037, + "plus_target_effective_rank": 29.68610679294233, + "plus_target_entropy": 0.8966476772516893, + "plus_weight": 55.316125284755586, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "cb493a21db337d201c280ab78fd10928d58b257d7388ad710c4fa050f25a8d04", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.489719+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "748396a424ee904a6b49324cb90bfa04879d08152a95cfb5620d0e114fc37a3a", + "panel_kind": "sparse", + "panel_seed": 17130045624121972024, + "realization": 15, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "98cc0c65c33739afa72c45f04f57443b4d1953ef6b2ea84161a7f6504791c91b", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.27152564176264354, + "kernel_residual": 1.0022735415302351e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.25660714400629, + "minus_external_entropy": 0.93811062156965, + "minus_target_effective_rank": 24.555079936545482, + "minus_target_entropy": 0.9509743365243137, + "minus_weight": 59.25848743129208, + "orthogonality_relative_error": 1.8830482621822953e-16, + "plus_external_effective_rank": 6.256607144006291, + "plus_external_entropy": 0.9381106215696497, + "plus_target_effective_rank": 24.555079936545464, + "plus_target_entropy": 0.9509743365243137, + "plus_weight": 59.25848743129214, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "57fe72497a2182faa19574c0267656d5d33dd4a47b8afbad4b7f9d1ffff89553", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.584604+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "748396a424ee904a6b49324cb90bfa04879d08152a95cfb5620d0e114fc37a3a", + "panel_kind": "isotropic", + "panel_seed": 17130045624121972024, + "realization": 15, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3e552e6d62d15cb4f26f2d6d34adfad0b47a5387016e6e1a5a094f72b795a7af", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.27152564176264354, + "kernel_residual": 1.0022735415302351e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.444891801146761, + "minus_external_entropy": 0.9457818780563936, + "minus_target_effective_rank": 28.313057527708978, + "minus_target_entropy": 0.8860824202564205, + "minus_weight": 61.75816258548764, + "orthogonality_relative_error": 1.985221881871783e-16, + "plus_external_effective_rank": 6.444891801146761, + "plus_external_entropy": 0.9457818780563935, + "plus_target_effective_rank": 28.31305752770897, + "plus_target_entropy": 0.8860824202564203, + "plus_weight": 61.7581625854877, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "b3b2a73df2980a86fd5c436f84c8b539fb65ac5b604839979db31583ee8b9624", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.699233+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "049fd0158d5eb54f51328447fe285a471e48511b1deeb0f3a6e5feada2657fea", + "panel_kind": "sparse", + "panel_seed": 8468519870069001714, + "realization": 16, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b34ec3aff1b17801e50936d2c45c8d1cf44c4547792df33ea06fc2d64b9577ec", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2751488832622427, + "kernel_residual": 1.0374134810669283e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 5.861216716078553, + "minus_external_entropy": 0.9186449751915255, + "minus_target_effective_rank": 22.43085929001295, + "minus_target_entropy": 0.9558170909662005, + "minus_weight": 60.67560411526415, + "orthogonality_relative_error": 2.295737533711303e-16, + "plus_external_effective_rank": 5.86121671607855, + "plus_external_entropy": 0.9186449751915255, + "plus_target_effective_rank": 22.430859290012943, + "plus_target_entropy": 0.9558170909662005, + "plus_weight": 60.675604115264164, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "818191805edbad92b69294804c60ae1906563bddd5686df371fa73c8cbed548e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.803711+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "049fd0158d5eb54f51328447fe285a471e48511b1deeb0f3a6e5feada2657fea", + "panel_kind": "isotropic", + "panel_seed": 8468519870069001714, + "realization": 16, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e63dc347c38ee7764182e0392893fad8774b5ca0c306a30ccc86833ecbc22f83", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2751488832622427, + "kernel_residual": 1.0374134810669283e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.741778347210195, + "minus_external_entropy": 0.959052148403052, + "minus_target_effective_rank": 28.97599210794673, + "minus_target_entropy": 0.8912987000480891, + "minus_weight": 58.382471518222644, + "orthogonality_relative_error": 2.372567783591787e-16, + "plus_external_effective_rank": 6.741778347210195, + "plus_external_entropy": 0.959052148403052, + "plus_target_effective_rank": 28.97599210794673, + "plus_target_entropy": 0.8912987000480892, + "plus_weight": 58.38247151822265, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "24a7c9bf32ec34db3cdadb3cb31db5e5cc6efd66cf6e0bcef024c7c913d0a342", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.909502+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "c4d71df0bdaa3eb55f7fd53e0e2e45227519f7db95b11f95e3eb52d2c48280d2", + "panel_kind": "sparse", + "panel_seed": 10734905020495770974, + "realization": 17, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7b31cda265d27eacf354957a70810bf5833957f23c51ed2711a6f71acd96af5d", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3189879976975491, + "kernel_residual": 1.0556089618008158e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.612017120705572, + "minus_external_entropy": 0.9497589858509551, + "minus_target_effective_rank": 25.964798641136206, + "minus_target_entropy": 0.9550451976914696, + "minus_weight": 56.84680077374537, + "orthogonality_relative_error": 2.475201441399634e-16, + "plus_external_effective_rank": 6.612017120705569, + "plus_external_entropy": 0.9497589858509548, + "plus_target_effective_rank": 25.964798641136202, + "plus_target_entropy": 0.9550451976914696, + "plus_weight": 56.84680077374537, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "0b1ef2438c1d0eacd40e42110b1285b692da114db46d9f2c0ffef9bc952b14d3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.009458+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "c4d71df0bdaa3eb55f7fd53e0e2e45227519f7db95b11f95e3eb52d2c48280d2", + "panel_kind": "isotropic", + "panel_seed": 10734905020495770974, + "realization": 17, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1c8dc976aa7c7bda2b0fd213938c6ff4d0e75134c6f83e0b143786d23f3cab21", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3189879976975491, + "kernel_residual": 1.0556089618008158e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.9543776036103635, + "minus_external_entropy": 0.9665719148244957, + "minus_target_effective_rank": 29.98630190796838, + "minus_target_entropy": 0.89924386282059, + "minus_weight": 56.59458940537691, + "orthogonality_relative_error": 2.4219036625286286e-16, + "plus_external_effective_rank": 6.954377603610358, + "plus_external_entropy": 0.9665719148244957, + "plus_target_effective_rank": 29.986301907968375, + "plus_target_entropy": 0.8992438628205899, + "plus_weight": 56.594589405376894, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6b2c1148138aaa739477353f03e85fbc29590ab0a80fc34a11dcf7bf8b606bfb", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.125631+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "9b36a85bbb182f41b4f73cff1ccbbe30df9a5ae17c7f0b132383bd24a3bbb15c", + "panel_kind": "sparse", + "panel_seed": 622580746501599869, + "realization": 18, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3815fb3b1d0b448c9c29a960ad58d34f010ff603ba33867f43baa86a67157b9c", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.36467483176070276, + "kernel_residual": 1.0386781587823134e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.817808239764929, + "minus_external_entropy": 0.9605917533325482, + "minus_target_effective_rank": 23.34267327072904, + "minus_target_entropy": 0.9508854137348804, + "minus_weight": 53.931697570143804, + "orthogonality_relative_error": 2.1622393909235737e-16, + "plus_external_effective_rank": 6.817808239764934, + "plus_external_entropy": 0.9605917533325484, + "plus_target_effective_rank": 23.342673270729055, + "plus_target_entropy": 0.9508854137348806, + "plus_weight": 53.93169757014381, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "610339f28c0cc8dc40810ea142c41f6605d83eab9196d0966d229b7e4b9d888f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.237676+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "9b36a85bbb182f41b4f73cff1ccbbe30df9a5ae17c7f0b132383bd24a3bbb15c", + "panel_kind": "isotropic", + "panel_seed": 622580746501599869, + "realization": 18, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b3706b2e2ccd4815369181db04843112d0acb2d658f6d2e5bb3c6570ae076f91", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.36467483176070276, + "kernel_residual": 1.0386781587823134e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.214882039991057, + "minus_external_entropy": 0.9744638323531402, + "minus_target_effective_rank": 29.985956196646086, + "minus_target_entropy": 0.897520556143872, + "minus_weight": 54.809459741110025, + "orthogonality_relative_error": 2.1831656198081942e-16, + "plus_external_effective_rank": 7.214882039991063, + "plus_external_entropy": 0.9744638323531402, + "plus_target_effective_rank": 29.98595619664609, + "plus_target_entropy": 0.8975205561438719, + "plus_weight": 54.80945974111003, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "0acc97a206b04006078089414aae89dd4fc6cf4bd4420512d2fe544aeaa6454f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.352081+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "09f15469555cc7e4e1bffff509700e835f0b8a5eb951237bd156ce1268e12ccb", + "panel_kind": "sparse", + "panel_seed": 16172746946472565369, + "realization": 19, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fab2ed461be8b6a06f65d86ef0d5272094faf7c864e2b899f2bc395e67547e45", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3639732936604348, + "kernel_residual": 1.0632504847169535e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.619571016737808, + "minus_external_entropy": 0.9511091536033534, + "minus_target_effective_rank": 25.450453719703358, + "minus_target_entropy": 0.9556164818907078, + "minus_weight": 56.068951100572775, + "orthogonality_relative_error": 1.9384798905447985e-16, + "plus_external_effective_rank": 6.619571016737814, + "plus_external_entropy": 0.9511091536033535, + "plus_target_effective_rank": 25.450453719703365, + "plus_target_entropy": 0.955616481890708, + "plus_weight": 56.06895110057279, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "499f6a8d05c79a8af689ab5b5c46b28fd38d2647414bf71bb5c4a7ee5538448c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.448531+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "09f15469555cc7e4e1bffff509700e835f0b8a5eb951237bd156ce1268e12ccb", + "panel_kind": "isotropic", + "panel_seed": 16172746946472565369, + "realization": 19, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5408520dd26b3531ece3b258e638ce4695cdb4a6c4fe1303694ae8d871154617", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3639732936604348, + "kernel_residual": 1.0632504847169535e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.189527903155194, + "minus_external_entropy": 0.9740268775523667, + "minus_target_effective_rank": 30.031048873865327, + "minus_target_entropy": 0.8978962169027865, + "minus_weight": 53.87570325459101, + "orthogonality_relative_error": 1.833895532555839e-16, + "plus_external_effective_rank": 7.189527903155197, + "plus_external_entropy": 0.9740268775523665, + "plus_target_effective_rank": 30.031048873865313, + "plus_target_entropy": 0.8978962169027869, + "plus_weight": 53.875703254591016, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "04714bbecf000656e715dc4294ddd027a27ee3e1d33285286c1435c84db2e4c7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.550219+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "f6ba4c43d01ef1839c9630955525484d721d20209cb60465340abf45e1d89666", + "panel_kind": "sparse", + "panel_seed": 5540539657471232395, + "realization": 20, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bb5e1dbbbb318df4262f140d85d278ff638a3ddedcda8397abc073ea369d61bc", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3244728598802648, + "kernel_residual": 9.407458251891029e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.929364488134903, + "minus_external_entropy": 0.9627010026577951, + "minus_target_effective_rank": 22.478892405357197, + "minus_target_entropy": 0.9427159118133448, + "minus_weight": 55.203370794892265, + "orthogonality_relative_error": 3.039417807978112e-16, + "plus_external_effective_rank": 6.929364488134904, + "plus_external_entropy": 0.9627010026577951, + "plus_target_effective_rank": 22.478892405357204, + "plus_target_entropy": 0.9427159118133448, + "plus_weight": 55.20337079489224, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "75844a61e9eefb3e6f870a8afc15d1b33638d0d73e9a3931fae7ea7b408c5848", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.645250+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "f6ba4c43d01ef1839c9630955525484d721d20209cb60465340abf45e1d89666", + "panel_kind": "isotropic", + "panel_seed": 5540539657471232395, + "realization": 20, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0b032c5b4ca77ee0a46f3a740785d041049836b9275a0ddabc14bc269a734b32", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3244728598802648, + "kernel_residual": 9.407458251891029e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.051283209121562, + "minus_external_entropy": 0.9697831021028197, + "minus_target_effective_rank": 30.07273987122339, + "minus_target_entropy": 0.8981434364970106, + "minus_weight": 56.358298619668965, + "orthogonality_relative_error": 3.057300715123277e-16, + "plus_external_effective_rank": 7.051283209121557, + "plus_external_entropy": 0.9697831021028197, + "plus_target_effective_rank": 30.072739871223398, + "plus_target_entropy": 0.8981434364970105, + "plus_weight": 56.35829861966894, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e092121d5859365fa8bc87a75bd55cd73036baa5ff90241bafc46501cd2df3b0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.750515+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1f4b834cf57626d755bb1f69c8ad2059bf6a8be20f59ec1bc024123a0076cbe2", + "panel_kind": "sparse", + "panel_seed": 16946374520226682116, + "realization": 21, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d232b39e0147d7492b3e6f60190c618085e6ecab1849f4b9857c50af1b52f505", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3256173514314861, + "kernel_residual": 9.50350977361131e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.806950625321102, + "minus_external_entropy": 0.9583331848942838, + "minus_target_effective_rank": 26.13641564920246, + "minus_target_entropy": 0.9559825994069976, + "minus_weight": 55.83609498504461, + "orthogonality_relative_error": 2.5518146647645507e-16, + "plus_external_effective_rank": 6.806950625321111, + "plus_external_entropy": 0.9583331848942839, + "plus_target_effective_rank": 26.136415649202466, + "plus_target_entropy": 0.9559825994069976, + "plus_weight": 55.83609498504458, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "c4098af0099fb03b82f6d38c87152a31d3b58f8ab60ab3b4b27782d6ff48af45", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.852936+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1f4b834cf57626d755bb1f69c8ad2059bf6a8be20f59ec1bc024123a0076cbe2", + "panel_kind": "isotropic", + "panel_seed": 16946374520226682116, + "realization": 21, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "813001233852e78f724d4ca489d4e42a4f9c6849c8bc4ea71621b73a9d94e9c4", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3256173514314861, + "kernel_residual": 9.50350977361131e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.333746607057441, + "minus_external_entropy": 0.9784616059461421, + "minus_target_effective_rank": 30.327723658459107, + "minus_target_entropy": 0.9013787974282578, + "minus_weight": 54.47148138217524, + "orthogonality_relative_error": 2.3576059776174464e-16, + "plus_external_effective_rank": 7.333746607057445, + "plus_external_entropy": 0.9784616059461423, + "plus_target_effective_rank": 30.32772365845911, + "plus_target_entropy": 0.9013787974282574, + "plus_weight": 54.4714813821752, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "b61c2cd2010f79e2b2eace82d07371521ca3e535274748d629f80f7dadb834e6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.955835+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ad47ea67ec2dc161c71979c4508c6b8415392cdde686cbf70ab1f00f6ad3b647", + "panel_kind": "sparse", + "panel_seed": 15809535641976001134, + "realization": 22, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bfbb25f60f718b2501fe4a5160dfd4d627e0abb12ad63fe664cbd65ba8abe23a", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30986919042010436, + "kernel_residual": 1.0123367091694878e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.587077273429888, + "minus_external_entropy": 0.9484205332326614, + "minus_target_effective_rank": 23.238803991953258, + "minus_target_entropy": 0.952708837452199, + "minus_weight": 57.18774589447265, + "orthogonality_relative_error": 2.677733649619349e-16, + "plus_external_effective_rank": 6.58707727342989, + "plus_external_entropy": 0.9484205332326616, + "plus_target_effective_rank": 23.238803991953258, + "plus_target_entropy": 0.9527088374521989, + "plus_weight": 57.18774589447262, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "db0971432929aac8e65b269a0f6ea8ca4bc6dbc352fb2a245a1109abcf40915e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.055639+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ad47ea67ec2dc161c71979c4508c6b8415392cdde686cbf70ab1f00f6ad3b647", + "panel_kind": "isotropic", + "panel_seed": 15809535641976001134, + "realization": 22, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1c38caf6bdcdbcbfcf0422d358fcc45f6217dd924d163d85547068e38618daad", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30986919042010436, + "kernel_residual": 1.0123367091694878e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.953395456316699, + "minus_external_entropy": 0.9661413834524765, + "minus_target_effective_rank": 29.43285809317356, + "minus_target_entropy": 0.8954777469766684, + "minus_weight": 56.275948972773406, + "orthogonality_relative_error": 2.507981403042116e-16, + "plus_external_effective_rank": 6.953395456316699, + "plus_external_entropy": 0.9661413834524765, + "plus_target_effective_rank": 29.432858093173564, + "plus_target_entropy": 0.8954777469766683, + "plus_weight": 56.27594897277339, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "20185b89af6115708b6c1ede61fc881028e6a783cb240ec21975dfa18cfacb3a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.161066+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "50624b1c15a23c087fb2c008bbf64bb31cdbf13d8e94156136cef531483eddc0", + "panel_kind": "sparse", + "panel_seed": 8116430984451738068, + "realization": 23, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c549b79ab9743ed693b4c5d79b0752aac2ff207235ce5752b796b0759cc70865", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30827320414910325, + "kernel_residual": 9.849714978598212e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.462984184714906, + "minus_external_entropy": 0.9439422287025737, + "minus_target_effective_rank": 23.867228141256188, + "minus_target_entropy": 0.9566473794064457, + "minus_weight": 57.38910937885127, + "orthogonality_relative_error": 1.6247538563667677e-16, + "plus_external_effective_rank": 6.4629841847149, + "plus_external_entropy": 0.9439422287025737, + "plus_target_effective_rank": 23.86722814125618, + "plus_target_entropy": 0.9566473794064457, + "plus_weight": 57.38910937885122, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6d0dc6d3480356b0e05e547331beb8ce860e8979c0a2279425a31025dffe8c7f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.255364+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "50624b1c15a23c087fb2c008bbf64bb31cdbf13d8e94156136cef531483eddc0", + "panel_kind": "isotropic", + "panel_seed": 8116430984451738068, + "realization": 23, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ad9a9a7aecf14fd7eb19cba079c8dbfa6cb631e6cabd9c4bafd3195c4b9b0c53", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30827320414910325, + "kernel_residual": 9.849714978598212e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.970271497186878, + "minus_external_entropy": 0.9668914868399983, + "minus_target_effective_rank": 29.355532511773198, + "minus_target_entropy": 0.8946601411405826, + "minus_weight": 57.123947326327055, + "orthogonality_relative_error": 1.7226355697116568e-16, + "plus_external_effective_rank": 6.970271497186873, + "plus_external_entropy": 0.966891486839998, + "plus_target_effective_rank": 29.355532511773177, + "plus_target_entropy": 0.8946601411405827, + "plus_weight": 57.123947326327, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "541498a18bd55a92032faa2a60ed3ef594536d5fbb933c2952316fbc65f3b8ca", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.361451+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "dac09ff86e4a52d94f465bc2b4fc5ff902a0eddecd26766b332268a2a748fc67", + "panel_kind": "sparse", + "panel_seed": 14739918944425602917, + "realization": 24, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "102a7b5a8cf8241ec6a383a2b757e3a32f33a54943769691e9c0bf102d6866fc", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.38160785604973996, + "kernel_residual": 9.63853253039875e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.283306584373373, + "minus_external_entropy": 0.9763549443690889, + "minus_target_effective_rank": 26.23515094793627, + "minus_target_entropy": 0.956839044374354, + "minus_weight": 54.244006009406704, + "orthogonality_relative_error": 2.3517975798052713e-16, + "plus_external_effective_rank": 7.283306584373369, + "plus_external_entropy": 0.9763549443690887, + "plus_target_effective_rank": 26.235150947936283, + "plus_target_entropy": 0.9568390443743541, + "plus_weight": 54.2440060094067, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "318dc9a4b4cc7a0c2c9285cdf5fe5669612943d0ddefec8a982c3801fe806b8a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.453278+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "dac09ff86e4a52d94f465bc2b4fc5ff902a0eddecd26766b332268a2a748fc67", + "panel_kind": "isotropic", + "panel_seed": 14739918944425602917, + "realization": 24, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9c6f6aeb9d395e4244c70e0f81dc8c86afa30e14f10d9d9232ed9261b30a3dcb", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.38160785604973996, + "kernel_residual": 9.63853253039875e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.216059044277745, + "minus_external_entropy": 0.9754945886881625, + "minus_target_effective_rank": 30.240401713791034, + "minus_target_entropy": 0.898118316750212, + "minus_weight": 53.71555780614533, + "orthogonality_relative_error": 2.306742295333721e-16, + "plus_external_effective_rank": 7.216059044277746, + "plus_external_entropy": 0.9754945886881625, + "plus_target_effective_rank": 30.24040171379106, + "plus_target_entropy": 0.8981183167502118, + "plus_weight": 53.7155578061453, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "974988727bb4cac7281afc02537cf4a4a4d018aec5f6b4e38b6ee1e82d796c3a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.579023+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "2c8c2f939063699f5c1df6114cccb0a51508192c538ed8dcaaa9635d842ab6ed", + "panel_kind": "sparse", + "panel_seed": 6321806154450624549, + "realization": 25, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "da67545ed329fa6ae48f1aedbe18e42fbb77ea7da4ab22e2a718bd8305e8ee22", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29979471995585666, + "kernel_residual": 9.670092073460438e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.7997945404414875, + "minus_external_entropy": 0.9581759489203823, + "minus_target_effective_rank": 22.433299045179627, + "minus_target_entropy": 0.943323712186164, + "minus_weight": 56.39789698971573, + "orthogonality_relative_error": 2.1283442078749752e-16, + "plus_external_effective_rank": 6.7997945404414875, + "plus_external_entropy": 0.9581759489203823, + "plus_target_effective_rank": 22.433299045179645, + "plus_target_entropy": 0.9433237121861638, + "plus_weight": 56.39789698971566, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "d0e8c07c1594f2c45070784590146ef3b649c0a504f0607e2484fd12c862ba8d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.839946+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "2c8c2f939063699f5c1df6114cccb0a51508192c538ed8dcaaa9635d842ab6ed", + "panel_kind": "isotropic", + "panel_seed": 6321806154450624549, + "realization": 25, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "09e68b88a8ac28bc7e165fb07bd559b21c34c2b7f42481dfa8c1abf964d4116a", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29979471995585666, + "kernel_residual": 9.670092073460438e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.885816580265418, + "minus_external_entropy": 0.9640634308805521, + "minus_target_effective_rank": 29.533145998207715, + "minus_target_entropy": 0.8965102879536299, + "minus_weight": 58.69226125148619, + "orthogonality_relative_error": 2.2066581352936303e-16, + "plus_external_effective_rank": 6.885816580265425, + "plus_external_entropy": 0.9640634308805521, + "plus_target_effective_rank": 29.53314599820773, + "plus_target_entropy": 0.8965102879536299, + "plus_weight": 58.692261251486116, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "c90c8ab1afd03ad7aebd9fecfd7c882b2912339120de226d28af92d1cfb3b9dd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.989466+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "cbbd7aafbf2d4c57a1b368505aabf51df47c4853343daf224d0ff34f4fd0f1f8", + "panel_kind": "sparse", + "panel_seed": 7966195206646712476, + "realization": 26, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "29606c1c51fd9f7100c5bcab7e69e0aa27a34e65c8291d71c72413735c73b781", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.33866533266258375, + "kernel_residual": 1.0539201552076208e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.56147001874957, + "minus_external_entropy": 0.9498048691654616, + "minus_target_effective_rank": 24.60835995546224, + "minus_target_entropy": 0.9536819186955936, + "minus_weight": 57.067787179177806, + "orthogonality_relative_error": 1.8954971828459144e-16, + "plus_external_effective_rank": 6.56147001874957, + "plus_external_entropy": 0.9498048691654617, + "plus_target_effective_rank": 24.608359955462245, + "plus_target_entropy": 0.9536819186955937, + "plus_weight": 57.06778717917782, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "84d39b2078fdc152ec7f2250b9f78b504b76f723da45f1f4b01084c64181faf2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.114056+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "cbbd7aafbf2d4c57a1b368505aabf51df47c4853343daf224d0ff34f4fd0f1f8", + "panel_kind": "isotropic", + "panel_seed": 7966195206646712476, + "realization": 26, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "887dfd64ee4e4c85d849c8aa88f8d10cb3042443504f1dbe70c7775d06613870", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.33866533266258375, + "kernel_residual": 1.0539201552076208e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.159074505447569, + "minus_external_entropy": 0.9732444511630691, + "minus_target_effective_rank": 29.96549648171596, + "minus_target_entropy": 0.8983986702102298, + "minus_weight": 54.699265763729315, + "orthogonality_relative_error": 1.7827109472184285e-16, + "plus_external_effective_rank": 7.159074505447571, + "plus_external_entropy": 0.9732444511630693, + "plus_target_effective_rank": 29.96549648171594, + "plus_target_entropy": 0.8983986702102298, + "plus_weight": 54.69926576372932, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "b6c703858b515bb49a1c38c0978a5447f2c1599f1904e8a0338af40377b6d3a9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.260249+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ebbc38daf2bfbdb5126b4855b63cba7b17c9dd591e4e58dd6402b15f569a4a5b", + "panel_kind": "sparse", + "panel_seed": 11394658273627970405, + "realization": 27, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "daa7c7362e3bff876dcc9fef301290585184ed12b2ce341a03275e3c7a217da4", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.32289944392036246, + "kernel_residual": 1.0300460319996752e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.664750618876657, + "minus_external_entropy": 0.9532428859395412, + "minus_target_effective_rank": 25.21077788042547, + "minus_target_entropy": 0.9513517033132246, + "minus_weight": 57.563946071058226, + "orthogonality_relative_error": 2.1777000068544e-16, + "plus_external_effective_rank": 6.664750618876659, + "plus_external_entropy": 0.9532428859395414, + "plus_target_effective_rank": 25.210777880425464, + "plus_target_entropy": 0.9513517033132247, + "plus_weight": 57.56394607105818, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "92dccfb73e8a0fd1184505fea195c19515710e1e8751f3125558f4a63a3514cf", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.390785+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ebbc38daf2bfbdb5126b4855b63cba7b17c9dd591e4e58dd6402b15f569a4a5b", + "panel_kind": "isotropic", + "panel_seed": 11394658273627970405, + "realization": 27, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cad35ef10a6379632b10c4c69500ec4b05e6c0db3ffa490d4982e7b8f39dcd0e", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.32289944392036246, + "kernel_residual": 1.0300460319996752e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.784413467769765, + "minus_external_entropy": 0.9591187595158003, + "minus_target_effective_rank": 29.708832397312545, + "minus_target_entropy": 0.8965227073033837, + "minus_weight": 58.877181237642304, + "orthogonality_relative_error": 2.293908320794218e-16, + "plus_external_effective_rank": 6.78441346776977, + "plus_external_entropy": 0.9591187595158004, + "plus_target_effective_rank": 29.708832397312563, + "plus_target_entropy": 0.8965227073033838, + "plus_weight": 58.87718123764225, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "21042ec2cb2d9959d24f571b6c5c42856440c35f3bcd8035b7e1d73ea64b7ed6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.498433+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ec274c92b9bb10ec83879700645a13394cbae1dede7841f9682dbcbd195f8200", + "panel_kind": "sparse", + "panel_seed": 9042812720163572080, + "realization": 28, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "229fad1d585c7209c6f0e925d33de1cd58d48f8949240f7b7e2c30406d14ee11", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3404279332917626, + "kernel_residual": 9.433101655659557e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.85285732327501, + "minus_external_entropy": 0.9632991902487493, + "minus_target_effective_rank": 23.21672839004285, + "minus_target_entropy": 0.949963318737306, + "minus_weight": 54.79014854355606, + "orthogonality_relative_error": 2.1666361177310027e-16, + "plus_external_effective_rank": 6.852857323275006, + "plus_external_entropy": 0.9632991902487491, + "plus_target_effective_rank": 23.216728390042856, + "plus_target_entropy": 0.949963318737306, + "plus_weight": 54.79014854355605, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "f15c38ab0e114518ce37376dbd550077d8404a537daa8e534de691937c889481", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.594153+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ec274c92b9bb10ec83879700645a13394cbae1dede7841f9682dbcbd195f8200", + "panel_kind": "isotropic", + "panel_seed": 9042812720163572080, + "realization": 28, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4ea4e9f09625ffd626dafcfd9b2b66ef95f22c8bc4c0effc89bcb13b8e4e5144", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3404279332917626, + "kernel_residual": 9.433101655659557e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.119514074332493, + "minus_external_entropy": 0.971397728435147, + "minus_target_effective_rank": 29.240080235047376, + "minus_target_entropy": 0.8939193137952118, + "minus_weight": 53.967584713980024, + "orthogonality_relative_error": 2.1894556343706477e-16, + "plus_external_effective_rank": 7.119514074332488, + "plus_external_entropy": 0.971397728435147, + "plus_target_effective_rank": 29.24008023504738, + "plus_target_entropy": 0.893919313795212, + "plus_weight": 53.96758471398, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "fdeeee7f5ccf1a87b25aac14bfa6cbcae14fa7f901a9bddc570a65a4d9b28103", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.695111+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "7e93f60ea948564d250e48bc09a6f369f8acf30c300fe0bc2b9c636ced22d7aa", + "panel_kind": "sparse", + "panel_seed": 10958938296146392478, + "realization": 29, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d43c52edf02b41ab1ee1291cb9754627bf8b2f3b595806756549fe4223471f67", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3598470945259208, + "kernel_residual": 1.0584930635392341e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.013563037284025, + "minus_external_entropy": 0.9676451416024788, + "minus_target_effective_rank": 24.47906218971633, + "minus_target_entropy": 0.953243517861783, + "minus_weight": 53.57159806341478, + "orthogonality_relative_error": 1.8539661394525442e-16, + "plus_external_effective_rank": 7.013563037284024, + "plus_external_entropy": 0.9676451416024788, + "plus_target_effective_rank": 24.47906218971633, + "plus_target_entropy": 0.9532435178617829, + "plus_weight": 53.57159806341477, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e06e9f7199d03b8a23e39c49ebcf45ba826d4087d40d3f84bddbacbcddf005c7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.792127+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "7e93f60ea948564d250e48bc09a6f369f8acf30c300fe0bc2b9c636ced22d7aa", + "panel_kind": "isotropic", + "panel_seed": 10958938296146392478, + "realization": 29, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "31cdc098c420f51cfbdac6201d7a0336c74337a7ea131ba79104e07f58b7953c", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3598470945259208, + "kernel_residual": 1.0584930635392341e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.246473202778986, + "minus_external_entropy": 0.9759006858000643, + "minus_target_effective_rank": 29.936972193847655, + "minus_target_entropy": 0.8991417695056881, + "minus_weight": 54.096881278268775, + "orthogonality_relative_error": 1.857434131709718e-16, + "plus_external_effective_rank": 7.246473202778989, + "plus_external_entropy": 0.9759006858000643, + "plus_target_effective_rank": 29.93697219384764, + "plus_target_entropy": 0.8991417695056885, + "plus_weight": 54.09688127826877, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "4e66453baaaa30f4a1035ac9c99529e3f4e82e5bac94cf4834d72740f3b0f5b7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.896475+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "3aba1be75624e0355f89c1458fedab1df8dc58c36854e23abb5dc242433d2c91", + "panel_kind": "sparse", + "panel_seed": 7986912027498248804, + "realization": 30, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "127663c6267c8479fff5cf18cda74ed85b19a1278732c17aa7f09a340b63e0fc", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.38318743182948967, + "kernel_residual": 9.667836133374428e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.991776554968171, + "minus_external_entropy": 0.9657611053144289, + "minus_target_effective_rank": 26.541114620927033, + "minus_target_entropy": 0.9533859635319265, + "minus_weight": 54.4370810401108, + "orthogonality_relative_error": 1.8164526240520933e-16, + "plus_external_effective_rank": 6.991776554968174, + "plus_external_entropy": 0.9657611053144289, + "plus_target_effective_rank": 26.54111462092704, + "plus_target_entropy": 0.9533859635319266, + "plus_weight": 54.43708104011078, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e93545052979047148451cd3894edad5616b9bb61426d81d0a412e4931892704", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.994878+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "3aba1be75624e0355f89c1458fedab1df8dc58c36854e23abb5dc242433d2c91", + "panel_kind": "isotropic", + "panel_seed": 7986912027498248804, + "realization": 30, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "07827654afd52afa464a0b114da96f3e904eaafbf33e9ec1837233f6fc406318", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.38318743182948967, + "kernel_residual": 9.667836133374428e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.283955350937265, + "minus_external_entropy": 0.976785283818127, + "minus_target_effective_rank": 30.229044370289436, + "minus_target_entropy": 0.8983713675960224, + "minus_weight": 54.014785459992304, + "orthogonality_relative_error": 1.7483999274340416e-16, + "plus_external_effective_rank": 7.2839553509372665, + "plus_external_entropy": 0.9767852838181275, + "plus_target_effective_rank": 30.229044370289436, + "plus_target_entropy": 0.8983713675960225, + "plus_weight": 54.01478545999228, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "7bcda4e247bf2f3ceb0dc57a7950ab548400476ed09a99224c5ee82572f13b69", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.096428+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "3203598425d2a947878200869618b38c6430e5c9ea176ab6ae2c5c8bc952c8cd", + "panel_kind": "sparse", + "panel_seed": 12501857984869979477, + "realization": 31, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "99087350aae32ab453e78da78663c7b96df7984dcb40bf97e232994410fb9447", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2906922695429446, + "kernel_residual": 1.0254795133629593e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.8555509512312796, + "minus_external_entropy": 0.9620617551710268, + "minus_target_effective_rank": 24.841145050902007, + "minus_target_entropy": 0.9480116043061866, + "minus_weight": 55.02866757902368, + "orthogonality_relative_error": 2.0100948870658936e-16, + "plus_external_effective_rank": 6.855550951231281, + "plus_external_entropy": 0.962061755171027, + "plus_target_effective_rank": 24.84114505090202, + "plus_target_entropy": 0.9480116043061866, + "plus_weight": 55.02866757902368, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "8e33c9ae03fc42b1d5e14657c822f958bdc7f538654fb9f0eac8c30b5221f8d5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.192426+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "3203598425d2a947878200869618b38c6430e5c9ea176ab6ae2c5c8bc952c8cd", + "panel_kind": "isotropic", + "panel_seed": 12501857984869979477, + "realization": 31, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c1ba4601896b1c8ae35fa607febfe91baedcc25fbd09fe20e595269a9656c6a5", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2906922695429446, + "kernel_residual": 1.0254795133629593e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.78770411346349, + "minus_external_entropy": 0.9621472452041426, + "minus_target_effective_rank": 29.704891766572917, + "minus_target_entropy": 0.8967961675234425, + "minus_weight": 56.22996340538977, + "orthogonality_relative_error": 2.0175798473637335e-16, + "plus_external_effective_rank": 6.787704113463491, + "plus_external_entropy": 0.9621472452041429, + "plus_target_effective_rank": 29.704891766572928, + "plus_target_entropy": 0.8967961675234426, + "plus_weight": 56.22996340538977, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "b9244576e116d112df1c9311a60b07511b83738a4adc6ea35bc9e8e518c0b3a0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.292167+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "6aa217218edd6c8ce9d5d74a89f887b0dde41e0a6749def0879f19a37eecf9af", + "panel_kind": "sparse", + "panel_seed": 16513817055896311692, + "realization": 32, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bedaa715c7211832d4140896f9b54f37d7ba1c96608aaa7e7b948ef8ddf69b12", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3094892051983197, + "kernel_residual": 9.571582478148274e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.485388646573045, + "minus_external_entropy": 0.9449110015556752, + "minus_target_effective_rank": 22.730974498840343, + "minus_target_entropy": 0.9470396478371055, + "minus_weight": 57.670642098735556, + "orthogonality_relative_error": 1.886127107248666e-16, + "plus_external_effective_rank": 6.4853886465730435, + "plus_external_entropy": 0.9449110015556753, + "plus_target_effective_rank": 22.730974498840332, + "plus_target_entropy": 0.9470396478371055, + "plus_weight": 57.67064209873553, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "930a9a03fc64afc2270fdbb80af2ca2e9fe96d1d22b96a4a21c7ffb42f99245e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.389100+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "6aa217218edd6c8ce9d5d74a89f887b0dde41e0a6749def0879f19a37eecf9af", + "panel_kind": "isotropic", + "panel_seed": 16513817055896311692, + "realization": 32, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2be3060d054dde43a96627304ceb07c9ef6e1a8e62234f3af4a916830c2c716b", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3094892051983197, + "kernel_residual": 9.571582478148274e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.944377793841251, + "minus_external_entropy": 0.9655730501560504, + "minus_target_effective_rank": 30.503180412690828, + "minus_target_entropy": 0.9019969219136621, + "minus_weight": 57.187912464411085, + "orthogonality_relative_error": 1.8319530067921874e-16, + "plus_external_effective_rank": 6.944377793841245, + "plus_external_entropy": 0.9655730501560502, + "plus_target_effective_rank": 30.503180412690817, + "plus_target_entropy": 0.9019969219136621, + "plus_weight": 57.18791246441107, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "4f2879498d46e1265dad2aa98901265d3b258050de55fcc161ee8a2d93ceb7d6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.489987+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "fe90d9c5497a6956f5a099cca03ec90432a301eac4e11b4c7d39fc2cdf8dcb03", + "panel_kind": "sparse", + "panel_seed": 11537612185872519621, + "realization": 33, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fa4ed1261f8218a7b2fc293b18aac9ad23b03e51e2b63b82933baa37519306ad", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.28800300960871456, + "kernel_residual": 9.54194665260879e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.480735237427451, + "minus_external_entropy": 0.9486346767640781, + "minus_target_effective_rank": 26.176844532412524, + "minus_target_entropy": 0.9513852849657861, + "minus_weight": 59.163277969098296, + "orthogonality_relative_error": 1.8419313807928227e-16, + "plus_external_effective_rank": 6.480735237427451, + "plus_external_entropy": 0.9486346767640781, + "plus_target_effective_rank": 26.17684453241252, + "plus_target_entropy": 0.9513852849657861, + "plus_weight": 59.16327796909827, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "328f5916ca9636b41215a86eb6642951e553616417e02eb021db2bf8c7e6ba47", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.582968+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "fe90d9c5497a6956f5a099cca03ec90432a301eac4e11b4c7d39fc2cdf8dcb03", + "panel_kind": "isotropic", + "panel_seed": 11537612185872519621, + "realization": 33, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "46f35464e3281402b34132520569ae2f39d75dfbad2499d7e656f222a43f3d9d", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.28800300960871456, + "kernel_residual": 9.54194665260879e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.752180363423046, + "minus_external_entropy": 0.9598981117372392, + "minus_target_effective_rank": 29.56763888463111, + "minus_target_entropy": 0.8966046512869547, + "minus_weight": 58.333106889303124, + "orthogonality_relative_error": 1.7233786265418592e-16, + "plus_external_effective_rank": 6.7521803634230455, + "plus_external_entropy": 0.9598981117372392, + "plus_target_effective_rank": 29.567638884631105, + "plus_target_entropy": 0.8966046512869544, + "plus_weight": 58.3331068893031, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "98ef205d959fa8f2fcfa2e2ab5be76adcd07a215f1acad1d4858cd036d382b05", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.680531+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "706b4b19bdcb64d2dbcdb283938c7cf0aaead7aedc3fb067a761c611a5eafa44", + "panel_kind": "sparse", + "panel_seed": 5932467768474802875, + "realization": 34, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "793c172fa0aa333a8edb325866a37496a9e74f09c0e3947e68414b40f934a3ad", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3296070557545598, + "kernel_residual": 1.0190851948106087e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.014604091754885, + "minus_external_entropy": 0.9675060369570181, + "minus_target_effective_rank": 25.331000412935047, + "minus_target_entropy": 0.9497810147195094, + "minus_weight": 54.829896468343975, + "orthogonality_relative_error": 1.911824222776462e-16, + "plus_external_effective_rank": 7.014604091754888, + "plus_external_entropy": 0.9675060369570181, + "plus_target_effective_rank": 25.33100041293505, + "plus_target_entropy": 0.9497810147195097, + "plus_weight": 54.829896468343975, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "4d1f498d4690bd5b5f46d052962e33f8c7baa8c700b25a5a3b293cc2402b08ba", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.774509+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "706b4b19bdcb64d2dbcdb283938c7cf0aaead7aedc3fb067a761c611a5eafa44", + "panel_kind": "isotropic", + "panel_seed": 5932467768474802875, + "realization": 34, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a17b4041c51764c0265b287474e351e0f197f5e615ef116437be92870a50adff", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3296070557545598, + "kernel_residual": 1.0190851948106087e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.126685116255177, + "minus_external_entropy": 0.971995290132715, + "minus_target_effective_rank": 30.20235325342857, + "minus_target_entropy": 0.8996578538336064, + "minus_weight": 54.86004056231948, + "orthogonality_relative_error": 1.9244187144372721e-16, + "plus_external_effective_rank": 7.126685116255176, + "plus_external_entropy": 0.971995290132715, + "plus_target_effective_rank": 30.202353253428587, + "plus_target_entropy": 0.8996578538336064, + "plus_weight": 54.86004056231948, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "c213e7646d04a9e9621eeae2891391170c3c39e5012208305b1e9490c0eed6a4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.875029+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "689b8a2717cda9822652e11baf524c086f9d1d9ce289ff90ec750b9bb812abe7", + "panel_kind": "sparse", + "panel_seed": 2060376366639230205, + "realization": 35, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "36d9802d3df795571b3850ed72f0efff53bab0b8ad6ef2c671af160dce6e625f", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31561879797412823, + "kernel_residual": 9.91319921545497e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.239994061139465, + "minus_external_entropy": 0.9349735904940323, + "minus_target_effective_rank": 21.97310778263433, + "minus_target_entropy": 0.9464727576762568, + "minus_weight": 56.000891731785885, + "orthogonality_relative_error": 2.0838200585328605e-16, + "plus_external_effective_rank": 6.239994061139471, + "plus_external_entropy": 0.9349735904940323, + "plus_target_effective_rank": 21.97310778263433, + "plus_target_entropy": 0.9464727576762568, + "plus_weight": 56.0008917317859, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "8322d6bcfb43c74f80042996a900a22446134af16d477f393a0fc5c12968787a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.968063+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "689b8a2717cda9822652e11baf524c086f9d1d9ce289ff90ec750b9bb812abe7", + "panel_kind": "isotropic", + "panel_seed": 2060376366639230205, + "realization": 35, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4f1f0677c1d140227634b4e3972a10f5af1aa786788a0d409e4f09af7e4a197a", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31561879797412823, + "kernel_residual": 9.91319921545497e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.226221162393649, + "minus_external_entropy": 0.9754682627559782, + "minus_target_effective_rank": 30.026577925169082, + "minus_target_entropy": 0.8988395349150938, + "minus_weight": 55.572750668693246, + "orthogonality_relative_error": 1.9382195832855033e-16, + "plus_external_effective_rank": 7.226221162393649, + "plus_external_entropy": 0.9754682627559782, + "plus_target_effective_rank": 30.026577925169075, + "plus_target_entropy": 0.8988395349150938, + "plus_weight": 55.57275066869325, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "5aebad281e1f4bc55657e498b0c839c0464f36909a9ecce0721ceb44e24ccb8c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.065420+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "58847d531085d0c3b71a51bbf7322e217d4aff12edd173fc0298b92fa9cd4fe5", + "panel_kind": "sparse", + "panel_seed": 10035671260458008558, + "realization": 36, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "78727cac71c9b1fb023f0b530b02f0aa5203943561e0f714ccd40c825562b895", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3718726479260771, + "kernel_residual": 9.229670490035076e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.033944168903004, + "minus_external_entropy": 0.9686309531923666, + "minus_target_effective_rank": 24.65465546989867, + "minus_target_entropy": 0.9497418499386084, + "minus_weight": 53.172371375223946, + "orthogonality_relative_error": 1.5712275345203328e-16, + "plus_external_effective_rank": 7.033944168903004, + "plus_external_entropy": 0.9686309531923666, + "plus_target_effective_rank": 24.654655469898657, + "plus_target_entropy": 0.9497418499386083, + "plus_weight": 53.17237137522396, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "fd82bd32128e1a2928aea90a8c51021bed40de3cea40220b183c7009d36b942d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.158392+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "58847d531085d0c3b71a51bbf7322e217d4aff12edd173fc0298b92fa9cd4fe5", + "panel_kind": "isotropic", + "panel_seed": 10035671260458008558, + "realization": 36, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f3ae23b70d802df70504c0887125c201499a069efd51eafcfe9c440540dcebfe", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3718726479260771, + "kernel_residual": 9.229670490035076e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.2594699154648055, + "minus_external_entropy": 0.9764334543970278, + "minus_target_effective_rank": 30.276045183894777, + "minus_target_entropy": 0.899261223420693, + "minus_weight": 54.61511167766331, + "orthogonality_relative_error": 1.5741200749543579e-16, + "plus_external_effective_rank": 7.259469915464804, + "plus_external_entropy": 0.9764334543970278, + "plus_target_effective_rank": 30.27604518389479, + "plus_target_entropy": 0.899261223420693, + "plus_weight": 54.615111677663336, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "1abdd39f7ec9877bdf358f56347847366fbdc003889b65153862d3c2a02c8e96", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.262631+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e3fd22b8bf27d37fcb5ea8de0847d06281a855c4579c651069dacaece9da02fb", + "panel_kind": "sparse", + "panel_seed": 10007530200759712625, + "realization": 37, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d8f009bcdad514a7565388e415c0154ad5f6bfec0d31268ba6f8a5be4cf70c5f", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2628086755093512, + "kernel_residual": 1.0536237340896794e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.473252835613785, + "minus_external_entropy": 0.9475396155662741, + "minus_target_effective_rank": 23.860442855347806, + "minus_target_entropy": 0.946270134666226, + "minus_weight": 61.22943378034046, + "orthogonality_relative_error": 2.1933138470290251e-16, + "plus_external_effective_rank": 6.473252835613789, + "plus_external_entropy": 0.9475396155662741, + "plus_target_effective_rank": 23.86044285534781, + "plus_target_entropy": 0.946270134666226, + "plus_weight": 61.22943378034045, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6982d42ebd7e895e903ceae9c5a18e0bb4680ad3472363fba9d7d53318022859", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.356227+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e3fd22b8bf27d37fcb5ea8de0847d06281a855c4579c651069dacaece9da02fb", + "panel_kind": "isotropic", + "panel_seed": 10007530200759712625, + "realization": 37, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "90be60453bf5f508f1db203edaa3ed214bfd85e2d998e32372e81175f84d475e", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2628086755093512, + "kernel_residual": 1.0536237340896794e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.5549124006378445, + "minus_external_entropy": 0.9519477947478338, + "minus_target_effective_rank": 28.537786473213412, + "minus_target_entropy": 0.8905832370982185, + "minus_weight": 58.97217598312726, + "orthogonality_relative_error": 2.2425459539475917e-16, + "plus_external_effective_rank": 6.5549124006378445, + "plus_external_entropy": 0.9519477947478338, + "plus_target_effective_rank": 28.537786473213416, + "plus_target_entropy": 0.8905832370982185, + "plus_weight": 58.972175983127244, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "bc22e64ef5751294acce8ee3761a597631c5dd236e2b6923cf1227e4e3a005a6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.455280+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "9d31ea86584f6ffb960e4cfbc7291e2fbe3d565924174ca37a397fb1a69fe473", + "panel_kind": "sparse", + "panel_seed": 18162057018034688398, + "realization": 38, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "84fc91637e5c216d28d559c80b4e8bd6721f94598a52864ca894dec00807e561", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31493110733768487, + "kernel_residual": 1.0063164460205464e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.576779504668236, + "minus_external_entropy": 0.9529394326411514, + "minus_target_effective_rank": 26.889273926966695, + "minus_target_entropy": 0.9560603225780195, + "minus_weight": 58.34041747254629, + "orthogonality_relative_error": 2.007440931175146e-16, + "plus_external_effective_rank": 6.5767795046682265, + "plus_external_entropy": 0.9529394326411511, + "plus_target_effective_rank": 26.88927392696668, + "plus_target_entropy": 0.9560603225780195, + "plus_weight": 58.34041747254628, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "d5805fc6bc1d01dc51c1d010deced78817ae3a8e0d25f4e81c16ac5c234080e0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.549323+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "9d31ea86584f6ffb960e4cfbc7291e2fbe3d565924174ca37a397fb1a69fe473", + "panel_kind": "isotropic", + "panel_seed": 18162057018034688398, + "realization": 38, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c33cd5f3e044396164a3d4488c78cb8da623861667e57a458de8c9a739c288d5", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31493110733768487, + "kernel_residual": 1.0063164460205464e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.7522378962569825, + "minus_external_entropy": 0.958132903128423, + "minus_target_effective_rank": 28.42852868812203, + "minus_target_entropy": 0.888189169265816, + "minus_weight": 57.85977411837008, + "orthogonality_relative_error": 1.9937029743936122e-16, + "plus_external_effective_rank": 6.752237896256982, + "plus_external_entropy": 0.9581329031284229, + "plus_target_effective_rank": 28.428528688122015, + "plus_target_entropy": 0.8881891692658161, + "plus_weight": 57.85977411837007, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "2b08e4c87feb76d284abd3ea465f9a56ec915672e4ecaafadb0c9b642808ac96", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.659652+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5c0b1804456d617c7b0b36d3ed57ba17e06169311b4adaa074d0aaf65d5dfe70", + "panel_kind": "sparse", + "panel_seed": 14002138720243123439, + "realization": 39, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "af6f465a74bf81f69767a0bf806d6af3debf15f1755b1cb7df07a8bec1c75b05", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31744035917676444, + "kernel_residual": 1.0066120846390991e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.691267669430957, + "minus_external_entropy": 0.9541282799315978, + "minus_target_effective_rank": 24.19988865444429, + "minus_target_entropy": 0.953823051514265, + "minus_weight": 56.531815199791566, + "orthogonality_relative_error": 2.4042824236784417e-16, + "plus_external_effective_rank": 6.691267669430962, + "plus_external_entropy": 0.9541282799315978, + "plus_target_effective_rank": 24.199888654444297, + "plus_target_entropy": 0.953823051514265, + "plus_weight": 56.53181519979159, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "8fd252b95597157523ff51e146874bdcf34fa5aa3da17ed1768adce6b954b1a4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.751872+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5c0b1804456d617c7b0b36d3ed57ba17e06169311b4adaa074d0aaf65d5dfe70", + "panel_kind": "isotropic", + "panel_seed": 14002138720243123439, + "realization": 39, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5a573f2c722cef05af8614ee07c91965c53f7c548378aea688ed6da991d84cec", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31744035917676444, + "kernel_residual": 1.0066120846390991e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.0017181258319585, + "minus_external_entropy": 0.967781393523791, + "minus_target_effective_rank": 29.408964718876682, + "minus_target_entropy": 0.8950909466505026, + "minus_weight": 56.112036929579965, + "orthogonality_relative_error": 2.3764759212657136e-16, + "plus_external_effective_rank": 7.001718125831962, + "plus_external_entropy": 0.9677813935237912, + "plus_target_effective_rank": 29.408964718876682, + "plus_target_entropy": 0.8950909466505028, + "plus_weight": 56.11203692957998, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "4cc38326448642bd5aeaeeb363d8aab74ac5a583e1828b796a81c0ea18e8ef37", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.847963+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "8837cae6b4bff6e47e557ff380b9ebc7ba13f6bc3a121359214a514ba10d1e29", + "panel_kind": "sparse", + "panel_seed": 2176011905066923166, + "realization": 40, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "91ee9d31a99da00494f65783c9c2fdf3deee83e2738b23737d1df8ccb4b4c1f8", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.33896986140901875, + "kernel_residual": 9.942673475188356e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.88012396292307, + "minus_external_entropy": 0.9628494155208677, + "minus_target_effective_rank": 24.734201615040647, + "minus_target_entropy": 0.9526138612343639, + "minus_weight": 55.63668214965021, + "orthogonality_relative_error": 1.7727189727592472e-16, + "plus_external_effective_rank": 6.88012396292307, + "plus_external_entropy": 0.9628494155208677, + "plus_target_effective_rank": 24.734201615040654, + "plus_target_entropy": 0.9526138612343639, + "plus_weight": 55.63668214965026, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "ce7d79c832b59c44a8ecc31c8557edb01132e9e402aa329b8307fc2506e0f421", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.941601+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "8837cae6b4bff6e47e557ff380b9ebc7ba13f6bc3a121359214a514ba10d1e29", + "panel_kind": "isotropic", + "panel_seed": 2176011905066923166, + "realization": 40, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a36b31e3fd55665e3422c9ae53e6eef84a51eef94fe88f645d27efb599f5820d", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.33896986140901875, + "kernel_residual": 9.942673475188356e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.1325981992313565, + "minus_external_entropy": 0.9722031377468915, + "minus_target_effective_rank": 29.738461933971614, + "minus_target_entropy": 0.8970015972675823, + "minus_weight": 55.21246162719649, + "orthogonality_relative_error": 1.7168642939465458e-16, + "plus_external_effective_rank": 7.132598199231357, + "plus_external_entropy": 0.9722031377468917, + "plus_target_effective_rank": 29.738461933971617, + "plus_target_entropy": 0.8970015972675824, + "plus_weight": 55.21246162719653, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "a93b35ab70bd15e1f0567dd291256755a5a19cbf273021bfe4c224f607a70ce9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.049036+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5229cc62f41dca6d23da0cc7eb354454153cd90013ccfc8ad29728bb88514a9d", + "panel_kind": "sparse", + "panel_seed": 9019764504221411957, + "realization": 41, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "11c86e86b399f77c22e9a1fd32cb9e1a3199a598e853f55ef23956daafdc113c", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29767999603067247, + "kernel_residual": 9.69295510912148e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.886694316291258, + "minus_external_entropy": 0.9628725639452493, + "minus_target_effective_rank": 25.328835268327484, + "minus_target_entropy": 0.948898575665054, + "minus_weight": 57.17803851085995, + "orthogonality_relative_error": 2.1758452162082337e-16, + "plus_external_effective_rank": 6.886694316291262, + "plus_external_entropy": 0.9628725639452493, + "plus_target_effective_rank": 25.32883526832748, + "plus_target_entropy": 0.9488985756650538, + "plus_weight": 57.17803851085993, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e85787e5f93ae8315f772eaea650b36ab8b81116de58ed9734c502b81b3e4ff2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.142455+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5229cc62f41dca6d23da0cc7eb354454153cd90013ccfc8ad29728bb88514a9d", + "panel_kind": "isotropic", + "panel_seed": 9019764504221411957, + "realization": 41, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fc2d5336260fce0f66af90e80d162ed066bc81a5559daf07713612dd1a1dbb5c", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29767999603067247, + "kernel_residual": 9.69295510912148e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.704237842186996, + "minus_external_entropy": 0.9562340474521045, + "minus_target_effective_rank": 29.2824248750556, + "minus_target_entropy": 0.8945662714382359, + "minus_weight": 57.40823767002261, + "orthogonality_relative_error": 2.139183160699574e-16, + "plus_external_effective_rank": 6.704237842186994, + "plus_external_entropy": 0.9562340474521046, + "plus_target_effective_rank": 29.282424875055582, + "plus_target_entropy": 0.8945662714382362, + "plus_weight": 57.40823767002261, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "3c1abac3a270abc916e3d1cf7af5150a952f467d1fbaf62d7fb5c6265a404c90", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.240741+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "69729fc7b7844cf761a98a20231beac11a853cc747491f072c8cbd7db2aabb3b", + "panel_kind": "sparse", + "panel_seed": 11404692286524372123, + "realization": 42, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "600cb8064a78cdff9251d86ac5afed5b966940f95b80817b2f04f7d62c474668", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3491985132570413, + "kernel_residual": 9.489137579945976e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.280948424645332, + "minus_external_entropy": 0.976887008953518, + "minus_target_effective_rank": 28.624995882548006, + "minus_target_entropy": 0.9634204475152863, + "minus_weight": 55.81525964919496, + "orthogonality_relative_error": 2.0179888879129936e-16, + "plus_external_effective_rank": 7.280948424645324, + "plus_external_entropy": 0.976887008953518, + "plus_target_effective_rank": 28.62499588254799, + "plus_target_entropy": 0.9634204475152862, + "plus_weight": 55.815259649194935, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "8ee3d66b653fa8f7c1e9a45e039e334bda24ec491e6634f699e32b1a3dc15a52", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.335503+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "69729fc7b7844cf761a98a20231beac11a853cc747491f072c8cbd7db2aabb3b", + "panel_kind": "isotropic", + "panel_seed": 11404692286524372123, + "realization": 42, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "70548c44fdd681ba10bdf75db4c39fac56e4d84a14e3f967499eb255dbbdea74", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3491985132570413, + "kernel_residual": 9.489137579945976e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.154594321065732, + "minus_external_entropy": 0.9725176002371483, + "minus_target_effective_rank": 30.210332739991422, + "minus_target_entropy": 0.8985448819412267, + "minus_weight": 55.8942116602843, + "orthogonality_relative_error": 2.051169468723342e-16, + "plus_external_effective_rank": 7.154594321065726, + "plus_external_entropy": 0.9725176002371483, + "plus_target_effective_rank": 30.210332739991397, + "plus_target_entropy": 0.8985448819412268, + "plus_weight": 55.89421166028427, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "d83f69873743c46d706fb39d51bb22c4acc4ff27cb1290b41d633a33edf49374", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.434947+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "8d621a755a43c304a4fdd3f1863a598716f4e9d3a62308d3402c79895e6c64df", + "panel_kind": "sparse", + "panel_seed": 17131408974406178594, + "realization": 43, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "205492b7c30bd7a4fc83e2cb47f4caa55f5cd2fd2051e29cb52a6346c956b0fe", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31529532270423544, + "kernel_residual": 9.760807453112064e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.302185467778656, + "minus_external_entropy": 0.9409490381877216, + "minus_target_effective_rank": 23.805268521054284, + "minus_target_entropy": 0.9503771054501253, + "minus_weight": 56.22700907061515, + "orthogonality_relative_error": 2.48316833603052e-16, + "plus_external_effective_rank": 6.302185467778644, + "plus_external_entropy": 0.9409490381877212, + "plus_target_effective_rank": 23.80526852105428, + "plus_target_entropy": 0.9503771054501252, + "plus_weight": 56.22700907061529, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "abf0f0623a75e7bc48201e1d651a672f9df587cf3ca8c60b80fe67f316268cf9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.528395+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "8d621a755a43c304a4fdd3f1863a598716f4e9d3a62308d3402c79895e6c64df", + "panel_kind": "isotropic", + "panel_seed": 17131408974406178594, + "realization": 43, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1e61eceefdd65358cb02320f2e58968fa0aab797d1d71b8e2a60bfb3284c518c", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31529532270423544, + "kernel_residual": 9.760807453112064e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.073443231669413, + "minus_external_entropy": 0.9708268042824649, + "minus_target_effective_rank": 29.96368882304039, + "minus_target_entropy": 0.8994473712897543, + "minus_weight": 56.23824225971234, + "orthogonality_relative_error": 2.5986440339869977e-16, + "plus_external_effective_rank": 7.073443231669402, + "plus_external_entropy": 0.9708268042824647, + "plus_target_effective_rank": 29.96368882304038, + "plus_target_entropy": 0.8994473712897542, + "plus_weight": 56.238242259712464, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "aebdd35145896b4a947382d0946ff300b00296acfd4482dc910e17dd9ed96bb9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.624547+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "a6f73763db08f9cdcc9be034428749201bf86800d7bc9ccfb30716216c74a1b7", + "panel_kind": "sparse", + "panel_seed": 10452910810935468794, + "realization": 44, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "34ac0d3d93584d44a3e11e8be4bbed4776d7b8a6a418221e3010dcd856779f31", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3593401167283206, + "kernel_residual": 1.0148475026771446e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.841054939915076, + "minus_external_entropy": 0.9623173215368862, + "minus_target_effective_rank": 24.154163793494487, + "minus_target_entropy": 0.9527673043915726, + "minus_weight": 53.46474177861535, + "orthogonality_relative_error": 1.8180147275507953e-16, + "plus_external_effective_rank": 6.841054939915081, + "plus_external_entropy": 0.9623173215368862, + "plus_target_effective_rank": 24.154163793494494, + "plus_target_entropy": 0.9527673043915725, + "plus_weight": 53.46474177861535, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "c07fd6226f16c5e484004b48bb242553058a1b0649b82f4a9a1a7432ff2d8f37", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.716939+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "a6f73763db08f9cdcc9be034428749201bf86800d7bc9ccfb30716216c74a1b7", + "panel_kind": "isotropic", + "panel_seed": 10452910810935468794, + "realization": 44, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "98bc7c9beb8684650cb1af6ee740363535269ac5ae9d81454b486e6aa7861d58", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3593401167283206, + "kernel_residual": 1.0148475026771446e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.329892685925249, + "minus_external_entropy": 0.9787150348705512, + "minus_target_effective_rank": 29.997792560644974, + "minus_target_entropy": 0.8985289789967729, + "minus_weight": 53.04174959923204, + "orthogonality_relative_error": 1.8875366658440907e-16, + "plus_external_effective_rank": 7.329892685925249, + "plus_external_entropy": 0.9787150348705512, + "plus_target_effective_rank": 29.997792560645, + "plus_target_entropy": 0.8985289789967723, + "plus_weight": 53.04174959923204, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "626e375abf89db3cb701b7c29af8354c25590826686f1c8fb746d85bd6404192", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.814366+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1e66101d60ae802d5f74a8d50e30f9e20d84e28e60b54a3bcaac0a88f358b661", + "panel_kind": "sparse", + "panel_seed": 2545204594319787093, + "realization": 45, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d375c9de22a2ba4048679247a88159858cb9c8a324c566961fe64db8ccc2bbdc", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3091751815974419, + "kernel_residual": 1.0051731060959005e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.124220835050001, + "minus_external_entropy": 0.9719775020440156, + "minus_target_effective_rank": 25.725550158103808, + "minus_target_entropy": 0.9595591426765477, + "minus_weight": 57.23364470956131, + "orthogonality_relative_error": 2.503656188960953e-16, + "plus_external_effective_rank": 7.124220835050009, + "plus_external_entropy": 0.9719775020440158, + "plus_target_effective_rank": 25.725550158103818, + "plus_target_entropy": 0.9595591426765477, + "plus_weight": 57.233644709561304, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "45b03e160c345327bf2600a5a0bc039ff28a5cec401eb60d3a55f07c362918a4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.906696+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1e66101d60ae802d5f74a8d50e30f9e20d84e28e60b54a3bcaac0a88f358b661", + "panel_kind": "isotropic", + "panel_seed": 2545204594319787093, + "realization": 45, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1116406ab919375e146a502c0af06aab3fd2c963b58b94ad623bfe18210fc4ec", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3091751815974419, + "kernel_residual": 1.0051731060959005e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.937133644722066, + "minus_external_entropy": 0.9657084537182549, + "minus_target_effective_rank": 29.299647651966513, + "minus_target_entropy": 0.8939838638579515, + "minus_weight": 55.84237933739159, + "orthogonality_relative_error": 2.5193813246566305e-16, + "plus_external_effective_rank": 6.937133644722072, + "plus_external_entropy": 0.9657084537182551, + "plus_target_effective_rank": 29.299647651966506, + "plus_target_entropy": 0.8939838638579516, + "plus_weight": 55.84237933739158, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "5bc3e4a57bc35b6b0339dc7da32dea66f5fd8ed2c11e829a3f08f35223454dc2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.005920+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "106d45f0df55e2c9bb9e57004828e836b2a05826e1bb7ca09cca4d0cf1456d1e", + "panel_kind": "sparse", + "panel_seed": 7818755242728806207, + "realization": 46, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8f6f2fc689f0bb495ab6a0428fe3654edcf0bcee580346a949a15ca4fd0e8757", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3374929659422562, + "kernel_residual": 9.807453318966246e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.02330675479242, + "minus_external_entropy": 0.9675184155477338, + "minus_target_effective_rank": 27.48611276133041, + "minus_target_entropy": 0.9590109835972958, + "minus_weight": 54.26780835097678, + "orthogonality_relative_error": 2.8317954521935306e-16, + "plus_external_effective_rank": 7.023306754792412, + "plus_external_entropy": 0.9675184155477333, + "plus_target_effective_rank": 27.486112761330407, + "plus_target_entropy": 0.9590109835972958, + "plus_weight": 54.26780835097685, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "4885fadafb155b5aece80299fe7aefd4f6e8727b509d9f766b62fbbb1024b4ca", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.099460+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "106d45f0df55e2c9bb9e57004828e836b2a05826e1bb7ca09cca4d0cf1456d1e", + "panel_kind": "isotropic", + "panel_seed": 7818755242728806207, + "realization": 46, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e29ec17a0b2d92336f8da66385b20d15acb992389f8e6e3d71c9bf0a3b882add", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3374929659422562, + "kernel_residual": 9.807453318966246e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.0578223115660315, + "minus_external_entropy": 0.9701341526243191, + "minus_target_effective_rank": 29.0535569915085, + "minus_target_entropy": 0.8940888776967104, + "minus_weight": 56.6653267608253, + "orthogonality_relative_error": 2.7415893713449643e-16, + "plus_external_effective_rank": 7.057822311566023, + "plus_external_entropy": 0.9701341526243189, + "plus_target_effective_rank": 29.05355699150849, + "plus_target_entropy": 0.8940888776967103, + "plus_weight": 56.665326760825366, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "7e247abed4f0c47cd49ba14babd9986d3a9b3537a140cf039b6717d14a31b014", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.197092+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "404308df70eb22e9d2803e21eabb6fba55cda3f1241bcbcd4025430cd043a214", + "panel_kind": "sparse", + "panel_seed": 11035902023735095670, + "realization": 47, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b0204467dad3babe862675debdd09e77a8b707e095341e9618b3727cfe761daf", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2979932182938613, + "kernel_residual": 9.499255441372454e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.436493463345236, + "minus_external_entropy": 0.9416837109804149, + "minus_target_effective_rank": 22.115657527539796, + "minus_target_entropy": 0.9437125477099025, + "minus_weight": 58.87781649799801, + "orthogonality_relative_error": 2.969535880846749e-16, + "plus_external_effective_rank": 6.436493463345237, + "plus_external_entropy": 0.9416837109804149, + "plus_target_effective_rank": 22.115657527539785, + "plus_target_entropy": 0.9437125477099024, + "plus_weight": 58.87781649799805, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "dafe5c7121c2772eea1d8139fb4c1ca1504cc79d9bddd9226381dc1fd0c1b003", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.290185+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "404308df70eb22e9d2803e21eabb6fba55cda3f1241bcbcd4025430cd043a214", + "panel_kind": "isotropic", + "panel_seed": 11035902023735095670, + "realization": 47, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1beb99ff6bb45128e315b11f3150e10ed7a3b91c74439cc2f1381c4ffb512177", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2979932182938613, + "kernel_residual": 9.499255441372454e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.659418828925028, + "minus_external_entropy": 0.9553518387603858, + "minus_target_effective_rank": 29.501425295134787, + "minus_target_entropy": 0.8943329587204516, + "minus_weight": 58.846311129488235, + "orthogonality_relative_error": 3.4419380946193344e-16, + "plus_external_effective_rank": 6.659418828925019, + "plus_external_entropy": 0.9553518387603855, + "plus_target_effective_rank": 29.501425295134773, + "plus_target_entropy": 0.8943329587204515, + "plus_weight": 58.846311129488285, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "da3e613130eb885d29cbb7bc356096970696ce39fe4fe6383a80d5ad8b96c291", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.387611+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "3cba02e5d8a58456a583f7b27b9bf8b11560c4eec4c3dfcb2bdf6317cc6d2120", + "panel_kind": "sparse", + "panel_seed": 1270522715933114774, + "realization": 48, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bacb4f3ac916dad2c44081da312b2ae53606bf1f3a9280b139d0a736cec30d35", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29045400184951864, + "kernel_residual": 1.0451815672124029e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.549023220073909, + "minus_external_entropy": 0.9522871571936476, + "minus_target_effective_rank": 26.922013057277226, + "minus_target_entropy": 0.9567167336770083, + "minus_weight": 58.23690686757353, + "orthogonality_relative_error": 1.6736751579077656e-16, + "plus_external_effective_rank": 6.5490232200739085, + "plus_external_entropy": 0.9522871571936478, + "plus_target_effective_rank": 26.922013057277233, + "plus_target_entropy": 0.9567167336770082, + "plus_weight": 58.23690686757353, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "0fa4a5d9025b48d78917d9d79130a3b80ceff167b310ddc0acc31b73ae5a0f79", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.479422+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "3cba02e5d8a58456a583f7b27b9bf8b11560c4eec4c3dfcb2bdf6317cc6d2120", + "panel_kind": "isotropic", + "panel_seed": 1270522715933114774, + "realization": 48, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "36ac28fe4afa5792e61d95e8f1a2da6a5cf49186cadc9d356b1220b7fb450d12", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29045400184951864, + "kernel_residual": 1.0451815672124029e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.937024802051029, + "minus_external_entropy": 0.9656197383831413, + "minus_target_effective_rank": 29.247238877351666, + "minus_target_entropy": 0.8938586494088663, + "minus_weight": 57.21117168747578, + "orthogonality_relative_error": 1.668600986222744e-16, + "plus_external_effective_rank": 6.9370248020510275, + "plus_external_entropy": 0.9656197383831413, + "plus_target_effective_rank": 29.247238877351638, + "plus_target_entropy": 0.8938586494088662, + "plus_weight": 57.21117168747578, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "1cc264b93a191285b3b05ebe1bc67336c58ea4fe9c9b4fa408c8ad44d3c6dada", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.576741+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5a427cc623ec5ea7d82b8bcece3be74a0a6e71322bab536c92d53ca5ee292963", + "panel_kind": "sparse", + "panel_seed": 1805543340859849486, + "realization": 49, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f29dde596300f1394facc012806ad8aa0bf688e74831d0a8642760086d7ff2da", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3389403202386162, + "kernel_residual": 9.467385558105478e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.380565747553295, + "minus_external_entropy": 0.9400397635687285, + "minus_target_effective_rank": 23.4667903923384, + "minus_target_entropy": 0.9513985005478797, + "minus_weight": 54.15720984075032, + "orthogonality_relative_error": 1.831926993138803e-16, + "plus_external_effective_rank": 6.380565747553298, + "plus_external_entropy": 0.9400397635687284, + "plus_target_effective_rank": 23.466790392338403, + "plus_target_entropy": 0.9513985005478794, + "plus_weight": 54.157209840750376, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "ae707c288224bd1a2b6e62057f5a925d73c397f9d032b22e9aa03ebd0f3e6ac7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.669560+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5a427cc623ec5ea7d82b8bcece3be74a0a6e71322bab536c92d53ca5ee292963", + "panel_kind": "isotropic", + "panel_seed": 1805543340859849486, + "realization": 49, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ac533f30ead56da29eff739e6209962229710bc688fe8eddd84116e155d683b1", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3389403202386162, + "kernel_residual": 9.467385558105478e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.32647670948379, + "minus_external_entropy": 0.9790881971796878, + "minus_target_effective_rank": 29.637696235082316, + "minus_target_entropy": 0.8966153061229368, + "minus_weight": 54.78153437975286, + "orthogonality_relative_error": 1.8376451876695267e-16, + "plus_external_effective_rank": 7.326476709483792, + "plus_external_entropy": 0.9790881971796878, + "plus_target_effective_rank": 29.63769623508235, + "plus_target_entropy": 0.8966153061229367, + "plus_weight": 54.78153437975293, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "b2eae501f032bfeca884d0a8f0305a3f1ef3dd2032ab02dc1e4c8dfc7be536d7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.764298+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ca2a2b8302e3a5b527f2b9c08b38ead66f1e6e499386cdf5ac4c59ba36e8052f", + "panel_kind": "sparse", + "panel_seed": 4767140795655149507, + "realization": 50, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "eaa27bf6700535009d37616869f2ae59b9f20fcf8f316eceb517f3a02181fb8b", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3346527635332656, + "kernel_residual": 1.0209269535344015e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.6497106519628995, + "minus_external_entropy": 0.9533283261901461, + "minus_target_effective_rank": 25.320766097829672, + "minus_target_entropy": 0.9480916706025403, + "minus_weight": 55.6666861116783, + "orthogonality_relative_error": 2.4937786021103865e-16, + "plus_external_effective_rank": 6.649710651962901, + "plus_external_entropy": 0.9533283261901462, + "plus_target_effective_rank": 25.320766097829686, + "plus_target_entropy": 0.9480916706025404, + "plus_weight": 55.66668611167831, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "8068e024ef8b4c3d1024dae1ee12b07037f0577d391b7221d948a8a77af70c98", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.858072+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ca2a2b8302e3a5b527f2b9c08b38ead66f1e6e499386cdf5ac4c59ba36e8052f", + "panel_kind": "isotropic", + "panel_seed": 4767140795655149507, + "realization": 50, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "36217862babb5eba8a37c2913b67ddfa8fb7259e848828a1695e23948221ebce", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3346527635332656, + "kernel_residual": 1.0209269535344015e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.07235478627998, + "minus_external_entropy": 0.9702694259192014, + "minus_target_effective_rank": 29.594986522715594, + "minus_target_entropy": 0.8957808932276731, + "minus_weight": 54.60979331496484, + "orthogonality_relative_error": 2.417017499334986e-16, + "plus_external_effective_rank": 7.072354786279984, + "plus_external_entropy": 0.9702694259192012, + "plus_target_effective_rank": 29.59498652271559, + "plus_target_entropy": 0.8957808932276732, + "plus_weight": 54.60979331496483, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "832244a35dc4c31e0ea18d1d9a5c7c3068ec453ded2bca2a44e9ac9b2c82fa89", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.958059+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e0268dfd25f561c5841ec7360592e84d5ee418097bda022089acd90bf15b6092", + "panel_kind": "sparse", + "panel_seed": 14617008461076312311, + "realization": 51, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4920006ec228c6061b371d32914a77ba783a32a243dd54df21861d96f6360a35", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3310695180725339, + "kernel_residual": 1.0045821257077803e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.66891286600662, + "minus_external_entropy": 0.9553120349194502, + "minus_target_effective_rank": 26.188659782433433, + "minus_target_entropy": 0.9545677744789945, + "minus_weight": 54.97719244992354, + "orthogonality_relative_error": 1.9517285943381244e-16, + "plus_external_effective_rank": 6.668912866006612, + "plus_external_entropy": 0.95531203491945, + "plus_target_effective_rank": 26.188659782433426, + "plus_target_entropy": 0.9545677744789944, + "plus_weight": 54.977192449923606, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "683ff1ed8ece96871bd136ce81302ae738a4d8a416a9826f04aa16ee18a047ec", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.050346+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e0268dfd25f561c5841ec7360592e84d5ee418097bda022089acd90bf15b6092", + "panel_kind": "isotropic", + "panel_seed": 14617008461076312311, + "realization": 51, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7fe6cde00ca7ded00121176877a70afa199ef83ce45c30471cb36137646f13d4", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3310695180725339, + "kernel_residual": 1.0045821257077803e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.037387542990259, + "minus_external_entropy": 0.968622890024136, + "minus_target_effective_rank": 29.462568107452586, + "minus_target_entropy": 0.8967527469121547, + "minus_weight": 57.43694144887567, + "orthogonality_relative_error": 1.8818513220916724e-16, + "plus_external_effective_rank": 7.037387542990252, + "plus_external_entropy": 0.968622890024136, + "plus_target_effective_rank": 29.462568107452572, + "plus_target_entropy": 0.8967527469121545, + "plus_weight": 57.436941448875736, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "ab34883ecbf56b5b50e5f15ca240b0a263f3e07831395351ad4326be6f46f8c6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.146330+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e0eff742819e709ee09ff794d0e8a60a64e37f5545f1afbcfaf005b0e2b3ab8f", + "panel_kind": "sparse", + "panel_seed": 5405299887041885102, + "realization": 52, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "89ff7e5079f638f473b0417a6f4bb15f5a397d512b0bf19ac8921a1acc98de60", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.41515846755597524, + "kernel_residual": 9.570713060952544e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.342656063519157, + "minus_external_entropy": 0.9365076296841367, + "minus_target_effective_rank": 21.343777022462145, + "minus_target_entropy": 0.9493193030042532, + "minus_weight": 53.905819442186285, + "orthogonality_relative_error": 1.6745811524214458e-16, + "plus_external_effective_rank": 6.342656063519161, + "plus_external_entropy": 0.9365076296841367, + "plus_target_effective_rank": 21.343777022462138, + "plus_target_entropy": 0.9493193030042528, + "plus_weight": 53.90581944218627, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e7a281c4dad686c6d5fd1ac4f3270f5e1b53e272b0683c6c352d1719fd813009", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.239292+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e0eff742819e709ee09ff794d0e8a60a64e37f5545f1afbcfaf005b0e2b3ab8f", + "panel_kind": "isotropic", + "panel_seed": 5405299887041885102, + "realization": 52, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fe9280f1e323b13fc320bd1c4a57c3707ee4d3de8e963d015bd418822d4a3d92", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.41515846755597524, + "kernel_residual": 9.570713060952544e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.443564447866038, + "minus_external_entropy": 0.9824217161376257, + "minus_target_effective_rank": 30.64173097379286, + "minus_target_entropy": 0.9026903261853371, + "minus_weight": 53.16962109420315, + "orthogonality_relative_error": 1.6388375520148506e-16, + "plus_external_effective_rank": 7.4435644478660405, + "plus_external_entropy": 0.9824217161376257, + "plus_target_effective_rank": 30.64173097379285, + "plus_target_entropy": 0.9026903261853372, + "plus_weight": 53.169621094203144, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "631f02a100f020667584ce304be741b2b0081a0242447f2fd37d0f260dba18f2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.336502+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1e57ca28defd80903b654e2d5432b1a3f99ea074c60a4da2c0eaa6cbae249671", + "panel_kind": "sparse", + "panel_seed": 7167363950177102078, + "realization": 53, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "370d15e57ae2cea216d8bb72ec929dc3e47defadf0824a276dc06f60db2a3f7f", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.24926862798260527, + "kernel_residual": 1.033157872793402e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.550240054159137, + "minus_external_entropy": 0.9533732558444548, + "minus_target_effective_rank": 24.1751949706797, + "minus_target_entropy": 0.9465398467633322, + "minus_weight": 61.196448257764665, + "orthogonality_relative_error": 2.1321844338649511e-16, + "plus_external_effective_rank": 6.550240054159141, + "plus_external_entropy": 0.9533732558444549, + "plus_target_effective_rank": 24.17519497067971, + "plus_target_entropy": 0.9465398467633325, + "plus_weight": 61.19644825776469, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e21ba388eaa9f35451e042465b33d4561a75b746e7f57bb61921c51507be43a2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.429155+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1e57ca28defd80903b654e2d5432b1a3f99ea074c60a4da2c0eaa6cbae249671", + "panel_kind": "isotropic", + "panel_seed": 7167363950177102078, + "realization": 53, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "89360411e6da72de5957cc093a5c482b26a481fd476064b0dff84154512997b9", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.24926862798260527, + "kernel_residual": 1.033157872793402e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.321577171335689, + "minus_external_entropy": 0.9463280327251989, + "minus_target_effective_rank": 27.794671403331872, + "minus_target_entropy": 0.8853254726028078, + "minus_weight": 60.71413231597108, + "orthogonality_relative_error": 1.977317876627541e-16, + "plus_external_effective_rank": 6.321577171335696, + "plus_external_entropy": 0.946328032725199, + "plus_target_effective_rank": 27.79467140333189, + "plus_target_entropy": 0.8853254726028078, + "plus_weight": 60.714132315971106, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "245f7a3bbb0aefceb17c7004f047d703f5ad3adfb9bd0b26991f51b6c2a2b20b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.525517+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5162c6d0f3092f61f37731eab6374880d0c3a728f72e0592648a48609e5b0996", + "panel_kind": "sparse", + "panel_seed": 13116686023042648886, + "realization": 54, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d28c9a8b214f7e479f209f5997318aab9d048d0a4cb5fcc8edacb63e5d6d8c04", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.36573286851644676, + "kernel_residual": 1.0588830311964758e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.4233666590406235, + "minus_external_entropy": 0.9416226623269986, + "minus_target_effective_rank": 23.07016883650376, + "minus_target_entropy": 0.9435869647895647, + "minus_weight": 55.54125998158281, + "orthogonality_relative_error": 1.8738327033666794e-16, + "plus_external_effective_rank": 6.4233666590406235, + "plus_external_entropy": 0.9416226623269989, + "plus_target_effective_rank": 23.070168836503765, + "plus_target_entropy": 0.9435869647895648, + "plus_weight": 55.54125998158277, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "21bc574eb7fb32a1e73bee5a7f1767cc30d6ff41c7095f8f958613d6e7e611dd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.618004+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5162c6d0f3092f61f37731eab6374880d0c3a728f72e0592648a48609e5b0996", + "panel_kind": "isotropic", + "panel_seed": 13116686023042648886, + "realization": 54, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cbacf4561296d65a23071640afc3e9e5d19bd97a1d7c07bd8da2581aafe69a57", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.36573286851644676, + "kernel_residual": 1.0588830311964758e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.061558940848296, + "minus_external_entropy": 0.9693486718691134, + "minus_target_effective_rank": 30.0591178035141, + "minus_target_entropy": 0.8980013276203321, + "minus_weight": 55.98091568688175, + "orthogonality_relative_error": 1.8464790565098193e-16, + "plus_external_effective_rank": 7.0615589408482915, + "plus_external_entropy": 0.9693486718691134, + "plus_target_effective_rank": 30.059117803514102, + "plus_target_entropy": 0.898001327620332, + "plus_weight": 55.980915686881715, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6825f84f2e609ab7b5b9e273e4683463e5d9d4b2c8036f0b169a0986db73ee5e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.715006+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "f371647b62e64e5a5d05e673af41b86dd2000352c93dfd7870cee5d1df38b159", + "panel_kind": "sparse", + "panel_seed": 14515707998503277710, + "realization": 55, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7fb766e4bd358d900064b3af441d04acd04c0ef690b3de73965e8373505d42ef", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3062195108398807, + "kernel_residual": 1.0237241826576634e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.35864207344805, + "minus_external_entropy": 0.9395289033606395, + "minus_target_effective_rank": 23.56779648050629, + "minus_target_entropy": 0.9443525490884355, + "minus_weight": 57.98194895152127, + "orthogonality_relative_error": 2.6241440761091404e-16, + "plus_external_effective_rank": 6.358642073448052, + "plus_external_entropy": 0.9395289033606394, + "plus_target_effective_rank": 23.567796480506296, + "plus_target_entropy": 0.9443525490884355, + "plus_weight": 57.981948951521304, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "d1ac4754c0da77aac56bee6c7bacfa5d5fc9c50f2f9bd02dd43b6e61a88764a6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.807426+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "f371647b62e64e5a5d05e673af41b86dd2000352c93dfd7870cee5d1df38b159", + "panel_kind": "isotropic", + "panel_seed": 14515707998503277710, + "realization": 55, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "799788bf9819b56634418c390e0cd8d438641b77c51a4de40250a66c0f66f2c5", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3062195108398807, + "kernel_residual": 1.0237241826576634e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.857722423957662, + "minus_external_entropy": 0.9627849047083435, + "minus_target_effective_rank": 28.996954914433893, + "minus_target_entropy": 0.892002124943489, + "minus_weight": 56.00600361198758, + "orthogonality_relative_error": 2.384955445734691e-16, + "plus_external_effective_rank": 6.857722423957659, + "plus_external_entropy": 0.9627849047083435, + "plus_target_effective_rank": 28.996954914433886, + "plus_target_entropy": 0.8920021249434892, + "plus_weight": 56.006003611987616, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "7bc681f980d3a655531a79224ebbf4e83dac8996b02f7bf7415087b75581f541", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.905228+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5e315bb31f0947e950c7608ab876d1e6da2e7b4c916c55b9ddf0349e15d3050b", + "panel_kind": "sparse", + "panel_seed": 18370795663787973316, + "realization": 56, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cae72356ff132f163ba91c28d5abc58b13ff7da7306b2c1a71fe69f814fde064", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30382876931364994, + "kernel_residual": 1.0190903209158404e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.172672120680332, + "minus_external_entropy": 0.9335986898244928, + "minus_target_effective_rank": 24.267591432769045, + "minus_target_entropy": 0.9474384238331275, + "minus_weight": 59.406925471821154, + "orthogonality_relative_error": 1.681843763955125e-16, + "plus_external_effective_rank": 6.172672120680333, + "plus_external_entropy": 0.9335986898244927, + "plus_target_effective_rank": 24.26759143276906, + "plus_target_entropy": 0.9474384238331275, + "plus_weight": 59.40692547182124, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6c5179238088980efb1f48fe7a4380cac219ffcf9ee0e1924e0f79ee109c80a2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.996811+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5e315bb31f0947e950c7608ab876d1e6da2e7b4c916c55b9ddf0349e15d3050b", + "panel_kind": "isotropic", + "panel_seed": 18370795663787973316, + "realization": 56, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "80705400f1c4f8836434b1fa275a3d13b2f0fd9138657f0c7048d81db8b188ff", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30382876931364994, + "kernel_residual": 1.0190903209158404e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.926927312317428, + "minus_external_entropy": 0.9649621154916529, + "minus_target_effective_rank": 29.450757106137175, + "minus_target_entropy": 0.8948128888403508, + "minus_weight": 56.96987886776753, + "orthogonality_relative_error": 1.699899597613969e-16, + "plus_external_effective_rank": 6.926927312317432, + "plus_external_entropy": 0.9649621154916529, + "plus_target_effective_rank": 29.45075710613719, + "plus_target_entropy": 0.8948128888403508, + "plus_weight": 56.96987886776759, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "dec5035d3ab18620219e04ad0b9654897a046523f014f102e78464e02a7cf8cf", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.094224+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "0504c3a283babb1a8bcad1baa28f81e04db26022129d92cb68d386074da3ebc7", + "panel_kind": "sparse", + "panel_seed": 6918270872981762365, + "realization": 57, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b75a16317e08b94a01ee2ca8f8e01590d5de5607c9587fa4c4ecd1387c666045", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3297513358437685, + "kernel_residual": 9.709177857550286e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.878982159053218, + "minus_external_entropy": 0.9613004400218, + "minus_target_effective_rank": 25.63138227199297, + "minus_target_entropy": 0.9519421799345293, + "minus_weight": 54.929242546419886, + "orthogonality_relative_error": 1.7579188704608201e-16, + "plus_external_effective_rank": 6.8789821590532165, + "plus_external_entropy": 0.9613004400217998, + "plus_target_effective_rank": 25.63138227199296, + "plus_target_entropy": 0.9519421799345297, + "plus_weight": 54.929242546419836, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6494081641d67759b6d2510dc094a6e1294a01e2cd755b2d39bfd0ada76f16a3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.185881+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "0504c3a283babb1a8bcad1baa28f81e04db26022129d92cb68d386074da3ebc7", + "panel_kind": "isotropic", + "panel_seed": 6918270872981762365, + "realization": 57, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e1cd196ce21e2673b2f8cad9cd076665dc88eac3f78fd3b9d5e66e91d6ec186f", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3297513358437685, + "kernel_residual": 9.709177857550286e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.052353818833708, + "minus_external_entropy": 0.9694049506955519, + "minus_target_effective_rank": 29.096676821422868, + "minus_target_entropy": 0.8926750754842268, + "minus_weight": 56.389960726728575, + "orthogonality_relative_error": 1.7078124256487398e-16, + "plus_external_effective_rank": 7.052353818833708, + "plus_external_entropy": 0.9694049506955517, + "plus_target_effective_rank": 29.096676821422864, + "plus_target_entropy": 0.8926750754842265, + "plus_weight": 56.38996072672852, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "d8f690fe19ac737569bd4f68a779a8f67530580116f7e2cc65625e14b46b207d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.281444+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "0332f5ead46b568472f5029d3f328cccc220058972fa3f46440839bad3fd8ab3", + "panel_kind": "sparse", + "panel_seed": 9843011202543739248, + "realization": 58, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "06fadcf4f76d25b04c790dd092c12f513a26d1dd0b811db344ab205eeb4f7930", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.36820883329663995, + "kernel_residual": 1.0016878900615019e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.904882063062687, + "minus_external_entropy": 0.9588625924369134, + "minus_target_effective_rank": 25.848740899276237, + "minus_target_entropy": 0.954394818509738, + "minus_weight": 55.083543961420375, + "orthogonality_relative_error": 1.4783320438344246e-16, + "plus_external_effective_rank": 6.9048820630626855, + "plus_external_entropy": 0.9588625924369135, + "plus_target_effective_rank": 25.848740899276244, + "plus_target_entropy": 0.9543948185097381, + "plus_weight": 55.08354396142035, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "06d169b2b9a23fff1b5c6a19a42004c55dcc8b075a830dc9ffbe53d14d582856", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.374895+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "0332f5ead46b568472f5029d3f328cccc220058972fa3f46440839bad3fd8ab3", + "panel_kind": "isotropic", + "panel_seed": 9843011202543739248, + "realization": 58, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4fa67a39ad39e0085ea214e8e668d88c590bc937357b264665f8e8d967f87a45", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.36820883329663995, + "kernel_residual": 1.0016878900615019e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.233184055955305, + "minus_external_entropy": 0.9757424555025023, + "minus_target_effective_rank": 30.240432881312522, + "minus_target_entropy": 0.8994971334563135, + "minus_weight": 55.015298138601594, + "orthogonality_relative_error": 1.4937435625792806e-16, + "plus_external_effective_rank": 7.233184055955305, + "plus_external_entropy": 0.9757424555025023, + "plus_target_effective_rank": 30.240432881312504, + "plus_target_entropy": 0.8994971334563137, + "plus_weight": 55.015298138601565, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "bfb1a04dc3527565b438dcd39ce7a6ea54ada3aaccad9b083092d3c7cbf531c6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.473677+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "d29e3c010351e1bd8dec42d3acf545dda64ca7edefd94a7068c439e496d22639", + "panel_kind": "sparse", + "panel_seed": 2834927314175927554, + "realization": 59, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "445f53e7f64c50ffaa891bdbd2407d38c2fbf52770593a24ed32aa3639370ea6", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.28897488037365887, + "kernel_residual": 9.905626780125992e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.027297546835846, + "minus_external_entropy": 0.9264966080881187, + "minus_target_effective_rank": 23.960452691872565, + "minus_target_entropy": 0.9553574406975154, + "minus_weight": 58.62858387944098, + "orthogonality_relative_error": 2.8763729951215793e-16, + "plus_external_effective_rank": 6.027297546835845, + "plus_external_entropy": 0.9264966080881186, + "plus_target_effective_rank": 23.960452691872558, + "plus_target_entropy": 0.9553574406975155, + "plus_weight": 58.628583879440995, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "923f5ff4151a4d72d8340fd9c7851ea958ba62eb685d250c46fb3011da6625d3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.565158+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "d29e3c010351e1bd8dec42d3acf545dda64ca7edefd94a7068c439e496d22639", + "panel_kind": "isotropic", + "panel_seed": 2834927314175927554, + "realization": 59, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "00f0698959e01e12aee289e57abc5b81915288ae126e3e8a963e62c820edc677", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.28897488037365887, + "kernel_residual": 9.905626780125992e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.637461205329949, + "minus_external_entropy": 0.9556736818480016, + "minus_target_effective_rank": 29.2714788431294, + "minus_target_entropy": 0.8953452935840035, + "minus_weight": 58.38525185813019, + "orthogonality_relative_error": 2.69974293355934e-16, + "plus_external_effective_rank": 6.637461205329947, + "plus_external_entropy": 0.9556736818480015, + "plus_target_effective_rank": 29.2714788431294, + "plus_target_entropy": 0.8953452935840036, + "plus_weight": 58.38525185813021, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "9feadeef3ebea8000d4e3daaa04e6480573f22f824968b3e6cb69f516ee55b87", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.660744+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "69e1d7fbfe5b45346edf536c33441d4a0c6f40f2ad334460366fde3777dee8d5", + "panel_kind": "sparse", + "panel_seed": 5391738000617553722, + "realization": 60, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7aee579c5f34ad0b21df2bc539b82bd3d600fbc6d1ae17c4332a3379b5d8b197", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29626919788480366, + "kernel_residual": 9.945151826081234e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.509811618322095, + "minus_external_entropy": 0.9492195914128956, + "minus_target_effective_rank": 24.609380105052608, + "minus_target_entropy": 0.9504412889757182, + "minus_weight": 58.864217239429564, + "orthogonality_relative_error": 1.5763833084685016e-16, + "plus_external_effective_rank": 6.5098116183220975, + "plus_external_entropy": 0.9492195914128957, + "plus_target_effective_rank": 24.60938010505261, + "plus_target_entropy": 0.9504412889757182, + "plus_weight": 58.86421723942951, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "08d30883eaaafeaf4068f35c4749bc343667015977bbb7c757c614984d834376", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.751287+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "69e1d7fbfe5b45346edf536c33441d4a0c6f40f2ad334460366fde3777dee8d5", + "panel_kind": "isotropic", + "panel_seed": 5391738000617553722, + "realization": 60, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3acffb450903fac7c531a393eb0a7cdb606f179b387792826c904354acb461be", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29626919788480366, + "kernel_residual": 9.945151826081234e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.679689407264585, + "minus_external_entropy": 0.9554810610262594, + "minus_target_effective_rank": 29.13250191223464, + "minus_target_entropy": 0.8928789255009079, + "minus_weight": 58.92024450009389, + "orthogonality_relative_error": 1.511131957565099e-16, + "plus_external_effective_rank": 6.679689407264585, + "plus_external_entropy": 0.9554810610262595, + "plus_target_effective_rank": 29.13250191223466, + "plus_target_entropy": 0.8928789255009079, + "plus_weight": 58.92024450009384, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "3916576754a9a2430ef931cb6767870a29de05821df800937b256c4c2ad8648b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.847227+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "485c3518c48bbee9796ba3def9e6e125eab8913714bbae10441b01a0578de86f", + "panel_kind": "sparse", + "panel_seed": 11592847769363164905, + "realization": 61, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3c924d75c5916d895b7dcbff874d3714240822c073301d2483723c372e0d2d78", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.26880987458907724, + "kernel_residual": 1.0108274805276933e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 5.850320686498543, + "minus_external_entropy": 0.9251713134570574, + "minus_target_effective_rank": 23.574447146852815, + "minus_target_entropy": 0.9475959996961985, + "minus_weight": 57.64813506408261, + "orthogonality_relative_error": 1.6284238110141289e-16, + "plus_external_effective_rank": 5.850320686498544, + "plus_external_entropy": 0.9251713134570575, + "plus_target_effective_rank": 23.574447146852822, + "plus_target_entropy": 0.9475959996961985, + "plus_weight": 57.64813506408264, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e8d6d2e4cd29830bc8c8c6d3e280597261bbf8cb203a8e406ff8ca2e2341f208", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.935997+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "485c3518c48bbee9796ba3def9e6e125eab8913714bbae10441b01a0578de86f", + "panel_kind": "isotropic", + "panel_seed": 11592847769363164905, + "realization": 61, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b3f3aec98da3267107179af63b2f202b2ba694bbb6295f76c962adf5e62634fe", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.26880987458907724, + "kernel_residual": 1.0108274805276933e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.662599661595757, + "minus_external_entropy": 0.9582634854540033, + "minus_target_effective_rank": 28.990037294970474, + "minus_target_entropy": 0.894002475411659, + "minus_weight": 57.18252905849415, + "orthogonality_relative_error": 1.6877328206304204e-16, + "plus_external_effective_rank": 6.662599661595757, + "plus_external_entropy": 0.9582634854540033, + "plus_target_effective_rank": 28.99003729497047, + "plus_target_entropy": 0.894002475411659, + "plus_weight": 57.182529058494175, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "fad6238f587dd1173ea997cd6caae4663bb5e1c7bbf9dd797abb2612965c0d16", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.030355+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "732f1e8d2fc7ecf472408ef634565b92a649aba064b3c6f3c41a6d0d768fb0fd", + "panel_kind": "sparse", + "panel_seed": 5390197761037612486, + "realization": 62, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2d5d421ee1debbefacae5a8965b439735c59275f5edd13e34072d4f0abbb73b7", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3478400013314658, + "kernel_residual": 9.71061010329965e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.939718214726538, + "minus_external_entropy": 0.9641965308791384, + "minus_target_effective_rank": 25.11283499887695, + "minus_target_entropy": 0.9548079466944898, + "minus_weight": 54.81798469915045, + "orthogonality_relative_error": 1.9159775886863017e-16, + "plus_external_effective_rank": 6.939718214726537, + "plus_external_entropy": 0.9641965308791381, + "plus_target_effective_rank": 25.11283499887694, + "plus_target_entropy": 0.9548079466944897, + "plus_weight": 54.81798469915046, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "90a9b5415ee3ae97211a9db56d1f176cfde7d4d46b5d9ff44a26621f447bf067", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.122478+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "732f1e8d2fc7ecf472408ef634565b92a649aba064b3c6f3c41a6d0d768fb0fd", + "panel_kind": "isotropic", + "panel_seed": 5390197761037612486, + "realization": 62, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d006a2900782a2fd0e71246d341a72d9d1cef5ef08d8b809ac5444613220a1f2", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3478400013314658, + "kernel_residual": 9.71061010329965e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.226063845580343, + "minus_external_entropy": 0.9758118862641261, + "minus_target_effective_rank": 30.89917308016804, + "minus_target_entropy": 0.9029115764563809, + "minus_weight": 55.130623374104104, + "orthogonality_relative_error": 1.9244192146398673e-16, + "plus_external_effective_rank": 7.22606384558034, + "plus_external_entropy": 0.9758118862641263, + "plus_target_effective_rank": 30.899173080168048, + "plus_target_entropy": 0.9029115764563806, + "plus_weight": 55.13062337410412, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "f3516ff39d5c766cca20cfd0b06227bc389d0d00cc5985d1cb5d736f2c26a647", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.219234+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "6b0c82711ac5257503fac74b671531d88153459ec70fe320990955d2691d399b", + "panel_kind": "sparse", + "panel_seed": 7326337864886062758, + "realization": 63, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6b6e215307f63fee0afa2211fdee8847b5afe50b963e590e4acfcc28f37b5e3c", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3328513900282485, + "kernel_residual": 9.767579233743913e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.37697128192993, + "minus_external_entropy": 0.9373048989424416, + "minus_target_effective_rank": 22.69304633966351, + "minus_target_entropy": 0.9532492639961517, + "minus_weight": 56.28533007229107, + "orthogonality_relative_error": 1.9057065629472505e-16, + "plus_external_effective_rank": 6.37697128192993, + "plus_external_entropy": 0.9373048989424417, + "plus_target_effective_rank": 22.693046339663518, + "plus_target_entropy": 0.9532492639961517, + "plus_weight": 56.28533007229109, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "9331630b4b1410daed7cd67979da8a462201f92b00d35344159b5bbeba5d0c19", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.311095+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "6b0c82711ac5257503fac74b671531d88153459ec70fe320990955d2691d399b", + "panel_kind": "isotropic", + "panel_seed": 7326337864886062758, + "realization": 63, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1637765f839c2e8c26b43d588bef7f7b1348f03a10f06db873b0a32c889938fb", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3328513900282485, + "kernel_residual": 9.767579233743913e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.004721328895643, + "minus_external_entropy": 0.9673915311403882, + "minus_target_effective_rank": 29.73572756318692, + "minus_target_entropy": 0.8975361425596053, + "minus_weight": 56.13568036821526, + "orthogonality_relative_error": 1.823913832124149e-16, + "plus_external_effective_rank": 7.0047213288956485, + "plus_external_entropy": 0.9673915311403884, + "plus_target_effective_rank": 29.735727563186916, + "plus_target_entropy": 0.8975361425596056, + "plus_weight": 56.13568036821527, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "3770cc8bb1c85f102b277c79b2831fa1a8258dd71055a6c43bea8262d842023c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.350260+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4cf5c1afd3269117ceec29b8d84ab4054f5905b0080cc5dfea1edfda2e188e11", + "panel_kind": "sparse", + "panel_seed": 16825777505976298391, + "realization": 0, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "948346513499661ed6dd3da393d22ab9569dbe32c70ef46aca722ee918eb5dd7", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024103210483011395, + "kernel_residual": 9.269984273569142e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07550663581695614, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.111978291011809, + "minus_target_entropy": 0.9672480509039363, + "minus_weight": 4.697734748132174, + "orthogonality_relative_error": 3.575320055159083e-16, + "plus_external_effective_rank": 12.442442612169339, + "plus_external_entropy": 0.8394584278440169, + "plus_target_effective_rank": 17.09013220740774, + "plus_target_entropy": 0.9154571696088875, + "plus_weight": 239.37707429979082, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "a5be4375a27606d11d843d16c4d8668f4c24a752cc34031fd8bf4ca7379531f2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.385726+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4cf5c1afd3269117ceec29b8d84ab4054f5905b0080cc5dfea1edfda2e188e11", + "panel_kind": "isotropic", + "panel_seed": 16825777505976298391, + "realization": 0, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "319a44aa842623213de81882908d89fb973bc5f5e677221255b474afaa91c562", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024103210483011395, + "kernel_residual": 9.269984273569142e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05838211539928263, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.008961989947275, + "minus_target_entropy": 0.9642501327971369, + "minus_weight": 4.030508661557647, + "orthogonality_relative_error": 4.15587133476243e-16, + "plus_external_effective_rank": 12.046006958462828, + "plus_external_entropy": 0.8425880113113037, + "plus_target_effective_rank": 20.491783330292947, + "plus_target_entropy": 0.9535814300968892, + "plus_weight": 268.0251778631658, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "c62d5e824788c508c3a7edb6da7e769d4b5d5f01a9826762cbe165d96038f856", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.424808+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2274b22cfe76fd219eeda0b74e3c8c3545cb2b05d885f61cffea6ba3ab49afb7", + "panel_kind": "sparse", + "panel_seed": 14713834655920423991, + "realization": 1, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "78af334fde28e8eddff28fd2a19f86febb52224528535730db259ae1edab174f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.023108653350816768, + "kernel_residual": 9.648594985038586e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05724365026795625, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.894108370760903, + "minus_target_entropy": 0.9576432575032098, + "minus_weight": 3.6941683390702673, + "orthogonality_relative_error": 8.16284746048064e-16, + "plus_external_effective_rank": 10.418823901362078, + "plus_external_entropy": 0.8282870126575557, + "plus_target_effective_rank": 18.84555610512151, + "plus_target_entropy": 0.9374749064328227, + "plus_weight": 250.69368892331596, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "463dcc35fd0c68e5d145c61d3f7b54a6d78b16ca748cca9b071ffd11e56afc5e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.462504+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2274b22cfe76fd219eeda0b74e3c8c3545cb2b05d885f61cffea6ba3ab49afb7", + "panel_kind": "isotropic", + "panel_seed": 14713834655920423991, + "realization": 1, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2649a47a0f166b2bb17f26a3479218dfbe78c74208708f958d939db4d5c31bfa", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.023108653350816768, + "kernel_residual": 9.648594985038586e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0593347260728538, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.572109424679293, + "minus_target_entropy": 0.9462181550057365, + "minus_weight": 3.609826885633675, + "orthogonality_relative_error": 8.369510747593265e-16, + "plus_external_effective_rank": 11.646821517598763, + "plus_external_entropy": 0.8534588771167478, + "plus_target_effective_rank": 20.63324292716858, + "plus_target_entropy": 0.9573536244005079, + "plus_weight": 236.07855275180202, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "52e6625e66043b67706739f0aed8431f64e902c05d4d35c503ba45ab5d3d7ecb", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.502784+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "5950f37b4ba9ce92679ac689824c9d256a6981b3965d108995b2d35b9bee1f6e", + "panel_kind": "sparse", + "panel_seed": 10921154700482938251, + "realization": 2, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fd2c7655a7a1a176dfa28137e9434e88c2b57808030ba8689fdf872a1b89d012", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.023704950083743685, + "kernel_residual": 1.1203722270716313e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06381124818959087, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.739073899791937, + "minus_target_entropy": 0.950498249388123, + "minus_weight": 4.216091863905711, + "orthogonality_relative_error": 3.87643954612697e-16, + "plus_external_effective_rank": 11.534714306450505, + "plus_external_entropy": 0.8433470249064502, + "plus_target_effective_rank": 18.853790637816502, + "plus_target_entropy": 0.9364251633007509, + "plus_weight": 255.78350601618087, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "ff6ef8aa3cd2418371baa49311061c703284de814b026038e7b39d36eda3c7f9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.539036+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "5950f37b4ba9ce92679ac689824c9d256a6981b3965d108995b2d35b9bee1f6e", + "panel_kind": "isotropic", + "panel_seed": 10921154700482938251, + "realization": 2, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "79b86d866b182c9329a2322ec3360e2d7ae74f3937ffd629e73f0aafc89b1690", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.023704950083743685, + "kernel_residual": 1.1203722270716313e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06293749269038754, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.690164971379642, + "minus_target_entropy": 0.9479618862295739, + "minus_weight": 3.8901330460200354, + "orthogonality_relative_error": 4.0511010846460543e-16, + "plus_external_effective_rank": 12.671802667485583, + "plus_external_entropy": 0.8589956395597493, + "plus_target_effective_rank": 20.44711432263951, + "plus_target_entropy": 0.9545634460188936, + "plus_weight": 239.3943983770064, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "16949595d434c2c0ee22ec6fb3f80cfffe5c82412f7c7c4aedcfd872d0416811", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.579741+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "57dff1ab62e9af38b45853b235cc52ba73ca66a027a8b14ea3c633b8c6c808f5", + "panel_kind": "sparse", + "panel_seed": 17076550612236467786, + "realization": 3, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f7af30de8cd8a23e43e319b26cea3c60f9f4a363f6c65d9c21d07f6d06aaa338", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.022266936222422786, + "kernel_residual": 9.702342248493937e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05656523309878598, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.816481151526014, + "minus_target_entropy": 0.956074798176677, + "minus_weight": 4.23946691610694, + "orthogonality_relative_error": 4.410346283994172e-16, + "plus_external_effective_rank": 12.126963136481251, + "plus_external_entropy": 0.8388021811261629, + "plus_target_effective_rank": 19.601585872445202, + "plus_target_entropy": 0.9444718363407744, + "plus_weight": 291.25247566719514, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "0cba6b3c970911a587e559a0c437aa797f518c3ee80139828e506ca78ffd4860", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.615520+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "57dff1ab62e9af38b45853b235cc52ba73ca66a027a8b14ea3c633b8c6c808f5", + "panel_kind": "isotropic", + "panel_seed": 17076550612236467786, + "realization": 3, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "90f360f3be47f50be8ed3b30fa244af6f7106b387b7bc125d2830964acc336f6", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.022266936222422786, + "kernel_residual": 9.702342248493937e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.056447582895470416, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.179311899331511, + "minus_target_entropy": 0.9713543408201011, + "minus_weight": 4.090360731516739, + "orthogonality_relative_error": 4.3657074916117903e-16, + "plus_external_effective_rank": 12.486281919846157, + "plus_external_entropy": 0.8490654754165871, + "plus_target_effective_rank": 21.213935966300312, + "plus_target_entropy": 0.9601296656767863, + "plus_weight": 281.6118336383041, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "e60f6bc060209b86082aba44c65373a13bc44242ba45ce6be85372e549a6b588", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.655704+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2896008eb9da29991cbf4c483344bc58b3f4f2a2033412794b042eaa1c7c0bfe", + "panel_kind": "sparse", + "panel_seed": 7743679942618729944, + "realization": 4, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "77bc44480d9d1fe8d730c10435a7a2bb6e8657bac780f35000cf655015d7df81", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03983005491750773, + "kernel_residual": 9.662275055838233e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07513688742099854, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.71615028024748, + "minus_target_entropy": 0.9527429684589993, + "minus_weight": 3.863152310833686, + "orthogonality_relative_error": 3.302246791415532e-16, + "plus_external_effective_rank": 13.842428324087402, + "plus_external_entropy": 0.8765033250659848, + "plus_target_effective_rank": 20.226971843585382, + "plus_target_entropy": 0.9456582252691391, + "plus_weight": 197.85769510026088, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "0970d2d16f79ff51669224755d460506dbe64e37967413fe1d9fdf98371c9e3b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.691707+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2896008eb9da29991cbf4c483344bc58b3f4f2a2033412794b042eaa1c7c0bfe", + "panel_kind": "isotropic", + "panel_seed": 7743679942618729944, + "realization": 4, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8421fc67b0f4e764a66edc10808a1bdad1a19a18acbcceae8c9f3b745da64eaf", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03983005491750773, + "kernel_residual": 9.662275055838233e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07211057921725936, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.916167850981662, + "minus_target_entropy": 0.9615736084075124, + "minus_weight": 3.6554049301639164, + "orthogonality_relative_error": 3.321436405497385e-16, + "plus_external_effective_rank": 15.323007517489193, + "plus_external_entropy": 0.8976996091655655, + "plus_target_effective_rank": 22.260603211316994, + "plus_target_entropy": 0.9686780530117884, + "plus_weight": 195.38744113389436, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "73134666e55592634e2d8ef2cf4b1da2f513d8b49583aea7bff8c66c32fb1ad3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.731654+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "039096ec7053869ca4385f81ab660f3067c4c85e27918cc6022360d32fa66e57", + "panel_kind": "sparse", + "panel_seed": 916865364380315589, + "realization": 5, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f9efbd7bf537c0a8c77c7a365eab098c2b25060e09cb02f15e52771d96cf8495", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02697673337770952, + "kernel_residual": 9.703247448515124e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06771344637967902, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.917567699003482, + "minus_target_entropy": 0.9598138745045087, + "minus_weight": 3.9040555652554088, + "orthogonality_relative_error": 5.444129789826209e-16, + "plus_external_effective_rank": 13.271338305051529, + "plus_external_entropy": 0.8738227775111546, + "plus_target_effective_rank": 19.51226529932243, + "plus_target_entropy": 0.9428493336716246, + "plus_weight": 222.74563732164847, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "68b9780155762f1ce75db3e4f8b2da5a9791a67578f95e6a82438e37374da91f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.767388+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "039096ec7053869ca4385f81ab660f3067c4c85e27918cc6022360d32fa66e57", + "panel_kind": "isotropic", + "panel_seed": 916865364380315589, + "realization": 5, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "485faf877261bd309942e083e7b5bdc74c77ac50a86cd25200fc1b2777fce42a", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02697673337770952, + "kernel_residual": 9.703247448515124e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06743114644287483, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.066664258349028, + "minus_target_entropy": 0.965597295632202, + "minus_weight": 3.8220042237403393, + "orthogonality_relative_error": 5.384666166298748e-16, + "plus_external_effective_rank": 13.583211215254236, + "plus_external_entropy": 0.8766268439846522, + "plus_target_effective_rank": 22.063020851489735, + "plus_target_entropy": 0.9675611212589166, + "plus_weight": 219.00969855189737, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "937c5709e70322058a63d1e692173147250cdbb249fdfa5691365fe758e9e118", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.807399+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "42ef855413c5b0de219907850b6032a904451d099ea47d0c85bff7e1be89397c", + "panel_kind": "sparse", + "panel_seed": 7346865150972736122, + "realization": 6, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f3ca23b3454366585b85a8cf7d1c1f3f5059259db0f9b70b7bbc454a091ba285", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.0300530227786912, + "kernel_residual": 8.954125737256982e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07665824790047734, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.969877708122469, + "minus_target_entropy": 0.9609781610168584, + "minus_weight": 4.006570206547089, + "orthogonality_relative_error": 5.7867329188583125e-16, + "plus_external_effective_rank": 12.733904587956543, + "plus_external_entropy": 0.8669869069368878, + "plus_target_effective_rank": 18.928821282375534, + "plus_target_entropy": 0.9417718676381174, + "plus_weight": 200.96838590836694, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "977370e74c6f03f9325b704cf862d662cd02cf9e91f7b285984b7b408ba2d5ad", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.843328+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "42ef855413c5b0de219907850b6032a904451d099ea47d0c85bff7e1be89397c", + "panel_kind": "isotropic", + "panel_seed": 7346865150972736122, + "realization": 6, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "544c400ac0bf126018ec22944ec6b68a5196af731ff6cab0b4692574b30872ca", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.0300530227786912, + "kernel_residual": 8.954125737256982e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0781422945302429, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.821103612176508, + "minus_target_entropy": 0.9561541148223885, + "minus_weight": 3.975195754919913, + "orthogonality_relative_error": 5.600509807840511e-16, + "plus_external_effective_rank": 14.318055170734128, + "plus_external_entropy": 0.8863599108022421, + "plus_target_effective_rank": 20.246382713137056, + "plus_target_entropy": 0.9550497092432952, + "plus_weight": 195.45373697146835, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "cb3f31efbfa639280b08d27eeb7b4640a6828da336a62a04f5258e7aaf027a8a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.882671+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "6792881d011ede063086a0e0bd0a07e9e1d67295dfd7ab56a96a71daabe650a6", + "panel_kind": "sparse", + "panel_seed": 7455772564310604881, + "realization": 7, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "eb810c397a5659b6967e8c4475d232d7643acef1731524f979f3299470beb365", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03318725701779882, + "kernel_residual": 1.041253600280675e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08289637873608373, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.794448442521405, + "minus_target_entropy": 0.9549170439285977, + "minus_weight": 4.054821399844896, + "orthogonality_relative_error": 4.523868986073242e-16, + "plus_external_effective_rank": 13.542873305215316, + "plus_external_entropy": 0.8731732713353076, + "plus_target_effective_rank": 17.881881104786597, + "plus_target_entropy": 0.9219112113969041, + "plus_weight": 187.45999780341506, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "f2c762dfe688b3721fb4ab96c2bdba9756891e8f7cc0d3dfad06b35efabba99e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.918238+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "6792881d011ede063086a0e0bd0a07e9e1d67295dfd7ab56a96a71daabe650a6", + "panel_kind": "isotropic", + "panel_seed": 7455772564310604881, + "realization": 7, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5a3131e18887efaba5efd2f83d756cbdb9fb1447af698e142fcca3d8b13c688a", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03318725701779882, + "kernel_residual": 1.041253600280675e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07890390182286319, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.1476181934797065, + "minus_target_entropy": 0.9695936539397867, + "minus_weight": 4.103814843000619, + "orthogonality_relative_error": 4.742949748290731e-16, + "plus_external_effective_rank": 14.244119028475499, + "plus_external_entropy": 0.8844201440920562, + "plus_target_effective_rank": 21.40147255080663, + "plus_target_entropy": 0.9636361340462142, + "plus_weight": 199.74921948528072, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "5b9422660c0836901e2fb1349fa55e711806518b387b3e18e30517b919d30569", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.958136+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "fe1ff278539f25a0ee73738b165d6d39c3385938d5fe05abacbf17cc0247feae", + "panel_kind": "sparse", + "panel_seed": 15185439957972700025, + "realization": 8, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0f5672c9bd4620a382441b7d79607f891a8689f10e6e5365fe84ec810bb21dea", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02644797691116107, + "kernel_residual": 9.649526737516424e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.10505344591833612, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.084626329134863, + "minus_target_entropy": 0.9674057457442221, + "minus_weight": 4.720534118981385, + "orthogonality_relative_error": 3.4726732515005797e-16, + "plus_external_effective_rank": 13.46593442687676, + "plus_external_entropy": 0.8688014576861216, + "plus_target_effective_rank": 15.305711458380204, + "plus_target_entropy": 0.8915207315844705, + "plus_weight": 170.16636362955813, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "6bb4f5ec4a8e0e481201436ed58cfad48352e7aabcdd4037f9abb075ae84f6ef", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.994408+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "fe1ff278539f25a0ee73738b165d6d39c3385938d5fe05abacbf17cc0247feae", + "panel_kind": "isotropic", + "panel_seed": 15185439957972700025, + "realization": 8, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e7d5c2062095099ef5234a42065d80ebe5e0e88e61d2deebf43f91e05fccbe0b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02644797691116107, + "kernel_residual": 9.649526737516424e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07500552411698347, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.103387623997509, + "minus_target_entropy": 0.9693818886944422, + "minus_weight": 3.9016724920344807, + "orthogonality_relative_error": 3.2029878707054853e-16, + "plus_external_effective_rank": 13.55186110470379, + "plus_external_entropy": 0.881777057057277, + "plus_target_effective_rank": 21.23043951986822, + "plus_target_entropy": 0.9606203307968313, + "plus_weight": 200.19448763644434, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "f8a1f14aa08fe65e0d8f006ae5772adc285214bafb5f76c6808b8e71574494f9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.034125+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d9e6fac0026276f608ef51197fcb7f555bab2e91986c6f914f85395769f00e14", + "panel_kind": "sparse", + "panel_seed": 11008158687752105530, + "realization": 9, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0a8367c35922046930da85516e1b6878f33663f27476413b6b9e7cb446bcdf3c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.030261737244653072, + "kernel_residual": 9.220163815218716e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05696759066143422, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.767400309916646, + "minus_target_entropy": 0.9532832074582056, + "minus_weight": 3.4117095428147026, + "orthogonality_relative_error": 3.981665676642226e-16, + "plus_external_effective_rank": 11.961178027932784, + "plus_external_entropy": 0.8504179544742407, + "plus_target_effective_rank": 19.924746094989974, + "plus_target_entropy": 0.9495465708466847, + "plus_weight": 232.68097691478295, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "af233837666a59446e1562ffc0ec1cc1d413e6742373b03c879839a958c52525", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.070159+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d9e6fac0026276f608ef51197fcb7f555bab2e91986c6f914f85395769f00e14", + "panel_kind": "isotropic", + "panel_seed": 11008158687752105530, + "realization": 9, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e361d24019028496913eb7ccb7f55cf80d3df75cc3ac2198a99a6775695da29d", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.030261737244653072, + "kernel_residual": 9.220163815218716e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07217731557442797, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.8620507082111875, + "minus_target_entropy": 0.9567423877348381, + "minus_weight": 4.045661116827862, + "orthogonality_relative_error": 3.486479012601365e-16, + "plus_external_effective_rank": 13.24189651848185, + "plus_external_entropy": 0.8685347987490786, + "plus_target_effective_rank": 20.68026903869611, + "plus_target_entropy": 0.9566138492664232, + "plus_weight": 216.03971002350275, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "cf58d003bb443e7b338353c9e6d849b69316b0af9f405b13170f21657865885e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.110372+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4dae7c03c8f5e371261b5ef536fc98a23867ba78af01a065a1fe39e44418542d", + "panel_kind": "sparse", + "panel_seed": 11140141162798394343, + "realization": 10, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "49dcedff673a90f4081ea7952c4b5baac65d86414ab7743d4608a6b8f43f2de9", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.018882096866273908, + "kernel_residual": 9.428792426244e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.047317914166141554, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.641405107220838, + "minus_target_entropy": 0.9475159176480048, + "minus_weight": 3.5053065851437646, + "orthogonality_relative_error": 7.980609977526677e-16, + "plus_external_effective_rank": 10.29718874044806, + "plus_external_entropy": 0.8171668576388673, + "plus_target_effective_rank": 19.756564086070856, + "plus_target_entropy": 0.947656099046982, + "plus_weight": 289.2665297386748, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "565cdce3d955c1b1be67e1e0a93ad662d8143f3d49b3f20f5c5faaf876a4984e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.147286+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4dae7c03c8f5e371261b5ef536fc98a23867ba78af01a065a1fe39e44418542d", + "panel_kind": "isotropic", + "panel_seed": 11140141162798394343, + "realization": 10, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "474ddc30d16715852b042593ea1e21bfd2a1289de472d7fff641efef69700e08", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.018882096866273908, + "kernel_residual": 9.428792426244e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05403449241366488, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.869541277369409, + "minus_target_entropy": 0.958286946775901, + "minus_weight": 3.985254896677685, + "orthogonality_relative_error": 8.529891318077061e-16, + "plus_external_effective_rank": 10.557674307551661, + "plus_external_entropy": 0.8231077270480451, + "plus_target_effective_rank": 20.06490320423982, + "plus_target_entropy": 0.9524936698197206, + "plus_weight": 286.9897750232185, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "8f641ade9fd0a717c52d36b3715971210ab3e1b530de8dcb483e11980095f3c3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.189157+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "473dd10d7fcb40993a78c310cab34850a869a566d2086c0096a4184275d4f43c", + "panel_kind": "sparse", + "panel_seed": 17498065421800041842, + "realization": 11, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8fac41dc0e8a815962a1cc0bc08a74493b69f0dbfd36021f5484902b37300a81", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04980298271750512, + "kernel_residual": 9.627381144658712e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0822065637155332, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.7997372822279, + "minus_target_entropy": 0.9567083314483056, + "minus_weight": 3.8804409348286493, + "orthogonality_relative_error": 2.2167459469650418e-16, + "plus_external_effective_rank": 15.471357061512002, + "plus_external_entropy": 0.8910150513859514, + "plus_target_effective_rank": 20.311548795512305, + "plus_target_entropy": 0.9490421481894469, + "plus_weight": 180.9700776440778, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "7c3e7b25421db4a81921c2e6c1ac9c205722ae621b0a1665bba73d8abf886ea5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.227651+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "473dd10d7fcb40993a78c310cab34850a869a566d2086c0096a4184275d4f43c", + "panel_kind": "isotropic", + "panel_seed": 17498065421800041842, + "realization": 11, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "afa1569c249be2fcae369d4787001273521a571cb146a74d6317d07cf6b53be4", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04980298271750512, + "kernel_residual": 9.627381144658712e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.085033542154009, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.7958948438741125, + "minus_target_entropy": 0.9550507353735442, + "minus_weight": 3.913403100759939, + "orthogonality_relative_error": 2.156026583292854e-16, + "plus_external_effective_rank": 16.93088261624069, + "plus_external_entropy": 0.9131025277949063, + "plus_target_effective_rank": 22.67280871609419, + "plus_target_entropy": 0.9718465507272949, + "plus_weight": 176.1737666390843, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "fc09f0ce0d64fddc96622404a62d0254f9a90c08ae9fcb448e95eb1e59c0cda3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.270422+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "3cd8becb9c77762b1a09888c5e79e1786f564594cd8a6261eba787fdbf96e417", + "panel_kind": "sparse", + "panel_seed": 167917693510966101, + "realization": 12, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cfc53df95af41f18a8cc0205663412d092f5e31ade30546c983db8d43463d84e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.014307834823170544, + "kernel_residual": 9.006604912132754e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05630851796703488, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.812103421077206, + "minus_target_entropy": 0.9547080034313155, + "minus_weight": 4.047779240249085, + "orthogonality_relative_error": 9.687202592206364e-16, + "plus_external_effective_rank": 9.508847535062511, + "plus_external_entropy": 0.8000609487971876, + "plus_target_effective_rank": 17.49832388595178, + "plus_target_entropy": 0.9280030147548237, + "plus_weight": 279.38874016466684, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "13612ba3b1b2644ee32bf25c312b740a36c490d04488cc03668cf19e9d780d8f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.312832+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "3cd8becb9c77762b1a09888c5e79e1786f564594cd8a6261eba787fdbf96e417", + "panel_kind": "isotropic", + "panel_seed": 167917693510966101, + "realization": 12, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "548d1f9be6908cfae4effc94b253edc8378e032da0c6a0eac1a2449aa25e9edd", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.014307834823170544, + "kernel_residual": 9.006604912132754e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06587736018077736, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.361760841407461, + "minus_target_entropy": 0.9782958405439399, + "minus_weight": 4.286957054072376, + "orthogonality_relative_error": 1.043507857934914e-15, + "plus_external_effective_rank": 10.324870416291157, + "plus_external_entropy": 0.829091658880504, + "plus_target_effective_rank": 18.100653967160707, + "plus_target_entropy": 0.9372388877398969, + "plus_weight": 251.65231823656285, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "8f053e110e61a534f97d72a7268cf8c0d3c6b0771d62abf2687b7a2c6d84b12d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.360373+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "b6d718077fc9dbfffc8bcc2a50bd02c144fd34b4e967ee10e940e6a167308343", + "panel_kind": "sparse", + "panel_seed": 7960898400706684734, + "realization": 13, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1c165fa90b01f39deabef263ea3ffbe02ed0d3fc85ba1ffffa4d45fd68453492", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.023715378362317754, + "kernel_residual": 9.714812569615722e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05846362475279649, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.608306523811424, + "minus_target_entropy": 0.9435954688321956, + "minus_weight": 3.471828455228776, + "orthogonality_relative_error": 7.712431999884565e-16, + "plus_external_effective_rank": 10.681257238454128, + "plus_external_entropy": 0.8380159182821354, + "plus_target_effective_rank": 17.90564273769677, + "plus_target_entropy": 0.9198748721800758, + "plus_weight": 230.5417398730471, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 25, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "d2d0bc10bb2f2f75f8e9b641b38e3dc82143f5bfe1993c19d696d3ae6727799a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.400872+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "b6d718077fc9dbfffc8bcc2a50bd02c144fd34b4e967ee10e940e6a167308343", + "panel_kind": "isotropic", + "panel_seed": 7960898400706684734, + "realization": 13, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8393c17e7235bbbd086b450260eafef4850de3c77cb6d6f4e3869abb09c6abaf", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.023715378362317754, + "kernel_residual": 9.714812569615722e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06821984080848188, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.260075445544778, + "minus_target_entropy": 0.9748605136410607, + "minus_weight": 4.220283476357689, + "orthogonality_relative_error": 7.20659260540113e-16, + "plus_external_effective_rank": 12.36112690209448, + "plus_external_entropy": 0.8552202808119589, + "plus_target_effective_rank": 21.275607135568706, + "plus_target_entropy": 0.9609547557004414, + "plus_weight": 238.93685980656903, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "564479e3ca1e2d2ece135c90e6d8d7eb5887cd04c9e7a8ea8ffbae4790ad0c12", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.447879+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "83172d0c151746471c52bd17545ba8721f98395c53cf8fad57d7acbf00e98b00", + "panel_kind": "sparse", + "panel_seed": 11031316681542720410, + "realization": 14, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3fcc4c7ec146eb4c4a1f90674ef594d43abcb403684736e4059c3373ec7261d9", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.013964183261977002, + "kernel_residual": 1.0185691307894619e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05470028483123422, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.699087057581746, + "minus_target_entropy": 0.949273133502657, + "minus_weight": 3.75857093203393, + "orthogonality_relative_error": 7.472621316601572e-16, + "plus_external_effective_rank": 10.02979879376789, + "plus_external_entropy": 0.8210620971392693, + "plus_target_effective_rank": 17.873919861259722, + "plus_target_entropy": 0.9245873017911032, + "plus_weight": 267.2783664251917, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "4c3d116966b90c014393d85f547c77539dd2d1139f78b7dcf3250ee141dcece2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.491072+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "83172d0c151746471c52bd17545ba8721f98395c53cf8fad57d7acbf00e98b00", + "panel_kind": "isotropic", + "panel_seed": 11031316681542720410, + "realization": 14, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1ff19a13bd6c96155275d820aefd97a147e2eb9a5ec48aa2ea61babefc3eae8b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.013964183261977002, + "kernel_residual": 1.0185691307894619e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05391049749855745, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.874348402953304, + "minus_target_entropy": 0.9587033528419068, + "minus_weight": 3.9254226153523035, + "orthogonality_relative_error": 7.391730878243666e-16, + "plus_external_effective_rank": 10.535708176676943, + "plus_external_entropy": 0.8221030377432434, + "plus_target_effective_rank": 19.51906491480728, + "plus_target_entropy": 0.9458644978447818, + "plus_weight": 283.3495602948528, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "48c0b8168fa6b5357c831a02f22886bd51295659225427232f2ec7491bc9d7c3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.539276+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "8160e34ff49c7af1b74134dfc7e576a01f84407680b9916d1b1a32fdbb82baf2", + "panel_kind": "sparse", + "panel_seed": 17936840037816290029, + "realization": 15, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b64b1bc18c12fae5afceafaf66794a03cdcd4b2052b7193b1ac9a04a2e4d5184", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.020990068342706777, + "kernel_residual": 9.51841917824288e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08105447665896978, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.042342219492384, + "minus_target_entropy": 0.9648980970648234, + "minus_weight": 4.530614566295723, + "orthogonality_relative_error": 7.282876049768713e-16, + "plus_external_effective_rank": 11.411593219529925, + "plus_external_entropy": 0.8437954922071209, + "plus_target_effective_rank": 16.578927876436182, + "plus_target_entropy": 0.9186390973536326, + "plus_weight": 214.42672482601662, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "2e7d61b2e1020a53a0ac9b55d44c2138cb92c551645661967ecd5237188dcdac", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.589359+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "8160e34ff49c7af1b74134dfc7e576a01f84407680b9916d1b1a32fdbb82baf2", + "panel_kind": "isotropic", + "panel_seed": 17936840037816290029, + "realization": 15, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7a7d63e7878fc08c3e2ff53f4979045cb60a818a04dfb0696cbbca438c7edcb9", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.020990068342706777, + "kernel_residual": 9.51841917824288e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06460425396248022, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.925702142787691, + "minus_target_entropy": 0.961405027656549, + "minus_weight": 3.8162179455575127, + "orthogonality_relative_error": 7.543471170448969e-16, + "plus_external_effective_rank": 11.127891427242375, + "plus_external_entropy": 0.8476929098582309, + "plus_target_effective_rank": 19.74580565645219, + "plus_target_entropy": 0.9505776023355376, + "plus_weight": 228.586618335683, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "0f6b16d7af04d6f309abb4aaf77b83645fa3bc3036c2aa585c313e9ebd631f93", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.641140+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4a8ebbf66cd886f19622568e9573df009d2db19f9ac2cee6d2252e0729312056", + "panel_kind": "sparse", + "panel_seed": 9679554556415199320, + "realization": 16, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "75dc8ec6ed5949659aa0505fe7137afdb8d249f80a43e3735ad44693cdd6c004", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.0269004005858456, + "kernel_residual": 9.234521971626622e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07462815735746217, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.81826572379774, + "minus_target_entropy": 0.9552945751308646, + "minus_weight": 4.172077997944928, + "orthogonality_relative_error": 5.690602757594327e-16, + "plus_external_effective_rank": 11.43904878484661, + "plus_external_entropy": 0.8516649345216761, + "plus_target_effective_rank": 17.97207932478053, + "plus_target_entropy": 0.9242514731509394, + "plus_weight": 215.19446808548793, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 26, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "20da77e642ded59c74912da69a5ddf0b6aafd72dab9da09045c9f4cea791e4e5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.687817+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4a8ebbf66cd886f19622568e9573df009d2db19f9ac2cee6d2252e0729312056", + "panel_kind": "isotropic", + "panel_seed": 9679554556415199320, + "realization": 16, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "40611eeb3050bdfca6c78030029a1553a5770bf9b82e659c8ce4f96a40298619", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.0269004005858456, + "kernel_residual": 9.234521971626622e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07005030500303126, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.095732495133809, + "minus_target_entropy": 0.9656560201696158, + "minus_weight": 3.97015174899326, + "orthogonality_relative_error": 5.88384701417253e-16, + "plus_external_effective_rank": 12.347442125124266, + "plus_external_entropy": 0.861059281099784, + "plus_target_effective_rank": 20.868393665415997, + "plus_target_entropy": 0.9579095411048602, + "plus_weight": 218.6905173682298, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "5e9f8480658689d75294e61b09c9eff3a803937cb64ab71ec20a678bd776c946", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.741074+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "0e4c3353d5e5eacf66402814a2ec9d73ce4ecc6e0af74373116affdc2a031ea6", + "panel_kind": "sparse", + "panel_seed": 11567434307949216747, + "realization": 17, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2a60309d0696d61cc70efc8ba10ee22b77aae66878d4d6d249dba9aa58fa8aaf", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.042026690097077636, + "kernel_residual": 9.420686392301114e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08488040682603737, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.003362031515723, + "minus_target_entropy": 0.9645670377763582, + "minus_weight": 3.8667109444201673, + "orthogonality_relative_error": 3.283460643395282e-16, + "plus_external_effective_rank": 15.59775329225592, + "plus_external_entropy": 0.8986625254538891, + "plus_target_effective_rank": 21.320764075261447, + "plus_target_entropy": 0.9589413852021406, + "plus_weight": 174.40009388381307, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "753475981fb5c4770bf993e87437a2ba52f3b0bf83eaafa8da2f6cc5054c7455", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.791056+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "0e4c3353d5e5eacf66402814a2ec9d73ce4ecc6e0af74373116affdc2a031ea6", + "panel_kind": "isotropic", + "panel_seed": 11567434307949216747, + "realization": 17, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "805dd8318569678786ec8ada1d537ec2cc91c41ac1cbfe7e2ba9c3667b329b28", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.042026690097077636, + "kernel_residual": 9.420686392301114e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07683222799943121, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.0718471652261226, + "minus_target_entropy": 0.9677081835289506, + "minus_weight": 3.7660574511476534, + "orthogonality_relative_error": 3.367191692209817e-16, + "plus_external_effective_rank": 15.061429156169613, + "plus_external_entropy": 0.8971773063067945, + "plus_target_effective_rank": 22.28075708098778, + "plus_target_entropy": 0.969267910468719, + "plus_weight": 188.45917553204544, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "beff360bad954f837a334ecb5678efee5fc895e4879e8c29a668a459ef867dc3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.849682+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2ef539529bee85aa55289d6b30150f4a29eee988b5d1a0e5ffb924db495e578c", + "panel_kind": "sparse", + "panel_seed": 3055915363016924156, + "realization": 18, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2b0f4ef5020447639f05062ac6c471e9776c398e12f04fa0ce8eb25888d2717f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.01641630746306982, + "kernel_residual": 9.692558284307962e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.052986646822854325, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.512681585620999, + "minus_target_entropy": 0.9405378082208424, + "minus_weight": 3.8356951064424694, + "orthogonality_relative_error": 7.465827833402128e-16, + "plus_external_effective_rank": 9.715452442766523, + "plus_external_entropy": 0.8115322325457726, + "plus_target_effective_rank": 16.845601209750104, + "plus_target_entropy": 0.9202039383809663, + "plus_weight": 281.8357838687056, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "bec2da4654c0ab13730d5da339600c1fc1caa009ea9be578d3b7ca9fc7daf15e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.899955+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2ef539529bee85aa55289d6b30150f4a29eee988b5d1a0e5ffb924db495e578c", + "panel_kind": "isotropic", + "panel_seed": 3055915363016924156, + "realization": 18, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "89b2aaf2b0a84286861e3dd9e24d9f37f854fef1cffc7d7d58cf8d4c2b8ff23e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.01641630746306982, + "kernel_residual": 9.692558284307962e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05304218475688679, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.077302225439563, + "minus_target_entropy": 0.9684116695209317, + "minus_weight": 3.962240969052851, + "orthogonality_relative_error": 8.278054844405382e-16, + "plus_external_effective_rank": 9.789610376692341, + "plus_external_entropy": 0.8117310726145862, + "plus_target_effective_rank": 20.282305073254992, + "plus_target_entropy": 0.9525985780697587, + "plus_weight": 290.8207635097905, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "e3ff6b0a00cbec20a4088cd6c7cec2388c6e15f54e1d6bf422a83732d22ef4a8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.955112+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "62203ef94bb73885d8087f1f5d8ec93e5b2fb2e583a2b7a0f51c84c005d7ea7f", + "panel_kind": "sparse", + "panel_seed": 3102311963417027461, + "realization": 19, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "632f288fb8f2a89492084f9e8965a3c7bb322c204088c5c2735fed62c6e2f668", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.017136921431509102, + "kernel_residual": 9.28734869636134e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07002655318312329, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.816533600806533, + "minus_target_entropy": 0.9553307520685665, + "minus_weight": 3.9742540969216904, + "orthogonality_relative_error": 3.5356050856654973e-16, + "plus_external_effective_rank": 10.439982283882797, + "plus_external_entropy": 0.8385470523006078, + "plus_target_effective_rank": 17.917262072158092, + "plus_target_entropy": 0.9261981649407842, + "plus_weight": 218.99348833768806, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "37625706f0747a2a12942e08e3154f41a4b58677c4599b18808596a054cae3e0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.016159+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "62203ef94bb73885d8087f1f5d8ec93e5b2fb2e583a2b7a0f51c84c005d7ea7f", + "panel_kind": "isotropic", + "panel_seed": 3102311963417027461, + "realization": 19, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4362c9bc777a4955563708418336dd816b3d458becb8b1808f9ef06c92dee3f2", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.017136921431509102, + "kernel_residual": 9.28734869636134e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06306172654207721, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.98271994701357, + "minus_target_entropy": 0.9641672432371181, + "minus_weight": 3.974809090816647, + "orthogonality_relative_error": 3.9118011720353834e-16, + "plus_external_effective_rank": 10.371835948029313, + "plus_external_entropy": 0.8347338919939821, + "plus_target_effective_rank": 19.51416444534122, + "plus_target_entropy": 0.9483978173214999, + "plus_weight": 244.10746553535728, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "ac9d8e284949a9b0781a65ccd24143f41484bf237e0035f249196b6cb59d86b9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.076539+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d2035750671db9e438c8a38701efc4ed47f7129531a052ce08a784adba8942f8", + "panel_kind": "sparse", + "panel_seed": 8305958690931705538, + "realization": 20, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a5bca0b56f0227669bf5af8f9a86f77304f0c5ca26e0128f89d5c07cca842401", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03672405111534426, + "kernel_residual": 9.22899428007268e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06952457190731813, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.487723998860449, + "minus_target_entropy": 0.9387788637351351, + "minus_weight": 3.6330519961702215, + "orthogonality_relative_error": 3.4671283141372636e-16, + "plus_external_effective_rank": 12.558304257826704, + "plus_external_entropy": 0.871781959835089, + "plus_target_effective_rank": 18.565020693568165, + "plus_target_entropy": 0.9310439290387075, + "plus_weight": 201.69107127957807, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 25, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "b335f03d46ce9729991aa594ae35b3e5f03bf703e2d998ac4690210768d9846c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.133034+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d2035750671db9e438c8a38701efc4ed47f7129531a052ce08a784adba8942f8", + "panel_kind": "isotropic", + "panel_seed": 8305958690931705538, + "realization": 20, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3fcf72bd8cd171a84eac3d2f92c2e9a8da7d355388b858c8947dc9598c39625b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03672405111534426, + "kernel_residual": 9.22899428007268e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07147736863300588, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.676699352887803, + "minus_target_entropy": 0.949962460129035, + "minus_weight": 3.724127087666365, + "orthogonality_relative_error": 3.314199247999751e-16, + "plus_external_effective_rank": 14.752747299657258, + "plus_external_entropy": 0.8922204500223545, + "plus_target_effective_rank": 21.94695801906541, + "plus_target_entropy": 0.9674446854796761, + "plus_weight": 200.8914481450418, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "36170fae0df853214cde9a3ea3d396fe876f0a6c63be60be970fd9d8d16faf5e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.194426+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "abe09e28dd09aa08114f00913ec69cf596270744bfd0942060b38404f2a35d7f", + "panel_kind": "sparse", + "panel_seed": 6072950980575034836, + "realization": 21, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "02c0c13e70db205a8ef0838c91c3a69a4cbfc24b74d4a517b786ce76f995cc78", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.019581228818421302, + "kernel_residual": 9.503434411225044e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05667113459549975, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.661315365643854, + "minus_target_entropy": 0.9501772473566482, + "minus_weight": 4.019567344451554, + "orthogonality_relative_error": 6.063836246049662e-16, + "plus_external_effective_rank": 9.933300662356366, + "plus_external_entropy": 0.8122458755726288, + "plus_target_effective_rank": 17.126855876308763, + "plus_target_entropy": 0.9233579795992567, + "plus_weight": 275.6140397695276, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "4d118513c46552b1044d981f963682ff629fc470243e522eeb6d0d3b17805856", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.248662+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "abe09e28dd09aa08114f00913ec69cf596270744bfd0942060b38404f2a35d7f", + "panel_kind": "isotropic", + "panel_seed": 6072950980575034836, + "realization": 21, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "dc28814705a77d5e11ba0aa0a601640eadc42677b8acc6261eb289f71e8452b6", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.019581228818421302, + "kernel_residual": 9.503434411225044e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06585859308301838, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.132980798569834, + "minus_target_entropy": 0.9704777304262242, + "minus_weight": 4.158631486764769, + "orthogonality_relative_error": 5.7410373425808e-16, + "plus_external_effective_rank": 10.830839774043012, + "plus_external_entropy": 0.8328533271282298, + "plus_target_effective_rank": 20.330086914789856, + "plus_target_entropy": 0.9531784455275065, + "plus_weight": 244.19134532337105, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "7096a3001f8c3286c3e1621228c183bf84afd219b5dfbdb6013222857c803c13", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.308682+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "fc221b4fb52bef66687ac28ee545ac7413df996996c4e9d41ae9a54b1d1cd995", + "panel_kind": "sparse", + "panel_seed": 13259922740100560487, + "realization": 22, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0bcaee6865d5097bdcd985c67abfc1fb5ebe7a8f90eb676dfc74fe25ac4aca40", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.05965821397788834, + "kernel_residual": 9.083792536696617e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08731476099351898, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.062823393521797, + "minus_target_entropy": 0.9643102166471357, + "minus_weight": 3.966545657981663, + "orthogonality_relative_error": 2.1615395533981525e-16, + "plus_external_effective_rank": 15.804835401734808, + "plus_external_entropy": 0.8959936090592497, + "plus_target_effective_rank": 21.15467699105823, + "plus_target_entropy": 0.9580137832240716, + "plus_weight": 173.68881433398985, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "479383f9ec21e7f6076ecdba19895fcd99e116031bd3ef64c353caed30c09ed1", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.361999+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "fc221b4fb52bef66687ac28ee545ac7413df996996c4e9d41ae9a54b1d1cd995", + "panel_kind": "isotropic", + "panel_seed": 13259922740100560487, + "realization": 22, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "65a27aa8a8d05c371039ec4f38bd6d0d30de550ce1d417c1fd796f1500ed4eb1", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.05965821397788834, + "kernel_residual": 9.083792536696617e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08217302522034824, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.777928211823393, + "minus_target_entropy": 0.9554525346215385, + "minus_weight": 3.612467100898233, + "orthogonality_relative_error": 2.2173022608578168e-16, + "plus_external_effective_rank": 17.631128017025883, + "plus_external_entropy": 0.9210608741871515, + "plus_target_effective_rank": 22.99591568483662, + "plus_target_entropy": 0.9744905597416674, + "plus_weight": 168.54449795039596, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "07ebeb9e103b3363e54799fc47995e504c03a47f3e2e26e5a687d9a5b207f025", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.415873+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "733f5798e621851e819b6e3a267798232ab22cc2a13832592894866b857a2b04", + "panel_kind": "sparse", + "panel_seed": 6636942677701829995, + "realization": 23, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0465e03dfa44372d7c34836c2b34e0672b876f115a2b3a9e9c296a31561a46fd", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.016985828128960136, + "kernel_residual": 9.441899915160604e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07401958801046096, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.889001261418759, + "minus_target_entropy": 0.9586452214559548, + "minus_weight": 4.227311447676893, + "orthogonality_relative_error": 1.1205834812304206e-15, + "plus_external_effective_rank": 10.799408163440187, + "plus_external_entropy": 0.8370655513162283, + "plus_target_effective_rank": 17.68535934681068, + "plus_target_entropy": 0.9253449376864741, + "plus_weight": 219.90696675452068, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "b79e1e5bb9545e5f03fc7f629e13b8e355d95a26db7c8ecddd018a93e49455f3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.464213+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "733f5798e621851e819b6e3a267798232ab22cc2a13832592894866b857a2b04", + "panel_kind": "isotropic", + "panel_seed": 6636942677701829995, + "realization": 23, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6803d34bfdc7b3d214ad7c0bc424c943a5e407741a3dc6170db5608799b60507", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.016985828128960136, + "kernel_residual": 9.441899915160604e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06330946206148112, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.740202974505475, + "minus_target_entropy": 0.9526176184851574, + "minus_weight": 4.0017835658909275, + "orthogonality_relative_error": 1.1679268692868772e-15, + "plus_external_effective_rank": 11.07869900586513, + "plus_external_entropy": 0.8410647401560165, + "plus_target_effective_rank": 19.124273323098812, + "plus_target_entropy": 0.9459702920817841, + "plus_weight": 244.77053139338804, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "12d589049f2033cea256adc0f8cb0c05f91182bc2c5bdbcc9dc36b96475d451f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.517999+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "18ad90913109b7fda81ae5108543a17db9b2e9614e42e0f4180d4a3ec60ef131", + "panel_kind": "sparse", + "panel_seed": 13295277435273124797, + "realization": 24, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "816ae9e5ff36ff691fb14f9917843bf3bc930e99572c4a3aaeb5b5b9c1c20073", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.039017049245403716, + "kernel_residual": 9.672505373110238e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.079337175388374, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.891035830457261, + "minus_target_entropy": 0.959727822917611, + "minus_weight": 3.9450280970101623, + "orthogonality_relative_error": 3.9166294669688393e-16, + "plus_external_effective_rank": 12.657320692059661, + "plus_external_entropy": 0.8623515749453114, + "plus_target_effective_rank": 19.34325328929082, + "plus_target_entropy": 0.9390604386893571, + "plus_weight": 190.92777714816822, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "5fd1d153d6ddb945b7401cc19601895ee573f09131de6b0303d8673aff0c340e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.564165+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "18ad90913109b7fda81ae5108543a17db9b2e9614e42e0f4180d4a3ec60ef131", + "panel_kind": "isotropic", + "panel_seed": 13295277435273124797, + "realization": 24, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6bdb16df0a7de95d5d784f3878c3e6c140483e67fe605d2ddfc3b45028fdc554", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.039017049245403716, + "kernel_residual": 9.672505373110238e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.09269010433613502, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.210570384225353, + "minus_target_entropy": 0.9719186396179382, + "minus_weight": 4.246480979860136, + "orthogonality_relative_error": 3.7979060168972605e-16, + "plus_external_effective_rank": 16.457833896329237, + "plus_external_entropy": 0.9088698440575351, + "plus_target_effective_rank": 22.092674343029273, + "plus_target_entropy": 0.9675242459056823, + "plus_weight": 174.65878088436523, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "501d802853cdb9dc13078efc8c1ff976c0dcf2e63ef461e484f7f5c8f349a927", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.613933+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "877258797b69667613dc6a3728164f0a75c3b1cb6a6ff7ae9dcbcaec2a054323", + "panel_kind": "sparse", + "panel_seed": 10056642251172038095, + "realization": 25, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4c91b48d36a6a068980e3c945bc1757d1526f32bae455a5c67b5b533baa0608f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04336137707138388, + "kernel_residual": 9.135435973038732e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08030892227865195, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.481450782397987, + "minus_target_entropy": 0.9391378274059528, + "minus_weight": 3.786556017982194, + "orthogonality_relative_error": 2.5430174188692757e-16, + "plus_external_effective_rank": 13.81385755652447, + "plus_external_entropy": 0.879845675519027, + "plus_target_effective_rank": 19.338941603603335, + "plus_target_entropy": 0.9406680014210914, + "plus_weight": 180.94716781619556, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "1e438d17889b1a16fd87f361162aeca2b5ba759675056b328f238e9f97bec5a7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.658342+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "877258797b69667613dc6a3728164f0a75c3b1cb6a6ff7ae9dcbcaec2a054323", + "panel_kind": "isotropic", + "panel_seed": 10056642251172038095, + "realization": 25, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ee338e207ba522e466f5261f2c08dc5e7af5792e5d45dc6603f763160bda898c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04336137707138388, + "kernel_residual": 9.135435973038732e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0827013815846243, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.061973939883839, + "minus_target_entropy": 0.9656369453951518, + "minus_weight": 4.126957702727019, + "orthogonality_relative_error": 2.59438841207805e-16, + "plus_external_effective_rank": 15.242288226371421, + "plus_external_entropy": 0.8946244458531183, + "plus_target_effective_rank": 22.24253365178964, + "plus_target_entropy": 0.969346338070928, + "plus_weight": 191.26471517881532, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "1d81c4812ec9dfb58d6ec80d1f6506a95601e89e43b1da0e60858cf6cb5c753f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.707134+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "455b72d82f0a24b115e11f0724c2f9d5712d4a16d64fefc23c192879e93ac49a", + "panel_kind": "sparse", + "panel_seed": 7703111330408262876, + "realization": 26, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "809e04f33117d65fb57bd13d6532eb374deef52b0d6108614366c17ff70cd725", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04255559204350772, + "kernel_residual": 9.435310641170021e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07787888473926498, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.677977711155954, + "minus_target_entropy": 0.9510856064739919, + "minus_weight": 3.9280319044248175, + "orthogonality_relative_error": 2.1793429006414624e-16, + "plus_external_effective_rank": 14.800876019409387, + "plus_external_entropy": 0.8873490613799156, + "plus_target_effective_rank": 21.252292402441867, + "plus_target_entropy": 0.95858306618275, + "plus_weight": 193.81513124989755, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "53fd7d052ad5c9d89b0838c28339da0a03818924c1b4391c38dcfc3c5fa19b66", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.748937+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "455b72d82f0a24b115e11f0724c2f9d5712d4a16d64fefc23c192879e93ac49a", + "panel_kind": "isotropic", + "panel_seed": 7703111330408262876, + "realization": 26, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "26ad4120384171384131fd5dc001e90bbef7876875528b0c2c531e79c14509fa", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04255559204350772, + "kernel_residual": 9.435310641170021e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0778952180224364, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.906583028399484, + "minus_target_entropy": 0.9609127002220231, + "minus_weight": 3.8354966903123433, + "orthogonality_relative_error": 2.304111200143174e-16, + "plus_external_effective_rank": 15.595823864420655, + "plus_external_entropy": 0.8996853347750999, + "plus_target_effective_rank": 21.785533541186076, + "plus_target_entropy": 0.9652807415493139, + "plus_weight": 189.2079775010883, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "834953319ab70e1128af356c3bc910cf1ddfd361f9d840aea1587e9271eae593", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.796640+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "855c409dc7d167c6057c4c87e8808ae2a90e5f48a8e79d0efeda32e4281ca8ec", + "panel_kind": "sparse", + "panel_seed": 619384347507738987, + "realization": 27, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e6441efd64420a8212745f66a319e43aa1a20d2868b0e2820ba72eb20d4df747", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.037710859087816025, + "kernel_residual": 9.371812877319012e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08128604736945222, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.893703292598664, + "minus_target_entropy": 0.9606004305165875, + "minus_weight": 4.127713440294628, + "orthogonality_relative_error": 4.142997201224517e-16, + "plus_external_effective_rank": 14.636844249499218, + "plus_external_entropy": 0.8826742744198447, + "plus_target_effective_rank": 19.89941822424145, + "plus_target_entropy": 0.949280112019775, + "plus_weight": 194.77749030302692, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "d98932ad40c53b10f2e251a38e104aa691e6b02cfcba70b7523255156e20f375", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.840627+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "855c409dc7d167c6057c4c87e8808ae2a90e5f48a8e79d0efeda32e4281ca8ec", + "panel_kind": "isotropic", + "panel_seed": 619384347507738987, + "realization": 27, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "84e2bb130416fc24ac371043ed07d1dfefd6af4e3e5ab1f3c7156b5c2543595e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.037710859087816025, + "kernel_residual": 9.371812877319012e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07937126878061747, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.909258305825506, + "minus_target_entropy": 0.9599264205939072, + "minus_weight": 4.001445417051791, + "orthogonality_relative_error": 4.384885873798812e-16, + "plus_external_effective_rank": 15.104295160418138, + "plus_external_entropy": 0.8933858762921899, + "plus_target_effective_rank": 21.85409148637087, + "plus_target_entropy": 0.966404934644868, + "plus_weight": 193.57151508756027, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "43ac7811f603e8a9e1ae16700573cac3c47d0d3846cea1e22b2dfaab7946f8a3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.887620+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "a008e7318f0e2ed1787e89952570f7c85a75700c9aecd426d3c4d554b8b72c15", + "panel_kind": "sparse", + "panel_seed": 9414262090148031847, + "realization": 28, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7323970c0fa01fbf049a21f8d0ba82f8c36250b6c567d140a394a8f0dd480c19", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03408167318359723, + "kernel_residual": 9.7006216950912e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.09473376791213606, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.008034526554224, + "minus_target_entropy": 0.9634132781388235, + "minus_weight": 4.387222456853992, + "orthogonality_relative_error": 2.999077668848089e-16, + "plus_external_effective_rank": 14.475710777141638, + "plus_external_entropy": 0.8813592044144649, + "plus_target_effective_rank": 18.828209876632016, + "plus_target_entropy": 0.9371736681233145, + "plus_weight": 176.36070936815528, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "46f8bcb586b9e16cb3f1e6e38ea9412d74d09e62fd923e21d64e0b5d3ef428de", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.929590+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "a008e7318f0e2ed1787e89952570f7c85a75700c9aecd426d3c4d554b8b72c15", + "panel_kind": "isotropic", + "panel_seed": 9414262090148031847, + "realization": 28, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fcc4afba0de3a525de73645482b5a4cb07a0a6470f4a1215c45f01e21cc2d905", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03408167318359723, + "kernel_residual": 9.7006216950912e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06917593228000651, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.0380074961725505, + "minus_target_entropy": 0.966084501263128, + "minus_weight": 3.8867564879053877, + "orthogonality_relative_error": 3.27604255463612e-16, + "plus_external_effective_rank": 13.416996117166219, + "plus_external_entropy": 0.8722461700556435, + "plus_target_effective_rank": 20.793406232567218, + "plus_target_entropy": 0.9585259102084502, + "plus_weight": 216.90301062432692, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "5b3762a69e1c93bd53cf0cfe4f52b585961c995a8348a8efdbdf6184a288c534", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.975347+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "f3237348441a24c07c5655af9044fab5023138a041c2f0b1c5c05c2dad6df297", + "panel_kind": "sparse", + "panel_seed": 1505830439293153535, + "realization": 29, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1f3bfbb9c47f142307a2515b8ff3e3331e22955e7b7cd0dffe4bca279e2a50aa", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.041701020043819606, + "kernel_residual": 9.448609638619279e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07716612243151771, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.780102756231253, + "minus_target_entropy": 0.9548532287194299, + "minus_weight": 3.9726420284209, + "orthogonality_relative_error": 2.501311660511251e-16, + "plus_external_effective_rank": 14.638895838189642, + "plus_external_entropy": 0.8897206671376168, + "plus_target_effective_rank": 19.78621225377902, + "plus_target_entropy": 0.9445157395394357, + "plus_weight": 197.90171094271398, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "1abe1bac5677d9c3069d5c3baae2aceaf91e0c341260e73f2a8e3ec2fb2f110a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.016747+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "f3237348441a24c07c5655af9044fab5023138a041c2f0b1c5c05c2dad6df297", + "panel_kind": "isotropic", + "panel_seed": 1505830439293153535, + "realization": 29, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0c48736c8299ffcd680a788895c70a67ca43ee6cd0fffe4a11b3a32ff579ea82", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.041701020043819606, + "kernel_residual": 9.448609638619279e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07430738426332094, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.909871315428448, + "minus_target_entropy": 0.9583777675835344, + "minus_weight": 3.9138853276621344, + "orthogonality_relative_error": 2.563813937155839e-16, + "plus_external_effective_rank": 15.21663302060028, + "plus_external_entropy": 0.8921087460864238, + "plus_target_effective_rank": 22.39907213434284, + "plus_target_entropy": 0.9690910336663062, + "plus_weight": 202.78289992725917, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "f11db895ed27f1ee28b80896f82335ee65309ccbd7278dc0eae10adf0cc208b8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.060666+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d295aba55d51caf1c86ac2aa2972142385f3359ec28807efd4c1938a2c54d27f", + "panel_kind": "sparse", + "panel_seed": 13826739762346464061, + "realization": 30, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "84e7cb63d1d00e87decd5632c5271f90a303b5938db3ee3ba996b7104b823b3a", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.046515867875906225, + "kernel_residual": 1.0166792220563414e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06628480576945835, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.990403432725482, + "minus_target_entropy": 0.9642529618565188, + "minus_weight": 3.522450837059854, + "orthogonality_relative_error": 4.837397164026053e-16, + "plus_external_effective_rank": 14.742983467881308, + "plus_external_entropy": 0.8789145920010278, + "plus_target_effective_rank": 20.400343843677973, + "plus_target_entropy": 0.9503408081174128, + "plus_weight": 205.4593103287845, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "32f6d90753428cd124ad825392fd1091b25a3844b527549641b68246636c389d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.099517+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d295aba55d51caf1c86ac2aa2972142385f3359ec28807efd4c1938a2c54d27f", + "panel_kind": "isotropic", + "panel_seed": 13826739762346464061, + "realization": 30, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f8bed5ba4fe9c639d9e3da38ac11996a9cf53249ea2a2c59719dd744d099aa35", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.046515867875906225, + "kernel_residual": 1.0166792220563414e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08442343118564147, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.230305189169924, + "minus_target_entropy": 0.9727352469943121, + "minus_weight": 4.2515893392696, + "orthogonality_relative_error": 4.878693091104856e-16, + "plus_external_effective_rank": 15.825621431500611, + "plus_external_entropy": 0.8997316846792153, + "plus_target_effective_rank": 22.66754588251347, + "plus_target_entropy": 0.9721142977052467, + "plus_weight": 192.8442884448262, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "d23bf25943169e4a1ae7e943a5bebe0cad22df49d91d8422aad51b28263a8fab", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.146903+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "990d21c1c2e3c4caa2d5cfd76fc21135f11d2593651646f55caf271d5abe2c31", + "panel_kind": "sparse", + "panel_seed": 1767629917062996345, + "realization": 31, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1ec372357d988b75238c89442c921794d5731cc087e97a261babab37b8ef3e8a", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02696673319787823, + "kernel_residual": 9.158190521276848e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08112129085507856, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.812933306231396, + "minus_target_entropy": 0.9529091866699106, + "minus_weight": 4.238667419246446, + "orthogonality_relative_error": 4.0342971102130916e-16, + "plus_external_effective_rank": 13.93668859881685, + "plus_external_entropy": 0.8766572779394022, + "plus_target_effective_rank": 19.344111272809645, + "plus_target_entropy": 0.9442649597600391, + "plus_weight": 200.43697282894152, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "66556ded0c2844d263bb23b8bd262d55994dbae2719cd283a0067a8d5b4fdf62", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.197361+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "990d21c1c2e3c4caa2d5cfd76fc21135f11d2593651646f55caf271d5abe2c31", + "panel_kind": "isotropic", + "panel_seed": 1767629917062996345, + "realization": 31, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "30d412faedc3c0cfe715443d56319d94e43217746cbbc25a95866dcd6844cfda", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02696673319787823, + "kernel_residual": 9.158190521276848e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07544342029473185, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.264377813975295, + "minus_target_entropy": 0.9748151476961749, + "minus_weight": 4.10724296969088, + "orthogonality_relative_error": 4.445734012613896e-16, + "plus_external_effective_rank": 13.292740001985976, + "plus_external_entropy": 0.8732152682928978, + "plus_target_effective_rank": 21.39605857146837, + "plus_target_entropy": 0.9626915088112893, + "plus_weight": 209.47045029015382, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "0279a5c208425ff284ab0ca7a5f8e86fae580194f48f52dc82d7199b52f46b81", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.247617+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "36779a95a007be60a62b3ae3f80649036a96928714bcd4a75e7882cd3d331664", + "panel_kind": "sparse", + "panel_seed": 14431721005041423857, + "realization": 32, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3691149ec23ffd6d5ab82fbe3eeac22da75e55858a423fb681ac4e7d1ea8026c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02805557985672942, + "kernel_residual": 1.0743698077509832e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.064543955753413, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.903152948727098, + "minus_target_entropy": 0.9591869050985873, + "minus_weight": 3.8494279879752247, + "orthogonality_relative_error": 4.281241160888051e-16, + "plus_external_effective_rank": 12.161960841532924, + "plus_external_entropy": 0.8452074652070601, + "plus_target_effective_rank": 18.86011287302905, + "plus_target_entropy": 0.9363760735116835, + "plus_weight": 230.79858067775956, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "dcefd080a3cc148cc7810bfbbdab56d459413e8d142ff3a9bdfd8d772470b10a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.296543+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "36779a95a007be60a62b3ae3f80649036a96928714bcd4a75e7882cd3d331664", + "panel_kind": "isotropic", + "panel_seed": 14431721005041423857, + "realization": 32, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e74c25c33837297caf767fcc00ec587711a2891eaf84aee1cb39ef0a0b61448a", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02805557985672942, + "kernel_residual": 1.0743698077509832e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06233464417184844, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.852291077782157, + "minus_target_entropy": 0.9545318673295816, + "minus_weight": 3.9076122428397686, + "orthogonality_relative_error": 4.335325494503823e-16, + "plus_external_effective_rank": 12.644572000827628, + "plus_external_entropy": 0.8569251984325927, + "plus_target_effective_rank": 21.456750455332692, + "plus_target_entropy": 0.9624149909888621, + "plus_weight": 242.87249804410308, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "3a7d1b94480696d680fb62f888456e44ff59e0aa4e3615819100748ad1cec809", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.361873+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "77f778e1f406718adff1851b5a105ad6866499a0fc49d9e38391dc4c5e63bffe", + "panel_kind": "sparse", + "panel_seed": 6163674277238423903, + "realization": 33, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6a8f961c19224de6a247c8356680cba4c7d18516c88259eb6e59e32aae955f76", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02431290869608705, + "kernel_residual": 1.029770387492062e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06533098265473934, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.8192181034859995, + "minus_target_entropy": 0.9581459404917425, + "minus_weight": 4.106309588480727, + "orthogonality_relative_error": 5.566286282437528e-16, + "plus_external_effective_rank": 10.524706261464205, + "plus_external_entropy": 0.8242657816000496, + "plus_target_effective_rank": 17.46542634546007, + "plus_target_entropy": 0.9203259953251238, + "plus_weight": 243.13378435116203, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "c7eda033cd6de6f81e5c512baa2576ebcbc318a3d7e151d1d10bd5a4ff27948a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.412090+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "77f778e1f406718adff1851b5a105ad6866499a0fc49d9e38391dc4c5e63bffe", + "panel_kind": "isotropic", + "panel_seed": 6163674277238423903, + "realization": 33, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0982f69fa26b243c9984eff8ad86f71b0622f5b17cad4b5677d391cbc4b5c57b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02431290869608705, + "kernel_residual": 1.029770387492062e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06091387880232937, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.068055219706227, + "minus_target_entropy": 0.9672876082389736, + "minus_weight": 3.856173522294837, + "orthogonality_relative_error": 5.303219829376822e-16, + "plus_external_effective_rank": 11.226870636370693, + "plus_external_entropy": 0.8445480649236758, + "plus_target_effective_rank": 20.526561474668874, + "plus_target_entropy": 0.9554445930184131, + "plus_weight": 245.44841087638318, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "775e50b2077155fc725978330177c9d013c23b5df3f0e2115429b82e291570e7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.465718+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "8da26b19dc58d564b8b6c3eaaf13f79a469e416c19278fba513af824431f60d0", + "panel_kind": "sparse", + "panel_seed": 9971808617202818391, + "realization": 34, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cd0f28246274e571adc9398b2de40d748d00f8677d69d96293de7ce0e519577c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.0334855292204153, + "kernel_residual": 9.035463246902373e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08483466654712873, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.803233394854467, + "minus_target_entropy": 0.9529946630980187, + "minus_weight": 4.252376407482744, + "orthogonality_relative_error": 2.959706298833491e-16, + "plus_external_effective_rank": 13.255679724046875, + "plus_external_entropy": 0.8620197226530973, + "plus_target_effective_rank": 18.273175571705043, + "plus_target_entropy": 0.928857867857152, + "plus_weight": 191.9028456812836, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "800546126ca328c0ccffd1a90f69b32985ef54a4140c7cf2b112b6e869e22d36", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.509827+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "8da26b19dc58d564b8b6c3eaaf13f79a469e416c19278fba513af824431f60d0", + "panel_kind": "isotropic", + "panel_seed": 9971808617202818391, + "realization": 34, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e42605e9363f6ae67a6a0caaa698385334013548ef3fdda2f06455b42432513f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.0334855292204153, + "kernel_residual": 9.035463246902373e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06630339447949857, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.893952817883276, + "minus_target_entropy": 0.9595361168972232, + "minus_weight": 3.953162667755162, + "orthogonality_relative_error": 3.438135131820729e-16, + "plus_external_effective_rank": 12.800940081265905, + "plus_external_entropy": 0.8620540029797883, + "plus_target_effective_rank": 22.209252271051387, + "plus_target_entropy": 0.9688121540850391, + "plus_weight": 230.51518894211807, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "b06c4c580ef645e56bd6c317a7f756c51a3e0d5dcd816e82b5123cb0f55a4da2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.559715+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "815b510b6c07acc1f54c16630d931ecc1db5e6b341117269d23102f9a9833c01", + "panel_kind": "sparse", + "panel_seed": 10539133455871650115, + "realization": 35, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5ebe25ac3999b85b40851144852b58e4d062352248b803d5b8a9d3d1facc5485", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03157968067103692, + "kernel_residual": 9.330078764929797e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05312925740064551, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.314406806979062, + "minus_target_entropy": 0.928839541755119, + "minus_weight": 3.4126152503844995, + "orthogonality_relative_error": 4.864528701776392e-16, + "plus_external_effective_rank": 12.718062439858942, + "plus_external_entropy": 0.8511549142430684, + "plus_target_effective_rank": 20.34318308301645, + "plus_target_entropy": 0.9515921256179183, + "plus_weight": 250.05746044589864, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "dd8bd118ad3121c22249dad60725b65d9200f411f993f71a12667d5c28755492", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.602966+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "815b510b6c07acc1f54c16630d931ecc1db5e6b341117269d23102f9a9833c01", + "panel_kind": "isotropic", + "panel_seed": 10539133455871650115, + "realization": 35, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3a4de5e33d42b9580e1fdaa184a2e88d9e50953e11943bf528901d4403711917", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03157968067103692, + "kernel_residual": 9.330078764929797e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07171512392362432, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.039109656113277, + "minus_target_entropy": 0.9646646042995715, + "minus_weight": 4.163174132405647, + "orthogonality_relative_error": 4.794460428895919e-16, + "plus_external_effective_rank": 14.561320977211151, + "plus_external_entropy": 0.8803867949307247, + "plus_target_effective_rank": 21.773448781609474, + "plus_target_entropy": 0.964483899163814, + "plus_weight": 223.80241002261738, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "bab86c13748f9df5f68f3bedea6a5a1a4d9588be3377ea3da2f8019698f7c0e8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.649358+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "9eada57451e660940b85b6d0b10bad62ce1cf9b3f53c4b07ae80fb4e470a27ea", + "panel_kind": "sparse", + "panel_seed": 2158251492828934580, + "realization": 36, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "987b5c7cc596e3b3af2facb09f9e9a98c767446bdaef0d7d4503fcab49e36677", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02162291312462984, + "kernel_residual": 1.0147273484964446e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06451087896703751, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.702888522198516, + "minus_target_entropy": 0.9481710085856364, + "minus_weight": 4.091032064821375, + "orthogonality_relative_error": 9.049333399743384e-16, + "plus_external_effective_rank": 10.175705436368556, + "plus_external_entropy": 0.8274085313051615, + "plus_target_effective_rank": 15.37523896820599, + "plus_target_entropy": 0.9066590902310526, + "plus_weight": 245.4143690250109, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "6072f9673df01a3bdb87e81481de722e542d8834865596851e50e105f1fc6966", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.692005+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "9eada57451e660940b85b6d0b10bad62ce1cf9b3f53c4b07ae80fb4e470a27ea", + "panel_kind": "isotropic", + "panel_seed": 2158251492828934580, + "realization": 36, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "151193604cf07896b407813215699c5c6d96c7d6574164a7850025b46eeaec75", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02162291312462984, + "kernel_residual": 1.0147273484964446e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0716882058718368, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.968117011022208, + "minus_target_entropy": 0.9609362113616182, + "minus_weight": 3.825531556653385, + "orthogonality_relative_error": 8.829350994441617e-16, + "plus_external_effective_rank": 12.304437490277248, + "plus_external_entropy": 0.8636051885582636, + "plus_target_effective_rank": 20.192497332023947, + "plus_target_entropy": 0.953302997011415, + "plus_weight": 205.73168947784018, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "8511d96b42056acf27ce56121ef0a766bf5d3f744a69ddb3db0965562d4c1a0c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.738686+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "bcb7996a6084456dfda3f8d5f1fab87e8f62ae69b5527b54f3be9fcb5d5e0d99", + "panel_kind": "sparse", + "panel_seed": 12216810490095280901, + "realization": 37, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7988f5c5655b22906a5a3a07ed196fc7017e07d27868c58539190cec02430d75", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02069793717279286, + "kernel_residual": 9.983547109539753e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06203904104193104, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.961716429707359, + "minus_target_entropy": 0.960623253860201, + "minus_weight": 3.761545281147348, + "orthogonality_relative_error": 1.110656052317372e-15, + "plus_external_effective_rank": 9.631192252282307, + "plus_external_entropy": 0.8155914716616439, + "plus_target_effective_rank": 16.984990332051208, + "plus_target_entropy": 0.9182433870601603, + "plus_weight": 234.94430818232038, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "1656c533ffcaa57c0217282a576d7a90747e1efe73f962864ef0343118f11806", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.781103+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "bcb7996a6084456dfda3f8d5f1fab87e8f62ae69b5527b54f3be9fcb5d5e0d99", + "panel_kind": "isotropic", + "panel_seed": 12216810490095280901, + "realization": 37, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d6c2e6dd71d38e6099b8f08310ff3a5b48b444589855def34c44346e81c9b309", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02069793717279286, + "kernel_residual": 9.983547109539753e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06422599249171478, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.997004270345313, + "minus_target_entropy": 0.9642251169614926, + "minus_weight": 3.7122999955485834, + "orthogonality_relative_error": 1.1125495625753338e-15, + "plus_external_effective_rank": 11.237078210831998, + "plus_external_entropy": 0.8489010657073353, + "plus_target_effective_rank": 20.616958203176782, + "plus_target_entropy": 0.9575088970317217, + "plus_weight": 223.71614243065784, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "278e92d793ad61653df4e7f6bbe70a7e2d92bbc50dfb416b0c0c5ee2907f115f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.826791+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4b5c3171902195b4d594c667a1ba902b7c11cb3a9b6a6c318496a94d7f6152dd", + "panel_kind": "sparse", + "panel_seed": 18238091485129436858, + "realization": 38, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b921c906890da072c6a6b0a17484407f1ec420418bc4ba8480c178849a655248", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.048038950543806545, + "kernel_residual": 9.837602849945985e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0867028896462665, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.744898254393439, + "minus_target_entropy": 0.9522409029327411, + "minus_weight": 4.050275389738761, + "orthogonality_relative_error": 2.470927804126754e-16, + "plus_external_effective_rank": 14.844083341286785, + "plus_external_entropy": 0.8839858674917777, + "plus_target_effective_rank": 19.422022218600283, + "plus_target_entropy": 0.9381186297905894, + "plus_weight": 178.66531965988312, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "678b06c479fbdece0d1fb421544379c81e9ce7dec8174c9cf3fa1e9ef56728af", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.867447+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4b5c3171902195b4d594c667a1ba902b7c11cb3a9b6a6c318496a94d7f6152dd", + "panel_kind": "isotropic", + "panel_seed": 18238091485129436858, + "realization": 38, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8b6b6f13a93cca3df4aaf977a840af9cedcf7a5acc3f170229cb3111bab2ca6c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.048038950543806545, + "kernel_residual": 9.837602849945985e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08165102136370783, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.052102138820547, + "minus_target_entropy": 0.9661624319546682, + "minus_weight": 4.01410304210797, + "orthogonality_relative_error": 2.7251072560803696e-16, + "plus_external_effective_rank": 15.786137085438167, + "plus_external_entropy": 0.9009707218771162, + "plus_target_effective_rank": 22.59688800979358, + "plus_target_entropy": 0.9718097533018838, + "plus_weight": 188.5331299386056, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "c5a9bf57606ff300dd5efa206fb54e00c0f956e270819b4cc4c13a854363fb40", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.911299+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "e80a160debfcf4078d4f3b6f08e36e025fc035124605fa65e1d37bb2125d149b", + "panel_kind": "sparse", + "panel_seed": 3207291759636131940, + "realization": 39, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "eac6c9de384f6ea6ed9b5489ca5b6f2b6445b629d7113384e489656610c3cd92", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.039518897209372475, + "kernel_residual": 1.0273719121787922e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07515430527125616, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.004811672356531, + "minus_target_entropy": 0.9630819775905803, + "minus_weight": 3.76883855493206, + "orthogonality_relative_error": 2.5835641818702185e-16, + "plus_external_effective_rank": 14.067637183882821, + "plus_external_entropy": 0.878319875779668, + "plus_target_effective_rank": 19.041406376019268, + "plus_target_entropy": 0.9391379659122395, + "plus_weight": 192.98074311855774, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "1625db9e1ed1a4cba55a4892a8b48c218a582aca125ee1ba9a55edb67162f84b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.950375+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "e80a160debfcf4078d4f3b6f08e36e025fc035124605fa65e1d37bb2125d149b", + "panel_kind": "isotropic", + "panel_seed": 3207291759636131940, + "realization": 39, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3863edcd671cbfd871e2dcea9d5754654e4bb1865e0df979eea76c2ff5aa004b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.039518897209372475, + "kernel_residual": 1.0273719121787922e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0748766658632248, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.026970926949175, + "minus_target_entropy": 0.9661131788437467, + "minus_weight": 3.7811898663331514, + "orthogonality_relative_error": 2.7195613505564466e-16, + "plus_external_effective_rank": 14.71850680215643, + "plus_external_entropy": 0.8897362886245386, + "plus_target_effective_rank": 22.024419743466385, + "plus_target_entropy": 0.9668234965110625, + "plus_weight": 194.35969103142958, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "53560586a07af3da6b4d79166d35c39d9e732ee1ea8af61264490ab73d45746a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.994685+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "fb72bb226c488287a1708c52b4416505f055486ee1e2e2546494fa6c70637f9a", + "panel_kind": "sparse", + "panel_seed": 6662868315813809543, + "realization": 40, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "07a4439385fe83869fffb0414a51cf2f8243aab89364a3154e1e43ae4e9c027c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02502586919981035, + "kernel_residual": 9.558798465081992e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06164140885694154, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.104318172257161, + "minus_target_entropy": 0.9677827813930184, + "minus_weight": 4.026935656543123, + "orthogonality_relative_error": 7.020454981062392e-16, + "plus_external_effective_rank": 11.811770446901223, + "plus_external_entropy": 0.8458155698613119, + "plus_target_effective_rank": 19.337371229803534, + "plus_target_entropy": 0.9392051977827722, + "plus_weight": 253.1957501737842, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 26, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "815b43cc2340678ffe000b623d3f0857d38cfac64522791d0250b8a482cc8e41", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.035254+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "fb72bb226c488287a1708c52b4416505f055486ee1e2e2546494fa6c70637f9a", + "panel_kind": "isotropic", + "panel_seed": 6662868315813809543, + "realization": 40, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "760c818a6d7726b4251b3474485ffc66aa323feb7aa29084de1c9cf7b7d1298a", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02502586919981035, + "kernel_residual": 9.558798465081992e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06033756943416116, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.998900087892035, + "minus_target_entropy": 0.9658851273098769, + "minus_weight": 3.920507874553746, + "orthogonality_relative_error": 6.6258508812977e-16, + "plus_external_effective_rank": 13.227096726261891, + "plus_external_entropy": 0.862535191925603, + "plus_target_effective_rank": 20.93703117692301, + "plus_target_entropy": 0.9577306314971631, + "plus_weight": 252.0029170363194, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "4078ba4ff0e2e26a81014d65b8f368fa79be589f79683873c238606906791bbc", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.080757+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "e25a140e3056d91fbfb3fa5ea398bc3a88de509a8afb0ad852f9754b53a7a76b", + "panel_kind": "sparse", + "panel_seed": 8403647489397277179, + "realization": 41, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "906519a5bac690e8ab2c08f94383e46091a0f3db45cd0091bddcb5a5a1d34aba", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03400872649428884, + "kernel_residual": 9.692802728360985e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0755392845953507, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.948661440995042, + "minus_target_entropy": 0.9626011895723015, + "minus_weight": 3.8778455626166304, + "orthogonality_relative_error": 2.63285595804616e-16, + "plus_external_effective_rank": 14.238499153894324, + "plus_external_entropy": 0.8806711237199739, + "plus_target_effective_rank": 19.90474531983833, + "plus_target_entropy": 0.9459532910529257, + "plus_weight": 197.5100994187035, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "73aa3d76268cec17912277e65356c0410456c0847e74971bd6322d47e262edd7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.119787+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "e25a140e3056d91fbfb3fa5ea398bc3a88de509a8afb0ad852f9754b53a7a76b", + "panel_kind": "isotropic", + "panel_seed": 8403647489397277179, + "realization": 41, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1eaf32766cd58e02f54d825041bf2dd3f9794276efe35f47a3586989dd81e535", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03400872649428884, + "kernel_residual": 9.692802728360985e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07076934353510553, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.700791185235813, + "minus_target_entropy": 0.9511388867965135, + "minus_weight": 3.6431719675242147, + "orthogonality_relative_error": 2.687231375213996e-16, + "plus_external_effective_rank": 14.711479701124375, + "plus_external_entropy": 0.8914146119606206, + "plus_target_effective_rank": 21.85136476021242, + "plus_target_entropy": 0.9662364705961971, + "plus_weight": 198.56490036166235, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "9e233d92ade978d82113578e7333683451241ec6341bba082ec9d176b6bbdac2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.165100+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "605d0defdf3d3fd0dead7213e10b22752eb01fdde457bb6b37c529c7bbf5cc37", + "panel_kind": "sparse", + "panel_seed": 9797533269871939222, + "realization": 42, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5157e996bfc4e64c30be273226e5c02045147cff923c65a183e585e6797686af", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.026193847047509742, + "kernel_residual": 1.023637585852314e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.055277816734955944, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.339704583530888, + "minus_target_entropy": 0.9338290010421565, + "minus_weight": 3.4559879397953983, + "orthogonality_relative_error": 6.689452668763523e-16, + "plus_external_effective_rank": 12.017864118963107, + "plus_external_entropy": 0.8473930045028154, + "plus_target_effective_rank": 19.315519087584875, + "plus_target_entropy": 0.9404647202073171, + "plus_weight": 243.12025989290905, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "dbe2d45c2eab756ee037d68392a3006eb44ab622105a64bae31dd32918727a16", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.206036+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "605d0defdf3d3fd0dead7213e10b22752eb01fdde457bb6b37c529c7bbf5cc37", + "panel_kind": "isotropic", + "panel_seed": 9797533269871939222, + "realization": 42, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cdd9ba11bdb4af877ae16ff6120bb0dde38ca42b7a9735584d30a8455757dd94", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.026193847047509742, + "kernel_residual": 1.023637585852314e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06731547259437921, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.946803898331027, + "minus_target_entropy": 0.9619166151752089, + "minus_weight": 4.007668135935188, + "orthogonality_relative_error": 6.535646880834198e-16, + "plus_external_effective_rank": 12.58690399759952, + "plus_external_entropy": 0.8609979182413718, + "plus_target_effective_rank": 20.956166190304252, + "plus_target_entropy": 0.9587523196213195, + "plus_weight": 230.05731345121848, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "2bb718ca1dd45a207944bcb646364bedf838369012c19ae346c2949025503eea", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.251391+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "cc441f7edb6defad68cf2c2983bed05bbc787eb49059e3fb0cea750aba08642d", + "panel_kind": "sparse", + "panel_seed": 16154021174208469419, + "realization": 43, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2732cd3a864d10c3ebf80ebb6eec076307edca4c63f19083c5434b78a9703aa7", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.022269304608184753, + "kernel_residual": 9.425912648055657e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06742166566149393, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.792876544529535, + "minus_target_entropy": 0.9523113680856485, + "minus_weight": 4.229943326426285, + "orthogonality_relative_error": 3.82112192116305e-16, + "plus_external_effective_rank": 10.880787861592875, + "plus_external_entropy": 0.8322453658735965, + "plus_target_effective_rank": 15.018924180737287, + "plus_target_entropy": 0.8918904700618431, + "plus_weight": 242.42084924732018, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 26, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "c6ee8061b3318da3e58736c31f0dde54e4ee6b3e0b8cc7cd0c101f5c4eea8a6c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.292301+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "cc441f7edb6defad68cf2c2983bed05bbc787eb49059e3fb0cea750aba08642d", + "panel_kind": "isotropic", + "panel_seed": 16154021174208469419, + "realization": 43, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2f13c0ad03e99bfbb738abc16498716a035b6f24d773f4f4926a945184ba8cd6", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.022269304608184753, + "kernel_residual": 9.425912648055657e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07173515371856627, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.7993206009443705, + "minus_target_entropy": 0.9547560400652271, + "minus_weight": 4.037127781664822, + "orthogonality_relative_error": 4.013031209369782e-16, + "plus_external_effective_rank": 13.004466506921183, + "plus_external_entropy": 0.8689782509459495, + "plus_target_effective_rank": 20.62945077758871, + "plus_target_entropy": 0.957084951592126, + "plus_weight": 216.96356080255777, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "d18f2d1064bb79306d407d19a30715d8f1f759bdef0bb550c7785500050e9c9f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.338102+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "457d3bd293bd10298d7b79061a552aad2ddeac37be1fc3771ce0f82007001a94", + "panel_kind": "sparse", + "panel_seed": 11886831641460578176, + "realization": 44, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ab3e4c45a0f36022bbeb2a4344f42d0cc370be62f5184489b8851ae2dd8f0ad4", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03233857788525284, + "kernel_residual": 9.313668085201289e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08719735495336117, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.078127021891789, + "minus_target_entropy": 0.9656777800004775, + "minus_weight": 4.164814233867163, + "orthogonality_relative_error": 2.6248731860421845e-16, + "plus_external_effective_rank": 13.226755345994288, + "plus_external_entropy": 0.8733071324969655, + "plus_target_effective_rank": 19.806581464480114, + "plus_target_entropy": 0.9457023493410647, + "plus_weight": 182.62771288814696, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "9250c0fb0d710c5a8b878c77ad7082cff716e40c3100b483212133eb13e1bc59", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.378323+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "457d3bd293bd10298d7b79061a552aad2ddeac37be1fc3771ce0f82007001a94", + "panel_kind": "isotropic", + "panel_seed": 11886831641460578176, + "realization": 44, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "155541ee9414983b9f174690ff38a4cf909bf1138159f54c60d5f5aa53910457", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03233857788525284, + "kernel_residual": 9.313668085201289e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07835576742665028, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.745784252575066, + "minus_target_entropy": 0.9512491402799261, + "minus_weight": 3.9596496277746938, + "orthogonality_relative_error": 2.8174343736780574e-16, + "plus_external_effective_rank": 13.57540595780099, + "plus_external_entropy": 0.882777605254768, + "plus_target_effective_rank": 21.310357606902986, + "plus_target_entropy": 0.9625674325040574, + "plus_weight": 194.13692311576366, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "098c59c0d15703ef934d5847b7196a24d112240fad50c6b3a26fa82580a302ed", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.423093+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "28d731a34370633435d8f3d94f698dfa214701a7c1b285242bd117627b278342", + "panel_kind": "sparse", + "panel_seed": 17881522337787230694, + "realization": 45, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5a5fe0d32337ebc748f90b5c3493247d350882fc69abf3e9dad01f873e18c949", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.017862708183946523, + "kernel_residual": 9.264379474265396e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05139102397619967, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.559457942919041, + "minus_target_entropy": 0.9447350810424161, + "minus_weight": 3.885257929999615, + "orthogonality_relative_error": 8.507357586620323e-16, + "plus_external_effective_rank": 8.542598472353946, + "plus_external_entropy": 0.7817676173761468, + "plus_target_effective_rank": 17.349219762325095, + "plus_target_entropy": 0.9217011076540378, + "plus_weight": 294.5857543096155, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "6add67265ad7f3c01be722db25c1fcdf13253a04943c91bc78b9455d5d028c87", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.464126+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "28d731a34370633435d8f3d94f698dfa214701a7c1b285242bd117627b278342", + "panel_kind": "isotropic", + "panel_seed": 17881522337787230694, + "realization": 45, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4a6416d09f98f4c5d32fb58e4027ca612b77d5b84a0b76dd7ec8241301895dbc", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.017862708183946523, + "kernel_residual": 9.264379474265396e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05129382589305509, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.645153223074956, + "minus_target_entropy": 0.9479439937757507, + "minus_weight": 3.7098578802070907, + "orthogonality_relative_error": 8.362496807968016e-16, + "plus_external_effective_rank": 9.869415318093951, + "plus_external_entropy": 0.8145510095716753, + "plus_target_effective_rank": 19.647896297226342, + "plus_target_entropy": 0.9464759738485283, + "plus_weight": 281.8339397399008, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "97f9851667fc53e4fd571b87eb93d5f1d5fbf484cdc5bd5aca4c5c027b8fee9d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.508851+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "52dac1585c2139ac72d2827989b68b4123faf105375579e5a02c4e5656efbfcc", + "panel_kind": "sparse", + "panel_seed": 14696773893940220218, + "realization": 46, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7a4b48cfdd17d33dfb73a08f35fd3ae9a91755205e760772df1b050d53c7e9f3", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03831236941152241, + "kernel_residual": 9.493073913869347e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.09021546883312853, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.855593929248275, + "minus_target_entropy": 0.9566275008949848, + "minus_weight": 4.221250499155497, + "orthogonality_relative_error": 3.933998018803304e-16, + "plus_external_effective_rank": 14.961759653526013, + "plus_external_entropy": 0.8843711690401799, + "plus_target_effective_rank": 19.913849727498352, + "plus_target_entropy": 0.9486209612369317, + "plus_weight": 178.62078701631413, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "db7ead260359fe472b64cc3916e728e27663bd00a81e4fce85521f842a4e2725", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.549117+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "52dac1585c2139ac72d2827989b68b4123faf105375579e5a02c4e5656efbfcc", + "panel_kind": "isotropic", + "panel_seed": 14696773893940220218, + "realization": 46, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ddbf681354806645d9a01e6dc37fa784807ee2dbd9de1ea0258397548d0d3df8", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03831236941152241, + "kernel_residual": 9.493073913869347e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07722885706490738, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.921269741661641, + "minus_target_entropy": 0.9607110297037, + "minus_weight": 4.041320720177114, + "orthogonality_relative_error": 4.46273245296473e-16, + "plus_external_effective_rank": 14.187325166211568, + "plus_external_entropy": 0.8832286341349469, + "plus_target_effective_rank": 21.429789874170503, + "plus_target_entropy": 0.9631705376738899, + "plus_weight": 201.1527794015161, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "dd76834a8f990583c1f04fc9d688abc8639528ee7cab01836bbf4dee16d404ba", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.591746+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "34c5d1709c8858451d0c9de9376b8ac1267e46d81e9aed5f933cdc123f64de77", + "panel_kind": "sparse", + "panel_seed": 8492369121304438099, + "realization": 47, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c5efba8217a235546afe23d8c25161b1d555d56078d6e782f0a0d3fd2dad2880", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04026904206950467, + "kernel_residual": 9.027250007247453e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07245987196661022, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.494109189788115, + "minus_target_entropy": 0.9367270197269056, + "minus_weight": 3.7963361323611684, + "orthogonality_relative_error": 3.3925564185157124e-16, + "plus_external_effective_rank": 15.119520731074205, + "plus_external_entropy": 0.8839839887319959, + "plus_target_effective_rank": 19.82303787780229, + "plus_target_entropy": 0.9456133147887199, + "plus_weight": 201.90496916243453, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "ffd2b2754cef7aeb8037bd3a935c9a8c55a96057999a4eef96d85d9d1149d340", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.630371+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "34c5d1709c8858451d0c9de9376b8ac1267e46d81e9aed5f933cdc123f64de77", + "panel_kind": "isotropic", + "panel_seed": 8492369121304438099, + "realization": 47, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "63347603df776923b17f363cac707103148f4357ce1275eae1a7a298fbb7da2d", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04026904206950467, + "kernel_residual": 9.027250007247453e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07850001228533657, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.055972929849011, + "minus_target_entropy": 0.9673150331162019, + "minus_weight": 4.089242382732605, + "orthogonality_relative_error": 3.4210758216410825e-16, + "plus_external_effective_rank": 15.496683829783938, + "plus_external_entropy": 0.8947756928710727, + "plus_target_effective_rank": 22.337823394262344, + "plus_target_entropy": 0.9692432033907958, + "plus_weight": 200.10695640777925, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "5fd61768a368af98b4c1b314040f3f5f460a327314093133cf8b8c4f54b6c8e7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.672537+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "02b210d3f10b7053a48ef76208e720a548b4f04ed69a24ae9ede47889e3c76d6", + "panel_kind": "sparse", + "panel_seed": 16760624523105391144, + "realization": 48, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "17b969bccd9c53e43344cf6087b307a8ede79d0a3a3210d747c77684cfd6a742", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024166435068516828, + "kernel_residual": 1.0000913715441384e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06480809165357339, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.972536044815611, + "minus_target_entropy": 0.9618414440179434, + "minus_weight": 4.29415964955505, + "orthogonality_relative_error": 2.9379180296505915e-16, + "plus_external_effective_rank": 11.716106247590748, + "plus_external_entropy": 0.8466072879512423, + "plus_target_effective_rank": 19.88207491758332, + "plus_target_entropy": 0.946964423034917, + "plus_weight": 256.3782441062548, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "2801dbdfa368fa0043730b951b98b5cb21de240399905abe054f9683a90d21f7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.711546+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "02b210d3f10b7053a48ef76208e720a548b4f04ed69a24ae9ede47889e3c76d6", + "panel_kind": "isotropic", + "panel_seed": 16760624523105391144, + "realization": 48, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "695002a2b3be3302d0fd6665a5a8bae0dad12af028c86fdbdbdbdbed90e99240", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024166435068516828, + "kernel_residual": 1.0000913715441384e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06167481919492837, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.694453731528625, + "minus_target_entropy": 0.9482474417066672, + "minus_weight": 3.834799348409473, + "orthogonality_relative_error": 2.966539594655995e-16, + "plus_external_effective_rank": 14.026693407301787, + "plus_external_entropy": 0.8741109926932841, + "plus_target_effective_rank": 21.050461102015667, + "plus_target_entropy": 0.9603888087507672, + "plus_weight": 240.9802380114515, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "4f60f0d283412948e9a3af3094fc36e168da4f24fb58535a44f7f1c08427e465", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.754094+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "ec0284f0eaba622e2d70eed2e027df8f42c4bbcd4d89ddb17f6e0ea8b5f88e56", + "panel_kind": "sparse", + "panel_seed": 1896903169962237912, + "realization": 49, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3b5a7443ece9583107ee8750f65ecbd9c706227bba42eb410d65b7632fb92f3c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024421055593207047, + "kernel_residual": 9.484423459040625e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07012405278642665, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.887675455741111, + "minus_target_entropy": 0.9605022675769841, + "minus_weight": 3.976067977661003, + "orthogonality_relative_error": 4.666767873577399e-16, + "plus_external_effective_rank": 11.999699300912, + "plus_external_entropy": 0.8510190777449931, + "plus_target_effective_rank": 18.435343451146917, + "plus_target_entropy": 0.9292724033724191, + "plus_weight": 218.7775528533251, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "30a4aa7f95633f7ad2a31c0037ca938f09b962de5aa10ec9d491d7165e3e3780", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.792679+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "ec0284f0eaba622e2d70eed2e027df8f42c4bbcd4d89ddb17f6e0ea8b5f88e56", + "panel_kind": "isotropic", + "panel_seed": 1896903169962237912, + "realization": 49, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e6e8caae96f6c353dd3353b6abbfb089c82900d03cfa51df25e55b8d0ba22ded", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024421055593207047, + "kernel_residual": 9.484423459040625e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.059530598805394457, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.987368861142755, + "minus_target_entropy": 0.9639738375660297, + "minus_weight": 3.7591435928026584, + "orthogonality_relative_error": 4.764349465141844e-16, + "plus_external_effective_rank": 11.864157129497691, + "plus_external_entropy": 0.8523093360831268, + "plus_target_effective_rank": 20.27728240041017, + "plus_target_entropy": 0.954363134665384, + "plus_weight": 245.009676421824, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "4f872c9e05e73ac3bbd6bdeb80f2acb51bb5b7b6e8f55c2584470f8f6947ceb0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.835524+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "a100be657d2ccbb7e5379f981fbd4eb4da4cd540a64e2118865153187d9a5e57", + "panel_kind": "sparse", + "panel_seed": 8117014381380433351, + "realization": 50, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "94290456a63c4f136338ec174817a8d319ba16dda9e5cf556eace5e41584e0a1", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03843913849718271, + "kernel_residual": 9.239192584269058e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05411316224946724, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.219210098154999, + "minus_target_entropy": 0.9224173683664569, + "minus_weight": 3.2340581787400335, + "orthogonality_relative_error": 4.347642517788398e-16, + "plus_external_effective_rank": 12.096140205977743, + "plus_external_entropy": 0.8527870376030422, + "plus_target_effective_rank": 19.533324482226536, + "plus_target_entropy": 0.9392036652879329, + "plus_weight": 232.54580092745746, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "f913f4232caf0702b87a916991a9969d9cf542269f432341b5051ea85440d694", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.873699+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "a100be657d2ccbb7e5379f981fbd4eb4da4cd540a64e2118865153187d9a5e57", + "panel_kind": "isotropic", + "panel_seed": 8117014381380433351, + "realization": 50, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e47ee0057fd9365d6433a4c6c217197a1e80bf0009f5aa2a482c49e4d9384f7d", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03843913849718271, + "kernel_residual": 9.239192584269058e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07296868147289996, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.106317425394345, + "minus_target_entropy": 0.9679741307610771, + "minus_weight": 3.9622006015476323, + "orthogonality_relative_error": 4.526239908107396e-16, + "plus_external_effective_rank": 13.675075481880054, + "plus_external_entropy": 0.875941129775982, + "plus_target_effective_rank": 21.4503726969906, + "plus_target_entropy": 0.9629650409193022, + "plus_weight": 209.20062148655597, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "f72109ae56f49795911d719c341af7c1b88bda9228d07b03bee148b743b64b2c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.915723+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2a962f06c1da8720288571ddf6eb2a9fc29d1147e6b59d95bf6fde48e59f4158", + "panel_kind": "sparse", + "panel_seed": 14047963382650668555, + "realization": 51, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5fe8e699553aff1871106456ce1bf61b7db26294080e871d3b2f9c0f776472c4", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03215721518465336, + "kernel_residual": 9.883171931623477e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0704683730925614, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.521310207862921, + "minus_target_entropy": 0.9384662832916205, + "minus_weight": 3.8301870832005593, + "orthogonality_relative_error": 3.004829084111879e-16, + "plus_external_effective_rank": 13.080451445531484, + "plus_external_entropy": 0.862704954536116, + "plus_target_effective_rank": 19.51394660814401, + "plus_target_entropy": 0.9419953062302729, + "plus_weight": 209.68277400059287, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "290b5e351731c0b94c939df2bd654e584f7b569b9ee7253c01dfafaa187fcaca", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.953900+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2a962f06c1da8720288571ddf6eb2a9fc29d1147e6b59d95bf6fde48e59f4158", + "panel_kind": "isotropic", + "panel_seed": 14047963382650668555, + "realization": 51, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bff15895dcf03741e49f96ee581834b4b6af21f29e0305c14d8c2264d7042dd3", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03215721518465336, + "kernel_residual": 9.883171931623477e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06768989363759507, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.97774784863008, + "minus_target_entropy": 0.9611887472930127, + "minus_weight": 3.549797227638392, + "orthogonality_relative_error": 3.1440289361895646e-16, + "plus_external_effective_rank": 13.417216763262777, + "plus_external_entropy": 0.8813395249648679, + "plus_target_effective_rank": 21.554697122291863, + "plus_target_entropy": 0.9652190211271025, + "plus_weight": 202.60643683668616, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "0a0d30c55d087d2599da0ca38617a6dbdabb1198594fbc63ec4a70315b9c758c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.995502+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "6ed4cc7e0ca318e51026ab14cae5316c211bea4915bcc5bd8f2db97b93bf5e58", + "panel_kind": "sparse", + "panel_seed": 6069293613950820156, + "realization": 52, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "80c166f9e665b4f88e40f02c327d2fdbfff7d4be57d4155cc395fcda96accb9f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.016725794403252024, + "kernel_residual": 1.0745160579740704e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05542610836987752, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.726650318675205, + "minus_target_entropy": 0.9537671765443556, + "minus_weight": 3.7442607218904818, + "orthogonality_relative_error": 3.9006666581697325e-16, + "plus_external_effective_rank": 10.043058191050495, + "plus_external_entropy": 0.8314134115307467, + "plus_target_effective_rank": 18.626242207528943, + "plus_target_entropy": 0.93622670199247, + "plus_weight": 262.6744959571675, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 26, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "b5a11b9d8137ff3ea6fa1b80a222e42ae6d2ef9d00ada9ad0d8ff8c5aea86981", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.033487+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "6ed4cc7e0ca318e51026ab14cae5316c211bea4915bcc5bd8f2db97b93bf5e58", + "panel_kind": "isotropic", + "panel_seed": 6069293613950820156, + "realization": 52, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c56d7fbcfce7d6ba7731fd2d5ca53ba9cda26943f8a5e67d59caf7f4812111ed", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.016725794403252024, + "kernel_residual": 1.0745160579740704e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0642140151983096, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.806619472750399, + "minus_target_entropy": 0.9569799931061199, + "minus_weight": 3.8918924332574876, + "orthogonality_relative_error": 3.8793922029682197e-16, + "plus_external_effective_rank": 12.184283358822622, + "plus_external_entropy": 0.8559195770321355, + "plus_target_effective_rank": 20.52830966901159, + "plus_target_entropy": 0.9562527443033222, + "plus_weight": 234.58423186421845, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "a5cbff3d0f1b81f6984d8fda6d08310609696879a0a9fd38c89de9fb2995e33e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.075011+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "90036f47e26990688be9256989ed5fbb4e2d06965ac70a0bbe677b99ec47b543", + "panel_kind": "sparse", + "panel_seed": 15819019725900743756, + "realization": 53, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ed93d38eb1213a0eda41d368481d167afce8504bd878979383e053f616457673", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024442387483140066, + "kernel_residual": 1.0503737428563818e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.04978432013238374, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.025215691790306, + "minus_target_entropy": 0.9655588854587503, + "minus_weight": 3.8274785366350574, + "orthogonality_relative_error": 4.2267992746679557e-16, + "plus_external_effective_rank": 10.420047509577094, + "plus_external_entropy": 0.8182615865394832, + "plus_target_effective_rank": 18.507890260518, + "plus_target_entropy": 0.9250848601062401, + "plus_weight": 299.82100298549284, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 25, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "45545b000165ab8fd391254cb83332c160d183a8a8ebab924295c614941ad541", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.112224+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "90036f47e26990688be9256989ed5fbb4e2d06965ac70a0bbe677b99ec47b543", + "panel_kind": "isotropic", + "panel_seed": 15819019725900743756, + "realization": 53, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9b6a481e9a54aa266cf0698a50d6e7f98e0279a768e4e5d5d716e5cbce0a3080", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024442387483140066, + "kernel_residual": 1.0503737428563818e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06057990210603284, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.938109072174344, + "minus_target_entropy": 0.9605200173029658, + "minus_weight": 4.139399861602291, + "orthogonality_relative_error": 3.949270992449002e-16, + "plus_external_effective_rank": 12.903762473606932, + "plus_external_entropy": 0.8507889146506253, + "plus_target_effective_rank": 20.946026279886453, + "plus_target_entropy": 0.9578319540405571, + "plus_weight": 264.97489440265974, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "65b57544997458c61fba9960b52df08d65cc8efb0cbd40a01abdbd9a9dcb922b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.152816+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d1e8ebc6e9511b143ef83b57e11e76aec0a105fee1a12b34b4b9f89e2b63ae5c", + "panel_kind": "sparse", + "panel_seed": 13246710990002478436, + "realization": 54, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9f355a1ea1a1950067d1a52d992dab2d057db7aba6f2a7da2eca9f3d97869fcc", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.037646188873057075, + "kernel_residual": 9.276103082323517e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0778724607325321, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.003647887208307, + "minus_target_entropy": 0.9646454300495064, + "minus_weight": 3.82563468692216, + "orthogonality_relative_error": 3.3294179045147364e-16, + "plus_external_effective_rank": 13.553414358531118, + "plus_external_entropy": 0.8758822323444221, + "plus_target_effective_rank": 20.18872146586509, + "plus_target_entropy": 0.9492687723384228, + "plus_weight": 188.7789111811717, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "97bb7f260824648f802af80de7d1365a8be437b43eecb255f80e2c2622cd6e3d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.190079+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d1e8ebc6e9511b143ef83b57e11e76aec0a105fee1a12b34b4b9f89e2b63ae5c", + "panel_kind": "isotropic", + "panel_seed": 13246710990002478436, + "realization": 54, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9d29dec7693b1069b0d0e71906b3c703450a8a5941575e7f180e793729a4b103", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.037646188873057075, + "kernel_residual": 9.276103082323517e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08008276097420303, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.85484214156462, + "minus_target_entropy": 0.95733364931975, + "minus_weight": 3.874471288458335, + "orthogonality_relative_error": 3.43446840077589e-16, + "plus_external_effective_rank": 13.95680156566429, + "plus_external_entropy": 0.8871269603732846, + "plus_target_effective_rank": 21.913156068030816, + "plus_target_entropy": 0.9667653999680311, + "plus_weight": 185.69357925447133, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "592a1042482497f9964535e5cb060f12ab22cc8e2fbaff5cb1ee8bc83ae4fa10", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.232894+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "1ecc6616268cf3f6ec52362f4336d9e2b1b48881fa0b23b01165d1060fe32b2d", + "panel_kind": "sparse", + "panel_seed": 2324830867988564616, + "realization": 55, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "61dbfafbd44312f79db9d652578cdc3c2f7dc051fb88cd3d3ab49d9ada7de72b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.027191015384236555, + "kernel_residual": 9.97844655067301e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06646039321186675, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.987499162920886, + "minus_target_entropy": 0.9637755172704525, + "minus_weight": 4.236231486035447, + "orthogonality_relative_error": 3.2565910672957617e-16, + "plus_external_effective_rank": 12.372674472241304, + "plus_external_entropy": 0.8478616072815764, + "plus_target_effective_rank": 20.061127909080728, + "plus_target_entropy": 0.9477634150778369, + "plus_weight": 246.4174807266818, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "7bb8287c5b19ecd6196fbdaeba36496e6ccbb331f9600148ae38590f7c972a16", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.271696+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "1ecc6616268cf3f6ec52362f4336d9e2b1b48881fa0b23b01165d1060fe32b2d", + "panel_kind": "isotropic", + "panel_seed": 2324830867988564616, + "realization": 55, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4f97fddc1e40f204c3ab4795b63b0c0321b26b42e9647d7a6451fd86bc2b1a8e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.027191015384236555, + "kernel_residual": 9.97844655067301e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06358882536823156, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.924625504874044, + "minus_target_entropy": 0.9565925524430613, + "minus_weight": 4.069466157508311, + "orthogonality_relative_error": 3.2302255104239065e-16, + "plus_external_effective_rank": 12.803377769519587, + "plus_external_entropy": 0.8591709189586358, + "plus_target_effective_rank": 20.777126967362843, + "plus_target_entropy": 0.9566323089996597, + "plus_weight": 247.78047709417413, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "6f3a78cd72654284808929ea5e36f275dad42307b48acf48ba3ec02ceb564591", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.314427+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "422af7550e579b4c040cba3aaf20da66207ec689f0c038b23356c5eb9fb6a4b6", + "panel_kind": "sparse", + "panel_seed": 14962966328289050529, + "realization": 56, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "106582588ee3bc33fb15694ebf34b03d2aa85ef035484dd6727ea8a930eb310f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.034697468975178426, + "kernel_residual": 9.554888773646797e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0883568825774921, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.970543396602764, + "minus_target_entropy": 0.9636929993242136, + "minus_weight": 4.3905336378347375, + "orthogonality_relative_error": 2.1556687059313701e-16, + "plus_external_effective_rank": 13.221749370020813, + "plus_external_entropy": 0.8670869751047701, + "plus_target_effective_rank": 16.954031661791415, + "plus_target_entropy": 0.9076605795272183, + "plus_weight": 189.88104052552845, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "f3755655edc6fd6e6bd6ff191f9279146463e46d017bc0df4158cf65accab6ac", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.351020+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "422af7550e579b4c040cba3aaf20da66207ec689f0c038b23356c5eb9fb6a4b6", + "panel_kind": "isotropic", + "panel_seed": 14962966328289050529, + "realization": 56, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0755725b2302b69a0a399ec8586fb31e392880898c8d72080d44f3ca50f8f362", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.034697468975178426, + "kernel_residual": 9.554888773646797e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06590200426588991, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.921398094579067, + "minus_target_entropy": 0.9588613251834956, + "minus_weight": 3.81230987394945, + "orthogonality_relative_error": 2.3427313014867256e-16, + "plus_external_effective_rank": 13.334997216079344, + "plus_external_entropy": 0.8683042027765103, + "plus_target_effective_rank": 21.160911510400265, + "plus_target_entropy": 0.9605094616381087, + "plus_weight": 223.70306285152054, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "3c55c89578adf706d23cf566d5baae1324b7d658766a2a85d71eafc141291c14", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.391962+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "8cdb3df5d1f2d0eda80f5f8cbac68dce2c1cbf3410d4663e53b3441773235de7", + "panel_kind": "sparse", + "panel_seed": 17926435067593881341, + "realization": 57, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "becfe16bfa57e92e4ab5c67c6ec9f2a7238f49c1354b04ba817dee4741dd664e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04285823177772459, + "kernel_residual": 9.294823039903429e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08679493131457917, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.727329378731199, + "minus_target_entropy": 0.9533070678961939, + "minus_weight": 3.9621455726702535, + "orthogonality_relative_error": 2.621104957456375e-16, + "plus_external_effective_rank": 14.385815035507465, + "plus_external_entropy": 0.8891778787502628, + "plus_target_effective_rank": 19.251830599161227, + "plus_target_entropy": 0.9411289249779938, + "plus_weight": 174.58380511911307, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "457433e32d364ebbc82018fb64b3c63a3ca085eb52f7bdf41cebde3ec32e2d76", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.429349+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "8cdb3df5d1f2d0eda80f5f8cbac68dce2c1cbf3410d4663e53b3441773235de7", + "panel_kind": "isotropic", + "panel_seed": 17926435067593881341, + "realization": 57, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d6c157e3d070a79f2c904fec70c1fc3ef8b6bc469537ddecc325d33aacb86a34", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04285823177772459, + "kernel_residual": 9.294823039903429e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08190054070811141, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.091450746137314, + "minus_target_entropy": 0.968354624580777, + "minus_weight": 3.9035576059106867, + "orthogonality_relative_error": 2.608317207295391e-16, + "plus_external_effective_rank": 14.428907861967584, + "plus_external_entropy": 0.8891620198394689, + "plus_target_effective_rank": 21.94171097351204, + "plus_target_entropy": 0.967339812569048, + "plus_weight": 182.75819360981424, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "ce1f81b1786877df67a09e70e3eb07076ebe0cd03d17423c1ae3287fe3fd89c4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.471557+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "965db5b6f61132dacf4b060ed3a9c69d8237b0826f03015320dc1d3c242603f1", + "panel_kind": "sparse", + "panel_seed": 14163288257799102656, + "realization": 58, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5b5cee8a7bf908a92380c5bba7a8a8bd6e6d0fb8acad1ae72c9349607d8e7b46", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03932241435288355, + "kernel_residual": 9.762347694878459e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08068606819903926, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.111807682491484, + "minus_target_entropy": 0.9692380536970092, + "minus_weight": 4.128261910632498, + "orthogonality_relative_error": 3.196523259929045e-16, + "plus_external_effective_rank": 13.973105839476924, + "plus_external_entropy": 0.877289968742924, + "plus_target_effective_rank": 20.699050671704207, + "plus_target_entropy": 0.9549450470637374, + "plus_weight": 196.31464266718007, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "a0945f8af515aa3c010e84125624f419edac570d55931c40b2a4f18d348f7686", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.508821+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "965db5b6f61132dacf4b060ed3a9c69d8237b0826f03015320dc1d3c242603f1", + "panel_kind": "isotropic", + "panel_seed": 14163288257799102656, + "realization": 58, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "30533fc318a2d973bb915caedef3e45ae41231c4fb8eb69013bdf9097c17489e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03932241435288355, + "kernel_residual": 9.762347694878459e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0751018797061872, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.914268857290263, + "minus_target_entropy": 0.9586025189218659, + "minus_weight": 3.9130383811029823, + "orthogonality_relative_error": 3.253051462973766e-16, + "plus_external_effective_rank": 14.798078816210662, + "plus_external_entropy": 0.8890758899163534, + "plus_target_effective_rank": 22.223634200163122, + "plus_target_entropy": 0.9686487420058987, + "plus_weight": 200.5098324659722, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "19c2e84d1f5c63c2d9b790c63e7ac05e5261ad851d1c59d4f449e6d2471c1daa", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.549795+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "dadfc99483813338a7bc9cc40d24c6029813476c77eb5729a5e9c222bd2aee90", + "panel_kind": "sparse", + "panel_seed": 14882293012189588689, + "realization": 59, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9433e404d3402eaa84a61bd4f5fe96838ffcc629d8f21f265166e66e30f2ca5b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03633728057950958, + "kernel_residual": 9.384097187666501e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07420736029433471, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.801273686422592, + "minus_target_entropy": 0.9546174826231777, + "minus_weight": 3.791637270831068, + "orthogonality_relative_error": 3.720459468676297e-16, + "plus_external_effective_rank": 13.501922438194901, + "plus_external_entropy": 0.8676859113263501, + "plus_target_effective_rank": 19.575808383546946, + "plus_target_entropy": 0.9415861049386685, + "plus_weight": 196.72430339407282, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "3661845b0e3d24c5cc38d654394cf4964ae56bb6e689408fb51258b1d56a9fa3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.588000+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "dadfc99483813338a7bc9cc40d24c6029813476c77eb5729a5e9c222bd2aee90", + "panel_kind": "isotropic", + "panel_seed": 14882293012189588689, + "realization": 59, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ae5cce6cc82a8404dca6de1e0b4bddfe0bdcef953d24619ad564f41cf65a5927", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03633728057950958, + "kernel_residual": 9.384097187666501e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07777077302351904, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.014659150349764, + "minus_target_entropy": 0.9661782364697651, + "minus_weight": 3.98000482128359, + "orthogonality_relative_error": 4.133531517015045e-16, + "plus_external_effective_rank": 14.678869366270959, + "plus_external_entropy": 0.8903465905004365, + "plus_target_effective_rank": 22.20026392565734, + "plus_target_entropy": 0.9688485802961357, + "plus_weight": 196.66384274503685, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "855a4c2093c459388f5a5e7d5e4412adc308a1590bbc0f8b80867b2b03cca010", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.631030+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "cbe5c913d9e70deb70fb84e233db3af5b95b0652b5f2921fa30e164b85b1b485", + "panel_kind": "sparse", + "panel_seed": 9472426558819414799, + "realization": 60, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5b205578731f01249fb19f7403473918c18bbc82c01946d2dd628df00aa2728f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02496383966418628, + "kernel_residual": 9.849216416805847e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05043125156083095, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.759954912363268, + "minus_target_entropy": 0.9552571890984698, + "minus_weight": 3.6569524995887575, + "orthogonality_relative_error": 3.186019692807103e-16, + "plus_external_effective_rank": 10.21790188020221, + "plus_external_entropy": 0.8184336713314004, + "plus_target_effective_rank": 17.636897492071885, + "plus_target_entropy": 0.9261126260867343, + "plus_weight": 282.69325934225503, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "2267c8e71f845e4610df0450cb7919602e8519cf4ac82f72ab086d756a28967f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.667470+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "cbe5c913d9e70deb70fb84e233db3af5b95b0652b5f2921fa30e164b85b1b485", + "panel_kind": "isotropic", + "panel_seed": 9472426558819414799, + "realization": 60, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "72f737a7438d0738748622ec6e98bf0b548bfa0ff7c47f281d982edbf26a840f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02496383966418628, + "kernel_residual": 9.849216416805847e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06613608547544156, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.807002917508126, + "minus_target_entropy": 0.9550565554216606, + "minus_weight": 3.9198232707067415, + "orthogonality_relative_error": 3.266281308850504e-16, + "plus_external_effective_rank": 12.587931845802677, + "plus_external_entropy": 0.8581254120300758, + "plus_target_effective_rank": 20.808462275035964, + "plus_target_entropy": 0.9581322524545088, + "plus_weight": 229.1695259418185, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "ea75512d93522597840aa5e219121ae3fcd991813a65a87a3bd713d6ad9ebf82", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.708456+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "04d690e398c7de094fb0a9434e832cb3fbe4c6a804013ec77a46818324d3379e", + "panel_kind": "sparse", + "panel_seed": 3094758090458480140, + "realization": 61, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "874d5a6a1d08f5e474d9ccba62ff9ba6023636434689e167f6c8ecc958a10779", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.035913647182111694, + "kernel_residual": 9.616809060997128e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08357325534487574, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.083307986446312, + "minus_target_entropy": 0.9675252762691392, + "minus_weight": 4.315456935301139, + "orthogonality_relative_error": 3.198297389273064e-16, + "plus_external_effective_rank": 12.864610974811116, + "plus_external_entropy": 0.8761544109986572, + "plus_target_effective_rank": 19.216868060653546, + "plus_target_entropy": 0.9386879210574219, + "plus_weight": 197.82221524944694, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 26, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "a900b266dbffb519944c0c95895dc1bc610bb8481afca2c76f58d131e92d1a51", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.745663+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "04d690e398c7de094fb0a9434e832cb3fbe4c6a804013ec77a46818324d3379e", + "panel_kind": "isotropic", + "panel_seed": 3094758090458480140, + "realization": 61, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e66234a19de29af1c6865c491f2e8e4a4f9461f478ace085a210fefbf12da254", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.035913647182111694, + "kernel_residual": 9.616809060997128e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07357704084689615, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.9976464124870486, + "minus_target_entropy": 0.9647877295720158, + "minus_weight": 3.8616320607578185, + "orthogonality_relative_error": 3.2639777034333933e-16, + "plus_external_effective_rank": 14.483578807160086, + "plus_external_entropy": 0.8884834967297529, + "plus_target_effective_rank": 21.851544799057816, + "plus_target_entropy": 0.9665146320973665, + "plus_weight": 202.13976052390188, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "fe62bc284714d4ea00643309f1abcceb2ebb5f33bd78e14894a5d6e2353006b9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.786947+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "b40529d7f84b2c02c164d20870da2d8726f73fdf0da0bb77f9117d80530b38a5", + "panel_kind": "sparse", + "panel_seed": 735977835594361410, + "realization": 62, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "02ded3f71ad4569dd77a1c1a35cb0756671982a0f89fb9de716490785083dd1e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.022077208473463072, + "kernel_residual": 1.0367532680892504e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.043524826173991386, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.433219881992342, + "minus_target_entropy": 0.9399772434478231, + "minus_weight": 3.4715031212252576, + "orthogonality_relative_error": 8.452663893953391e-16, + "plus_external_effective_rank": 10.689917459125642, + "plus_external_entropy": 0.815577894639894, + "plus_target_effective_rank": 19.46557206085253, + "plus_target_entropy": 0.9426670400442516, + "plus_weight": 312.0549728090864, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "4cc4cfae5457779920c0817d8171ab850c67fd793f8bbb4f6958e826790c00e9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.822891+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "b40529d7f84b2c02c164d20870da2d8726f73fdf0da0bb77f9117d80530b38a5", + "panel_kind": "isotropic", + "panel_seed": 735977835594361410, + "realization": 62, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "eb456c8528ee78eadc08777e84e6c87ebf6465c8c02816c2126073d0040ab90e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.022077208473463072, + "kernel_residual": 1.0367532680892504e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05659002334614523, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.962125961175115, + "minus_target_entropy": 0.9627457893588793, + "minus_weight": 3.8590918553173736, + "orthogonality_relative_error": 8.012751899262861e-16, + "plus_external_effective_rank": 12.130187475735942, + "plus_external_entropy": 0.852130349258116, + "plus_target_effective_rank": 21.07251266174129, + "plus_target_entropy": 0.9602255413244202, + "plus_weight": 265.0010386792851, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "1b931ff477a9b9007ce59c1adf0e70f2f040c4216f006aeb7db1ced8d4967810", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.862013+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d6118a63b4ff40122e549429fe4309e78ab0f83c176cefbd40caf026d31180bc", + "panel_kind": "sparse", + "panel_seed": 6462186101004937597, + "realization": 63, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c55f02dff31d438e15bcc42d7d0e4a83cd41fa1a43aaa062d1f594843c4c4fa2", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04890236339354925, + "kernel_residual": 9.33350731896364e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0819690860247444, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.106753923964923, + "minus_target_entropy": 0.9681438304909481, + "minus_weight": 3.9328971025299726, + "orthogonality_relative_error": 2.0618852898690301e-16, + "plus_external_effective_rank": 15.521735729149622, + "plus_external_entropy": 0.8948185932989486, + "plus_target_effective_rank": 20.8154052698482, + "plus_target_entropy": 0.9556998716025302, + "plus_weight": 183.97112242784186, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "08e0b750805a23ed5eb2c49ab1cf49d1c814be1cf30fd4a188658871b4e8a538", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.896882+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d6118a63b4ff40122e549429fe4309e78ab0f83c176cefbd40caf026d31180bc", + "panel_kind": "isotropic", + "panel_seed": 6462186101004937597, + "realization": 63, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a9eda22596c26afd5490842ecb461280a0a5965355b660bebc5f3f387ee221bc", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04890236339354925, + "kernel_residual": 9.33350731896364e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08539437709596681, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.0123612782730085, + "minus_target_entropy": 0.9642593000958389, + "minus_weight": 4.003870184244082, + "orthogonality_relative_error": 2.11441376980676e-16, + "plus_external_effective_rank": 16.136944975389884, + "plus_external_entropy": 0.9066247278476562, + "plus_target_effective_rank": 22.440805030320337, + "plus_target_entropy": 0.9701903714063876, + "plus_weight": 179.45017749810555, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + } + ], + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_covariates_pilot_N10_banked.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_covariates_pilot_N10_banked.json new file mode 100644 index 000000000..c8fa8e392 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_covariates_pilot_N10_banked.json @@ -0,0 +1,12299 @@ +{ + "checks": { + "all_safe_checks": true, + "complete_requested_grid": true, + "no_outcome_leakage": true + }, + "passed": true, + "records": [ + { + "arrays_sha256": "c8717df2ef92e797c25996539e5a3fc25f0d0810129f480910f0dfd78746baea", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:06.170506+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "9f7748cc111122bd6643f90ff89e805343eff1a874a6539e73b58368d2adb023", + "panel_kind": "sparse", + "panel_seed": 18330923054686305452, + "realization": 0, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9c4e51098b4f5925444b917e8cc44d1bda1b0699b890e93e44da4d2b7d73fc8f", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1561162183456809, + "kernel_residual": 3.3093133935807476e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 32.616654972234954, + "minus_external_entropy": 0.9528153508606346, + "minus_target_effective_rank": 81.20400186918205, + "minus_target_entropy": 0.9340603593938095, + "minus_weight": 282.95327095822245, + "orthogonality_relative_error": 1.515722101397546e-16, + "plus_external_effective_rank": 32.616654972234976, + "plus_external_entropy": 0.9528153508606344, + "plus_target_effective_rank": 81.20400186918206, + "plus_target_entropy": 0.9340603593938095, + "plus_weight": 282.95327095822245, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "c25be6a203edd9820ed1790a0c7a36ebdf4ddcf4f9236f9774c4a4187e9a306c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:53.040096+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "9f7748cc111122bd6643f90ff89e805343eff1a874a6539e73b58368d2adb023", + "panel_kind": "isotropic", + "panel_seed": 18330923054686305452, + "realization": 0, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "14dcedf64d921c9f8ba4a59d8e4a987638d2bf64aefe4b48dc3d04264bfc2f92", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1561162183456809, + "kernel_residual": 3.3093133935807476e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 34.846961090301896, + "minus_external_entropy": 0.9636957319365894, + "minus_target_effective_rank": 104.65339999652129, + "minus_target_entropy": 0.9482285284070819, + "minus_weight": 286.9888124354737, + "orthogonality_relative_error": 1.4881146342631161e-16, + "plus_external_effective_rank": 34.84696109030192, + "plus_external_entropy": 0.9636957319365892, + "plus_target_effective_rank": 104.65339999652132, + "plus_target_entropy": 0.9482285284070822, + "plus_weight": 286.9888124354736, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "ed9a74dcf86da542aa1759faa4238950a09ec9bd20429841e147225de95fc5d9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:05.554211+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "efc02573fc57f1cc503e700ab9db18e52647c78379e25fbf383109246a43f5c1", + "panel_kind": "sparse", + "panel_seed": 4532576265242426819, + "realization": 1, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2ac4fa977503dc51b504d096df04512f0bda76dbc58e48d662be3310aabbd8fa", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1418523731419675, + "kernel_residual": 3.3036437956353386e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 28.62159153625188, + "minus_external_entropy": 0.9292130232221059, + "minus_target_effective_rank": 70.23210982598155, + "minus_target_entropy": 0.9328200288174688, + "minus_weight": 299.35391745716043, + "orthogonality_relative_error": 1.4705157170227898e-16, + "plus_external_effective_rank": 28.62159153625185, + "plus_external_entropy": 0.9292130232221059, + "plus_target_effective_rank": 70.23210982598155, + "plus_target_entropy": 0.9328200288174688, + "plus_weight": 299.3539174571605, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "0e191adad1ec564bfbb6f6742b239b7d488382f427372d1c63a3f259d6fe5742", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:36.118583+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "efc02573fc57f1cc503e700ab9db18e52647c78379e25fbf383109246a43f5c1", + "panel_kind": "isotropic", + "panel_seed": 4532576265242426819, + "realization": 1, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ffa402fa6e91a9f70403376bd8af16239ed1e140ed1245be05fd2e2090352b77", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1418523731419675, + "kernel_residual": 3.3036437956353386e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 32.891983835768364, + "minus_external_entropy": 0.9553939116688772, + "minus_target_effective_rank": 102.98913306319724, + "minus_target_entropy": 0.9457693643069254, + "minus_weight": 299.6004131606635, + "orthogonality_relative_error": 1.4899347011056812e-16, + "plus_external_effective_rank": 32.89198383576834, + "plus_external_entropy": 0.9553939116688773, + "plus_target_effective_rank": 102.98913306319724, + "plus_target_entropy": 0.9457693643069254, + "plus_weight": 299.6004131606636, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "aa56052c8ab39f553562743bbeabcccb0605bf16f8a3eb97976eaae2e878941a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:04.343182+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "9807e5656a1719f39c302f2bae5f28c6cbbc1ca19f09f9aa6b1a8d5d2cb418aa", + "panel_kind": "sparse", + "panel_seed": 10930736999065707006, + "realization": 2, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8b5a36ee3bf8bb41be1c3a2cad16d00f59d2bc3f306c3160a9039648b82c3f8b", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.12376925824813924, + "kernel_residual": 3.4270913484206717e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 27.87711948117728, + "minus_external_entropy": 0.9317550376100895, + "minus_target_effective_rank": 79.93959929470276, + "minus_target_entropy": 0.9321405270926841, + "minus_weight": 312.2556730718626, + "orthogonality_relative_error": 1.748185242357787e-16, + "plus_external_effective_rank": 27.877119481177296, + "plus_external_entropy": 0.9317550376100899, + "plus_target_effective_rank": 79.93959929470275, + "plus_target_entropy": 0.9321405270926844, + "plus_weight": 312.25567307186236, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "8f8789ad052c24118d698e6dff646b75ecd05e41a946f76d7ea334bfba8ff9fd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:29.230507+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "9807e5656a1719f39c302f2bae5f28c6cbbc1ca19f09f9aa6b1a8d5d2cb418aa", + "panel_kind": "isotropic", + "panel_seed": 10930736999065707006, + "realization": 2, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c6809eadc0e4d3082bafe197c9ed997b88059c4bfffeac2c466cc06f7b4490d6", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.12376925824813924, + "kernel_residual": 3.4270913484206717e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 31.1903180253748, + "minus_external_entropy": 0.9496952056989166, + "minus_target_effective_rank": 101.95097224229164, + "minus_target_entropy": 0.9451147773175658, + "minus_weight": 308.5383789094715, + "orthogonality_relative_error": 1.6808036950214805e-16, + "plus_external_effective_rank": 31.19031802537482, + "plus_external_entropy": 0.9496952056989171, + "plus_target_effective_rank": 101.95097224229173, + "plus_target_entropy": 0.9451147773175658, + "plus_weight": 308.53837890947125, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "70c771ad59df6946817a3d46a96fd27ab3704d22fb04eeb5f1e0f78fb89f061b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:05.580174+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "bca163d2aad8814aa836eda806c6392bbfbbaeac5b94290cd7b899c8801d9418", + "panel_kind": "sparse", + "panel_seed": 15994058055488772162, + "realization": 3, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "dfd4e335215e0384f0da5ac6c8ce57d6efe99e0afb8c8bb5185b2c7ba1b96622", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14052416007779303, + "kernel_residual": 3.2363363643135758e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 30.85067356533602, + "minus_external_entropy": 0.944834408223086, + "minus_target_effective_rank": 77.88090796226678, + "minus_target_entropy": 0.9335952439180086, + "minus_weight": 284.08541771109185, + "orthogonality_relative_error": 1.372125715835746e-16, + "plus_external_effective_rank": 30.85067356533601, + "plus_external_entropy": 0.944834408223086, + "plus_target_effective_rank": 77.88090796226679, + "plus_target_entropy": 0.9335952439180086, + "plus_weight": 284.08541771109196, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "40df2997c95c9724c266093e4f3433f65d82bf59800c34f719fab3a1d30a363d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:41.543830+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "bca163d2aad8814aa836eda806c6392bbfbbaeac5b94290cd7b899c8801d9418", + "panel_kind": "isotropic", + "panel_seed": 15994058055488772162, + "realization": 3, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b4c9e9d1fdbdad72cd9ead988af2cb48e504fc50419b2af45f050d6d0d27fc43", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14052416007779303, + "kernel_residual": 3.2363363643135758e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 33.72818636533229, + "minus_external_entropy": 0.959997806918064, + "minus_target_effective_rank": 104.90925427968415, + "minus_target_entropy": 0.9483778376558397, + "minus_weight": 288.7368227391215, + "orthogonality_relative_error": 1.409368156445103e-16, + "plus_external_effective_rank": 33.72818636533226, + "plus_external_entropy": 0.9599978069180641, + "plus_target_effective_rank": 104.90925427968415, + "plus_target_entropy": 0.9483778376558395, + "plus_weight": 288.7368227391215, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "4c307685dade4ce9bd9f2f49db56c6e57d830e447a7e204209c5c9c242120930", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:04.674801+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "0812a13f38ddcbb41ebe442e64f2d10d230e6f0f2690e1615ad3d4979ac34c3a", + "panel_kind": "sparse", + "panel_seed": 9989501234288223678, + "realization": 4, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7b1e406daaec1ca8053f0bac113be4e86b41a88bad9c4fd391232393f468f851", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15133608098130297, + "kernel_residual": 3.271786155348237e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 30.955420501171393, + "minus_external_entropy": 0.9500094415189987, + "minus_target_effective_rank": 82.8167329771788, + "minus_target_entropy": 0.9361193564081347, + "minus_weight": 286.8914887427111, + "orthogonality_relative_error": 1.4355528226456754e-16, + "plus_external_effective_rank": 30.955420501171364, + "plus_external_entropy": 0.9500094415189989, + "plus_target_effective_rank": 82.8167329771788, + "plus_target_entropy": 0.9361193564081345, + "plus_weight": 286.8914887427112, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 44, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 44, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "b48d733ff96f5602f4236926b1677324bd8a26cdcaee47f3253e2324b21ae4f3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:36.115040+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "0812a13f38ddcbb41ebe442e64f2d10d230e6f0f2690e1615ad3d4979ac34c3a", + "panel_kind": "isotropic", + "panel_seed": 9989501234288223678, + "realization": 4, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0cb7e4a3d5478f1a327440467870819694baf89fbfc5872f917e9dde1e336252", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15133608098130297, + "kernel_residual": 3.271786155348237e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 34.18425385557778, + "minus_external_entropy": 0.9612518888139656, + "minus_target_effective_rank": 104.34283858008486, + "minus_target_entropy": 0.947603826125647, + "minus_weight": 284.438718997904, + "orthogonality_relative_error": 1.4047474818828476e-16, + "plus_external_effective_rank": 34.184253855577765, + "plus_external_entropy": 0.9612518888139655, + "plus_target_effective_rank": 104.34283858008486, + "plus_target_entropy": 0.947603826125647, + "plus_weight": 284.4387189979042, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "cdf6b0c7cc0e8fc7527a6598fdb93f8f9cb413f19e3c62ba7063a408d9d07ebd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:04.755906+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "88366ce241e0720bfafe3ccc8336ef47a1a650b86c8d1339c3eed1defe7165bf", + "panel_kind": "sparse", + "panel_seed": 18081555134914159961, + "realization": 5, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ba2645785e0d895ac02b2a836954b02f59c6b0f28cdc06d8b6ea91e6fa066d68", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.12058487545537876, + "kernel_residual": 3.3764768476464305e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 28.164890059697168, + "minus_external_entropy": 0.9330636730204839, + "minus_target_effective_rank": 74.90569467654323, + "minus_target_entropy": 0.930157944902253, + "minus_weight": 303.13383327012684, + "orthogonality_relative_error": 1.359032945014014e-16, + "plus_external_effective_rank": 28.164890059697168, + "plus_external_entropy": 0.9330636730204839, + "plus_target_effective_rank": 74.90569467654326, + "plus_target_entropy": 0.930157944902253, + "plus_weight": 303.13383327012673, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "2d5a5e34f8517494c279e7197f327084bdedf7b8e31a6121df70f09f5ba4a693", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:36.300479+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "88366ce241e0720bfafe3ccc8336ef47a1a650b86c8d1339c3eed1defe7165bf", + "panel_kind": "isotropic", + "panel_seed": 18081555134914159961, + "realization": 5, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "496ab56e32521476f1f43b55fb61bb3cbb5651e1572ab21cc048878869f3b9bb", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.12058487545537876, + "kernel_residual": 3.3764768476464305e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 32.76241237420616, + "minus_external_entropy": 0.9565384018640197, + "minus_target_effective_rank": 101.7803130498517, + "minus_target_entropy": 0.9452696426711089, + "minus_weight": 294.9479901044949, + "orthogonality_relative_error": 1.3413604790947503e-16, + "plus_external_effective_rank": 32.762412374206164, + "plus_external_entropy": 0.9565384018640197, + "plus_target_effective_rank": 101.78031304985177, + "plus_target_entropy": 0.9452696426711087, + "plus_weight": 294.9479901044949, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "7343d717f8f8ba3688c13df2ccbb81607d11fea342bc61973b7b2a10949925d6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:44:52.135799+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "9dab30707098e1881461b0fdba621f63c521c5891302f5ca17d84de47cf676ea", + "panel_kind": "sparse", + "panel_seed": 10612859955870065703, + "realization": 6, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ce738609ea2064c23ce532b6663c7eb746e9a7564804ea052508a7df7277abfe", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1498381978907188, + "kernel_residual": 3.2835520383677753e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 32.27678011056383, + "minus_external_entropy": 0.9512530490138118, + "minus_target_effective_rank": 80.9831138806853, + "minus_target_entropy": 0.9343336570857547, + "minus_weight": 286.90266963218437, + "orthogonality_relative_error": 1.4642225118363706e-16, + "plus_external_effective_rank": 32.27678011056381, + "plus_external_entropy": 0.9512530490138118, + "plus_target_effective_rank": 80.98311388068527, + "plus_target_entropy": 0.9343336570857548, + "plus_weight": 286.90266963218437, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "c3a58abb4b4de2cd9c7503bd6bcee1ce77eefa9a9ce8354501f08d045650d7ba", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:27.073329+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "9dab30707098e1881461b0fdba621f63c521c5891302f5ca17d84de47cf676ea", + "panel_kind": "isotropic", + "panel_seed": 10612859955870065703, + "realization": 6, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8793335decc6f1a1d954ababce8eaedcf6f83263a87eb8437b1ac555b60ebc41", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1498381978907188, + "kernel_residual": 3.2835520383677753e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 34.50245061063582, + "minus_external_entropy": 0.9625551235883674, + "minus_target_effective_rank": 104.35049614038763, + "minus_target_entropy": 0.9475298486918111, + "minus_weight": 289.4995194841468, + "orthogonality_relative_error": 1.5191716730109408e-16, + "plus_external_effective_rank": 34.502450610635805, + "plus_external_entropy": 0.9625551235883674, + "plus_target_effective_rank": 104.35049614038763, + "plus_target_entropy": 0.9475298486918111, + "plus_weight": 289.4995194841466, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "eca1ca5a3460456d73b543e11baa7d136641d28af87598dfff646323541828b5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:44:51.741159+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "245d3753c2c7ea5ca500758665c430ea96e1c6cf494f9c648acb550ae200b525", + "panel_kind": "sparse", + "panel_seed": 5793494924379600303, + "realization": 7, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cb96964e40abb614e9744e7f7087f8643dc27d1f6d3406ba457243435f757053", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15704136706550767, + "kernel_residual": 3.310545674031436e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 30.134101853803198, + "minus_external_entropy": 0.9402532845799073, + "minus_target_effective_rank": 72.83459089426697, + "minus_target_entropy": 0.9318917670418329, + "minus_weight": 287.92611415199474, + "orthogonality_relative_error": 1.3151770099260074e-16, + "plus_external_effective_rank": 30.134101853803234, + "plus_external_entropy": 0.9402532845799074, + "plus_target_effective_rank": 72.83459089426698, + "plus_target_entropy": 0.9318917670418329, + "plus_weight": 287.92611415199445, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 44, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 44, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "c8a4ae33b0bdf9e96a35c44a79bea56758196838fe013f23fd283251aabf38b7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:39.802289+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "245d3753c2c7ea5ca500758665c430ea96e1c6cf494f9c648acb550ae200b525", + "panel_kind": "isotropic", + "panel_seed": 5793494924379600303, + "realization": 7, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "42daca43175c2c8558d0b86cd532c368a09dcd227e401eb49015c4466fc4ebd2", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15704136706550767, + "kernel_residual": 3.310545674031436e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 34.49796915829241, + "minus_external_entropy": 0.9623445238197146, + "minus_target_effective_rank": 104.36494681259315, + "minus_target_entropy": 0.9476998179774792, + "minus_weight": 289.24345699976067, + "orthogonality_relative_error": 1.3274884916321392e-16, + "plus_external_effective_rank": 34.49796915829245, + "plus_external_entropy": 0.9623445238197148, + "plus_target_effective_rank": 104.36494681259312, + "plus_target_entropy": 0.9476998179774794, + "plus_weight": 289.2434569997606, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "f02b9f37a512eb46827e4108f0f8f41f916d21bd3ef0eb239dde8eafdce370c2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:30.130532+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "0408b85c6257448ea92b078672b574f3b16159fda45eeef81b01fdd885b0c6f9", + "panel_kind": "sparse", + "panel_seed": 5187498986858355873, + "realization": 8, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6390b29190262e4c359e40a562d2bc7fa4c782dd178374de6b859c15588d30c2", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.11527615781927422, + "kernel_residual": 3.373722069767504e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 28.44375747871809, + "minus_external_entropy": 0.9328950853388196, + "minus_target_effective_rank": 81.85843439671275, + "minus_target_entropy": 0.9300167698769765, + "minus_weight": 322.0407623024683, + "orthogonality_relative_error": 1.8389390021919253e-16, + "plus_external_effective_rank": 28.443757478718073, + "plus_external_entropy": 0.9328950853388196, + "plus_target_effective_rank": 81.85843439671272, + "plus_target_entropy": 0.9300167698769765, + "plus_weight": 322.04076230246835, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "385f745c3d35bd4f73dae137667e0c772e5b2b642ccc5c233816b8198c9bd52c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:17.511030+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "0408b85c6257448ea92b078672b574f3b16159fda45eeef81b01fdd885b0c6f9", + "panel_kind": "isotropic", + "panel_seed": 5187498986858355873, + "realization": 8, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5c0cecdcc1ba68b66a948e15dc9bddd4b17446c746c1072eb6c1fae4c88da834", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.11527615781927422, + "kernel_residual": 3.373722069767504e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 30.57702339048959, + "minus_external_entropy": 0.9452700478454259, + "minus_target_effective_rank": 98.98841444564513, + "minus_target_entropy": 0.94141412517395, + "minus_weight": 321.1793910004491, + "orthogonality_relative_error": 1.7986904118367268e-16, + "plus_external_effective_rank": 30.577023390489565, + "plus_external_entropy": 0.9452700478454258, + "plus_target_effective_rank": 98.98841444564506, + "plus_target_entropy": 0.94141412517395, + "plus_weight": 321.17939100044913, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "9ae7ef018daae635ef7c979f51473b3bcbdf3b0a003d88cd400a340b2dba9777", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:07.933101+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "19e1b1c349fc11d0bc20192891a81a5b21ef5a44b7d77bfc013913fe86b432be", + "panel_kind": "sparse", + "panel_seed": 3791321627556155355, + "realization": 9, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7348ace1f4599a5101d7d4195f8bcd426479e1b91797ca2f8f59260f60725ad3", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.13469105839343123, + "kernel_residual": 3.407429393498607e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 28.344027995251516, + "minus_external_entropy": 0.9340979890291908, + "minus_target_effective_rank": 74.69569961551545, + "minus_target_entropy": 0.9347820574069149, + "minus_weight": 304.016276868547, + "orthogonality_relative_error": 1.6530520238182377e-16, + "plus_external_effective_rank": 28.344027995251555, + "plus_external_entropy": 0.934097989029191, + "plus_target_effective_rank": 74.69569961551547, + "plus_target_entropy": 0.9347820574069149, + "plus_weight": 304.0162768685469, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 44, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 44, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "3d3c4bda6009a1948335b27de7edfe2732361ef0de07f2753cd40d3ea589ea4a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:37.944868+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "19e1b1c349fc11d0bc20192891a81a5b21ef5a44b7d77bfc013913fe86b432be", + "panel_kind": "isotropic", + "panel_seed": 3791321627556155355, + "realization": 9, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "637eaa501bf2d175eca445d174501a86359f852cbea40190f110a757ecbf26ce", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.13469105839343123, + "kernel_residual": 3.407429393498607e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 33.235265258946434, + "minus_external_entropy": 0.9573748201793374, + "minus_target_effective_rank": 102.74886504549235, + "minus_target_entropy": 0.945845466207101, + "minus_weight": 297.70054822938664, + "orthogonality_relative_error": 1.644010751147585e-16, + "plus_external_effective_rank": 33.23526525894648, + "plus_external_entropy": 0.9573748201793376, + "plus_target_effective_rank": 102.7488650454924, + "plus_target_entropy": 0.9458454662071012, + "plus_weight": 297.7005482293863, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "4e50141b7efe0a5b3457dcca6eed5844b995219858a5df6fdb1eee67282f8559", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:45:55.339246+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "8bb9b395f81c0bfa5e40e545ae0a43c27af9aec2ffc87c753ccaa7b73b473526", + "panel_kind": "sparse", + "panel_seed": 13896662830426418481, + "realization": 10, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c56c4d4afe5f9141e7e0d206c891168bb23b6f4d2356b388a593da8162a851df", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.12007579093280672, + "kernel_residual": 3.3534469673547007e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 29.662057559720573, + "minus_external_entropy": 0.9382081412281051, + "minus_target_effective_rank": 70.5370548369791, + "minus_target_entropy": 0.9281652197283502, + "minus_weight": 299.2754898568052, + "orthogonality_relative_error": 2.0447402353185616e-16, + "plus_external_effective_rank": 29.662057559720612, + "plus_external_entropy": 0.9382081412281051, + "plus_target_effective_rank": 70.53705483697912, + "plus_target_entropy": 0.9281652197283505, + "plus_weight": 299.27548985680494, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "6b6834fab834f39a367813f1c61a1dd3fb598dd52bc183b40aa95d8ab9a84d61", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:20.765523+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "8bb9b395f81c0bfa5e40e545ae0a43c27af9aec2ffc87c753ccaa7b73b473526", + "panel_kind": "isotropic", + "panel_seed": 13896662830426418481, + "realization": 10, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "de5cbf44cbe18aa39c49b467f13ecc91faabfe2c44c27f913003fcd2ddaaa6ac", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.12007579093280672, + "kernel_residual": 3.3534469673547007e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 31.736070972024038, + "minus_external_entropy": 0.9518005998728557, + "minus_target_effective_rank": 101.67933791096074, + "minus_target_entropy": 0.9451462880194785, + "minus_weight": 309.99824149023294, + "orthogonality_relative_error": 2.1094109080513511e-16, + "plus_external_effective_rank": 31.736070972024088, + "plus_external_entropy": 0.9518005998728556, + "plus_target_effective_rank": 101.67933791096084, + "plus_target_entropy": 0.9451462880194785, + "plus_weight": 309.99824149023266, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "dc4c57a6da1e3fd4197ca359cefedfb96c9c4fc21de41061e22a5830d31f38ae", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:14.179501+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "413bae05970ed3c4aad3d1f8a946eee3bf5ee0afef23176bd80f737b2f0f819e", + "panel_kind": "sparse", + "panel_seed": 3590570534994232795, + "realization": 11, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ae345e25244c5a2b8fc0986bafd1175a63297da5f167aabf4180308025f65b76", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.18643186694284977, + "kernel_residual": 3.166766245151596e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 32.168474690229246, + "minus_external_entropy": 0.9538483669461062, + "minus_target_effective_rank": 82.09332155927484, + "minus_target_entropy": 0.9377372351234725, + "minus_weight": 286.4147290258586, + "orthogonality_relative_error": 1.4835392925442714e-16, + "plus_external_effective_rank": 32.16847469022923, + "plus_external_entropy": 0.9538483669461062, + "plus_target_effective_rank": 82.0933215592748, + "plus_target_entropy": 0.9377372351234725, + "plus_weight": 286.4147290258586, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 44, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 44, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "632092157ac4229b3051a1cad1569ad3a13f5ad50d9b1a3b9fa359c0916be97d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:46.618979+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "413bae05970ed3c4aad3d1f8a946eee3bf5ee0afef23176bd80f737b2f0f819e", + "panel_kind": "isotropic", + "panel_seed": 3590570534994232795, + "realization": 11, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a39356582520f610dfacf4818f0e7ac299cfc5dae21087c2565ca5aa89f57870", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.18643186694284977, + "kernel_residual": 3.166766245151596e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 34.95605940677153, + "minus_external_entropy": 0.9634171606717107, + "minus_target_effective_rank": 105.5644604731739, + "minus_target_entropy": 0.9484935136920949, + "minus_weight": 289.3263353386583, + "orthogonality_relative_error": 1.492033573853009e-16, + "plus_external_effective_rank": 34.956059406771494, + "plus_external_entropy": 0.9634171606717109, + "plus_target_effective_rank": 105.56446047317387, + "plus_target_entropy": 0.9484935136920951, + "plus_weight": 289.32633533865834, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "57119ca391819f0171a4b3cdf71e7ae3bbbe124071f80efa0c90ca981fdb0481", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:08.344307+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "c0caf388b3fa8b5221b26d659e5860536034085d64fcd19ffb76da05bf19033f", + "panel_kind": "sparse", + "panel_seed": 18227657195444883552, + "realization": 12, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "68c506386310d19a868b8d3d23bccb59d5fcdbd14514042cabe2da41de0eb9ca", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1532805676557766, + "kernel_residual": 3.342053396775957e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 30.894670066644437, + "minus_external_entropy": 0.943798913160429, + "minus_target_effective_rank": 78.72270985178801, + "minus_target_entropy": 0.9346302393400908, + "minus_weight": 295.1902544467531, + "orthogonality_relative_error": 1.5194356535547367e-16, + "plus_external_effective_rank": 30.89467006664445, + "plus_external_entropy": 0.943798913160429, + "plus_target_effective_rank": 78.72270985178798, + "plus_target_entropy": 0.9346302393400908, + "plus_weight": 295.190254446753, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "49452aff1ccb5e683345c398560c5cf51f5f77fd54204b006eff5ddc56210ca2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:40.770810+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "c0caf388b3fa8b5221b26d659e5860536034085d64fcd19ffb76da05bf19033f", + "panel_kind": "isotropic", + "panel_seed": 18227657195444883552, + "realization": 12, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e42ae63d9ae9b7e540c9475cf471bcc86b89905223ac1195b94e1ad045934afd", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1532805676557766, + "kernel_residual": 3.342053396775957e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 34.420583218642136, + "minus_external_entropy": 0.9621187816969312, + "minus_target_effective_rank": 104.85841670778021, + "minus_target_entropy": 0.9483565161905554, + "minus_weight": 293.15129620457276, + "orthogonality_relative_error": 1.529293745203665e-16, + "plus_external_effective_rank": 34.420583218642136, + "plus_external_entropy": 0.9621187816969311, + "plus_target_effective_rank": 104.85841670778018, + "plus_target_entropy": 0.9483565161905554, + "plus_weight": 293.15129620457265, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "b2fad4165e8da3d8e3c14874c9d710e5d99228b755c22c1b06e66b8176a5cc50", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:08.948159+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "27c6ff7bc22bee2274e03f88f0bb640438273fa787db84aae1d99ab1a52cb199", + "panel_kind": "sparse", + "panel_seed": 16949447941250321636, + "realization": 13, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2d86aa2883dddb66827279e245139a80549664fab1d65601ef0fef64e9508cfa", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.152362910829263, + "kernel_residual": 3.3088988698949675e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 28.17203420316236, + "minus_external_entropy": 0.9272556122713563, + "minus_target_effective_rank": 63.95461929181814, + "minus_target_entropy": 0.9233570725012815, + "minus_weight": 288.6491345523153, + "orthogonality_relative_error": 1.5082545010623578e-16, + "plus_external_effective_rank": 28.17203420316236, + "plus_external_entropy": 0.9272556122713564, + "plus_target_effective_rank": 63.954619291818176, + "plus_target_entropy": 0.9233570725012815, + "plus_weight": 288.6491345523151, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "4e97d092bff76afdd83e5481fb4deb4247c9d3c2e87ddb14477b4d96672274a1", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:42.644060+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "27c6ff7bc22bee2274e03f88f0bb640438273fa787db84aae1d99ab1a52cb199", + "panel_kind": "isotropic", + "panel_seed": 16949447941250321636, + "realization": 13, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "790ebfe33651cd3480a4e7b2b538871d8c0975a2b87d5690e1277337649be4c2", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.152362910829263, + "kernel_residual": 3.3088988698949675e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 33.941806651716966, + "minus_external_entropy": 0.9598463036163304, + "minus_target_effective_rank": 102.49579668265248, + "minus_target_entropy": 0.9456310618091996, + "minus_weight": 293.64282058681204, + "orthogonality_relative_error": 1.46837546376427e-16, + "plus_external_effective_rank": 33.941806651716995, + "plus_external_entropy": 0.9598463036163307, + "plus_target_effective_rank": 102.49579668265251, + "plus_target_entropy": 0.9456310618091994, + "plus_weight": 293.6428205868119, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "62a9b53a114ee39196c2f1b8d5718c84c86f59dc337c246399dadfd70488fcbe", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:04.736744+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "cd1023cb7378e73bdcb59ed820f6fe581cdbca90db97dd149824a8b42772951f", + "panel_kind": "sparse", + "panel_seed": 16091217554281366613, + "realization": 14, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5518aca6095710f2c7cdbeea6e5a6713f5a40297f9cf60398998a4a440643b6d", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.13571072149735372, + "kernel_residual": 3.357100553332726e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999997, + "minus_external_effective_rank": 29.749694324318053, + "minus_external_entropy": 0.940613123851316, + "minus_target_effective_rank": 79.40702709503876, + "minus_target_entropy": 0.9305387444738529, + "minus_weight": 300.04835762467206, + "orthogonality_relative_error": 1.511691007668541e-16, + "plus_external_effective_rank": 29.749694324318035, + "plus_external_entropy": 0.9406131238513158, + "plus_target_effective_rank": 79.40702709503873, + "plus_target_entropy": 0.9305387444738531, + "plus_weight": 300.0483576246721, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "2eb003e8c646a94ab99be906b3254d5021b1bdbf12ac8332e5ef7e28f54ab7d5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:43.761120+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "cd1023cb7378e73bdcb59ed820f6fe581cdbca90db97dd149824a8b42772951f", + "panel_kind": "isotropic", + "panel_seed": 16091217554281366613, + "realization": 14, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f2ce04cfa8cba462934f59692c5fb6cb2311a54c401165ab74e72d9a9e0aff47", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.13571072149735372, + "kernel_residual": 3.357100553332726e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 32.43392080052645, + "minus_external_entropy": 0.9546945728919435, + "minus_target_effective_rank": 102.29361942883583, + "minus_target_entropy": 0.9453962343674129, + "minus_weight": 300.76201459103225, + "orthogonality_relative_error": 1.501656961555547e-16, + "plus_external_effective_rank": 32.43392080052642, + "plus_external_entropy": 0.9546945728919433, + "plus_target_effective_rank": 102.29361942883581, + "plus_target_entropy": 0.9453962343674129, + "plus_weight": 300.76201459103225, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "d6982f22f8e3d07de84462ca34222cc3dd446f0955d0d0df483323d940feb09f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:17.217093+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "9fb1dbf594b76475d83647749eb6c1a1c783b24012993d618495c97200874616", + "panel_kind": "sparse", + "panel_seed": 15273213204861940752, + "realization": 15, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "74c55031b36fec0ea6aa82ebdc4cdf0e0348e85e0b5eac949d79d3db8650e38f", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14876129342656988, + "kernel_residual": 3.3127272459028046e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 32.02175741970446, + "minus_external_entropy": 0.949386016202848, + "minus_target_effective_rank": 87.93888957845202, + "minus_target_entropy": 0.9341409601209022, + "minus_weight": 291.6706538799234, + "orthogonality_relative_error": 1.5125403106539923e-16, + "plus_external_effective_rank": 32.02175741970451, + "plus_external_entropy": 0.9493860162028485, + "plus_target_effective_rank": 87.93888957845212, + "plus_target_entropy": 0.9341409601209024, + "plus_weight": 291.6706538799231, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "cb83656fd0c3e8f4db63549ae4557bac689f746258a664cd8df95903604c3ad7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:53.979029+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "9fb1dbf594b76475d83647749eb6c1a1c783b24012993d618495c97200874616", + "panel_kind": "isotropic", + "panel_seed": 15273213204861940752, + "realization": 15, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b352bd830beee3ecd82878ec297be0e9d8530190138bbbb3308a2094ea886888", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14876129342656988, + "kernel_residual": 3.3127272459028046e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 34.27884146747295, + "minus_external_entropy": 0.9619564704703272, + "minus_target_effective_rank": 104.93291031226298, + "minus_target_entropy": 0.9484359227880773, + "minus_weight": 290.79367920561697, + "orthogonality_relative_error": 1.5160541826946363e-16, + "plus_external_effective_rank": 34.278841467472986, + "plus_external_entropy": 0.9619564704703275, + "plus_target_effective_rank": 104.93291031226308, + "plus_target_entropy": 0.9484359227880773, + "plus_weight": 290.7936792056166, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "5884933fb2fb8ab08d478ef74bc55cebf5f020af05be12b6c4f927d047b31001", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:52.751494+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "333a6c11e37c522457b0e9cf117e98d8109cd2d71a9be05df94612656a55abb8", + "panel_kind": "sparse", + "panel_seed": 17456917826340989711, + "realization": 16, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a55829c31b67b651d966c666e40a1d6030db02ae56528ff4ad7d9697dd53149c", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.16242300942687884, + "kernel_residual": 3.5287743340366024e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 28.690772245188132, + "minus_external_entropy": 0.9327695510143504, + "minus_target_effective_rank": 73.03672774383435, + "minus_target_entropy": 0.9354364101510407, + "minus_weight": 284.0768074388667, + "orthogonality_relative_error": 1.3287490532658305e-16, + "plus_external_effective_rank": 28.690772245188157, + "plus_external_entropy": 0.93276955101435, + "plus_target_effective_rank": 73.03672774383433, + "plus_target_entropy": 0.9354364101510407, + "plus_weight": 284.07680743886647, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "1b6e29d700102a6ee0cfbe40d75b3b92624988435def59b5be1a742acc38b666", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:29.914763+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "333a6c11e37c522457b0e9cf117e98d8109cd2d71a9be05df94612656a55abb8", + "panel_kind": "isotropic", + "panel_seed": 17456917826340989711, + "realization": 16, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9dd2121fca2e8271c88e8ea7754cfb822f4ff3cc7652fbed250044d342cfb0d2", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.16242300942687884, + "kernel_residual": 3.5287743340366024e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 35.27208253186538, + "minus_external_entropy": 0.9654115917282228, + "minus_target_effective_rank": 105.16270450366298, + "minus_target_entropy": 0.9486413484360227, + "minus_weight": 280.5062134785304, + "orthogonality_relative_error": 1.3160384018660104e-16, + "plus_external_effective_rank": 35.27208253186542, + "plus_external_entropy": 0.9654115917282226, + "plus_target_effective_rank": 105.16270450366302, + "plus_target_entropy": 0.9486413484360225, + "plus_weight": 280.5062134785303, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "bdab7245cd3bc4e49a4546bda9d9b330859802ed0927fcbb0f9921d5077594ea", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:10.390197+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "8ebfb2db8675ba779aa112a5830728d99d9d0503ca2db5d23f233465fa1618b2", + "panel_kind": "sparse", + "panel_seed": 4620848224800115886, + "realization": 17, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6696175acb18d3c0f6ef7f544535f41b67867aef157853172910c05c7839c855", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15031729943049046, + "kernel_residual": 3.3643376029345533e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 29.114726266736014, + "minus_external_entropy": 0.9338330074971628, + "minus_target_effective_rank": 75.42743527917008, + "minus_target_entropy": 0.9317555983402613, + "minus_weight": 293.9333266621569, + "orthogonality_relative_error": 1.67732684584171e-16, + "plus_external_effective_rank": 29.114726266736003, + "plus_external_entropy": 0.933833007497163, + "plus_target_effective_rank": 75.42743527917007, + "plus_target_entropy": 0.9317555983402613, + "plus_weight": 293.93332666215696, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "6cf043e81fbf246a4880f43d12117d41137637f68d3fdf7950ca08150d77080e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:43.371738+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "8ebfb2db8675ba779aa112a5830728d99d9d0503ca2db5d23f233465fa1618b2", + "panel_kind": "isotropic", + "panel_seed": 4620848224800115886, + "realization": 17, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "50ec679c21d763311830a4e1b94e841975679d27c40cb53bc8749ff84d3ee9e9", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15031729943049046, + "kernel_residual": 3.3643376029345533e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 34.335556136118, + "minus_external_entropy": 0.9620028861238403, + "minus_target_effective_rank": 104.18671040804307, + "minus_target_entropy": 0.9473210581484781, + "minus_weight": 289.1764701363715, + "orthogonality_relative_error": 1.6055974015969852e-16, + "plus_external_effective_rank": 34.335556136118, + "plus_external_entropy": 0.9620028861238407, + "plus_target_effective_rank": 104.18671040804315, + "plus_target_entropy": 0.9473210581484779, + "plus_weight": 289.1764701363713, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "c3ee700db3d7b945e429e266848f86fca0ce475513ac3018894b8e0886cc2adf", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:46:46.914002+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "991a1367fd7c8ab2e5dc69d653d9103a7488197710fe43bb4615f600f097c918", + "panel_kind": "sparse", + "panel_seed": 5957810183632608589, + "realization": 18, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4149aeea42291a6e3045f95d847a43f25612f3ebefb32cc75f900bc12af676db", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.12931795410801106, + "kernel_residual": 3.3480536814835608e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 26.829409787599996, + "minus_external_entropy": 0.9267718144935173, + "minus_target_effective_rank": 68.71522598625714, + "minus_target_entropy": 0.9307965892669706, + "minus_weight": 306.0611013831177, + "orthogonality_relative_error": 1.3689186721275062e-16, + "plus_external_effective_rank": 26.829409787599992, + "plus_external_entropy": 0.9267718144935173, + "plus_target_effective_rank": 68.71522598625711, + "plus_target_entropy": 0.9307965892669706, + "plus_weight": 306.0611013831176, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 43, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 43, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "b1d5b526487a0f8a4dfae865f5318f74db4e54b551555076e4e6981222f2fac8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:14.452516+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "991a1367fd7c8ab2e5dc69d653d9103a7488197710fe43bb4615f600f097c918", + "panel_kind": "isotropic", + "panel_seed": 5957810183632608589, + "realization": 18, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c429706e304881c5153e7d3e2a719838bea06e424ecf47c05b2edf02d9a6dddf", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.12931795410801106, + "kernel_residual": 3.3480536814835608e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 32.41751291167493, + "minus_external_entropy": 0.9542860786723495, + "minus_target_effective_rank": 102.66737615005601, + "minus_target_entropy": 0.9460599563099552, + "minus_weight": 303.6742629695277, + "orthogonality_relative_error": 1.3840357498516908e-16, + "plus_external_effective_rank": 32.41751291167493, + "plus_external_entropy": 0.9542860786723496, + "plus_target_effective_rank": 102.667376150056, + "plus_target_entropy": 0.9460599563099552, + "plus_weight": 303.6742629695277, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "87833c0e5294f254c2a6ae1d21976ca05bb3b01b5a48fcf3aef2d36fa61b3679", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:18.668053+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "ff2c213805041f0abd60888367ec671a9a08cdd34ef932cfab13931d5f2abc12", + "panel_kind": "sparse", + "panel_seed": 2119048014588772401, + "realization": 19, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d72071d2a7f6176f57511f39a35fbab95d5da491d04c3b302ce689f818e4dec9", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14249316273870355, + "kernel_residual": 3.325122656102218e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 30.639115601378347, + "minus_external_entropy": 0.9464233205899192, + "minus_target_effective_rank": 78.0998925096779, + "minus_target_entropy": 0.9345263277436349, + "minus_weight": 290.7908542998044, + "orthogonality_relative_error": 1.4325212700624772e-16, + "plus_external_effective_rank": 30.639115601378354, + "plus_external_entropy": 0.946423320589919, + "plus_target_effective_rank": 78.09989250967789, + "plus_target_entropy": 0.9345263277436348, + "plus_weight": 290.7908542998045, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 44, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 44, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "959f614b2dc5b1c7aa25055d61b435515ae81e4264c14e0d0b68e9d72fd34560", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:55.872096+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "ff2c213805041f0abd60888367ec671a9a08cdd34ef932cfab13931d5f2abc12", + "panel_kind": "isotropic", + "panel_seed": 2119048014588772401, + "realization": 19, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d25e10360db7ae0f43726e83606c0b5e2b87e521bfdd0ddd8c1596ee79d9f870", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14249316273870355, + "kernel_residual": 3.325122656102218e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000004, + "minus_external_effective_rank": 33.35014775803105, + "minus_external_entropy": 0.957107491277568, + "minus_target_effective_rank": 103.44927597134115, + "minus_target_entropy": 0.9461466056867008, + "minus_weight": 295.47931778426545, + "orthogonality_relative_error": 1.4193379859442973e-16, + "plus_external_effective_rank": 33.35014775803104, + "plus_external_entropy": 0.9571074912775679, + "plus_target_effective_rank": 103.44927597134112, + "plus_target_entropy": 0.946146605686701, + "plus_weight": 295.4793177842654, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "eaa34e9c943503dd9388f7ab0c6a0d739267cde3bf4d53c53e0783a9f801bbff", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:15.906108+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "5170c584e539dcb72539752576ef293dee35db38fbf8aad13b939c0aa488be47", + "panel_kind": "sparse", + "panel_seed": 4372998560516994987, + "realization": 20, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cd30da8d35b629be5fcf2089ec2baf0ea2a89386f3b185912702a4f9ce19d407", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15929435688543656, + "kernel_residual": 3.2365613176914802e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 30.10010298356616, + "minus_external_entropy": 0.9386310910796113, + "minus_target_effective_rank": 79.99544048289178, + "minus_target_entropy": 0.9339301922615215, + "minus_weight": 304.4347834557362, + "orthogonality_relative_error": 2.3512718477857163e-16, + "plus_external_effective_rank": 30.100102983566174, + "plus_external_entropy": 0.9386310910796112, + "plus_target_effective_rank": 79.99544048289181, + "plus_target_entropy": 0.9339301922615215, + "plus_weight": 304.43478345573635, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "c2b2287adbe4aaf21d522e7283229e7a2f1c0acae084ad3d7a895c500a074324", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:49.566407+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "5170c584e539dcb72539752576ef293dee35db38fbf8aad13b939c0aa488be47", + "panel_kind": "isotropic", + "panel_seed": 4372998560516994987, + "realization": 20, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "29aa2d7d117de5f2906a308877105479f1838da59861ee0c95455eda6e5bc3b3", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15929435688543656, + "kernel_residual": 3.2365613176914802e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 34.73977318964251, + "minus_external_entropy": 0.9633563322691377, + "minus_target_effective_rank": 104.17751186740574, + "minus_target_entropy": 0.9472886380393518, + "minus_weight": 287.36575222938836, + "orthogonality_relative_error": 2.1082080952886078e-16, + "plus_external_effective_rank": 34.73977318964249, + "plus_external_entropy": 0.9633563322691373, + "plus_target_effective_rank": 104.17751186740571, + "plus_target_entropy": 0.9472886380393517, + "plus_weight": 287.36575222938836, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "f5d6a38dec36daf00aa8597c889bb52b3948615314dd105958f39d47f89b61d7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:17.138123+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "ed970ad45b4780e84b3e1b019ff047da8d621b9026a1adddee3bb76cb014a11a", + "panel_kind": "sparse", + "panel_seed": 15707208217182303436, + "realization": 21, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3c43482e6a799b37648094a3117fc072083cc1f697eb5a4d25a862100a3d5d16", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15975633252476126, + "kernel_residual": 3.5111440703583887e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 28.806439312310747, + "minus_external_entropy": 0.9304319509502469, + "minus_target_effective_rank": 68.89997325354553, + "minus_target_entropy": 0.9282417289361162, + "minus_weight": 298.83807685159104, + "orthogonality_relative_error": 1.4513686527682202e-16, + "plus_external_effective_rank": 28.806439312310758, + "plus_external_entropy": 0.9304319509502468, + "plus_target_effective_rank": 68.89997325354557, + "plus_target_entropy": 0.928241728936116, + "plus_weight": 298.83807685159087, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "38c0b34b1a2bf7ff8b6aab9a8494459453058049d85f6ffe71bc1d1bf579d2ae", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:50.476298+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "ed970ad45b4780e84b3e1b019ff047da8d621b9026a1adddee3bb76cb014a11a", + "panel_kind": "isotropic", + "panel_seed": 15707208217182303436, + "realization": 21, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9694493c346270f0126d9068174ae56c169d8be8eb48a13db892049ab9685afe", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15975633252476126, + "kernel_residual": 3.5111440703583887e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 33.400955237304316, + "minus_external_entropy": 0.957404309851876, + "minus_target_effective_rank": 102.69608101977863, + "minus_target_entropy": 0.9458096060282492, + "minus_weight": 299.2534792845192, + "orthogonality_relative_error": 1.4313097443261048e-16, + "plus_external_effective_rank": 33.40095523730435, + "plus_external_entropy": 0.9574043098518761, + "plus_target_effective_rank": 102.69608101977869, + "plus_target_entropy": 0.9458096060282489, + "plus_weight": 299.253479284519, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "8947203f813761a8d3b75caf660f48a352dbe9d360a92c304fe4d87990737359", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:19.189004+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "b03ce1d67ceee7378287da5207967e646cc87a5bc4680485c33da0783459e57e", + "panel_kind": "sparse", + "panel_seed": 16749342407589759121, + "realization": 22, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d83958450c754eecc834df913269d5f08be3ae2ff2b62f92512a081d4d6eb38e", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1487786559860164, + "kernel_residual": 3.3401401865718395e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 32.23737307169414, + "minus_external_entropy": 0.9518812967371068, + "minus_target_effective_rank": 91.43188181011536, + "minus_target_entropy": 0.9374117126243671, + "minus_weight": 294.30839217496305, + "orthogonality_relative_error": 1.5527783722204415e-16, + "plus_external_effective_rank": 32.237373071694115, + "plus_external_entropy": 0.9518812967371069, + "plus_target_effective_rank": 91.43188181011536, + "plus_target_entropy": 0.9374117126243671, + "plus_weight": 294.30839217496305, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "3d216a3b766fde26347626233c9bef47247bc43650f0097ee8ad6e476fd109c0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:55.029537+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "b03ce1d67ceee7378287da5207967e646cc87a5bc4680485c33da0783459e57e", + "panel_kind": "isotropic", + "panel_seed": 16749342407589759121, + "realization": 22, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "455b08eb5e28a97d0ca26832b32c06f16074a13196625496dcc979b2b59f4155", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1487786559860164, + "kernel_residual": 3.3401401865718395e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 33.162657628431845, + "minus_external_entropy": 0.9565254508004439, + "minus_target_effective_rank": 103.7418529706764, + "minus_target_entropy": 0.9468228256193584, + "minus_weight": 298.15061884184655, + "orthogonality_relative_error": 1.5562088892720268e-16, + "plus_external_effective_rank": 33.162657628431866, + "plus_external_entropy": 0.956525450800444, + "plus_target_effective_rank": 103.74185297067646, + "plus_target_entropy": 0.9468228256193584, + "plus_weight": 298.15061884184666, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "746e0d6e42cdc123c641d5c2dd6318f61ccb420ea99d628dd16f1b93a4e2e41f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:32.650185+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "e77940c46dfbff394e2c53546c5a20022ea4a648f29b9bee15909b8351376545", + "panel_kind": "sparse", + "panel_seed": 11395588382482722749, + "realization": 23, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "21a084790d10b4fea88fb0ca35701ef8218ba5e322e914118501f531bfc86b7b", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14298782990039446, + "kernel_residual": 3.4061959721596345e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 31.52300128557842, + "minus_external_entropy": 0.9481401839085293, + "minus_target_effective_rank": 84.73586163301019, + "minus_target_entropy": 0.935600872743113, + "minus_weight": 296.4558874932617, + "orthogonality_relative_error": 1.5419128597979563e-16, + "plus_external_effective_rank": 31.523001285578406, + "plus_external_entropy": 0.9481401839085295, + "plus_target_effective_rank": 84.73586163301017, + "plus_target_entropy": 0.9356008727431132, + "plus_weight": 296.45588749326174, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "fd1071638cdf398918c4335c69d07bdbba8b1c70cfa0886ae58941721e723dd0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:11.656990+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "e77940c46dfbff394e2c53546c5a20022ea4a648f29b9bee15909b8351376545", + "panel_kind": "isotropic", + "panel_seed": 11395588382482722749, + "realization": 23, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "69441a59138d637ac01de7c4c51efc2782af2fc1cc378a210fda408e0fae1575", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14298782990039446, + "kernel_residual": 3.4061959721596345e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 33.76300448516514, + "minus_external_entropy": 0.9595188174336695, + "minus_target_effective_rank": 104.11026711202493, + "minus_target_entropy": 0.9475672049597191, + "minus_weight": 298.3900688126751, + "orthogonality_relative_error": 1.5352084771725449e-16, + "plus_external_effective_rank": 33.763004485165126, + "plus_external_entropy": 0.9595188174336696, + "plus_target_effective_rank": 104.11026711202494, + "plus_target_entropy": 0.9475672049597191, + "plus_weight": 298.39006881267517, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "635787079dbf70048662f6bd9cf38c7731ef0175aac053008965c7c01d60c7f6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:49:09.618719+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "f9d9c9e8624964e21c90f2b627b814a205d06203f46ecd397a4e03f3296c828f", + "panel_kind": "sparse", + "panel_seed": 9123582196403837841, + "realization": 24, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ec9d166083d7d9a5bf32c1ef6b2361866ba9b3932ef8867aaff3c3d7b557e775", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14201432326230495, + "kernel_residual": 3.315634626160065e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 31.995783418257407, + "minus_external_entropy": 0.9515359591175867, + "minus_target_effective_rank": 86.82526507944483, + "minus_target_entropy": 0.9362160016876204, + "minus_weight": 294.65508061549707, + "orthogonality_relative_error": 1.384279227093271e-16, + "plus_external_effective_rank": 31.995783418257396, + "plus_external_entropy": 0.9515359591175865, + "plus_target_effective_rank": 86.82526507944485, + "plus_target_entropy": 0.9362160016876204, + "plus_weight": 294.655080615497, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "e844fb3cfb9a6da4ba98f99c1c6ac9a77ba50f3b57925254c7b3c2d6f134c0eb", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:49:59.192905+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "f9d9c9e8624964e21c90f2b627b814a205d06203f46ecd397a4e03f3296c828f", + "panel_kind": "isotropic", + "panel_seed": 9123582196403837841, + "realization": 24, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2a382dbd3a7f7fd805149dbce88df266634fd07093b659d5df47bb8ff71dd6f2", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14201432326230495, + "kernel_residual": 3.315634626160065e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 32.964906097099394, + "minus_external_entropy": 0.9571028631532535, + "minus_target_effective_rank": 102.55125540378093, + "minus_target_entropy": 0.9455741537331411, + "minus_weight": 292.0849288068867, + "orthogonality_relative_error": 1.3686933165663158e-16, + "plus_external_effective_rank": 32.96490609709939, + "plus_external_entropy": 0.9571028631532537, + "plus_target_effective_rank": 102.55125540378093, + "plus_target_entropy": 0.9455741537331414, + "plus_weight": 292.08492880688664, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "65c23ec09c60f2fa7ef6a7b626f88b73615b8f7a1928dd9d0840791f4318d572", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:14.662892+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "8c534e53016a36c5f1cbc5bd3e37ed0b797ec3c6e9d8c5d8b7f7d3aff544ec04", + "panel_kind": "sparse", + "panel_seed": 4119443917425061710, + "realization": 25, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6ed3b2310601ed9499adf28e370111c20ab195cd272211403bfbd75b0dfda742", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.12086154143519977, + "kernel_residual": 3.3468888967073388e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 29.188805120881767, + "minus_external_entropy": 0.9404719493470186, + "minus_target_effective_rank": 76.23074570344576, + "minus_target_entropy": 0.9307427332456507, + "minus_weight": 293.6400438853912, + "orthogonality_relative_error": 1.3699467937834216e-16, + "plus_external_effective_rank": 29.18880512088178, + "plus_external_entropy": 0.9404719493470187, + "plus_target_effective_rank": 76.23074570344578, + "plus_target_entropy": 0.9307427332456507, + "plus_weight": 293.64004388539126, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 44, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 44, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "39df581a94ade479838318b0a097889b49b68b7bc9a23b3ab4b57f26ba3db358", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:46.179649+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "8c534e53016a36c5f1cbc5bd3e37ed0b797ec3c6e9d8c5d8b7f7d3aff544ec04", + "panel_kind": "isotropic", + "panel_seed": 4119443917425061710, + "realization": 25, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0d02b826d5a5f47793a4eb58d8be733fa90b7ac6966178088acfa7e12f2f680d", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.12086154143519977, + "kernel_residual": 3.3468888967073388e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 31.508261021804692, + "minus_external_entropy": 0.9507252491504442, + "minus_target_effective_rank": 101.8074497078993, + "minus_target_entropy": 0.9446857186760093, + "minus_weight": 309.43042262248053, + "orthogonality_relative_error": 1.3552288529126158e-16, + "plus_external_effective_rank": 31.508261021804696, + "plus_external_entropy": 0.9507252491504444, + "plus_target_effective_rank": 101.80744970789934, + "plus_target_entropy": 0.9446857186760089, + "plus_weight": 309.43042262248053, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "ad11229049cd879194e3f08230b83fae00b4fc4d9b15e2d15f1d8e576d58feab", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:47:39.937967+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "a07bf8915579c8b313958f71a3713813f592a57bcfea6554ca38770ecadc16d7", + "panel_kind": "sparse", + "panel_seed": 10081179719102135162, + "realization": 26, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d19cd1b016bd40e529de537b82d8d575769f46fd2d8e80858103b10929e7bb90", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.17428127333146795, + "kernel_residual": 3.3441845375882288e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 32.39257828597104, + "minus_external_entropy": 0.9501922687675193, + "minus_target_effective_rank": 80.48870261634774, + "minus_target_entropy": 0.9330291739318137, + "minus_weight": 287.99621077847183, + "orthogonality_relative_error": 1.4054390045199805e-16, + "plus_external_effective_rank": 32.392578285971055, + "plus_external_entropy": 0.9501922687675193, + "plus_target_effective_rank": 80.48870261634784, + "plus_target_entropy": 0.9330291739318135, + "plus_weight": 287.9962107784717, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "3da52ae64e3840330119aa79968a719666f002e823df9672f04b8e54ebc2aa92", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:05.232453+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "a07bf8915579c8b313958f71a3713813f592a57bcfea6554ca38770ecadc16d7", + "panel_kind": "isotropic", + "panel_seed": 10081179719102135162, + "realization": 26, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fb8c67c6ec06e0dc6ed0ef6e48c65c4f419408dc7d536e76d9f9f715f2d24a5a", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.17428127333146795, + "kernel_residual": 3.3441845375882288e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 34.6696501275661, + "minus_external_entropy": 0.961802372824316, + "minus_target_effective_rank": 105.30051052598232, + "minus_target_entropy": 0.9486042777130177, + "minus_weight": 295.9125694329941, + "orthogonality_relative_error": 1.4416200963317883e-16, + "plus_external_effective_rank": 34.66965012756611, + "plus_external_entropy": 0.9618023728243161, + "plus_target_effective_rank": 105.30051052598238, + "plus_target_entropy": 0.9486042777130177, + "plus_weight": 295.9125694329942, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "3019b261b0209d0f797b5c0082bdfa960bc6ef722f6d8de825ff87f7a565641a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:33.493039+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "133e715d71fef228eed2e94f091aa73d5b7eee646ac403c6e18b7d62d91dd97e", + "panel_kind": "sparse", + "panel_seed": 10931698801794283540, + "realization": 27, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "86cbc2433196dba3d1922b063d2baa1ccba015fadd28147d61d0acf63f27b991", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.17729979975920587, + "kernel_residual": 3.3153378681652858e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 32.958962740665136, + "minus_external_entropy": 0.9535376403468802, + "minus_target_effective_rank": 84.08293316446547, + "minus_target_entropy": 0.9380150459079628, + "minus_weight": 284.58737564351424, + "orthogonality_relative_error": 1.2496420220702408e-16, + "plus_external_effective_rank": 32.95896274066516, + "plus_external_entropy": 0.95353764034688, + "plus_target_effective_rank": 84.08293316446549, + "plus_target_entropy": 0.9380150459079628, + "plus_weight": 284.5873756435143, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "f6c0a48daef3355bba3d4ae20d6b4413711d13461855ec6293e060dcb6e4e902", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:49:04.701288+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "133e715d71fef228eed2e94f091aa73d5b7eee646ac403c6e18b7d62d91dd97e", + "panel_kind": "isotropic", + "panel_seed": 10931698801794283540, + "realization": 27, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "97023916491e00ff7295cd5b76c87964914497e98e0c504a002004ba3bbf7cba", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.17729979975920587, + "kernel_residual": 3.3153378681652858e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 35.81990280201477, + "minus_external_entropy": 0.9677710296737516, + "minus_target_effective_rank": 106.6505346709192, + "minus_target_entropy": 0.95034838980608, + "minus_weight": 276.53811864049175, + "orthogonality_relative_error": 1.2466567339397665e-16, + "plus_external_effective_rank": 35.819902802014774, + "plus_external_entropy": 0.9677710296737516, + "plus_target_effective_rank": 106.65053467091924, + "plus_target_entropy": 0.95034838980608, + "plus_weight": 276.5381186404918, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "f7f8256ff1241919c1c396674a7d8c72dd5e99b28f75f2d8f59a27e9321a2d07", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:27.131081+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "eaba937929369059a4a1ae1f27b9eaad371bf44d5881e7229b7465235a2d82aa", + "panel_kind": "sparse", + "panel_seed": 10638206557683616505, + "realization": 28, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "975758001b211abe1454d021f375b680fa4fde4c76752654193243ed8c769d15", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15825083955339336, + "kernel_residual": 3.2735662898393244e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 31.24897936161635, + "minus_external_entropy": 0.94590192393644, + "minus_target_effective_rank": 78.59125753608636, + "minus_target_entropy": 0.9330675163884083, + "minus_weight": 293.37580587556255, + "orthogonality_relative_error": 1.2143444805228354e-16, + "plus_external_effective_rank": 31.248979361616367, + "plus_external_entropy": 0.9459019239364399, + "plus_target_effective_rank": 78.59125753608637, + "plus_target_entropy": 0.9330675163884085, + "plus_weight": 293.37580587556243, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "ea6586f4f4e59b03fa5660bbc13eb2e6c25f1f7c01e6ec4dbac5b3874c2da75d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:58.943933+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "eaba937929369059a4a1ae1f27b9eaad371bf44d5881e7229b7465235a2d82aa", + "panel_kind": "isotropic", + "panel_seed": 10638206557683616505, + "realization": 28, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f837f9ca2a2b6c65800b0c2de48b933d675e089df82ef0545cee941a7cae52f2", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15825083955339336, + "kernel_residual": 3.2735662898393244e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 34.327245589358355, + "minus_external_entropy": 0.9617185838244764, + "minus_target_effective_rank": 104.23920116043001, + "minus_target_entropy": 0.9472078132700901, + "minus_weight": 289.24302249947397, + "orthogonality_relative_error": 1.2360105986223507e-16, + "plus_external_effective_rank": 34.32724558935837, + "plus_external_entropy": 0.9617185838244765, + "plus_target_effective_rank": 104.23920116043006, + "plus_target_entropy": 0.9472078132700901, + "plus_weight": 289.24302249947385, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "ba0cddb561cd8376d395c0d8b1591547fb0d73062aa0558df94826b049c079da", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:27.442006+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "9b6248ebae28864f187e41fae2b1a4541deb678c732a1eaef206857420d53835", + "panel_kind": "sparse", + "panel_seed": 8127149061119117813, + "realization": 29, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d975bbb1450ffc127f722e4122baa092ab15322fea936010dbb4948f69f5697d", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.13667750535778792, + "kernel_residual": 3.6440545985142086e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 28.824444003817487, + "minus_external_entropy": 0.9339361745624647, + "minus_target_effective_rank": 69.90618193166952, + "minus_target_entropy": 0.9268044509818538, + "minus_weight": 310.84768252951244, + "orthogonality_relative_error": 1.698994303626059e-16, + "plus_external_effective_rank": 28.8244440038175, + "plus_external_entropy": 0.9339361745624647, + "plus_target_effective_rank": 69.90618193166952, + "plus_target_entropy": 0.9268044509818538, + "plus_weight": 310.8476825295123, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "df31e1d1e2babfd3fa1c770904d482e76d95737fc93d806724bf4ff94acc313c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:58.567364+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "9b6248ebae28864f187e41fae2b1a4541deb678c732a1eaef206857420d53835", + "panel_kind": "isotropic", + "panel_seed": 8127149061119117813, + "realization": 29, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ab9fe019291083211f7a1913433a8ee838cc3136a3d21edc4d1089057a118008", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.13667750535778792, + "kernel_residual": 3.6440545985142086e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 31.53354942723587, + "minus_external_entropy": 0.9496846292680774, + "minus_target_effective_rank": 100.50271977995743, + "minus_target_entropy": 0.9428364915434712, + "minus_weight": 306.9912586220497, + "orthogonality_relative_error": 1.7416176276553512e-16, + "plus_external_effective_rank": 31.533549427235872, + "plus_external_entropy": 0.9496846292680778, + "plus_target_effective_rank": 100.50271977995742, + "plus_target_entropy": 0.9428364915434712, + "plus_weight": 306.99125862204966, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "231ab9d2c082c6a384525e399c24e106a13833ea32645584d458d81861b13f7b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:34.476759+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "19731e52d012fae77844096f49b794cf13c00ae339bd51e632026f37c38c077c", + "panel_kind": "sparse", + "panel_seed": 1295097102592508988, + "realization": 30, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4712ba58cb486e7c9ceffc343d4d429813f1c00bccdbf14bf25eb3dc16c8f9a0", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.16244328184572154, + "kernel_residual": 3.2563968709242917e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 33.231045375626415, + "minus_external_entropy": 0.9565832963558364, + "minus_target_effective_rank": 89.77338078718492, + "minus_target_entropy": 0.9381019095136536, + "minus_weight": 284.6705033866057, + "orthogonality_relative_error": 1.385069918041861e-16, + "plus_external_effective_rank": 33.23104537562645, + "plus_external_entropy": 0.9565832963558362, + "plus_target_effective_rank": 89.77338078718489, + "plus_target_entropy": 0.9381019095136536, + "plus_weight": 284.6705033866055, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "302cca61560a1ffa80b76dde6f4658d1701b50933b3836048424a680d767ba17", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:49:09.483192+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "19731e52d012fae77844096f49b794cf13c00ae339bd51e632026f37c38c077c", + "panel_kind": "isotropic", + "panel_seed": 1295097102592508988, + "realization": 30, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cd64f0d1dd91a4840de5a5a9e9f695b1f706ab117cf9557ff36c8e17fe806c7f", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.16244328184572154, + "kernel_residual": 3.2563968709242917e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 34.72185569452243, + "minus_external_entropy": 0.963319780951941, + "minus_target_effective_rank": 105.0194164881177, + "minus_target_entropy": 0.9485018125064251, + "minus_weight": 288.5613773349363, + "orthogonality_relative_error": 1.381963765883353e-16, + "plus_external_effective_rank": 34.72185569452244, + "plus_external_entropy": 0.9633197809519413, + "plus_target_effective_rank": 105.01941648811771, + "plus_target_entropy": 0.9485018125064248, + "plus_weight": 288.5613773349361, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "8e6100051590e9bdbcd3263d75cad97cb0521dd6dcf150204a36fb4646372688", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:47.053475+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "fe273cc81605588014e53ca880067d6b8f3badc41182eb9e91055288aafdc698", + "panel_kind": "sparse", + "panel_seed": 7987983761770852736, + "realization": 31, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "96de110a9066ccd279c02fec5e62a3436843671161eb636cc1860ebc35106c6e", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1442822831412214, + "kernel_residual": 3.313399768757478e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 27.844396881559884, + "minus_external_entropy": 0.9344106461850661, + "minus_target_effective_rank": 74.50314526728917, + "minus_target_entropy": 0.934384989522568, + "minus_weight": 298.568895077832, + "orthogonality_relative_error": 1.5686593738701677e-16, + "plus_external_effective_rank": 27.84439688155987, + "plus_external_entropy": 0.9344106461850661, + "plus_target_effective_rank": 74.50314526728917, + "plus_target_entropy": 0.9343849895225678, + "plus_weight": 298.5688950778319, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 44, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 44, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "fc391e53359d2194183df9a3c9f97756ba5ac496606393106aaec77e320ce1ee", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:49:24.511189+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "fe273cc81605588014e53ca880067d6b8f3badc41182eb9e91055288aafdc698", + "panel_kind": "isotropic", + "panel_seed": 7987983761770852736, + "realization": 31, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0b44603e1b078ce49878eea44224e48cb99091499ff04b94c6aab4ce7d77474a", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1442822831412214, + "kernel_residual": 3.313399768757478e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 33.63020332173654, + "minus_external_entropy": 0.9595052679420308, + "minus_target_effective_rank": 103.66090936712341, + "minus_target_entropy": 0.9470704910723514, + "minus_weight": 292.0708438161996, + "orthogonality_relative_error": 1.529818703091068e-16, + "plus_external_effective_rank": 33.63020332173654, + "plus_external_entropy": 0.9595052679420304, + "plus_target_effective_rank": 103.66090936712341, + "plus_target_entropy": 0.9470704910723514, + "plus_weight": 292.07084381619984, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "ce45584b15fb35cef434a61f2dfe54d37920fa191ea0e8d1b4a0e6e3e80a6227", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:40.029231+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "3a0620267d1baa88d344ff25573dc13ec191a9d36d399f3a0813613d85b659b3", + "panel_kind": "sparse", + "panel_seed": 8627282510082473144, + "realization": 32, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "628aa20ed86ed65acf1b871f7d61084546ea61f745b9b4a7b60aa630cf4fc9c9", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.12106520790695452, + "kernel_residual": 3.306676666203645e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 28.668529244238925, + "minus_external_entropy": 0.9382749525855296, + "minus_target_effective_rank": 79.40382374853371, + "minus_target_entropy": 0.9324225318064349, + "minus_weight": 297.43941710158214, + "orthogonality_relative_error": 1.5530795636084004e-16, + "plus_external_effective_rank": 28.668529244238922, + "plus_external_entropy": 0.9382749525855296, + "plus_target_effective_rank": 79.40382374853372, + "plus_target_entropy": 0.932422531806435, + "plus_weight": 297.4394171015822, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "8e2a574d399c7a0d75e411fd6d100433701d822ca0903684593d8fb57353b22f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:24.245817+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "3a0620267d1baa88d344ff25573dc13ec191a9d36d399f3a0813613d85b659b3", + "panel_kind": "isotropic", + "panel_seed": 8627282510082473144, + "realization": 32, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "981686ea0bf48031adde536af85c5977647a32d2822175632371b318f34bc048", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.12106520790695452, + "kernel_residual": 3.306676666203645e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 32.80357830317808, + "minus_external_entropy": 0.957710189668951, + "minus_target_effective_rank": 101.99207076044928, + "minus_target_entropy": 0.9457140191639384, + "minus_weight": 295.7414717679581, + "orthogonality_relative_error": 1.5452604367535923e-16, + "plus_external_effective_rank": 32.80357830317808, + "plus_external_entropy": 0.9577101896689512, + "plus_target_effective_rank": 101.99207076044931, + "plus_target_entropy": 0.9457140191639384, + "plus_weight": 295.74147176795793, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "364a473dee158b5b3cb2b6808f004277a06c2cffe651af60789a1cf7f7dbfc6b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:49:17.789403+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "69f3f752bcc25ad0882f63ee7e99ebd36100bdfab26510ab74dbe0395b54604b", + "panel_kind": "sparse", + "panel_seed": 5914402396525267322, + "realization": 33, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "61a16835e4c0331ee3d8734c86d39ea844773ff263ca86130807927d1b1eabd8", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15511675980718315, + "kernel_residual": 3.3421458209010425e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999997, + "minus_external_effective_rank": 29.588572011800814, + "minus_external_entropy": 0.9361467650534814, + "minus_target_effective_rank": 72.62455545682433, + "minus_target_entropy": 0.9306685817818725, + "minus_weight": 293.5569353966066, + "orthogonality_relative_error": 1.456713204614742e-16, + "plus_external_effective_rank": 29.588572011800835, + "plus_external_entropy": 0.9361467650534813, + "plus_target_effective_rank": 72.62455545682435, + "plus_target_entropy": 0.9306685817818723, + "plus_weight": 293.55693539660655, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "10e10969198b6ccd3d2727df1f465a4304439b249dcdbd626ec79d7d200f4f31", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:49:48.769441+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "69f3f752bcc25ad0882f63ee7e99ebd36100bdfab26510ab74dbe0395b54604b", + "panel_kind": "isotropic", + "panel_seed": 5914402396525267322, + "realization": 33, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "70759a1828a393a9096132a4a80edd372ef99840f628313c839af34193278a1e", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15511675980718315, + "kernel_residual": 3.3421458209010425e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 34.32112421130742, + "minus_external_entropy": 0.9612285853000445, + "minus_target_effective_rank": 104.42722938425597, + "minus_target_entropy": 0.9473576439387957, + "minus_weight": 290.39642730203246, + "orthogonality_relative_error": 1.4361517373460505e-16, + "plus_external_effective_rank": 34.32112421130744, + "plus_external_entropy": 0.9612285853000447, + "plus_target_effective_rank": 104.42722938425594, + "plus_target_entropy": 0.9473576439387957, + "plus_weight": 290.3964273020324, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "199215a7dced3e46c18621b359e6591d21b970a723a69462ab622bd2af44742e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:32.820176+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "34de02f01b6ee30e3ce4d12afffa85d6086ffa74d069f598a1978aef2944fa5b", + "panel_kind": "sparse", + "panel_seed": 16964271621017944112, + "realization": 34, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3404f7db4a361736fab0e3c990732285406e1773910c2311e15f442f4ac4afe2", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14915108116493522, + "kernel_residual": 3.2706004395150875e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 31.39534621456958, + "minus_external_entropy": 0.9445703005199227, + "minus_target_effective_rank": 72.7028848847927, + "minus_target_entropy": 0.9314621905378394, + "minus_weight": 287.91340152668175, + "orthogonality_relative_error": 1.5287594205690082e-16, + "plus_external_effective_rank": 31.39534621456959, + "plus_external_entropy": 0.9445703005199227, + "plus_target_effective_rank": 72.70288488479271, + "plus_target_entropy": 0.9314621905378394, + "plus_weight": 287.9134015266818, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "26862b270638356d6d69cf9c070fd58e8607a55a95c3725dda0ef521b673c4cd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:48:58.897603+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "34de02f01b6ee30e3ce4d12afffa85d6086ffa74d069f598a1978aef2944fa5b", + "panel_kind": "isotropic", + "panel_seed": 16964271621017944112, + "realization": 34, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0b10b94e9abed3ef388d0213931c8e38b0e9f831e789d13a89bc3a5525799640", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14915108116493522, + "kernel_residual": 3.2706004395150875e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 33.97267482104307, + "minus_external_entropy": 0.9604554557097468, + "minus_target_effective_rank": 103.75838041743863, + "minus_target_entropy": 0.9470180712859252, + "minus_weight": 293.3522928687964, + "orthogonality_relative_error": 1.571288322867653e-16, + "plus_external_effective_rank": 33.97267482104308, + "plus_external_entropy": 0.9604554557097469, + "plus_target_effective_rank": 103.75838041743857, + "plus_target_entropy": 0.9470180712859255, + "plus_weight": 293.3522928687962, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "d906872534c9a6e44cca5e8d938bf6b0afad82004ce83b627023a05a13ecdc9e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:49:37.024423+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "c8880226efca31c6dc1ac658baffb03cba5a260f245a0695f6d3dc0724399deb", + "panel_kind": "sparse", + "panel_seed": 16673254353817791223, + "realization": 35, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8ce091e3260b683ce57ab4925f7fc7295ac411808dac4be97a3395356b8f1fd4", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14789541238417828, + "kernel_residual": 3.3055539426615405e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 30.20127410039203, + "minus_external_entropy": 0.9398271626511059, + "minus_target_effective_rank": 78.33078248888424, + "minus_target_entropy": 0.9350595523156533, + "minus_weight": 288.72126963329123, + "orthogonality_relative_error": 1.2520148997160445e-16, + "plus_external_effective_rank": 30.201274100392038, + "plus_external_entropy": 0.9398271626511059, + "plus_target_effective_rank": 78.33078248888427, + "plus_target_entropy": 0.9350595523156532, + "plus_weight": 288.7212696332912, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "618dac5502efe9b882019cea0d9106af836c9fc5bea3607c55a6d1ce0b683b0c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:10.060040+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "c8880226efca31c6dc1ac658baffb03cba5a260f245a0695f6d3dc0724399deb", + "panel_kind": "isotropic", + "panel_seed": 16673254353817791223, + "realization": 35, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "625a27b647e5a31c126ecf2ecf6314f14c58a4f7f7a04acfab429ca9e6d23de1", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.14789541238417828, + "kernel_residual": 3.3055539426615405e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 33.77368074924732, + "minus_external_entropy": 0.9597140117284828, + "minus_target_effective_rank": 104.06296654837391, + "minus_target_entropy": 0.9470859724894319, + "minus_weight": 290.7189123367809, + "orthogonality_relative_error": 1.237881622953244e-16, + "plus_external_effective_rank": 33.773680749247305, + "plus_external_entropy": 0.9597140117284827, + "plus_target_effective_rank": 104.06296654837396, + "plus_target_entropy": 0.9470859724894317, + "plus_weight": 290.7189123367809, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "8fa2a65606bae810577c2a4fc72c56d17d53eb96e2677780b2e8548ff12ccaf5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:49:30.062992+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "340280451ede4820aa38f1cb734dc134e8a3859c7f2159bc9f3b67ba1b530dad", + "panel_kind": "sparse", + "panel_seed": 6778488455532156907, + "realization": 36, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "67785e1afffd4aaf88e01abd0607eb453815dda0e406abdfd6fdfe92325731ac", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.13619485293968783, + "kernel_residual": 3.41197413231324e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 31.02987424326247, + "minus_external_entropy": 0.9430337529112408, + "minus_target_effective_rank": 75.57757156284022, + "minus_target_entropy": 0.9319210341452872, + "minus_weight": 293.35660050795025, + "orthogonality_relative_error": 1.606315263615449e-16, + "plus_external_effective_rank": 31.029874243262462, + "plus_external_entropy": 0.9430337529112407, + "plus_target_effective_rank": 75.57757156284023, + "plus_target_entropy": 0.9319210341452869, + "plus_weight": 293.35660050795025, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "faeab9e14523ba0707616ce07378711823eaf5321571cd4518975a455700829c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:08.510556+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "340280451ede4820aa38f1cb734dc134e8a3859c7f2159bc9f3b67ba1b530dad", + "panel_kind": "isotropic", + "panel_seed": 6778488455532156907, + "realization": 36, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9c1a703c3c5cfadff2c87e97d89667ad0e43a0eb94548200cb4f680a882ad270", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.13619485293968783, + "kernel_residual": 3.41197413231324e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 32.17070434037618, + "minus_external_entropy": 0.951702898141011, + "minus_target_effective_rank": 101.0063367030188, + "minus_target_entropy": 0.9434374956044265, + "minus_weight": 309.5220850053176, + "orthogonality_relative_error": 1.6156586637638842e-16, + "plus_external_effective_rank": 32.17070434037617, + "plus_external_entropy": 0.9517028981410113, + "plus_target_effective_rank": 101.00633670301875, + "plus_target_entropy": 0.9434374956044265, + "plus_weight": 309.5220850053176, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "c501c8905dcb6bdd7f22c8358fc43a258bb9fa861c9aa2628cf22c1eefb192f8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:49:30.366612+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "63b8babe1d4e93049bea7cae3ebdb1068e814fc4843f8461acbe918334f18067", + "panel_kind": "sparse", + "panel_seed": 7939895470908768144, + "realization": 37, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e2fb09820f794daee9dbbcfb50dcff859631b5e9a71376dedb08c4ebf64ef61f", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.11601741284366243, + "kernel_residual": 3.4316442754984105e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 28.00721596818928, + "minus_external_entropy": 0.9379560842546355, + "minus_target_effective_rank": 70.03272053865558, + "minus_target_entropy": 0.9251960775602551, + "minus_weight": 299.45873259403993, + "orthogonality_relative_error": 2.0120226683924804e-16, + "plus_external_effective_rank": 28.007215968189275, + "plus_external_entropy": 0.9379560842546356, + "plus_target_effective_rank": 70.0327205386556, + "plus_target_entropy": 0.9251960775602549, + "plus_weight": 299.45873259403993, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 43, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 43, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "b51453254cae0781079d73a2c564dbe66f662fd45e7134401881c8d25336ed6f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:02.036061+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "63b8babe1d4e93049bea7cae3ebdb1068e814fc4843f8461acbe918334f18067", + "panel_kind": "isotropic", + "panel_seed": 7939895470908768144, + "realization": 37, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "66455678413782134317471a055fcc040217a1040c1b88eb6c1d82df3ac5c460", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.11601741284366243, + "kernel_residual": 3.4316442754984105e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 31.736917394139148, + "minus_external_entropy": 0.952583459048421, + "minus_target_effective_rank": 100.16429052030576, + "minus_target_entropy": 0.9431795200330717, + "minus_weight": 305.28524515074287, + "orthogonality_relative_error": 1.994490462635517e-16, + "plus_external_effective_rank": 31.73691739413914, + "plus_external_entropy": 0.9525834590484211, + "plus_target_effective_rank": 100.16429052030583, + "plus_target_entropy": 0.9431795200330714, + "plus_weight": 305.2852451507429, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "3b4f1be8baecd604c11aee8bd44167bf57e1c945ddc5ef4ed2ae94aa834aaafd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:49:46.127146+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "0e088f6c1d0dbadb54ecfa6e32debc9351ffb740fa3929883ffbfcd062c13f1a", + "panel_kind": "sparse", + "panel_seed": 3654198854926151821, + "realization": 38, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cb748d0f16d047a09335930d076f8dd6679d7cb939c252063c2fd366e0dbf6ae", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1306493373568247, + "kernel_residual": 3.3324837703283217e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 29.078383663567983, + "minus_external_entropy": 0.9335851446142693, + "minus_target_effective_rank": 74.57523957617127, + "minus_target_entropy": 0.9324576742135812, + "minus_weight": 299.44147860859863, + "orthogonality_relative_error": 1.4432357879034392e-16, + "plus_external_effective_rank": 29.078383663568008, + "plus_external_entropy": 0.9335851446142689, + "plus_target_effective_rank": 74.57523957617136, + "plus_target_entropy": 0.9324576742135812, + "plus_weight": 299.44147860859835, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "d183d729fd10b56dc2a82f23b134262baa004513f36849c473917671ffb2243e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:25.684233+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "0e088f6c1d0dbadb54ecfa6e32debc9351ffb740fa3929883ffbfcd062c13f1a", + "panel_kind": "isotropic", + "panel_seed": 3654198854926151821, + "realization": 38, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e92ae582f5638c248e31be5601330ebae2bbfb5d26d2a14dda1189a381aefc28", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1306493373568247, + "kernel_residual": 3.3324837703283217e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 31.949341648906422, + "minus_external_entropy": 0.9516098009358083, + "minus_target_effective_rank": 102.0704926434002, + "minus_target_entropy": 0.9454021430462943, + "minus_weight": 308.52037805908566, + "orthogonality_relative_error": 1.4720458821292675e-16, + "plus_external_effective_rank": 31.949341648906447, + "plus_external_entropy": 0.9516098009358083, + "plus_target_effective_rank": 102.07049264340019, + "plus_target_entropy": 0.9454021430462943, + "plus_weight": 308.5203780590854, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "abc7ffbe7eadc3ca72dfe6bd6657c3db7f4cbadd62c9d7555c79496ea1b1dfda", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:01.487523+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "81aa62fe2793741ac2d8a6673ef1f93855a93fc4761d70bc276de0f07a859ced", + "panel_kind": "sparse", + "panel_seed": 12451128348875914675, + "realization": 39, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d9d852ab002ffcad703647f7f4203120c84ee166acecdc2afc947a680c6b57da", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1341385499167237, + "kernel_residual": 3.3395495133915656e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 30.526613352919426, + "minus_external_entropy": 0.94417735938783, + "minus_target_effective_rank": 77.94936151358658, + "minus_target_entropy": 0.9316792339419528, + "minus_weight": 294.40173411045754, + "orthogonality_relative_error": 1.9631358228931118e-16, + "plus_external_effective_rank": 30.526613352919405, + "plus_external_entropy": 0.94417735938783, + "plus_target_effective_rank": 77.94936151358652, + "plus_target_entropy": 0.9316792339419528, + "plus_weight": 294.4017341104577, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "6d73245524873686082e0fe66a6eb37d565dc5724f56e0409567b35093dd320a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:38.828428+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "81aa62fe2793741ac2d8a6673ef1f93855a93fc4761d70bc276de0f07a859ced", + "panel_kind": "isotropic", + "panel_seed": 12451128348875914675, + "realization": 39, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c499f84e8a774f46bd5a77a9855759914b444a00ef2f9c3216b9fecef61e5be7", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1341385499167237, + "kernel_residual": 3.3395495133915656e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 32.33190171265507, + "minus_external_entropy": 0.9538784709461152, + "minus_target_effective_rank": 102.36650226370652, + "minus_target_entropy": 0.9454964591661429, + "minus_weight": 301.42289311572046, + "orthogonality_relative_error": 1.972584042072782e-16, + "plus_external_effective_rank": 32.33190171265504, + "plus_external_entropy": 0.9538784709461153, + "plus_target_effective_rank": 102.36650226370645, + "plus_target_entropy": 0.9454964591661429, + "plus_weight": 301.42289311572057, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "90c95ca8777ce2138c9a206615675ec53b798a79750e7be8dc8c655c86114e66", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:06.482749+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "58f93e2d817b7e2bb68cda4e681c701c6734d43b90a5c0701e5cac2f5678fe8e", + "panel_kind": "sparse", + "panel_seed": 9635923904796549406, + "realization": 40, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4fc268f7b48f0a0e393833220a1595e508c27c8488cc12bcdc7aa0aba4f9e82a", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1345289042248388, + "kernel_residual": 3.31905116472765e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 32.366081304676435, + "minus_external_entropy": 0.9537534453891019, + "minus_target_effective_rank": 91.46169219327066, + "minus_target_entropy": 0.9365799007681055, + "minus_weight": 294.3597834130703, + "orthogonality_relative_error": 1.6441262691644886e-16, + "plus_external_effective_rank": 32.36608130467643, + "plus_external_entropy": 0.953753445389102, + "plus_target_effective_rank": 91.46169219327071, + "plus_target_entropy": 0.9365799007681055, + "plus_weight": 294.35978341307043, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "da0a1224ca0c5e7efcb4e8ac7c915e0b1614f7ca41feaacf6c4a8869375b6d17", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:42.563086+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "58f93e2d817b7e2bb68cda4e681c701c6734d43b90a5c0701e5cac2f5678fe8e", + "panel_kind": "isotropic", + "panel_seed": 9635923904796549406, + "realization": 40, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "05081374feb0385083ab6b45850c4170ce4e900e5b0d049b1c38b0c9b87839f7", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1345289042248388, + "kernel_residual": 3.31905116472765e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 32.61418362647997, + "minus_external_entropy": 0.9550505637563312, + "minus_target_effective_rank": 102.64721630706067, + "minus_target_entropy": 0.945821119140922, + "minus_weight": 301.52431894659367, + "orthogonality_relative_error": 1.6485485532889844e-16, + "plus_external_effective_rank": 32.61418362647996, + "plus_external_entropy": 0.9550505637563316, + "plus_target_effective_rank": 102.6472163070607, + "plus_target_entropy": 0.945821119140922, + "plus_weight": 301.52431894659355, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "ff2914fb2064149602fd84b7b6843f7f2b40ae17dde89df11f047b5479c56d9a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:19.431350+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "030b9699373aac8b00e62afea98b9f683c8c91520d79b63a4129c7dda8fa2651", + "panel_kind": "sparse", + "panel_seed": 10362045754205692676, + "realization": 41, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bad4f27b3abfb6b160273a32d7d1d142a6c8e8a772e1c4cf22f349981c511038", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1731759768201029, + "kernel_residual": 3.256659112097082e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 29.12532093746155, + "minus_external_entropy": 0.9352480423902471, + "minus_target_effective_rank": 77.30334297796006, + "minus_target_entropy": 0.9358403246355419, + "minus_weight": 292.5587744273933, + "orthogonality_relative_error": 1.4642074029032114e-16, + "plus_external_effective_rank": 29.125320937461524, + "plus_external_entropy": 0.9352480423902471, + "plus_target_effective_rank": 77.30334297796004, + "plus_target_entropy": 0.9358403246355416, + "plus_weight": 292.55877442739336, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "8eb7722ca1d2e6ac5f4ca517d30389832ad95ce6eced8a41e9a154a0fa4418c4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:52.191457+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "030b9699373aac8b00e62afea98b9f683c8c91520d79b63a4129c7dda8fa2651", + "panel_kind": "isotropic", + "panel_seed": 10362045754205692676, + "realization": 41, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a20dd234f65351d7d749a8c5bca5cac8750a8297f0b4e655d71447567da443b5", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1731759768201029, + "kernel_residual": 3.256659112097082e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 34.47420940944554, + "minus_external_entropy": 0.9618338863165975, + "minus_target_effective_rank": 104.80640597905773, + "minus_target_entropy": 0.9480145762987254, + "minus_weight": 290.0034595479975, + "orthogonality_relative_error": 1.4540378627368564e-16, + "plus_external_effective_rank": 34.47420940944556, + "plus_external_entropy": 0.9618338863165978, + "plus_target_effective_rank": 104.80640597905777, + "plus_target_entropy": 0.9480145762987252, + "plus_weight": 290.0034595479976, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "430b0fc06f596198c1c627e3b502954090cb61cfda1ca5e559cd14cc70f2e98f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:49:24.222676+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "a849564c8776e50727c48d68c80580d9b83c188c1ec4b127eef1a8a818653aea", + "panel_kind": "sparse", + "panel_seed": 9494154870382996696, + "realization": 42, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8a1d280f234177610e5f0c2eab1d89681977b1e453e6df2f97929271d58bfe30", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1333465648738752, + "kernel_residual": 3.2598933818047027e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 28.966771217350384, + "minus_external_entropy": 0.9339213058096454, + "minus_target_effective_rank": 78.60730924796394, + "minus_target_entropy": 0.9306959248439467, + "minus_weight": 317.4832583837529, + "orthogonality_relative_error": 1.59546434675379e-16, + "plus_external_effective_rank": 28.9667712173504, + "plus_external_entropy": 0.9339213058096455, + "plus_target_effective_rank": 78.60730924796395, + "plus_target_entropy": 0.9306959248439466, + "plus_weight": 317.4832583837529, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "bd6a4fd834f12533ceac2a6c8d685991854398266642b67970c36d15e2dcc708", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:49:49.837693+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "a849564c8776e50727c48d68c80580d9b83c188c1ec4b127eef1a8a818653aea", + "panel_kind": "isotropic", + "panel_seed": 9494154870382996696, + "realization": 42, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4d781b30a718e502fa794a254de2f778273bc4d700f7004004aa183ebb781e1a", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1333465648738752, + "kernel_residual": 3.2598933818047027e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 32.31566273200668, + "minus_external_entropy": 0.9524986775463582, + "minus_target_effective_rank": 101.92699377854832, + "minus_target_entropy": 0.9447179516744929, + "minus_weight": 310.97866859824484, + "orthogonality_relative_error": 1.6033697129609241e-16, + "plus_external_effective_rank": 32.315662732006686, + "plus_external_entropy": 0.9524986775463583, + "plus_target_effective_rank": 101.9269937785483, + "plus_target_entropy": 0.9447179516744927, + "plus_weight": 310.9786685982449, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "2641f645f0549d1347c73d00889b5e6b75887e84d8fcd36acfff446e83c9c8b6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:42.270390+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "9264e37474abb3eb55515c1c081cde375787036e3749d4ab7bfd24fa053451cf", + "panel_kind": "sparse", + "panel_seed": 6592302852804528193, + "realization": 43, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "dfd30bf6b657637c43f19a514a4d407e0f5ac393b1b730a127706456e203ec3c", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1682181862999659, + "kernel_residual": 3.3181463018951507e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 31.287964595218142, + "minus_external_entropy": 0.9440412390955317, + "minus_target_effective_rank": 80.19319485369144, + "minus_target_entropy": 0.9354965426578892, + "minus_weight": 290.2528754653035, + "orthogonality_relative_error": 1.550885618263626e-16, + "plus_external_effective_rank": 31.287964595218142, + "plus_external_entropy": 0.9440412390955318, + "plus_target_effective_rank": 80.1931948536914, + "plus_target_entropy": 0.9354965426578892, + "plus_weight": 290.25287546530353, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "33d9534dffa150d1116e2c86bcd038c3778508343f4173cb4d16fc03b9682a82", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:15.230079+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "9264e37474abb3eb55515c1c081cde375787036e3749d4ab7bfd24fa053451cf", + "panel_kind": "isotropic", + "panel_seed": 6592302852804528193, + "realization": 43, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "da61461fbee40909a25c3833490d48f33ee19d20857c5116cb30d530b5970496", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1682181862999659, + "kernel_residual": 3.3181463018951507e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 33.85000700316767, + "minus_external_entropy": 0.9592428978498369, + "minus_target_effective_rank": 103.20088780355232, + "minus_target_entropy": 0.9459927323803227, + "minus_weight": 298.1841403155423, + "orthogonality_relative_error": 1.5647706003645602e-16, + "plus_external_effective_rank": 33.850007003167676, + "plus_external_entropy": 0.959242897849837, + "plus_target_effective_rank": 103.20088780355225, + "plus_target_entropy": 0.9459927323803228, + "plus_weight": 298.18414031554227, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "8451feefe5bcbec0bd0a07287aba05f2f44867ac134abd20b78e780e54d2b60c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:42.293672+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "0d46de2f49c134e5c140267b91c219acd4e508f2a779ac7011e24d57c2ed9b78", + "panel_kind": "sparse", + "panel_seed": 5666108154634730448, + "realization": 44, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e31166688993d59b29ffcf26e88002d816576157cc5c1ee9317d2d219331b579", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15495171463008792, + "kernel_residual": 3.257808172183433e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 27.200046863438388, + "minus_external_entropy": 0.9194547757830585, + "minus_target_effective_rank": 66.07346879620052, + "minus_target_entropy": 0.9269770820252878, + "minus_weight": 295.8021852713153, + "orthogonality_relative_error": 1.5368885135094266e-16, + "plus_external_effective_rank": 27.2000468634384, + "plus_external_entropy": 0.9194547757830582, + "plus_target_effective_rank": 66.07346879620052, + "plus_target_entropy": 0.9269770820252876, + "plus_weight": 295.80218527131547, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "19012749be6459c74f55ea0a7f3f12d0e28087bfb7ea030e7745b6f2970e89a8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:16.288541+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "0d46de2f49c134e5c140267b91c219acd4e508f2a779ac7011e24d57c2ed9b78", + "panel_kind": "isotropic", + "panel_seed": 5666108154634730448, + "realization": 44, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "edabb3e22988a9acf37e3122dad057038a13f7da6f5ae6e178e6d5b5e9edb65a", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.15495171463008792, + "kernel_residual": 3.257808172183433e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 34.06791497250534, + "minus_external_entropy": 0.9604744443684784, + "minus_target_effective_rank": 104.63346148304022, + "minus_target_entropy": 0.9476748622335269, + "minus_weight": 293.44988916480156, + "orthogonality_relative_error": 1.4805546359507697e-16, + "plus_external_effective_rank": 34.067914972505356, + "plus_external_entropy": 0.9604744443684785, + "plus_target_effective_rank": 104.63346148304025, + "plus_target_entropy": 0.9476748622335271, + "plus_weight": 293.4498891648017, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "0210ffd4356445754c849fe90ee01ee2931b6688db3f96f6117026f3436890b6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:37.344675+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "5ddc8944831a678e78f11ecdb17522793254401f3abbc2620d0652e7702b2ec3", + "panel_kind": "sparse", + "panel_seed": 13272246560284351411, + "realization": 45, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cc05f2167bfa55e848dd2d470427c92d8a090750320313eac99e0662d873705d", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1283087802435453, + "kernel_residual": 3.3447152148879203e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 29.494024885049534, + "minus_external_entropy": 0.938759601276041, + "minus_target_effective_rank": 76.44741046208574, + "minus_target_entropy": 0.9339405899189993, + "minus_weight": 291.08304321773323, + "orthogonality_relative_error": 1.7692660824220917e-16, + "plus_external_effective_rank": 29.494024885049534, + "plus_external_entropy": 0.9387596012760409, + "plus_target_effective_rank": 76.44741046208574, + "plus_target_entropy": 0.9339405899189993, + "plus_weight": 291.0830432177332, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "0c59f207e3d7d991814994d3db4c079f093e7684091d1c13db45727431ca5965", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:12.044110+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "5ddc8944831a678e78f11ecdb17522793254401f3abbc2620d0652e7702b2ec3", + "panel_kind": "isotropic", + "panel_seed": 13272246560284351411, + "realization": 45, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7f4a16d3cdfbf5de204d34f0387f1994d9d255225b7f91eaf05ca7cd41fa6b86", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.1283087802435453, + "kernel_residual": 3.3447152148879203e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 32.714038985253765, + "minus_external_entropy": 0.9558320611169613, + "minus_target_effective_rank": 102.90723870379635, + "minus_target_entropy": 0.9461280937005888, + "minus_weight": 296.09290512716257, + "orthogonality_relative_error": 1.8018944184631426e-16, + "plus_external_effective_rank": 32.71403898525373, + "plus_external_entropy": 0.9558320611169614, + "plus_target_effective_rank": 102.90723870379628, + "plus_target_entropy": 0.9461280937005888, + "plus_weight": 296.0929051271625, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "90831c6c4e550f37b83fd381d7c630a0bd7586506c867b039cacccc46c0f531a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:09.049352+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "27b2558ad859976b5872ba45d907de82d3794729a23eee33bdbb6641453664e7", + "panel_kind": "sparse", + "panel_seed": 17051832160380018863, + "realization": 46, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "818c7fd019a83bef52b02de37a66d022235efe98f8ddd41ca92b92ec119e30ca", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.13383820395257834, + "kernel_residual": 3.570665688340913e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 28.986498932506287, + "minus_external_entropy": 0.9341991141076398, + "minus_target_effective_rank": 74.71054277810407, + "minus_target_entropy": 0.9335915634856302, + "minus_weight": 307.5081272185091, + "orthogonality_relative_error": 1.6272681782883037e-16, + "plus_external_effective_rank": 28.98649893250628, + "plus_external_entropy": 0.9341991141076399, + "plus_target_effective_rank": 74.71054277810408, + "plus_target_entropy": 0.9335915634856302, + "plus_weight": 307.5081272185091, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "db646b5b71443b78d312edf0782e51b07d157142cf3cbcd7d5bdd70a54d3bada", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:43.590961+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "27b2558ad859976b5872ba45d907de82d3794729a23eee33bdbb6641453664e7", + "panel_kind": "isotropic", + "panel_seed": 17051832160380018863, + "realization": 46, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0b369428165bce4c62134e1df0a179cf1ba405e336b236ac3c4b6b5c1cd13aec", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.13383820395257834, + "kernel_residual": 3.570665688340913e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 32.8309166177912, + "minus_external_entropy": 0.9555868952708747, + "minus_target_effective_rank": 101.91794255532739, + "minus_target_entropy": 0.9446498849773921, + "minus_weight": 300.54832864719225, + "orthogonality_relative_error": 1.5811381104221815e-16, + "plus_external_effective_rank": 32.83091661779122, + "plus_external_entropy": 0.9555868952708744, + "plus_target_effective_rank": 101.91794255532733, + "plus_target_entropy": 0.9446498849773923, + "plus_weight": 300.5483286471923, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "0b73d6eb44ee1b8ee6eb0982448ae179c4d269c1db74c3235f5ed46ef18c2525", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:20.991455+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "cd1b8c27776d05fc26b8a78e46a98deb6b92f50110468a3ad1b10eeca2aa096c", + "panel_kind": "sparse", + "panel_seed": 8262039786593768002, + "realization": 47, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7e1f2a4921d57e3459c58d9a1a6d612150f7acb28bd7c5a0e05086b4ae2a9c11", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.16437981191983364, + "kernel_residual": 3.3607886507029904e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 30.59277285771408, + "minus_external_entropy": 0.9426419701282919, + "minus_target_effective_rank": 81.67574346109741, + "minus_target_entropy": 0.9342420474303798, + "minus_weight": 290.9301518634363, + "orthogonality_relative_error": 1.3640179621724763e-16, + "plus_external_effective_rank": 30.592772857714078, + "plus_external_entropy": 0.9426419701282915, + "plus_target_effective_rank": 81.67574346109745, + "plus_target_entropy": 0.93424204743038, + "plus_weight": 290.93015186343615, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "63053da0f623ae964dcb985ee6f62a5bdd6d38adffe2aa3b05f66f83dfebb933", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:00.071829+00:00", + "identity": { + "N": 10, + "charge": 5, + "kernel_identity_hash": "cd1b8c27776d05fc26b8a78e46a98deb6b92f50110468a3ad1b10eeca2aa096c", + "panel_kind": "isotropic", + "panel_seed": 8262039786593768002, + "realization": 47, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "76306f5913781f1b2e36080d1ec0c71c6829b2797bfb6af35b21fdc095a33a71", + "kernel": { + "bps_rank": 162, + "complement_rank": 90, + "gap": 0.16437981191983364, + "kernel_residual": 3.3607886507029904e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 34.86342581962365, + "minus_external_entropy": 0.9637374245851505, + "minus_target_effective_rank": 104.65377658937001, + "minus_target_entropy": 0.9479649857101539, + "minus_weight": 285.6085842645929, + "orthogonality_relative_error": 1.3016203073026267e-16, + "plus_external_effective_rank": 34.86342581962364, + "plus_external_entropy": 0.9637374245851507, + "plus_target_effective_rank": 104.65377658937, + "plus_target_entropy": 0.9479649857101538, + "plus_weight": 285.60858426459276, + "target_rank": 162 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 45, + "minus_target_eigenvalues": 162, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 45, + "plus_target_eigenvalues": 162 + } + }, + { + "arrays_sha256": "032799d2b2b6e4296f9182f79ddb44acd9a011623397096900f6d1b13d54736d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:19.794006+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "ef0201b309e61e9c8c2cdaa76ba8a6eeb872c42ff7543d3a896d9db8e9b1250c", + "panel_kind": "sparse", + "panel_seed": 4335525719167323622, + "realization": 0, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "28927856686975a35be24eadaaee847b22444b2ee377ac666709d86f79cab0ba", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.02006512227889362, + "kernel_residual": 2.721427734020474e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14924623447991595, + "minus_external_effective_rank": 8.532619311363858, + "minus_external_entropy": 0.9633046534207911, + "minus_target_effective_rank": 33.85715127288905, + "minus_target_entropy": 0.92701963261338, + "minus_weight": 32.866539089518916, + "orthogonality_relative_error": 4.749815671355823e-16, + "plus_external_effective_rank": 48.384601850575436, + "plus_external_entropy": 0.8824444317856406, + "plus_target_effective_rank": 61.827381685497855, + "plus_target_entropy": 0.9652906778249646, + "plus_weight": 813.8070613185627, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 118, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "b76ef0589ac28ecbdb64ad29d8615ffe9e00f840c4483197111c7a8d1fc191ce", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:34.168052+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "ef0201b309e61e9c8c2cdaa76ba8a6eeb872c42ff7543d3a896d9db8e9b1250c", + "panel_kind": "isotropic", + "panel_seed": 4335525719167323622, + "realization": 0, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7a0c265854d70ed5fd5ed7eac76bed718204402a7718734fbe9e5afa902b38ef", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.02006512227889362, + "kernel_residual": 2.721427734020474e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14752137590637382, + "minus_external_effective_rank": 8.510838572345794, + "minus_external_entropy": 0.9645006632417997, + "minus_target_effective_rank": 38.64354625700833, + "minus_target_entropy": 0.8810040039311916, + "minus_weight": 32.376885076267435, + "orthogonality_relative_error": 4.830546671384281e-16, + "plus_external_effective_rank": 51.80031977762518, + "plus_external_entropy": 0.894187304485537, + "plus_target_effective_rank": 67.04020309436719, + "plus_target_entropy": 0.9774061441498221, + "plus_weight": 811.8450168593884, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "7e5d176b32b305c0ca7f4743b49ecad1a609bf85765439bd7af09d16ba4d6bab", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:20.960738+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "0bc6dc134063415d1a1c5196e78ef2f8491664f4b0beb436a0acb78171b5a10f", + "panel_kind": "sparse", + "panel_seed": 13614044768780887445, + "realization": 1, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "787a7f1c4399df512e1a4f30fe1606f610fd8025a4d0135914cc04fb7367f8af", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.0183150496434246, + "kernel_residual": 2.6585129329918786e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.15907296691729475, + "minus_external_effective_rank": 8.160835783161076, + "minus_external_entropy": 0.9530493979307535, + "minus_target_effective_rank": 29.902666458020654, + "minus_target_entropy": 0.9230206076529303, + "minus_weight": 33.86463534997125, + "orthogonality_relative_error": 5.306976291531486e-16, + "plus_external_effective_rank": 44.778104112082815, + "plus_external_entropy": 0.8827556828126285, + "plus_target_effective_rank": 56.47047739429717, + "plus_target_entropy": 0.9506583996679457, + "plus_weight": 782.354606590204, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 106, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "c65a29bbd61c07b1876c0d04da47574d52b3de2cc842d677d5c363116b3be071", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:43.258384+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "0bc6dc134063415d1a1c5196e78ef2f8491664f4b0beb436a0acb78171b5a10f", + "panel_kind": "isotropic", + "panel_seed": 13614044768780887445, + "realization": 1, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3cff64028851d1af414fb0d7019156f83b031e6ebfba7326f03b7e0082c9aef2", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.0183150496434246, + "kernel_residual": 2.6585129329918786e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.15551020996119813, + "minus_external_effective_rank": 8.909476195580957, + "minus_external_entropy": 0.9742197124394524, + "minus_target_effective_rank": 39.133026680599905, + "minus_target_entropy": 0.8828303492570619, + "minus_weight": 33.465928135511774, + "orthogonality_relative_error": 5.517231723353423e-16, + "plus_external_effective_rank": 51.06907385776452, + "plus_external_entropy": 0.8938365525544203, + "plus_target_effective_rank": 66.20878911364184, + "plus_target_entropy": 0.9759934087398406, + "plus_weight": 792.4582282826144, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "3ede02cbe8ed5733e6c164002e5991f4117a4da7c81bc5218ace9aa4d245d6b4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:13.877747+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "8ac7b4be877682428a51d59b7a58071651b42d1211427f3b3c9c2eaa2671ccba", + "panel_kind": "sparse", + "panel_seed": 232208470447199950, + "realization": 2, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "61deb68af53e61e0fba42d94cb687cb0a0e009b1845f0940fe16f388086a0a65", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007415986870200697, + "kernel_residual": 2.6618848509520708e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.135046532807347, + "minus_external_effective_rank": 8.060180129125566, + "minus_external_entropy": 0.9485135323027741, + "minus_target_effective_rank": 31.477261702686786, + "minus_target_entropy": 0.9162092946759905, + "minus_weight": 35.552568375561144, + "orthogonality_relative_error": 1.3273205069963156e-15, + "plus_external_effective_rank": 34.727100757191444, + "plus_external_entropy": 0.8437939581926581, + "plus_target_effective_rank": 51.39389533359228, + "plus_target_entropy": 0.9412425950334011, + "plus_weight": 980.6524020109853, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 113, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "81a67304512cc8623e62aa6bf08fbdf101d9f20ff60626a43030e6f4aab9ac6d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:23.589436+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "8ac7b4be877682428a51d59b7a58071651b42d1211427f3b3c9c2eaa2671ccba", + "panel_kind": "isotropic", + "panel_seed": 232208470447199950, + "realization": 2, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4d8d68c533cacbbf809ffd2b03d0f1e7bec7fdd24eb91d2e15b20d67454390a1", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007415986870200697, + "kernel_residual": 2.6618848509520708e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.11516547986060229, + "minus_external_effective_rank": 8.445897943887495, + "minus_external_entropy": 0.9604644746700406, + "minus_target_effective_rank": 37.546326041030596, + "minus_target_entropy": 0.8756328310683321, + "minus_weight": 33.6769244326921, + "orthogonality_relative_error": 1.4428817748053655e-15, + "plus_external_effective_rank": 33.30804472897431, + "plus_external_entropy": 0.8390518293919256, + "plus_target_effective_rank": 59.47611292017779, + "plus_target_entropy": 0.9630347470106195, + "plus_weight": 1101.3044959904173, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "c18b02f471286b0ddf7ee2146c73e6af94a18da2a7627712aa813217ef12d8c9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:48.545536+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "7b71b67ea64617d6a715c93b6c9e95c639defa7caad28b19129dfe507be4e836", + "panel_kind": "sparse", + "panel_seed": 12603455259744080376, + "realization": 3, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e5a8c470b20347f4d26f74bc38128ac7dd5d420464615d29d603909cffa042ca", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01591896802349444, + "kernel_residual": 2.8387421725186886e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13860575217148557, + "minus_external_effective_rank": 8.63874163445898, + "minus_external_entropy": 0.9661807832618733, + "minus_target_effective_rank": 34.8674030493232, + "minus_target_entropy": 0.9239897609699914, + "minus_weight": 32.06049369123678, + "orthogonality_relative_error": 5.449935224287274e-16, + "plus_external_effective_rank": 46.48503221442821, + "plus_external_entropy": 0.8796401183163456, + "plus_target_effective_rank": 63.80743700759443, + "plus_target_entropy": 0.9697117691210974, + "plus_weight": 859.9120610101874, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "5062dec0fc08de56662c12ad065a1af24c506d90a4516e846a5978772744a14e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:01.657681+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "7b71b67ea64617d6a715c93b6c9e95c639defa7caad28b19129dfe507be4e836", + "panel_kind": "isotropic", + "panel_seed": 12603455259744080376, + "realization": 3, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1541936b440572ed0e917f42a8a21c72ad5c8c08d29a3a9e8d476bd07297c010", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01591896802349444, + "kernel_residual": 2.8387421725186886e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14658889840758327, + "minus_external_effective_rank": 8.723150328745072, + "minus_external_entropy": 0.9687585722618078, + "minus_target_effective_rank": 39.50970793069033, + "minus_target_entropy": 0.8840354277036176, + "minus_weight": 33.36917985144566, + "orthogonality_relative_error": 5.382703798543416e-16, + "plus_external_effective_rank": 48.5075946920426, + "plus_external_entropy": 0.8873513029332187, + "plus_target_effective_rank": 66.14975055761353, + "plus_target_entropy": 0.975770328372511, + "plus_weight": 842.491312827979, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "8ed0f284246e6a5ba659dc2bfa5e2caf3b71c0e7496127b7de858f35121b6a0b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:48.583938+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "2d2cafcbe2de70de275b86ad225f6e29443fbfa3eb93b809e129cef167664f7c", + "panel_kind": "sparse", + "panel_seed": 7770111801243963963, + "realization": 4, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8166d6d2ed34bd0fd3d5a12e1334004d5836a5cc2c86e2884670c7e3dd4e6baa", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.012691334434889503, + "kernel_residual": 2.7475392526997516e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14002969727111075, + "minus_external_effective_rank": 7.759050347757389, + "minus_external_entropy": 0.9399543279775465, + "minus_target_effective_rank": 30.827194044648675, + "minus_target_entropy": 0.9158934633829683, + "minus_weight": 33.98056465275523, + "orthogonality_relative_error": 6.873449971564174e-16, + "plus_external_effective_rank": 39.66722950746456, + "plus_external_entropy": 0.8660654488825323, + "plus_target_effective_rank": 55.27108419959948, + "plus_target_entropy": 0.9468267565705084, + "plus_weight": 901.4252974326625, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 107, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "0dd37534162ce22b817c5e075d0d863acb5893881a278a7c73d8f8f1887dce91", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:02.869797+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "2d2cafcbe2de70de275b86ad225f6e29443fbfa3eb93b809e129cef167664f7c", + "panel_kind": "isotropic", + "panel_seed": 7770111801243963963, + "realization": 4, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "699b195375e9e997a202ae2dca22b95f9d56dfc593f3debaafe696d8a9a35e76", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.012691334434889503, + "kernel_residual": 2.7475392526997516e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1369000259247839, + "minus_external_effective_rank": 8.482999622972436, + "minus_external_entropy": 0.9635158434942085, + "minus_target_effective_rank": 38.82881760674353, + "minus_target_entropy": 0.8820587123841785, + "minus_weight": 32.78704825023837, + "orthogonality_relative_error": 6.99692202730983e-16, + "plus_external_effective_rank": 44.31011273852569, + "plus_external_entropy": 0.877007202938416, + "plus_target_effective_rank": 64.33325309114099, + "plus_target_entropy": 0.9724861909478161, + "plus_weight": 891.2048401512826, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "8b4ed2a267bd281da03607f80cf76a8881fc15ef943a630eb9ff5f52660d0e6a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:42.733972+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "8eea604de3d94dcb5bcca7deaf818c7fa86abdcf49400006529234c462a92ec6", + "panel_kind": "sparse", + "panel_seed": 8115342432319480691, + "realization": 5, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5e166825b3fd382999939f127a7a2f75be45a32fc20e11a33a382b77e90c11f7", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.022316252331638267, + "kernel_residual": 2.7764194958556766e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1530335468309004, + "minus_external_effective_rank": 8.306190272129601, + "minus_external_entropy": 0.9550151697858471, + "minus_target_effective_rank": 29.697274465789747, + "minus_target_entropy": 0.9189741155498179, + "minus_weight": 33.769804083270444, + "orthogonality_relative_error": 4.309317782676933e-16, + "plus_external_effective_rank": 43.01985298804462, + "plus_external_entropy": 0.8827169842744444, + "plus_target_effective_rank": 54.53782248581031, + "plus_target_entropy": 0.9431383852935467, + "plus_weight": 813.7361140167907, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 103, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "8957619d77eda3fe0c876438d00ed83e3b13361c937cf5b01574553889d11abc", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:57.759681+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "8eea604de3d94dcb5bcca7deaf818c7fa86abdcf49400006529234c462a92ec6", + "panel_kind": "isotropic", + "panel_seed": 8115342432319480691, + "realization": 5, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "87f1492f8ccf03e71e6316fc9ffd3db91d584d7ca3e3b235f440f0729c7ee885", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.022316252331638267, + "kernel_residual": 2.7764194958556766e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14607461240499958, + "minus_external_effective_rank": 8.684497137484742, + "minus_external_entropy": 0.968481110840681, + "minus_target_effective_rank": 39.45905706816743, + "minus_target_entropy": 0.8841814759375385, + "minus_weight": 33.24407793999508, + "orthogonality_relative_error": 4.4322569641456634e-16, + "plus_external_effective_rank": 51.50922330663161, + "plus_external_entropy": 0.8922537280007593, + "plus_target_effective_rank": 68.02158255960545, + "plus_target_entropy": 0.9791974004220478, + "plus_weight": 842.5315568831736, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "b60eadccd0415d16e6f541cfd191285bd2950f543f5e3d0696c533821cf3040f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:21.190986+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "4897b4dcd73ab882dd4651ddf9a19f4a6380fa69bdc43e746f3d0e3fa50cd403", + "panel_kind": "sparse", + "panel_seed": 1275143713785600806, + "realization": 6, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "aa954f51def4fc156ff2b93f05ac8d653e6280b9e40d54c4bcabbfdf65b8bb9a", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007936871273118432, + "kernel_residual": 2.7639845572444556e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1659967537164754, + "minus_external_effective_rank": 8.47618996251905, + "minus_external_entropy": 0.9620026151721524, + "minus_target_effective_rank": 32.28484724526177, + "minus_target_entropy": 0.9257512280567047, + "minus_weight": 36.69216137586447, + "orthogonality_relative_error": 1.1457895253787265e-15, + "plus_external_effective_rank": 35.779144558839945, + "plus_external_entropy": 0.8566360146635958, + "plus_target_effective_rank": 51.76740736017684, + "plus_target_entropy": 0.9399654827961509, + "plus_weight": 809.1175050427576, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 112, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "b68f2c40955d4e83842c13c6d36dcf100090c96bdea7890e69e09b79eaa644f2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:37.898688+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "4897b4dcd73ab882dd4651ddf9a19f4a6380fa69bdc43e746f3d0e3fa50cd403", + "panel_kind": "isotropic", + "panel_seed": 1275143713785600806, + "realization": 6, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e146992499475f997e698f57318098b6e9d48f7f6831971597aacba00f26d172", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007936871273118432, + "kernel_residual": 2.7639845572444556e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1322735590323469, + "minus_external_effective_rank": 8.635158402082755, + "minus_external_entropy": 0.965874551427709, + "minus_target_effective_rank": 39.18570452683054, + "minus_target_entropy": 0.8823099693232199, + "minus_weight": 32.65990303824816, + "orthogonality_relative_error": 1.1838718644021684e-15, + "plus_external_effective_rank": 36.31284520019802, + "plus_external_entropy": 0.8594594184473789, + "plus_target_effective_rank": 60.83720543135434, + "plus_target_entropy": 0.9662127256479913, + "plus_weight": 921.1694574082524, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "77353b395572564a9438216dd2190807c30f988a3cbb7e9ad2f7e856a03d8e2b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:42.874571+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "5d3809f536306f8cd7e400da825a795a37072cfb6ab47dc58f89b1281f0cbbd1", + "panel_kind": "sparse", + "panel_seed": 5665436405369052547, + "realization": 7, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cd9992a33fa57e30daacae736401685b7e3dcd8753804bdff37c12f31c6f185b", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.013508858916819943, + "kernel_residual": 2.7469975789744918e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13271193329161612, + "minus_external_effective_rank": 7.947177670423244, + "minus_external_entropy": 0.9429812523256633, + "minus_target_effective_rank": 29.056290977855426, + "minus_target_entropy": 0.9104168057461652, + "minus_weight": 31.74826335911329, + "orthogonality_relative_error": 7.95975520330785e-16, + "plus_external_effective_rank": 38.787311030623655, + "plus_external_entropy": 0.8605143181729746, + "plus_target_effective_rank": 53.32437220802666, + "plus_target_entropy": 0.9428779159494632, + "plus_weight": 892.2814071698032, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 109, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "2fb3baf40d972b1df5cec7a5c633b123274e5030d95e4b078e296839dae046a5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:56.794298+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "5d3809f536306f8cd7e400da825a795a37072cfb6ab47dc58f89b1281f0cbbd1", + "panel_kind": "isotropic", + "panel_seed": 5665436405369052547, + "realization": 7, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5d46de9a16731da428ba948e5125a4d86e78fd451e7593bda2376cf0847aa9a7", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.013508858916819943, + "kernel_residual": 2.7469975789744918e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14250257739966277, + "minus_external_effective_rank": 8.66775947446406, + "minus_external_entropy": 0.9665483458931025, + "minus_target_effective_rank": 38.901855105319285, + "minus_target_entropy": 0.8815427909487433, + "minus_weight": 33.56406215026831, + "orthogonality_relative_error": 8.309539041812352e-16, + "plus_external_effective_rank": 45.027325337553606, + "plus_external_entropy": 0.8780314858778037, + "plus_target_effective_rank": 64.69173373578325, + "plus_target_entropy": 0.9731436701721271, + "plus_weight": 873.7145727133479, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "98d938bf9c09c596940983ad2c86230a684c099da57383bab2c471cd38629321", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:48.354178+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "6250e0cba7a48b8b7918fd5c1cf855cb803aac27bd2cfb53dd6e6b2408c2f9e4", + "panel_kind": "sparse", + "panel_seed": 14733645433978310927, + "realization": 8, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c1b9b6b1f857db15b919e3a02d6b5d13fa38a5d90e74b2b5b1652ea849053c42", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01096823070211098, + "kernel_residual": 2.7366901444231138e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.12282253282719083, + "minus_external_effective_rank": 7.89873112192623, + "minus_external_entropy": 0.943742447836379, + "minus_target_effective_rank": 29.80059039026923, + "minus_target_entropy": 0.9132496619973465, + "minus_weight": 32.93799686795507, + "orthogonality_relative_error": 9.091405117892577e-16, + "plus_external_effective_rank": 36.87794507715867, + "plus_external_entropy": 0.8522009874140937, + "plus_target_effective_rank": 54.63875549076222, + "plus_target_entropy": 0.947292910517327, + "plus_weight": 1005.7473828413983, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 111, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "8c714391fb9fe2df3f572ea4f0fcb4f4bee7bd642896b0da11bd550a5bb7126c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:02.427938+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "6250e0cba7a48b8b7918fd5c1cf855cb803aac27bd2cfb53dd6e6b2408c2f9e4", + "panel_kind": "isotropic", + "panel_seed": 14733645433978310927, + "realization": 8, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ff428e9f906c0709713abb182c6f58b7baa60c1cec7a7efd7882917381215240", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01096823070211098, + "kernel_residual": 2.7366901444231138e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.12929563740694028, + "minus_external_effective_rank": 8.324441114363292, + "minus_external_entropy": 0.9587868166959438, + "minus_target_effective_rank": 38.03407178353216, + "minus_target_entropy": 0.8783937183849132, + "minus_weight": 34.799668751498714, + "orthogonality_relative_error": 9.75610380886945e-16, + "plus_external_effective_rank": 41.042056432263976, + "plus_external_entropy": 0.8661939614242785, + "plus_target_effective_rank": 63.35734424949986, + "plus_target_entropy": 0.9705355661086618, + "plus_weight": 1005.7888177229457, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "71ad1ef8964411dda43f4d47f9d2e1583bc27686be93d021e3fb5909964565c4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:57.221533+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "d80fa250ed1075491bfd53cd2870281608a6cf645e176d8c631b686c2e0e68b0", + "panel_kind": "sparse", + "panel_seed": 195690533124084658, + "realization": 9, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "295f7f9ae3bc5b5f895dbe51b6e68b51c456286787950c0ce89f47f1d9b0971e", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.008315328687328708, + "kernel_residual": 2.8572717849253194e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14038535732907967, + "minus_external_effective_rank": 7.96562205324811, + "minus_external_entropy": 0.9477335261631522, + "minus_target_effective_rank": 29.25352833206403, + "minus_target_entropy": 0.9091801603914024, + "minus_weight": 33.99021019843401, + "orthogonality_relative_error": 1.1859480304930911e-15, + "plus_external_effective_rank": 35.25854313556145, + "plus_external_entropy": 0.8522057355609682, + "plus_target_effective_rank": 53.13007998801135, + "plus_target_entropy": 0.9444455660512098, + "plus_weight": 899.217820585118, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 114, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "dd5ccc14c306968ecc5513f00ea02d8822009112ea9153ff5cf87d8953cb186d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:10.262114+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "d80fa250ed1075491bfd53cd2870281608a6cf645e176d8c631b686c2e0e68b0", + "panel_kind": "isotropic", + "panel_seed": 195690533124084658, + "realization": 9, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a11c89f99e0874ea546a9b906c55d752e43b8cfd809849b9d4fdb13d628b785f", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.008315328687328708, + "kernel_residual": 2.8572717849253194e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1296859954023774, + "minus_external_effective_rank": 8.37533238641564, + "minus_external_entropy": 0.9604668272014654, + "minus_target_effective_rank": 37.85176746972669, + "minus_target_entropy": 0.8785630654545631, + "minus_weight": 34.036538481500024, + "orthogonality_relative_error": 1.226487318102565e-15, + "plus_external_effective_rank": 38.421270923912104, + "plus_external_entropy": 0.8585804730679201, + "plus_target_effective_rank": 60.563884632315464, + "plus_target_entropy": 0.9652978992022261, + "plus_weight": 980.5593172781382, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "c2b94c0b962d68ec3ffe44fe8d5ddf2da7bd28fabd0ac5f75c8cc513b7bc642d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:34.559728+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "f85466694debda87024eaf996d3ab5cc79a844eaa6186247ff16a0fbef1a65d0", + "panel_kind": "sparse", + "panel_seed": 11345595685281178192, + "realization": 10, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8114ae97ab8979147a1c8402f0a30d020f3080b92ff6538012f68c905f3ad9f6", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.014795958260953866, + "kernel_residual": 2.707799639576868e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.145820417978942, + "minus_external_effective_rank": 8.536153633560419, + "minus_external_entropy": 0.9630096951455576, + "minus_target_effective_rank": 32.9153886090081, + "minus_target_entropy": 0.9294337466769667, + "minus_weight": 33.21056816459146, + "orthogonality_relative_error": 6.723216138838614e-16, + "plus_external_effective_rank": 41.867412676480114, + "plus_external_entropy": 0.8715734530767183, + "plus_target_effective_rank": 58.41820901889676, + "plus_target_entropy": 0.9573475450295205, + "plus_weight": 843.2700507358221, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 112, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "2befa7186501e127ed063a3c42eff8b3cd97d1e468c22fa23d7ec59a5817393b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:45.011734+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "f85466694debda87024eaf996d3ab5cc79a844eaa6186247ff16a0fbef1a65d0", + "panel_kind": "isotropic", + "panel_seed": 11345595685281178192, + "realization": 10, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5ced74014683d012cfecbcbf35698ded4ae88a6e93b45bac893b09db27950758", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.014795958260953866, + "kernel_residual": 2.707799639576868e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13832938515923177, + "minus_external_effective_rank": 8.725881074919581, + "minus_external_entropy": 0.9679981424018331, + "minus_target_effective_rank": 39.3447441242281, + "minus_target_entropy": 0.8832521709733049, + "minus_weight": 31.23829074981402, + "orthogonality_relative_error": 6.680126729226871e-16, + "plus_external_effective_rank": 46.50949987008866, + "plus_external_entropy": 0.8838668989090516, + "plus_target_effective_rank": 66.25184165999275, + "plus_target_entropy": 0.9760493995338063, + "plus_weight": 839.6629070278887, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "0cefaf61ceed85662f338552e2e714d55d0a3bc7b68fa789920187812a912e43", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:15.052460+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "8919f588b9ea1ccce7feffe2c0741350ac6b10c3f6041fbd0244b343c6f3cab1", + "panel_kind": "sparse", + "panel_seed": 17607704719213752772, + "realization": 11, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ab4d25c8e818541d46936a97d943b6f994b1b35302092b5f04790796e6796196", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.013725346191549147, + "kernel_residual": 2.7309457313626195e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13749657688793698, + "minus_external_effective_rank": 8.226015583245644, + "minus_external_entropy": 0.9552460846605241, + "minus_target_effective_rank": 31.7626186791986, + "minus_target_entropy": 0.9207686455964001, + "minus_weight": 34.830886821071644, + "orthogonality_relative_error": 7.258155169775967e-16, + "plus_external_effective_rank": 39.997021710818345, + "plus_external_entropy": 0.8631099609267573, + "plus_target_effective_rank": 55.9735924898037, + "plus_target_entropy": 0.9505454096334728, + "plus_weight": 942.3381885887048, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 112, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "c2d63315fbfbc5e95e9a526098e31de3da203f1f2c4dd9e83d4c539c1151caab", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:28.696274+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "8919f588b9ea1ccce7feffe2c0741350ac6b10c3f6041fbd0244b343c6f3cab1", + "panel_kind": "isotropic", + "panel_seed": 17607704719213752772, + "realization": 11, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c01e91cfd5156202a527c33aab76ad47fa6ffd8ed0083df1c8f7cdc79d053282", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.013725346191549147, + "kernel_residual": 2.7309457313626195e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13943227140310735, + "minus_external_effective_rank": 8.534892454995004, + "minus_external_entropy": 0.9633477142459707, + "minus_target_effective_rank": 38.08018550492491, + "minus_target_entropy": 0.8778767060049971, + "minus_weight": 33.76136292312709, + "orthogonality_relative_error": 7.54007684390902e-16, + "plus_external_effective_rank": 46.40268898058964, + "plus_external_entropy": 0.8794464562226313, + "plus_target_effective_rank": 64.39830473863037, + "plus_target_entropy": 0.9724447072148847, + "plus_weight": 899.7484312983355, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "9eeafdffa0e69532743375556c107bf8628502e974081b6db3b5a5232f94accc", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:15.975850+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "9cc13774259ac7b5e6129c1dbfdbf1fcc4912c2d79f0a1d9ca05bbe4e738066d", + "panel_kind": "sparse", + "panel_seed": 15902574427491776222, + "realization": 12, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "396790530d63f880b25a668ee90edcd02c2ff1568daf91ff26bf0cb25670e3f3", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.012648680589379131, + "kernel_residual": 2.7868533893606445e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14243773859992598, + "minus_external_effective_rank": 8.475491028879993, + "minus_external_entropy": 0.9622093214754137, + "minus_target_effective_rank": 34.50482472701075, + "minus_target_entropy": 0.9300585014295933, + "minus_weight": 34.22968709437805, + "orthogonality_relative_error": 9.647916959223347e-16, + "plus_external_effective_rank": 39.00550222730146, + "plus_external_entropy": 0.8624195377416265, + "plus_target_effective_rank": 58.63176086273048, + "plus_target_entropy": 0.9584889327544875, + "plus_weight": 891.4796408205004, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 115, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "85cc5a605f8cd49b93835aa8c3512587f8a325d7e9e7277347b3201d4ab8908a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:30.242320+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "9cc13774259ac7b5e6129c1dbfdbf1fcc4912c2d79f0a1d9ca05bbe4e738066d", + "panel_kind": "isotropic", + "panel_seed": 15902574427491776222, + "realization": 12, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "503fa35e93f9d4e64a33097946c743185c72ed58b4e1dbc4945b6ca2c9bfbba8", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.012648680589379131, + "kernel_residual": 2.7868533893606445e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13540103716761515, + "minus_external_effective_rank": 8.561803338856931, + "minus_external_entropy": 0.9642233942833152, + "minus_target_effective_rank": 38.44277954775181, + "minus_target_entropy": 0.8803827075640869, + "minus_weight": 32.41026232605162, + "orthogonality_relative_error": 9.535684542989956e-16, + "plus_external_effective_rank": 43.18115814814736, + "plus_external_entropy": 0.8743251194057726, + "plus_target_effective_rank": 63.95984108500138, + "plus_target_entropy": 0.9718262086486428, + "plus_weight": 891.4609517644851, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "01df99f19cc2e2443eccbf34ed31dd007d4f163de03b98ff092fac460c673ad4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:11.892811+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "eaa6a4109453eaa993b62d360f7eccf0a02f289070934103574b3f7e880b181c", + "panel_kind": "sparse", + "panel_seed": 18421277561702758607, + "realization": 13, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "722d9972ea7eb12abce76844bf43ae7c1c71183c192c11bb596b0252b51bb097", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.015144669005864773, + "kernel_residual": 2.737124343096396e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14881040044468455, + "minus_external_effective_rank": 8.06723100271687, + "minus_external_entropy": 0.9507958659999324, + "minus_target_effective_rank": 31.753610010400436, + "minus_target_entropy": 0.9221876670886155, + "minus_weight": 36.492067220544506, + "orthogonality_relative_error": 8.293998283032925e-16, + "plus_external_effective_rank": 43.292871695122045, + "plus_external_entropy": 0.8712008838908769, + "plus_target_effective_rank": 57.94915690106988, + "plus_target_entropy": 0.9553004976457103, + "plus_weight": 906.4477444959234, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 112, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "4806cc12798e238365b4b0d7d520369a23600c2e5698ec121f2d9817d7eb63f0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:25.392299+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "eaa6a4109453eaa993b62d360f7eccf0a02f289070934103574b3f7e880b181c", + "panel_kind": "isotropic", + "panel_seed": 18421277561702758607, + "realization": 13, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2a13c3a5e2845677c334b3914c08741bdddbbce717d52b609d9b2229534ae1af", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.015144669005864773, + "kernel_residual": 2.737124343096396e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14398820119655822, + "minus_external_effective_rank": 8.54119979773058, + "minus_external_entropy": 0.9641163332081245, + "minus_target_effective_rank": 38.71401944844383, + "minus_target_entropy": 0.8814528932665813, + "minus_weight": 33.11372856008337, + "orthogonality_relative_error": 8.31762626410365e-16, + "plus_external_effective_rank": 48.226110333428274, + "plus_external_entropy": 0.8864754258282203, + "plus_target_effective_rank": 64.75405890505064, + "plus_target_entropy": 0.9735594070410788, + "plus_weight": 852.38729998041, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "6afc899275ce4756827da38acbfa70f42e887cd0faf20d4252f96dd81f8ea342", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:53.423065+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "9ddc28f3569f75336cd1df02167bdb48dfd628d4f623fb8b455012d8d6512152", + "panel_kind": "sparse", + "panel_seed": 8046982520635381594, + "realization": 14, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cc3248a35c49e1ab00147784aa110afd4444440c6e6400cb0f43e9a09eb7537b", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.016133860780832534, + "kernel_residual": 2.691889202114498e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14739538284700904, + "minus_external_effective_rank": 8.425977626785885, + "minus_external_entropy": 0.9594364207694687, + "minus_target_effective_rank": 31.121633394947597, + "minus_target_entropy": 0.9202513705598339, + "minus_weight": 32.16145869451886, + "orthogonality_relative_error": 5.453045485960372e-16, + "plus_external_effective_rank": 45.368406598197964, + "plus_external_entropy": 0.8831578817648746, + "plus_target_effective_rank": 58.27191081764224, + "plus_target_entropy": 0.955792919102718, + "plus_weight": 807.1898467196087, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 111, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "94a8ac8a3730e87ada9b4dde7954f42b0342f63141dd0d4ab478d7b7f513344b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:07.138646+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "9ddc28f3569f75336cd1df02167bdb48dfd628d4f623fb8b455012d8d6512152", + "panel_kind": "isotropic", + "panel_seed": 8046982520635381594, + "realization": 14, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c5d1e6efc9843b0c856c56aa72e816be198557ee788065c6f5d370cbb481de98", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.016133860780832534, + "kernel_residual": 2.691889202114498e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.15486171479582025, + "minus_external_effective_rank": 8.778953823109601, + "minus_external_entropy": 0.970833066890619, + "minus_target_effective_rank": 39.41676422883862, + "minus_target_entropy": 0.8831424755880694, + "minus_weight": 33.33811664412978, + "orthogonality_relative_error": 5.457905109427737e-16, + "plus_external_effective_rank": 50.505129678639406, + "plus_external_entropy": 0.8934423108246804, + "plus_target_effective_rank": 66.1417496657288, + "plus_target_entropy": 0.9757325227201114, + "plus_weight": 793.0290081579413, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "2780b309ea259901457ea4cc7d398b540beaa8138f8f152125643714b2bd435f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:11.272983+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "2fd686e23255aec854739e95c2f51cad6e18223df5da6faf44dbd789726765d6", + "panel_kind": "sparse", + "panel_seed": 3524047977246257894, + "realization": 15, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c4bc6cd340078ce7035b54e0adb445263b3d469af2f775b2cf07c3e7910f91bf", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.014459935483568012, + "kernel_residual": 2.6502862095232746e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.12780433538045408, + "minus_external_effective_rank": 8.277853067071307, + "minus_external_entropy": 0.9550181030239607, + "minus_target_effective_rank": 30.02240013491325, + "minus_target_entropy": 0.9164849134561291, + "minus_weight": 31.319062466795554, + "orthogonality_relative_error": 6.669643412507028e-16, + "plus_external_effective_rank": 39.36946888393361, + "plus_external_entropy": 0.8606781200763942, + "plus_target_effective_rank": 55.426657070173945, + "plus_target_entropy": 0.9487941004215225, + "plus_weight": 916.5107323360938, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 112, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "0d32f906081fc098a26db75eab87ba0dd27b54c487a81703fe1154278e207a78", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:26.251041+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "2fd686e23255aec854739e95c2f51cad6e18223df5da6faf44dbd789726765d6", + "panel_kind": "isotropic", + "panel_seed": 3524047977246257894, + "realization": 15, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4571580f3e682f1484f5c4277ef9b333f276c25ccc20a930ab3c12efbc1cc92b", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.014459935483568012, + "kernel_residual": 2.6502862095232746e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14015181657040263, + "minus_external_effective_rank": 8.691926224520943, + "minus_external_entropy": 0.9681789938425047, + "minus_target_effective_rank": 39.47357189927359, + "minus_target_entropy": 0.8834653170247518, + "minus_weight": 33.51185810434891, + "orthogonality_relative_error": 6.872762268980468e-16, + "plus_external_effective_rank": 44.79052009462231, + "plus_external_entropy": 0.8778677746418362, + "plus_target_effective_rank": 65.11553480840041, + "plus_target_entropy": 0.9741404107714122, + "plus_weight": 888.1563042828406, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "cb3a3ac3705512a38a3e79e12ab6fd4e53e47276a967c4f05d8f7054de7d397f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:18.095385+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "b433118cf0f2e5949f8aa3b56036b8cbe820796ead45ced72d581cc5d6917569", + "panel_kind": "sparse", + "panel_seed": 9630672285941381350, + "realization": 16, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "94cb0ce09065d0fdd9867fe6287aa7b3d2bc53240ff0188a6ce5a5ef3a6b2daa", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.011700223347772333, + "kernel_residual": 2.6607512393909914e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1498833499582592, + "minus_external_effective_rank": 8.451864260263644, + "minus_external_entropy": 0.9624388895541385, + "minus_target_effective_rank": 32.827003493908805, + "minus_target_entropy": 0.9257557890910849, + "minus_weight": 33.748726424897725, + "orthogonality_relative_error": 8.333915415218524e-16, + "plus_external_effective_rank": 42.26808116852616, + "plus_external_entropy": 0.8688635510466813, + "plus_target_effective_rank": 57.51183606512498, + "plus_target_entropy": 0.956092221231771, + "plus_weight": 831.7997118663893, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 117, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "e1b0f64ff272df8f543039b99a0234b06b7b4b3352cd0e84e43c72b346f25cf4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:33.582801+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "b433118cf0f2e5949f8aa3b56036b8cbe820796ead45ced72d581cc5d6917569", + "panel_kind": "isotropic", + "panel_seed": 9630672285941381350, + "realization": 16, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f3734047f2d622efa60fef047000d063a4695e9cd2db14f6743e3c72c2d8d524", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.011700223347772333, + "kernel_residual": 2.6607512393909914e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13526181026823086, + "minus_external_effective_rank": 8.482480300012321, + "minus_external_entropy": 0.9634466355410091, + "minus_target_effective_rank": 39.050926954206794, + "minus_target_entropy": 0.8812891917424435, + "minus_weight": 32.72847786928857, + "orthogonality_relative_error": 8.710983551364804e-16, + "plus_external_effective_rank": 39.004784786819286, + "plus_external_entropy": 0.8646094402096376, + "plus_target_effective_rank": 62.18310690335782, + "plus_target_entropy": 0.9685986490235485, + "plus_weight": 901.2101530414803, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "8dc928ce66c7ee6ba274dd327b441daa8ae8d980197a18d1e645252afb69b96e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:22.742329+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "75e3b6329292a07255f60e96dabb98f6254b929e2304592064d78a251799a1f7", + "panel_kind": "sparse", + "panel_seed": 4009787932271038748, + "realization": 17, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "399e211bcc6a103a5f7d7d3c238a9b1527221c356a6d8eec9edfb8aef7282484", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.012249778463768372, + "kernel_residual": 2.6974048286187447e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.147891271665415, + "minus_external_effective_rank": 7.882807029899311, + "minus_external_entropy": 0.9446076116620808, + "minus_target_effective_rank": 31.932125555642727, + "minus_target_entropy": 0.9245961683582623, + "minus_weight": 33.87684720673728, + "orthogonality_relative_error": 7.536855000157494e-16, + "plus_external_effective_rank": 39.03943678162971, + "plus_external_entropy": 0.8683086980370689, + "plus_target_effective_rank": 53.38622993007423, + "plus_target_entropy": 0.941434126020926, + "plus_weight": 847.155204967618, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 106, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "44b0449555e93360183f13fc639f60041c760d0b661af762f032ff9e93e49126", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:35.756715+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "75e3b6329292a07255f60e96dabb98f6254b929e2304592064d78a251799a1f7", + "panel_kind": "isotropic", + "panel_seed": 4009787932271038748, + "realization": 17, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "262f2d84c0ae36637c21862f435543e109b1f390bbf0e143c9f554af467477ee", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.012249778463768372, + "kernel_residual": 2.6974048286187447e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14069555881459483, + "minus_external_effective_rank": 8.464934036306081, + "minus_external_entropy": 0.9633359849038, + "minus_target_effective_rank": 38.5381327800446, + "minus_target_entropy": 0.8809078076511724, + "minus_weight": 33.09114887905905, + "orthogonality_relative_error": 8.095800337816471e-16, + "plus_external_effective_rank": 41.44051594377686, + "plus_external_entropy": 0.8725254049214295, + "plus_target_effective_rank": 62.93465071656587, + "plus_target_entropy": 0.9700160490412931, + "plus_weight": 873.3511878324556, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "8a96de4b083a473f73be0a526ad00dc2199c05550b06499ccef03b008d173ba4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:50:55.332630+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "b5ca31f7bb1632ba758d6be799d4786eaa58a379269b5499658cc3a7eb8d1b4f", + "panel_kind": "sparse", + "panel_seed": 1738975000186071782, + "realization": 18, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "80ab282dc9ba6cf5b7758f3ebc57e14e8dabf592a7c943ab2345263733477929", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01351557681017, + "kernel_residual": 2.5930125216912975e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13239540620770646, + "minus_external_effective_rank": 8.342132284004556, + "minus_external_entropy": 0.9581036693026254, + "minus_target_effective_rank": 33.351687104383714, + "minus_target_entropy": 0.9239584853712223, + "minus_weight": 34.873924118678254, + "orthogonality_relative_error": 6.88317838647943e-16, + "plus_external_effective_rank": 39.764755315062295, + "plus_external_entropy": 0.8580413233224129, + "plus_target_effective_rank": 59.30402110331417, + "plus_target_entropy": 0.9598204846654186, + "plus_weight": 982.6439107745238, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 117, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "f2c9033f08e5cf6360895a9795f04d4bfe1942055560c5bd93938f74ca43b06e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:04.856773+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "b5ca31f7bb1632ba758d6be799d4786eaa58a379269b5499658cc3a7eb8d1b4f", + "panel_kind": "isotropic", + "panel_seed": 1738975000186071782, + "realization": 18, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b8e608e00283b83b4b45255197af0d05fefbba824c0f766b5d6e6dff707b0aff", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01351557681017, + "kernel_residual": 2.5930125216912975e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1402790382247504, + "minus_external_effective_rank": 8.659305994525116, + "minus_external_entropy": 0.9671323185685825, + "minus_target_effective_rank": 38.90227933040716, + "minus_target_entropy": 0.8822528161211644, + "minus_weight": 35.39490093961671, + "orthogonality_relative_error": 6.868724588910118e-16, + "plus_external_effective_rank": 44.2208425553187, + "plus_external_entropy": 0.873349535692193, + "plus_target_effective_rank": 64.35747029907944, + "plus_target_entropy": 0.9725214214079884, + "plus_weight": 937.1446474143589, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "e24d96c16e6722930ea66edbca49dd761a44fd3804eb93731c1db64eb8b437f6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:42.176134+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "a1fba42e17ac6d5a12afb693ca68ef1ac39a6ab16a2c902f2588b77cde96255b", + "panel_kind": "sparse", + "panel_seed": 8996993957569642443, + "realization": 19, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5f16f61220b946d283b60e47880fcbee640f9a1356404291b1fd84af3a5b0452", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01480205795899762, + "kernel_residual": 2.6688602358893717e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14395862414051894, + "minus_external_effective_rank": 7.793353760516181, + "minus_external_entropy": 0.9449849526219727, + "minus_target_effective_rank": 31.43822200713778, + "minus_target_entropy": 0.9185517477665027, + "minus_weight": 34.88406712559059, + "orthogonality_relative_error": 6.270893871485021e-16, + "plus_external_effective_rank": 40.96955867561264, + "plus_external_entropy": 0.8670676959535376, + "plus_target_effective_rank": 55.037019711477704, + "plus_target_entropy": 0.9479378348660238, + "plus_weight": 898.1573529508544, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 112, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "1d8cff76fd19657c7e39a37b449c5f69e30e99ae59e319ad8d3cd7dec2146260", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:54.939405+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "a1fba42e17ac6d5a12afb693ca68ef1ac39a6ab16a2c902f2588b77cde96255b", + "panel_kind": "isotropic", + "panel_seed": 8996993957569642443, + "realization": 19, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6d77d22a56adaccdd9a696b3bd7f7454988429264efec5678eb484faedf8ba12", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01480205795899762, + "kernel_residual": 2.6688602358893717e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14225007782184793, + "minus_external_effective_rank": 8.46152032925738, + "minus_external_entropy": 0.9625723119729824, + "minus_target_effective_rank": 38.31776659483787, + "minus_target_entropy": 0.880590388598727, + "minus_weight": 34.109443474963975, + "orthogonality_relative_error": 6.291880696302085e-16, + "plus_external_effective_rank": 46.0091670977258, + "plus_external_entropy": 0.8796137068956542, + "plus_target_effective_rank": 64.79517376361353, + "plus_target_entropy": 0.9732036154881323, + "plus_weight": 889.6135341457141, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "fcc04dd65e36cefeb41351b982df3b1c1fa0229f62e5b5f1f296bc6eb4cfb305", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:44.976341+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "67f2c7de5dda412cab9db4ffe4e1c1fc53407db20e8b20cb685bb60123b960d1", + "panel_kind": "sparse", + "panel_seed": 5078029223208891414, + "realization": 20, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "44e4e38e13cc2afa217b14a95c8d1a4266248f7fc86ff81c90ba62a2e3e28842", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.015168453332531733, + "kernel_residual": 2.641483137124713e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.147806317943784, + "minus_external_effective_rank": 8.44549129364641, + "minus_external_entropy": 0.9598834991984564, + "minus_target_effective_rank": 30.52131363624378, + "minus_target_entropy": 0.9181974463811685, + "minus_weight": 33.37349521508053, + "orthogonality_relative_error": 6.344976031925357e-16, + "plus_external_effective_rank": 39.35549903644199, + "plus_external_entropy": 0.8684973815851996, + "plus_target_effective_rank": 51.96666281265202, + "plus_target_entropy": 0.9384425734632382, + "plus_weight": 835.0875686714957, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 107, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "1fa4b51e70b60d2ae10da675eecf69f4b042a783f49e840dbefdcfa3def61528", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:58.672067+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "67f2c7de5dda412cab9db4ffe4e1c1fc53407db20e8b20cb685bb60123b960d1", + "panel_kind": "isotropic", + "panel_seed": 5078029223208891414, + "realization": 20, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3db2539133d6271a49ef4482d4b85f0b3a183a6a76eb29c79fe81900447b365b", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.015168453332531733, + "kernel_residual": 2.641483137124713e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.15217173756627383, + "minus_external_effective_rank": 8.810939125466113, + "minus_external_entropy": 0.9716026306796948, + "minus_target_effective_rank": 39.51682244439143, + "minus_target_entropy": 0.8838051637590716, + "minus_weight": 32.93629926804126, + "orthogonality_relative_error": 5.880169645065483e-16, + "plus_external_effective_rank": 49.781670967289784, + "plus_external_entropy": 0.8914593661818785, + "plus_target_effective_rank": 65.89303949551173, + "plus_target_entropy": 0.9753902118994211, + "plus_weight": 798.5354439078457, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "6663dbb2e9bd124a9100b79d14e631d9b35f8d6b67234b470bba59484ff6d407", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:38.935023+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "b2e5875b710262b1adc498f74b1caa5e31257f0c57eb1e1dd43a77fbe1460632", + "panel_kind": "sparse", + "panel_seed": 15175832279995395043, + "realization": 21, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "dc20b33601a1265751c9a96e52b8c4faf14146b825d9229f9f448a9d255dc5e4", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007438915085233553, + "kernel_residual": 2.6655385086373716e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1389136702845401, + "minus_external_effective_rank": 8.092358809449316, + "minus_external_entropy": 0.9505925556553434, + "minus_target_effective_rank": 31.08363147856114, + "minus_target_entropy": 0.9216493684411663, + "minus_weight": 33.95434855517807, + "orthogonality_relative_error": 1.0618628466186711e-15, + "plus_external_effective_rank": 37.96601571192172, + "plus_external_entropy": 0.8601542865230609, + "plus_target_effective_rank": 52.20132339407689, + "plus_target_entropy": 0.942400753048752, + "plus_weight": 908.5331260529116, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 111, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "1004c70b6936c9bc689501c3a4bbd7b09e79708f9a3fa1e2f3550424529b1d21", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:52.277240+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "b2e5875b710262b1adc498f74b1caa5e31257f0c57eb1e1dd43a77fbe1460632", + "panel_kind": "isotropic", + "panel_seed": 15175832279995395043, + "realization": 21, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "91dc90843ecdd3ab401d94d2e9302254a6ec10ebcde8795360f7dc8c1c271b6c", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007438915085233553, + "kernel_residual": 2.6655385086373716e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.12569712737017502, + "minus_external_effective_rank": 8.410491763145888, + "minus_external_entropy": 0.9603080480842738, + "minus_target_effective_rank": 37.717265981323365, + "minus_target_entropy": 0.8764316026021574, + "minus_weight": 33.5439624083173, + "orthogonality_relative_error": 1.0531365617138141e-15, + "plus_external_effective_rank": 38.92506354671652, + "plus_external_entropy": 0.8607090935306478, + "plus_target_effective_rank": 61.79083554389716, + "plus_target_entropy": 0.9679216241145928, + "plus_weight": 999.2396096935769, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "991a2956c61323aaecf11b5270a53706708c94cc2b60e5649b5458ced32a5a9d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:22.812571+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "bad661d80ffdfa016fc825040f26c41ecb4b7bcb4a611b74fb61bbb1f4b3eda0", + "panel_kind": "sparse", + "panel_seed": 1460822151629638284, + "realization": 22, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3036874f3c77047c05516bb0d0295090e2b538191d3c5d17d8691ae5b2f7f32c", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.010580068502493043, + "kernel_residual": 2.6929649154262107e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.12970675127375736, + "minus_external_effective_rank": 7.4436768821066455, + "minus_external_entropy": 0.932317249183239, + "minus_target_effective_rank": 29.504401005239636, + "minus_target_entropy": 0.907596835431191, + "minus_weight": 33.52929714895874, + "orthogonality_relative_error": 8.835380876036801e-16, + "plus_external_effective_rank": 38.28409603348746, + "plus_external_entropy": 0.8532209202736215, + "plus_target_effective_rank": 54.716707016783374, + "plus_target_entropy": 0.9494773811971973, + "plus_weight": 965.7805026877211, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 116, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "3aa24b564208fb902feb2a7adc9a8de7ba0bfe4f7815803ee7f3b9c6f2c3b352", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:37.000298+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "bad661d80ffdfa016fc825040f26c41ecb4b7bcb4a611b74fb61bbb1f4b3eda0", + "panel_kind": "isotropic", + "panel_seed": 1460822151629638284, + "realization": 22, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a03e41217303c8beff75fda51a2e2735424a04266a039f990b8ab211fa049ca8", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.010580068502493043, + "kernel_residual": 2.6929649154262107e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1394934579552034, + "minus_external_effective_rank": 8.123618064402073, + "minus_external_entropy": 0.9538928533256531, + "minus_target_effective_rank": 38.08581321795695, + "minus_target_entropy": 0.879234673336752, + "minus_weight": 32.47417048046111, + "orthogonality_relative_error": 9.305860412741917e-16, + "plus_external_effective_rank": 43.52867701291598, + "plus_external_entropy": 0.8753759616082648, + "plus_target_effective_rank": 63.13345867357881, + "plus_target_entropy": 0.9699285936130252, + "plus_weight": 865.0352308276158, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "1b7a2d93c1d18df386ff35d8df1160ee7b0745239ee4c5bd3ac2b4f3701d8e8d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:43.356803+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "f51bff1a6fa257a1b7e0b44ba6f48f345f527869189294bd37893c0779759573", + "panel_kind": "sparse", + "panel_seed": 456199164509452094, + "realization": 23, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "15094609a6efef5fb68a8b7164b30a4b888133bea55dcf6bff1b4a68b31d224f", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01325599950621371, + "kernel_residual": 2.7451891375394084e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1217462628562345, + "minus_external_effective_rank": 7.886130760674971, + "minus_external_entropy": 0.9447539264121932, + "minus_target_effective_rank": 32.153707199008984, + "minus_target_entropy": 0.9194213525273558, + "minus_weight": 31.3313637850868, + "orthogonality_relative_error": 8.397636125860526e-16, + "plus_external_effective_rank": 40.054200242835016, + "plus_external_entropy": 0.8587717092493296, + "plus_target_effective_rank": 57.56806564966978, + "plus_target_entropy": 0.9561153036217227, + "plus_weight": 965.7195576278237, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 116, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "d1991129f4fee60e95ef31da747ffda0e193bbcc95f69ad4bc7ff39751c57223", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:58.057315+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "f51bff1a6fa257a1b7e0b44ba6f48f345f527869189294bd37893c0779759573", + "panel_kind": "isotropic", + "panel_seed": 456199164509452094, + "realization": 23, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bdd3017791a96a41629da1f1d96b67fae38f82b517ca30f4d003925685cda134", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01325599950621371, + "kernel_residual": 2.7451891375394084e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1433826720758539, + "minus_external_effective_rank": 8.580770456713323, + "minus_external_entropy": 0.9659727869716463, + "minus_target_effective_rank": 38.35744019921994, + "minus_target_entropy": 0.8795393893526494, + "minus_weight": 33.629833901293026, + "orthogonality_relative_error": 8.253786159430311e-16, + "plus_external_effective_rank": 45.53597199160481, + "plus_external_entropy": 0.8789247476857055, + "plus_target_effective_rank": 65.10494074893018, + "plus_target_entropy": 0.9738066920855655, + "plus_weight": 869.6238566412906, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "0c4ed94bd54f6b02c34869da0b9255c91b72e4e7addcea275d3b11fcb99dcfb0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:48.762361+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "1be61f208aa4e2622c2329410bb9f52c370863992a726d31105a43ee16b95417", + "panel_kind": "sparse", + "panel_seed": 12813672015724181733, + "realization": 24, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cfa23e5e4ca938616f15b0d55762e128ac09aa9c44c9fc193f9ed4547bc5a2bb", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.02093819524528032, + "kernel_residual": 2.686353496689181e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1372856863482498, + "minus_external_effective_rank": 7.965437228017074, + "minus_external_entropy": 0.9458747110729708, + "minus_target_effective_rank": 29.47652366621111, + "minus_target_entropy": 0.9150332897964637, + "minus_weight": 32.918389184990865, + "orthogonality_relative_error": 4.685169525089449e-16, + "plus_external_effective_rank": 39.11186487964434, + "plus_external_entropy": 0.8571636016415337, + "plus_target_effective_rank": 52.57419115050085, + "plus_target_entropy": 0.9419307222380442, + "plus_weight": 892.0692907570666, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 114, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "b9145e4dca9a98b8dc1449cc3cca52dbf51be970cb0e368d40c01017efbcfb68", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:55:04.624214+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "1be61f208aa4e2622c2329410bb9f52c370863992a726d31105a43ee16b95417", + "panel_kind": "isotropic", + "panel_seed": 12813672015724181733, + "realization": 24, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "29a4a55500f4cbbb0a071e356d330fe6470537ed900ec782a90e9f0a9e9da644", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.02093819524528032, + "kernel_residual": 2.686353496689181e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.15191114497147057, + "minus_external_effective_rank": 8.912566446462822, + "minus_external_entropy": 0.9737501763666976, + "minus_target_effective_rank": 39.2880385105121, + "minus_target_entropy": 0.8829782847572636, + "minus_weight": 31.537498051715676, + "orthogonality_relative_error": 4.476325954483098e-16, + "plus_external_effective_rank": 51.51190464642623, + "plus_external_entropy": 0.8968458953001456, + "plus_target_effective_rank": 67.65778316183382, + "plus_target_entropy": 0.9785538591866139, + "plus_weight": 766.0462306070784, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "be1cde91e11f8bc6a94ecbbe4f9ed17e0084afdfd5bfbb964ab163caf4c5c0f2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:49.537264+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "1c4383280cfb9e5cef97be5a93de521f4ccb46ba705901787939b142cd7a986b", + "panel_kind": "sparse", + "panel_seed": 9318691172415911830, + "realization": 25, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9b0c42f85a8b0508642181d1d5c99c303bee14d5e7564dfe16bb899a9784fad1", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.011373210677038934, + "kernel_residual": 2.711427284507533e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1457590306206704, + "minus_external_effective_rank": 8.045918176573718, + "minus_external_entropy": 0.9479760792101977, + "minus_target_effective_rank": 30.3225683930061, + "minus_target_entropy": 0.9166880856628938, + "minus_weight": 33.163509756137465, + "orthogonality_relative_error": 9.927426178529162e-16, + "plus_external_effective_rank": 38.403846512502746, + "plus_external_entropy": 0.8623738793961352, + "plus_target_effective_rank": 54.08983062133204, + "plus_target_entropy": 0.9449772427104515, + "plus_weight": 842.4588860311359, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 109, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "e687d71735fda46a8e37acf6c8ebcbaf8c113ba6df374f13f640197149c781ec", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:02.500920+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "1c4383280cfb9e5cef97be5a93de521f4ccb46ba705901787939b142cd7a986b", + "panel_kind": "isotropic", + "panel_seed": 9318691172415911830, + "realization": 25, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "55ac1b5572170e440a8ae0ec2da8a5cf316f8044211d6753898b5413740e0d1f", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.011373210677038934, + "kernel_residual": 2.711427284507533e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.139147336622127, + "minus_external_effective_rank": 8.539720741073618, + "minus_external_entropy": 0.9640794082530868, + "minus_target_effective_rank": 39.37413861404886, + "minus_target_entropy": 0.8833864224577662, + "minus_weight": 32.607206765857555, + "orthogonality_relative_error": 9.339777199382334e-16, + "plus_external_effective_rank": 44.61624661283325, + "plus_external_entropy": 0.8781617713000293, + "plus_target_effective_rank": 64.50314086095953, + "plus_target_entropy": 0.9728020810800664, + "plus_weight": 870.9080815674452, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "89496b8fed7eba266b70dd7bd8bde2937e387fc107f5246e615a7c6a86fabeb4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:14.819685+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "72a46c0522ee3fe18117c60604e78f9f05abbe61fd115ff21ce78daeedde5ce9", + "panel_kind": "sparse", + "panel_seed": 8929051067749740094, + "realization": 26, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "64e5999ed227d6b75a5d5707f41dcc3ab8a619ecf6147bddd260755144c2beef", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.012402545132885027, + "kernel_residual": 2.790062846024736e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.16111169830838198, + "minus_external_effective_rank": 8.617571537063677, + "minus_external_entropy": 0.9650169401709764, + "minus_target_effective_rank": 33.657073155927996, + "minus_target_entropy": 0.9297560901822991, + "minus_weight": 35.67943682599917, + "orthogonality_relative_error": 7.611352974386518e-16, + "plus_external_effective_rank": 40.37292162734268, + "plus_external_entropy": 0.8611755841111414, + "plus_target_effective_rank": 52.631769407216886, + "plus_target_entropy": 0.944764566160496, + "plus_weight": 812.9061776933019, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 116, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "d7fbd98a275225f06aa4ed0ac9f4918b6ed516cc576824ed75f55f7dcdccd949", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:24.552174+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "72a46c0522ee3fe18117c60604e78f9f05abbe61fd115ff21ce78daeedde5ce9", + "panel_kind": "isotropic", + "panel_seed": 8929051067749740094, + "realization": 26, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1fcce28fe9d2f76bb3a224ca6a9c5f9b9d3b542116f95c8f41eb5c6a849b97cd", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.012402545132885027, + "kernel_residual": 2.790062846024736e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14082279247014862, + "minus_external_effective_rank": 8.671724889365395, + "minus_external_entropy": 0.966912373880166, + "minus_target_effective_rank": 39.27004290991271, + "minus_target_entropy": 0.8831782041374902, + "minus_weight": 33.70081658929733, + "orthogonality_relative_error": 7.88234227652263e-16, + "plus_external_effective_rank": 42.82299097230063, + "plus_external_entropy": 0.8736155549868128, + "plus_target_effective_rank": 64.5182913272203, + "plus_target_entropy": 0.9728804631450608, + "plus_weight": 888.5748054316781, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "fe6a9ee190d4d83bbf5231838efdbc83786b03fe1e5b8302577744c0080425aa", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:08.657075+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "ab264008bd87f685966da3294757b0334fc293b61dbbaa24f4ec8b88af2bb6df", + "panel_kind": "sparse", + "panel_seed": 16218434247088458926, + "realization": 27, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "adbf946e3b0b7ef165f92d129533dab4b794d7773c95d642b0f1ae97a8ed92d6", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.00753141116444504, + "kernel_residual": 2.6360674766768125e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1264574761490893, + "minus_external_effective_rank": 7.773366883390118, + "minus_external_entropy": 0.940209609204529, + "minus_target_effective_rank": 29.358505254388362, + "minus_target_entropy": 0.9128578894873554, + "minus_weight": 32.974846599102705, + "orthogonality_relative_error": 1.245406798500275e-15, + "plus_external_effective_rank": 32.87678256659438, + "plus_external_entropy": 0.8447573351251497, + "plus_target_effective_rank": 49.316333899576634, + "plus_target_entropy": 0.933934073834226, + "plus_weight": 975.9697131935559, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 109, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "c4c02d8783c63b37827dff0ecc146c813cc3f5c9273abeca3cfc66cad31919bd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:38.184777+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "ab264008bd87f685966da3294757b0334fc293b61dbbaa24f4ec8b88af2bb6df", + "panel_kind": "isotropic", + "panel_seed": 16218434247088458926, + "realization": 27, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "51116c98e66cd308561d29ae6137a2732773f81bc8e165a401046d0291b7b941", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.00753141116444504, + "kernel_residual": 2.6360674766768125e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13143079887125628, + "minus_external_effective_rank": 8.60529598763188, + "minus_external_entropy": 0.9651271059464059, + "minus_target_effective_rank": 38.74797757230526, + "minus_target_entropy": 0.8805315839090289, + "minus_weight": 34.41053849780522, + "orthogonality_relative_error": 1.4286151550861148e-15, + "plus_external_effective_rank": 36.60238327518233, + "plus_external_entropy": 0.857464066336534, + "plus_target_effective_rank": 59.891542273458505, + "plus_target_entropy": 0.9643286171679404, + "plus_weight": 977.2267537242031, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "fa46cfcb36f901512f07fef7c3c6ab25d78893198dfcbdcc0bc9b4d063b3ca04", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:12.588051+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "03abfbce64cd6cc11b04a8d37d02529e266434c97a2d2da3d5149710b9934679", + "panel_kind": "sparse", + "panel_seed": 12934451924257272809, + "realization": 28, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b27d22b2f214610f5ead001f6af664b7b547426eb73ece99f2fbe648dafa1a77", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01184659822733009, + "kernel_residual": 2.7580028681596693e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.12273227568598818, + "minus_external_effective_rank": 8.304966186913237, + "minus_external_entropy": 0.9575177490585197, + "minus_target_effective_rank": 32.42299743569828, + "minus_target_entropy": 0.9228761834617805, + "minus_weight": 31.70852889718247, + "orthogonality_relative_error": 6.460654403131569e-16, + "plus_external_effective_rank": 39.077470436542136, + "plus_external_entropy": 0.8570532360605927, + "plus_target_effective_rank": 59.40464938669659, + "plus_target_entropy": 0.9609815038158477, + "plus_weight": 968.9663466829269, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 118, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "dd1f91ef484f586a388309ac75ce0823375b8639838f7026790f9ac1153ed739", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:29.832744+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "03abfbce64cd6cc11b04a8d37d02529e266434c97a2d2da3d5149710b9934679", + "panel_kind": "isotropic", + "panel_seed": 12934451924257272809, + "realization": 28, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "68343996545ac4f24267ee01832cc98066c08e1e597c5d8d285b606c03940ba3", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01184659822733009, + "kernel_residual": 2.7580028681596693e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13622493427244256, + "minus_external_effective_rank": 8.455737859574807, + "minus_external_entropy": 0.9612879448771193, + "minus_target_effective_rank": 38.60246380293453, + "minus_target_entropy": 0.8804439336871688, + "minus_weight": 33.19393169308712, + "orthogonality_relative_error": 6.164688057764815e-16, + "plus_external_effective_rank": 44.20857489279856, + "plus_external_entropy": 0.8762359937603479, + "plus_target_effective_rank": 63.90192267299355, + "plus_target_entropy": 0.9718302979940898, + "plus_weight": 907.077483018513, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "0e200cf327552f3eb7be511b1559aac0dec6ba1d842a1df50b51b837e987de27", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:06.869305+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "266c6f57a615d61945b03c406bee82ebbcb0fe036515c9d771a5536c5b0e3d91", + "panel_kind": "sparse", + "panel_seed": 17000744414924562224, + "realization": 29, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "550754fa710eb3ebf5cc7b40bdfad000f2babf20a707fa6534a59c6606bd8713", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.012989338139528976, + "kernel_residual": 2.7944685603426067e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14168315443226762, + "minus_external_effective_rank": 8.242196814488636, + "minus_external_entropy": 0.9525521106266923, + "minus_target_effective_rank": 31.791712975605417, + "minus_target_entropy": 0.9167594597501896, + "minus_weight": 32.91844005920413, + "orthogonality_relative_error": 6.650253818279255e-16, + "plus_external_effective_rank": 44.15501380342307, + "plus_external_entropy": 0.878570712539527, + "plus_target_effective_rank": 55.01874501152396, + "plus_target_entropy": 0.9470206650130183, + "plus_weight": 862.2600698423532, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 111, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "793b4d9c3a6b83c0fc1ccfb4d0f522cc34784c433b624768ed245980c476d9af", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:21.995512+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "266c6f57a615d61945b03c406bee82ebbcb0fe036515c9d771a5536c5b0e3d91", + "panel_kind": "isotropic", + "panel_seed": 17000744414924562224, + "realization": 29, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bf3aae1c7f77c07e726a4710278bbc4e7191d17b5285e3320c77ac7db0ee2b41", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.012989338139528976, + "kernel_residual": 2.7944685603426067e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13727191916332596, + "minus_external_effective_rank": 8.416135020911025, + "minus_external_entropy": 0.959959614269091, + "minus_target_effective_rank": 38.787134004511955, + "minus_target_entropy": 0.8804150660054655, + "minus_weight": 33.93534824387426, + "orthogonality_relative_error": 7.026725273281798e-16, + "plus_external_effective_rank": 45.58045157576364, + "plus_external_entropy": 0.878292605272083, + "plus_target_effective_rank": 65.00486823510947, + "plus_target_entropy": 0.9736591946027238, + "plus_weight": 919.7275909325552, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "7ac138c90bf985a04e750be6398948076419aa5595f2f3a2faafbd1dbc4ccc26", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:52.540485+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "6a6f39265752ffa4ad64f5e3e84732df69014afa6470a208b97abf78fcfa5d64", + "panel_kind": "sparse", + "panel_seed": 8673924366167569603, + "realization": 30, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "49cd853e4647786ffe0c87e6a8144ee5e90cc1e66caba7ff2bd8da80249fe96b", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.012850541626473127, + "kernel_residual": 2.6810051522924407e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.173805063877361, + "minus_external_effective_rank": 8.869004993741209, + "minus_external_entropy": 0.972974368262312, + "minus_target_effective_rank": 33.40287518525614, + "minus_target_entropy": 0.9274444330297176, + "minus_weight": 35.567946997790045, + "orthogonality_relative_error": 6.587343340111529e-16, + "plus_external_effective_rank": 42.599534471327864, + "plus_external_entropy": 0.8805365080950011, + "plus_target_effective_rank": 54.324222843820046, + "plus_target_entropy": 0.9446781771575967, + "plus_weight": 745.7387132152812, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 108, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "c0008ee49f932541af7c3f3776138bf74809096078f91d8c1b320bfb9843882c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:07.419534+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "6a6f39265752ffa4ad64f5e3e84732df69014afa6470a208b97abf78fcfa5d64", + "panel_kind": "isotropic", + "panel_seed": 8673924366167569603, + "realization": 30, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0a132b0b8fddc4b44deb5158c3f0b1ed5acfa60c6c092e077ab0440b3481196f", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.012850541626473127, + "kernel_residual": 2.6810051522924407e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13513103555581626, + "minus_external_effective_rank": 8.670373273136741, + "minus_external_entropy": 0.9667685615726707, + "minus_target_effective_rank": 39.30554416687272, + "minus_target_entropy": 0.8835090918588577, + "minus_weight": 32.080656130955425, + "orthogonality_relative_error": 7.096040908673011e-16, + "plus_external_effective_rank": 42.88396111215722, + "plus_external_entropy": 0.8751478401787037, + "plus_target_effective_rank": 65.73093143551999, + "plus_target_entropy": 0.9751443863512571, + "plus_weight": 884.2910830837666, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "d3c23050ab7626cc4909d135dabba17777408d6196b12201c0d35a3a246415fd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:13.878073+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "bb0e0c076ae4b35bed1f0b4f6838a6f5bff3dfb1b08e2067187d8b1e5d0df940", + "panel_kind": "sparse", + "panel_seed": 3041943740552649467, + "realization": 31, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "75009bcb66040e32957212ed20eeb1223b4874d12eac6bd6933bf921e283e179", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.008821852822357484, + "kernel_residual": 2.738302771096424e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14324940764783803, + "minus_external_effective_rank": 7.595425624971443, + "minus_external_entropy": 0.9366215258302181, + "minus_target_effective_rank": 27.323142394336674, + "minus_target_entropy": 0.9081811875695508, + "minus_weight": 33.72630347146576, + "orthogonality_relative_error": 8.6167221631928e-16, + "plus_external_effective_rank": 37.40299132011035, + "plus_external_entropy": 0.8609505687555598, + "plus_target_effective_rank": 50.83021917342031, + "plus_target_entropy": 0.934620346572878, + "plus_weight": 872.9950371914541, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 105, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "841ea05caf6350573b728cbd0b1d47235ee685fa18f95844671f4177d09e55ea", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:30.719632+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "bb0e0c076ae4b35bed1f0b4f6838a6f5bff3dfb1b08e2067187d8b1e5d0df940", + "panel_kind": "isotropic", + "panel_seed": 3041943740552649467, + "realization": 31, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5ff6164f59203c0c22a70497dbacbc7c82b0000161b2135446649a951ec77f22", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.008821852822357484, + "kernel_residual": 2.738302771096424e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13556399992103652, + "minus_external_effective_rank": 8.412142013026006, + "minus_external_entropy": 0.9615135627192642, + "minus_target_effective_rank": 37.96861134426058, + "minus_target_entropy": 0.8789621952550783, + "minus_weight": 34.13065325889983, + "orthogonality_relative_error": 8.864378676057962e-16, + "plus_external_effective_rank": 42.2320249595673, + "plus_external_entropy": 0.8708521705295903, + "plus_target_effective_rank": 61.989749199601704, + "plus_target_entropy": 0.9680841755596828, + "plus_weight": 937.5675169595488, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "fe167836f06bcc7480e02a8b9f9f0a5ff9c2d5aa1ebf840426110ee117ef46b3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:55:18.292659+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "648f9ea22174af2f376776b2580902fc3c96ec9174dfd588c2bbe769f6145c4c", + "panel_kind": "sparse", + "panel_seed": 6472229691808117606, + "realization": 32, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e6ceed2aadc42bbf7725e96226285d47d28e6211ce79da053d4042eed57377c2", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007900250573739312, + "kernel_residual": 2.726129634685488e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.10102432642969592, + "minus_external_effective_rank": 7.414364930303553, + "minus_external_entropy": 0.9323986520777322, + "minus_target_effective_rank": 32.114700405213405, + "minus_target_entropy": 0.9164944167217635, + "minus_weight": 33.699163347561026, + "orthogonality_relative_error": 1.1920224731999117e-15, + "plus_external_effective_rank": 32.712571724838014, + "plus_external_entropy": 0.8338680185006196, + "plus_target_effective_rank": 57.068168369023006, + "plus_target_entropy": 0.954674698173108, + "plus_weight": 1266.0036079269883, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 112, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "43f8f53601cacc1d6b2fb8b3597273ca6413d513238913adce6d50bfae093b62", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:55:32.748782+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "648f9ea22174af2f376776b2580902fc3c96ec9174dfd588c2bbe769f6145c4c", + "panel_kind": "isotropic", + "panel_seed": 6472229691808117606, + "realization": 32, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d88e02de0039103b5665bf05f8dcb66ee7a713eb7f608eabe992d7128e3a9701", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007900250573739312, + "kernel_residual": 2.726129634685488e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.12901358081763717, + "minus_external_effective_rank": 8.355826532650218, + "minus_external_entropy": 0.9600318439791368, + "minus_target_effective_rank": 38.36623980529603, + "minus_target_entropy": 0.8799306640771087, + "minus_weight": 35.51312452360098, + "orthogonality_relative_error": 1.147522843275966e-15, + "plus_external_effective_rank": 38.48647093930956, + "plus_external_entropy": 0.855385763176651, + "plus_target_effective_rank": 60.94602537229297, + "plus_target_entropy": 0.9654678101769321, + "plus_weight": 1028.8141291234117, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "eb96450f0f2d4b749bdd8d44e36669e3016c93b07c04396e1280947616ca0279", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:16.184452+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "6e95e5a9ab7cb29d80c3d3ab0afe2a7b1c50363b316a7d49cba875a0dcb7734a", + "panel_kind": "sparse", + "panel_seed": 1110253380064193478, + "realization": 33, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "424002a7a02e01674e3819a0ff9676d042458eab389adda2030d05143c82f6de", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007663530751672727, + "kernel_residual": 2.682895170405342e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13894296897688616, + "minus_external_effective_rank": 7.57355606563944, + "minus_external_entropy": 0.9270386901198908, + "minus_target_effective_rank": 26.309095313813877, + "minus_target_entropy": 0.9025457598097973, + "minus_weight": 34.17663423912961, + "orthogonality_relative_error": 1.3704694282928451e-15, + "plus_external_effective_rank": 34.200451660247154, + "plus_external_entropy": 0.860800765362499, + "plus_target_effective_rank": 47.68540789007164, + "plus_target_entropy": 0.9224023965927189, + "plus_weight": 914.2731245098806, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 98, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "25120681e46f050e4c4f92261f137475e2aab3a064c0604f39205134ab9e3d06", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:29.113979+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "6e95e5a9ab7cb29d80c3d3ab0afe2a7b1c50363b316a7d49cba875a0dcb7734a", + "panel_kind": "isotropic", + "panel_seed": 1110253380064193478, + "realization": 33, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e14d68e76b3dc47092479d01a919fdfbfa11e18cfabf79e73d0e85c5b15ebe50", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007663530751672727, + "kernel_residual": 2.682895170405342e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13364828986992616, + "minus_external_effective_rank": 8.433723688599999, + "minus_external_entropy": 0.9619244221355736, + "minus_target_effective_rank": 38.46468972535135, + "minus_target_entropy": 0.880279372763441, + "minus_weight": 33.12143424523076, + "orthogonality_relative_error": 1.4241044427714673e-15, + "plus_external_effective_rank": 38.475527327254156, + "plus_external_entropy": 0.8662184380886087, + "plus_target_effective_rank": 61.83040652747202, + "plus_target_entropy": 0.9689911849117355, + "plus_weight": 923.8711055428663, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "388164138fdf005cbb1af678e6a1347daba17c66a1d1a69a1b76f07529b8fa67", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:36.025420+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "c4b2337bc4225f37969d43cf719e7180315bfc6ac5aec440c0e0541ae8634acc", + "panel_kind": "sparse", + "panel_seed": 12034728457119839498, + "realization": 34, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6a679fdfd7510930777319d9eac07e28c8fc589cce22d9a7ce22121c9b00f554", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.00836362505441755, + "kernel_residual": 2.6930382160106507e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1432220491507681, + "minus_external_effective_rank": 8.34958013243765, + "minus_external_entropy": 0.958274650950133, + "minus_target_effective_rank": 31.0056495251722, + "minus_target_entropy": 0.9232816747480856, + "minus_weight": 35.297361252171584, + "orthogonality_relative_error": 1.013818404391723e-15, + "plus_external_effective_rank": 35.63506724641358, + "plus_external_entropy": 0.8518578709106713, + "plus_target_effective_rank": 54.007781245041365, + "plus_target_entropy": 0.9453087003054941, + "plus_weight": 913.8499427006453, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 112, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "c4099a682ea1a631f9a04b577334777b483cfd60d81b6391427dfafe30b811c3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:46.464271+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "c4b2337bc4225f37969d43cf719e7180315bfc6ac5aec440c0e0541ae8634acc", + "panel_kind": "isotropic", + "panel_seed": 12034728457119839498, + "realization": 34, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1931991e0e948604aff900b5043d888829ee2aa7ac88d1e79cb4d1fbf8b1c5c8", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.00836362505441755, + "kernel_residual": 2.6930382160106507e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1333590332717697, + "minus_external_effective_rank": 8.323133550707155, + "minus_external_entropy": 0.9590486792542031, + "minus_target_effective_rank": 37.8271971455828, + "minus_target_entropy": 0.8777516046038436, + "minus_weight": 34.79909554148362, + "orthogonality_relative_error": 1.0039114746853328e-15, + "plus_external_effective_rank": 37.95735687426744, + "plus_external_entropy": 0.8588587374413252, + "plus_target_effective_rank": 60.37468879773604, + "plus_target_entropy": 0.9647591004877085, + "plus_weight": 972.9288168637754, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "ce2b8b8f48875b633d192c3403ffbfed2259c73b0ce4a0d99d1ba7f9ce510596", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:53.666408+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "e659e2232f25a25cc190daf97f53cf22bdc722779c19ee7e15869154b1877152", + "panel_kind": "sparse", + "panel_seed": 17337308285550423296, + "realization": 35, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f888b5b0a1dcb03101510c4807ee9bc4d1881ec12dec0c1e927e6e2b6d1bdff4", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.010153965348208477, + "kernel_residual": 2.729594323776699e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.133935604528693, + "minus_external_effective_rank": 8.154982843488343, + "minus_external_entropy": 0.9512354900568496, + "minus_target_effective_rank": 31.598660638035668, + "minus_target_entropy": 0.9180716863548206, + "minus_weight": 34.27684275591213, + "orthogonality_relative_error": 9.825469878740413e-16, + "plus_external_effective_rank": 36.74425652475193, + "plus_external_entropy": 0.8577829370427271, + "plus_target_effective_rank": 54.66710762288506, + "plus_target_entropy": 0.9484553481571707, + "plus_weight": 953.8959062571305, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 109, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "2272b4dcd167095d1f9abfda33b15e1d426d3ad37d9392207136da51f4e48a3b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:10.873361+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "e659e2232f25a25cc190daf97f53cf22bdc722779c19ee7e15869154b1877152", + "panel_kind": "isotropic", + "panel_seed": 17337308285550423296, + "realization": 35, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f376e7b68dcea8f5c3d88f3a3815b2e62b281e234ebf454d61d80029b29240c8", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.010153965348208477, + "kernel_residual": 2.729594323776699e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1403397811107, + "minus_external_effective_rank": 8.542602375678669, + "minus_external_entropy": 0.964993817030526, + "minus_target_effective_rank": 37.92907695233185, + "minus_target_entropy": 0.8784229929810208, + "minus_weight": 33.64280201342171, + "orthogonality_relative_error": 1.0016937563654551e-15, + "plus_external_effective_rank": 42.14793335343797, + "plus_external_entropy": 0.8711416658366965, + "plus_target_effective_rank": 63.036553333724925, + "plus_target_entropy": 0.9697165429799274, + "plus_weight": 890.3388189744074, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "b6a0d1a16d2af7b2f271e974d4c5556dbb0f17ccd476a36828a78fb2113c98b9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:46.339851+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "9f62e611013ee52fedff2cd5243a1314040cd0f2418c47321746053439ea72d0", + "panel_kind": "sparse", + "panel_seed": 9910764783973605310, + "realization": 36, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e5b961f0f5f35eb51ad7e65907b962437e133523414ed09fe6c85fa553d904b4", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.010608499336778045, + "kernel_residual": 2.6389972950238277e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13199705536206513, + "minus_external_effective_rank": 8.175948837068564, + "minus_external_entropy": 0.9527376048493049, + "minus_target_effective_rank": 32.324489693439816, + "minus_target_entropy": 0.9205230599271201, + "minus_weight": 33.53006364657711, + "orthogonality_relative_error": 8.095486239115708e-16, + "plus_external_effective_rank": 39.963408274026506, + "plus_external_entropy": 0.8582036504495616, + "plus_target_effective_rank": 56.74740182930475, + "plus_target_entropy": 0.9538978652137013, + "plus_weight": 947.8389389003044, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 117, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "1753464d3e7cdbb646198d60dce80db27f73e4a4d957bef8ce1770a0d9034764", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:02.321921+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "9f62e611013ee52fedff2cd5243a1314040cd0f2418c47321746053439ea72d0", + "panel_kind": "isotropic", + "panel_seed": 9910764783973605310, + "realization": 36, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bb24f157ded88d5e28ab88e4c24a0504b539d22d934af8e4aa981b7bf479aff8", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.010608499336778045, + "kernel_residual": 2.6389972950238277e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13665491624714274, + "minus_external_effective_rank": 8.638924506031849, + "minus_external_entropy": 0.965895918983093, + "minus_target_effective_rank": 38.76772592998565, + "minus_target_entropy": 0.8801497883655705, + "minus_weight": 35.46496348536238, + "orthogonality_relative_error": 8.467749813647403e-16, + "plus_external_effective_rank": 40.678517347891336, + "plus_external_entropy": 0.8647367744981893, + "plus_target_effective_rank": 62.1033028214454, + "plus_target_entropy": 0.967713248113519, + "plus_weight": 965.8560309319058, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "4162dff52c5d971886a2fd077bcb04e6d310fb405b1baa46384a28b7b6f97d4f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:58.438311+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "8433604e7b524d262e034c410ce017caed374194fad6ba88a36822844ea5c4cc", + "panel_kind": "sparse", + "panel_seed": 9192213476151327048, + "realization": 37, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cd5525b96c17075285816a02fabbaf59e2f4bccff7ad6b3afe4593ef13b50783", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007329374293822192, + "kernel_residual": 2.6768268785935556e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.12730226150018228, + "minus_external_effective_rank": 8.313151510924502, + "minus_external_entropy": 0.9560725223740123, + "minus_target_effective_rank": 32.649446265056675, + "minus_target_entropy": 0.9199142787914913, + "minus_weight": 33.84837373369456, + "orthogonality_relative_error": 1.5971445867982995e-15, + "plus_external_effective_rank": 34.74317794185471, + "plus_external_entropy": 0.8493525611561215, + "plus_target_effective_rank": 55.58615391706077, + "plus_target_entropy": 0.9517058398370047, + "plus_weight": 994.7106756317899, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 115, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "4fa501944f8efbe33fb87c7a249901ad2d122ad200bd710c771beb94125f34c5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:13.075626+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "8433604e7b524d262e034c410ce017caed374194fad6ba88a36822844ea5c4cc", + "panel_kind": "isotropic", + "panel_seed": 9192213476151327048, + "realization": 37, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "357845319cf078e95f32e65f54596abf8c49208cea4fcce7ff294244c91da18a", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007329374293822192, + "kernel_residual": 2.6768268785935556e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13841144068505193, + "minus_external_effective_rank": 8.308682007182941, + "minus_external_entropy": 0.9587149823033938, + "minus_target_effective_rank": 38.54043797362355, + "minus_target_entropy": 0.8809349915569126, + "minus_weight": 35.22552285726788, + "orthogonality_relative_error": 1.5903220838238514e-15, + "plus_external_effective_rank": 38.42769822400569, + "plus_external_entropy": 0.8623511725689117, + "plus_target_effective_rank": 59.608806240709654, + "plus_target_entropy": 0.9642646006412297, + "plus_weight": 946.2321524775452, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "58389f813e1055c4ab492d1979aa6fc1dc3b0615ec81d2177769ca5ef9c23f6c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:23.324063+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "c11f6b28f51ebfade57012527ab8d6474976d9bfecff35e8299ffe94909a87b5", + "panel_kind": "sparse", + "panel_seed": 17329099098087717060, + "realization": 38, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "249fdbbf108e8acade9b66cf83401820315c4d356e28db32060f691e83e3c2ee", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007635849363378969, + "kernel_residual": 2.7347761819495176e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1133347304475228, + "minus_external_effective_rank": 7.827461278238239, + "minus_external_entropy": 0.943400715164733, + "minus_target_effective_rank": 30.940612952771787, + "minus_target_entropy": 0.9146761205921048, + "minus_weight": 33.35469027985236, + "orthogonality_relative_error": 1.1656085966384768e-15, + "plus_external_effective_rank": 31.3445874038576, + "plus_external_entropy": 0.8382471137762282, + "plus_target_effective_rank": 52.18169211272392, + "plus_target_entropy": 0.9422138720707304, + "plus_weight": 1109.497732386298, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 109, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "e89a8ba4145ffd5ed0783be223e3c9a7e6bd858f6d4de25e775a51786fbbdc39", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:36.859711+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "c11f6b28f51ebfade57012527ab8d6474976d9bfecff35e8299ffe94909a87b5", + "panel_kind": "isotropic", + "panel_seed": 17329099098087717060, + "realization": 38, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b5a2ae457bbb157da6f8197ac3f14b65a426f0c66f01539a2760ef4799864186", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.007635849363378969, + "kernel_residual": 2.7347761819495176e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.12244562102541102, + "minus_external_effective_rank": 8.421216985227725, + "minus_external_entropy": 0.9602149225322485, + "minus_target_effective_rank": 37.92789575882345, + "minus_target_entropy": 0.8777430620174805, + "minus_weight": 34.06336155255465, + "orthogonality_relative_error": 1.1420365817717391e-15, + "plus_external_effective_rank": 35.55721001587832, + "plus_external_entropy": 0.8476871866723527, + "plus_target_effective_rank": 59.86711385211964, + "plus_target_entropy": 0.9637339905538437, + "plus_weight": 1043.5283627228157, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "8d7acd429a8c491b2a5dc92c453013340b3b07a4fd72525f530eadb2c2b78635", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:46.569083+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "ccde345e178444db4140bc470ba67eb93662876550d9756c1d8d74bff0b64971", + "panel_kind": "sparse", + "panel_seed": 11233896474534391533, + "realization": 39, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d5aeb4fca566e894947990391f44bb658de5c9a7678af97c7012e164a62451c1", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.015494166449445006, + "kernel_residual": 2.699065945628541e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.15748936669599936, + "minus_external_effective_rank": 7.940252675852264, + "minus_external_entropy": 0.9447456946574323, + "minus_target_effective_rank": 28.453700846026717, + "minus_target_entropy": 0.9171510396835731, + "minus_weight": 33.816933370750014, + "orthogonality_relative_error": 5.373033674700631e-16, + "plus_external_effective_rank": 44.03093181491506, + "plus_external_entropy": 0.8839207232436599, + "plus_target_effective_rank": 53.49154007269457, + "plus_target_entropy": 0.9413624180379314, + "plus_weight": 789.8189648049065, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 103, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "e6db8fdf808a561c38c33a27d4ded427e3a114e025e389892faba272170f4572", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:55:01.695181+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "ccde345e178444db4140bc470ba67eb93662876550d9756c1d8d74bff0b64971", + "panel_kind": "isotropic", + "panel_seed": 11233896474534391533, + "realization": 39, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "644b54bd95ab3b144067e5c1324cc18a3e266b9643449eb3c58de50c5c603e5e", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.015494166449445006, + "kernel_residual": 2.699065945628541e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14695478956767752, + "minus_external_effective_rank": 8.566460810246433, + "minus_external_entropy": 0.9654041433112506, + "minus_target_effective_rank": 38.74673331658121, + "minus_target_entropy": 0.8811107354317862, + "minus_weight": 33.026569415867655, + "orthogonality_relative_error": 5.846150490606813e-16, + "plus_external_effective_rank": 48.26152909058519, + "plus_external_entropy": 0.88695269037525, + "plus_target_effective_rank": 65.30421687170336, + "plus_target_entropy": 0.9743979298039407, + "plus_weight": 831.5938574042436, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "1f435d9b3741018b8ef50f2b26f25db5633b9f1a56fe553f28dcfd5de1542b80", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:55:52.321847+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "481cd49de4dfa92d5017e7e0b906f5fab183a324577efd3cc0eecdcea09151dd", + "panel_kind": "sparse", + "panel_seed": 9370413621447335628, + "realization": 40, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b9fa1e0861d12630676bc0847485a68bd60f73b583a36f6263dc9008be47d06f", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.011768710579222118, + "kernel_residual": 2.670352013434395e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.12310792288768875, + "minus_external_effective_rank": 7.627251128396447, + "minus_external_entropy": 0.9361097471156061, + "minus_target_effective_rank": 31.43031716716433, + "minus_target_entropy": 0.9168681929942871, + "minus_weight": 32.440759700616724, + "orthogonality_relative_error": 8.029087245169803e-16, + "plus_external_effective_rank": 38.50964203794566, + "plus_external_entropy": 0.8558661898751228, + "plus_target_effective_rank": 56.78602231796174, + "plus_target_entropy": 0.9526509214437846, + "plus_weight": 988.112617618744, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 112, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "a644fc5451d06194a5d0c298b0aa6f7a01d0ecfa1968de828fc76b5fdef37e18", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:56:08.704216+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "481cd49de4dfa92d5017e7e0b906f5fab183a324577efd3cc0eecdcea09151dd", + "panel_kind": "isotropic", + "panel_seed": 9370413621447335628, + "realization": 40, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "52ad5652f930da6634110f69f6a47d019cf610844a7f943537713ad6c37cf54b", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.011768710579222118, + "kernel_residual": 2.670352013434395e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13122825877315109, + "minus_external_effective_rank": 8.530189187451896, + "minus_external_entropy": 0.9635391685666911, + "minus_target_effective_rank": 38.34422899271413, + "minus_target_entropy": 0.8792022263734262, + "minus_weight": 32.95522899827384, + "orthogonality_relative_error": 8.751045239471131e-16, + "plus_external_effective_rank": 41.3774348604287, + "plus_external_entropy": 0.8670857918628493, + "plus_target_effective_rank": 63.217400992203174, + "plus_target_entropy": 0.9701433164431941, + "plus_weight": 937.4472582510527, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "23788c1a5d7b93adc066ef485f9b194b42ffb105b2ef0f771514bc4c9d472ba9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:42.390201+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "2a475b1689f47b9b3636fb436d58798d25befebc84ab34f09d6b4ff2778c6975", + "panel_kind": "sparse", + "panel_seed": 12528782262091730613, + "realization": 41, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b6833f6cbcafdab9db5ef042ff26f8ad3912640f14f785ecc0f34e66598f86b9", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01227466553696646, + "kernel_residual": 2.6294813181707653e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14151555185494458, + "minus_external_effective_rank": 8.271915398968023, + "minus_external_entropy": 0.9551870536417195, + "minus_target_effective_rank": 32.253589072900176, + "minus_target_entropy": 0.9211735902733711, + "minus_weight": 34.14977698256949, + "orthogonality_relative_error": 7.76102458493378e-16, + "plus_external_effective_rank": 39.91456163740572, + "plus_external_entropy": 0.8647687960088245, + "plus_target_effective_rank": 56.16976818784827, + "plus_target_entropy": 0.9515298496155241, + "plus_weight": 895.6570085638024, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 114, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "c8450ead7a4b18a719e6d80ad0c6108f796a805fe4e0b414b77ca4656e32c79b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:55.002472+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "2a475b1689f47b9b3636fb436d58798d25befebc84ab34f09d6b4ff2778c6975", + "panel_kind": "isotropic", + "panel_seed": 12528782262091730613, + "realization": 41, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "50411d25b0d70382feae7eb98db78be5574c103edcbeaef0d7c20f082fbea90b", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01227466553696646, + "kernel_residual": 2.6294813181707653e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13013964933612465, + "minus_external_effective_rank": 8.726007335282087, + "minus_external_entropy": 0.9681744904116489, + "minus_target_effective_rank": 39.18065424939226, + "minus_target_entropy": 0.8819072275382891, + "minus_weight": 32.891653260682915, + "orthogonality_relative_error": 8.076678524717945e-16, + "plus_external_effective_rank": 42.117517738803265, + "plus_external_entropy": 0.8687530437979699, + "plus_target_effective_rank": 63.85010918175731, + "plus_target_entropy": 0.9716411845509935, + "plus_weight": 944.0355627680268, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "c54591b6d0c1110daca1dbc939a7aa8f42a77de6e3d148f2e2401ea40a52d110", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:51:58.567874+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "44375858a52c747c4e480b2bfc246ec3ffea0845fdba134c273b6d5d1e72a20b", + "panel_kind": "sparse", + "panel_seed": 10673404341089180839, + "realization": 42, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "132b0094eda86e0a18b84105452b010504dbf41e36186623282a3a7302c22784", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01528048142770614, + "kernel_residual": 2.601122176817739e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1400055065219637, + "minus_external_effective_rank": 8.463018173672678, + "minus_external_entropy": 0.9588994588928078, + "minus_target_effective_rank": 32.12631150157505, + "minus_target_entropy": 0.9235249770936628, + "minus_weight": 31.68813626557672, + "orthogonality_relative_error": 6.113729450803912e-16, + "plus_external_effective_rank": 41.97110154963629, + "plus_external_entropy": 0.8713589885054928, + "plus_target_effective_rank": 58.5363545054215, + "plus_target_entropy": 0.9564101396748763, + "plus_weight": 840.7691314405514, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 111, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "45cc4c8df4e2af0c64bad4d60bdc2b40f8b29f4c503b9c78d82ea4e63135c944", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:52:08.544808+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "44375858a52c747c4e480b2bfc246ec3ffea0845fdba134c273b6d5d1e72a20b", + "panel_kind": "isotropic", + "panel_seed": 10673404341089180839, + "realization": 42, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d9618cd6cee89cd66ad8ac0b0be17628bea9d467f5dd7fb082a26e5f9d2c5cce", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.01528048142770614, + "kernel_residual": 2.601122176817739e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.15233189024451982, + "minus_external_effective_rank": 8.903008594194405, + "minus_external_entropy": 0.9730334134653674, + "minus_target_effective_rank": 39.35014287089443, + "minus_target_entropy": 0.8845695311086391, + "minus_weight": 33.75774173390438, + "orthogonality_relative_error": 6.25546209514566e-16, + "plus_external_effective_rank": 46.39791590488422, + "plus_external_entropy": 0.8826355070261155, + "plus_target_effective_rank": 64.89949563536341, + "plus_target_entropy": 0.9735685123776944, + "plus_weight": 817.5166804254707, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "84f0722bd5bfbe721895baaf2bf8a1bc4ad050cdd0b18d34f940277503c4be8c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:27.698940+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "5e128408034f25804ad09c3d7d247cc6fd6dff4fc9a1e0075aead4b833ffa1d5", + "panel_kind": "sparse", + "panel_seed": 4076603982595795892, + "realization": 43, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ea2740e8d9a0c947e4eefa68226951f774379431c0c50864969ed5299726331e", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.015567702410101844, + "kernel_residual": 2.795289610691679e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14109834405638652, + "minus_external_effective_rank": 8.549368498536625, + "minus_external_entropy": 0.9646180355894874, + "minus_target_effective_rank": 33.7992216809376, + "minus_target_entropy": 0.9267401800071009, + "minus_weight": 33.06745947498424, + "orthogonality_relative_error": 6.212897498028626e-16, + "plus_external_effective_rank": 42.933602129808854, + "plus_external_entropy": 0.8704186861465101, + "plus_target_effective_rank": 61.506283291563655, + "plus_target_entropy": 0.9651238096164222, + "plus_weight": 870.0384116766398, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 117, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "a6df8e6a69df0182abb51b5922e8f4ae4878ee352d7010db5e527ef290b81817", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:41.480479+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "5e128408034f25804ad09c3d7d247cc6fd6dff4fc9a1e0075aead4b833ffa1d5", + "panel_kind": "isotropic", + "panel_seed": 4076603982595795892, + "realization": 43, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "50eac77d7a0349e2e5f5028afa53c2ae641bc8b234913104148ace4519a6d31a", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.015567702410101844, + "kernel_residual": 2.795289610691679e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13812812986298245, + "minus_external_effective_rank": 8.537545285209395, + "minus_external_entropy": 0.9638723748235639, + "minus_target_effective_rank": 38.80128120806492, + "minus_target_entropy": 0.8811740774122184, + "minus_weight": 32.03659122020696, + "orthogonality_relative_error": 6.147143809557227e-16, + "plus_external_effective_rank": 46.16312184556342, + "plus_external_entropy": 0.8817054846668763, + "plus_target_effective_rank": 66.73697947940867, + "plus_target_entropy": 0.9771369108327129, + "plus_weight": 862.4722818847347, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "8ecadf8be3a601c8dd05ea51045115e62ddfb168db31cbe80845fe27474a4570", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:21.563811+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "22f16ec59650cd53858578ab0c73815f6596a4d338f4cd84776a8c71da7fc5cb", + "panel_kind": "sparse", + "panel_seed": 10857372922455795294, + "realization": 44, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "790b98079f5d8b8d7535aa40a22fdee5a6d1ea503e48b4cf07a515d4da667b13", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.014777488515971732, + "kernel_residual": 2.6523338040114488e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14365786723100907, + "minus_external_effective_rank": 8.126504990172949, + "minus_external_entropy": 0.9531532519626243, + "minus_target_effective_rank": 33.715267110850306, + "minus_target_entropy": 0.9231390787696125, + "minus_weight": 32.81892867996722, + "orthogonality_relative_error": 5.633444515886638e-16, + "plus_external_effective_rank": 44.77410246835981, + "plus_external_entropy": 0.8785338405584677, + "plus_target_effective_rank": 61.71572541732855, + "plus_target_entropy": 0.9661390534469192, + "plus_weight": 846.8983909491131, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 117, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "4f043cf8da54ba57ce195d134041bd465d7e79eeb66938a17a2a42a7d1d3ac65", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:39.202277+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "22f16ec59650cd53858578ab0c73815f6596a4d338f4cd84776a8c71da7fc5cb", + "panel_kind": "isotropic", + "panel_seed": 10857372922455795294, + "realization": 44, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "00a7a9779f53db203dfc4810a5ceec41b4740a0ac42b3c0b602a3caab728a94c", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.014777488515971732, + "kernel_residual": 2.6523338040114488e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14901724737337588, + "minus_external_effective_rank": 8.295074182035373, + "minus_external_entropy": 0.9592818674136672, + "minus_target_effective_rank": 38.28669544303549, + "minus_target_entropy": 0.8800440299599489, + "minus_weight": 33.818744697600316, + "orthogonality_relative_error": 5.745087332373306e-16, + "plus_external_effective_rank": 47.31632999951576, + "plus_external_entropy": 0.8860629484269985, + "plus_target_effective_rank": 65.85018387640527, + "plus_target_entropy": 0.9752622826276253, + "plus_weight": 838.7796574155054, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "d661bd29d9084b2a0f5975a1d4457a42633c672ffc2e44ab7e8e0e439ce3e733", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:31.892107+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "fbad30a0bacb6c053d5c8de175bb05b89175e9369d0395772d76a04d5daa9528", + "panel_kind": "sparse", + "panel_seed": 8447309985587250154, + "realization": 45, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "19cce0c7e315a9821109639e956742648c151714b73ccc43726ae13f7efb2be2", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.010024333132175248, + "kernel_residual": 2.726733679222159e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.12743025800054852, + "minus_external_effective_rank": 7.782656363787652, + "minus_external_entropy": 0.9419634854226294, + "minus_target_effective_rank": 28.37013461169017, + "minus_target_entropy": 0.9128100725621429, + "minus_weight": 34.05937632097072, + "orthogonality_relative_error": 8.264817662355555e-16, + "plus_external_effective_rank": 35.01975480101282, + "plus_external_entropy": 0.8511969346462406, + "plus_target_effective_rank": 49.75210674147479, + "plus_target_entropy": 0.9342263963547401, + "plus_weight": 999.8352696241277, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 106, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "d7048c920e67431b47ad8beac6b836f751252236d28a3d3127348a46f000b916", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:49.249878+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "fbad30a0bacb6c053d5c8de175bb05b89175e9369d0395772d76a04d5daa9528", + "panel_kind": "isotropic", + "panel_seed": 8447309985587250154, + "realization": 45, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c4e6a318cc5526205dbc6b7a07d194b8dc8c1078594e7f391f0f8ba41698537f", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.010024333132175248, + "kernel_residual": 2.726733679222159e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1278173973882825, + "minus_external_effective_rank": 8.577586937175392, + "minus_external_entropy": 0.9646331938527669, + "minus_target_effective_rank": 38.83040955220473, + "minus_target_entropy": 0.8810562000930107, + "minus_weight": 32.80480836907954, + "orthogonality_relative_error": 8.179076322287389e-16, + "plus_external_effective_rank": 41.440458036927815, + "plus_external_entropy": 0.8677307742776431, + "plus_target_effective_rank": 63.269709726034144, + "plus_target_entropy": 0.9707379909560356, + "plus_weight": 959.8840652800205, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "6001db8f4a9c296ddcdb0670caaee382ceeaae2f707de9e983d8dd0fd718a29e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:52.115958+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "07eae7bd097e121747f206394dacf4511798ec22587a6afe40e2bb1f5e311492", + "panel_kind": "sparse", + "panel_seed": 7433907581508222762, + "realization": 46, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "becf317a37b95c6c7bf96eb91b72a2ccecdf6d8ba7253ecd39325e2ecc495144", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.009362484862803349, + "kernel_residual": 2.700126067405065e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.11155403743714788, + "minus_external_effective_rank": 8.111429095871399, + "minus_external_entropy": 0.9504447887854683, + "minus_target_effective_rank": 32.273287392186575, + "minus_target_entropy": 0.9213574937661396, + "minus_weight": 33.04577792060344, + "orthogonality_relative_error": 1.0227111333058985e-15, + "plus_external_effective_rank": 35.582582173547216, + "plus_external_entropy": 0.845223266533699, + "plus_target_effective_rank": 54.96581148142256, + "plus_target_entropy": 0.9506086562084629, + "plus_weight": 1117.856050082513, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 114, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "e297dbf47e9b888b0b163b2755d54c21b222c738b3ab0e569a3f9d30a6fb2d10", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:55:08.466938+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "07eae7bd097e121747f206394dacf4511798ec22587a6afe40e2bb1f5e311492", + "panel_kind": "isotropic", + "panel_seed": 7433907581508222762, + "realization": 46, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "eaf1605a28dd4e436d79412279044b3c763cfe352bcd3795daa5763079791580", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.009362484862803349, + "kernel_residual": 2.700126067405065e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.13039431537351973, + "minus_external_effective_rank": 8.509682359827144, + "minus_external_entropy": 0.9636340976104113, + "minus_target_effective_rank": 38.3824471642602, + "minus_target_entropy": 0.8802741883414886, + "minus_weight": 34.598527433132254, + "orthogonality_relative_error": 1.1099860344993463e-15, + "plus_external_effective_rank": 39.40400782916143, + "plus_external_entropy": 0.8625904471450577, + "plus_target_effective_rank": 62.48951125839009, + "plus_target_entropy": 0.9690345994623097, + "plus_weight": 990.9457402890462, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "1e440ff8e4aa81ea9948787b69c35f12fd612e843d362d36622050b869a806ba", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:55:18.139493+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "8c95d2a7992bbe1e22fcdb0c0745776e0319d926c22f8ed4ee2fa7ef313500ac", + "panel_kind": "sparse", + "panel_seed": 3013918476944443126, + "realization": 47, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f16b04c24faa258d9ddd9e04508ec1a7545d834bce2c2a6f93df3146a2ffc250", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.014841459692887351, + "kernel_residual": 2.7364208876886697e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1354594441451133, + "minus_external_effective_rank": 7.913125039980009, + "minus_external_entropy": 0.9462169685563823, + "minus_target_effective_rank": 32.477489315484696, + "minus_target_entropy": 0.92013843372919, + "minus_weight": 33.398417218816576, + "orthogonality_relative_error": 6.676570162990673e-16, + "plus_external_effective_rank": 42.874816441086686, + "plus_external_entropy": 0.8685563799906766, + "plus_target_effective_rank": 58.874582255203606, + "plus_target_entropy": 0.9582097833172902, + "plus_weight": 918.2146761255617, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 115, + "plus_target_eigenvalues": 81 + } + }, + { + "arrays_sha256": "e8efca1394c0d4de02d2357269972f83f84c2c8254c49fc387020fd07f7ae489", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:55:33.702142+00:00", + "identity": { + "N": 10, + "charge": 4, + "kernel_identity_hash": "8c95d2a7992bbe1e22fcdb0c0745776e0319d926c22f8ed4ee2fa7ef313500ac", + "panel_kind": "isotropic", + "panel_seed": 3013918476944443126, + "realization": 47, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b7653be12eb5dd07838d09ffa4aa3a8d4ecae98f96b621bd409e88e5d348e4e9", + "kernel": { + "bps_rank": 81, + "complement_rank": 129, + "gap": 0.014841459692887351, + "kernel_residual": 2.7364208876886697e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.14202944584383878, + "minus_external_effective_rank": 8.474856700972929, + "minus_external_entropy": 0.9630835287671491, + "minus_target_effective_rank": 38.77693190980736, + "minus_target_entropy": 0.8812833093804957, + "minus_weight": 34.037022627482514, + "orthogonality_relative_error": 6.617375379156782e-16, + "plus_external_effective_rank": 48.06578080518994, + "plus_external_entropy": 0.8830813456574764, + "plus_target_effective_rank": 65.42386990991062, + "plus_target_entropy": 0.9743359555699364, + "plus_weight": 889.2136885925969, + "target_rank": 81 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 10, + "minus_target_eigenvalues": 81, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 119, + "plus_target_eigenvalues": 81 + } + } + ], + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_covariates_pilot_N12_banked.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_covariates_pilot_N12_banked.json new file mode 100644 index 000000000..1d35d6d6e --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_covariates_pilot_N12_banked.json @@ -0,0 +1,8203 @@ +{ + "checks": { + "all_safe_checks": true, + "complete_requested_grid": true, + "no_outcome_leakage": true + }, + "passed": true, + "records": [ + { + "arrays_sha256": "8ae3962867fe2763b0aec02df0d9872526bae981ac1ba0cb7defd09865e7c3cf", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:57:21.125835+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "e36908deaf8741b80f67520e235c91f33fbf6ec8c044fcc61655685e23b853bd", + "panel_kind": "sparse", + "panel_seed": 5590238514886246416, + "realization": 0, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b46c793d71c005d68de2f3cb1384f414f0c38de27092d3a544e6f25ff9c0e6cd", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08615004179310749, + "kernel_residual": 8.158204130881437e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 122.36648488210683, + "minus_external_entropy": 0.9377766504363716, + "minus_target_effective_rank": 240.24072543934867, + "minus_target_entropy": 0.9228002539225202, + "minus_weight": 1285.5775593550027, + "orthogonality_relative_error": 1.1659386743153548e-16, + "plus_external_effective_rank": 122.3664848821068, + "plus_external_entropy": 0.9377766504363716, + "plus_target_effective_rank": 240.24072543934872, + "plus_target_entropy": 0.9228002539225197, + "plus_weight": 1285.5775593550022, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 216, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 216, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "b77fe81241b7a5593fc59f5796a94114ee71690facb0a506ef877e34f0bdddd7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:03:00.000327+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "e36908deaf8741b80f67520e235c91f33fbf6ec8c044fcc61655685e23b853bd", + "panel_kind": "isotropic", + "panel_seed": 5590238514886246416, + "realization": 0, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "71eee8e9b6a6fb68d29afca704b6b636b8b6483f31ccf1676445ba37f09090e0", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08615004179310749, + "kernel_residual": 8.158204130881437e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 141.0250218907332, + "minus_external_entropy": 0.9543027491721032, + "minus_target_effective_rank": 341.5815109953259, + "minus_target_entropy": 0.9676525493829563, + "minus_weight": 1291.3381663661116, + "orthogonality_relative_error": 1.1830757680142007e-16, + "plus_external_effective_rank": 141.02502189073317, + "plus_external_entropy": 0.9543027491721031, + "plus_target_effective_rank": 341.5815109953258, + "plus_target_entropy": 0.9676525493829563, + "plus_weight": 1291.3381663661107, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "451b4a4f8b94d7cbdb7e646013e0ea2de994581bd8e97bbd9ce132243ce4636e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:54:56.545935+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "bcd0a748623b8e403ccedd7a984229f416f33d9c0eab2a857bb28a8b9f13e8a0", + "panel_kind": "sparse", + "panel_seed": 2560011602869683220, + "realization": 1, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7e32f1addc1ef201cf0545ed96939b5d511661502514e1c750788ba629f4531e", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08963393882882238, + "kernel_residual": 8.098751817549765e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 122.18274141548963, + "minus_external_entropy": 0.9383119202084922, + "minus_target_effective_rank": 252.15736335320267, + "minus_target_entropy": 0.9239572938411046, + "minus_weight": 1306.3498574530183, + "orthogonality_relative_error": 1.268440101076293e-16, + "plus_external_effective_rank": 122.18274141548963, + "plus_external_entropy": 0.9383119202084922, + "plus_target_effective_rank": 252.15736335320275, + "plus_target_entropy": 0.9239572938411046, + "plus_weight": 1306.3498574530172, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 213, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 213, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "e91d5481be12112d46e1cea973e6fa52f0931e64a44cfb04e46c1ddf93cf77fc", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:00:36.178153+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "bcd0a748623b8e403ccedd7a984229f416f33d9c0eab2a857bb28a8b9f13e8a0", + "panel_kind": "isotropic", + "panel_seed": 2560011602869683220, + "realization": 1, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "105224fbf728b1a07cfe9ad50879e6f2e0ef144cb22e5ed057d7fa13f9a47c95", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08963393882882238, + "kernel_residual": 8.098751817549765e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 138.1949052296002, + "minus_external_entropy": 0.951418351979294, + "minus_target_effective_rank": 343.1482629071898, + "minus_target_entropy": 0.9680017420686616, + "minus_weight": 1338.4299087955183, + "orthogonality_relative_error": 1.2706377380270998e-16, + "plus_external_effective_rank": 138.19490522960015, + "plus_external_entropy": 0.9514183519792944, + "plus_target_effective_rank": 343.1482629071899, + "plus_target_entropy": 0.9680017420686616, + "plus_weight": 1338.4299087955178, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "a94fb5b1d28b0e7bac890e508482a5ddaf8f22ee2a0843ec8db9d9927f7bafd1", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:53:03.135138+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "ee71c8c4810d3544d278ad6ddd93db1a527b42873f7b5b9a38026804b23246bc", + "panel_kind": "sparse", + "panel_seed": 5211852120117673501, + "realization": 2, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bd396f4c7f7b7f797d167f0f6dac6448a21c03301727cea3500c7092e07e98cf", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.06845876074362021, + "kernel_residual": 7.949020813070242e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 120.54471987373047, + "minus_external_entropy": 0.9365480973630602, + "minus_target_effective_rank": 262.0140722249937, + "minus_target_entropy": 0.9301825272950405, + "minus_weight": 1327.401773945583, + "orthogonality_relative_error": 1.2882828007935845e-16, + "plus_external_effective_rank": 120.5447198737305, + "plus_external_entropy": 0.9365480973630602, + "plus_target_effective_rank": 262.0140722249938, + "plus_target_entropy": 0.9301825272950404, + "plus_weight": 1327.4017739455828, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 218, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 218, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "eb7edac0899d02b98b36cedf87ab561bf9857af3e0d96404c3805bcd8f287011", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:58:15.800062+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "ee71c8c4810d3544d278ad6ddd93db1a527b42873f7b5b9a38026804b23246bc", + "panel_kind": "isotropic", + "panel_seed": 5211852120117673501, + "realization": 2, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "980c91b48c3961253a27ae10d0cfa12a0170f743393f1f13474f8cc213698e6a", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.06845876074362021, + "kernel_residual": 7.949020813070242e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 135.4753713251706, + "minus_external_entropy": 0.9504611139824912, + "minus_target_effective_rank": 335.6326726919668, + "minus_target_entropy": 0.9661789031347887, + "minus_weight": 1334.5114442749232, + "orthogonality_relative_error": 1.268196773764227e-16, + "plus_external_effective_rank": 135.47537132517058, + "plus_external_entropy": 0.9504611139824909, + "plus_target_effective_rank": 335.63267269196683, + "plus_target_entropy": 0.9661789031347887, + "plus_weight": 1334.5114442749243, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "dd9a1d1e5a37029cd146184234f7babc70259e7d89ca14aa300528ce7c89a400", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:55:51.578520+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "84fa4e6f73e2593e8ad82d76dba2ecff52ad04830627432ecaef92517a31b0f8", + "panel_kind": "sparse", + "panel_seed": 3361729610320139837, + "realization": 3, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f27407b37453f8f5a72bbbb3a1b2423be3e7c1686ffd8eaaa174a35578a80a7b", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08930762882892604, + "kernel_residual": 7.980174365402962e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 120.19711785504528, + "minus_external_entropy": 0.937270680292239, + "minus_target_effective_rank": 222.44572949277975, + "minus_target_entropy": 0.9180369234594047, + "minus_weight": 1289.0640468767683, + "orthogonality_relative_error": 1.1490367311984056e-16, + "plus_external_effective_rank": 120.1971178550452, + "plus_external_entropy": 0.9372706802922394, + "plus_target_effective_rank": 222.4457294927798, + "plus_target_entropy": 0.9180369234594047, + "plus_weight": 1289.0640468767674, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 213, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 213, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "b072033a4e104883b06746feeed96f593302d4f0c9729966ac60f3f63b009f01", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:02:11.083066+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "84fa4e6f73e2593e8ad82d76dba2ecff52ad04830627432ecaef92517a31b0f8", + "panel_kind": "isotropic", + "panel_seed": 3361729610320139837, + "realization": 3, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "482d46060916c41bfddddb4d21ecca5bf090b01438d2298aba7a3b61abf1f850", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08930762882892604, + "kernel_residual": 7.980174365402962e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 140.81814241250106, + "minus_external_entropy": 0.9535605439473863, + "minus_target_effective_rank": 342.11521308370357, + "minus_target_entropy": 0.9676401088571229, + "minus_weight": 1297.5859415007235, + "orthogonality_relative_error": 1.1585628126812716e-16, + "plus_external_effective_rank": 140.81814241250103, + "plus_external_entropy": 0.9535605439473864, + "plus_target_effective_rank": 342.1152130837035, + "plus_target_entropy": 0.9676401088571227, + "plus_weight": 1297.5859415007237, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "d922d401ff4f980121626519772b97045de7419f615d37de68a1f012ec0d1ac8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:55:52.530780+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "dd97efcc0b14ee92fd35ad7aa380774de0758ff0320b9278be846b5be8b7485f", + "panel_kind": "sparse", + "panel_seed": 14112104925841754836, + "realization": 4, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0e969a5831e0c9ca6238df917e038439737b1dd6036b5b114fdae50c4589b332", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.09821999982499431, + "kernel_residual": 8.051612339976525e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 126.21742484238123, + "minus_external_entropy": 0.9418153114694311, + "minus_target_effective_rank": 247.6488046386551, + "minus_target_entropy": 0.9241225635826061, + "minus_weight": 1245.1104843482403, + "orthogonality_relative_error": 1.14572248015963e-16, + "plus_external_effective_rank": 126.21742484238125, + "plus_external_entropy": 0.9418153114694311, + "plus_target_effective_rank": 247.64880463865512, + "plus_target_entropy": 0.9241225635826062, + "plus_weight": 1245.110484348241, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 214, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 214, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "ae463c713df0254fda6773679bf4c7c5a1a5bd27858624696bbcc89b2be53d1f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:01:50.010069+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "dd97efcc0b14ee92fd35ad7aa380774de0758ff0320b9278be846b5be8b7485f", + "panel_kind": "isotropic", + "panel_seed": 14112104925841754836, + "realization": 4, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "110065c5ff84c687b0a971c217bbdedc66097a7eaffab9211caa90a5ab1898a7", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.09821999982499431, + "kernel_residual": 8.051612339976525e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 148.03651693494504, + "minus_external_entropy": 0.9586238803195536, + "minus_target_effective_rank": 347.57015596685363, + "minus_target_entropy": 0.9692231325136398, + "minus_weight": 1242.9948701476303, + "orthogonality_relative_error": 1.145616840464559e-16, + "plus_external_effective_rank": 148.0365169349451, + "plus_external_entropy": 0.9586238803195536, + "plus_target_effective_rank": 347.57015596685363, + "plus_target_entropy": 0.9692231325136397, + "plus_weight": 1242.9948701476294, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "0ad6b8f2bf64b0a8633323acba0612dc9a4d0e2b784f6edefd8dfbea9f1d31ec", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:56:02.226443+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "1756a998fb50c49a3d40aec8efdacd43d81d3fcb786c287a041647eb5aff71a8", + "panel_kind": "sparse", + "panel_seed": 7597303123420221814, + "realization": 5, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ae2f3df5b211f130a857512ba96a1fcac1b4582e1bb292f1ea5a8f149a818f88", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.06883583077870999, + "kernel_residual": 8.019850000544915e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 109.45285829118896, + "minus_external_entropy": 0.9264799975120336, + "minus_target_effective_rank": 242.5537227855621, + "minus_target_entropy": 0.9212575046681543, + "minus_weight": 1384.4387071444826, + "orthogonality_relative_error": 1.3346658994853385e-16, + "plus_external_effective_rank": 109.45285829118889, + "plus_external_entropy": 0.9264799975120339, + "plus_target_effective_rank": 242.55372278556212, + "plus_target_entropy": 0.9212575046681543, + "plus_weight": 1384.4387071444814, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 216, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 216, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "7f2cecc4562d858261cd6817712f8fd89075770e1c78de1fee3632fde320c51f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:02:21.705675+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "1756a998fb50c49a3d40aec8efdacd43d81d3fcb786c287a041647eb5aff71a8", + "panel_kind": "isotropic", + "panel_seed": 7597303123420221814, + "realization": 5, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "74ca2e4cb2475217fceacd2969df2f4b514588109bf229df898e7ad5fa7dd693", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.06883583077870999, + "kernel_residual": 8.019850000544915e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 134.28203892869422, + "minus_external_entropy": 0.9497055881160933, + "minus_target_effective_rank": 337.30147049419156, + "minus_target_entropy": 0.9667957008188719, + "minus_weight": 1346.905276197251, + "orthogonality_relative_error": 1.269439548380027e-16, + "plus_external_effective_rank": 134.28203892869428, + "plus_external_entropy": 0.9497055881160933, + "plus_target_effective_rank": 337.3014704941916, + "plus_target_entropy": 0.9667957008188718, + "plus_weight": 1346.9052761972512, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "3d458fe9dc356de4507ac1c0b0abf88411c0c18bd84d5208cd6c8d2b7613d350", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:56:25.043812+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "ef9df01a3b7e491ffe77d8a19a8ab8fa791a383eaac0a7806c159a9076087e12", + "panel_kind": "sparse", + "panel_seed": 4906014532609465266, + "realization": 6, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "397aebae3b5f5e59022a3ae5247958487a0b1ecaf666f562930cf026541827b5", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.0680380582180937, + "kernel_residual": 8.065919873726626e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 109.8818794075278, + "minus_external_entropy": 0.925991404840358, + "minus_target_effective_rank": 228.01115576829983, + "minus_target_entropy": 0.9191751614196607, + "minus_weight": 1334.961787367346, + "orthogonality_relative_error": 1.234640114485189e-16, + "plus_external_effective_rank": 109.88187940752773, + "plus_external_entropy": 0.925991404840358, + "plus_target_effective_rank": 228.01115576829974, + "plus_target_entropy": 0.9191751614196612, + "plus_weight": 1334.9617873673476, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "2b6da8b9e0967b16e7e57a02a0beef3f0ff3c0ce3c47f6701eb622ffbb210972", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:04:14.196363+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "ef9df01a3b7e491ffe77d8a19a8ab8fa791a383eaac0a7806c159a9076087e12", + "panel_kind": "isotropic", + "panel_seed": 4906014532609465266, + "realization": 6, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d995fa6f0f4ad50f9a5fa07a7a9badc7fb9819020af077c0b8339f7a48bde900", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.0680380582180937, + "kernel_residual": 8.065919873726626e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 133.32420086938322, + "minus_external_entropy": 0.9491845048695172, + "minus_target_effective_rank": 333.33590569379425, + "minus_target_entropy": 0.9655822031686112, + "minus_weight": 1321.588976911858, + "orthogonality_relative_error": 1.197762204391537e-16, + "plus_external_effective_rank": 133.32420086938316, + "plus_external_entropy": 0.9491845048695172, + "plus_target_effective_rank": 333.3359056937942, + "plus_target_entropy": 0.9655822031686113, + "plus_weight": 1321.5889769118567, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "fdbb04a19bc466ecb051a590a6f61fc27278a64607ab94a4cde5353c1f1fda5c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:56:49.884990+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "c7111d1830c262e86ee5e9a0d1a89021ef1263ab542d96846ca1be96888b0ab9", + "panel_kind": "sparse", + "panel_seed": 1604672729945405439, + "realization": 7, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ba89610654ac4ed751d45408a0d981e8240e02287782c62788652865022e1037", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08117956795970725, + "kernel_residual": 7.951242605957994e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 122.53753347537949, + "minus_external_entropy": 0.9389445906063576, + "minus_target_effective_rank": 234.95549401448432, + "minus_target_entropy": 0.9192957585216306, + "minus_weight": 1271.8099346557597, + "orthogonality_relative_error": 1.22776835070084e-16, + "plus_external_effective_rank": 122.53753347537946, + "plus_external_entropy": 0.9389445906063576, + "plus_target_effective_rank": 234.95549401448426, + "plus_target_entropy": 0.9192957585216308, + "plus_weight": 1271.8099346557606, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 214, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 214, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "fbb31789dbe6008425c8cebc260b2b5337f7a2b6b1b827aa94f3ee4e9d8527a2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:03:31.293797+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "c7111d1830c262e86ee5e9a0d1a89021ef1263ab542d96846ca1be96888b0ab9", + "panel_kind": "isotropic", + "panel_seed": 1604672729945405439, + "realization": 7, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e7e3054c71ad55e4bffaf25c341b03236507d1977aa2a40a6bb3d4a5fa241bcb", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08117956795970725, + "kernel_residual": 7.951242605957994e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 138.0369068810004, + "minus_external_entropy": 0.9518000415936306, + "minus_target_effective_rank": 340.1535060799186, + "minus_target_entropy": 0.9671716749895943, + "minus_weight": 1323.964677272459, + "orthogonality_relative_error": 1.2581198203770597e-16, + "plus_external_effective_rank": 138.03690688100048, + "plus_external_entropy": 0.9518000415936306, + "plus_target_effective_rank": 340.1535060799186, + "plus_target_entropy": 0.9671716749895941, + "plus_weight": 1323.9646772724593, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "ebb7e56606d89297499df5f26be08f4e32f28075a0ae0555a9708aadca13ecb2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:08:18.949847+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "d00133c4e8e9b7f2a16d77b789a6dde33f08bf916ca2654199d3bfd806a43c64", + "panel_kind": "sparse", + "panel_seed": 17942723243395988926, + "realization": 8, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "44d18133ff4f0e26e06e9f235b219d0aa8869ea342c6c16331d5a015bfd53fcf", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08724349120452476, + "kernel_residual": 7.890383779823736e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 127.01560016177609, + "minus_external_entropy": 0.9454322696373771, + "minus_target_effective_rank": 251.3437389718429, + "minus_target_entropy": 0.9254793296233658, + "minus_weight": 1279.5081032198866, + "orthogonality_relative_error": 1.2133820312490787e-16, + "plus_external_effective_rank": 127.01560016177612, + "plus_external_entropy": 0.9454322696373771, + "plus_target_effective_rank": 251.34373897184298, + "plus_target_entropy": 0.9254793296233655, + "plus_weight": 1279.5081032198852, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 209, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 209, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "8a7d9dc7a9a851293a67c70a3b92c88b85e60ebe440759b9ecb6e6dafac6f930", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:13:36.829555+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "d00133c4e8e9b7f2a16d77b789a6dde33f08bf916ca2654199d3bfd806a43c64", + "panel_kind": "isotropic", + "panel_seed": 17942723243395988926, + "realization": 8, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b7e09c5d8304218e2c58e1f9c942fdd4a7497363167debfcc80391b872774747", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08724349120452476, + "kernel_residual": 7.890383779823736e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 141.04243078319843, + "minus_external_entropy": 0.9539008727740171, + "minus_target_effective_rank": 343.5497684538962, + "minus_target_entropy": 0.9681238856939327, + "minus_weight": 1298.7449823287561, + "orthogonality_relative_error": 1.2438424738393365e-16, + "plus_external_effective_rank": 141.04243078319845, + "plus_external_entropy": 0.9539008727740171, + "plus_target_effective_rank": 343.5497684538963, + "plus_target_entropy": 0.9681238856939325, + "plus_weight": 1298.7449823287566, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "8423fae1856fa516a61e707b2eb450dbcb97a3dab1c85fe7950593296d97a44a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:06:01.375041+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "03dc48c99a21a140239002c4bea88bbf474862ca3f3fe24044919f439c4c08b0", + "panel_kind": "sparse", + "panel_seed": 14332724097029281885, + "realization": 9, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "df6b130996e8ac1b3c8ad2b81286db02b03e8f055868cee2bf268fccb987e56a", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07991074270245513, + "kernel_residual": 8.115651119212922e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 111.81311951761616, + "minus_external_entropy": 0.9290269601753639, + "minus_target_effective_rank": 245.98458524183627, + "minus_target_entropy": 0.92159529863894, + "minus_weight": 1346.3321658241427, + "orthogonality_relative_error": 1.3078214759174537e-16, + "plus_external_effective_rank": 111.81311951761606, + "plus_external_entropy": 0.9290269601753642, + "plus_target_effective_rank": 245.98458524183624, + "plus_target_entropy": 0.9215952986389401, + "plus_weight": 1346.3321658241423, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 215, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 215, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "ae261fefbdf455e66cb2c318a96a2f56118ad4f91b47835ff0c3e9f548466a02", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:11:18.365354+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "03dc48c99a21a140239002c4bea88bbf474862ca3f3fe24044919f439c4c08b0", + "panel_kind": "isotropic", + "panel_seed": 14332724097029281885, + "realization": 9, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a9cf873c7d79923d51ddeec1d302f849cf72f4605cf1f70cb8fbec84ef03b953", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07991074270245513, + "kernel_residual": 8.115651119212922e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 137.7516950542867, + "minus_external_entropy": 0.9517301352997274, + "minus_target_effective_rank": 340.3852856743955, + "minus_target_entropy": 0.9673172456962958, + "minus_weight": 1322.8112504386813, + "orthogonality_relative_error": 1.2555548759202717e-16, + "plus_external_effective_rank": 137.75169505428656, + "plus_external_entropy": 0.9517301352997277, + "plus_target_effective_rank": 340.3852856743952, + "plus_target_entropy": 0.967317245696296, + "plus_weight": 1322.8112504386816, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "159bb7c40f4ec3067a665999d32277a52e5f56b31d61c34178b59692f0f267cc", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:03:23.237440+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "eda6fee2db9bb9d3a005c1f056b2c85e5da06b0fdc27e1a8bb472c3416743a01", + "panel_kind": "sparse", + "panel_seed": 558749786060967692, + "realization": 10, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6680ca2041170c377cd4789388108db1d12660fd23a3db14a1aa3277aa0b2d80", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08098574182812693, + "kernel_residual": 7.924004178271263e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 124.38438300832586, + "minus_external_entropy": 0.939799507091463, + "minus_target_effective_rank": 269.0304830937839, + "minus_target_entropy": 0.9315353777585301, + "minus_weight": 1305.15000495612, + "orthogonality_relative_error": 1.2123891950193807e-16, + "plus_external_effective_rank": 124.38438300832568, + "plus_external_entropy": 0.9397995070914626, + "plus_target_effective_rank": 269.0304830937838, + "plus_target_entropy": 0.9315353777585297, + "plus_weight": 1305.1500049561196, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 217, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 217, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "5f4e4a49c0ec86cea110defb69da9f886b3b827754ce985c0d6bf1342cd82d85", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:08:27.121906+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "eda6fee2db9bb9d3a005c1f056b2c85e5da06b0fdc27e1a8bb472c3416743a01", + "panel_kind": "isotropic", + "panel_seed": 558749786060967692, + "realization": 10, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "eaa723fb833c6e2cdbee9b2b3710c5f721e4eb54e96106aba8d29a47c24bd763", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08098574182812693, + "kernel_residual": 7.924004178271263e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 141.2344441972241, + "minus_external_entropy": 0.9542799944521634, + "minus_target_effective_rank": 341.3338484360134, + "minus_target_entropy": 0.9676408777360438, + "minus_weight": 1291.933985442206, + "orthogonality_relative_error": 1.1963590864527847e-16, + "plus_external_effective_rank": 141.23444419722398, + "plus_external_entropy": 0.954279994452163, + "plus_target_effective_rank": 341.33384843601334, + "plus_target_entropy": 0.9676408777360438, + "plus_weight": 1291.9339854422044, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "1d1e5df14ff7a1a87e89bc265a75a185857a48fa08e314619368d021ac116e03", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:08:29.928940+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "ef0af4c1d50e4855962d9b6d61d803797668627ef8c7249bcf868aad721c871a", + "panel_kind": "sparse", + "panel_seed": 13569904168694810039, + "realization": 11, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d40c672bc6467c3f097679a06dd9930e433b093757e0b6eaacad0d75d3718ac1", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.0840412187190953, + "kernel_residual": 8.048940819013765e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 120.47769831310565, + "minus_external_entropy": 0.937366791901732, + "minus_target_effective_rank": 237.91372366041944, + "minus_target_entropy": 0.9209659989579805, + "minus_weight": 1327.970620749828, + "orthogonality_relative_error": 1.2499513863006817e-16, + "plus_external_effective_rank": 120.47769831310573, + "plus_external_entropy": 0.9373667919017319, + "plus_target_effective_rank": 237.91372366041944, + "plus_target_entropy": 0.9209659989579808, + "plus_weight": 1327.9706207498282, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 213, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 213, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "c16332250d0de8d96acb64dfca16dd9983dff566a56f8eeefd300f6fccdd1607", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:14:25.782830+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "ef0af4c1d50e4855962d9b6d61d803797668627ef8c7249bcf868aad721c871a", + "panel_kind": "isotropic", + "panel_seed": 13569904168694810039, + "realization": 11, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8209cad3201fc56fa047a85d0ad96b10cda1b5f1824b411cda413865f6014814", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.0840412187190953, + "kernel_residual": 8.048940819013765e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 138.47738614575073, + "minus_external_entropy": 0.9520615809984281, + "minus_target_effective_rank": 341.66954114351154, + "minus_target_entropy": 0.967585574388299, + "minus_weight": 1308.5840472171853, + "orthogonality_relative_error": 1.2788594915674394e-16, + "plus_external_effective_rank": 138.47738614575078, + "plus_external_entropy": 0.9520615809984281, + "plus_target_effective_rank": 341.66954114351154, + "plus_target_entropy": 0.9675855743882992, + "plus_weight": 1308.5840472171842, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "88692e35924ac2b65e79fdaba30b538251955e1e59fd1a80f4199222386c1560", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:08:18.139715+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "c7d85ef2b3c03c4c35293f1a1ee732226ef08c6ff2dbb75eddbfd544a269f8a1", + "panel_kind": "sparse", + "panel_seed": 5279007992092632813, + "realization": 12, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ec602fdad2bf47261edd1fbe9afd7d04d339eff6583c3264e410aebe8dac3c62", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.0693947883301592, + "kernel_residual": 8.039772363230066e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 113.65371083431711, + "minus_external_entropy": 0.930176794900309, + "minus_target_effective_rank": 243.22087388047123, + "minus_target_entropy": 0.9231424357773197, + "minus_weight": 1338.3264835868513, + "orthogonality_relative_error": 1.327517467691688e-16, + "plus_external_effective_rank": 113.6537108343171, + "plus_external_entropy": 0.9301767949003094, + "plus_target_effective_rank": 243.2208738804713, + "plus_target_entropy": 0.9231424357773198, + "plus_weight": 1338.3264835868536, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 214, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 214, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "3b23f6cfa88d66e6f1bc5c539d023badf2a63d7a9825c7ed795da4975a4f26c8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:14:14.062491+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "c7d85ef2b3c03c4c35293f1a1ee732226ef08c6ff2dbb75eddbfd544a269f8a1", + "panel_kind": "isotropic", + "panel_seed": 5279007992092632813, + "realization": 12, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c6ac66e350ded586142fbe0b674fadbcf0944b1d307f391999e3e52fd985c23d", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.0693947883301592, + "kernel_residual": 8.039772363230066e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 134.81455945647744, + "minus_external_entropy": 0.9498549223392645, + "minus_target_effective_rank": 335.2047611930195, + "minus_target_entropy": 0.9660371086322486, + "minus_weight": 1336.527946678545, + "orthogonality_relative_error": 1.3271548361724145e-16, + "plus_external_effective_rank": 134.81455945647744, + "plus_external_entropy": 0.9498549223392648, + "plus_target_effective_rank": 335.2047611930195, + "plus_target_entropy": 0.9660371086322488, + "plus_weight": 1336.5279466785448, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "5a915804d42fba0e78beabb04ef7533749384ff13d311c74adf07bf729d40bcd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:08:28.654373+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "0e08f920f83f89393d83deadb1be5704fae8d190d40b1e6a01a1c1317c177601", + "panel_kind": "sparse", + "panel_seed": 7661256542549931073, + "realization": 13, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f99daa04f029f41c1cda71c76f55b128a9e053e95e0b528ea9ac91e1be2f200f", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08794721566910581, + "kernel_residual": 7.948822819863247e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 119.81805303250152, + "minus_external_entropy": 0.9342531902172128, + "minus_target_effective_rank": 254.4325757002335, + "minus_target_entropy": 0.925969071142623, + "minus_weight": 1314.4599108057837, + "orthogonality_relative_error": 1.187511167147045e-16, + "plus_external_effective_rank": 119.81805303250154, + "plus_external_entropy": 0.9342531902172128, + "plus_target_effective_rank": 254.4325757002334, + "plus_target_entropy": 0.925969071142623, + "plus_weight": 1314.4599108057832, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 218, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 218, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "06723b7b95c0b027b4cefa09d43ea22183aaaf9c091313f8816d51b4a0216208", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:14:28.324862+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "0e08f920f83f89393d83deadb1be5704fae8d190d40b1e6a01a1c1317c177601", + "panel_kind": "isotropic", + "panel_seed": 7661256542549931073, + "realization": 13, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "58fff33a6222e4f399db3d2343dcd8911b8c95d5f4018a2234df1c03ffe0f5cd", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08794721566910581, + "kernel_residual": 7.948822819863247e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 144.8126196833963, + "minus_external_entropy": 0.956603395201416, + "minus_target_effective_rank": 344.2685496141185, + "minus_target_entropy": 0.9682914513694544, + "minus_weight": 1267.5150984939642, + "orthogonality_relative_error": 1.1511361834808466e-16, + "plus_external_effective_rank": 144.8126196833963, + "plus_external_entropy": 0.956603395201416, + "plus_target_effective_rank": 344.26854961411874, + "plus_target_entropy": 0.9682914513694543, + "plus_weight": 1267.5150984939644, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "ef4d5f2f384a699e02629ec633ae10baed563540dd49dffee6e4ff713c79bc95", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:11:19.011422+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "997812eefcddd91ef7e0e40418ddceba95569aa988ba44500b571699f0992392", + "panel_kind": "sparse", + "panel_seed": 6466577644792577191, + "realization": 14, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7c0296f1b3471057843aea84ee0683b3b35451286beedc5fd3fe91e8a18e9e91", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08730968979423592, + "kernel_residual": 8.147668086459837e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 127.2403625672868, + "minus_external_entropy": 0.941991071494719, + "minus_target_effective_rank": 258.1213813760631, + "minus_target_entropy": 0.9263868092743559, + "minus_weight": 1261.5990052938928, + "orthogonality_relative_error": 1.283727378693626e-16, + "plus_external_effective_rank": 127.24036256728687, + "plus_external_entropy": 0.9419910714947191, + "plus_target_effective_rank": 258.12138137606337, + "plus_target_entropy": 0.9263868092743556, + "plus_weight": 1261.5990052938917, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 217, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 217, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "7a946b976ebe74e4f6e1b453c726338fa6d66305656ed19a9849aa206d2e715c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:17:56.958143+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "997812eefcddd91ef7e0e40418ddceba95569aa988ba44500b571699f0992392", + "panel_kind": "isotropic", + "panel_seed": 6466577644792577191, + "realization": 14, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "364f1f3881ac683350bdf88c2e4df1ab9702d7db9ab298eda7be3986d168663f", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08730968979423592, + "kernel_residual": 8.147668086459837e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 137.99901980257826, + "minus_external_entropy": 0.9514126394254858, + "minus_target_effective_rank": 340.0878556945141, + "minus_target_entropy": 0.9670486464951884, + "minus_weight": 1317.9895831462602, + "orthogonality_relative_error": 1.3009688784214305e-16, + "plus_external_effective_rank": 137.99901980257835, + "plus_external_entropy": 0.951412639425486, + "plus_target_effective_rank": 340.08785569451413, + "plus_target_entropy": 0.9670486464951884, + "plus_weight": 1317.9895831462588, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "afd5033174a5f1f3f4e19921845882214347356ef852effaa0f12ffdea9e6183", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:10:32.124133+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "4ef56c037b44ee89ba7261a7367e27540857fce94a3641ed373f63f10fc57dc3", + "panel_kind": "sparse", + "panel_seed": 14594679594287786685, + "realization": 15, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0b8fc6de1c77b58614d9d7479dd9166049a3fc1aae0d04b49347e8280cd11c68", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07702068146207317, + "kernel_residual": 8.047873469821361e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 116.53130695209371, + "minus_external_entropy": 0.9330854766226053, + "minus_target_effective_rank": 249.7480870623025, + "minus_target_entropy": 0.923327968226316, + "minus_weight": 1382.3593344855685, + "orthogonality_relative_error": 1.214989510502449e-16, + "plus_external_effective_rank": 116.5313069520937, + "plus_external_entropy": 0.9330854766226055, + "plus_target_effective_rank": 249.7480870623024, + "plus_target_entropy": 0.9233279682263164, + "plus_weight": 1382.3593344855674, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 214, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 214, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "95c335a2eb04ea5802074aedbaaa3774247f9915cdf9f2372951125396446943", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:18:31.488956+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "4ef56c037b44ee89ba7261a7367e27540857fce94a3641ed373f63f10fc57dc3", + "panel_kind": "isotropic", + "panel_seed": 14594679594287786685, + "realization": 15, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "897e9c17b11cca9892d08bc2f298a5f988cfdf409b215cc320d9defc06c6d3e0", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07702068146207317, + "kernel_residual": 8.047873469821361e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 138.6607925078936, + "minus_external_entropy": 0.9522135535908813, + "minus_target_effective_rank": 338.04052404900216, + "minus_target_entropy": 0.9667066202698672, + "minus_weight": 1324.0997881407736, + "orthogonality_relative_error": 1.1851768411629908e-16, + "plus_external_effective_rank": 138.66079250789355, + "plus_external_entropy": 0.9522135535908813, + "plus_target_effective_rank": 338.0405240490023, + "plus_target_entropy": 0.9667066202698672, + "plus_weight": 1324.099788140774, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "c2c61da93b00c8e97b66fade8543cbccd350f6c4cfc7fa7eadaa229eddf127c6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:19:20.967494+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "54237ee372e2eac2f16fea7530ab7007499a5cbc257ffd4d1c956b6fdaedfea1", + "panel_kind": "sparse", + "panel_seed": 11304665961358764344, + "realization": 16, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cf0d2fcb52984d6e69f6838d4190243d4b347e06bed52624c94be28857da5314", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07423495224505836, + "kernel_residual": 7.986746707235424e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 125.6612831609781, + "minus_external_entropy": 0.9407128081110947, + "minus_target_effective_rank": 273.4453460422015, + "minus_target_entropy": 0.9352553765211166, + "minus_weight": 1353.2868681682, + "orthogonality_relative_error": 1.3294287913857703e-16, + "plus_external_effective_rank": 125.66128316097806, + "plus_external_entropy": 0.9407128081110946, + "plus_target_effective_rank": 273.44534604220155, + "plus_target_entropy": 0.9352553765211163, + "plus_weight": 1353.2868681682012, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "21d56348a5e8566b3c82cdf3115d2b466e94dfc8952f9d75d3c3b2c7fddda21c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:27:38.053920+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "54237ee372e2eac2f16fea7530ab7007499a5cbc257ffd4d1c956b6fdaedfea1", + "panel_kind": "isotropic", + "panel_seed": 11304665961358764344, + "realization": 16, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "776da0e61b59d2465b40c7f580d203b67f2d330a53d1ed99c04dbb06c002b6fc", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07423495224505836, + "kernel_residual": 7.986746707235424e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 134.34511352015883, + "minus_external_entropy": 0.9491949978253422, + "minus_target_effective_rank": 337.5674340139081, + "minus_target_entropy": 0.9665956114936106, + "minus_weight": 1361.819613385505, + "orthogonality_relative_error": 1.315625443668203e-16, + "plus_external_effective_rank": 134.34511352015886, + "plus_external_entropy": 0.9491949978253421, + "plus_target_effective_rank": 337.5674340139081, + "plus_target_entropy": 0.9665956114936107, + "plus_weight": 1361.8196133855035, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "5214079d62447a000929b08d051ea912f2182c8a7d3f699f3f12d1a3fb634838", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:17:05.752128+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "31e0d54dd60d6c3d10a93cdf2784c36e0c7897b88c1be25dca08879271df97b2", + "panel_kind": "sparse", + "panel_seed": 13198365492341629948, + "realization": 17, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5c16b72fced80e498201fd5113261fe637e74ec4ebe1ffa0ea8c92ac86fa5a36", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08343280150371474, + "kernel_residual": 8.044140217382729e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 122.40268345219283, + "minus_external_entropy": 0.9386286002933905, + "minus_target_effective_rank": 265.10993749682336, + "minus_target_entropy": 0.9294261273415423, + "minus_weight": 1325.6621793530699, + "orthogonality_relative_error": 1.227021900391104e-16, + "plus_external_effective_rank": 122.40268345219285, + "plus_external_entropy": 0.9386286002933903, + "plus_target_effective_rank": 265.1099374968234, + "plus_target_entropy": 0.9294261273415421, + "plus_weight": 1325.6621793530692, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 216, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 216, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "6ff326a4c29206fbd826cb9b718fd3a18a14871cd37c965cc0b74852528c61aa", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:22:50.854349+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "31e0d54dd60d6c3d10a93cdf2784c36e0c7897b88c1be25dca08879271df97b2", + "panel_kind": "isotropic", + "panel_seed": 13198365492341629948, + "realization": 17, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8481eeb33b4c63a9ce4ecf933dcc4639d91a24ef16def6388ed32adabf7ae1b1", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08343280150371474, + "kernel_residual": 8.044140217382729e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 142.90667617282335, + "minus_external_entropy": 0.9553064540386252, + "minus_target_effective_rank": 340.73053884897035, + "minus_target_entropy": 0.9674110120168296, + "minus_weight": 1286.9933782157839, + "orthogonality_relative_error": 1.1973109489631306e-16, + "plus_external_effective_rank": 142.90667617282335, + "plus_external_entropy": 0.9553064540386255, + "plus_target_effective_rank": 340.7305388489704, + "plus_target_entropy": 0.9674110120168298, + "plus_weight": 1286.9933782157825, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "79fe895868ed18faa0ba5222a4ab83e1d5ede46bdc641bd60b38ef4d690eac00", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:13:36.780105+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "bcac20738773ab3ca749c930dc4b322dce01d5fac650b6c5ee6cdf496e4eca62", + "panel_kind": "sparse", + "panel_seed": 14157667274857317898, + "realization": 18, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fb9e8d170ecc1ff1b5fe944d8a5b66da6a28daafa643d0ee26d5766fcfe6e298", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08624912489625823, + "kernel_residual": 8.179347005165088e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999998, + "minus_external_effective_rank": 120.75950365063305, + "minus_external_entropy": 0.9372278011066659, + "minus_target_effective_rank": 248.68061109601646, + "minus_target_entropy": 0.9244519204804561, + "minus_weight": 1313.2062286181613, + "orthogonality_relative_error": 1.2154889591022942e-16, + "plus_external_effective_rank": 120.75950365063306, + "plus_external_entropy": 0.9372278011066659, + "plus_target_effective_rank": 248.68061109601666, + "plus_target_entropy": 0.924451920480456, + "plus_weight": 1313.206228618161, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 212, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 212, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "4af58b5040de0c675bf5d80905d516faef0ce019825ecc142df430e672039aee", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:18:52.963173+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "bcac20738773ab3ca749c930dc4b322dce01d5fac650b6c5ee6cdf496e4eca62", + "panel_kind": "isotropic", + "panel_seed": 14157667274857317898, + "realization": 18, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bea20a006938139ac40dab23fc98b53a86bef4b33bec64fafacff92d20a59395", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08624912489625823, + "kernel_residual": 8.179347005165088e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 141.1594313860971, + "minus_external_entropy": 0.9534438052227113, + "minus_target_effective_rank": 341.76894468818733, + "minus_target_entropy": 0.9675760893638395, + "minus_weight": 1308.51229586301, + "orthogonality_relative_error": 1.2099859134663144e-16, + "plus_external_effective_rank": 141.15943138609717, + "plus_external_entropy": 0.9534438052227115, + "plus_target_effective_rank": 341.7689446881873, + "plus_target_entropy": 0.9675760893638393, + "plus_weight": 1308.5122958630102, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "5a5b42a16cfb1200cfc5591fb1410747a1edfe83d93365a32cc6be511936baa5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:20:37.971499+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "7d8d4fe97ff72c3d3ff9b7bc4809d876f102402877345f15d8a0c920f5ffad38", + "panel_kind": "sparse", + "panel_seed": 13862946949454208362, + "realization": 19, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b9da25e7206bf6c5056fa41962b1ff1383d89b4673f4d99d5d25c5c6e290e1c4", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08274165634303234, + "kernel_residual": 7.941117713967446e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 121.5264252087405, + "minus_external_entropy": 0.9369126028737901, + "minus_target_effective_rank": 255.42912909550353, + "minus_target_entropy": 0.9267820152652715, + "minus_weight": 1332.3035192267978, + "orthogonality_relative_error": 1.3142697659849452e-16, + "plus_external_effective_rank": 121.52642520874052, + "plus_external_entropy": 0.9369126028737904, + "plus_target_effective_rank": 255.4291290955036, + "plus_target_entropy": 0.9267820152652715, + "plus_weight": 1332.3035192267967, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 217, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 217, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "e385ccce264229dd621c589e948f161a1d638eba4a2d291dd3a81e953bbfb532", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:26:45.475019+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "7d8d4fe97ff72c3d3ff9b7bc4809d876f102402877345f15d8a0c920f5ffad38", + "panel_kind": "isotropic", + "panel_seed": 13862946949454208362, + "realization": 19, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ab4812d2357a979e221a097949aa864c9f43b17041065b1de64a33fa969283b5", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08274165634303234, + "kernel_residual": 7.941117713967446e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 140.74319043584052, + "minus_external_entropy": 0.9536073878498643, + "minus_target_effective_rank": 341.61616598990486, + "minus_target_entropy": 0.9676082751551385, + "minus_weight": 1301.1306408221842, + "orthogonality_relative_error": 1.298623204251826e-16, + "plus_external_effective_rank": 140.74319043584046, + "plus_external_entropy": 0.9536073878498643, + "plus_target_effective_rank": 341.616165989905, + "plus_target_entropy": 0.9676082751551384, + "plus_weight": 1301.130640822183, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "ebf0cbbeaf830b75b36128df3c2ac4b88aa4a9c99504364c17fd0858fe275062", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:20:28.588807+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "9296f91c3b990a56ed7d62c970d0bee803f7dbcb85feb3cdfe889cca7a6f990e", + "panel_kind": "sparse", + "panel_seed": 10210789521473046616, + "realization": 20, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4c4675c975a4edf0e539b4d3141da5b8683c0ea1b7e78b8d06b7d8989342140d", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08002758373489888, + "kernel_residual": 8.056812084073192e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 122.49880178541842, + "minus_external_entropy": 0.9423562709717704, + "minus_target_effective_rank": 255.8192295740465, + "minus_target_entropy": 0.9256122507174696, + "minus_weight": 1290.4732707055018, + "orthogonality_relative_error": 1.2467041941687992e-16, + "plus_external_effective_rank": 122.4988017854184, + "plus_external_entropy": 0.9423562709717703, + "plus_target_effective_rank": 255.81922957404663, + "plus_target_entropy": 0.9256122507174692, + "plus_weight": 1290.4732707055014, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 209, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 209, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "94ed7535bbf4bbb2b15ba9a99335349c4a9857434341057c8de950491bff64da", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:26:18.847625+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "9296f91c3b990a56ed7d62c970d0bee803f7dbcb85feb3cdfe889cca7a6f990e", + "panel_kind": "isotropic", + "panel_seed": 10210789521473046616, + "realization": 20, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9fbbe90e42ab3c15deb5cc752b9a15e3f98da48e8821eb41ffa41e59bff53985", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08002758373489888, + "kernel_residual": 8.056812084073192e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 138.44117750377478, + "minus_external_entropy": 0.9525652312551564, + "minus_target_effective_rank": 339.1734193404416, + "minus_target_entropy": 0.9671257763451293, + "minus_weight": 1304.6466617559006, + "orthogonality_relative_error": 1.250343776757689e-16, + "plus_external_effective_rank": 138.4411775037748, + "plus_external_entropy": 0.9525652312551562, + "plus_target_effective_rank": 339.17341934044174, + "plus_target_entropy": 0.967125776345129, + "plus_weight": 1304.6466617559008, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "4c399f2d210d5d2bea2b31d2099559ac4474871d8a4573cad00c0cd0ed65dd7a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:20:30.698975+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "32b80e2ce44a41e27b4cd423c2f7f2092a57b8bd26b6e8b3b8f8b3a6d38356f2", + "panel_kind": "sparse", + "panel_seed": 10677760042151579695, + "realization": 21, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a797146a8975b58e53d37d30495958448df0296f975c0fd2a3e8bf78632337a6", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07788960398883814, + "kernel_residual": 7.948787513740868e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 121.13449410631735, + "minus_external_entropy": 0.9386316968029178, + "minus_target_effective_rank": 244.53379798982843, + "minus_target_entropy": 0.925573208751195, + "minus_weight": 1286.3312108834714, + "orthogonality_relative_error": 1.2179888906672702e-16, + "plus_external_effective_rank": 121.13449410631742, + "plus_external_entropy": 0.9386316968029176, + "plus_target_effective_rank": 244.5337979898285, + "plus_target_entropy": 0.9255732087511949, + "plus_weight": 1286.3312108834714, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 212, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 212, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "f27508cba03d977cb24fb61bdf1b3c953f435abdccf29ff6af7c489ab0225a13", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:26:43.869640+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "32b80e2ce44a41e27b4cd423c2f7f2092a57b8bd26b6e8b3b8f8b3a6d38356f2", + "panel_kind": "isotropic", + "panel_seed": 10677760042151579695, + "realization": 21, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "689e114981b296638026c415bde2d9dab2515c870b390797fc9038d11da47f31", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07788960398883814, + "kernel_residual": 7.948787513740868e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 142.12620352755047, + "minus_external_entropy": 0.9550342688063655, + "minus_target_effective_rank": 342.5830289969548, + "minus_target_entropy": 0.967997008208497, + "minus_weight": 1295.282517062935, + "orthogonality_relative_error": 1.2129510080465386e-16, + "plus_external_effective_rank": 142.12620352755056, + "plus_external_entropy": 0.9550342688063653, + "plus_target_effective_rank": 342.5830289969547, + "plus_target_entropy": 0.967997008208497, + "plus_weight": 1295.2825170629364, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "b0b9fcf10c3a4a7bfd5f371a3b8a3c12ad425c87bf38d553d67affb945130ee4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:24:44.468828+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "c0c9d4f3916f6248b8baaa26c9962b6392bcb07452502db5ab230607958a0bfc", + "panel_kind": "sparse", + "panel_seed": 10187089410345300937, + "realization": 22, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ee7a18c4969751f0e61250b824c5c1e0af1c2c92639755e45dbde71f5daecb13", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07574042073695422, + "kernel_residual": 8.034830890268048e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 117.99770069382217, + "minus_external_entropy": 0.9350519795575283, + "minus_target_effective_rank": 255.15993940360585, + "minus_target_entropy": 0.9254829633761439, + "minus_weight": 1335.441067665316, + "orthogonality_relative_error": 1.262118979451585e-16, + "plus_external_effective_rank": 117.99770069382211, + "plus_external_entropy": 0.9350519795575286, + "plus_target_effective_rank": 255.1599394036059, + "plus_target_entropy": 0.9254829633761439, + "plus_weight": 1335.4410676653156, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 214, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 214, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "40c4682aa3c690f304e7159d5e83e114b2085cb2bcbfd608c342673371f5cf19", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:31:04.792718+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "c0c9d4f3916f6248b8baaa26c9962b6392bcb07452502db5ab230607958a0bfc", + "panel_kind": "isotropic", + "panel_seed": 10187089410345300937, + "realization": 22, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6a43d54d6dfe5e818037efcf0e5e220c86d503931c4a7c94392a383e82a81de6", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07574042073695422, + "kernel_residual": 8.034830890268048e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 136.07336022602408, + "minus_external_entropy": 0.9506600128637456, + "minus_target_effective_rank": 339.05244596139147, + "minus_target_entropy": 0.966961163303118, + "minus_weight": 1331.8466438332744, + "orthogonality_relative_error": 1.2634333247833405e-16, + "plus_external_effective_rank": 136.0733602260241, + "plus_external_entropy": 0.9506600128637456, + "plus_target_effective_rank": 339.05244596139136, + "plus_target_entropy": 0.966961163303118, + "plus_weight": 1331.8466438332741, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "3aabf63d2bfb8d259050c977303ec71a13a5dddd627c58dc14aa376a645d0770", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:25:16.808265+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "6c6f78011e499bbc1c51fbf419cc80c489044360410b23984df8eb6aca8e6bbe", + "panel_kind": "sparse", + "panel_seed": 17925107741578208821, + "realization": 23, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "529e1331596ea4a42bf735e250264d5f3e8f23cfb41149d4f03ebe7713a86a7d", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.0795692873021809, + "kernel_residual": 8.006231974894816e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 115.34867933665777, + "minus_external_entropy": 0.9309752166876337, + "minus_target_effective_rank": 259.91781907317085, + "minus_target_entropy": 0.927454739298845, + "minus_weight": 1344.9251385329026, + "orthogonality_relative_error": 1.221232830995883e-16, + "plus_external_effective_rank": 115.34867933665774, + "plus_external_entropy": 0.9309752166876337, + "plus_target_effective_rank": 259.91781907317085, + "plus_target_entropy": 0.9274547392988449, + "plus_weight": 1344.9251385329026, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 214, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 214, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "379f682c93fb0528f2530613325daa639c7618ea368d10cb31eb065bc5d8c9c7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:31:33.675172+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "6c6f78011e499bbc1c51fbf419cc80c489044360410b23984df8eb6aca8e6bbe", + "panel_kind": "isotropic", + "panel_seed": 17925107741578208821, + "realization": 23, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "474b77d2176ea6985991c76beaa2b4f5b960263dfffe85531e0a0712f0431a5f", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.0795692873021809, + "kernel_residual": 8.006231974894816e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 140.03519218869985, + "minus_external_entropy": 0.9534434978358863, + "minus_target_effective_rank": 340.99374426408093, + "minus_target_entropy": 0.9673832817328065, + "minus_weight": 1296.99430781248, + "orthogonality_relative_error": 1.1883254020675572e-16, + "plus_external_effective_rank": 140.03519218869982, + "plus_external_entropy": 0.9534434978358863, + "plus_target_effective_rank": 340.99374426408093, + "plus_target_entropy": 0.9673832817328066, + "plus_weight": 1296.994307812478, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "76e90d1cf28c4b0069fc7dcef7475cf375c733eed72b996a19adb747bab4a981", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:35:34.404361+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "3224a7906f2412a400e745f3d1277baa9baed2bffc1efe62c8afdc1b1322b3c4", + "panel_kind": "sparse", + "panel_seed": 13356525011863021680, + "realization": 24, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "784a312d92067a4a35d26613f082541b699825f1b02a1fdb7dd35611c1fbbecb", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07908383457585975, + "kernel_residual": 8.002430276546935e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 118.29498616989864, + "minus_external_entropy": 0.934506664212902, + "minus_target_effective_rank": 256.5014728383997, + "minus_target_entropy": 0.9255906599963153, + "minus_weight": 1305.5202158659965, + "orthogonality_relative_error": 1.2429915523561374e-16, + "plus_external_effective_rank": 118.29498616989875, + "plus_external_entropy": 0.9345066642129018, + "plus_target_effective_rank": 256.5014728383997, + "plus_target_entropy": 0.9255906599963153, + "plus_weight": 1305.5202158659945, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 213, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 213, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "190a9dbfa7b21f5deee7591c154a138ba066fb3f269614e00db8de08cb931a42", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:42:03.991050+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "3224a7906f2412a400e745f3d1277baa9baed2bffc1efe62c8afdc1b1322b3c4", + "panel_kind": "isotropic", + "panel_seed": 13356525011863021680, + "realization": 24, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fdd52be7d4b8c55e6c512aea413617e7403c5386682eb8ac7a25ae2c870e4ea9", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07908383457585975, + "kernel_residual": 8.002430276546935e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 138.3861114178528, + "minus_external_entropy": 0.9518949096507662, + "minus_target_effective_rank": 340.48670922497223, + "minus_target_entropy": 0.9673599160642073, + "minus_weight": 1324.1506498608421, + "orthogonality_relative_error": 1.2440235830416612e-16, + "plus_external_effective_rank": 138.38611141785276, + "plus_external_entropy": 0.9518949096507665, + "plus_target_effective_rank": 340.4867092249723, + "plus_target_entropy": 0.9673599160642077, + "plus_weight": 1324.150649860841, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "9ee5732e4e88e8a472738dc54a06fbcb6d8c0ae3a8be838556c82cb63d9a3184", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:28:37.045013+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "08aac381f8eb8a63f97f5327394ced74265cdfec70b9bf871b500422e47bf255", + "panel_kind": "sparse", + "panel_seed": 2713649627104869325, + "realization": 25, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "56923cbc9485c941dbed80d833c0a87cb029f898b4bc1462560fca4feee2a0a3", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07540622623544006, + "kernel_residual": 8.156817401406066e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 117.21575164032672, + "minus_external_entropy": 0.9325576748882821, + "minus_target_effective_rank": 251.0605478333982, + "minus_target_entropy": 0.9233183252538121, + "minus_weight": 1326.2213055599304, + "orthogonality_relative_error": 1.1556195881244176e-16, + "plus_external_effective_rank": 117.21575164032676, + "plus_external_entropy": 0.9325576748882821, + "plus_target_effective_rank": 251.06054783339835, + "plus_target_entropy": 0.9233183252538124, + "plus_weight": 1326.2213055599316, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 217, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 217, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "4e2f6a4b16ec0b5485ef78beb09239747a829b826747b9ef930a3500e3e4a905", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:34:03.642915+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "08aac381f8eb8a63f97f5327394ced74265cdfec70b9bf871b500422e47bf255", + "panel_kind": "isotropic", + "panel_seed": 2713649627104869325, + "realization": 25, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d2331ab4d8ab15e60384723ae245f55d83bdbb494107b57e74b67aa1eeba9a76", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07540622623544006, + "kernel_residual": 8.156817401406066e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 137.15013244512468, + "minus_external_entropy": 0.9507103423267039, + "minus_target_effective_rank": 339.62146736620724, + "minus_target_entropy": 0.9671131785712993, + "minus_weight": 1349.1355458371256, + "orthogonality_relative_error": 1.141797510807446e-16, + "plus_external_effective_rank": 137.15013244512483, + "plus_external_entropy": 0.9507103423267039, + "plus_target_effective_rank": 339.62146736620724, + "plus_target_entropy": 0.9671131785712993, + "plus_weight": 1349.1355458371247, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "5ebcc2a4c1b523728ed0da95647e81d74588878331e6cc5b2db4f30c83a3222c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:24:13.665464+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "7e1616b0e3da1d0fa1cb9353057ffe522b80b4701e78a97754ec253a14a06a1e", + "panel_kind": "sparse", + "panel_seed": 6696869146386789042, + "realization": 26, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6e4d6273e9d117293a52d662db1a8d4be1a58ff13e5fa51ebdaba93ca82918ac", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.09126187639198825, + "kernel_residual": 7.855084363665359e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 119.34992413393539, + "minus_external_entropy": 0.9341330325612808, + "minus_target_effective_rank": 264.4511622441917, + "minus_target_entropy": 0.9293800576202628, + "minus_weight": 1348.019926223613, + "orthogonality_relative_error": 1.215174733639883e-16, + "plus_external_effective_rank": 119.34992413393552, + "plus_external_entropy": 0.9341330325612808, + "plus_target_effective_rank": 264.4511622441915, + "plus_target_entropy": 0.929380057620263, + "plus_weight": 1348.0199262236117, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 217, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 217, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "83668eae88580721fb35813ee24a5c0eba88549d651f21cdb89330f402c8a245", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:29:32.476833+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "7e1616b0e3da1d0fa1cb9353057ffe522b80b4701e78a97754ec253a14a06a1e", + "panel_kind": "isotropic", + "panel_seed": 6696869146386789042, + "realization": 26, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bf8dfcacffa10cfd591bfd792d665d8d3fd2f07810c54de1f2a0bbd12119a532", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.09126187639198825, + "kernel_residual": 7.855084363665359e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 143.6526219834776, + "minus_external_entropy": 0.955481353058382, + "minus_target_effective_rank": 342.7544427797531, + "minus_target_entropy": 0.9678717572763755, + "minus_weight": 1292.5108860250693, + "orthogonality_relative_error": 1.1660794941220856e-16, + "plus_external_effective_rank": 143.65262198347764, + "plus_external_entropy": 0.955481353058382, + "plus_target_effective_rank": 342.754442779753, + "plus_target_entropy": 0.9678717572763755, + "plus_weight": 1292.5108860250696, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "18b2de993bebb1dcfd1f3569222f80fbadcb68092482cb72dc2283acdb993d16", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:33:36.925301+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "be8fe8d8d1d7ed1e21ca60628640e271595363f5fbb6a8847d66ed09b8b4373f", + "panel_kind": "sparse", + "panel_seed": 14075924685723924052, + "realization": 27, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "af8a39dfd1f86c57b116e5aa35b65f42fb55f6ba58e981b599b768d2d6af6e42", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.0854978787774885, + "kernel_residual": 8.020372784783748e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999997, + "minus_external_effective_rank": 132.00886658496376, + "minus_external_entropy": 0.945561531856031, + "minus_target_effective_rank": 269.2293248747585, + "minus_target_entropy": 0.9334024552402487, + "minus_weight": 1274.3660603574397, + "orthogonality_relative_error": 1.2234787872767885e-16, + "plus_external_effective_rank": 132.00886658496378, + "plus_external_entropy": 0.945561531856031, + "plus_target_effective_rank": 269.22932487475873, + "plus_target_entropy": 0.9334024552402482, + "plus_weight": 1274.36606035744, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "c6d9f518d8ed1b55d7d177beeb33e7c64f10b4add4135b33446f7fc4806977df", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:39:40.685330+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "be8fe8d8d1d7ed1e21ca60628640e271595363f5fbb6a8847d66ed09b8b4373f", + "panel_kind": "isotropic", + "panel_seed": 14075924685723924052, + "realization": 27, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c15879ff168e8382698c354dcdc8b74f008e56bffeb2a8429cbdfe6facc7f022", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.0854978787774885, + "kernel_residual": 8.020372784783748e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 140.53390942577187, + "minus_external_entropy": 0.9536414024087436, + "minus_target_effective_rank": 341.31641413271683, + "minus_target_entropy": 0.9675757887292135, + "minus_weight": 1301.8368666164479, + "orthogonality_relative_error": 1.2267287847087545e-16, + "plus_external_effective_rank": 140.53390942577187, + "plus_external_entropy": 0.9536414024087436, + "plus_target_effective_rank": 341.31641413271694, + "plus_target_entropy": 0.9675757887292135, + "plus_weight": 1301.8368666164477, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "44bc22b30a1c5950371cb66a14053b718ef28d309cbfd408a35d8f9ce3882ef5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:33:18.637478+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "7a2c6c7243a648a547264a2f94fc403cc8f69a8e3f023ca9c1b5e60096d0b969", + "panel_kind": "sparse", + "panel_seed": 2095679339274127036, + "realization": 28, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e32eef184438d9144a9cabfdf5280ecf6ae77d70998adf8368c2478d7d36d7d9", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07295765798124872, + "kernel_residual": 8.0322620064574e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 124.21514930315469, + "minus_external_entropy": 0.9385375616460826, + "minus_target_effective_rank": 275.8585405307181, + "minus_target_entropy": 0.9361476883270514, + "minus_weight": 1375.5540717408498, + "orthogonality_relative_error": 1.6250043885451872e-16, + "plus_external_effective_rank": 124.21514930315476, + "plus_external_entropy": 0.938537561646082, + "plus_target_effective_rank": 275.8585405307181, + "plus_target_entropy": 0.9361476883270513, + "plus_weight": 1375.5540717408498, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "b1f3d2a5a03a0841870184c542cc4b4850fff52e79c295af54bcb789b8ab31f2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:39:27.868021+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "7a2c6c7243a648a547264a2f94fc403cc8f69a8e3f023ca9c1b5e60096d0b969", + "panel_kind": "isotropic", + "panel_seed": 2095679339274127036, + "realization": 28, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e2bb8461a769d52d1391cf53893f1fd9bc7efa722fc3ccfb5550f039369eaa53", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07295765798124872, + "kernel_residual": 8.0322620064574e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 134.43571102518757, + "minus_external_entropy": 0.9485201945141329, + "minus_target_effective_rank": 336.64622092854455, + "minus_target_entropy": 0.966299468916031, + "minus_weight": 1367.0185532321475, + "orthogonality_relative_error": 1.5969304835018883e-16, + "plus_external_effective_rank": 134.43571102518752, + "plus_external_entropy": 0.9485201945141333, + "plus_target_effective_rank": 336.64622092854466, + "plus_target_entropy": 0.9662994689160309, + "plus_weight": 1367.0185532321475, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "3608404eda0d5c701dbe5571b333a6a4d9eaa75af256b6384c49293de6aabca0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:33:58.828016+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "e74b1a54365b12ee80605fb095cd89fe8c0dc420e9534f111245b982c9df81d1", + "panel_kind": "sparse", + "panel_seed": 6838818032672973510, + "realization": 29, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9b0e29a7ae30f6c50b42a6666b6825499a9b2e77a28a11d42c313a55e2bcc6f4", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08706194434549143, + "kernel_residual": 8.02312683784418e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 130.4607123479673, + "minus_external_entropy": 0.9448031721557956, + "minus_target_effective_rank": 288.3823650784148, + "minus_target_entropy": 0.9407448245047598, + "minus_weight": 1294.3667255488729, + "orthogonality_relative_error": 1.2307617766778772e-16, + "plus_external_effective_rank": 130.46071234796733, + "plus_external_entropy": 0.9448031721557955, + "plus_target_effective_rank": 288.3823650784147, + "plus_target_entropy": 0.9407448245047598, + "plus_weight": 1294.3667255488735, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "c1e145ec73c42c562ed78cc6f67cfb4874885024b0b4576caeb3ea086dedc142", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:40:39.101218+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "e74b1a54365b12ee80605fb095cd89fe8c0dc420e9534f111245b982c9df81d1", + "panel_kind": "isotropic", + "panel_seed": 6838818032672973510, + "realization": 29, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "88600cf7d8131a9b199ce27e9d7d54bd6e64cabd1ddbe2b83766a6a9216caff4", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.08706194434549143, + "kernel_residual": 8.02312683784418e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 142.0815107635344, + "minus_external_entropy": 0.9547491200503863, + "minus_target_effective_rank": 342.52976116805485, + "minus_target_entropy": 0.967910904691484, + "minus_weight": 1291.8076594473316, + "orthogonality_relative_error": 1.2012643604995663e-16, + "plus_external_effective_rank": 142.08151076353448, + "plus_external_entropy": 0.9547491200503863, + "plus_target_effective_rank": 342.52976116805496, + "plus_target_entropy": 0.967910904691484, + "plus_weight": 1291.8076594473307, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "43c4612c7a711e1d4a2d65c54f83d748694d29521313f0b58894a3b91a651119", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:38:20.765237+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "c703a38ccae89a75142ba079633a6cb5d00ed33a7fa2174fc5f82d3e3878713e", + "panel_kind": "sparse", + "panel_seed": 15972978933549361765, + "realization": 30, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b7cadf7c0e83f994d9beeb905eca741433c489e00b31a5391cddd5cd83386ba1", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07093825257558854, + "kernel_residual": 7.960392762224018e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 114.69174343348416, + "minus_external_entropy": 0.9308549278896325, + "minus_target_effective_rank": 246.78125120689208, + "minus_target_entropy": 0.9224541993726593, + "minus_weight": 1370.2530374870694, + "orthogonality_relative_error": 1.3091374900554985e-16, + "plus_external_effective_rank": 114.69174343348402, + "plus_external_entropy": 0.9308549278896325, + "plus_target_effective_rank": 246.7812512068921, + "plus_target_entropy": 0.9224541993726593, + "plus_weight": 1370.2530374870687, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 216, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 216, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "94ca17fb278280b1175df6ce5b3ec6a39d3944d16caa956c33d5f465cc94f533", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:47:10.895822+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "c703a38ccae89a75142ba079633a6cb5d00ed33a7fa2174fc5f82d3e3878713e", + "panel_kind": "isotropic", + "panel_seed": 15972978933549361765, + "realization": 30, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "085bd621574a13f99205db9b887699a04399b68f723c496716b7002b64b951ec", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07093825257558854, + "kernel_residual": 7.960392762224018e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 132.99494204651373, + "minus_external_entropy": 0.9478411255612622, + "minus_target_effective_rank": 334.6093377104909, + "minus_target_entropy": 0.9657207447981802, + "minus_weight": 1373.5146131484707, + "orthogonality_relative_error": 1.2953840931279844e-16, + "plus_external_effective_rank": 132.99494204651344, + "plus_external_entropy": 0.9478411255612622, + "plus_target_effective_rank": 334.60933771049076, + "plus_target_entropy": 0.96572074479818, + "plus_weight": 1373.5146131484707, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "4577a030e30e1f343e55bf7132aefe6a3428482d8a1f5b83eb9554e6257b8dfe", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:39:15.595160+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "abc8e692f2517a49f50cc7599d6498167a90adcc88640ec28e070aa7d8aae807", + "panel_kind": "sparse", + "panel_seed": 12977853151856891739, + "realization": 31, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "148c9456bc379e9fc650bc34b006de73c67722d6aaf67f48c944ad97aa3ea40a", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07237189615328127, + "kernel_residual": 8.089399154050559e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 114.0426146742449, + "minus_external_entropy": 0.9297648529706983, + "minus_target_effective_rank": 248.57852578449976, + "minus_target_entropy": 0.9243254422540983, + "minus_weight": 1382.4241225409996, + "orthogonality_relative_error": 1.5414668150970798e-16, + "plus_external_effective_rank": 114.04261467424496, + "plus_external_entropy": 0.9297648529706982, + "plus_target_effective_rank": 248.57852578449987, + "plus_target_entropy": 0.9243254422540983, + "plus_weight": 1382.4241225410017, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 218, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 218, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "d90418d03bad4d4e7b9cf39ac959bd7f8bd4aea5a57aa39c49f7fe9fc3093efa", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:47:38.388225+00:00", + "identity": { + "N": 12, + "charge": 6, + "kernel_identity_hash": "abc8e692f2517a49f50cc7599d6498167a90adcc88640ec28e070aa7d8aae807", + "panel_kind": "isotropic", + "panel_seed": 12977853151856891739, + "realization": 31, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6192318acf676a149d3474c8e726e413f0cb694dcc66466d7655c11a54728d79", + "kernel": { + "bps_rank": 486, + "complement_rank": 438, + "gap": 0.07237189615328127, + "kernel_residual": 8.089399154050559e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 132.82608917642514, + "minus_external_entropy": 0.948149567367993, + "minus_target_effective_rank": 334.41851788432047, + "minus_target_entropy": 0.9657249165280098, + "minus_weight": 1365.5648286738347, + "orthogonality_relative_error": 1.4710128214794314e-16, + "plus_external_effective_rank": 132.82608917642526, + "plus_external_entropy": 0.9481495673679927, + "plus_target_effective_rank": 334.4185178843205, + "plus_target_entropy": 0.9657249165280098, + "plus_weight": 1365.564828673835, + "target_rank": 486 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 219, + "minus_target_eigenvalues": 486, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 219, + "plus_target_eigenvalues": 486 + } + }, + { + "arrays_sha256": "153507beaad594892b5b1c42db0289ec9c3fc73bbb9c3cba92437ed8e8b01baf", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:47:01.744366+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "70891eed7fad68263b2e2274d7710d44f3eb26796184176de160e520b24f4799", + "panel_kind": "sparse", + "panel_seed": 15631887001993512644, + "realization": 0, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fc3672e5ed479dad6a05841f038459720de3ba08ee1a3325acfcf501e70b7496", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006616041874040371, + "kernel_residual": 6.694561635615992e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2033342276149118, + "minus_external_effective_rank": 41.43529905961096, + "minus_external_entropy": 0.9364715740447295, + "minus_target_effective_rank": 114.08664080684812, + "minus_target_entropy": 0.8999507435767755, + "minus_weight": 192.87604790194726, + "orthogonality_relative_error": 7.974403591889417e-16, + "plus_external_effective_rank": 126.17366461278593, + "plus_external_entropy": 0.8704746981260367, + "plus_target_effective_rank": 164.80253938191896, + "plus_target_entropy": 0.9587212565116581, + "plus_weight": 3397.564763172913, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 432, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "93b09b116b3d221b78e688c58a5096b4c632da1f1a099fc5291c0a21735a8411", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:49:25.756557+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "70891eed7fad68263b2e2274d7710d44f3eb26796184176de160e520b24f4799", + "panel_kind": "isotropic", + "panel_seed": 15631887001993512644, + "realization": 0, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a6e0c2b54891d454af513c569e39a14a8c7f6b27e0f53e945a23f3821b62601f", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006616041874040371, + "kernel_residual": 6.694561635615992e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1972286239326608, + "minus_external_effective_rank": 47.95997608366228, + "minus_external_entropy": 0.9570109198850729, + "minus_target_effective_rank": 151.79356774093128, + "minus_target_entropy": 0.9474507742070324, + "minus_weight": 191.93363364503978, + "orthogonality_relative_error": 8.077377173654504e-16, + "plus_external_effective_rank": 140.3890250346944, + "plus_external_entropy": 0.8760729946492711, + "plus_target_effective_rank": 195.36672304537217, + "plus_target_entropy": 0.9793115910770929, + "plus_weight": 3498.21420175049, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "86ad0627e9e987460606aa612d6d08066cd46cde31a02111b3d0ea8d8b477df1", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:39:18.729711+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "0fd875f82b53082501322d3fa6b16b59a0e59fdf3bc36a2c9480097ce8c844b7", + "panel_kind": "sparse", + "panel_seed": 4727431476315975753, + "realization": 1, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f2a7db4fb2bb5a1a49220c087c18467c08bd51824b499b7815e4c694826b2c99", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.0073857758417132015, + "kernel_residual": 6.374205079683002e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2096313070599114, + "minus_external_effective_rank": 46.23463295775105, + "minus_external_entropy": 0.9516164552281019, + "minus_target_effective_rank": 122.75322256754, + "minus_target_entropy": 0.9104479912845861, + "minus_weight": 187.32748814372277, + "orthogonality_relative_error": 5.793759054119534e-16, + "plus_external_effective_rank": 129.95450726792222, + "plus_external_entropy": 0.8726076629985419, + "plus_target_effective_rank": 164.0087037604301, + "plus_target_entropy": 0.9593519818681983, + "plus_weight": 3188.7584109457457, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 443, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "34218ed0af6d9ccbdc96378ed2b4863f6e5a7fe2c0e340004575669a7a2f01d5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:41:09.205709+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "0fd875f82b53082501322d3fa6b16b59a0e59fdf3bc36a2c9480097ce8c844b7", + "panel_kind": "isotropic", + "panel_seed": 4727431476315975753, + "realization": 1, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "74c5a26ba6ea7864d5c2af6b3136bad4f6302f781dac0fbb8ea369305d73eed5", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.0073857758417132015, + "kernel_residual": 6.374205079683002e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.21213842812664788, + "minus_external_effective_rank": 50.03516457045958, + "minus_external_entropy": 0.9629309882727717, + "minus_target_effective_rank": 153.65370201299248, + "minus_target_entropy": 0.9488998193138383, + "minus_weight": 188.25746687543526, + "orthogonality_relative_error": 5.794385958460229e-16, + "plus_external_effective_rank": 149.97237502978177, + "plus_external_entropy": 0.8836445475689206, + "plus_target_effective_rank": 194.52800592181094, + "plus_target_entropy": 0.9789775082366263, + "plus_weight": 3161.9864940725656, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "0e6da1e323d971d747a91f8ddf02073654d9bb61d923421adf42c4b5ec52ba8d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:33:59.393949+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "2e164ccd3d2dfe607cd61c5df886a87b385e2c63ecf1cf97c6f500abc49dd893", + "panel_kind": "sparse", + "panel_seed": 11418192461976715216, + "realization": 2, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ed829fdcbb6e00ec4c5c7956d4d16e787e4e4abc1d3e69b21dbe83bd522a5329", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.007212210233291425, + "kernel_residual": 6.501296698794235e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20668637984406532, + "minus_external_effective_rank": 40.59831116749109, + "minus_external_entropy": 0.9333318879435324, + "minus_target_effective_rank": 103.08506163633818, + "minus_target_entropy": 0.8953112622905787, + "minus_weight": 191.29639997647377, + "orthogonality_relative_error": 6.720913325220615e-16, + "plus_external_effective_rank": 116.2467303258603, + "plus_external_entropy": 0.8685689051826091, + "plus_target_effective_rank": 149.1167033430755, + "plus_target_entropy": 0.9460666141697857, + "plus_weight": 3308.5043506059415, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 65, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 397, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "cd16cbc38b5bfe8d14c06cbeb5b3b1616ae6169a8cac18bfa864e00d0f61c1a2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:35:37.460991+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "2e164ccd3d2dfe607cd61c5df886a87b385e2c63ecf1cf97c6f500abc49dd893", + "panel_kind": "isotropic", + "panel_seed": 11418192461976715216, + "realization": 2, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ed952c1fb9e78eb89ab9d8a83fb3689a860f128ba20c88e0c810dbd9984ef50a", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.007212210233291425, + "kernel_residual": 6.501296698794235e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.19936759620857247, + "minus_external_effective_rank": 48.979112402852174, + "minus_external_entropy": 0.9603223364228707, + "minus_target_effective_rank": 152.83618402713145, + "minus_target_entropy": 0.9483140966871543, + "minus_weight": 187.55011798791935, + "orthogonality_relative_error": 6.755575666995631e-16, + "plus_external_effective_rank": 140.9049042959567, + "plus_external_entropy": 0.8773473195501625, + "plus_target_effective_rank": 193.71941509306944, + "plus_target_entropy": 0.9786584251849448, + "plus_weight": 3377.3856128625953, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "f70c353b4f20d70dada6ad77edeca4629cc24da004afd7b27be98e04caa58765", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:45:10.661326+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "4b3b728a93f2ee1d0b7dae3f61427ea69341ab34c175cd0c26710cd37bbb613a", + "panel_kind": "sparse", + "panel_seed": 16748787446977000816, + "realization": 3, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5a910590bfb5ca8840a972ba8ba731c2601b93c144ccf98709ae13432cbb2cc7", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.005249347702882209, + "kernel_residual": 6.304791987859869e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.17553855152994122, + "minus_external_effective_rank": 43.169699364464826, + "minus_external_entropy": 0.9428034289453314, + "minus_target_effective_rank": 115.55063814752144, + "minus_target_entropy": 0.9012990379267523, + "minus_weight": 180.11763575795877, + "orthogonality_relative_error": 7.670552803422609e-16, + "plus_external_effective_rank": 112.44084887718837, + "plus_external_entropy": 0.8600234008318834, + "plus_target_effective_rank": 164.32081882739777, + "plus_target_entropy": 0.9598609898664843, + "plus_weight": 3735.4233432518845, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 443, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "f1c57ce870ff5c03a2f9b7daa7758a149c9507d79cfdf1fdb5f31aba5100091c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:47:13.229202+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "4b3b728a93f2ee1d0b7dae3f61427ea69341ab34c175cd0c26710cd37bbb613a", + "panel_kind": "isotropic", + "panel_seed": 16748787446977000816, + "realization": 3, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "da9efdc98b83f4b67babfb08cf46a5cc01a1d8045157601cf581682dee288fbc", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.005249347702882209, + "kernel_residual": 6.304791987859869e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.19750168843655974, + "minus_external_effective_rank": 48.965333487965495, + "minus_external_entropy": 0.9603486827822112, + "minus_target_effective_rank": 153.86003462292027, + "minus_target_entropy": 0.9492196308658671, + "minus_weight": 189.97813409807534, + "orthogonality_relative_error": 7.823460071369058e-16, + "plus_external_effective_rank": 128.52120347805194, + "plus_external_entropy": 0.8703231814439181, + "plus_target_effective_rank": 186.91635351884233, + "plus_target_entropy": 0.9754265030763967, + "plus_weight": 3457.2297673747325, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "7f85ebdc19ee0faa7329a968c2a2081a8417af8c3d4879a5d6b51814580dd580", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:44:57.255055+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "6522ff73f4582f6b58fd9781013f1c5c7b242072dc3566ef455f587232063a42", + "panel_kind": "sparse", + "panel_seed": 9376414662157622022, + "realization": 4, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8d62589235bc9847ccabbe2a19f5c80292bd0ae990a972652c30201980617b5f", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006452496433621143, + "kernel_residual": 6.501436896198523e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2100486169596852, + "minus_external_effective_rank": 48.14284490932568, + "minus_external_entropy": 0.9575372569237632, + "minus_target_effective_rank": 123.3167295121869, + "minus_target_entropy": 0.9127371932661474, + "minus_weight": 188.88204032888223, + "orthogonality_relative_error": 5.934661911311599e-16, + "plus_external_effective_rank": 137.9801836128142, + "plus_external_entropy": 0.8757372444129513, + "plus_target_effective_rank": 177.79106378378785, + "plus_target_entropy": 0.9683622951488461, + "plus_weight": 3208.035390342338, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 464, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "339b8507aa9dd69ad407a39371a74d61d2beba5e615bb216e1ec9a98aab2209d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:47:02.502483+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "6522ff73f4582f6b58fd9781013f1c5c7b242072dc3566ef455f587232063a42", + "panel_kind": "isotropic", + "panel_seed": 9376414662157622022, + "realization": 4, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d47cd680bbb58f66e30e66929628ae8e9c06e91822568b439a5ce9636e8c711c", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006452496433621143, + "kernel_residual": 6.501436896198523e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2031676820272235, + "minus_external_effective_rank": 49.71279289288948, + "minus_external_entropy": 0.961783509286124, + "minus_target_effective_rank": 155.3786403982344, + "minus_target_entropy": 0.9501265686227528, + "minus_weight": 191.7026052843206, + "orthogonality_relative_error": 6.079756627054616e-16, + "plus_external_effective_rank": 141.119368098427, + "plus_external_entropy": 0.8779072547197841, + "plus_target_effective_rank": 194.5153200460884, + "plus_target_entropy": 0.9789624828777033, + "plus_weight": 3379.995639466882, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "5b627275ad31edf84d75386dfaf47ec66328d7a1b93d1dbee05592f00f604758", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:46:11.450549+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "b26776f260f5538a408773f69918ff7d3ff20f740aed67fce0c4751ca662efa4", + "panel_kind": "sparse", + "panel_seed": 15498811526228393083, + "realization": 5, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d667e31f5fb6511cbb0ae974db7afda4d682b0449feeac2c27d83c1ed29f9f9f", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.0077997464803441436, + "kernel_residual": 6.503212657040547e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2181810711938892, + "minus_external_effective_rank": 47.41824417262693, + "minus_external_entropy": 0.9558178141860725, + "minus_target_effective_rank": 127.48758315301353, + "minus_target_entropy": 0.9167185060540303, + "minus_weight": 194.4860819609297, + "orthogonality_relative_error": 5.966050977617581e-16, + "plus_external_effective_rank": 140.70014715712915, + "plus_external_entropy": 0.8775327100997743, + "plus_target_effective_rank": 174.17008897584236, + "plus_target_entropy": 0.9656020018411446, + "plus_weight": 3164.6659763915504, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 461, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "30b1e9d1512e5086e0a55cd03ee4d7b7f00ab2e9bd9d31456d591124ff2194da", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:48:26.644410+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "b26776f260f5538a408773f69918ff7d3ff20f740aed67fce0c4751ca662efa4", + "panel_kind": "isotropic", + "panel_seed": 15498811526228393083, + "realization": 5, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7344a6546a21a07f950a03b459283ed324a25f457184b7739b3687b408079eec", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.0077997464803441436, + "kernel_residual": 6.503212657040547e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20323066373259344, + "minus_external_effective_rank": 48.20745275219851, + "minus_external_entropy": 0.9583223238787554, + "minus_target_effective_rank": 151.90065884498503, + "minus_target_entropy": 0.9476221963987276, + "minus_weight": 190.210403677798, + "orthogonality_relative_error": 6.11071866385408e-16, + "plus_external_effective_rank": 149.85372047904494, + "plus_external_entropy": 0.8825745082644012, + "plus_target_effective_rank": 195.77411746162645, + "plus_target_entropy": 0.9795225880282243, + "plus_weight": 3352.521656521055, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "5e07408900e277703dc0de865499d6a6836a703436310f3c3d68d639a8fbfa70", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:53:04.163338+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "d5713d4af90ff183709d00207ad68d23135ad80c5b98945daf4e568e45081593", + "panel_kind": "sparse", + "panel_seed": 5349224012762927503, + "realization": 6, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "da3574c157c5aa7fe7cbaf0812548768748e4a3cc537e7248a89bfd54433a539", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.00734274711506284, + "kernel_residual": 6.481715539233254e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.21405673581031465, + "minus_external_effective_rank": 43.69377358065396, + "minus_external_entropy": 0.9444151249592613, + "minus_target_effective_rank": 106.5502197274066, + "minus_target_entropy": 0.8948400121103116, + "minus_weight": 198.10102731274515, + "orthogonality_relative_error": 6.282701774087872e-16, + "plus_external_effective_rank": 130.19306450705437, + "plus_external_entropy": 0.873313222316441, + "plus_target_effective_rank": 158.64009218223927, + "plus_target_entropy": 0.9542066261032842, + "plus_weight": 3293.7246676131044, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 427, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "caf081e74bfe5fad3afc891e76b80734fac4038e98234a5f81bfa425e2f5906d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:55:16.681983+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "d5713d4af90ff183709d00207ad68d23135ad80c5b98945daf4e568e45081593", + "panel_kind": "isotropic", + "panel_seed": 5349224012762927503, + "realization": 6, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7103448c33cd76ce3e7c84a5aa8549891a98f178d9154bd87fad2abd3d404ae4", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.00734274711506284, + "kernel_residual": 6.481715539233254e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2003336481870218, + "minus_external_effective_rank": 47.93880170219477, + "minus_external_entropy": 0.958096073638727, + "minus_target_effective_rank": 151.97721587535884, + "minus_target_entropy": 0.94778780383398, + "minus_weight": 192.98700066481024, + "orthogonality_relative_error": 6.344138342769592e-16, + "plus_external_effective_rank": 146.16996288538348, + "plus_external_entropy": 0.8787440740309577, + "plus_target_effective_rank": 195.2163776663598, + "plus_target_entropy": 0.9790811838265363, + "plus_weight": 3456.562899231611, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "39d21984b7ad4e4d119a5f0bebb80b4ddd4227e6571b482612baba352b4ee554", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:53:54.042765+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "4ccb0c52075095195901c126e90a423b07ab70f942f243bbc425d0120d8e1907", + "panel_kind": "sparse", + "panel_seed": 7621037793786278096, + "realization": 7, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "779d9b98e96752d13da4e3af14a787ed6c3733bb8e09dbb0744d5b181444eac5", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.005269046367720884, + "kernel_residual": 6.591992810210017e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1861825384187246, + "minus_external_effective_rank": 45.04909822641747, + "minus_external_entropy": 0.9483827331049361, + "minus_target_effective_rank": 120.74351464351335, + "minus_target_entropy": 0.9087833464692107, + "minus_weight": 193.17467656903636, + "orthogonality_relative_error": 9.34749934706068e-16, + "plus_external_effective_rank": 119.81104205625927, + "plus_external_entropy": 0.8612445264426942, + "plus_target_effective_rank": 169.14688219349677, + "plus_target_entropy": 0.9623565740182572, + "plus_weight": 3753.9311497982717, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 455, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "dc21116070891d628aeac844b88398281de4b68147492f1b5fc4549d2685d64a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:56:14.872381+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "4ccb0c52075095195901c126e90a423b07ab70f942f243bbc425d0120d8e1907", + "panel_kind": "isotropic", + "panel_seed": 7621037793786278096, + "realization": 7, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f7d9b3854686d330145d1bc8b444cecf58c936cf6fdc4cb8d98d4e606e5871c1", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.005269046367720884, + "kernel_residual": 6.591992810210017e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.18595998000522268, + "minus_external_effective_rank": 46.346465193006175, + "minus_external_entropy": 0.9524308952829579, + "minus_target_effective_rank": 149.50662365233177, + "minus_target_entropy": 0.9456686480450073, + "minus_weight": 194.36184298158045, + "orthogonality_relative_error": 9.40675376527328e-16, + "plus_external_effective_rank": 128.94646901613405, + "plus_external_entropy": 0.8667487688682356, + "plus_target_effective_rank": 187.71082690358986, + "plus_target_entropy": 0.9753389093675047, + "plus_weight": 3782.0119506992733, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "b05f0a77318efb238f15b6befd0a21252259036b45593461eb81ae20da83121b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:51:18.779604+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "47760cf4fb56c1b5ed34efa62c2c06e684e2a64436510572d68d899f704cfaa4", + "panel_kind": "sparse", + "panel_seed": 10207669480241488558, + "realization": 8, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6fc689bd88ed3b28f661dbb25f99685e8a01412fa472edeb4625e3e4dc60033e", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.008555573274427493, + "kernel_residual": 6.435864274599172e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20853068633385377, + "minus_external_effective_rank": 43.74994119665787, + "minus_external_entropy": 0.944460319437005, + "minus_target_effective_rank": 118.22212491588665, + "minus_target_entropy": 0.9054061508572344, + "minus_weight": 190.36550589702912, + "orthogonality_relative_error": 5.056880302880065e-16, + "plus_external_effective_rank": 141.2321194670231, + "plus_external_entropy": 0.8788401384756215, + "plus_target_effective_rank": 173.3041568682813, + "plus_target_entropy": 0.9646054730129512, + "plus_weight": 3259.7103470267994, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 444, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "5759aa5cabfe5d44c21ac4b446691b079dc86dc8c9d88b6811b17f7f223f7d6a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:54:15.383727+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "47760cf4fb56c1b5ed34efa62c2c06e684e2a64436510572d68d899f704cfaa4", + "panel_kind": "isotropic", + "panel_seed": 10207669480241488558, + "realization": 8, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c6733c74f5654bb8e7f4de2c9aa190a35973f8315d74a2330d34fe6d312f590a", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.008555573274427493, + "kernel_residual": 6.435864274599172e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20621258300844064, + "minus_external_effective_rank": 48.654803721569515, + "minus_external_entropy": 0.9594547657251383, + "minus_target_effective_rank": 152.59593676907934, + "minus_target_entropy": 0.9481036307702047, + "minus_weight": 192.25601537709434, + "orthogonality_relative_error": 5.215332817771373e-16, + "plus_external_effective_rank": 154.45071490822704, + "plus_external_entropy": 0.8836536982697901, + "plus_target_effective_rank": 198.0834886636442, + "plus_target_entropy": 0.9805065002253848, + "plus_weight": 3333.6784646062915, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "c586be5f1bead8baefc4856437215af496575e0b767349dde69a7c1077b7d41e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:43:15.283110+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "757afb2376ebb1f44ec2e24b1fd2e46098841fe517b3a36a8e519b6bb9c2e016", + "panel_kind": "sparse", + "panel_seed": 8812651477963994628, + "realization": 9, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "430045c1e3eebcfefdbdd60e0470df2618fdc75a5dd2f71ade75a32d1a0dd04d", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.005022577451940529, + "kernel_residual": 6.540500478895242e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.15812615159441723, + "minus_external_effective_rank": 42.544930181800495, + "minus_external_entropy": 0.9409044717148863, + "minus_target_effective_rank": 115.66956138310377, + "minus_target_entropy": 0.9015929514703823, + "minus_weight": 187.75208762367902, + "orthogonality_relative_error": 8.972331581799752e-16, + "plus_external_effective_rank": 107.00946308520737, + "plus_external_entropy": 0.8474304233964659, + "plus_target_effective_rank": 163.3505365373871, + "plus_target_entropy": 0.9586442012155157, + "plus_weight": 4365.846931006931, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 449, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "86a96d3d82a201c5f27cfaf032485f234e369279de5dfb15af20415a93f3b912", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:45:06.691786+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "757afb2376ebb1f44ec2e24b1fd2e46098841fe517b3a36a8e519b6bb9c2e016", + "panel_kind": "isotropic", + "panel_seed": 8812651477963994628, + "realization": 9, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "173e2e9c1fd33589a83074cf60afd14a64946f4830c6aeaf3e1940678dbae322", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.005022577451940529, + "kernel_residual": 6.540500478895242e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.18338512494976447, + "minus_external_effective_rank": 46.80516682442698, + "minus_external_entropy": 0.9548033766327675, + "minus_target_effective_rank": 151.07338190442667, + "minus_target_entropy": 0.9470132473380451, + "minus_weight": 194.7041952229662, + "orthogonality_relative_error": 8.863055858469714e-16, + "plus_external_effective_rank": 128.78735070409175, + "plus_external_entropy": 0.8650530533410651, + "plus_target_effective_rank": 187.9633646934174, + "plus_target_entropy": 0.9754384754015094, + "plus_weight": 3847.6306509308583, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "c666aed371b80f519f72a070fd4785c2057837d4a2ba58567d171ecd347868b4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:37:27.314481+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "9bd5db76c272a0f1fa9b1776a26c2dccc0663639dec9b8b09189a457f4b9bc9c", + "panel_kind": "sparse", + "panel_seed": 7290277248299451132, + "realization": 10, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4885fa53d9c3b66fc4a62a8e43357f7606a6c68ab3de8cf33c4415dee2fff5eb", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.008326381820279586, + "kernel_residual": 6.479201247526205e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.23716213573247596, + "minus_external_effective_rank": 48.567445926626036, + "minus_external_entropy": 0.95900367138306, + "minus_target_effective_rank": 121.49989467652162, + "minus_target_entropy": 0.9099932516243514, + "minus_weight": 191.57981672280567, + "orthogonality_relative_error": 5.810336534753719e-16, + "plus_external_effective_rank": 146.87096916327923, + "plus_external_entropy": 0.8830048883335144, + "plus_target_effective_rank": 169.32066639592753, + "plus_target_entropy": 0.9619548809835217, + "plus_weight": 2835.0986001665683, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 452, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "dfbbb384ce52053112e76df836e396e6eef75bfb33edce285ebbe7cb9521c424", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:39:11.510901+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "9bd5db76c272a0f1fa9b1776a26c2dccc0663639dec9b8b09189a457f4b9bc9c", + "panel_kind": "isotropic", + "panel_seed": 7290277248299451132, + "realization": 10, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0c0302b102fb03ea5351c09f42f134c7a19c095b1f5902262cbfe0a0b0567e07", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.008326381820279586, + "kernel_residual": 6.479201247526205e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20629116150554416, + "minus_external_effective_rank": 49.633209442194286, + "minus_external_entropy": 0.961677186281913, + "minus_target_effective_rank": 154.4675069996308, + "minus_target_entropy": 0.9494452829309098, + "minus_weight": 189.3674668114268, + "orthogonality_relative_error": 5.947289327746816e-16, + "plus_external_effective_rank": 150.4317109935695, + "plus_external_entropy": 0.8822497857692123, + "plus_target_effective_rank": 196.67400162709046, + "plus_target_entropy": 0.979906483917117, + "plus_weight": 3282.1877959544813, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "ca5ebe7089a689981c75553f856e6a04c81924d3820804d220386ea017747528", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:49:20.049394+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "ac23668e71cc90afc0bd4499533898bd7cdbf9daee514bf0e8155e6281269dfc", + "panel_kind": "sparse", + "panel_seed": 7550589346728886770, + "realization": 11, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "540a204ed378c514db13c5e99225584611e46997eb1ea16a93575cf3db2685e5", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006332018394019176, + "kernel_residual": 6.473110977527562e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20456324933591932, + "minus_external_effective_rank": 42.771413447988934, + "minus_external_entropy": 0.9408200224511512, + "minus_target_effective_rank": 110.56047410624574, + "minus_target_entropy": 0.8959119672330925, + "minus_weight": 194.06169243520844, + "orthogonality_relative_error": 6.258056215072958e-16, + "plus_external_effective_rank": 129.2461694405374, + "plus_external_entropy": 0.8711356930056396, + "plus_target_effective_rank": 162.84336365402459, + "plus_target_entropy": 0.9572110213610373, + "plus_weight": 3395.4393695981203, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 434, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "0cff8daa1a2aa9454e275698c2782b8afd4ca12264a745c58ea3c2003abecc8a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:51:36.838007+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "ac23668e71cc90afc0bd4499533898bd7cdbf9daee514bf0e8155e6281269dfc", + "panel_kind": "isotropic", + "panel_seed": 7550589346728886770, + "realization": 11, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8908712c6e1527787c9789de1fc1986c732f8a44d8c8b1e0a9a417bbf11be9d6", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006332018394019176, + "kernel_residual": 6.473110977527562e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.19240419369730047, + "minus_external_effective_rank": 48.23692893165746, + "minus_external_entropy": 0.9577450535156857, + "minus_target_effective_rank": 152.26927699917852, + "minus_target_entropy": 0.9478478434319992, + "minus_weight": 189.48280793522878, + "orthogonality_relative_error": 6.703945845567838e-16, + "plus_external_effective_rank": 137.8296300781422, + "plus_external_entropy": 0.8735394185345897, + "plus_target_effective_rank": 192.8780548780957, + "plus_target_entropy": 0.978082476940985, + "plus_weight": 3550.186841455188, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "083088397e43f2f92323c6b639cb7d809470a8e1272188fcf405e2572839230e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:49:17.483796+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "0b7999eff7a1ef7235624f6720d1d7f80f56baa1c85b7312c0e7eb1b970a15e6", + "panel_kind": "sparse", + "panel_seed": 14643307009578063006, + "realization": 12, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e4de3ccb12a83b89dcdf201ca8680b7268bce9c50cdbc596080e02cbb0fe1fcd", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.008136340219212092, + "kernel_residual": 6.4506748228574675e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2016879942466414, + "minus_external_effective_rank": 47.23409090886798, + "minus_external_entropy": 0.9543970268519509, + "minus_target_effective_rank": 128.93136867940777, + "minus_target_entropy": 0.917140085055767, + "minus_weight": 185.88108309718433, + "orthogonality_relative_error": 5.67838256717831e-16, + "plus_external_effective_rank": 147.0462706317194, + "plus_external_entropy": 0.8795348833436466, + "plus_target_effective_rank": 182.838372924777, + "plus_target_entropy": 0.9710536450220143, + "plus_weight": 3304.288831754008, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 464, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "95769947a9d14a2df02b979ebc2cf06f5b218448151cdf03cbb0ffa9309fa7ad", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:51:38.886390+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "0b7999eff7a1ef7235624f6720d1d7f80f56baa1c85b7312c0e7eb1b970a15e6", + "panel_kind": "isotropic", + "panel_seed": 14643307009578063006, + "realization": 12, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f3926a12ed5f808166f116875dfe7d6717a3a391821f8f6e4d652acf297df344", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.008136340219212092, + "kernel_residual": 6.4506748228574675e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20656133333629448, + "minus_external_effective_rank": 49.51267050871072, + "minus_external_entropy": 0.9616190939202757, + "minus_target_effective_rank": 153.01244049174377, + "minus_target_entropy": 0.9484470556428749, + "minus_weight": 189.622018098213, + "orthogonality_relative_error": 5.776079216164744e-16, + "plus_external_effective_rank": 153.6308588463084, + "plus_external_entropy": 0.8833696213829744, + "plus_target_effective_rank": 198.21183367935012, + "plus_target_entropy": 0.980586315959961, + "plus_weight": 3281.774640064185, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "f9b04e99bff4a162c9cba92a5b79b583a1ef494bbf7f848a19750d3a90bbaf39", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:50:48.623929+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "8867f93db056e760c280408589f191827bfc116d31da48a410b66c53e1fcf42e", + "panel_kind": "sparse", + "panel_seed": 9331663878100054652, + "realization": 13, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4ee5745643215510e022bf384452ac803b99f9e2fd79cde6363aee13361c1b41", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006602095161122826, + "kernel_residual": 6.5509502827142405e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2012582555416409, + "minus_external_effective_rank": 43.7318119781423, + "minus_external_entropy": 0.9441737020765788, + "minus_target_effective_rank": 116.85497096207109, + "minus_target_entropy": 0.9038677726271857, + "minus_weight": 190.07874144934576, + "orthogonality_relative_error": 6.5539492956567e-16, + "plus_external_effective_rank": 131.67006478612618, + "plus_external_entropy": 0.872133517452915, + "plus_target_effective_rank": 171.16821787087318, + "plus_target_entropy": 0.9631694525596121, + "plus_weight": 3386.9828193994636, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 442, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "122ef66f7265967a425d88982e64ac8f9ad6da8551c90d532c0c44fbb9c6122c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:52:53.421116+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "8867f93db056e760c280408589f191827bfc116d31da48a410b66c53e1fcf42e", + "panel_kind": "isotropic", + "panel_seed": 9331663878100054652, + "realization": 13, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d7e194d8de16b31f775787e99e34982f81fba3fa35dea8be57450be4925e04a1", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006602095161122826, + "kernel_residual": 6.5509502827142405e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.19328980508127466, + "minus_external_effective_rank": 47.01586110114129, + "minus_external_entropy": 0.9549481097110137, + "minus_target_effective_rank": 151.6762452126343, + "minus_target_entropy": 0.9475119529272698, + "minus_weight": 192.4562695910397, + "orthogonality_relative_error": 6.588243856002998e-16, + "plus_external_effective_rank": 142.3684880783273, + "plus_external_entropy": 0.8759814060500732, + "plus_target_effective_rank": 195.15486009704452, + "plus_target_entropy": 0.9791171917494094, + "plus_weight": 3587.5134782882537, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "1c2f6f3e236799cc7ea9fd003f12c0f0b8a69988ff4b066c5f01ba403de31420", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:57:37.987270+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "a0ba15c52f3bbf394357d129c205c7f9ef75e91d810c208c7fdba9090d521eda", + "panel_kind": "sparse", + "panel_seed": 6989209858264986851, + "realization": 14, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "150ee3d1864dd6b6af3d36b1621c7aa0dca024b2aba1c0d4267426fcef309dec", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.007752263597437619, + "kernel_residual": 6.513969490134479e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20621522455114769, + "minus_external_effective_rank": 41.78521556680085, + "minus_external_entropy": 0.9358796557124903, + "minus_target_effective_rank": 103.7451390302083, + "minus_target_entropy": 0.8917833553669198, + "minus_weight": 190.22530456733514, + "orthogonality_relative_error": 6.227786487911321e-16, + "plus_external_effective_rank": 126.93848367216776, + "plus_external_entropy": 0.8744869975371932, + "plus_target_effective_rank": 157.35838061515562, + "plus_target_entropy": 0.9528090203498832, + "plus_weight": 3298.4189467018095, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 414, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "9d35748425c8a1c8617c841f173d739ec57ca92d309f99771860f16d03707e6c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:59:45.003725+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "a0ba15c52f3bbf394357d129c205c7f9ef75e91d810c208c7fdba9090d521eda", + "panel_kind": "isotropic", + "panel_seed": 6989209858264986851, + "realization": 14, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d00694cde64d5f44109b52b4ed7c04c19b2efc4e7705a4e96c0c869f6a395aa8", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.007752263597437619, + "kernel_residual": 6.513969490134479e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2035223616738015, + "minus_external_effective_rank": 48.49172582365297, + "minus_external_entropy": 0.958790195316608, + "minus_target_effective_rank": 152.7796478350749, + "minus_target_entropy": 0.9480778297268306, + "minus_weight": 191.9658950419501, + "orthogonality_relative_error": 6.356573031760317e-16, + "plus_external_effective_rank": 144.70303733968947, + "plus_external_entropy": 0.8793865087862399, + "plus_target_effective_rank": 195.69152446376754, + "plus_target_entropy": 0.9794245070286043, + "plus_weight": 3378.030040177153, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "20d0a93da298bf686491045e810cd28dd7cd905a20ba15399d406965a5e03a9a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:59:08.123000+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "b776aedf1cdbbd709852ab3964a0b10708722d82ccab2af02f15fc5673ff0f32", + "panel_kind": "sparse", + "panel_seed": 17079030507940901927, + "realization": 15, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "707ef40f65f51f91f54404eba8f0898d32d36a92d298ca4928e66f106a4c9243", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.009093579258611692, + "kernel_residual": 6.466670381558055e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1924155136574385, + "minus_external_effective_rank": 45.657483656194984, + "minus_external_entropy": 0.9497873550149839, + "minus_target_effective_rank": 122.114143007069, + "minus_target_entropy": 0.9088283638296702, + "minus_weight": 186.2626276085653, + "orthogonality_relative_error": 5.928920305444555e-16, + "plus_external_effective_rank": 131.34180811160476, + "plus_external_entropy": 0.8717198757041149, + "plus_target_effective_rank": 176.31988862132204, + "plus_target_entropy": 0.9663736432807831, + "plus_weight": 3489.6244523371724, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 451, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "080514f36eebff73cc2ae3259c259cfcf85ea67cf23faf922b77255d0f9d09b8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:01:21.683510+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "b776aedf1cdbbd709852ab3964a0b10708722d82ccab2af02f15fc5673ff0f32", + "panel_kind": "isotropic", + "panel_seed": 17079030507940901927, + "realization": 15, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "44f7c07d7c4e2f5d1c85472b613253bc10c89d4e16a2c3cb7c6c1701ee67702e", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.009093579258611692, + "kernel_residual": 6.466670381558055e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20580149272902895, + "minus_external_effective_rank": 49.47780232848439, + "minus_external_entropy": 0.9613543173950251, + "minus_target_effective_rank": 153.9509640181994, + "minus_target_entropy": 0.9490889857557249, + "minus_weight": 188.02510829860455, + "orthogonality_relative_error": 5.727628670399544e-16, + "plus_external_effective_rank": 157.04050820959154, + "plus_external_entropy": 0.8860863517190289, + "plus_target_effective_rank": 199.96397428548238, + "plus_target_entropy": 0.9814738827831248, + "plus_weight": 3267.625023689913, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "233799ec2ec73e3e6c8db9536889cbdbd10390dfdc66d46cb9e58bb9a4232928", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:57:00.038973+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "624e5eea600d8a20b0113052340ee81bf247bc693b8cb36a68373d01e3c14d20", + "panel_kind": "sparse", + "panel_seed": 14641610919764975073, + "realization": 16, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fd90b79b9159c6d74d6b332c5d112c670ce5e64483663bf8f3393d3c64db829b", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.007692853968150895, + "kernel_residual": 6.525819957208146e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.21012311781627385, + "minus_external_effective_rank": 46.207126190097334, + "minus_external_entropy": 0.9513018475342329, + "minus_target_effective_rank": 125.08975304234178, + "minus_target_entropy": 0.9131531088140015, + "minus_weight": 193.2464478004514, + "orthogonality_relative_error": 5.931741500636781e-16, + "plus_external_effective_rank": 140.1446617544098, + "plus_external_entropy": 0.8765489558171626, + "plus_target_effective_rank": 177.94112896516125, + "plus_target_entropy": 0.9679215077920887, + "plus_weight": 3280.852612138801, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 459, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "15cb64281852a49779bc0e6b634cec9b6b31ce2115308f4d530dbb50829c08fb", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:59:49.636301+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "624e5eea600d8a20b0113052340ee81bf247bc693b8cb36a68373d01e3c14d20", + "panel_kind": "isotropic", + "panel_seed": 14641610919764975073, + "realization": 16, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "007ae70a54c420b58d8e72e289afd7680a95cd22754b3fda9116af359f862a7f", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.007692853968150895, + "kernel_residual": 6.525819957208146e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20772636909456577, + "minus_external_effective_rank": 48.88262411309887, + "minus_external_entropy": 0.9596663244319291, + "minus_target_effective_rank": 152.91146946063583, + "minus_target_entropy": 0.9483220411127571, + "minus_weight": 190.2295528890516, + "orthogonality_relative_error": 6.024813574567966e-16, + "plus_external_effective_rank": 149.32412259819935, + "plus_external_entropy": 0.8822496545428202, + "plus_target_effective_rank": 194.378601974857, + "plus_target_entropy": 0.9787608557514444, + "plus_weight": 3271.5592564812587, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "150dbb60dff6617b79ccca4aa45bba0504371d6899458ce420f5e991170d28df", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:47:15.566041+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "a9a447c48563425606d96dfa0edd4b518f9815114728e2b0c9bfa01d606124e6", + "panel_kind": "sparse", + "panel_seed": 200520273070480407, + "realization": 17, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a5ed6ce71b7ad2103b59e01751535dbe1737d2d81b3ca251f3a29cb89dc117ca", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006141623498671435, + "kernel_residual": 6.5761372479905876e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20340714266706764, + "minus_external_effective_rank": 42.27724389818367, + "minus_external_entropy": 0.938459177033877, + "minus_target_effective_rank": 106.19228635343532, + "minus_target_entropy": 0.8950739136166747, + "minus_weight": 194.84691313064224, + "orthogonality_relative_error": 6.621554902823808e-16, + "plus_external_effective_rank": 126.60056174556013, + "plus_external_entropy": 0.8708471886214406, + "plus_target_effective_rank": 161.1187623328052, + "plus_target_entropy": 0.9558926831982071, + "plus_weight": 3430.9036303322973, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 422, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "63174b576f441b5f835681a6445492e5f4c94708f428137f26d9eef4277b71d6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:49:09.374168+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "a9a447c48563425606d96dfa0edd4b518f9815114728e2b0c9bfa01d606124e6", + "panel_kind": "isotropic", + "panel_seed": 200520273070480407, + "realization": 17, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cf1c537c35241dac62d4016a4094e4b780cf9b9064442dc7916aa884d8d2a509", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006141623498671435, + "kernel_residual": 6.5761372479905876e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20254856622534323, + "minus_external_effective_rank": 47.98223201657718, + "minus_external_entropy": 0.9577445008396096, + "minus_target_effective_rank": 152.52230995478521, + "minus_target_entropy": 0.9480022763978452, + "minus_weight": 196.48652510070582, + "orthogonality_relative_error": 6.829383147232572e-16, + "plus_external_effective_rank": 141.8933435004249, + "plus_external_entropy": 0.877083559613682, + "plus_target_effective_rank": 192.37622927830913, + "plus_target_entropy": 0.9778552761893252, + "plus_weight": 3476.2055773255497, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "7e59961e926da90859bf526ffd0addf59ea3e896f61bccb57ffca1541deeba7a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:40:50.988914+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "f30f375a5c25698f2b805f9b02d7d18082baf0e9f8d1f44b5c43796d6b1d6ea9", + "panel_kind": "sparse", + "panel_seed": 9166056732133401218, + "realization": 18, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7926dbc88686a18e4d7a21bea0a31034ba03ac7e543607968d1a355dd3f4c3fe", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.0064770869788412806, + "kernel_residual": 6.472828588883931e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.17184565602598664, + "minus_external_effective_rank": 39.66062701227077, + "minus_external_entropy": 0.9281152393712907, + "minus_target_effective_rank": 100.98561763599453, + "minus_target_entropy": 0.8914507388484909, + "minus_weight": 184.85336261696483, + "orthogonality_relative_error": 6.947154995692619e-16, + "plus_external_effective_rank": 111.92521904466983, + "plus_external_entropy": 0.8592404077464426, + "plus_target_effective_rank": 154.33559909330538, + "plus_target_entropy": 0.950608570155999, + "plus_weight": 3924.362433345252, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 412, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "d0a6ec5aca73dd4c4a3c76049f44c40d1f9b06c77a01cc72e259adfd5c8237e2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:42:29.720240+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "f30f375a5c25698f2b805f9b02d7d18082baf0e9f8d1f44b5c43796d6b1d6ea9", + "panel_kind": "isotropic", + "panel_seed": 9166056732133401218, + "realization": 18, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f00e9f390880d2adc15650e56e7baaeb24cc7f3731358bc8e34660c5aec050a3", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.0064770869788412806, + "kernel_residual": 6.472828588883931e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1993934223871628, + "minus_external_effective_rank": 47.96056256877476, + "minus_external_entropy": 0.9577160860166704, + "minus_target_effective_rank": 151.3890414028215, + "minus_target_entropy": 0.9472539947745157, + "minus_weight": 190.61451520230491, + "orthogonality_relative_error": 6.636413007365811e-16, + "plus_external_effective_rank": 144.22085070235048, + "plus_external_entropy": 0.8785630930707985, + "plus_target_effective_rank": 193.0684897197739, + "plus_target_entropy": 0.9781560978907207, + "plus_weight": 3432.0721207796455, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "f25ad028cf4268497eaa33dde76dc22100460bedc568528e22f4d77a8a0ce28d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:53:40.975948+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "097204d09a2c3e1f2bd23f8b654972b2114592665490ae1f5f725d2061869250", + "panel_kind": "sparse", + "panel_seed": 5783053080661066463, + "realization": 19, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ab24acd47f741cf7a2e9b0d677d5f65af47adf7aff60993c42a2f0f8bc32a782", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.005372676538093635, + "kernel_residual": 6.50778027082447e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20112702923096717, + "minus_external_effective_rank": 43.941717578214735, + "minus_external_entropy": 0.9445876300262137, + "minus_target_effective_rank": 119.1673958976603, + "minus_target_entropy": 0.905194822394752, + "minus_weight": 187.2888890064205, + "orthogonality_relative_error": 8.368291089294151e-16, + "plus_external_effective_rank": 118.1056775248698, + "plus_external_entropy": 0.8660693356277479, + "plus_target_effective_rank": 163.46282435500203, + "plus_target_entropy": 0.9582436704075166, + "plus_weight": 3339.70722223736, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 434, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "19318c62400d4c19b074010d80545a9267132b5e3bdf0723ec75a7f5e4ca89c3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:55:49.828466+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "097204d09a2c3e1f2bd23f8b654972b2114592665490ae1f5f725d2061869250", + "panel_kind": "isotropic", + "panel_seed": 5783053080661066463, + "realization": 19, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "59f15a3dade4e01308061b81645eabfddb59fd899140649ae13bb3fc2dad2d5c", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.005372676538093635, + "kernel_residual": 6.50778027082447e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1919341143080567, + "minus_external_effective_rank": 48.01382131694328, + "minus_external_entropy": 0.9572343962222305, + "minus_target_effective_rank": 152.61274066227372, + "minus_target_entropy": 0.9480912668220023, + "minus_weight": 192.49973917182385, + "orthogonality_relative_error": 8.277791883664625e-16, + "plus_external_effective_rank": 129.93325809570774, + "plus_external_entropy": 0.8683049690937, + "plus_target_effective_rank": 186.62472287087968, + "plus_target_entropy": 0.9748555032031411, + "plus_weight": 3616.5421252445126, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "91c76b884a2fa46e09c1fd78cb02b8785ccc2a5570b73806bda2b332a6e8de07", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:53:46.479158+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "1ee768e5be085a0d0dd4a3efdeab74552afaba3e18e5ec78d45cf42f13056b41", + "panel_kind": "sparse", + "panel_seed": 9732372325394799332, + "realization": 20, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "588f765386bb4f6b66bea89b31a815c0917ecb481906cf1933aa9742b92d68cc", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.009214432468131358, + "kernel_residual": 6.5436922756907085e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.18857887053246414, + "minus_external_effective_rank": 45.948930137193535, + "minus_external_entropy": 0.951311909003576, + "minus_target_effective_rank": 126.41106036017342, + "minus_target_entropy": 0.9141112273965918, + "minus_weight": 185.11548506163427, + "orthogonality_relative_error": 5.342487140012083e-16, + "plus_external_effective_rank": 132.96509316679087, + "plus_external_entropy": 0.8701182502907151, + "plus_target_effective_rank": 180.56877242929608, + "plus_target_entropy": 0.9694722582262795, + "plus_weight": 3546.6441577936675, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 460, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "928c5e1321f24f0424eecc1eb051879ca47d323f85ca483f4cb10ffc1f69b886", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:56:00.348198+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "1ee768e5be085a0d0dd4a3efdeab74552afaba3e18e5ec78d45cf42f13056b41", + "panel_kind": "isotropic", + "panel_seed": 9732372325394799332, + "realization": 20, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f089921e631ec04e5dc16552acb69f9b3208d0d1cb4e3f953bf1f2f286fb8b15", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.009214432468131358, + "kernel_residual": 6.5436922756907085e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2078991726759237, + "minus_external_effective_rank": 49.62464741824351, + "minus_external_entropy": 0.9619325799209749, + "minus_target_effective_rank": 154.38251464170725, + "minus_target_entropy": 0.9494723100552326, + "minus_weight": 192.8725596884337, + "orthogonality_relative_error": 5.274518142573688e-16, + "plus_external_effective_rank": 152.8474334616751, + "plus_external_entropy": 0.8835165338555407, + "plus_target_effective_rank": 198.52545576362877, + "plus_target_entropy": 0.9807879783975665, + "plus_weight": 3313.9160702437957, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "1378c49bf1d9a178a3c0cd9e4addbc67cf850a7cf30aa9e1b3218ddec313ecc5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:55:03.175642+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "8370dee54c79345073faa1bfdebe41e4ebfe5f55d1e7dca843fd6022399ff3cc", + "panel_kind": "sparse", + "panel_seed": 6083733690532228404, + "realization": 21, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "69519e341ebf73ef7266d441abe8446851234587ea1f146920ce2459af4d51f1", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006569824611009816, + "kernel_residual": 6.49206510434588e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.23303829189838435, + "minus_external_effective_rank": 44.62354541519158, + "minus_external_entropy": 0.9468131791605112, + "minus_target_effective_rank": 114.42938836963523, + "minus_target_entropy": 0.8998241448577345, + "minus_weight": 202.24343014545693, + "orthogonality_relative_error": 6.419060598098757e-16, + "plus_external_effective_rank": 135.6191959626777, + "plus_external_entropy": 0.8781137922642004, + "plus_target_effective_rank": 162.01141987859347, + "plus_target_entropy": 0.9563371178407993, + "plus_weight": 3053.5377662479937, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 427, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "5a9be60de566ae84bf9102b7f28e96718a59a20998663b6094e4dc5d454b24db", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:57:16.672068+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "8370dee54c79345073faa1bfdebe41e4ebfe5f55d1e7dca843fd6022399ff3cc", + "panel_kind": "isotropic", + "panel_seed": 6083733690532228404, + "realization": 21, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4b755325f101bcf4af18371d29710dfb8b6ab8bbc3cffe921b117d2ab432f26e", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006569824611009816, + "kernel_residual": 6.49206510434588e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20005696782792767, + "minus_external_effective_rank": 47.798345223572966, + "minus_external_entropy": 0.9567974356362451, + "minus_target_effective_rank": 152.24714451791755, + "minus_target_entropy": 0.9478290406441767, + "minus_weight": 190.92492606527512, + "orthogonality_relative_error": 6.637783425287946e-16, + "plus_external_effective_rank": 145.88709132777677, + "plus_external_entropy": 0.8791356230625886, + "plus_target_effective_rank": 195.09791242756302, + "plus_target_entropy": 0.9791330879795043, + "plus_weight": 3424.9180511053364, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "58acce7a2bd8a415d34a1f40832469d18e62c08596bc946dcb441c870b0e95a4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:02:14.191403+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "98992520596d21c4138373e0a99a5a51681bc618215093b3b401dae958b54fdf", + "panel_kind": "sparse", + "panel_seed": 6446337212763188697, + "realization": 22, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b5140d774a957da460e62423db35b323acb116b68def381dffc5bd3c9071163c", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.007659858571647801, + "kernel_residual": 6.479911031294551e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.21160422012444383, + "minus_external_effective_rank": 45.47842596066358, + "minus_external_entropy": 0.9498106065443166, + "minus_target_effective_rank": 116.11588153314496, + "minus_target_entropy": 0.9052293397594361, + "minus_weight": 191.9442563775432, + "orthogonality_relative_error": 5.990212792149173e-16, + "plus_external_effective_rank": 137.02826326660679, + "plus_external_entropy": 0.8742651993520208, + "plus_target_effective_rank": 167.89629453295512, + "plus_target_entropy": 0.9620631905640887, + "plus_weight": 3233.0794594049303, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 458, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "22d2a7d9a1d3817bf5c4077ad5e0ff0e4b50f9984308b8ec53800608be143c39", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:04:45.863310+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "98992520596d21c4138373e0a99a5a51681bc618215093b3b401dae958b54fdf", + "panel_kind": "isotropic", + "panel_seed": 6446337212763188697, + "realization": 22, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5b303ce5d7b5058eaddf9b4228c9bce34623aa1ba72298995786058f3c7e048c", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.007659858571647801, + "kernel_residual": 6.479911031294551e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20937952041967559, + "minus_external_effective_rank": 49.75218196857757, + "minus_external_entropy": 0.9619326816602959, + "minus_target_effective_rank": 154.46181147420592, + "minus_target_entropy": 0.949618110716708, + "minus_weight": 188.94357089036095, + "orthogonality_relative_error": 6.04182892394125e-16, + "plus_external_effective_rank": 151.58911024244924, + "plus_external_entropy": 0.8843332900901129, + "plus_target_effective_rank": 198.09834790128946, + "plus_target_entropy": 0.9806739187225856, + "plus_weight": 3220.6184208554578, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "10692ae4cbe1bb6931d7547d1e661eb730282a7e4889eb8cb0a0eeab9961263a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:03:42.706235+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "0e2a036b9abce55ebb25b779e4342472e2af2dbce4fb8cd8c0db3b752742c767", + "panel_kind": "sparse", + "panel_seed": 1254894322704354552, + "realization": 23, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "457f4f272fecd028232c12b5040db7d00ca7844ce83cf712788207fc51be8725", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006787450541402254, + "kernel_residual": 6.601957032696207e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1812750240307343, + "minus_external_effective_rank": 43.02128632604354, + "minus_external_entropy": 0.9407552707292915, + "minus_target_effective_rank": 119.43297775857093, + "minus_target_entropy": 0.9055241942272154, + "minus_weight": 186.72858856846605, + "orthogonality_relative_error": 7.4356619988784485e-16, + "plus_external_effective_rank": 121.56051438130386, + "plus_external_entropy": 0.8636961662037415, + "plus_target_effective_rank": 169.0737780866768, + "plus_target_entropy": 0.9622398617139007, + "plus_weight": 3737.55175088509, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 437, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "3924cf42354bfbc46e5c0f5dd78ec03ceff0c29bf89c53de729450d5468b1645", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:06:21.932566+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "0e2a036b9abce55ebb25b779e4342472e2af2dbce4fb8cd8c0db3b752742c767", + "panel_kind": "isotropic", + "panel_seed": 1254894322704354552, + "realization": 23, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9b50030f3a484d5a7b7a86ed77ffe1c598b9829ca6b2d07adecaaa6214a234e7", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006787450541402254, + "kernel_residual": 6.601957032696207e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.19799289081628021, + "minus_external_effective_rank": 48.97453517027289, + "minus_external_entropy": 0.9598639345709891, + "minus_target_effective_rank": 151.92950937395142, + "minus_target_entropy": 0.9476003228961677, + "minus_weight": 191.09570252291914, + "orthogonality_relative_error": 7.46081942166189e-16, + "plus_external_effective_rank": 141.4495167537629, + "plus_external_entropy": 0.8759636262638341, + "plus_target_effective_rank": 194.61119341710193, + "plus_target_entropy": 0.9789275383725141, + "plus_weight": 3467.9363977599655, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "308712723a369cc009256dfb683b41e26a1010ab77fdcc7ed63caa919c66f4e4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:02:22.727823+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "e7f11005e87f654e9923a3cf0669cece0e4884128ec27a54c5773d176db3eafa", + "panel_kind": "sparse", + "panel_seed": 17843517020241681841, + "realization": 24, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "99a0f26ba41f5f5f74face0828e7deeb81509b079e0be426d2fa3b19d170432e", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006104701647304105, + "kernel_residual": 6.56067458616233e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1837822438508581, + "minus_external_effective_rank": 43.20258894170387, + "minus_external_entropy": 0.9411492417480453, + "minus_target_effective_rank": 114.78660937276639, + "minus_target_entropy": 0.9012942741441755, + "minus_weight": 195.43855435524324, + "orthogonality_relative_error": 7.544857547955424e-16, + "plus_external_effective_rank": 120.57080363479483, + "plus_external_entropy": 0.8615399893246088, + "plus_target_effective_rank": 161.2483439785741, + "plus_target_entropy": 0.9568100544008834, + "plus_weight": 3852.9075754237033, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 439, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "5add46b98d49c0712d115187d74588dc0b6d473c319cad1de387d6ecb3786580", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:05:24.216971+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "e7f11005e87f654e9923a3cf0669cece0e4884128ec27a54c5773d176db3eafa", + "panel_kind": "isotropic", + "panel_seed": 17843517020241681841, + "realization": 24, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9c6a38821ab0ccbd046bf054cfe95a63e6abb2f975351935663dfee3fc414195", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006104701647304105, + "kernel_residual": 6.56067458616233e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1904326062888741, + "minus_external_effective_rank": 47.29030567243108, + "minus_external_entropy": 0.9551692354654985, + "minus_target_effective_rank": 151.00812042020104, + "minus_target_entropy": 0.9466907739708487, + "minus_weight": 191.48575775313472, + "orthogonality_relative_error": 7.674385616169076e-16, + "plus_external_effective_rank": 135.48664327778621, + "plus_external_entropy": 0.8717592925123454, + "plus_target_effective_rank": 191.90564678414958, + "plus_target_entropy": 0.977515644815479, + "plus_weight": 3629.0460261081776, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "714a135df77e672a3fd1709159e8a57cb9e08613823e4467761de3c1bbd01b3b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:51:11.416458+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "4a12b6097c7e396092e233d515fe1655c61adbc96be3912e22555ede49d49fdd", + "panel_kind": "sparse", + "panel_seed": 16914992965665641200, + "realization": 25, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7f88326501b044541691126583b3e7e6095abbe889d18e85f0aa81571c771df6", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.005582933323155429, + "kernel_residual": 6.4956682727837225e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.19218734195067386, + "minus_external_effective_rank": 41.83543631022249, + "minus_external_entropy": 0.9377814138930993, + "minus_target_effective_rank": 115.23978694609208, + "minus_target_entropy": 0.9017856151734631, + "minus_weight": 194.8148338378879, + "orthogonality_relative_error": 8.100256617428916e-16, + "plus_external_effective_rank": 121.07193591906223, + "plus_external_entropy": 0.8644901688629884, + "plus_target_effective_rank": 163.5459798861926, + "plus_target_entropy": 0.9577123896746276, + "plus_weight": 3654.671646033331, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 432, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "4cb5db7200715edfce7fe7f1654900780f5305c84e48b67c4b354a1485b9acfc", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:53:06.286716+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "4a12b6097c7e396092e233d515fe1655c61adbc96be3912e22555ede49d49fdd", + "panel_kind": "isotropic", + "panel_seed": 16914992965665641200, + "realization": 25, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7534901236540c86f6af81a04818e506783f01a3119506da519e35ee314c1aea", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.005582933323155429, + "kernel_residual": 6.4956682727837225e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.18508567096484496, + "minus_external_effective_rank": 46.6082793811198, + "minus_external_entropy": 0.9535301008579986, + "minus_target_effective_rank": 149.75445422817174, + "minus_target_entropy": 0.9456902192508687, + "minus_weight": 189.32573348952928, + "orthogonality_relative_error": 8.335233557049681e-16, + "plus_external_effective_rank": 131.3995416902672, + "plus_external_entropy": 0.8688354955244753, + "plus_target_effective_rank": 190.00541219244508, + "plus_target_entropy": 0.97667756506486, + "plus_weight": 3703.3041386559494, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "f8467d0e0e6b13f5883284ee7ffe6178c07b57f2168971933d5bc730269e3a30", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:44:12.817148+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "f1944a4c1ba4ca5428e1bee6615e1be569f7ae23902a3631638d835866e7b6b0", + "panel_kind": "sparse", + "panel_seed": 8559190164211049046, + "realization": 26, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9feeb9d41bca0e49e8402cf475a13c0c46110ddcb84a02318d254576e9b24091", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006351776138948228, + "kernel_residual": 6.415252887692369e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2064131243643515, + "minus_external_effective_rank": 42.49362960104729, + "minus_external_entropy": 0.940109769954226, + "minus_target_effective_rank": 106.67405162583698, + "minus_target_entropy": 0.8947553169173039, + "minus_weight": 192.97207737225003, + "orthogonality_relative_error": 6.671237416237697e-16, + "plus_external_effective_rank": 123.45026235763129, + "plus_external_entropy": 0.8664773543768471, + "plus_target_effective_rank": 156.26223500696724, + "plus_target_entropy": 0.9527177612489482, + "plus_weight": 3342.445991343078, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 432, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "e94531c86642f88333ae705496aee903c2ee17135a1a89b811215b80e256075e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:45:51.279984+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "f1944a4c1ba4ca5428e1bee6615e1be569f7ae23902a3631638d835866e7b6b0", + "panel_kind": "isotropic", + "panel_seed": 8559190164211049046, + "realization": 26, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d6e4b92ff0b159905243ef47f84323561b65abf940fe7ff4438086dbe1db11c9", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006351776138948228, + "kernel_residual": 6.415252887692369e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1967880789014228, + "minus_external_effective_rank": 47.76622994682149, + "minus_external_entropy": 0.9568358130142084, + "minus_target_effective_rank": 151.25071559871523, + "minus_target_entropy": 0.9470950464730469, + "minus_weight": 189.5061112029927, + "orthogonality_relative_error": 6.748861272458405e-16, + "plus_external_effective_rank": 141.57462306259708, + "plus_external_entropy": 0.8764744013264785, + "plus_target_effective_rank": 193.12883069587193, + "plus_target_entropy": 0.9781196727289467, + "plus_weight": 3462.5997766000246, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "3e5e9ad6d4b140fab31e8bc51a986a1695f8a60edeb8c3a6a34b1d7d77059e02", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:58:01.977681+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "cf2601404016147aa1bacfc51c769ed4994f25b462ff169ae392323dc2b2f97c", + "panel_kind": "sparse", + "panel_seed": 16821510611515252535, + "realization": 27, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2ee4b819c3142386fc07a7165e1a011a17691495e9c8a25c11596d6e60f98a6f", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006297729496433315, + "kernel_residual": 6.571282113403337e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.19147302590057583, + "minus_external_effective_rank": 41.79495406491809, + "minus_external_entropy": 0.9374355245932946, + "minus_target_effective_rank": 108.3298089823498, + "minus_target_entropy": 0.8979415973638911, + "minus_weight": 189.5972473798539, + "orthogonality_relative_error": 7.557100566296196e-16, + "plus_external_effective_rank": 121.95172385530269, + "plus_external_entropy": 0.866666688721726, + "plus_target_effective_rank": 162.6078985162953, + "plus_target_entropy": 0.9575485323384051, + "plus_weight": 3571.5543952428416, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 425, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "9cfa8adab3d89915bb9c6083b7589d1799e2b8cbeeea6968e7f865d34d76f742", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:00:03.990197+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "cf2601404016147aa1bacfc51c769ed4994f25b462ff169ae392323dc2b2f97c", + "panel_kind": "isotropic", + "panel_seed": 16821510611515252535, + "realization": 27, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6e0bc51469c11d220209a3372966c58b09fd13c4d3550ce48c4822f62cfbbb93", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006297729496433315, + "kernel_residual": 6.571282113403337e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.19355557851687924, + "minus_external_effective_rank": 48.60041634127127, + "minus_external_entropy": 0.9588872658421589, + "minus_target_effective_rank": 152.64576743057899, + "minus_target_entropy": 0.9481457459638132, + "minus_weight": 187.9221844311714, + "orthogonality_relative_error": 7.6178909824402665e-16, + "plus_external_effective_rank": 138.54125156651412, + "plus_external_entropy": 0.8743088653058109, + "plus_target_effective_rank": 191.5797315720797, + "plus_target_entropy": 0.9774663043919493, + "plus_weight": 3497.6397423404765, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "207d15d2f76665b00f840bcaeecf5d0942a62ec3225b7c918212a4523196580c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:58:18.935535+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "ff603b8a976cb5c6e770d92c724f4ddaf19f71879b387b3f89b21c070775a9be", + "panel_kind": "sparse", + "panel_seed": 13308670771604502888, + "realization": 28, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e6dd96c5ea29e5c079e9a52806a3d32c21f910c61fe6b01879b745d32ea79a34", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006838681174157458, + "kernel_residual": 6.5015197216907845e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20276487442543287, + "minus_external_effective_rank": 46.16151992544824, + "minus_external_entropy": 0.9530130408899237, + "minus_target_effective_rank": 129.46768466471406, + "minus_target_entropy": 0.9185954892777607, + "minus_weight": 189.36184906534058, + "orthogonality_relative_error": 6.58086614799231e-16, + "plus_external_effective_rank": 139.55223074783055, + "plus_external_entropy": 0.8743731947651429, + "plus_target_effective_rank": 178.3833211448689, + "plus_target_entropy": 0.9690602827951056, + "plus_weight": 3346.1548778451615, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 471, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "572024cbfafe8514d7eb797300912f48dd0fd0f4b8d581a36792673e7460eb10", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:00:30.888109+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "ff603b8a976cb5c6e770d92c724f4ddaf19f71879b387b3f89b21c070775a9be", + "panel_kind": "isotropic", + "panel_seed": 13308670771604502888, + "realization": 28, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d60f154ccb353e88183924a1aa5137c61a9871ff92fc228999f5a0d6eaee27f2", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.006838681174157458, + "kernel_residual": 6.5015197216907845e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.19970285456721348, + "minus_external_effective_rank": 47.34068326834651, + "minus_external_entropy": 0.9566518956944131, + "minus_target_effective_rank": 151.42585588440744, + "minus_target_entropy": 0.947375571916267, + "minus_weight": 194.38281580580477, + "orthogonality_relative_error": 6.831175241261853e-16, + "plus_external_effective_rank": 142.90506780827653, + "plus_external_entropy": 0.8768546949202005, + "plus_target_effective_rank": 194.26235074113202, + "plus_target_entropy": 0.9787704588888885, + "plus_weight": 3493.8606830524286, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "ceb7a3356caf8bd1a8093123eacd411b576a985cc4c00ef3ea9292c612673141", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T16:59:35.871108+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "ca56a8e8240554ae66dfe2b707e9465091dd2f2faf2ec023256989ab480d1a6d", + "panel_kind": "sparse", + "panel_seed": 11008845009396074729, + "realization": 29, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "01694bccce2cc675e6a50069bdeee3930f174dfa73f1f67fc15af76c5d568456", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.008783171047243375, + "kernel_residual": 6.38274451551697e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2080134887899544, + "minus_external_effective_rank": 47.52475018811105, + "minus_external_entropy": 0.9564897143796652, + "minus_target_effective_rank": 122.24963295468102, + "minus_target_entropy": 0.9104446944163288, + "minus_weight": 183.28522914927495, + "orthogonality_relative_error": 5.039429376951472e-16, + "plus_external_effective_rank": 144.93013048738905, + "plus_external_entropy": 0.8801440359386447, + "plus_target_effective_rank": 181.6280050628069, + "plus_target_entropy": 0.9704556189550086, + "plus_weight": 3147.242986451269, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 464, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "602f0aaca765376b41e513d35e906158479af5cd7dee1f42f6ff1b1517357272", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:02:07.414623+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "ca56a8e8240554ae66dfe2b707e9465091dd2f2faf2ec023256989ab480d1a6d", + "panel_kind": "isotropic", + "panel_seed": 11008845009396074729, + "realization": 29, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "dc6f5507b11bc097b3866c863380afaad2f384be86080182086a439133227b2e", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.008783171047243375, + "kernel_residual": 6.38274451551697e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.2120169392138017, + "minus_external_effective_rank": 49.72909142966895, + "minus_external_entropy": 0.9622094587078681, + "minus_target_effective_rank": 153.3326526166815, + "minus_target_entropy": 0.9486947149758875, + "minus_weight": 189.56419302331037, + "orthogonality_relative_error": 5.070872866181301e-16, + "plus_external_effective_rank": 155.04391636205773, + "plus_external_entropy": 0.886578306473773, + "plus_target_effective_rank": 198.80974047910965, + "plus_target_entropy": 0.9810137466708022, + "plus_weight": 3185.989801497982, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "e64ef5d98be48f8b9c412c730348e04a2d17fb2d7e8f8eccf709e32cd8841d29", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:07:11.566959+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "57c236290669220146ed55de83e6d99a558dead6509ec432365de1f51cf8e872", + "panel_kind": "sparse", + "panel_seed": 10987169552175901476, + "realization": 30, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a10a1a87ff25c6955228eab0d92d3a535dd18502a9c642c2fa7c160f9e26e3b1", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.0073577329324321875, + "kernel_residual": 6.474299984890836e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.19915395787638368, + "minus_external_effective_rank": 43.088578613197626, + "minus_external_entropy": 0.9430928730546293, + "minus_target_effective_rank": 112.24733127011038, + "minus_target_entropy": 0.9000328031223954, + "minus_weight": 187.40360051489816, + "orthogonality_relative_error": 6.256719486293478e-16, + "plus_external_effective_rank": 131.46575519504898, + "plus_external_entropy": 0.8691942345825924, + "plus_target_effective_rank": 166.34576088728056, + "plus_target_entropy": 0.9607380853579545, + "plus_weight": 3378.7930220965413, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 454, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "39d9748020174eb7cc8e6ad8436fef49b769fb34ae8248e159e1d4e98b7b4c27", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:09:35.682292+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "57c236290669220146ed55de83e6d99a558dead6509ec432365de1f51cf8e872", + "panel_kind": "isotropic", + "panel_seed": 10987169552175901476, + "realization": 30, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4115513e904a8d1317ff5600128fca9cadb262933d434cf54fafd9d0cb838e11", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.0073577329324321875, + "kernel_residual": 6.474299984890836e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.20547780586250908, + "minus_external_effective_rank": 47.85766875772887, + "minus_external_entropy": 0.9574366810078108, + "minus_target_effective_rank": 151.8291847965014, + "minus_target_entropy": 0.9476685007775992, + "minus_weight": 193.11402559648062, + "orthogonality_relative_error": 6.429430277992148e-16, + "plus_external_effective_rank": 145.13082337268935, + "plus_external_entropy": 0.8792528897257966, + "plus_target_effective_rank": 193.69372866112005, + "plus_target_entropy": 0.9784548462383953, + "plus_weight": 3361.9959054327483, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "99a0de2aa630f56fa02b1986d48699dd287efc75b741d23f62e9c66c37e61ac2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:08:50.198288+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "422501f20de7f8ad861579d374acb042da61a295ba8550cf83be9fa7afd20458", + "panel_kind": "sparse", + "panel_seed": 3758319713811461021, + "realization": 31, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "91ea1fd6a77e14a06563316196f20df176c199fa259edd0485ae45a27f5ec558", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.005772870480686141, + "kernel_residual": 6.650847626532838e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1991258615136892, + "minus_external_effective_rank": 44.528749554547076, + "minus_external_entropy": 0.9471793169694949, + "minus_target_effective_rank": 116.59520522246139, + "minus_target_entropy": 0.9036468702017345, + "minus_weight": 195.87843283961988, + "orthogonality_relative_error": 8.058589831117529e-16, + "plus_external_effective_rank": 123.37299999335886, + "plus_external_entropy": 0.8663058217953015, + "plus_target_effective_rank": 165.15254136529566, + "plus_target_entropy": 0.9591668894629202, + "plus_weight": 3532.1468267979953, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 440, + "plus_target_eigenvalues": 243 + } + }, + { + "arrays_sha256": "093920191c2c91d3a9efbbf8104581c5dad17e86e5284cda6d4b8caf201c3aa6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T17:11:08.121200+00:00", + "identity": { + "N": 12, + "charge": 5, + "kernel_identity_hash": "422501f20de7f8ad861579d374acb042da61a295ba8550cf83be9fa7afd20458", + "panel_kind": "isotropic", + "panel_seed": 3758319713811461021, + "realization": 31, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5aae37c2273ce5403b57e95422630596dcdea90c82de518b2154243e2278ad6d", + "kernel": { + "bps_rank": 243, + "complement_rank": 549, + "gap": 0.005772870480686141, + "kernel_residual": 6.650847626532838e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.1956648899733258, + "minus_external_effective_rank": 46.676342256245576, + "minus_external_entropy": 0.9551173176203127, + "minus_target_effective_rank": 149.85853096043064, + "minus_target_entropy": 0.9462788838810495, + "minus_weight": 190.48391083526855, + "orthogonality_relative_error": 7.992722418202359e-16, + "plus_external_effective_rank": 139.35877132127544, + "plus_external_entropy": 0.8750524130878363, + "plus_target_effective_rank": 192.64030604050083, + "plus_target_entropy": 0.9778967025111835, + "plus_weight": 3502.758093395167, + "target_rank": 243 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 66, + "minus_target_eigenvalues": 243, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 483, + "plus_target_eigenvalues": 243 + } + } + ], + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_covariates_pilot_banked.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_covariates_pilot_banked.json new file mode 100644 index 000000000..ace3e87f8 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_covariates_pilot_banked.json @@ -0,0 +1,16395 @@ +{ + "checks": { + "all_safe_checks": true, + "complete_requested_grid": true, + "no_outcome_leakage": true + }, + "passed": true, + "records": [ + { + "arrays_sha256": "d279db2f7d4cf50bdbfddc47b5ecf396eb7bfb8902bad7a21d768f343791b487", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:58.818301+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "d2de21b595fda6b3d91f1f507c6902cd690051cce7b2cea7fcd30fd79364a68c", + "panel_kind": "sparse", + "panel_seed": 6712381035597109010, + "realization": 0, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2553c466e83e20d6183d243b38d6b899a21420e6f2eb66d3c77feae31c410db4", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31989749891442076, + "kernel_residual": 1.0031638903585107e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.906310061891147, + "minus_external_entropy": 0.9631286314909848, + "minus_target_effective_rank": 26.561920821356804, + "minus_target_entropy": 0.954378948880504, + "minus_weight": 56.164849021787994, + "orthogonality_relative_error": 1.4480188977902597e-16, + "plus_external_effective_rank": 6.906310061891147, + "plus_external_entropy": 0.9631286314909853, + "plus_target_effective_rank": 26.561920821356818, + "plus_target_entropy": 0.9543789488805039, + "plus_weight": 56.164849021788044, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "99f907ead50362f3b55b83ebd4872f119a4f96ca76766d7e4041aadd287de30f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:58.925816+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "d2de21b595fda6b3d91f1f507c6902cd690051cce7b2cea7fcd30fd79364a68c", + "panel_kind": "isotropic", + "panel_seed": 6712381035597109010, + "realization": 0, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "783cfe3ae8dc692ef7face1ffa4c861b4ba4059f3c957088216651d839a04621", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31989749891442076, + "kernel_residual": 1.0031638903585107e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.892615486864619, + "minus_external_entropy": 0.9633991313758382, + "minus_target_effective_rank": 29.737000287600384, + "minus_target_entropy": 0.897049430206789, + "minus_weight": 56.876805558765525, + "orthogonality_relative_error": 1.410917552015928e-16, + "plus_external_effective_rank": 6.892615486864621, + "plus_external_entropy": 0.9633991313758384, + "plus_target_effective_rank": 29.737000287600384, + "plus_target_entropy": 0.8970494302067888, + "plus_weight": 56.87680555876557, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "02830def174e2f17aedc22c5c39a3819efb2ea079fa96a19e6d56e8163875075", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.039084+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "feb4fbe8f2183b83c4e852401cc33698e53567ca9882d0d5257e7b5232496d68", + "panel_kind": "sparse", + "panel_seed": 4494313612115535194, + "realization": 1, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "dc3fdd4069a1090447a49ec3784ec239034af7772c85915dba8565d6ac60aa4e", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.33348932379770296, + "kernel_residual": 1.000574811034804e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.727303230971197, + "minus_external_entropy": 0.9553987333898606, + "minus_target_effective_rank": 24.80016052897615, + "minus_target_entropy": 0.9494422263062948, + "minus_weight": 55.47706362251138, + "orthogonality_relative_error": 1.5776406367338692e-16, + "plus_external_effective_rank": 6.727303230971191, + "plus_external_entropy": 0.9553987333898606, + "plus_target_effective_rank": 24.800160528976136, + "plus_target_entropy": 0.9494422263062947, + "plus_weight": 55.47706362251134, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "f2bf28bb5835cbac8183af5c89881caef6c6cd6d1effc31f593a42bcf1074874", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.145784+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "feb4fbe8f2183b83c4e852401cc33698e53567ca9882d0d5257e7b5232496d68", + "panel_kind": "isotropic", + "panel_seed": 4494313612115535194, + "realization": 1, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f147fd2c691a1b500bb22d7109356c69b26f6206adf997c5c26eb7c8eef7b42e", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.33348932379770296, + "kernel_residual": 1.000574811034804e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.192184176210985, + "minus_external_entropy": 0.974796383646619, + "minus_target_effective_rank": 29.937255885235057, + "minus_target_entropy": 0.8972636008609922, + "minus_weight": 55.389587447323976, + "orthogonality_relative_error": 1.6278568872994446e-16, + "plus_external_effective_rank": 7.19218417621097, + "plus_external_entropy": 0.9747963836466188, + "plus_target_effective_rank": 29.937255885235043, + "plus_target_entropy": 0.897263600860992, + "plus_weight": 55.38958744732395, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "3429a4223488309787f962140cbd5fe9030a8c6038763c3e71468d998a057284", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.255616+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "894f0a1e62fa9cb87a75932a8b7fb66e936c2e43c67ed1228fc333c69db1f21d", + "panel_kind": "sparse", + "panel_seed": 11196775874684465776, + "realization": 2, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "34244965454c2d58776def768d33aecd23c0cea1db5f410ac88b5af47fae7a11", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29317024715248113, + "kernel_residual": 9.717750587981882e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 5.934532170897461, + "minus_external_entropy": 0.9182116407072981, + "minus_target_effective_rank": 22.63709126325537, + "minus_target_entropy": 0.9507528246191665, + "minus_weight": 60.738040056089204, + "orthogonality_relative_error": 1.7716601985572866e-16, + "plus_external_effective_rank": 5.934532170897461, + "plus_external_entropy": 0.918211640707298, + "plus_target_effective_rank": 22.63709126325537, + "plus_target_entropy": 0.9507528246191664, + "plus_weight": 60.73804005608921, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "06c4e28a758a322a3f5d1380ea51db7690bfbea9ebb976782f6d1a49ef405da0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.359139+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "894f0a1e62fa9cb87a75932a8b7fb66e936c2e43c67ed1228fc333c69db1f21d", + "panel_kind": "isotropic", + "panel_seed": 11196775874684465776, + "realization": 2, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b16d562ac212c8484d3e9b28c7ab9e7b07083c2c88834fbbdcd63477cfd04252", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29317024715248113, + "kernel_residual": 9.717750587981882e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.528043216281279, + "minus_external_entropy": 0.9490436967366969, + "minus_target_effective_rank": 28.95498241088932, + "minus_target_entropy": 0.8915963307462438, + "minus_weight": 59.94207719323898, + "orthogonality_relative_error": 1.846505404050576e-16, + "plus_external_effective_rank": 6.528043216281283, + "plus_external_entropy": 0.949043696736697, + "plus_target_effective_rank": 28.95498241088933, + "plus_target_entropy": 0.8915963307462433, + "plus_weight": 59.942077193239, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "127e78754212c972d3b3a3a251948a9e31a9e4eee9abf8cf897a2f21b8383f29", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.468612+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e8c9a44b73c8c29edb1481b7d99e22d72f0f449a86cd35f8070f48f775f4564f", + "panel_kind": "sparse", + "panel_seed": 16173911803461271316, + "realization": 3, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e06eabd66a0ae7b30c213a62a66fb7f148dc9467f87ec12770bda2f122e5764d", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3162335021455887, + "kernel_residual": 9.72197053917316e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.957512334528189, + "minus_external_entropy": 0.9653810253041193, + "minus_target_effective_rank": 26.541713210397397, + "minus_target_entropy": 0.9536613676007686, + "minus_weight": 56.1628258884668, + "orthogonality_relative_error": 2.04559035992696e-16, + "plus_external_effective_rank": 6.9575123345281895, + "plus_external_entropy": 0.9653810253041195, + "plus_target_effective_rank": 26.541713210397415, + "plus_target_entropy": 0.9536613676007684, + "plus_weight": 56.162825888466834, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "25ece3b52de35f4565370707195f7f6617c6f4497f47722acef0579bc3906b95", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.571715+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e8c9a44b73c8c29edb1481b7d99e22d72f0f449a86cd35f8070f48f775f4564f", + "panel_kind": "isotropic", + "panel_seed": 16173911803461271316, + "realization": 3, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2cf55f7b7312e562f3db98961f61773d7d5f1c48fe6326a229acfb22c4f70ff3", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3162335021455887, + "kernel_residual": 9.72197053917316e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.05168165317988, + "minus_external_entropy": 0.9699826989414064, + "minus_target_effective_rank": 29.9386637366093, + "minus_target_entropy": 0.8979618220134903, + "minus_weight": 56.073059454639186, + "orthogonality_relative_error": 1.9547205995833357e-16, + "plus_external_effective_rank": 7.051681653179883, + "plus_external_entropy": 0.9699826989414069, + "plus_target_effective_rank": 29.938663736609318, + "plus_target_entropy": 0.8979618220134903, + "plus_weight": 56.07305945463921, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "901c2f4a20fbd2ab870e84cd4d6a637a3e32e0b1a0a856e4f448a166dd48ef25", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.676438+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e21720f59c201483c3fc7fb34bb9651353c50804138a49024537d2644684976d", + "panel_kind": "sparse", + "panel_seed": 7300569131601052580, + "realization": 4, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c824a4215b46eeea1684238401b0ac6504a782567654418c60b30a15ba29384e", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3782966553874937, + "kernel_residual": 9.923846259980019e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.307755143797807, + "minus_external_entropy": 0.97828950857954, + "minus_target_effective_rank": 28.799599595450115, + "minus_target_entropy": 0.9635901948488405, + "minus_weight": 53.81216059059692, + "orthogonality_relative_error": 1.5282756889323535e-16, + "plus_external_effective_rank": 7.307755143797808, + "plus_external_entropy": 0.9782895085795398, + "plus_target_effective_rank": 28.799599595450108, + "plus_target_entropy": 0.9635901948488408, + "plus_weight": 53.81216059059694, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6be941a43ae7c7d45637a7ff0b5a59c936c82e1d4565f48b698e51fe8c8bb722", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.772039+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e21720f59c201483c3fc7fb34bb9651353c50804138a49024537d2644684976d", + "panel_kind": "isotropic", + "panel_seed": 7300569131601052580, + "realization": 4, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "05e1516c316993285585d7981bcfb2eed629035bce2e7e0a1cf7ae84b2c5c929", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3782966553874937, + "kernel_residual": 9.923846259980019e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.276226763789925, + "minus_external_entropy": 0.977035439001372, + "minus_target_effective_rank": 30.289373806358032, + "minus_target_entropy": 0.8994323956834662, + "minus_weight": 53.4670790210558, + "orthogonality_relative_error": 1.5336658913890028e-16, + "plus_external_effective_rank": 7.276226763789928, + "plus_external_entropy": 0.9770354390013718, + "plus_target_effective_rank": 30.289373806358025, + "plus_target_entropy": 0.8994323956834662, + "plus_weight": 53.467079021055824, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "85397b700a2ee75489411a7ebeaeb08269809e28ecb46b469f94e8f59cf594c3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:31:59.913189+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "0b25f8bb64f02aaf69c7de7e0d63a70a4ba38def6d4f83cd7e9aeaf816c70877", + "panel_kind": "sparse", + "panel_seed": 6401611679012054544, + "realization": 5, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1bdee3b35338f519c1684880d21f5f1fee958de04410c9b7879d4a21d85593d2", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2753987560855047, + "kernel_residual": 1.0055587865485858e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.281767827736662, + "minus_external_entropy": 0.9354692787104288, + "minus_target_effective_rank": 23.56252533718206, + "minus_target_entropy": 0.9426960964435014, + "minus_weight": 59.84599594894605, + "orthogonality_relative_error": 2.1102440323989682e-16, + "plus_external_effective_rank": 6.281767827736659, + "plus_external_entropy": 0.9354692787104287, + "plus_target_effective_rank": 23.562525337182045, + "plus_target_entropy": 0.9426960964435014, + "plus_weight": 59.84599594894606, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "f67927f7be4d62437d4af61351d33fe914fab282e50658d05154555396e8ed9e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:00.085688+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "0b25f8bb64f02aaf69c7de7e0d63a70a4ba38def6d4f83cd7e9aeaf816c70877", + "panel_kind": "isotropic", + "panel_seed": 6401611679012054544, + "realization": 5, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ad41fbf86bccb98211036f57488e321e3f2ce5ade8c2fffef4c66ea62e5b2ae3", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2753987560855047, + "kernel_residual": 1.0055587865485858e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.536550662430953, + "minus_external_entropy": 0.9498941407349833, + "minus_target_effective_rank": 28.78335891438232, + "minus_target_entropy": 0.8911110584471464, + "minus_weight": 59.21735436244465, + "orthogonality_relative_error": 2.0481812623994773e-16, + "plus_external_effective_rank": 6.5365506624309475, + "plus_external_entropy": 0.9498941407349833, + "plus_target_effective_rank": 28.783358914382305, + "plus_target_entropy": 0.8911110584471464, + "plus_weight": 59.217354362444674, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e7762161bb39ba201ec8e0e69be43cb409d33921ce5aaed5c30b61d927780249", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:00.265397+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "8a995cf82e9837e64c813ea356da3ccd7760e72e7b112c47a56ca92371a9995a", + "panel_kind": "sparse", + "panel_seed": 4546943701502790165, + "realization": 6, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7e9d7b2221b1a76c3d8c5a1e04e2b692e8fc27aad359bc8bebe78f7b3f8a16a3", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30267053027854063, + "kernel_residual": 9.816159958283208e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 5.908054785530005, + "minus_external_entropy": 0.9243590019097366, + "minus_target_effective_rank": 21.77898127439201, + "minus_target_entropy": 0.9481536248143324, + "minus_weight": 56.59885373425371, + "orthogonality_relative_error": 1.7917953010406818e-16, + "plus_external_effective_rank": 5.908054785530001, + "plus_external_entropy": 0.9243590019097365, + "plus_target_effective_rank": 21.778981274392013, + "plus_target_entropy": 0.9481536248143325, + "plus_weight": 56.59885373425371, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "3c1cdb49c2fcb75699db6c108f83a88fe4b49564520fbe2586e65425cdcc8233", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:00.453380+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "8a995cf82e9837e64c813ea356da3ccd7760e72e7b112c47a56ca92371a9995a", + "panel_kind": "isotropic", + "panel_seed": 4546943701502790165, + "realization": 6, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d138d7ea668bc77119f5e63e2e44891cc72af46449588f537b76cbafa3c72933", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30267053027854063, + "kernel_residual": 9.816159958283208e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.959116559977406, + "minus_external_entropy": 0.9677150661838805, + "minus_target_effective_rank": 29.499601100406426, + "minus_target_entropy": 0.8962867153219757, + "minus_weight": 56.0277251296167, + "orthogonality_relative_error": 1.776709110947721e-16, + "plus_external_effective_rank": 6.959116559977404, + "plus_external_entropy": 0.9677150661838805, + "plus_target_effective_rank": 29.49960110040642, + "plus_target_entropy": 0.8962867153219757, + "plus_weight": 56.027725129616684, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "0a93aebcd9d827bacfa7f54f58c39038c888bbd97b0ac44a0d2dac26674e943f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:00.613599+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1e5525a2dc8f510a9a340529ca785c4c393f8b63f7005d170f3b99696b3c0ced", + "panel_kind": "sparse", + "panel_seed": 5127668464502805323, + "realization": 7, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "55627b33168c3e0c24cf570a30092f8324bd9fee26fd7cda0464a5e226e34ec9", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3236910654405299, + "kernel_residual": 1.0886305064312513e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.84514389871164, + "minus_external_entropy": 0.9614402878966052, + "minus_target_effective_rank": 25.22841155638714, + "minus_target_entropy": 0.9540264989342846, + "minus_weight": 55.51731320937134, + "orthogonality_relative_error": 2.3912175068837956e-16, + "plus_external_effective_rank": 6.845143898711643, + "plus_external_entropy": 0.9614402878966053, + "plus_target_effective_rank": 25.228411556387144, + "plus_target_entropy": 0.9540264989342846, + "plus_weight": 55.51731320937131, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "5b4ffad75d00fc706b0c4f8e7f0f804b60c00bd7bf23a3c40bdd6ee73155766e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:00.780357+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1e5525a2dc8f510a9a340529ca785c4c393f8b63f7005d170f3b99696b3c0ced", + "panel_kind": "isotropic", + "panel_seed": 5127668464502805323, + "realization": 7, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "df8e3523ac98f1cd026d33f218a5ead804dc69c8fa9541c52b291e6f9459cdbe", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3236910654405299, + "kernel_residual": 1.0886305064312513e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.940219922286247, + "minus_external_entropy": 0.9649233821964273, + "minus_target_effective_rank": 29.305381419913793, + "minus_target_entropy": 0.893494855383621, + "minus_weight": 56.865431205900165, + "orthogonality_relative_error": 2.378335514725826e-16, + "plus_external_effective_rank": 6.94021992228625, + "plus_external_entropy": 0.9649233821964275, + "plus_target_effective_rank": 29.3053814199138, + "plus_target_entropy": 0.893494855383621, + "plus_weight": 56.86543120590014, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "1927b7c601da4bd3bb7da0fa622a17c07421d49474f137646d8e47d99fd2f0f4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:00.934330+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "08128ffa8e7479b0726ac3ce8647800e682e7da0ea649e6ab7cfaa41a6ae5350", + "panel_kind": "sparse", + "panel_seed": 10421454225035959596, + "realization": 8, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "35de11d4f5289cb15b2292288f002490cefe8b9b412c6ce012995d3832401af0", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3078495649877013, + "kernel_residual": 9.753541343150522e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.593672618768767, + "minus_external_entropy": 0.9537281510279926, + "minus_target_effective_rank": 26.31722185658438, + "minus_target_entropy": 0.9499774493106804, + "minus_weight": 57.40918823341669, + "orthogonality_relative_error": 1.7697300811257965e-16, + "plus_external_effective_rank": 6.593672618768766, + "plus_external_entropy": 0.9537281510279925, + "plus_target_effective_rank": 26.317221856584382, + "plus_target_entropy": 0.9499774493106804, + "plus_weight": 57.40918823341672, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "fbc9c2706df2bb8d8044e457eddc24f66ade0a7ad79a4714913ee4dd369cdc72", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.065042+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "08128ffa8e7479b0726ac3ce8647800e682e7da0ea649e6ab7cfaa41a6ae5350", + "panel_kind": "isotropic", + "panel_seed": 10421454225035959596, + "realization": 8, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8b622b20baf5bb448700bb62c08aa51cda88b104eccb454c698c83e309aac4ed", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3078495649877013, + "kernel_residual": 9.753541343150522e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.922712441026345, + "minus_external_entropy": 0.9650180796929784, + "minus_target_effective_rank": 29.324054424645094, + "minus_target_entropy": 0.8952083798223981, + "minus_weight": 56.93823496517609, + "orthogonality_relative_error": 1.7148754376301312e-16, + "plus_external_effective_rank": 6.922712441026345, + "plus_external_entropy": 0.9650180796929784, + "plus_target_effective_rank": 29.324054424645098, + "plus_target_entropy": 0.8952083798223984, + "plus_weight": 56.93823496517612, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "503784456880fe732b271fc58f64d1f5551404421acb2b4d30ddd3009c5f8086", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.204397+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "29bad6fb772d0aea3833ecbccffb1ed6fc9946dd82a1a119d552e7360a0c305d", + "panel_kind": "sparse", + "panel_seed": 17241178783425349627, + "realization": 9, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3d19c6b7b57a85c15691e4bd045f31ebdc7213ad3477c237ed97bc6a1ee66f74", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3258893617669939, + "kernel_residual": 9.726884288410461e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.639970549197485, + "minus_external_entropy": 0.9541303560176388, + "minus_target_effective_rank": 24.833260538918683, + "minus_target_entropy": 0.9512535494063864, + "minus_weight": 55.638207976692115, + "orthogonality_relative_error": 2.4882555254331784e-16, + "plus_external_effective_rank": 6.639970549197494, + "plus_external_entropy": 0.9541303560176391, + "plus_target_effective_rank": 24.83326053891869, + "plus_target_entropy": 0.9512535494063864, + "plus_weight": 55.6382079766921, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "102ccebc9c55d4a364657db8f96a600abd052a68798c4e0ac19087eecdc951a8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.334347+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "29bad6fb772d0aea3833ecbccffb1ed6fc9946dd82a1a119d552e7360a0c305d", + "panel_kind": "isotropic", + "panel_seed": 17241178783425349627, + "realization": 9, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ea6a9300b16da1754149f2f94456da49e839246d1b23720a4e8e2cc1b7ab5e72", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3258893617669939, + "kernel_residual": 9.726884288410461e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.15626459317449, + "minus_external_entropy": 0.9739365922584264, + "minus_target_effective_rank": 29.141448750674986, + "minus_target_entropy": 0.8928980976617124, + "minus_weight": 55.78324517684163, + "orthogonality_relative_error": 2.4842143043235153e-16, + "plus_external_effective_rank": 7.156264593174494, + "plus_external_entropy": 0.9739365922584267, + "plus_target_effective_rank": 29.141448750674986, + "plus_target_entropy": 0.8928980976617125, + "plus_weight": 55.78324517684164, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "eabfb43c5efdcd49bb5de6e330171f7398fc8444740828f4fcab02dd7f1b9eba", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.459157+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ca2082cf7b35356da5701538d258cef01a4dbf8e11ff8bbc0b3b316ee0228cd2", + "panel_kind": "sparse", + "panel_seed": 9825404631407848744, + "realization": 10, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b0612ba48b1139547ba3ad571c1cb2257e5ad7cd13c172eedfc0ad1a8eca53ef", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3297372007939848, + "kernel_residual": 9.682562591081158e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.889192871151712, + "minus_external_entropy": 0.9622446729325163, + "minus_target_effective_rank": 27.980747589057152, + "minus_target_entropy": 0.9591429450224473, + "minus_weight": 57.28054251693665, + "orthogonality_relative_error": 2.5605639121142206e-16, + "plus_external_effective_rank": 6.889192871151712, + "plus_external_entropy": 0.9622446729325163, + "plus_target_effective_rank": 27.980747589057135, + "plus_target_entropy": 0.9591429450224476, + "plus_weight": 57.28054251693672, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "7f62a54a1163686ce18d6cd4c5a5cf299af72379cf896d151371bd452cb52c95", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.559612+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ca2082cf7b35356da5701538d258cef01a4dbf8e11ff8bbc0b3b316ee0228cd2", + "panel_kind": "isotropic", + "panel_seed": 9825404631407848744, + "realization": 10, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5758f3adaafa262dd2a38781a439862ee2f72fb0c7645e2ad22944af891651b3", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3297372007939848, + "kernel_residual": 9.682562591081158e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.21998336338748, + "minus_external_entropy": 0.9749699630505838, + "minus_target_effective_rank": 29.67770334465231, + "minus_target_entropy": 0.8963176411673427, + "minus_weight": 55.0276352256857, + "orthogonality_relative_error": 2.5072411491300566e-16, + "plus_external_effective_rank": 7.219983363387481, + "plus_external_entropy": 0.9749699630505838, + "plus_target_effective_rank": 29.677703344652304, + "plus_target_entropy": 0.8963176411673427, + "plus_weight": 55.027635225685756, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "61f0459572d55f6d91f134ca5f5d882f34ad9eb12757cd5eacde5dada31029e8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.660401+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "59cc1e84c890292bd75f76a89c3306bd159cdad33972ee3edf73b55bd088275e", + "panel_kind": "sparse", + "panel_seed": 9402798246654180518, + "realization": 11, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8f5bec25a773bf5032d7795c57a39f2dc747c307e3eae0c00b2381928db19f20", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3149905638416165, + "kernel_residual": 9.786310277580935e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.487921588974767, + "minus_external_entropy": 0.9460158723410904, + "minus_target_effective_rank": 22.562144227135345, + "minus_target_entropy": 0.9464431643557163, + "minus_weight": 54.157512314790736, + "orthogonality_relative_error": 1.586787555744292e-16, + "plus_external_effective_rank": 6.487921588974772, + "plus_external_entropy": 0.9460158723410905, + "plus_target_effective_rank": 22.562144227135352, + "plus_target_entropy": 0.9464431643557163, + "plus_weight": 54.15751231479074, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "58e57c6ca110ee11ae7c74b5b87a0b8445c1f22eb35f84b4522f2ea1c1a912dd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.771103+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "59cc1e84c890292bd75f76a89c3306bd159cdad33972ee3edf73b55bd088275e", + "panel_kind": "isotropic", + "panel_seed": 9402798246654180518, + "realization": 11, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6a4240ca04aa0580fa6a3c7b464c98110326c3cc0f2ccf85630d2d3371fefdf5", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3149905638416165, + "kernel_residual": 9.786310277580935e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.0251970107069575, + "minus_external_entropy": 0.9687626872980408, + "minus_target_effective_rank": 29.95195113476132, + "minus_target_entropy": 0.8988151261186589, + "minus_weight": 55.531890118776985, + "orthogonality_relative_error": 1.5021574662605767e-16, + "plus_external_effective_rank": 7.025197010706962, + "plus_external_entropy": 0.968762687298041, + "plus_target_effective_rank": 29.95195113476133, + "plus_target_entropy": 0.8988151261186591, + "plus_weight": 55.53189011877697, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "41f26bec2b2ecf9e74d0f9c8b78a55854c1b8166646b271900189976949d1daa", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.872904+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "6396c67d571e4cc8b5f49740e0f368d0b6b9be364ef59f9eba07462a24b92299", + "panel_kind": "sparse", + "panel_seed": 10157656434833357907, + "realization": 12, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "38d3e88a6eb9a417e0d91c0832a6be7da731e61bb9b442568e8e31579022e173", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.35501599290416397, + "kernel_residual": 1.0080867797627542e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.126924809159419, + "minus_external_entropy": 0.9711186138325061, + "minus_target_effective_rank": 25.250727321936594, + "minus_target_entropy": 0.9564415407544424, + "minus_weight": 55.58407579277957, + "orthogonality_relative_error": 1.8250257389113238e-16, + "plus_external_effective_rank": 7.126924809159415, + "plus_external_entropy": 0.9711186138325059, + "plus_target_effective_rank": 25.250727321936598, + "plus_target_entropy": 0.9564415407544424, + "plus_weight": 55.58407579277961, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "8fc5ead67ed3e37d1917aa7d2225a8865ccc74d21223ef407d3aa69559bf82b2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:01.969693+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "6396c67d571e4cc8b5f49740e0f368d0b6b9be364ef59f9eba07462a24b92299", + "panel_kind": "isotropic", + "panel_seed": 10157656434833357907, + "realization": 12, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8593641c3f2074b7a11ed3cd854e2788753ee578747e5166d7b6a5acf9ad6bf3", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.35501599290416397, + "kernel_residual": 1.0080867797627542e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.255904704227948, + "minus_external_entropy": 0.9759793563090019, + "minus_target_effective_rank": 29.717109724275424, + "minus_target_entropy": 0.8960492479767079, + "minus_weight": 54.31742212678941, + "orthogonality_relative_error": 1.812760995641023e-16, + "plus_external_effective_rank": 7.255904704227944, + "plus_external_entropy": 0.9759793563090019, + "plus_target_effective_rank": 29.717109724275417, + "plus_target_entropy": 0.896049247976708, + "plus_weight": 54.31742212678945, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "cd1e887098de3dbe1b993b9e154f6db1afff84859772394c61c6a692b4b7b067", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.070714+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "46356196c710a71ea94560434c094b6881e8780506d85649c80fa120009fa54b", + "panel_kind": "sparse", + "panel_seed": 15760182665437088626, + "realization": 13, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "81770893861224f1016a34a4833dd057c216ae5be504e7d071325d873f2865dd", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29751308707747204, + "kernel_residual": 9.746051942499644e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.17814196328533, + "minus_external_entropy": 0.9330278785103996, + "minus_target_effective_rank": 22.09720335824965, + "minus_target_entropy": 0.94840712288873, + "minus_weight": 57.802178361334846, + "orthogonality_relative_error": 1.522698165943653e-16, + "plus_external_effective_rank": 6.178141963285328, + "plus_external_entropy": 0.9330278785103996, + "plus_target_effective_rank": 22.097203358249647, + "plus_target_entropy": 0.94840712288873, + "plus_weight": 57.802178361334825, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e44b2e83a78ede465410eb365a9bb3d5129f377ff908d3a70e51fecb29a03047", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.171153+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "46356196c710a71ea94560434c094b6881e8780506d85649c80fa120009fa54b", + "panel_kind": "isotropic", + "panel_seed": 15760182665437088626, + "realization": 13, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "496d157777258d04d5a7c697f17b55bf6fb0d3ad467a22d1a278b5bf906d25e5", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29751308707747204, + "kernel_residual": 9.746051942499644e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.693639674536681, + "minus_external_entropy": 0.9591282230083537, + "minus_target_effective_rank": 29.055198585954013, + "minus_target_entropy": 0.8918098103059912, + "minus_weight": 56.71173312362145, + "orthogonality_relative_error": 1.5362853473346955e-16, + "plus_external_effective_rank": 6.693639674536677, + "plus_external_entropy": 0.9591282230083537, + "plus_target_effective_rank": 29.055198585954003, + "plus_target_entropy": 0.8918098103059913, + "plus_weight": 56.71173312362143, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "904bf25d746772113885320727f70c6e2f785956c9a46aba6cbb71e2826d8064", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.281188+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ed2ada199f4d5abec7b2d776045da39349d8b63ffac723d75a6e30ae21509759", + "panel_kind": "sparse", + "panel_seed": 1502686167259042665, + "realization": 14, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4d4c89a54d24ab0301420a7cf966ed0ca1b93750aee8ad658cab3b4f3027310a", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3157620242317473, + "kernel_residual": 9.987387410199076e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.129258855030907, + "minus_external_entropy": 0.9714070460021546, + "minus_target_effective_rank": 25.290137649331985, + "minus_target_entropy": 0.9575001430781045, + "minus_weight": 56.4615567023274, + "orthogonality_relative_error": 1.887864137173779e-16, + "plus_external_effective_rank": 7.129258855030906, + "plus_external_entropy": 0.9714070460021546, + "plus_target_effective_rank": 25.290137649331985, + "plus_target_entropy": 0.9575001430781045, + "plus_weight": 56.4615567023274, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "679657b775cfb9804796af95a8b4d6574dc3fd01b422f60564366c7931c5cebf", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.385295+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ed2ada199f4d5abec7b2d776045da39349d8b63ffac723d75a6e30ae21509759", + "panel_kind": "isotropic", + "panel_seed": 1502686167259042665, + "realization": 14, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e2fc9acb66e438833673c6febe3165d47b4f143a25bc9c64ce4b2b5376041ceb", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3157620242317473, + "kernel_residual": 9.987387410199076e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.018121391938885, + "minus_external_entropy": 0.9686508026446035, + "minus_target_effective_rank": 29.68610679294233, + "minus_target_entropy": 0.896647677251689, + "minus_weight": 55.316125284755586, + "orthogonality_relative_error": 1.8139186632981392e-16, + "plus_external_effective_rank": 7.018121391938886, + "plus_external_entropy": 0.9686508026446037, + "plus_target_effective_rank": 29.68610679294233, + "plus_target_entropy": 0.8966476772516893, + "plus_weight": 55.316125284755586, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "cb493a21db337d201c280ab78fd10928d58b257d7388ad710c4fa050f25a8d04", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.489719+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "748396a424ee904a6b49324cb90bfa04879d08152a95cfb5620d0e114fc37a3a", + "panel_kind": "sparse", + "panel_seed": 17130045624121972024, + "realization": 15, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "98cc0c65c33739afa72c45f04f57443b4d1953ef6b2ea84161a7f6504791c91b", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.27152564176264354, + "kernel_residual": 1.0022735415302351e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.25660714400629, + "minus_external_entropy": 0.93811062156965, + "minus_target_effective_rank": 24.555079936545482, + "minus_target_entropy": 0.9509743365243137, + "minus_weight": 59.25848743129208, + "orthogonality_relative_error": 1.8830482621822953e-16, + "plus_external_effective_rank": 6.256607144006291, + "plus_external_entropy": 0.9381106215696497, + "plus_target_effective_rank": 24.555079936545464, + "plus_target_entropy": 0.9509743365243137, + "plus_weight": 59.25848743129214, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "57fe72497a2182faa19574c0267656d5d33dd4a47b8afbad4b7f9d1ffff89553", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.584604+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "748396a424ee904a6b49324cb90bfa04879d08152a95cfb5620d0e114fc37a3a", + "panel_kind": "isotropic", + "panel_seed": 17130045624121972024, + "realization": 15, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3e552e6d62d15cb4f26f2d6d34adfad0b47a5387016e6e1a5a094f72b795a7af", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.27152564176264354, + "kernel_residual": 1.0022735415302351e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.444891801146761, + "minus_external_entropy": 0.9457818780563936, + "minus_target_effective_rank": 28.313057527708978, + "minus_target_entropy": 0.8860824202564205, + "minus_weight": 61.75816258548764, + "orthogonality_relative_error": 1.985221881871783e-16, + "plus_external_effective_rank": 6.444891801146761, + "plus_external_entropy": 0.9457818780563935, + "plus_target_effective_rank": 28.31305752770897, + "plus_target_entropy": 0.8860824202564203, + "plus_weight": 61.7581625854877, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "b3b2a73df2980a86fd5c436f84c8b539fb65ac5b604839979db31583ee8b9624", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.699233+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "049fd0158d5eb54f51328447fe285a471e48511b1deeb0f3a6e5feada2657fea", + "panel_kind": "sparse", + "panel_seed": 8468519870069001714, + "realization": 16, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b34ec3aff1b17801e50936d2c45c8d1cf44c4547792df33ea06fc2d64b9577ec", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2751488832622427, + "kernel_residual": 1.0374134810669283e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 5.861216716078553, + "minus_external_entropy": 0.9186449751915255, + "minus_target_effective_rank": 22.43085929001295, + "minus_target_entropy": 0.9558170909662005, + "minus_weight": 60.67560411526415, + "orthogonality_relative_error": 2.295737533711303e-16, + "plus_external_effective_rank": 5.86121671607855, + "plus_external_entropy": 0.9186449751915255, + "plus_target_effective_rank": 22.430859290012943, + "plus_target_entropy": 0.9558170909662005, + "plus_weight": 60.675604115264164, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "818191805edbad92b69294804c60ae1906563bddd5686df371fa73c8cbed548e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.803711+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "049fd0158d5eb54f51328447fe285a471e48511b1deeb0f3a6e5feada2657fea", + "panel_kind": "isotropic", + "panel_seed": 8468519870069001714, + "realization": 16, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e63dc347c38ee7764182e0392893fad8774b5ca0c306a30ccc86833ecbc22f83", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2751488832622427, + "kernel_residual": 1.0374134810669283e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.741778347210195, + "minus_external_entropy": 0.959052148403052, + "minus_target_effective_rank": 28.97599210794673, + "minus_target_entropy": 0.8912987000480891, + "minus_weight": 58.382471518222644, + "orthogonality_relative_error": 2.372567783591787e-16, + "plus_external_effective_rank": 6.741778347210195, + "plus_external_entropy": 0.959052148403052, + "plus_target_effective_rank": 28.97599210794673, + "plus_target_entropy": 0.8912987000480892, + "plus_weight": 58.38247151822265, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "24a7c9bf32ec34db3cdadb3cb31db5e5cc6efd66cf6e0bcef024c7c913d0a342", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:02.909502+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "c4d71df0bdaa3eb55f7fd53e0e2e45227519f7db95b11f95e3eb52d2c48280d2", + "panel_kind": "sparse", + "panel_seed": 10734905020495770974, + "realization": 17, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7b31cda265d27eacf354957a70810bf5833957f23c51ed2711a6f71acd96af5d", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3189879976975491, + "kernel_residual": 1.0556089618008158e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.612017120705572, + "minus_external_entropy": 0.9497589858509551, + "minus_target_effective_rank": 25.964798641136206, + "minus_target_entropy": 0.9550451976914696, + "minus_weight": 56.84680077374537, + "orthogonality_relative_error": 2.475201441399634e-16, + "plus_external_effective_rank": 6.612017120705569, + "plus_external_entropy": 0.9497589858509548, + "plus_target_effective_rank": 25.964798641136202, + "plus_target_entropy": 0.9550451976914696, + "plus_weight": 56.84680077374537, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "0b1ef2438c1d0eacd40e42110b1285b692da114db46d9f2c0ffef9bc952b14d3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.009458+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "c4d71df0bdaa3eb55f7fd53e0e2e45227519f7db95b11f95e3eb52d2c48280d2", + "panel_kind": "isotropic", + "panel_seed": 10734905020495770974, + "realization": 17, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1c8dc976aa7c7bda2b0fd213938c6ff4d0e75134c6f83e0b143786d23f3cab21", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3189879976975491, + "kernel_residual": 1.0556089618008158e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.9543776036103635, + "minus_external_entropy": 0.9665719148244957, + "minus_target_effective_rank": 29.98630190796838, + "minus_target_entropy": 0.89924386282059, + "minus_weight": 56.59458940537691, + "orthogonality_relative_error": 2.4219036625286286e-16, + "plus_external_effective_rank": 6.954377603610358, + "plus_external_entropy": 0.9665719148244957, + "plus_target_effective_rank": 29.986301907968375, + "plus_target_entropy": 0.8992438628205899, + "plus_weight": 56.594589405376894, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6b2c1148138aaa739477353f03e85fbc29590ab0a80fc34a11dcf7bf8b606bfb", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.125631+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "9b36a85bbb182f41b4f73cff1ccbbe30df9a5ae17c7f0b132383bd24a3bbb15c", + "panel_kind": "sparse", + "panel_seed": 622580746501599869, + "realization": 18, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3815fb3b1d0b448c9c29a960ad58d34f010ff603ba33867f43baa86a67157b9c", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.36467483176070276, + "kernel_residual": 1.0386781587823134e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.817808239764929, + "minus_external_entropy": 0.9605917533325482, + "minus_target_effective_rank": 23.34267327072904, + "minus_target_entropy": 0.9508854137348804, + "minus_weight": 53.931697570143804, + "orthogonality_relative_error": 2.1622393909235737e-16, + "plus_external_effective_rank": 6.817808239764934, + "plus_external_entropy": 0.9605917533325484, + "plus_target_effective_rank": 23.342673270729055, + "plus_target_entropy": 0.9508854137348806, + "plus_weight": 53.93169757014381, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "610339f28c0cc8dc40810ea142c41f6605d83eab9196d0966d229b7e4b9d888f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.237676+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "9b36a85bbb182f41b4f73cff1ccbbe30df9a5ae17c7f0b132383bd24a3bbb15c", + "panel_kind": "isotropic", + "panel_seed": 622580746501599869, + "realization": 18, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b3706b2e2ccd4815369181db04843112d0acb2d658f6d2e5bb3c6570ae076f91", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.36467483176070276, + "kernel_residual": 1.0386781587823134e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.214882039991057, + "minus_external_entropy": 0.9744638323531402, + "minus_target_effective_rank": 29.985956196646086, + "minus_target_entropy": 0.897520556143872, + "minus_weight": 54.809459741110025, + "orthogonality_relative_error": 2.1831656198081942e-16, + "plus_external_effective_rank": 7.214882039991063, + "plus_external_entropy": 0.9744638323531402, + "plus_target_effective_rank": 29.98595619664609, + "plus_target_entropy": 0.8975205561438719, + "plus_weight": 54.80945974111003, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "0acc97a206b04006078089414aae89dd4fc6cf4bd4420512d2fe544aeaa6454f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.352081+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "09f15469555cc7e4e1bffff509700e835f0b8a5eb951237bd156ce1268e12ccb", + "panel_kind": "sparse", + "panel_seed": 16172746946472565369, + "realization": 19, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fab2ed461be8b6a06f65d86ef0d5272094faf7c864e2b899f2bc395e67547e45", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3639732936604348, + "kernel_residual": 1.0632504847169535e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.619571016737808, + "minus_external_entropy": 0.9511091536033534, + "minus_target_effective_rank": 25.450453719703358, + "minus_target_entropy": 0.9556164818907078, + "minus_weight": 56.068951100572775, + "orthogonality_relative_error": 1.9384798905447985e-16, + "plus_external_effective_rank": 6.619571016737814, + "plus_external_entropy": 0.9511091536033535, + "plus_target_effective_rank": 25.450453719703365, + "plus_target_entropy": 0.955616481890708, + "plus_weight": 56.06895110057279, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "499f6a8d05c79a8af689ab5b5c46b28fd38d2647414bf71bb5c4a7ee5538448c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.448531+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "09f15469555cc7e4e1bffff509700e835f0b8a5eb951237bd156ce1268e12ccb", + "panel_kind": "isotropic", + "panel_seed": 16172746946472565369, + "realization": 19, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5408520dd26b3531ece3b258e638ce4695cdb4a6c4fe1303694ae8d871154617", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3639732936604348, + "kernel_residual": 1.0632504847169535e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.189527903155194, + "minus_external_entropy": 0.9740268775523667, + "minus_target_effective_rank": 30.031048873865327, + "minus_target_entropy": 0.8978962169027865, + "minus_weight": 53.87570325459101, + "orthogonality_relative_error": 1.833895532555839e-16, + "plus_external_effective_rank": 7.189527903155197, + "plus_external_entropy": 0.9740268775523665, + "plus_target_effective_rank": 30.031048873865313, + "plus_target_entropy": 0.8978962169027869, + "plus_weight": 53.875703254591016, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "04714bbecf000656e715dc4294ddd027a27ee3e1d33285286c1435c84db2e4c7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.550219+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "f6ba4c43d01ef1839c9630955525484d721d20209cb60465340abf45e1d89666", + "panel_kind": "sparse", + "panel_seed": 5540539657471232395, + "realization": 20, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bb5e1dbbbb318df4262f140d85d278ff638a3ddedcda8397abc073ea369d61bc", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3244728598802648, + "kernel_residual": 9.407458251891029e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.929364488134903, + "minus_external_entropy": 0.9627010026577951, + "minus_target_effective_rank": 22.478892405357197, + "minus_target_entropy": 0.9427159118133448, + "minus_weight": 55.203370794892265, + "orthogonality_relative_error": 3.039417807978112e-16, + "plus_external_effective_rank": 6.929364488134904, + "plus_external_entropy": 0.9627010026577951, + "plus_target_effective_rank": 22.478892405357204, + "plus_target_entropy": 0.9427159118133448, + "plus_weight": 55.20337079489224, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "75844a61e9eefb3e6f870a8afc15d1b33638d0d73e9a3931fae7ea7b408c5848", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.645250+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "f6ba4c43d01ef1839c9630955525484d721d20209cb60465340abf45e1d89666", + "panel_kind": "isotropic", + "panel_seed": 5540539657471232395, + "realization": 20, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0b032c5b4ca77ee0a46f3a740785d041049836b9275a0ddabc14bc269a734b32", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3244728598802648, + "kernel_residual": 9.407458251891029e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.051283209121562, + "minus_external_entropy": 0.9697831021028197, + "minus_target_effective_rank": 30.07273987122339, + "minus_target_entropy": 0.8981434364970106, + "minus_weight": 56.358298619668965, + "orthogonality_relative_error": 3.057300715123277e-16, + "plus_external_effective_rank": 7.051283209121557, + "plus_external_entropy": 0.9697831021028197, + "plus_target_effective_rank": 30.072739871223398, + "plus_target_entropy": 0.8981434364970105, + "plus_weight": 56.35829861966894, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e092121d5859365fa8bc87a75bd55cd73036baa5ff90241bafc46501cd2df3b0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.750515+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1f4b834cf57626d755bb1f69c8ad2059bf6a8be20f59ec1bc024123a0076cbe2", + "panel_kind": "sparse", + "panel_seed": 16946374520226682116, + "realization": 21, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d232b39e0147d7492b3e6f60190c618085e6ecab1849f4b9857c50af1b52f505", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3256173514314861, + "kernel_residual": 9.50350977361131e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.806950625321102, + "minus_external_entropy": 0.9583331848942838, + "minus_target_effective_rank": 26.13641564920246, + "minus_target_entropy": 0.9559825994069976, + "minus_weight": 55.83609498504461, + "orthogonality_relative_error": 2.5518146647645507e-16, + "plus_external_effective_rank": 6.806950625321111, + "plus_external_entropy": 0.9583331848942839, + "plus_target_effective_rank": 26.136415649202466, + "plus_target_entropy": 0.9559825994069976, + "plus_weight": 55.83609498504458, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "c4098af0099fb03b82f6d38c87152a31d3b58f8ab60ab3b4b27782d6ff48af45", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.852936+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1f4b834cf57626d755bb1f69c8ad2059bf6a8be20f59ec1bc024123a0076cbe2", + "panel_kind": "isotropic", + "panel_seed": 16946374520226682116, + "realization": 21, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "813001233852e78f724d4ca489d4e42a4f9c6849c8bc4ea71621b73a9d94e9c4", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3256173514314861, + "kernel_residual": 9.50350977361131e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.333746607057441, + "minus_external_entropy": 0.9784616059461421, + "minus_target_effective_rank": 30.327723658459107, + "minus_target_entropy": 0.9013787974282578, + "minus_weight": 54.47148138217524, + "orthogonality_relative_error": 2.3576059776174464e-16, + "plus_external_effective_rank": 7.333746607057445, + "plus_external_entropy": 0.9784616059461423, + "plus_target_effective_rank": 30.32772365845911, + "plus_target_entropy": 0.9013787974282574, + "plus_weight": 54.4714813821752, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "b61c2cd2010f79e2b2eace82d07371521ca3e535274748d629f80f7dadb834e6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:03.955835+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ad47ea67ec2dc161c71979c4508c6b8415392cdde686cbf70ab1f00f6ad3b647", + "panel_kind": "sparse", + "panel_seed": 15809535641976001134, + "realization": 22, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bfbb25f60f718b2501fe4a5160dfd4d627e0abb12ad63fe664cbd65ba8abe23a", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30986919042010436, + "kernel_residual": 1.0123367091694878e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.587077273429888, + "minus_external_entropy": 0.9484205332326614, + "minus_target_effective_rank": 23.238803991953258, + "minus_target_entropy": 0.952708837452199, + "minus_weight": 57.18774589447265, + "orthogonality_relative_error": 2.677733649619349e-16, + "plus_external_effective_rank": 6.58707727342989, + "plus_external_entropy": 0.9484205332326616, + "plus_target_effective_rank": 23.238803991953258, + "plus_target_entropy": 0.9527088374521989, + "plus_weight": 57.18774589447262, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "db0971432929aac8e65b269a0f6ea8ca4bc6dbc352fb2a245a1109abcf40915e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.055639+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ad47ea67ec2dc161c71979c4508c6b8415392cdde686cbf70ab1f00f6ad3b647", + "panel_kind": "isotropic", + "panel_seed": 15809535641976001134, + "realization": 22, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1c38caf6bdcdbcbfcf0422d358fcc45f6217dd924d163d85547068e38618daad", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30986919042010436, + "kernel_residual": 1.0123367091694878e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.953395456316699, + "minus_external_entropy": 0.9661413834524765, + "minus_target_effective_rank": 29.43285809317356, + "minus_target_entropy": 0.8954777469766684, + "minus_weight": 56.275948972773406, + "orthogonality_relative_error": 2.507981403042116e-16, + "plus_external_effective_rank": 6.953395456316699, + "plus_external_entropy": 0.9661413834524765, + "plus_target_effective_rank": 29.432858093173564, + "plus_target_entropy": 0.8954777469766683, + "plus_weight": 56.27594897277339, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "20185b89af6115708b6c1ede61fc881028e6a783cb240ec21975dfa18cfacb3a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.161066+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "50624b1c15a23c087fb2c008bbf64bb31cdbf13d8e94156136cef531483eddc0", + "panel_kind": "sparse", + "panel_seed": 8116430984451738068, + "realization": 23, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c549b79ab9743ed693b4c5d79b0752aac2ff207235ce5752b796b0759cc70865", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30827320414910325, + "kernel_residual": 9.849714978598212e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.462984184714906, + "minus_external_entropy": 0.9439422287025737, + "minus_target_effective_rank": 23.867228141256188, + "minus_target_entropy": 0.9566473794064457, + "minus_weight": 57.38910937885127, + "orthogonality_relative_error": 1.6247538563667677e-16, + "plus_external_effective_rank": 6.4629841847149, + "plus_external_entropy": 0.9439422287025737, + "plus_target_effective_rank": 23.86722814125618, + "plus_target_entropy": 0.9566473794064457, + "plus_weight": 57.38910937885122, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6d0dc6d3480356b0e05e547331beb8ce860e8979c0a2279425a31025dffe8c7f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.255364+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "50624b1c15a23c087fb2c008bbf64bb31cdbf13d8e94156136cef531483eddc0", + "panel_kind": "isotropic", + "panel_seed": 8116430984451738068, + "realization": 23, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ad9a9a7aecf14fd7eb19cba079c8dbfa6cb631e6cabd9c4bafd3195c4b9b0c53", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30827320414910325, + "kernel_residual": 9.849714978598212e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.970271497186878, + "minus_external_entropy": 0.9668914868399983, + "minus_target_effective_rank": 29.355532511773198, + "minus_target_entropy": 0.8946601411405826, + "minus_weight": 57.123947326327055, + "orthogonality_relative_error": 1.7226355697116568e-16, + "plus_external_effective_rank": 6.970271497186873, + "plus_external_entropy": 0.966891486839998, + "plus_target_effective_rank": 29.355532511773177, + "plus_target_entropy": 0.8946601411405827, + "plus_weight": 57.123947326327, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "541498a18bd55a92032faa2a60ed3ef594536d5fbb933c2952316fbc65f3b8ca", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.361451+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "dac09ff86e4a52d94f465bc2b4fc5ff902a0eddecd26766b332268a2a748fc67", + "panel_kind": "sparse", + "panel_seed": 14739918944425602917, + "realization": 24, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "102a7b5a8cf8241ec6a383a2b757e3a32f33a54943769691e9c0bf102d6866fc", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.38160785604973996, + "kernel_residual": 9.63853253039875e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.283306584373373, + "minus_external_entropy": 0.9763549443690889, + "minus_target_effective_rank": 26.23515094793627, + "minus_target_entropy": 0.956839044374354, + "minus_weight": 54.244006009406704, + "orthogonality_relative_error": 2.3517975798052713e-16, + "plus_external_effective_rank": 7.283306584373369, + "plus_external_entropy": 0.9763549443690887, + "plus_target_effective_rank": 26.235150947936283, + "plus_target_entropy": 0.9568390443743541, + "plus_weight": 54.2440060094067, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "318dc9a4b4cc7a0c2c9285cdf5fe5669612943d0ddefec8a982c3801fe806b8a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.453278+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "dac09ff86e4a52d94f465bc2b4fc5ff902a0eddecd26766b332268a2a748fc67", + "panel_kind": "isotropic", + "panel_seed": 14739918944425602917, + "realization": 24, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9c6f6aeb9d395e4244c70e0f81dc8c86afa30e14f10d9d9232ed9261b30a3dcb", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.38160785604973996, + "kernel_residual": 9.63853253039875e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.216059044277745, + "minus_external_entropy": 0.9754945886881625, + "minus_target_effective_rank": 30.240401713791034, + "minus_target_entropy": 0.898118316750212, + "minus_weight": 53.71555780614533, + "orthogonality_relative_error": 2.306742295333721e-16, + "plus_external_effective_rank": 7.216059044277746, + "plus_external_entropy": 0.9754945886881625, + "plus_target_effective_rank": 30.24040171379106, + "plus_target_entropy": 0.8981183167502118, + "plus_weight": 53.7155578061453, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "974988727bb4cac7281afc02537cf4a4a4d018aec5f6b4e38b6ee1e82d796c3a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.579023+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "2c8c2f939063699f5c1df6114cccb0a51508192c538ed8dcaaa9635d842ab6ed", + "panel_kind": "sparse", + "panel_seed": 6321806154450624549, + "realization": 25, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "da67545ed329fa6ae48f1aedbe18e42fbb77ea7da4ab22e2a718bd8305e8ee22", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29979471995585666, + "kernel_residual": 9.670092073460438e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.7997945404414875, + "minus_external_entropy": 0.9581759489203823, + "minus_target_effective_rank": 22.433299045179627, + "minus_target_entropy": 0.943323712186164, + "minus_weight": 56.39789698971573, + "orthogonality_relative_error": 2.1283442078749752e-16, + "plus_external_effective_rank": 6.7997945404414875, + "plus_external_entropy": 0.9581759489203823, + "plus_target_effective_rank": 22.433299045179645, + "plus_target_entropy": 0.9433237121861638, + "plus_weight": 56.39789698971566, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "d0e8c07c1594f2c45070784590146ef3b649c0a504f0607e2484fd12c862ba8d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.839946+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "2c8c2f939063699f5c1df6114cccb0a51508192c538ed8dcaaa9635d842ab6ed", + "panel_kind": "isotropic", + "panel_seed": 6321806154450624549, + "realization": 25, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "09e68b88a8ac28bc7e165fb07bd559b21c34c2b7f42481dfa8c1abf964d4116a", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29979471995585666, + "kernel_residual": 9.670092073460438e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.885816580265418, + "minus_external_entropy": 0.9640634308805521, + "minus_target_effective_rank": 29.533145998207715, + "minus_target_entropy": 0.8965102879536299, + "minus_weight": 58.69226125148619, + "orthogonality_relative_error": 2.2066581352936303e-16, + "plus_external_effective_rank": 6.885816580265425, + "plus_external_entropy": 0.9640634308805521, + "plus_target_effective_rank": 29.53314599820773, + "plus_target_entropy": 0.8965102879536299, + "plus_weight": 58.692261251486116, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "c90c8ab1afd03ad7aebd9fecfd7c882b2912339120de226d28af92d1cfb3b9dd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:04.989466+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "cbbd7aafbf2d4c57a1b368505aabf51df47c4853343daf224d0ff34f4fd0f1f8", + "panel_kind": "sparse", + "panel_seed": 7966195206646712476, + "realization": 26, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "29606c1c51fd9f7100c5bcab7e69e0aa27a34e65c8291d71c72413735c73b781", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.33866533266258375, + "kernel_residual": 1.0539201552076208e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.56147001874957, + "minus_external_entropy": 0.9498048691654616, + "minus_target_effective_rank": 24.60835995546224, + "minus_target_entropy": 0.9536819186955936, + "minus_weight": 57.067787179177806, + "orthogonality_relative_error": 1.8954971828459144e-16, + "plus_external_effective_rank": 6.56147001874957, + "plus_external_entropy": 0.9498048691654617, + "plus_target_effective_rank": 24.608359955462245, + "plus_target_entropy": 0.9536819186955937, + "plus_weight": 57.06778717917782, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "84d39b2078fdc152ec7f2250b9f78b504b76f723da45f1f4b01084c64181faf2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.114056+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "cbbd7aafbf2d4c57a1b368505aabf51df47c4853343daf224d0ff34f4fd0f1f8", + "panel_kind": "isotropic", + "panel_seed": 7966195206646712476, + "realization": 26, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "887dfd64ee4e4c85d849c8aa88f8d10cb3042443504f1dbe70c7775d06613870", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.33866533266258375, + "kernel_residual": 1.0539201552076208e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.159074505447569, + "minus_external_entropy": 0.9732444511630691, + "minus_target_effective_rank": 29.96549648171596, + "minus_target_entropy": 0.8983986702102298, + "minus_weight": 54.699265763729315, + "orthogonality_relative_error": 1.7827109472184285e-16, + "plus_external_effective_rank": 7.159074505447571, + "plus_external_entropy": 0.9732444511630693, + "plus_target_effective_rank": 29.96549648171594, + "plus_target_entropy": 0.8983986702102298, + "plus_weight": 54.69926576372932, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "b6c703858b515bb49a1c38c0978a5447f2c1599f1904e8a0338af40377b6d3a9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.260249+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ebbc38daf2bfbdb5126b4855b63cba7b17c9dd591e4e58dd6402b15f569a4a5b", + "panel_kind": "sparse", + "panel_seed": 11394658273627970405, + "realization": 27, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "daa7c7362e3bff876dcc9fef301290585184ed12b2ce341a03275e3c7a217da4", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.32289944392036246, + "kernel_residual": 1.0300460319996752e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.664750618876657, + "minus_external_entropy": 0.9532428859395412, + "minus_target_effective_rank": 25.21077788042547, + "minus_target_entropy": 0.9513517033132246, + "minus_weight": 57.563946071058226, + "orthogonality_relative_error": 2.1777000068544e-16, + "plus_external_effective_rank": 6.664750618876659, + "plus_external_entropy": 0.9532428859395414, + "plus_target_effective_rank": 25.210777880425464, + "plus_target_entropy": 0.9513517033132247, + "plus_weight": 57.56394607105818, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "92dccfb73e8a0fd1184505fea195c19515710e1e8751f3125558f4a63a3514cf", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.390785+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ebbc38daf2bfbdb5126b4855b63cba7b17c9dd591e4e58dd6402b15f569a4a5b", + "panel_kind": "isotropic", + "panel_seed": 11394658273627970405, + "realization": 27, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cad35ef10a6379632b10c4c69500ec4b05e6c0db3ffa490d4982e7b8f39dcd0e", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.32289944392036246, + "kernel_residual": 1.0300460319996752e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.784413467769765, + "minus_external_entropy": 0.9591187595158003, + "minus_target_effective_rank": 29.708832397312545, + "minus_target_entropy": 0.8965227073033837, + "minus_weight": 58.877181237642304, + "orthogonality_relative_error": 2.293908320794218e-16, + "plus_external_effective_rank": 6.78441346776977, + "plus_external_entropy": 0.9591187595158004, + "plus_target_effective_rank": 29.708832397312563, + "plus_target_entropy": 0.8965227073033838, + "plus_weight": 58.87718123764225, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "21042ec2cb2d9959d24f571b6c5c42856440c35f3bcd8035b7e1d73ea64b7ed6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.498433+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ec274c92b9bb10ec83879700645a13394cbae1dede7841f9682dbcbd195f8200", + "panel_kind": "sparse", + "panel_seed": 9042812720163572080, + "realization": 28, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "229fad1d585c7209c6f0e925d33de1cd58d48f8949240f7b7e2c30406d14ee11", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3404279332917626, + "kernel_residual": 9.433101655659557e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.85285732327501, + "minus_external_entropy": 0.9632991902487493, + "minus_target_effective_rank": 23.21672839004285, + "minus_target_entropy": 0.949963318737306, + "minus_weight": 54.79014854355606, + "orthogonality_relative_error": 2.1666361177310027e-16, + "plus_external_effective_rank": 6.852857323275006, + "plus_external_entropy": 0.9632991902487491, + "plus_target_effective_rank": 23.216728390042856, + "plus_target_entropy": 0.949963318737306, + "plus_weight": 54.79014854355605, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "f15c38ab0e114518ce37376dbd550077d8404a537daa8e534de691937c889481", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.594153+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ec274c92b9bb10ec83879700645a13394cbae1dede7841f9682dbcbd195f8200", + "panel_kind": "isotropic", + "panel_seed": 9042812720163572080, + "realization": 28, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4ea4e9f09625ffd626dafcfd9b2b66ef95f22c8bc4c0effc89bcb13b8e4e5144", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3404279332917626, + "kernel_residual": 9.433101655659557e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.119514074332493, + "minus_external_entropy": 0.971397728435147, + "minus_target_effective_rank": 29.240080235047376, + "minus_target_entropy": 0.8939193137952118, + "minus_weight": 53.967584713980024, + "orthogonality_relative_error": 2.1894556343706477e-16, + "plus_external_effective_rank": 7.119514074332488, + "plus_external_entropy": 0.971397728435147, + "plus_target_effective_rank": 29.24008023504738, + "plus_target_entropy": 0.893919313795212, + "plus_weight": 53.96758471398, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "fdeeee7f5ccf1a87b25aac14bfa6cbcae14fa7f901a9bddc570a65a4d9b28103", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.695111+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "7e93f60ea948564d250e48bc09a6f369f8acf30c300fe0bc2b9c636ced22d7aa", + "panel_kind": "sparse", + "panel_seed": 10958938296146392478, + "realization": 29, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d43c52edf02b41ab1ee1291cb9754627bf8b2f3b595806756549fe4223471f67", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3598470945259208, + "kernel_residual": 1.0584930635392341e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.013563037284025, + "minus_external_entropy": 0.9676451416024788, + "minus_target_effective_rank": 24.47906218971633, + "minus_target_entropy": 0.953243517861783, + "minus_weight": 53.57159806341478, + "orthogonality_relative_error": 1.8539661394525442e-16, + "plus_external_effective_rank": 7.013563037284024, + "plus_external_entropy": 0.9676451416024788, + "plus_target_effective_rank": 24.47906218971633, + "plus_target_entropy": 0.9532435178617829, + "plus_weight": 53.57159806341477, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e06e9f7199d03b8a23e39c49ebcf45ba826d4087d40d3f84bddbacbcddf005c7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.792127+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "7e93f60ea948564d250e48bc09a6f369f8acf30c300fe0bc2b9c636ced22d7aa", + "panel_kind": "isotropic", + "panel_seed": 10958938296146392478, + "realization": 29, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "31cdc098c420f51cfbdac6201d7a0336c74337a7ea131ba79104e07f58b7953c", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3598470945259208, + "kernel_residual": 1.0584930635392341e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.246473202778986, + "minus_external_entropy": 0.9759006858000643, + "minus_target_effective_rank": 29.936972193847655, + "minus_target_entropy": 0.8991417695056881, + "minus_weight": 54.096881278268775, + "orthogonality_relative_error": 1.857434131709718e-16, + "plus_external_effective_rank": 7.246473202778989, + "plus_external_entropy": 0.9759006858000643, + "plus_target_effective_rank": 29.93697219384764, + "plus_target_entropy": 0.8991417695056885, + "plus_weight": 54.09688127826877, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "4e66453baaaa30f4a1035ac9c99529e3f4e82e5bac94cf4834d72740f3b0f5b7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.896475+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "3aba1be75624e0355f89c1458fedab1df8dc58c36854e23abb5dc242433d2c91", + "panel_kind": "sparse", + "panel_seed": 7986912027498248804, + "realization": 30, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "127663c6267c8479fff5cf18cda74ed85b19a1278732c17aa7f09a340b63e0fc", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.38318743182948967, + "kernel_residual": 9.667836133374428e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.991776554968171, + "minus_external_entropy": 0.9657611053144289, + "minus_target_effective_rank": 26.541114620927033, + "minus_target_entropy": 0.9533859635319265, + "minus_weight": 54.4370810401108, + "orthogonality_relative_error": 1.8164526240520933e-16, + "plus_external_effective_rank": 6.991776554968174, + "plus_external_entropy": 0.9657611053144289, + "plus_target_effective_rank": 26.54111462092704, + "plus_target_entropy": 0.9533859635319266, + "plus_weight": 54.43708104011078, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e93545052979047148451cd3894edad5616b9bb61426d81d0a412e4931892704", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:05.994878+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "3aba1be75624e0355f89c1458fedab1df8dc58c36854e23abb5dc242433d2c91", + "panel_kind": "isotropic", + "panel_seed": 7986912027498248804, + "realization": 30, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "07827654afd52afa464a0b114da96f3e904eaafbf33e9ec1837233f6fc406318", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.38318743182948967, + "kernel_residual": 9.667836133374428e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.283955350937265, + "minus_external_entropy": 0.976785283818127, + "minus_target_effective_rank": 30.229044370289436, + "minus_target_entropy": 0.8983713675960224, + "minus_weight": 54.014785459992304, + "orthogonality_relative_error": 1.7483999274340416e-16, + "plus_external_effective_rank": 7.2839553509372665, + "plus_external_entropy": 0.9767852838181275, + "plus_target_effective_rank": 30.229044370289436, + "plus_target_entropy": 0.8983713675960225, + "plus_weight": 54.01478545999228, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "7bcda4e247bf2f3ceb0dc57a7950ab548400476ed09a99224c5ee82572f13b69", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.096428+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "3203598425d2a947878200869618b38c6430e5c9ea176ab6ae2c5c8bc952c8cd", + "panel_kind": "sparse", + "panel_seed": 12501857984869979477, + "realization": 31, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "99087350aae32ab453e78da78663c7b96df7984dcb40bf97e232994410fb9447", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2906922695429446, + "kernel_residual": 1.0254795133629593e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.8555509512312796, + "minus_external_entropy": 0.9620617551710268, + "minus_target_effective_rank": 24.841145050902007, + "minus_target_entropy": 0.9480116043061866, + "minus_weight": 55.02866757902368, + "orthogonality_relative_error": 2.0100948870658936e-16, + "plus_external_effective_rank": 6.855550951231281, + "plus_external_entropy": 0.962061755171027, + "plus_target_effective_rank": 24.84114505090202, + "plus_target_entropy": 0.9480116043061866, + "plus_weight": 55.02866757902368, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "8e33c9ae03fc42b1d5e14657c822f958bdc7f538654fb9f0eac8c30b5221f8d5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.192426+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "3203598425d2a947878200869618b38c6430e5c9ea176ab6ae2c5c8bc952c8cd", + "panel_kind": "isotropic", + "panel_seed": 12501857984869979477, + "realization": 31, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c1ba4601896b1c8ae35fa607febfe91baedcc25fbd09fe20e595269a9656c6a5", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2906922695429446, + "kernel_residual": 1.0254795133629593e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.78770411346349, + "minus_external_entropy": 0.9621472452041426, + "minus_target_effective_rank": 29.704891766572917, + "minus_target_entropy": 0.8967961675234425, + "minus_weight": 56.22996340538977, + "orthogonality_relative_error": 2.0175798473637335e-16, + "plus_external_effective_rank": 6.787704113463491, + "plus_external_entropy": 0.9621472452041429, + "plus_target_effective_rank": 29.704891766572928, + "plus_target_entropy": 0.8967961675234426, + "plus_weight": 56.22996340538977, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "b9244576e116d112df1c9311a60b07511b83738a4adc6ea35bc9e8e518c0b3a0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.292167+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "6aa217218edd6c8ce9d5d74a89f887b0dde41e0a6749def0879f19a37eecf9af", + "panel_kind": "sparse", + "panel_seed": 16513817055896311692, + "realization": 32, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bedaa715c7211832d4140896f9b54f37d7ba1c96608aaa7e7b948ef8ddf69b12", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3094892051983197, + "kernel_residual": 9.571582478148274e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.485388646573045, + "minus_external_entropy": 0.9449110015556752, + "minus_target_effective_rank": 22.730974498840343, + "minus_target_entropy": 0.9470396478371055, + "minus_weight": 57.670642098735556, + "orthogonality_relative_error": 1.886127107248666e-16, + "plus_external_effective_rank": 6.4853886465730435, + "plus_external_entropy": 0.9449110015556753, + "plus_target_effective_rank": 22.730974498840332, + "plus_target_entropy": 0.9470396478371055, + "plus_weight": 57.67064209873553, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "930a9a03fc64afc2270fdbb80af2ca2e9fe96d1d22b96a4a21c7ffb42f99245e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.389100+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "6aa217218edd6c8ce9d5d74a89f887b0dde41e0a6749def0879f19a37eecf9af", + "panel_kind": "isotropic", + "panel_seed": 16513817055896311692, + "realization": 32, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2be3060d054dde43a96627304ceb07c9ef6e1a8e62234f3af4a916830c2c716b", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3094892051983197, + "kernel_residual": 9.571582478148274e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.944377793841251, + "minus_external_entropy": 0.9655730501560504, + "minus_target_effective_rank": 30.503180412690828, + "minus_target_entropy": 0.9019969219136621, + "minus_weight": 57.187912464411085, + "orthogonality_relative_error": 1.8319530067921874e-16, + "plus_external_effective_rank": 6.944377793841245, + "plus_external_entropy": 0.9655730501560502, + "plus_target_effective_rank": 30.503180412690817, + "plus_target_entropy": 0.9019969219136621, + "plus_weight": 57.18791246441107, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "4f2879498d46e1265dad2aa98901265d3b258050de55fcc161ee8a2d93ceb7d6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.489987+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "fe90d9c5497a6956f5a099cca03ec90432a301eac4e11b4c7d39fc2cdf8dcb03", + "panel_kind": "sparse", + "panel_seed": 11537612185872519621, + "realization": 33, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fa4ed1261f8218a7b2fc293b18aac9ad23b03e51e2b63b82933baa37519306ad", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.28800300960871456, + "kernel_residual": 9.54194665260879e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.480735237427451, + "minus_external_entropy": 0.9486346767640781, + "minus_target_effective_rank": 26.176844532412524, + "minus_target_entropy": 0.9513852849657861, + "minus_weight": 59.163277969098296, + "orthogonality_relative_error": 1.8419313807928227e-16, + "plus_external_effective_rank": 6.480735237427451, + "plus_external_entropy": 0.9486346767640781, + "plus_target_effective_rank": 26.17684453241252, + "plus_target_entropy": 0.9513852849657861, + "plus_weight": 59.16327796909827, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "328f5916ca9636b41215a86eb6642951e553616417e02eb021db2bf8c7e6ba47", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.582968+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "fe90d9c5497a6956f5a099cca03ec90432a301eac4e11b4c7d39fc2cdf8dcb03", + "panel_kind": "isotropic", + "panel_seed": 11537612185872519621, + "realization": 33, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "46f35464e3281402b34132520569ae2f39d75dfbad2499d7e656f222a43f3d9d", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.28800300960871456, + "kernel_residual": 9.54194665260879e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.752180363423046, + "minus_external_entropy": 0.9598981117372392, + "minus_target_effective_rank": 29.56763888463111, + "minus_target_entropy": 0.8966046512869547, + "minus_weight": 58.333106889303124, + "orthogonality_relative_error": 1.7233786265418592e-16, + "plus_external_effective_rank": 6.7521803634230455, + "plus_external_entropy": 0.9598981117372392, + "plus_target_effective_rank": 29.567638884631105, + "plus_target_entropy": 0.8966046512869544, + "plus_weight": 58.3331068893031, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "98ef205d959fa8f2fcfa2e2ab5be76adcd07a215f1acad1d4858cd036d382b05", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.680531+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "706b4b19bdcb64d2dbcdb283938c7cf0aaead7aedc3fb067a761c611a5eafa44", + "panel_kind": "sparse", + "panel_seed": 5932467768474802875, + "realization": 34, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "793c172fa0aa333a8edb325866a37496a9e74f09c0e3947e68414b40f934a3ad", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3296070557545598, + "kernel_residual": 1.0190851948106087e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.014604091754885, + "minus_external_entropy": 0.9675060369570181, + "minus_target_effective_rank": 25.331000412935047, + "minus_target_entropy": 0.9497810147195094, + "minus_weight": 54.829896468343975, + "orthogonality_relative_error": 1.911824222776462e-16, + "plus_external_effective_rank": 7.014604091754888, + "plus_external_entropy": 0.9675060369570181, + "plus_target_effective_rank": 25.33100041293505, + "plus_target_entropy": 0.9497810147195097, + "plus_weight": 54.829896468343975, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "4d1f498d4690bd5b5f46d052962e33f8c7baa8c700b25a5a3b293cc2402b08ba", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.774509+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "706b4b19bdcb64d2dbcdb283938c7cf0aaead7aedc3fb067a761c611a5eafa44", + "panel_kind": "isotropic", + "panel_seed": 5932467768474802875, + "realization": 34, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a17b4041c51764c0265b287474e351e0f197f5e615ef116437be92870a50adff", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3296070557545598, + "kernel_residual": 1.0190851948106087e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.126685116255177, + "minus_external_entropy": 0.971995290132715, + "minus_target_effective_rank": 30.20235325342857, + "minus_target_entropy": 0.8996578538336064, + "minus_weight": 54.86004056231948, + "orthogonality_relative_error": 1.9244187144372721e-16, + "plus_external_effective_rank": 7.126685116255176, + "plus_external_entropy": 0.971995290132715, + "plus_target_effective_rank": 30.202353253428587, + "plus_target_entropy": 0.8996578538336064, + "plus_weight": 54.86004056231948, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "c213e7646d04a9e9621eeae2891391170c3c39e5012208305b1e9490c0eed6a4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.875029+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "689b8a2717cda9822652e11baf524c086f9d1d9ce289ff90ec750b9bb812abe7", + "panel_kind": "sparse", + "panel_seed": 2060376366639230205, + "realization": 35, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "36d9802d3df795571b3850ed72f0efff53bab0b8ad6ef2c671af160dce6e625f", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31561879797412823, + "kernel_residual": 9.91319921545497e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.239994061139465, + "minus_external_entropy": 0.9349735904940323, + "minus_target_effective_rank": 21.97310778263433, + "minus_target_entropy": 0.9464727576762568, + "minus_weight": 56.000891731785885, + "orthogonality_relative_error": 2.0838200585328605e-16, + "plus_external_effective_rank": 6.239994061139471, + "plus_external_entropy": 0.9349735904940323, + "plus_target_effective_rank": 21.97310778263433, + "plus_target_entropy": 0.9464727576762568, + "plus_weight": 56.0008917317859, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "8322d6bcfb43c74f80042996a900a22446134af16d477f393a0fc5c12968787a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:06.968063+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "689b8a2717cda9822652e11baf524c086f9d1d9ce289ff90ec750b9bb812abe7", + "panel_kind": "isotropic", + "panel_seed": 2060376366639230205, + "realization": 35, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4f1f0677c1d140227634b4e3972a10f5af1aa786788a0d409e4f09af7e4a197a", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31561879797412823, + "kernel_residual": 9.91319921545497e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.226221162393649, + "minus_external_entropy": 0.9754682627559782, + "minus_target_effective_rank": 30.026577925169082, + "minus_target_entropy": 0.8988395349150938, + "minus_weight": 55.572750668693246, + "orthogonality_relative_error": 1.9382195832855033e-16, + "plus_external_effective_rank": 7.226221162393649, + "plus_external_entropy": 0.9754682627559782, + "plus_target_effective_rank": 30.026577925169075, + "plus_target_entropy": 0.8988395349150938, + "plus_weight": 55.57275066869325, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "5aebad281e1f4bc55657e498b0c839c0464f36909a9ecce0721ceb44e24ccb8c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.065420+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "58847d531085d0c3b71a51bbf7322e217d4aff12edd173fc0298b92fa9cd4fe5", + "panel_kind": "sparse", + "panel_seed": 10035671260458008558, + "realization": 36, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "78727cac71c9b1fb023f0b530b02f0aa5203943561e0f714ccd40c825562b895", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3718726479260771, + "kernel_residual": 9.229670490035076e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.033944168903004, + "minus_external_entropy": 0.9686309531923666, + "minus_target_effective_rank": 24.65465546989867, + "minus_target_entropy": 0.9497418499386084, + "minus_weight": 53.172371375223946, + "orthogonality_relative_error": 1.5712275345203328e-16, + "plus_external_effective_rank": 7.033944168903004, + "plus_external_entropy": 0.9686309531923666, + "plus_target_effective_rank": 24.654655469898657, + "plus_target_entropy": 0.9497418499386083, + "plus_weight": 53.17237137522396, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "fd82bd32128e1a2928aea90a8c51021bed40de3cea40220b183c7009d36b942d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.158392+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "58847d531085d0c3b71a51bbf7322e217d4aff12edd173fc0298b92fa9cd4fe5", + "panel_kind": "isotropic", + "panel_seed": 10035671260458008558, + "realization": 36, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f3ae23b70d802df70504c0887125c201499a069efd51eafcfe9c440540dcebfe", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3718726479260771, + "kernel_residual": 9.229670490035076e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.2594699154648055, + "minus_external_entropy": 0.9764334543970278, + "minus_target_effective_rank": 30.276045183894777, + "minus_target_entropy": 0.899261223420693, + "minus_weight": 54.61511167766331, + "orthogonality_relative_error": 1.5741200749543579e-16, + "plus_external_effective_rank": 7.259469915464804, + "plus_external_entropy": 0.9764334543970278, + "plus_target_effective_rank": 30.27604518389479, + "plus_target_entropy": 0.899261223420693, + "plus_weight": 54.615111677663336, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "1abdd39f7ec9877bdf358f56347847366fbdc003889b65153862d3c2a02c8e96", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.262631+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e3fd22b8bf27d37fcb5ea8de0847d06281a855c4579c651069dacaece9da02fb", + "panel_kind": "sparse", + "panel_seed": 10007530200759712625, + "realization": 37, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d8f009bcdad514a7565388e415c0154ad5f6bfec0d31268ba6f8a5be4cf70c5f", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2628086755093512, + "kernel_residual": 1.0536237340896794e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.473252835613785, + "minus_external_entropy": 0.9475396155662741, + "minus_target_effective_rank": 23.860442855347806, + "minus_target_entropy": 0.946270134666226, + "minus_weight": 61.22943378034046, + "orthogonality_relative_error": 2.1933138470290251e-16, + "plus_external_effective_rank": 6.473252835613789, + "plus_external_entropy": 0.9475396155662741, + "plus_target_effective_rank": 23.86044285534781, + "plus_target_entropy": 0.946270134666226, + "plus_weight": 61.22943378034045, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6982d42ebd7e895e903ceae9c5a18e0bb4680ad3472363fba9d7d53318022859", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.356227+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e3fd22b8bf27d37fcb5ea8de0847d06281a855c4579c651069dacaece9da02fb", + "panel_kind": "isotropic", + "panel_seed": 10007530200759712625, + "realization": 37, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "90be60453bf5f508f1db203edaa3ed214bfd85e2d998e32372e81175f84d475e", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2628086755093512, + "kernel_residual": 1.0536237340896794e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.5549124006378445, + "minus_external_entropy": 0.9519477947478338, + "minus_target_effective_rank": 28.537786473213412, + "minus_target_entropy": 0.8905832370982185, + "minus_weight": 58.97217598312726, + "orthogonality_relative_error": 2.2425459539475917e-16, + "plus_external_effective_rank": 6.5549124006378445, + "plus_external_entropy": 0.9519477947478338, + "plus_target_effective_rank": 28.537786473213416, + "plus_target_entropy": 0.8905832370982185, + "plus_weight": 58.972175983127244, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "bc22e64ef5751294acce8ee3761a597631c5dd236e2b6923cf1227e4e3a005a6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.455280+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "9d31ea86584f6ffb960e4cfbc7291e2fbe3d565924174ca37a397fb1a69fe473", + "panel_kind": "sparse", + "panel_seed": 18162057018034688398, + "realization": 38, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "84fc91637e5c216d28d559c80b4e8bd6721f94598a52864ca894dec00807e561", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31493110733768487, + "kernel_residual": 1.0063164460205464e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.576779504668236, + "minus_external_entropy": 0.9529394326411514, + "minus_target_effective_rank": 26.889273926966695, + "minus_target_entropy": 0.9560603225780195, + "minus_weight": 58.34041747254629, + "orthogonality_relative_error": 2.007440931175146e-16, + "plus_external_effective_rank": 6.5767795046682265, + "plus_external_entropy": 0.9529394326411511, + "plus_target_effective_rank": 26.88927392696668, + "plus_target_entropy": 0.9560603225780195, + "plus_weight": 58.34041747254628, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "d5805fc6bc1d01dc51c1d010deced78817ae3a8e0d25f4e81c16ac5c234080e0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.549323+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "9d31ea86584f6ffb960e4cfbc7291e2fbe3d565924174ca37a397fb1a69fe473", + "panel_kind": "isotropic", + "panel_seed": 18162057018034688398, + "realization": 38, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c33cd5f3e044396164a3d4488c78cb8da623861667e57a458de8c9a739c288d5", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31493110733768487, + "kernel_residual": 1.0063164460205464e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.7522378962569825, + "minus_external_entropy": 0.958132903128423, + "minus_target_effective_rank": 28.42852868812203, + "minus_target_entropy": 0.888189169265816, + "minus_weight": 57.85977411837008, + "orthogonality_relative_error": 1.9937029743936122e-16, + "plus_external_effective_rank": 6.752237896256982, + "plus_external_entropy": 0.9581329031284229, + "plus_target_effective_rank": 28.428528688122015, + "plus_target_entropy": 0.8881891692658161, + "plus_weight": 57.85977411837007, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "2b08e4c87feb76d284abd3ea465f9a56ec915672e4ecaafadb0c9b642808ac96", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.659652+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5c0b1804456d617c7b0b36d3ed57ba17e06169311b4adaa074d0aaf65d5dfe70", + "panel_kind": "sparse", + "panel_seed": 14002138720243123439, + "realization": 39, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "af6f465a74bf81f69767a0bf806d6af3debf15f1755b1cb7df07a8bec1c75b05", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31744035917676444, + "kernel_residual": 1.0066120846390991e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.691267669430957, + "minus_external_entropy": 0.9541282799315978, + "minus_target_effective_rank": 24.19988865444429, + "minus_target_entropy": 0.953823051514265, + "minus_weight": 56.531815199791566, + "orthogonality_relative_error": 2.4042824236784417e-16, + "plus_external_effective_rank": 6.691267669430962, + "plus_external_entropy": 0.9541282799315978, + "plus_target_effective_rank": 24.199888654444297, + "plus_target_entropy": 0.953823051514265, + "plus_weight": 56.53181519979159, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "8fd252b95597157523ff51e146874bdcf34fa5aa3da17ed1768adce6b954b1a4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.751872+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5c0b1804456d617c7b0b36d3ed57ba17e06169311b4adaa074d0aaf65d5dfe70", + "panel_kind": "isotropic", + "panel_seed": 14002138720243123439, + "realization": 39, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5a573f2c722cef05af8614ee07c91965c53f7c548378aea688ed6da991d84cec", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31744035917676444, + "kernel_residual": 1.0066120846390991e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.0017181258319585, + "minus_external_entropy": 0.967781393523791, + "minus_target_effective_rank": 29.408964718876682, + "minus_target_entropy": 0.8950909466505026, + "minus_weight": 56.112036929579965, + "orthogonality_relative_error": 2.3764759212657136e-16, + "plus_external_effective_rank": 7.001718125831962, + "plus_external_entropy": 0.9677813935237912, + "plus_target_effective_rank": 29.408964718876682, + "plus_target_entropy": 0.8950909466505028, + "plus_weight": 56.11203692957998, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "4cc38326448642bd5aeaeeb363d8aab74ac5a583e1828b796a81c0ea18e8ef37", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.847963+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "8837cae6b4bff6e47e557ff380b9ebc7ba13f6bc3a121359214a514ba10d1e29", + "panel_kind": "sparse", + "panel_seed": 2176011905066923166, + "realization": 40, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "91ee9d31a99da00494f65783c9c2fdf3deee83e2738b23737d1df8ccb4b4c1f8", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.33896986140901875, + "kernel_residual": 9.942673475188356e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.88012396292307, + "minus_external_entropy": 0.9628494155208677, + "minus_target_effective_rank": 24.734201615040647, + "minus_target_entropy": 0.9526138612343639, + "minus_weight": 55.63668214965021, + "orthogonality_relative_error": 1.7727189727592472e-16, + "plus_external_effective_rank": 6.88012396292307, + "plus_external_entropy": 0.9628494155208677, + "plus_target_effective_rank": 24.734201615040654, + "plus_target_entropy": 0.9526138612343639, + "plus_weight": 55.63668214965026, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "ce7d79c832b59c44a8ecc31c8557edb01132e9e402aa329b8307fc2506e0f421", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:07.941601+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "8837cae6b4bff6e47e557ff380b9ebc7ba13f6bc3a121359214a514ba10d1e29", + "panel_kind": "isotropic", + "panel_seed": 2176011905066923166, + "realization": 40, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a36b31e3fd55665e3422c9ae53e6eef84a51eef94fe88f645d27efb599f5820d", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.33896986140901875, + "kernel_residual": 9.942673475188356e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.1325981992313565, + "minus_external_entropy": 0.9722031377468915, + "minus_target_effective_rank": 29.738461933971614, + "minus_target_entropy": 0.8970015972675823, + "minus_weight": 55.21246162719649, + "orthogonality_relative_error": 1.7168642939465458e-16, + "plus_external_effective_rank": 7.132598199231357, + "plus_external_entropy": 0.9722031377468917, + "plus_target_effective_rank": 29.738461933971617, + "plus_target_entropy": 0.8970015972675824, + "plus_weight": 55.21246162719653, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "a93b35ab70bd15e1f0567dd291256755a5a19cbf273021bfe4c224f607a70ce9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.049036+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5229cc62f41dca6d23da0cc7eb354454153cd90013ccfc8ad29728bb88514a9d", + "panel_kind": "sparse", + "panel_seed": 9019764504221411957, + "realization": 41, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "11c86e86b399f77c22e9a1fd32cb9e1a3199a598e853f55ef23956daafdc113c", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29767999603067247, + "kernel_residual": 9.69295510912148e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.886694316291258, + "minus_external_entropy": 0.9628725639452493, + "minus_target_effective_rank": 25.328835268327484, + "minus_target_entropy": 0.948898575665054, + "minus_weight": 57.17803851085995, + "orthogonality_relative_error": 2.1758452162082337e-16, + "plus_external_effective_rank": 6.886694316291262, + "plus_external_entropy": 0.9628725639452493, + "plus_target_effective_rank": 25.32883526832748, + "plus_target_entropy": 0.9488985756650538, + "plus_weight": 57.17803851085993, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e85787e5f93ae8315f772eaea650b36ab8b81116de58ed9734c502b81b3e4ff2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.142455+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5229cc62f41dca6d23da0cc7eb354454153cd90013ccfc8ad29728bb88514a9d", + "panel_kind": "isotropic", + "panel_seed": 9019764504221411957, + "realization": 41, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fc2d5336260fce0f66af90e80d162ed066bc81a5559daf07713612dd1a1dbb5c", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29767999603067247, + "kernel_residual": 9.69295510912148e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.704237842186996, + "minus_external_entropy": 0.9562340474521045, + "minus_target_effective_rank": 29.2824248750556, + "minus_target_entropy": 0.8945662714382359, + "minus_weight": 57.40823767002261, + "orthogonality_relative_error": 2.139183160699574e-16, + "plus_external_effective_rank": 6.704237842186994, + "plus_external_entropy": 0.9562340474521046, + "plus_target_effective_rank": 29.282424875055582, + "plus_target_entropy": 0.8945662714382362, + "plus_weight": 57.40823767002261, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "3c1abac3a270abc916e3d1cf7af5150a952f467d1fbaf62d7fb5c6265a404c90", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.240741+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "69729fc7b7844cf761a98a20231beac11a853cc747491f072c8cbd7db2aabb3b", + "panel_kind": "sparse", + "panel_seed": 11404692286524372123, + "realization": 42, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "600cb8064a78cdff9251d86ac5afed5b966940f95b80817b2f04f7d62c474668", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3491985132570413, + "kernel_residual": 9.489137579945976e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.280948424645332, + "minus_external_entropy": 0.976887008953518, + "minus_target_effective_rank": 28.624995882548006, + "minus_target_entropy": 0.9634204475152863, + "minus_weight": 55.81525964919496, + "orthogonality_relative_error": 2.0179888879129936e-16, + "plus_external_effective_rank": 7.280948424645324, + "plus_external_entropy": 0.976887008953518, + "plus_target_effective_rank": 28.62499588254799, + "plus_target_entropy": 0.9634204475152862, + "plus_weight": 55.815259649194935, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "8ee3d66b653fa8f7c1e9a45e039e334bda24ec491e6634f699e32b1a3dc15a52", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.335503+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "69729fc7b7844cf761a98a20231beac11a853cc747491f072c8cbd7db2aabb3b", + "panel_kind": "isotropic", + "panel_seed": 11404692286524372123, + "realization": 42, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "70548c44fdd681ba10bdf75db4c39fac56e4d84a14e3f967499eb255dbbdea74", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3491985132570413, + "kernel_residual": 9.489137579945976e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.154594321065732, + "minus_external_entropy": 0.9725176002371483, + "minus_target_effective_rank": 30.210332739991422, + "minus_target_entropy": 0.8985448819412267, + "minus_weight": 55.8942116602843, + "orthogonality_relative_error": 2.051169468723342e-16, + "plus_external_effective_rank": 7.154594321065726, + "plus_external_entropy": 0.9725176002371483, + "plus_target_effective_rank": 30.210332739991397, + "plus_target_entropy": 0.8985448819412268, + "plus_weight": 55.89421166028427, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "d83f69873743c46d706fb39d51bb22c4acc4ff27cb1290b41d633a33edf49374", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.434947+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "8d621a755a43c304a4fdd3f1863a598716f4e9d3a62308d3402c79895e6c64df", + "panel_kind": "sparse", + "panel_seed": 17131408974406178594, + "realization": 43, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "205492b7c30bd7a4fc83e2cb47f4caa55f5cd2fd2051e29cb52a6346c956b0fe", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31529532270423544, + "kernel_residual": 9.760807453112064e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.302185467778656, + "minus_external_entropy": 0.9409490381877216, + "minus_target_effective_rank": 23.805268521054284, + "minus_target_entropy": 0.9503771054501253, + "minus_weight": 56.22700907061515, + "orthogonality_relative_error": 2.48316833603052e-16, + "plus_external_effective_rank": 6.302185467778644, + "plus_external_entropy": 0.9409490381877212, + "plus_target_effective_rank": 23.80526852105428, + "plus_target_entropy": 0.9503771054501252, + "plus_weight": 56.22700907061529, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "abf0f0623a75e7bc48201e1d651a672f9df587cf3ca8c60b80fe67f316268cf9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.528395+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "8d621a755a43c304a4fdd3f1863a598716f4e9d3a62308d3402c79895e6c64df", + "panel_kind": "isotropic", + "panel_seed": 17131408974406178594, + "realization": 43, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1e61eceefdd65358cb02320f2e58968fa0aab797d1d71b8e2a60bfb3284c518c", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.31529532270423544, + "kernel_residual": 9.760807453112064e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.073443231669413, + "minus_external_entropy": 0.9708268042824649, + "minus_target_effective_rank": 29.96368882304039, + "minus_target_entropy": 0.8994473712897543, + "minus_weight": 56.23824225971234, + "orthogonality_relative_error": 2.5986440339869977e-16, + "plus_external_effective_rank": 7.073443231669402, + "plus_external_entropy": 0.9708268042824647, + "plus_target_effective_rank": 29.96368882304038, + "plus_target_entropy": 0.8994473712897542, + "plus_weight": 56.238242259712464, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "aebdd35145896b4a947382d0946ff300b00296acfd4482dc910e17dd9ed96bb9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.624547+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "a6f73763db08f9cdcc9be034428749201bf86800d7bc9ccfb30716216c74a1b7", + "panel_kind": "sparse", + "panel_seed": 10452910810935468794, + "realization": 44, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "34ac0d3d93584d44a3e11e8be4bbed4776d7b8a6a418221e3010dcd856779f31", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3593401167283206, + "kernel_residual": 1.0148475026771446e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.841054939915076, + "minus_external_entropy": 0.9623173215368862, + "minus_target_effective_rank": 24.154163793494487, + "minus_target_entropy": 0.9527673043915726, + "minus_weight": 53.46474177861535, + "orthogonality_relative_error": 1.8180147275507953e-16, + "plus_external_effective_rank": 6.841054939915081, + "plus_external_entropy": 0.9623173215368862, + "plus_target_effective_rank": 24.154163793494494, + "plus_target_entropy": 0.9527673043915725, + "plus_weight": 53.46474177861535, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "c07fd6226f16c5e484004b48bb242553058a1b0649b82f4a9a1a7432ff2d8f37", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.716939+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "a6f73763db08f9cdcc9be034428749201bf86800d7bc9ccfb30716216c74a1b7", + "panel_kind": "isotropic", + "panel_seed": 10452910810935468794, + "realization": 44, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "98bc7c9beb8684650cb1af6ee740363535269ac5ae9d81454b486e6aa7861d58", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3593401167283206, + "kernel_residual": 1.0148475026771446e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.329892685925249, + "minus_external_entropy": 0.9787150348705512, + "minus_target_effective_rank": 29.997792560644974, + "minus_target_entropy": 0.8985289789967729, + "minus_weight": 53.04174959923204, + "orthogonality_relative_error": 1.8875366658440907e-16, + "plus_external_effective_rank": 7.329892685925249, + "plus_external_entropy": 0.9787150348705512, + "plus_target_effective_rank": 29.997792560645, + "plus_target_entropy": 0.8985289789967723, + "plus_weight": 53.04174959923204, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "626e375abf89db3cb701b7c29af8354c25590826686f1c8fb746d85bd6404192", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.814366+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1e66101d60ae802d5f74a8d50e30f9e20d84e28e60b54a3bcaac0a88f358b661", + "panel_kind": "sparse", + "panel_seed": 2545204594319787093, + "realization": 45, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d375c9de22a2ba4048679247a88159858cb9c8a324c566961fe64db8ccc2bbdc", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3091751815974419, + "kernel_residual": 1.0051731060959005e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.124220835050001, + "minus_external_entropy": 0.9719775020440156, + "minus_target_effective_rank": 25.725550158103808, + "minus_target_entropy": 0.9595591426765477, + "minus_weight": 57.23364470956131, + "orthogonality_relative_error": 2.503656188960953e-16, + "plus_external_effective_rank": 7.124220835050009, + "plus_external_entropy": 0.9719775020440158, + "plus_target_effective_rank": 25.725550158103818, + "plus_target_entropy": 0.9595591426765477, + "plus_weight": 57.233644709561304, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "45b03e160c345327bf2600a5a0bc039ff28a5cec401eb60d3a55f07c362918a4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:08.906696+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1e66101d60ae802d5f74a8d50e30f9e20d84e28e60b54a3bcaac0a88f358b661", + "panel_kind": "isotropic", + "panel_seed": 2545204594319787093, + "realization": 45, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1116406ab919375e146a502c0af06aab3fd2c963b58b94ad623bfe18210fc4ec", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3091751815974419, + "kernel_residual": 1.0051731060959005e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.937133644722066, + "minus_external_entropy": 0.9657084537182549, + "minus_target_effective_rank": 29.299647651966513, + "minus_target_entropy": 0.8939838638579515, + "minus_weight": 55.84237933739159, + "orthogonality_relative_error": 2.5193813246566305e-16, + "plus_external_effective_rank": 6.937133644722072, + "plus_external_entropy": 0.9657084537182551, + "plus_target_effective_rank": 29.299647651966506, + "plus_target_entropy": 0.8939838638579516, + "plus_weight": 55.84237933739158, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "5bc3e4a57bc35b6b0339dc7da32dea66f5fd8ed2c11e829a3f08f35223454dc2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.005920+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "106d45f0df55e2c9bb9e57004828e836b2a05826e1bb7ca09cca4d0cf1456d1e", + "panel_kind": "sparse", + "panel_seed": 7818755242728806207, + "realization": 46, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8f6f2fc689f0bb495ab6a0428fe3654edcf0bcee580346a949a15ca4fd0e8757", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3374929659422562, + "kernel_residual": 9.807453318966246e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.02330675479242, + "minus_external_entropy": 0.9675184155477338, + "minus_target_effective_rank": 27.48611276133041, + "minus_target_entropy": 0.9590109835972958, + "minus_weight": 54.26780835097678, + "orthogonality_relative_error": 2.8317954521935306e-16, + "plus_external_effective_rank": 7.023306754792412, + "plus_external_entropy": 0.9675184155477333, + "plus_target_effective_rank": 27.486112761330407, + "plus_target_entropy": 0.9590109835972958, + "plus_weight": 54.26780835097685, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "4885fadafb155b5aece80299fe7aefd4f6e8727b509d9f766b62fbbb1024b4ca", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.099460+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "106d45f0df55e2c9bb9e57004828e836b2a05826e1bb7ca09cca4d0cf1456d1e", + "panel_kind": "isotropic", + "panel_seed": 7818755242728806207, + "realization": 46, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e29ec17a0b2d92336f8da66385b20d15acb992389f8e6e3d71c9bf0a3b882add", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3374929659422562, + "kernel_residual": 9.807453318966246e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.0578223115660315, + "minus_external_entropy": 0.9701341526243191, + "minus_target_effective_rank": 29.0535569915085, + "minus_target_entropy": 0.8940888776967104, + "minus_weight": 56.6653267608253, + "orthogonality_relative_error": 2.7415893713449643e-16, + "plus_external_effective_rank": 7.057822311566023, + "plus_external_entropy": 0.9701341526243189, + "plus_target_effective_rank": 29.05355699150849, + "plus_target_entropy": 0.8940888776967103, + "plus_weight": 56.665326760825366, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "7e247abed4f0c47cd49ba14babd9986d3a9b3537a140cf039b6717d14a31b014", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.197092+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "404308df70eb22e9d2803e21eabb6fba55cda3f1241bcbcd4025430cd043a214", + "panel_kind": "sparse", + "panel_seed": 11035902023735095670, + "realization": 47, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b0204467dad3babe862675debdd09e77a8b707e095341e9618b3727cfe761daf", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2979932182938613, + "kernel_residual": 9.499255441372454e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.436493463345236, + "minus_external_entropy": 0.9416837109804149, + "minus_target_effective_rank": 22.115657527539796, + "minus_target_entropy": 0.9437125477099025, + "minus_weight": 58.87781649799801, + "orthogonality_relative_error": 2.969535880846749e-16, + "plus_external_effective_rank": 6.436493463345237, + "plus_external_entropy": 0.9416837109804149, + "plus_target_effective_rank": 22.115657527539785, + "plus_target_entropy": 0.9437125477099024, + "plus_weight": 58.87781649799805, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "dafe5c7121c2772eea1d8139fb4c1ca1504cc79d9bddd9226381dc1fd0c1b003", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.290185+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "404308df70eb22e9d2803e21eabb6fba55cda3f1241bcbcd4025430cd043a214", + "panel_kind": "isotropic", + "panel_seed": 11035902023735095670, + "realization": 47, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1beb99ff6bb45128e315b11f3150e10ed7a3b91c74439cc2f1381c4ffb512177", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.2979932182938613, + "kernel_residual": 9.499255441372454e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.659418828925028, + "minus_external_entropy": 0.9553518387603858, + "minus_target_effective_rank": 29.501425295134787, + "minus_target_entropy": 0.8943329587204516, + "minus_weight": 58.846311129488235, + "orthogonality_relative_error": 3.4419380946193344e-16, + "plus_external_effective_rank": 6.659418828925019, + "plus_external_entropy": 0.9553518387603855, + "plus_target_effective_rank": 29.501425295134773, + "plus_target_entropy": 0.8943329587204515, + "plus_weight": 58.846311129488285, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "da3e613130eb885d29cbb7bc356096970696ce39fe4fe6383a80d5ad8b96c291", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.387611+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "3cba02e5d8a58456a583f7b27b9bf8b11560c4eec4c3dfcb2bdf6317cc6d2120", + "panel_kind": "sparse", + "panel_seed": 1270522715933114774, + "realization": 48, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bacb4f3ac916dad2c44081da312b2ae53606bf1f3a9280b139d0a736cec30d35", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29045400184951864, + "kernel_residual": 1.0451815672124029e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.549023220073909, + "minus_external_entropy": 0.9522871571936476, + "minus_target_effective_rank": 26.922013057277226, + "minus_target_entropy": 0.9567167336770083, + "minus_weight": 58.23690686757353, + "orthogonality_relative_error": 1.6736751579077656e-16, + "plus_external_effective_rank": 6.5490232200739085, + "plus_external_entropy": 0.9522871571936478, + "plus_target_effective_rank": 26.922013057277233, + "plus_target_entropy": 0.9567167336770082, + "plus_weight": 58.23690686757353, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "0fa4a5d9025b48d78917d9d79130a3b80ceff167b310ddc0acc31b73ae5a0f79", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.479422+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "3cba02e5d8a58456a583f7b27b9bf8b11560c4eec4c3dfcb2bdf6317cc6d2120", + "panel_kind": "isotropic", + "panel_seed": 1270522715933114774, + "realization": 48, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "36ac28fe4afa5792e61d95e8f1a2da6a5cf49186cadc9d356b1220b7fb450d12", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29045400184951864, + "kernel_residual": 1.0451815672124029e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.937024802051029, + "minus_external_entropy": 0.9656197383831413, + "minus_target_effective_rank": 29.247238877351666, + "minus_target_entropy": 0.8938586494088663, + "minus_weight": 57.21117168747578, + "orthogonality_relative_error": 1.668600986222744e-16, + "plus_external_effective_rank": 6.9370248020510275, + "plus_external_entropy": 0.9656197383831413, + "plus_target_effective_rank": 29.247238877351638, + "plus_target_entropy": 0.8938586494088662, + "plus_weight": 57.21117168747578, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "1cc264b93a191285b3b05ebe1bc67336c58ea4fe9c9b4fa408c8ad44d3c6dada", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.576741+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5a427cc623ec5ea7d82b8bcece3be74a0a6e71322bab536c92d53ca5ee292963", + "panel_kind": "sparse", + "panel_seed": 1805543340859849486, + "realization": 49, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f29dde596300f1394facc012806ad8aa0bf688e74831d0a8642760086d7ff2da", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3389403202386162, + "kernel_residual": 9.467385558105478e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.380565747553295, + "minus_external_entropy": 0.9400397635687285, + "minus_target_effective_rank": 23.4667903923384, + "minus_target_entropy": 0.9513985005478797, + "minus_weight": 54.15720984075032, + "orthogonality_relative_error": 1.831926993138803e-16, + "plus_external_effective_rank": 6.380565747553298, + "plus_external_entropy": 0.9400397635687284, + "plus_target_effective_rank": 23.466790392338403, + "plus_target_entropy": 0.9513985005478794, + "plus_weight": 54.157209840750376, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "ae707c288224bd1a2b6e62057f5a925d73c397f9d032b22e9aa03ebd0f3e6ac7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.669560+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5a427cc623ec5ea7d82b8bcece3be74a0a6e71322bab536c92d53ca5ee292963", + "panel_kind": "isotropic", + "panel_seed": 1805543340859849486, + "realization": 49, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ac533f30ead56da29eff739e6209962229710bc688fe8eddd84116e155d683b1", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3389403202386162, + "kernel_residual": 9.467385558105478e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 7.32647670948379, + "minus_external_entropy": 0.9790881971796878, + "minus_target_effective_rank": 29.637696235082316, + "minus_target_entropy": 0.8966153061229368, + "minus_weight": 54.78153437975286, + "orthogonality_relative_error": 1.8376451876695267e-16, + "plus_external_effective_rank": 7.326476709483792, + "plus_external_entropy": 0.9790881971796878, + "plus_target_effective_rank": 29.63769623508235, + "plus_target_entropy": 0.8966153061229367, + "plus_weight": 54.78153437975293, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "b2eae501f032bfeca884d0a8f0305a3f1ef3dd2032ab02dc1e4c8dfc7be536d7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.764298+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ca2a2b8302e3a5b527f2b9c08b38ead66f1e6e499386cdf5ac4c59ba36e8052f", + "panel_kind": "sparse", + "panel_seed": 4767140795655149507, + "realization": 50, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "eaa27bf6700535009d37616869f2ae59b9f20fcf8f316eceb517f3a02181fb8b", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3346527635332656, + "kernel_residual": 1.0209269535344015e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.6497106519628995, + "minus_external_entropy": 0.9533283261901461, + "minus_target_effective_rank": 25.320766097829672, + "minus_target_entropy": 0.9480916706025403, + "minus_weight": 55.6666861116783, + "orthogonality_relative_error": 2.4937786021103865e-16, + "plus_external_effective_rank": 6.649710651962901, + "plus_external_entropy": 0.9533283261901462, + "plus_target_effective_rank": 25.320766097829686, + "plus_target_entropy": 0.9480916706025404, + "plus_weight": 55.66668611167831, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "8068e024ef8b4c3d1024dae1ee12b07037f0577d391b7221d948a8a77af70c98", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.858072+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "ca2a2b8302e3a5b527f2b9c08b38ead66f1e6e499386cdf5ac4c59ba36e8052f", + "panel_kind": "isotropic", + "panel_seed": 4767140795655149507, + "realization": 50, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "36217862babb5eba8a37c2913b67ddfa8fb7259e848828a1695e23948221ebce", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3346527635332656, + "kernel_residual": 1.0209269535344015e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.07235478627998, + "minus_external_entropy": 0.9702694259192014, + "minus_target_effective_rank": 29.594986522715594, + "minus_target_entropy": 0.8957808932276731, + "minus_weight": 54.60979331496484, + "orthogonality_relative_error": 2.417017499334986e-16, + "plus_external_effective_rank": 7.072354786279984, + "plus_external_entropy": 0.9702694259192012, + "plus_target_effective_rank": 29.59498652271559, + "plus_target_entropy": 0.8957808932276732, + "plus_weight": 54.60979331496483, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "832244a35dc4c31e0ea18d1d9a5c7c3068ec453ded2bca2a44e9ac9b2c82fa89", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:09.958059+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e0268dfd25f561c5841ec7360592e84d5ee418097bda022089acd90bf15b6092", + "panel_kind": "sparse", + "panel_seed": 14617008461076312311, + "realization": 51, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4920006ec228c6061b371d32914a77ba783a32a243dd54df21861d96f6360a35", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3310695180725339, + "kernel_residual": 1.0045821257077803e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.66891286600662, + "minus_external_entropy": 0.9553120349194502, + "minus_target_effective_rank": 26.188659782433433, + "minus_target_entropy": 0.9545677744789945, + "minus_weight": 54.97719244992354, + "orthogonality_relative_error": 1.9517285943381244e-16, + "plus_external_effective_rank": 6.668912866006612, + "plus_external_entropy": 0.95531203491945, + "plus_target_effective_rank": 26.188659782433426, + "plus_target_entropy": 0.9545677744789944, + "plus_weight": 54.977192449923606, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "683ff1ed8ece96871bd136ce81302ae738a4d8a416a9826f04aa16ee18a047ec", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.050346+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e0268dfd25f561c5841ec7360592e84d5ee418097bda022089acd90bf15b6092", + "panel_kind": "isotropic", + "panel_seed": 14617008461076312311, + "realization": 51, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7fe6cde00ca7ded00121176877a70afa199ef83ce45c30471cb36137646f13d4", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3310695180725339, + "kernel_residual": 1.0045821257077803e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.037387542990259, + "minus_external_entropy": 0.968622890024136, + "minus_target_effective_rank": 29.462568107452586, + "minus_target_entropy": 0.8967527469121547, + "minus_weight": 57.43694144887567, + "orthogonality_relative_error": 1.8818513220916724e-16, + "plus_external_effective_rank": 7.037387542990252, + "plus_external_entropy": 0.968622890024136, + "plus_target_effective_rank": 29.462568107452572, + "plus_target_entropy": 0.8967527469121545, + "plus_weight": 57.436941448875736, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "ab34883ecbf56b5b50e5f15ca240b0a263f3e07831395351ad4326be6f46f8c6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.146330+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e0eff742819e709ee09ff794d0e8a60a64e37f5545f1afbcfaf005b0e2b3ab8f", + "panel_kind": "sparse", + "panel_seed": 5405299887041885102, + "realization": 52, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "89ff7e5079f638f473b0417a6f4bb15f5a397d512b0bf19ac8921a1acc98de60", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.41515846755597524, + "kernel_residual": 9.570713060952544e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.342656063519157, + "minus_external_entropy": 0.9365076296841367, + "minus_target_effective_rank": 21.343777022462145, + "minus_target_entropy": 0.9493193030042532, + "minus_weight": 53.905819442186285, + "orthogonality_relative_error": 1.6745811524214458e-16, + "plus_external_effective_rank": 6.342656063519161, + "plus_external_entropy": 0.9365076296841367, + "plus_target_effective_rank": 21.343777022462138, + "plus_target_entropy": 0.9493193030042528, + "plus_weight": 53.90581944218627, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e7a281c4dad686c6d5fd1ac4f3270f5e1b53e272b0683c6c352d1719fd813009", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.239292+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "e0eff742819e709ee09ff794d0e8a60a64e37f5545f1afbcfaf005b0e2b3ab8f", + "panel_kind": "isotropic", + "panel_seed": 5405299887041885102, + "realization": 52, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fe9280f1e323b13fc320bd1c4a57c3707ee4d3de8e963d015bd418822d4a3d92", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.41515846755597524, + "kernel_residual": 9.570713060952544e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.443564447866038, + "minus_external_entropy": 0.9824217161376257, + "minus_target_effective_rank": 30.64173097379286, + "minus_target_entropy": 0.9026903261853371, + "minus_weight": 53.16962109420315, + "orthogonality_relative_error": 1.6388375520148506e-16, + "plus_external_effective_rank": 7.4435644478660405, + "plus_external_entropy": 0.9824217161376257, + "plus_target_effective_rank": 30.64173097379285, + "plus_target_entropy": 0.9026903261853372, + "plus_weight": 53.169621094203144, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "631f02a100f020667584ce304be741b2b0081a0242447f2fd37d0f260dba18f2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.336502+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1e57ca28defd80903b654e2d5432b1a3f99ea074c60a4da2c0eaa6cbae249671", + "panel_kind": "sparse", + "panel_seed": 7167363950177102078, + "realization": 53, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "370d15e57ae2cea216d8bb72ec929dc3e47defadf0824a276dc06f60db2a3f7f", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.24926862798260527, + "kernel_residual": 1.033157872793402e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.550240054159137, + "minus_external_entropy": 0.9533732558444548, + "minus_target_effective_rank": 24.1751949706797, + "minus_target_entropy": 0.9465398467633322, + "minus_weight": 61.196448257764665, + "orthogonality_relative_error": 2.1321844338649511e-16, + "plus_external_effective_rank": 6.550240054159141, + "plus_external_entropy": 0.9533732558444549, + "plus_target_effective_rank": 24.17519497067971, + "plus_target_entropy": 0.9465398467633325, + "plus_weight": 61.19644825776469, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e21ba388eaa9f35451e042465b33d4561a75b746e7f57bb61921c51507be43a2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.429155+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "1e57ca28defd80903b654e2d5432b1a3f99ea074c60a4da2c0eaa6cbae249671", + "panel_kind": "isotropic", + "panel_seed": 7167363950177102078, + "realization": 53, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "89360411e6da72de5957cc093a5c482b26a481fd476064b0dff84154512997b9", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.24926862798260527, + "kernel_residual": 1.033157872793402e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.321577171335689, + "minus_external_entropy": 0.9463280327251989, + "minus_target_effective_rank": 27.794671403331872, + "minus_target_entropy": 0.8853254726028078, + "minus_weight": 60.71413231597108, + "orthogonality_relative_error": 1.977317876627541e-16, + "plus_external_effective_rank": 6.321577171335696, + "plus_external_entropy": 0.946328032725199, + "plus_target_effective_rank": 27.79467140333189, + "plus_target_entropy": 0.8853254726028078, + "plus_weight": 60.714132315971106, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "245f7a3bbb0aefceb17c7004f047d703f5ad3adfb9bd0b26991f51b6c2a2b20b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.525517+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5162c6d0f3092f61f37731eab6374880d0c3a728f72e0592648a48609e5b0996", + "panel_kind": "sparse", + "panel_seed": 13116686023042648886, + "realization": 54, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d28c9a8b214f7e479f209f5997318aab9d048d0a4cb5fcc8edacb63e5d6d8c04", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.36573286851644676, + "kernel_residual": 1.0588830311964758e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.4233666590406235, + "minus_external_entropy": 0.9416226623269986, + "minus_target_effective_rank": 23.07016883650376, + "minus_target_entropy": 0.9435869647895647, + "minus_weight": 55.54125998158281, + "orthogonality_relative_error": 1.8738327033666794e-16, + "plus_external_effective_rank": 6.4233666590406235, + "plus_external_entropy": 0.9416226623269989, + "plus_target_effective_rank": 23.070168836503765, + "plus_target_entropy": 0.9435869647895648, + "plus_weight": 55.54125998158277, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "21bc574eb7fb32a1e73bee5a7f1767cc30d6ff41c7095f8f958613d6e7e611dd", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.618004+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5162c6d0f3092f61f37731eab6374880d0c3a728f72e0592648a48609e5b0996", + "panel_kind": "isotropic", + "panel_seed": 13116686023042648886, + "realization": 54, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cbacf4561296d65a23071640afc3e9e5d19bd97a1d7c07bd8da2581aafe69a57", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.36573286851644676, + "kernel_residual": 1.0588830311964758e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.061558940848296, + "minus_external_entropy": 0.9693486718691134, + "minus_target_effective_rank": 30.0591178035141, + "minus_target_entropy": 0.8980013276203321, + "minus_weight": 55.98091568688175, + "orthogonality_relative_error": 1.8464790565098193e-16, + "plus_external_effective_rank": 7.0615589408482915, + "plus_external_entropy": 0.9693486718691134, + "plus_target_effective_rank": 30.059117803514102, + "plus_target_entropy": 0.898001327620332, + "plus_weight": 55.980915686881715, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6825f84f2e609ab7b5b9e273e4683463e5d9d4b2c8036f0b169a0986db73ee5e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.715006+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "f371647b62e64e5a5d05e673af41b86dd2000352c93dfd7870cee5d1df38b159", + "panel_kind": "sparse", + "panel_seed": 14515707998503277710, + "realization": 55, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7fb766e4bd358d900064b3af441d04acd04c0ef690b3de73965e8373505d42ef", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3062195108398807, + "kernel_residual": 1.0237241826576634e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.35864207344805, + "minus_external_entropy": 0.9395289033606395, + "minus_target_effective_rank": 23.56779648050629, + "minus_target_entropy": 0.9443525490884355, + "minus_weight": 57.98194895152127, + "orthogonality_relative_error": 2.6241440761091404e-16, + "plus_external_effective_rank": 6.358642073448052, + "plus_external_entropy": 0.9395289033606394, + "plus_target_effective_rank": 23.567796480506296, + "plus_target_entropy": 0.9443525490884355, + "plus_weight": 57.981948951521304, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "d1ac4754c0da77aac56bee6c7bacfa5d5fc9c50f2f9bd02dd43b6e61a88764a6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.807426+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "f371647b62e64e5a5d05e673af41b86dd2000352c93dfd7870cee5d1df38b159", + "panel_kind": "isotropic", + "panel_seed": 14515707998503277710, + "realization": 55, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "799788bf9819b56634418c390e0cd8d438641b77c51a4de40250a66c0f66f2c5", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3062195108398807, + "kernel_residual": 1.0237241826576634e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.857722423957662, + "minus_external_entropy": 0.9627849047083435, + "minus_target_effective_rank": 28.996954914433893, + "minus_target_entropy": 0.892002124943489, + "minus_weight": 56.00600361198758, + "orthogonality_relative_error": 2.384955445734691e-16, + "plus_external_effective_rank": 6.857722423957659, + "plus_external_entropy": 0.9627849047083435, + "plus_target_effective_rank": 28.996954914433886, + "plus_target_entropy": 0.8920021249434892, + "plus_weight": 56.006003611987616, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "7bc681f980d3a655531a79224ebbf4e83dac8996b02f7bf7415087b75581f541", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.905228+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5e315bb31f0947e950c7608ab876d1e6da2e7b4c916c55b9ddf0349e15d3050b", + "panel_kind": "sparse", + "panel_seed": 18370795663787973316, + "realization": 56, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cae72356ff132f163ba91c28d5abc58b13ff7da7306b2c1a71fe69f814fde064", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30382876931364994, + "kernel_residual": 1.0190903209158404e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.172672120680332, + "minus_external_entropy": 0.9335986898244928, + "minus_target_effective_rank": 24.267591432769045, + "minus_target_entropy": 0.9474384238331275, + "minus_weight": 59.406925471821154, + "orthogonality_relative_error": 1.681843763955125e-16, + "plus_external_effective_rank": 6.172672120680333, + "plus_external_entropy": 0.9335986898244927, + "plus_target_effective_rank": 24.26759143276906, + "plus_target_entropy": 0.9474384238331275, + "plus_weight": 59.40692547182124, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6c5179238088980efb1f48fe7a4380cac219ffcf9ee0e1924e0f79ee109c80a2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:10.996811+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "5e315bb31f0947e950c7608ab876d1e6da2e7b4c916c55b9ddf0349e15d3050b", + "panel_kind": "isotropic", + "panel_seed": 18370795663787973316, + "realization": 56, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "80705400f1c4f8836434b1fa275a3d13b2f0fd9138657f0c7048d81db8b188ff", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.30382876931364994, + "kernel_residual": 1.0190903209158404e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.926927312317428, + "minus_external_entropy": 0.9649621154916529, + "minus_target_effective_rank": 29.450757106137175, + "minus_target_entropy": 0.8948128888403508, + "minus_weight": 56.96987886776753, + "orthogonality_relative_error": 1.699899597613969e-16, + "plus_external_effective_rank": 6.926927312317432, + "plus_external_entropy": 0.9649621154916529, + "plus_target_effective_rank": 29.45075710613719, + "plus_target_entropy": 0.8948128888403508, + "plus_weight": 56.96987886776759, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "dec5035d3ab18620219e04ad0b9654897a046523f014f102e78464e02a7cf8cf", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.094224+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "0504c3a283babb1a8bcad1baa28f81e04db26022129d92cb68d386074da3ebc7", + "panel_kind": "sparse", + "panel_seed": 6918270872981762365, + "realization": 57, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b75a16317e08b94a01ee2ca8f8e01590d5de5607c9587fa4c4ecd1387c666045", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3297513358437685, + "kernel_residual": 9.709177857550286e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.878982159053218, + "minus_external_entropy": 0.9613004400218, + "minus_target_effective_rank": 25.63138227199297, + "minus_target_entropy": 0.9519421799345293, + "minus_weight": 54.929242546419886, + "orthogonality_relative_error": 1.7579188704608201e-16, + "plus_external_effective_rank": 6.8789821590532165, + "plus_external_entropy": 0.9613004400217998, + "plus_target_effective_rank": 25.63138227199296, + "plus_target_entropy": 0.9519421799345297, + "plus_weight": 54.929242546419836, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "6494081641d67759b6d2510dc094a6e1294a01e2cd755b2d39bfd0ada76f16a3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.185881+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "0504c3a283babb1a8bcad1baa28f81e04db26022129d92cb68d386074da3ebc7", + "panel_kind": "isotropic", + "panel_seed": 6918270872981762365, + "realization": 57, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e1cd196ce21e2673b2f8cad9cd076665dc88eac3f78fd3b9d5e66e91d6ec186f", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3297513358437685, + "kernel_residual": 9.709177857550286e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.052353818833708, + "minus_external_entropy": 0.9694049506955519, + "minus_target_effective_rank": 29.096676821422868, + "minus_target_entropy": 0.8926750754842268, + "minus_weight": 56.389960726728575, + "orthogonality_relative_error": 1.7078124256487398e-16, + "plus_external_effective_rank": 7.052353818833708, + "plus_external_entropy": 0.9694049506955517, + "plus_target_effective_rank": 29.096676821422864, + "plus_target_entropy": 0.8926750754842265, + "plus_weight": 56.38996072672852, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "d8f690fe19ac737569bd4f68a779a8f67530580116f7e2cc65625e14b46b207d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.281444+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "0332f5ead46b568472f5029d3f328cccc220058972fa3f46440839bad3fd8ab3", + "panel_kind": "sparse", + "panel_seed": 9843011202543739248, + "realization": 58, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "06fadcf4f76d25b04c790dd092c12f513a26d1dd0b811db344ab205eeb4f7930", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.36820883329663995, + "kernel_residual": 1.0016878900615019e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.904882063062687, + "minus_external_entropy": 0.9588625924369134, + "minus_target_effective_rank": 25.848740899276237, + "minus_target_entropy": 0.954394818509738, + "minus_weight": 55.083543961420375, + "orthogonality_relative_error": 1.4783320438344246e-16, + "plus_external_effective_rank": 6.9048820630626855, + "plus_external_entropy": 0.9588625924369135, + "plus_target_effective_rank": 25.848740899276244, + "plus_target_entropy": 0.9543948185097381, + "plus_weight": 55.08354396142035, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "06d169b2b9a23fff1b5c6a19a42004c55dcc8b075a830dc9ffbe53d14d582856", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.374895+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "0332f5ead46b568472f5029d3f328cccc220058972fa3f46440839bad3fd8ab3", + "panel_kind": "isotropic", + "panel_seed": 9843011202543739248, + "realization": 58, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4fa67a39ad39e0085ea214e8e668d88c590bc937357b264665f8e8d967f87a45", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.36820883329663995, + "kernel_residual": 1.0016878900615019e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.233184055955305, + "minus_external_entropy": 0.9757424555025023, + "minus_target_effective_rank": 30.240432881312522, + "minus_target_entropy": 0.8994971334563135, + "minus_weight": 55.015298138601594, + "orthogonality_relative_error": 1.4937435625792806e-16, + "plus_external_effective_rank": 7.233184055955305, + "plus_external_entropy": 0.9757424555025023, + "plus_target_effective_rank": 30.240432881312504, + "plus_target_entropy": 0.8994971334563137, + "plus_weight": 55.015298138601565, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "bfb1a04dc3527565b438dcd39ce7a6ea54ada3aaccad9b083092d3c7cbf531c6", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.473677+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "d29e3c010351e1bd8dec42d3acf545dda64ca7edefd94a7068c439e496d22639", + "panel_kind": "sparse", + "panel_seed": 2834927314175927554, + "realization": 59, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "445f53e7f64c50ffaa891bdbd2407d38c2fbf52770593a24ed32aa3639370ea6", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.28897488037365887, + "kernel_residual": 9.905626780125992e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.027297546835846, + "minus_external_entropy": 0.9264966080881187, + "minus_target_effective_rank": 23.960452691872565, + "minus_target_entropy": 0.9553574406975154, + "minus_weight": 58.62858387944098, + "orthogonality_relative_error": 2.8763729951215793e-16, + "plus_external_effective_rank": 6.027297546835845, + "plus_external_entropy": 0.9264966080881186, + "plus_target_effective_rank": 23.960452691872558, + "plus_target_entropy": 0.9553574406975155, + "plus_weight": 58.628583879440995, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "923f5ff4151a4d72d8340fd9c7851ea958ba62eb685d250c46fb3011da6625d3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.565158+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "d29e3c010351e1bd8dec42d3acf545dda64ca7edefd94a7068c439e496d22639", + "panel_kind": "isotropic", + "panel_seed": 2834927314175927554, + "realization": 59, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "00f0698959e01e12aee289e57abc5b81915288ae126e3e8a963e62c820edc677", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.28897488037365887, + "kernel_residual": 9.905626780125992e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.637461205329949, + "minus_external_entropy": 0.9556736818480016, + "minus_target_effective_rank": 29.2714788431294, + "minus_target_entropy": 0.8953452935840035, + "minus_weight": 58.38525185813019, + "orthogonality_relative_error": 2.69974293355934e-16, + "plus_external_effective_rank": 6.637461205329947, + "plus_external_entropy": 0.9556736818480015, + "plus_target_effective_rank": 29.2714788431294, + "plus_target_entropy": 0.8953452935840036, + "plus_weight": 58.38525185813021, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "9feadeef3ebea8000d4e3daaa04e6480573f22f824968b3e6cb69f516ee55b87", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.660744+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "69e1d7fbfe5b45346edf536c33441d4a0c6f40f2ad334460366fde3777dee8d5", + "panel_kind": "sparse", + "panel_seed": 5391738000617553722, + "realization": 60, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7aee579c5f34ad0b21df2bc539b82bd3d600fbc6d1ae17c4332a3379b5d8b197", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29626919788480366, + "kernel_residual": 9.945151826081234e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.509811618322095, + "minus_external_entropy": 0.9492195914128956, + "minus_target_effective_rank": 24.609380105052608, + "minus_target_entropy": 0.9504412889757182, + "minus_weight": 58.864217239429564, + "orthogonality_relative_error": 1.5763833084685016e-16, + "plus_external_effective_rank": 6.5098116183220975, + "plus_external_entropy": 0.9492195914128957, + "plus_target_effective_rank": 24.60938010505261, + "plus_target_entropy": 0.9504412889757182, + "plus_weight": 58.86421723942951, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "08d30883eaaafeaf4068f35c4749bc343667015977bbb7c757c614984d834376", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.751287+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "69e1d7fbfe5b45346edf536c33441d4a0c6f40f2ad334460366fde3777dee8d5", + "panel_kind": "isotropic", + "panel_seed": 5391738000617553722, + "realization": 60, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3acffb450903fac7c531a393eb0a7cdb606f179b387792826c904354acb461be", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.29626919788480366, + "kernel_residual": 9.945151826081234e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.679689407264585, + "minus_external_entropy": 0.9554810610262594, + "minus_target_effective_rank": 29.13250191223464, + "minus_target_entropy": 0.8928789255009079, + "minus_weight": 58.92024450009389, + "orthogonality_relative_error": 1.511131957565099e-16, + "plus_external_effective_rank": 6.679689407264585, + "plus_external_entropy": 0.9554810610262595, + "plus_target_effective_rank": 29.13250191223466, + "plus_target_entropy": 0.8928789255009079, + "plus_weight": 58.92024450009384, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "3916576754a9a2430ef931cb6767870a29de05821df800937b256c4c2ad8648b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.847227+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "485c3518c48bbee9796ba3def9e6e125eab8913714bbae10441b01a0578de86f", + "panel_kind": "sparse", + "panel_seed": 11592847769363164905, + "realization": 61, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3c924d75c5916d895b7dcbff874d3714240822c073301d2483723c372e0d2d78", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.26880987458907724, + "kernel_residual": 1.0108274805276933e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 5.850320686498543, + "minus_external_entropy": 0.9251713134570574, + "minus_target_effective_rank": 23.574447146852815, + "minus_target_entropy": 0.9475959996961985, + "minus_weight": 57.64813506408261, + "orthogonality_relative_error": 1.6284238110141289e-16, + "plus_external_effective_rank": 5.850320686498544, + "plus_external_entropy": 0.9251713134570575, + "plus_target_effective_rank": 23.574447146852822, + "plus_target_entropy": 0.9475959996961985, + "plus_weight": 57.64813506408264, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "e8d6d2e4cd29830bc8c8c6d3e280597261bbf8cb203a8e406ff8ca2e2341f208", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:11.935997+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "485c3518c48bbee9796ba3def9e6e125eab8913714bbae10441b01a0578de86f", + "panel_kind": "isotropic", + "panel_seed": 11592847769363164905, + "realization": 61, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b3f3aec98da3267107179af63b2f202b2ba694bbb6295f76c962adf5e62634fe", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.26880987458907724, + "kernel_residual": 1.0108274805276933e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 6.662599661595757, + "minus_external_entropy": 0.9582634854540033, + "minus_target_effective_rank": 28.990037294970474, + "minus_target_entropy": 0.894002475411659, + "minus_weight": 57.18252905849415, + "orthogonality_relative_error": 1.6877328206304204e-16, + "plus_external_effective_rank": 6.662599661595757, + "plus_external_entropy": 0.9582634854540033, + "plus_target_effective_rank": 28.99003729497047, + "plus_target_entropy": 0.894002475411659, + "plus_weight": 57.182529058494175, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "fad6238f587dd1173ea997cd6caae4663bb5e1c7bbf9dd797abb2612965c0d16", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.030355+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "732f1e8d2fc7ecf472408ef634565b92a649aba064b3c6f3c41a6d0d768fb0fd", + "panel_kind": "sparse", + "panel_seed": 5390197761037612486, + "realization": 62, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2d5d421ee1debbefacae5a8965b439735c59275f5edd13e34072d4f0abbb73b7", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3478400013314658, + "kernel_residual": 9.71061010329965e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.9999999999999999, + "minus_external_effective_rank": 6.939718214726538, + "minus_external_entropy": 0.9641965308791384, + "minus_target_effective_rank": 25.11283499887695, + "minus_target_entropy": 0.9548079466944898, + "minus_weight": 54.81798469915045, + "orthogonality_relative_error": 1.9159775886863017e-16, + "plus_external_effective_rank": 6.939718214726537, + "plus_external_entropy": 0.9641965308791381, + "plus_target_effective_rank": 25.11283499887694, + "plus_target_entropy": 0.9548079466944897, + "plus_weight": 54.81798469915046, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "90a9b5415ee3ae97211a9db56d1f176cfde7d4d46b5d9ff44a26621f447bf067", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.122478+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "732f1e8d2fc7ecf472408ef634565b92a649aba064b3c6f3c41a6d0d768fb0fd", + "panel_kind": "isotropic", + "panel_seed": 5390197761037612486, + "realization": 62, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d006a2900782a2fd0e71246d341a72d9d1cef5ef08d8b809ac5444613220a1f2", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3478400013314658, + "kernel_residual": 9.71061010329965e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0, + "minus_external_effective_rank": 7.226063845580343, + "minus_external_entropy": 0.9758118862641261, + "minus_target_effective_rank": 30.89917308016804, + "minus_target_entropy": 0.9029115764563809, + "minus_weight": 55.130623374104104, + "orthogonality_relative_error": 1.9244192146398673e-16, + "plus_external_effective_rank": 7.22606384558034, + "plus_external_entropy": 0.9758118862641263, + "plus_target_effective_rank": 30.899173080168048, + "plus_target_entropy": 0.9029115764563806, + "plus_weight": 55.13062337410412, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "f3516ff39d5c766cca20cfd0b06227bc389d0d00cc5985d1cb5d736f2c26a647", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.219234+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "6b0c82711ac5257503fac74b671531d88153459ec70fe320990955d2691d399b", + "panel_kind": "sparse", + "panel_seed": 7326337864886062758, + "realization": 63, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6b6e215307f63fee0afa2211fdee8847b5afe50b963e590e4acfcc28f37b5e3c", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3328513900282485, + "kernel_residual": 9.767579233743913e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 6.37697128192993, + "minus_external_entropy": 0.9373048989424416, + "minus_target_effective_rank": 22.69304633966351, + "minus_target_entropy": 0.9532492639961517, + "minus_weight": 56.28533007229107, + "orthogonality_relative_error": 1.9057065629472505e-16, + "plus_external_effective_rank": 6.37697128192993, + "plus_external_entropy": 0.9373048989424417, + "plus_target_effective_rank": 22.693046339663518, + "plus_target_entropy": 0.9532492639961517, + "plus_weight": 56.28533007229109, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "9331630b4b1410daed7cd67979da8a462201f92b00d35344159b5bbeba5d0c19", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.311095+00:00", + "identity": { + "N": 8, + "charge": 4, + "kernel_identity_hash": "6b0c82711ac5257503fac74b671531d88153459ec70fe320990955d2691d399b", + "panel_kind": "isotropic", + "panel_seed": 7326337864886062758, + "realization": 63, + "sector": "central", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1637765f839c2e8c26b43d588bef7f7b1348f03a10f06db873b0a32c889938fb", + "kernel": { + "bps_rank": 54, + "complement_rank": 16, + "gap": 0.3328513900282485, + "kernel_residual": 9.767579233743913e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 1.0000000000000002, + "minus_external_effective_rank": 7.004721328895643, + "minus_external_entropy": 0.9673915311403882, + "minus_target_effective_rank": 29.73572756318692, + "minus_target_entropy": 0.8975361425596053, + "minus_weight": 56.13568036821526, + "orthogonality_relative_error": 1.823913832124149e-16, + "plus_external_effective_rank": 7.0047213288956485, + "plus_external_entropy": 0.9673915311403884, + "plus_target_effective_rank": 29.735727563186916, + "plus_target_entropy": 0.8975361425596056, + "plus_weight": 56.13568036821527, + "target_rank": 54 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 8, + "minus_target_eigenvalues": 54, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 8, + "plus_target_eigenvalues": 54 + } + }, + { + "arrays_sha256": "3770cc8bb1c85f102b277c79b2831fa1a8258dd71055a6c43bea8262d842023c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.350260+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4cf5c1afd3269117ceec29b8d84ab4054f5905b0080cc5dfea1edfda2e188e11", + "panel_kind": "sparse", + "panel_seed": 16825777505976298391, + "realization": 0, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "948346513499661ed6dd3da393d22ab9569dbe32c70ef46aca722ee918eb5dd7", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024103210483011395, + "kernel_residual": 9.269984273569142e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07550663581695614, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.111978291011809, + "minus_target_entropy": 0.9672480509039363, + "minus_weight": 4.697734748132174, + "orthogonality_relative_error": 3.575320055159083e-16, + "plus_external_effective_rank": 12.442442612169339, + "plus_external_entropy": 0.8394584278440169, + "plus_target_effective_rank": 17.09013220740774, + "plus_target_entropy": 0.9154571696088875, + "plus_weight": 239.37707429979082, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "a5be4375a27606d11d843d16c4d8668f4c24a752cc34031fd8bf4ca7379531f2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.385726+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4cf5c1afd3269117ceec29b8d84ab4054f5905b0080cc5dfea1edfda2e188e11", + "panel_kind": "isotropic", + "panel_seed": 16825777505976298391, + "realization": 0, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "319a44aa842623213de81882908d89fb973bc5f5e677221255b474afaa91c562", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024103210483011395, + "kernel_residual": 9.269984273569142e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05838211539928263, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.008961989947275, + "minus_target_entropy": 0.9642501327971369, + "minus_weight": 4.030508661557647, + "orthogonality_relative_error": 4.15587133476243e-16, + "plus_external_effective_rank": 12.046006958462828, + "plus_external_entropy": 0.8425880113113037, + "plus_target_effective_rank": 20.491783330292947, + "plus_target_entropy": 0.9535814300968892, + "plus_weight": 268.0251778631658, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "c62d5e824788c508c3a7edb6da7e769d4b5d5f01a9826762cbe165d96038f856", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.424808+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2274b22cfe76fd219eeda0b74e3c8c3545cb2b05d885f61cffea6ba3ab49afb7", + "panel_kind": "sparse", + "panel_seed": 14713834655920423991, + "realization": 1, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "78af334fde28e8eddff28fd2a19f86febb52224528535730db259ae1edab174f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.023108653350816768, + "kernel_residual": 9.648594985038586e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05724365026795625, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.894108370760903, + "minus_target_entropy": 0.9576432575032098, + "minus_weight": 3.6941683390702673, + "orthogonality_relative_error": 8.16284746048064e-16, + "plus_external_effective_rank": 10.418823901362078, + "plus_external_entropy": 0.8282870126575557, + "plus_target_effective_rank": 18.84555610512151, + "plus_target_entropy": 0.9374749064328227, + "plus_weight": 250.69368892331596, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "463dcc35fd0c68e5d145c61d3f7b54a6d78b16ca748cca9b071ffd11e56afc5e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.462504+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2274b22cfe76fd219eeda0b74e3c8c3545cb2b05d885f61cffea6ba3ab49afb7", + "panel_kind": "isotropic", + "panel_seed": 14713834655920423991, + "realization": 1, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2649a47a0f166b2bb17f26a3479218dfbe78c74208708f958d939db4d5c31bfa", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.023108653350816768, + "kernel_residual": 9.648594985038586e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0593347260728538, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.572109424679293, + "minus_target_entropy": 0.9462181550057365, + "minus_weight": 3.609826885633675, + "orthogonality_relative_error": 8.369510747593265e-16, + "plus_external_effective_rank": 11.646821517598763, + "plus_external_entropy": 0.8534588771167478, + "plus_target_effective_rank": 20.63324292716858, + "plus_target_entropy": 0.9573536244005079, + "plus_weight": 236.07855275180202, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "52e6625e66043b67706739f0aed8431f64e902c05d4d35c503ba45ab5d3d7ecb", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.502784+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "5950f37b4ba9ce92679ac689824c9d256a6981b3965d108995b2d35b9bee1f6e", + "panel_kind": "sparse", + "panel_seed": 10921154700482938251, + "realization": 2, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fd2c7655a7a1a176dfa28137e9434e88c2b57808030ba8689fdf872a1b89d012", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.023704950083743685, + "kernel_residual": 1.1203722270716313e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06381124818959087, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.739073899791937, + "minus_target_entropy": 0.950498249388123, + "minus_weight": 4.216091863905711, + "orthogonality_relative_error": 3.87643954612697e-16, + "plus_external_effective_rank": 11.534714306450505, + "plus_external_entropy": 0.8433470249064502, + "plus_target_effective_rank": 18.853790637816502, + "plus_target_entropy": 0.9364251633007509, + "plus_weight": 255.78350601618087, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "ff6ef8aa3cd2418371baa49311061c703284de814b026038e7b39d36eda3c7f9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.539036+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "5950f37b4ba9ce92679ac689824c9d256a6981b3965d108995b2d35b9bee1f6e", + "panel_kind": "isotropic", + "panel_seed": 10921154700482938251, + "realization": 2, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "79b86d866b182c9329a2322ec3360e2d7ae74f3937ffd629e73f0aafc89b1690", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.023704950083743685, + "kernel_residual": 1.1203722270716313e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06293749269038754, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.690164971379642, + "minus_target_entropy": 0.9479618862295739, + "minus_weight": 3.8901330460200354, + "orthogonality_relative_error": 4.0511010846460543e-16, + "plus_external_effective_rank": 12.671802667485583, + "plus_external_entropy": 0.8589956395597493, + "plus_target_effective_rank": 20.44711432263951, + "plus_target_entropy": 0.9545634460188936, + "plus_weight": 239.3943983770064, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "16949595d434c2c0ee22ec6fb3f80cfffe5c82412f7c7c4aedcfd872d0416811", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.579741+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "57dff1ab62e9af38b45853b235cc52ba73ca66a027a8b14ea3c633b8c6c808f5", + "panel_kind": "sparse", + "panel_seed": 17076550612236467786, + "realization": 3, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f7af30de8cd8a23e43e319b26cea3c60f9f4a363f6c65d9c21d07f6d06aaa338", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.022266936222422786, + "kernel_residual": 9.702342248493937e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05656523309878598, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.816481151526014, + "minus_target_entropy": 0.956074798176677, + "minus_weight": 4.23946691610694, + "orthogonality_relative_error": 4.410346283994172e-16, + "plus_external_effective_rank": 12.126963136481251, + "plus_external_entropy": 0.8388021811261629, + "plus_target_effective_rank": 19.601585872445202, + "plus_target_entropy": 0.9444718363407744, + "plus_weight": 291.25247566719514, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "0cba6b3c970911a587e559a0c437aa797f518c3ee80139828e506ca78ffd4860", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.615520+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "57dff1ab62e9af38b45853b235cc52ba73ca66a027a8b14ea3c633b8c6c808f5", + "panel_kind": "isotropic", + "panel_seed": 17076550612236467786, + "realization": 3, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "90f360f3be47f50be8ed3b30fa244af6f7106b387b7bc125d2830964acc336f6", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.022266936222422786, + "kernel_residual": 9.702342248493937e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.056447582895470416, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.179311899331511, + "minus_target_entropy": 0.9713543408201011, + "minus_weight": 4.090360731516739, + "orthogonality_relative_error": 4.3657074916117903e-16, + "plus_external_effective_rank": 12.486281919846157, + "plus_external_entropy": 0.8490654754165871, + "plus_target_effective_rank": 21.213935966300312, + "plus_target_entropy": 0.9601296656767863, + "plus_weight": 281.6118336383041, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "e60f6bc060209b86082aba44c65373a13bc44242ba45ce6be85372e549a6b588", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.655704+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2896008eb9da29991cbf4c483344bc58b3f4f2a2033412794b042eaa1c7c0bfe", + "panel_kind": "sparse", + "panel_seed": 7743679942618729944, + "realization": 4, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "77bc44480d9d1fe8d730c10435a7a2bb6e8657bac780f35000cf655015d7df81", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03983005491750773, + "kernel_residual": 9.662275055838233e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07513688742099854, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.71615028024748, + "minus_target_entropy": 0.9527429684589993, + "minus_weight": 3.863152310833686, + "orthogonality_relative_error": 3.302246791415532e-16, + "plus_external_effective_rank": 13.842428324087402, + "plus_external_entropy": 0.8765033250659848, + "plus_target_effective_rank": 20.226971843585382, + "plus_target_entropy": 0.9456582252691391, + "plus_weight": 197.85769510026088, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "0970d2d16f79ff51669224755d460506dbe64e37967413fe1d9fdf98371c9e3b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.691707+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2896008eb9da29991cbf4c483344bc58b3f4f2a2033412794b042eaa1c7c0bfe", + "panel_kind": "isotropic", + "panel_seed": 7743679942618729944, + "realization": 4, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8421fc67b0f4e764a66edc10808a1bdad1a19a18acbcceae8c9f3b745da64eaf", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03983005491750773, + "kernel_residual": 9.662275055838233e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07211057921725936, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.916167850981662, + "minus_target_entropy": 0.9615736084075124, + "minus_weight": 3.6554049301639164, + "orthogonality_relative_error": 3.321436405497385e-16, + "plus_external_effective_rank": 15.323007517489193, + "plus_external_entropy": 0.8976996091655655, + "plus_target_effective_rank": 22.260603211316994, + "plus_target_entropy": 0.9686780530117884, + "plus_weight": 195.38744113389436, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "73134666e55592634e2d8ef2cf4b1da2f513d8b49583aea7bff8c66c32fb1ad3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.731654+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "039096ec7053869ca4385f81ab660f3067c4c85e27918cc6022360d32fa66e57", + "panel_kind": "sparse", + "panel_seed": 916865364380315589, + "realization": 5, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f9efbd7bf537c0a8c77c7a365eab098c2b25060e09cb02f15e52771d96cf8495", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02697673337770952, + "kernel_residual": 9.703247448515124e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06771344637967902, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.917567699003482, + "minus_target_entropy": 0.9598138745045087, + "minus_weight": 3.9040555652554088, + "orthogonality_relative_error": 5.444129789826209e-16, + "plus_external_effective_rank": 13.271338305051529, + "plus_external_entropy": 0.8738227775111546, + "plus_target_effective_rank": 19.51226529932243, + "plus_target_entropy": 0.9428493336716246, + "plus_weight": 222.74563732164847, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "68b9780155762f1ce75db3e4f8b2da5a9791a67578f95e6a82438e37374da91f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.767388+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "039096ec7053869ca4385f81ab660f3067c4c85e27918cc6022360d32fa66e57", + "panel_kind": "isotropic", + "panel_seed": 916865364380315589, + "realization": 5, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "485faf877261bd309942e083e7b5bdc74c77ac50a86cd25200fc1b2777fce42a", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02697673337770952, + "kernel_residual": 9.703247448515124e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06743114644287483, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.066664258349028, + "minus_target_entropy": 0.965597295632202, + "minus_weight": 3.8220042237403393, + "orthogonality_relative_error": 5.384666166298748e-16, + "plus_external_effective_rank": 13.583211215254236, + "plus_external_entropy": 0.8766268439846522, + "plus_target_effective_rank": 22.063020851489735, + "plus_target_entropy": 0.9675611212589166, + "plus_weight": 219.00969855189737, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "937c5709e70322058a63d1e692173147250cdbb249fdfa5691365fe758e9e118", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.807399+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "42ef855413c5b0de219907850b6032a904451d099ea47d0c85bff7e1be89397c", + "panel_kind": "sparse", + "panel_seed": 7346865150972736122, + "realization": 6, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f3ca23b3454366585b85a8cf7d1c1f3f5059259db0f9b70b7bbc454a091ba285", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.0300530227786912, + "kernel_residual": 8.954125737256982e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07665824790047734, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.969877708122469, + "minus_target_entropy": 0.9609781610168584, + "minus_weight": 4.006570206547089, + "orthogonality_relative_error": 5.7867329188583125e-16, + "plus_external_effective_rank": 12.733904587956543, + "plus_external_entropy": 0.8669869069368878, + "plus_target_effective_rank": 18.928821282375534, + "plus_target_entropy": 0.9417718676381174, + "plus_weight": 200.96838590836694, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "977370e74c6f03f9325b704cf862d662cd02cf9e91f7b285984b7b408ba2d5ad", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.843328+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "42ef855413c5b0de219907850b6032a904451d099ea47d0c85bff7e1be89397c", + "panel_kind": "isotropic", + "panel_seed": 7346865150972736122, + "realization": 6, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "544c400ac0bf126018ec22944ec6b68a5196af731ff6cab0b4692574b30872ca", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.0300530227786912, + "kernel_residual": 8.954125737256982e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0781422945302429, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.821103612176508, + "minus_target_entropy": 0.9561541148223885, + "minus_weight": 3.975195754919913, + "orthogonality_relative_error": 5.600509807840511e-16, + "plus_external_effective_rank": 14.318055170734128, + "plus_external_entropy": 0.8863599108022421, + "plus_target_effective_rank": 20.246382713137056, + "plus_target_entropy": 0.9550497092432952, + "plus_weight": 195.45373697146835, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "cb3f31efbfa639280b08d27eeb7b4640a6828da336a62a04f5258e7aaf027a8a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.882671+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "6792881d011ede063086a0e0bd0a07e9e1d67295dfd7ab56a96a71daabe650a6", + "panel_kind": "sparse", + "panel_seed": 7455772564310604881, + "realization": 7, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "eb810c397a5659b6967e8c4475d232d7643acef1731524f979f3299470beb365", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03318725701779882, + "kernel_residual": 1.041253600280675e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08289637873608373, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.794448442521405, + "minus_target_entropy": 0.9549170439285977, + "minus_weight": 4.054821399844896, + "orthogonality_relative_error": 4.523868986073242e-16, + "plus_external_effective_rank": 13.542873305215316, + "plus_external_entropy": 0.8731732713353076, + "plus_target_effective_rank": 17.881881104786597, + "plus_target_entropy": 0.9219112113969041, + "plus_weight": 187.45999780341506, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "f2c762dfe688b3721fb4ab96c2bdba9756891e8f7cc0d3dfad06b35efabba99e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.918238+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "6792881d011ede063086a0e0bd0a07e9e1d67295dfd7ab56a96a71daabe650a6", + "panel_kind": "isotropic", + "panel_seed": 7455772564310604881, + "realization": 7, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5a3131e18887efaba5efd2f83d756cbdb9fb1447af698e142fcca3d8b13c688a", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03318725701779882, + "kernel_residual": 1.041253600280675e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07890390182286319, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.1476181934797065, + "minus_target_entropy": 0.9695936539397867, + "minus_weight": 4.103814843000619, + "orthogonality_relative_error": 4.742949748290731e-16, + "plus_external_effective_rank": 14.244119028475499, + "plus_external_entropy": 0.8844201440920562, + "plus_target_effective_rank": 21.40147255080663, + "plus_target_entropy": 0.9636361340462142, + "plus_weight": 199.74921948528072, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "5b9422660c0836901e2fb1349fa55e711806518b387b3e18e30517b919d30569", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.958136+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "fe1ff278539f25a0ee73738b165d6d39c3385938d5fe05abacbf17cc0247feae", + "panel_kind": "sparse", + "panel_seed": 15185439957972700025, + "realization": 8, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0f5672c9bd4620a382441b7d79607f891a8689f10e6e5365fe84ec810bb21dea", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02644797691116107, + "kernel_residual": 9.649526737516424e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.10505344591833612, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.084626329134863, + "minus_target_entropy": 0.9674057457442221, + "minus_weight": 4.720534118981385, + "orthogonality_relative_error": 3.4726732515005797e-16, + "plus_external_effective_rank": 13.46593442687676, + "plus_external_entropy": 0.8688014576861216, + "plus_target_effective_rank": 15.305711458380204, + "plus_target_entropy": 0.8915207315844705, + "plus_weight": 170.16636362955813, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "6bb4f5ec4a8e0e481201436ed58cfad48352e7aabcdd4037f9abb075ae84f6ef", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:12.994408+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "fe1ff278539f25a0ee73738b165d6d39c3385938d5fe05abacbf17cc0247feae", + "panel_kind": "isotropic", + "panel_seed": 15185439957972700025, + "realization": 8, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e7d5c2062095099ef5234a42065d80ebe5e0e88e61d2deebf43f91e05fccbe0b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02644797691116107, + "kernel_residual": 9.649526737516424e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07500552411698347, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.103387623997509, + "minus_target_entropy": 0.9693818886944422, + "minus_weight": 3.9016724920344807, + "orthogonality_relative_error": 3.2029878707054853e-16, + "plus_external_effective_rank": 13.55186110470379, + "plus_external_entropy": 0.881777057057277, + "plus_target_effective_rank": 21.23043951986822, + "plus_target_entropy": 0.9606203307968313, + "plus_weight": 200.19448763644434, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "f8a1f14aa08fe65e0d8f006ae5772adc285214bafb5f76c6808b8e71574494f9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.034125+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d9e6fac0026276f608ef51197fcb7f555bab2e91986c6f914f85395769f00e14", + "panel_kind": "sparse", + "panel_seed": 11008158687752105530, + "realization": 9, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0a8367c35922046930da85516e1b6878f33663f27476413b6b9e7cb446bcdf3c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.030261737244653072, + "kernel_residual": 9.220163815218716e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05696759066143422, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.767400309916646, + "minus_target_entropy": 0.9532832074582056, + "minus_weight": 3.4117095428147026, + "orthogonality_relative_error": 3.981665676642226e-16, + "plus_external_effective_rank": 11.961178027932784, + "plus_external_entropy": 0.8504179544742407, + "plus_target_effective_rank": 19.924746094989974, + "plus_target_entropy": 0.9495465708466847, + "plus_weight": 232.68097691478295, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "af233837666a59446e1562ffc0ec1cc1d413e6742373b03c879839a958c52525", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.070159+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d9e6fac0026276f608ef51197fcb7f555bab2e91986c6f914f85395769f00e14", + "panel_kind": "isotropic", + "panel_seed": 11008158687752105530, + "realization": 9, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e361d24019028496913eb7ccb7f55cf80d3df75cc3ac2198a99a6775695da29d", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.030261737244653072, + "kernel_residual": 9.220163815218716e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07217731557442797, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.8620507082111875, + "minus_target_entropy": 0.9567423877348381, + "minus_weight": 4.045661116827862, + "orthogonality_relative_error": 3.486479012601365e-16, + "plus_external_effective_rank": 13.24189651848185, + "plus_external_entropy": 0.8685347987490786, + "plus_target_effective_rank": 20.68026903869611, + "plus_target_entropy": 0.9566138492664232, + "plus_weight": 216.03971002350275, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "cf58d003bb443e7b338353c9e6d849b69316b0af9f405b13170f21657865885e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.110372+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4dae7c03c8f5e371261b5ef536fc98a23867ba78af01a065a1fe39e44418542d", + "panel_kind": "sparse", + "panel_seed": 11140141162798394343, + "realization": 10, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "49dcedff673a90f4081ea7952c4b5baac65d86414ab7743d4608a6b8f43f2de9", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.018882096866273908, + "kernel_residual": 9.428792426244e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.047317914166141554, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.641405107220838, + "minus_target_entropy": 0.9475159176480048, + "minus_weight": 3.5053065851437646, + "orthogonality_relative_error": 7.980609977526677e-16, + "plus_external_effective_rank": 10.29718874044806, + "plus_external_entropy": 0.8171668576388673, + "plus_target_effective_rank": 19.756564086070856, + "plus_target_entropy": 0.947656099046982, + "plus_weight": 289.2665297386748, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "565cdce3d955c1b1be67e1e0a93ad662d8143f3d49b3f20f5c5faaf876a4984e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.147286+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4dae7c03c8f5e371261b5ef536fc98a23867ba78af01a065a1fe39e44418542d", + "panel_kind": "isotropic", + "panel_seed": 11140141162798394343, + "realization": 10, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "474ddc30d16715852b042593ea1e21bfd2a1289de472d7fff641efef69700e08", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.018882096866273908, + "kernel_residual": 9.428792426244e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05403449241366488, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.869541277369409, + "minus_target_entropy": 0.958286946775901, + "minus_weight": 3.985254896677685, + "orthogonality_relative_error": 8.529891318077061e-16, + "plus_external_effective_rank": 10.557674307551661, + "plus_external_entropy": 0.8231077270480451, + "plus_target_effective_rank": 20.06490320423982, + "plus_target_entropy": 0.9524936698197206, + "plus_weight": 286.9897750232185, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "8f641ade9fd0a717c52d36b3715971210ab3e1b530de8dcb483e11980095f3c3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.189157+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "473dd10d7fcb40993a78c310cab34850a869a566d2086c0096a4184275d4f43c", + "panel_kind": "sparse", + "panel_seed": 17498065421800041842, + "realization": 11, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8fac41dc0e8a815962a1cc0bc08a74493b69f0dbfd36021f5484902b37300a81", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04980298271750512, + "kernel_residual": 9.627381144658712e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0822065637155332, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.7997372822279, + "minus_target_entropy": 0.9567083314483056, + "minus_weight": 3.8804409348286493, + "orthogonality_relative_error": 2.2167459469650418e-16, + "plus_external_effective_rank": 15.471357061512002, + "plus_external_entropy": 0.8910150513859514, + "plus_target_effective_rank": 20.311548795512305, + "plus_target_entropy": 0.9490421481894469, + "plus_weight": 180.9700776440778, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "7c3e7b25421db4a81921c2e6c1ac9c205722ae621b0a1665bba73d8abf886ea5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.227651+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "473dd10d7fcb40993a78c310cab34850a869a566d2086c0096a4184275d4f43c", + "panel_kind": "isotropic", + "panel_seed": 17498065421800041842, + "realization": 11, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "afa1569c249be2fcae369d4787001273521a571cb146a74d6317d07cf6b53be4", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04980298271750512, + "kernel_residual": 9.627381144658712e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.085033542154009, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.7958948438741125, + "minus_target_entropy": 0.9550507353735442, + "minus_weight": 3.913403100759939, + "orthogonality_relative_error": 2.156026583292854e-16, + "plus_external_effective_rank": 16.93088261624069, + "plus_external_entropy": 0.9131025277949063, + "plus_target_effective_rank": 22.67280871609419, + "plus_target_entropy": 0.9718465507272949, + "plus_weight": 176.1737666390843, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "fc09f0ce0d64fddc96622404a62d0254f9a90c08ae9fcb448e95eb1e59c0cda3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.270422+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "3cd8becb9c77762b1a09888c5e79e1786f564594cd8a6261eba787fdbf96e417", + "panel_kind": "sparse", + "panel_seed": 167917693510966101, + "realization": 12, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cfc53df95af41f18a8cc0205663412d092f5e31ade30546c983db8d43463d84e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.014307834823170544, + "kernel_residual": 9.006604912132754e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05630851796703488, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.812103421077206, + "minus_target_entropy": 0.9547080034313155, + "minus_weight": 4.047779240249085, + "orthogonality_relative_error": 9.687202592206364e-16, + "plus_external_effective_rank": 9.508847535062511, + "plus_external_entropy": 0.8000609487971876, + "plus_target_effective_rank": 17.49832388595178, + "plus_target_entropy": 0.9280030147548237, + "plus_weight": 279.38874016466684, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "13612ba3b1b2644ee32bf25c312b740a36c490d04488cc03668cf19e9d780d8f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.312832+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "3cd8becb9c77762b1a09888c5e79e1786f564594cd8a6261eba787fdbf96e417", + "panel_kind": "isotropic", + "panel_seed": 167917693510966101, + "realization": 12, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "548d1f9be6908cfae4effc94b253edc8378e032da0c6a0eac1a2449aa25e9edd", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.014307834823170544, + "kernel_residual": 9.006604912132754e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06587736018077736, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.361760841407461, + "minus_target_entropy": 0.9782958405439399, + "minus_weight": 4.286957054072376, + "orthogonality_relative_error": 1.043507857934914e-15, + "plus_external_effective_rank": 10.324870416291157, + "plus_external_entropy": 0.829091658880504, + "plus_target_effective_rank": 18.100653967160707, + "plus_target_entropy": 0.9372388877398969, + "plus_weight": 251.65231823656285, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "8f053e110e61a534f97d72a7268cf8c0d3c6b0771d62abf2687b7a2c6d84b12d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.360373+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "b6d718077fc9dbfffc8bcc2a50bd02c144fd34b4e967ee10e940e6a167308343", + "panel_kind": "sparse", + "panel_seed": 7960898400706684734, + "realization": 13, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1c165fa90b01f39deabef263ea3ffbe02ed0d3fc85ba1ffffa4d45fd68453492", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.023715378362317754, + "kernel_residual": 9.714812569615722e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05846362475279649, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.608306523811424, + "minus_target_entropy": 0.9435954688321956, + "minus_weight": 3.471828455228776, + "orthogonality_relative_error": 7.712431999884565e-16, + "plus_external_effective_rank": 10.681257238454128, + "plus_external_entropy": 0.8380159182821354, + "plus_target_effective_rank": 17.90564273769677, + "plus_target_entropy": 0.9198748721800758, + "plus_weight": 230.5417398730471, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 25, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "d2d0bc10bb2f2f75f8e9b641b38e3dc82143f5bfe1993c19d696d3ae6727799a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.400872+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "b6d718077fc9dbfffc8bcc2a50bd02c144fd34b4e967ee10e940e6a167308343", + "panel_kind": "isotropic", + "panel_seed": 7960898400706684734, + "realization": 13, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8393c17e7235bbbd086b450260eafef4850de3c77cb6d6f4e3869abb09c6abaf", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.023715378362317754, + "kernel_residual": 9.714812569615722e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06821984080848188, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.260075445544778, + "minus_target_entropy": 0.9748605136410607, + "minus_weight": 4.220283476357689, + "orthogonality_relative_error": 7.20659260540113e-16, + "plus_external_effective_rank": 12.36112690209448, + "plus_external_entropy": 0.8552202808119589, + "plus_target_effective_rank": 21.275607135568706, + "plus_target_entropy": 0.9609547557004414, + "plus_weight": 238.93685980656903, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "564479e3ca1e2d2ece135c90e6d8d7eb5887cd04c9e7a8ea8ffbae4790ad0c12", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.447879+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "83172d0c151746471c52bd17545ba8721f98395c53cf8fad57d7acbf00e98b00", + "panel_kind": "sparse", + "panel_seed": 11031316681542720410, + "realization": 14, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3fcc4c7ec146eb4c4a1f90674ef594d43abcb403684736e4059c3373ec7261d9", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.013964183261977002, + "kernel_residual": 1.0185691307894619e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05470028483123422, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.699087057581746, + "minus_target_entropy": 0.949273133502657, + "minus_weight": 3.75857093203393, + "orthogonality_relative_error": 7.472621316601572e-16, + "plus_external_effective_rank": 10.02979879376789, + "plus_external_entropy": 0.8210620971392693, + "plus_target_effective_rank": 17.873919861259722, + "plus_target_entropy": 0.9245873017911032, + "plus_weight": 267.2783664251917, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "4c3d116966b90c014393d85f547c77539dd2d1139f78b7dcf3250ee141dcece2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.491072+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "83172d0c151746471c52bd17545ba8721f98395c53cf8fad57d7acbf00e98b00", + "panel_kind": "isotropic", + "panel_seed": 11031316681542720410, + "realization": 14, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1ff19a13bd6c96155275d820aefd97a147e2eb9a5ec48aa2ea61babefc3eae8b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.013964183261977002, + "kernel_residual": 1.0185691307894619e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05391049749855745, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.874348402953304, + "minus_target_entropy": 0.9587033528419068, + "minus_weight": 3.9254226153523035, + "orthogonality_relative_error": 7.391730878243666e-16, + "plus_external_effective_rank": 10.535708176676943, + "plus_external_entropy": 0.8221030377432434, + "plus_target_effective_rank": 19.51906491480728, + "plus_target_entropy": 0.9458644978447818, + "plus_weight": 283.3495602948528, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "48c0b8168fa6b5357c831a02f22886bd51295659225427232f2ec7491bc9d7c3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.539276+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "8160e34ff49c7af1b74134dfc7e576a01f84407680b9916d1b1a32fdbb82baf2", + "panel_kind": "sparse", + "panel_seed": 17936840037816290029, + "realization": 15, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b64b1bc18c12fae5afceafaf66794a03cdcd4b2052b7193b1ac9a04a2e4d5184", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.020990068342706777, + "kernel_residual": 9.51841917824288e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08105447665896978, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.042342219492384, + "minus_target_entropy": 0.9648980970648234, + "minus_weight": 4.530614566295723, + "orthogonality_relative_error": 7.282876049768713e-16, + "plus_external_effective_rank": 11.411593219529925, + "plus_external_entropy": 0.8437954922071209, + "plus_target_effective_rank": 16.578927876436182, + "plus_target_entropy": 0.9186390973536326, + "plus_weight": 214.42672482601662, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "2e7d61b2e1020a53a0ac9b55d44c2138cb92c551645661967ecd5237188dcdac", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.589359+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "8160e34ff49c7af1b74134dfc7e576a01f84407680b9916d1b1a32fdbb82baf2", + "panel_kind": "isotropic", + "panel_seed": 17936840037816290029, + "realization": 15, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7a7d63e7878fc08c3e2ff53f4979045cb60a818a04dfb0696cbbca438c7edcb9", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.020990068342706777, + "kernel_residual": 9.51841917824288e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06460425396248022, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.925702142787691, + "minus_target_entropy": 0.961405027656549, + "minus_weight": 3.8162179455575127, + "orthogonality_relative_error": 7.543471170448969e-16, + "plus_external_effective_rank": 11.127891427242375, + "plus_external_entropy": 0.8476929098582309, + "plus_target_effective_rank": 19.74580565645219, + "plus_target_entropy": 0.9505776023355376, + "plus_weight": 228.586618335683, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "0f6b16d7af04d6f309abb4aaf77b83645fa3bc3036c2aa585c313e9ebd631f93", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.641140+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4a8ebbf66cd886f19622568e9573df009d2db19f9ac2cee6d2252e0729312056", + "panel_kind": "sparse", + "panel_seed": 9679554556415199320, + "realization": 16, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "75dc8ec6ed5949659aa0505fe7137afdb8d249f80a43e3735ad44693cdd6c004", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.0269004005858456, + "kernel_residual": 9.234521971626622e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07462815735746217, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.81826572379774, + "minus_target_entropy": 0.9552945751308646, + "minus_weight": 4.172077997944928, + "orthogonality_relative_error": 5.690602757594327e-16, + "plus_external_effective_rank": 11.43904878484661, + "plus_external_entropy": 0.8516649345216761, + "plus_target_effective_rank": 17.97207932478053, + "plus_target_entropy": 0.9242514731509394, + "plus_weight": 215.19446808548793, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 26, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "20da77e642ded59c74912da69a5ddf0b6aafd72dab9da09045c9f4cea791e4e5", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.687817+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4a8ebbf66cd886f19622568e9573df009d2db19f9ac2cee6d2252e0729312056", + "panel_kind": "isotropic", + "panel_seed": 9679554556415199320, + "realization": 16, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "40611eeb3050bdfca6c78030029a1553a5770bf9b82e659c8ce4f96a40298619", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.0269004005858456, + "kernel_residual": 9.234521971626622e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07005030500303126, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.095732495133809, + "minus_target_entropy": 0.9656560201696158, + "minus_weight": 3.97015174899326, + "orthogonality_relative_error": 5.88384701417253e-16, + "plus_external_effective_rank": 12.347442125124266, + "plus_external_entropy": 0.861059281099784, + "plus_target_effective_rank": 20.868393665415997, + "plus_target_entropy": 0.9579095411048602, + "plus_weight": 218.6905173682298, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "5e9f8480658689d75294e61b09c9eff3a803937cb64ab71ec20a678bd776c946", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.741074+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "0e4c3353d5e5eacf66402814a2ec9d73ce4ecc6e0af74373116affdc2a031ea6", + "panel_kind": "sparse", + "panel_seed": 11567434307949216747, + "realization": 17, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2a60309d0696d61cc70efc8ba10ee22b77aae66878d4d6d249dba9aa58fa8aaf", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.042026690097077636, + "kernel_residual": 9.420686392301114e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08488040682603737, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.003362031515723, + "minus_target_entropy": 0.9645670377763582, + "minus_weight": 3.8667109444201673, + "orthogonality_relative_error": 3.283460643395282e-16, + "plus_external_effective_rank": 15.59775329225592, + "plus_external_entropy": 0.8986625254538891, + "plus_target_effective_rank": 21.320764075261447, + "plus_target_entropy": 0.9589413852021406, + "plus_weight": 174.40009388381307, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "753475981fb5c4770bf993e87437a2ba52f3b0bf83eaafa8da2f6cc5054c7455", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.791056+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "0e4c3353d5e5eacf66402814a2ec9d73ce4ecc6e0af74373116affdc2a031ea6", + "panel_kind": "isotropic", + "panel_seed": 11567434307949216747, + "realization": 17, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "805dd8318569678786ec8ada1d537ec2cc91c41ac1cbfe7e2ba9c3667b329b28", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.042026690097077636, + "kernel_residual": 9.420686392301114e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07683222799943121, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.0718471652261226, + "minus_target_entropy": 0.9677081835289506, + "minus_weight": 3.7660574511476534, + "orthogonality_relative_error": 3.367191692209817e-16, + "plus_external_effective_rank": 15.061429156169613, + "plus_external_entropy": 0.8971773063067945, + "plus_target_effective_rank": 22.28075708098778, + "plus_target_entropy": 0.969267910468719, + "plus_weight": 188.45917553204544, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "beff360bad954f837a334ecb5678efee5fc895e4879e8c29a668a459ef867dc3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.849682+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2ef539529bee85aa55289d6b30150f4a29eee988b5d1a0e5ffb924db495e578c", + "panel_kind": "sparse", + "panel_seed": 3055915363016924156, + "realization": 18, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2b0f4ef5020447639f05062ac6c471e9776c398e12f04fa0ce8eb25888d2717f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.01641630746306982, + "kernel_residual": 9.692558284307962e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.052986646822854325, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.512681585620999, + "minus_target_entropy": 0.9405378082208424, + "minus_weight": 3.8356951064424694, + "orthogonality_relative_error": 7.465827833402128e-16, + "plus_external_effective_rank": 9.715452442766523, + "plus_external_entropy": 0.8115322325457726, + "plus_target_effective_rank": 16.845601209750104, + "plus_target_entropy": 0.9202039383809663, + "plus_weight": 281.8357838687056, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "bec2da4654c0ab13730d5da339600c1fc1caa009ea9be578d3b7ca9fc7daf15e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.899955+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2ef539529bee85aa55289d6b30150f4a29eee988b5d1a0e5ffb924db495e578c", + "panel_kind": "isotropic", + "panel_seed": 3055915363016924156, + "realization": 18, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "89b2aaf2b0a84286861e3dd9e24d9f37f854fef1cffc7d7d58cf8d4c2b8ff23e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.01641630746306982, + "kernel_residual": 9.692558284307962e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05304218475688679, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.077302225439563, + "minus_target_entropy": 0.9684116695209317, + "minus_weight": 3.962240969052851, + "orthogonality_relative_error": 8.278054844405382e-16, + "plus_external_effective_rank": 9.789610376692341, + "plus_external_entropy": 0.8117310726145862, + "plus_target_effective_rank": 20.282305073254992, + "plus_target_entropy": 0.9525985780697587, + "plus_weight": 290.8207635097905, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "e3ff6b0a00cbec20a4088cd6c7cec2388c6e15f54e1d6bf422a83732d22ef4a8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:13.955112+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "62203ef94bb73885d8087f1f5d8ec93e5b2fb2e583a2b7a0f51c84c005d7ea7f", + "panel_kind": "sparse", + "panel_seed": 3102311963417027461, + "realization": 19, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "632f288fb8f2a89492084f9e8965a3c7bb322c204088c5c2735fed62c6e2f668", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.017136921431509102, + "kernel_residual": 9.28734869636134e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07002655318312329, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.816533600806533, + "minus_target_entropy": 0.9553307520685665, + "minus_weight": 3.9742540969216904, + "orthogonality_relative_error": 3.5356050856654973e-16, + "plus_external_effective_rank": 10.439982283882797, + "plus_external_entropy": 0.8385470523006078, + "plus_target_effective_rank": 17.917262072158092, + "plus_target_entropy": 0.9261981649407842, + "plus_weight": 218.99348833768806, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "37625706f0747a2a12942e08e3154f41a4b58677c4599b18808596a054cae3e0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.016159+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "62203ef94bb73885d8087f1f5d8ec93e5b2fb2e583a2b7a0f51c84c005d7ea7f", + "panel_kind": "isotropic", + "panel_seed": 3102311963417027461, + "realization": 19, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4362c9bc777a4955563708418336dd816b3d458becb8b1808f9ef06c92dee3f2", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.017136921431509102, + "kernel_residual": 9.28734869636134e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06306172654207721, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.98271994701357, + "minus_target_entropy": 0.9641672432371181, + "minus_weight": 3.974809090816647, + "orthogonality_relative_error": 3.9118011720353834e-16, + "plus_external_effective_rank": 10.371835948029313, + "plus_external_entropy": 0.8347338919939821, + "plus_target_effective_rank": 19.51416444534122, + "plus_target_entropy": 0.9483978173214999, + "plus_weight": 244.10746553535728, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "ac9d8e284949a9b0781a65ccd24143f41484bf237e0035f249196b6cb59d86b9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.076539+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d2035750671db9e438c8a38701efc4ed47f7129531a052ce08a784adba8942f8", + "panel_kind": "sparse", + "panel_seed": 8305958690931705538, + "realization": 20, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a5bca0b56f0227669bf5af8f9a86f77304f0c5ca26e0128f89d5c07cca842401", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03672405111534426, + "kernel_residual": 9.22899428007268e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06952457190731813, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.487723998860449, + "minus_target_entropy": 0.9387788637351351, + "minus_weight": 3.6330519961702215, + "orthogonality_relative_error": 3.4671283141372636e-16, + "plus_external_effective_rank": 12.558304257826704, + "plus_external_entropy": 0.871781959835089, + "plus_target_effective_rank": 18.565020693568165, + "plus_target_entropy": 0.9310439290387075, + "plus_weight": 201.69107127957807, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 25, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "b335f03d46ce9729991aa594ae35b3e5f03bf703e2d998ac4690210768d9846c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.133034+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d2035750671db9e438c8a38701efc4ed47f7129531a052ce08a784adba8942f8", + "panel_kind": "isotropic", + "panel_seed": 8305958690931705538, + "realization": 20, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3fcf72bd8cd171a84eac3d2f92c2e9a8da7d355388b858c8947dc9598c39625b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03672405111534426, + "kernel_residual": 9.22899428007268e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07147736863300588, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.676699352887803, + "minus_target_entropy": 0.949962460129035, + "minus_weight": 3.724127087666365, + "orthogonality_relative_error": 3.314199247999751e-16, + "plus_external_effective_rank": 14.752747299657258, + "plus_external_entropy": 0.8922204500223545, + "plus_target_effective_rank": 21.94695801906541, + "plus_target_entropy": 0.9674446854796761, + "plus_weight": 200.8914481450418, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "36170fae0df853214cde9a3ea3d396fe876f0a6c63be60be970fd9d8d16faf5e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.194426+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "abe09e28dd09aa08114f00913ec69cf596270744bfd0942060b38404f2a35d7f", + "panel_kind": "sparse", + "panel_seed": 6072950980575034836, + "realization": 21, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "02c0c13e70db205a8ef0838c91c3a69a4cbfc24b74d4a517b786ce76f995cc78", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.019581228818421302, + "kernel_residual": 9.503434411225044e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05667113459549975, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.661315365643854, + "minus_target_entropy": 0.9501772473566482, + "minus_weight": 4.019567344451554, + "orthogonality_relative_error": 6.063836246049662e-16, + "plus_external_effective_rank": 9.933300662356366, + "plus_external_entropy": 0.8122458755726288, + "plus_target_effective_rank": 17.126855876308763, + "plus_target_entropy": 0.9233579795992567, + "plus_weight": 275.6140397695276, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "4d118513c46552b1044d981f963682ff629fc470243e522eeb6d0d3b17805856", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.248662+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "abe09e28dd09aa08114f00913ec69cf596270744bfd0942060b38404f2a35d7f", + "panel_kind": "isotropic", + "panel_seed": 6072950980575034836, + "realization": 21, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "dc28814705a77d5e11ba0aa0a601640eadc42677b8acc6261eb289f71e8452b6", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.019581228818421302, + "kernel_residual": 9.503434411225044e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06585859308301838, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.132980798569834, + "minus_target_entropy": 0.9704777304262242, + "minus_weight": 4.158631486764769, + "orthogonality_relative_error": 5.7410373425808e-16, + "plus_external_effective_rank": 10.830839774043012, + "plus_external_entropy": 0.8328533271282298, + "plus_target_effective_rank": 20.330086914789856, + "plus_target_entropy": 0.9531784455275065, + "plus_weight": 244.19134532337105, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "7096a3001f8c3286c3e1621228c183bf84afd219b5dfbdb6013222857c803c13", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.308682+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "fc221b4fb52bef66687ac28ee545ac7413df996996c4e9d41ae9a54b1d1cd995", + "panel_kind": "sparse", + "panel_seed": 13259922740100560487, + "realization": 22, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0bcaee6865d5097bdcd985c67abfc1fb5ebe7a8f90eb676dfc74fe25ac4aca40", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.05965821397788834, + "kernel_residual": 9.083792536696617e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08731476099351898, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.062823393521797, + "minus_target_entropy": 0.9643102166471357, + "minus_weight": 3.966545657981663, + "orthogonality_relative_error": 2.1615395533981525e-16, + "plus_external_effective_rank": 15.804835401734808, + "plus_external_entropy": 0.8959936090592497, + "plus_target_effective_rank": 21.15467699105823, + "plus_target_entropy": 0.9580137832240716, + "plus_weight": 173.68881433398985, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "479383f9ec21e7f6076ecdba19895fcd99e116031bd3ef64c353caed30c09ed1", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.361999+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "fc221b4fb52bef66687ac28ee545ac7413df996996c4e9d41ae9a54b1d1cd995", + "panel_kind": "isotropic", + "panel_seed": 13259922740100560487, + "realization": 22, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "65a27aa8a8d05c371039ec4f38bd6d0d30de550ce1d417c1fd796f1500ed4eb1", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.05965821397788834, + "kernel_residual": 9.083792536696617e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08217302522034824, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.777928211823393, + "minus_target_entropy": 0.9554525346215385, + "minus_weight": 3.612467100898233, + "orthogonality_relative_error": 2.2173022608578168e-16, + "plus_external_effective_rank": 17.631128017025883, + "plus_external_entropy": 0.9210608741871515, + "plus_target_effective_rank": 22.99591568483662, + "plus_target_entropy": 0.9744905597416674, + "plus_weight": 168.54449795039596, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "07ebeb9e103b3363e54799fc47995e504c03a47f3e2e26e5a687d9a5b207f025", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.415873+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "733f5798e621851e819b6e3a267798232ab22cc2a13832592894866b857a2b04", + "panel_kind": "sparse", + "panel_seed": 6636942677701829995, + "realization": 23, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0465e03dfa44372d7c34836c2b34e0672b876f115a2b3a9e9c296a31561a46fd", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.016985828128960136, + "kernel_residual": 9.441899915160604e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07401958801046096, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.889001261418759, + "minus_target_entropy": 0.9586452214559548, + "minus_weight": 4.227311447676893, + "orthogonality_relative_error": 1.1205834812304206e-15, + "plus_external_effective_rank": 10.799408163440187, + "plus_external_entropy": 0.8370655513162283, + "plus_target_effective_rank": 17.68535934681068, + "plus_target_entropy": 0.9253449376864741, + "plus_weight": 219.90696675452068, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "b79e1e5bb9545e5f03fc7f629e13b8e355d95a26db7c8ecddd018a93e49455f3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.464213+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "733f5798e621851e819b6e3a267798232ab22cc2a13832592894866b857a2b04", + "panel_kind": "isotropic", + "panel_seed": 6636942677701829995, + "realization": 23, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6803d34bfdc7b3d214ad7c0bc424c943a5e407741a3dc6170db5608799b60507", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.016985828128960136, + "kernel_residual": 9.441899915160604e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06330946206148112, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.740202974505475, + "minus_target_entropy": 0.9526176184851574, + "minus_weight": 4.0017835658909275, + "orthogonality_relative_error": 1.1679268692868772e-15, + "plus_external_effective_rank": 11.07869900586513, + "plus_external_entropy": 0.8410647401560165, + "plus_target_effective_rank": 19.124273323098812, + "plus_target_entropy": 0.9459702920817841, + "plus_weight": 244.77053139338804, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "12d589049f2033cea256adc0f8cb0c05f91182bc2c5bdbcc9dc36b96475d451f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.517999+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "18ad90913109b7fda81ae5108543a17db9b2e9614e42e0f4180d4a3ec60ef131", + "panel_kind": "sparse", + "panel_seed": 13295277435273124797, + "realization": 24, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "816ae9e5ff36ff691fb14f9917843bf3bc930e99572c4a3aaeb5b5b9c1c20073", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.039017049245403716, + "kernel_residual": 9.672505373110238e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.079337175388374, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.891035830457261, + "minus_target_entropy": 0.959727822917611, + "minus_weight": 3.9450280970101623, + "orthogonality_relative_error": 3.9166294669688393e-16, + "plus_external_effective_rank": 12.657320692059661, + "plus_external_entropy": 0.8623515749453114, + "plus_target_effective_rank": 19.34325328929082, + "plus_target_entropy": 0.9390604386893571, + "plus_weight": 190.92777714816822, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "5fd1d153d6ddb945b7401cc19601895ee573f09131de6b0303d8673aff0c340e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.564165+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "18ad90913109b7fda81ae5108543a17db9b2e9614e42e0f4180d4a3ec60ef131", + "panel_kind": "isotropic", + "panel_seed": 13295277435273124797, + "realization": 24, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6bdb16df0a7de95d5d784f3878c3e6c140483e67fe605d2ddfc3b45028fdc554", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.039017049245403716, + "kernel_residual": 9.672505373110238e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.09269010433613502, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.210570384225353, + "minus_target_entropy": 0.9719186396179382, + "minus_weight": 4.246480979860136, + "orthogonality_relative_error": 3.7979060168972605e-16, + "plus_external_effective_rank": 16.457833896329237, + "plus_external_entropy": 0.9088698440575351, + "plus_target_effective_rank": 22.092674343029273, + "plus_target_entropy": 0.9675242459056823, + "plus_weight": 174.65878088436523, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "501d802853cdb9dc13078efc8c1ff976c0dcf2e63ef461e484f7f5c8f349a927", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.613933+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "877258797b69667613dc6a3728164f0a75c3b1cb6a6ff7ae9dcbcaec2a054323", + "panel_kind": "sparse", + "panel_seed": 10056642251172038095, + "realization": 25, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4c91b48d36a6a068980e3c945bc1757d1526f32bae455a5c67b5b533baa0608f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04336137707138388, + "kernel_residual": 9.135435973038732e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08030892227865195, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.481450782397987, + "minus_target_entropy": 0.9391378274059528, + "minus_weight": 3.786556017982194, + "orthogonality_relative_error": 2.5430174188692757e-16, + "plus_external_effective_rank": 13.81385755652447, + "plus_external_entropy": 0.879845675519027, + "plus_target_effective_rank": 19.338941603603335, + "plus_target_entropy": 0.9406680014210914, + "plus_weight": 180.94716781619556, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "1e438d17889b1a16fd87f361162aeca2b5ba759675056b328f238e9f97bec5a7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.658342+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "877258797b69667613dc6a3728164f0a75c3b1cb6a6ff7ae9dcbcaec2a054323", + "panel_kind": "isotropic", + "panel_seed": 10056642251172038095, + "realization": 25, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ee338e207ba522e466f5261f2c08dc5e7af5792e5d45dc6603f763160bda898c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04336137707138388, + "kernel_residual": 9.135435973038732e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0827013815846243, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.061973939883839, + "minus_target_entropy": 0.9656369453951518, + "minus_weight": 4.126957702727019, + "orthogonality_relative_error": 2.59438841207805e-16, + "plus_external_effective_rank": 15.242288226371421, + "plus_external_entropy": 0.8946244458531183, + "plus_target_effective_rank": 22.24253365178964, + "plus_target_entropy": 0.969346338070928, + "plus_weight": 191.26471517881532, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "1d81c4812ec9dfb58d6ec80d1f6506a95601e89e43b1da0e60858cf6cb5c753f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.707134+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "455b72d82f0a24b115e11f0724c2f9d5712d4a16d64fefc23c192879e93ac49a", + "panel_kind": "sparse", + "panel_seed": 7703111330408262876, + "realization": 26, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "809e04f33117d65fb57bd13d6532eb374deef52b0d6108614366c17ff70cd725", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04255559204350772, + "kernel_residual": 9.435310641170021e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07787888473926498, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.677977711155954, + "minus_target_entropy": 0.9510856064739919, + "minus_weight": 3.9280319044248175, + "orthogonality_relative_error": 2.1793429006414624e-16, + "plus_external_effective_rank": 14.800876019409387, + "plus_external_entropy": 0.8873490613799156, + "plus_target_effective_rank": 21.252292402441867, + "plus_target_entropy": 0.95858306618275, + "plus_weight": 193.81513124989755, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "53fd7d052ad5c9d89b0838c28339da0a03818924c1b4391c38dcfc3c5fa19b66", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.748937+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "455b72d82f0a24b115e11f0724c2f9d5712d4a16d64fefc23c192879e93ac49a", + "panel_kind": "isotropic", + "panel_seed": 7703111330408262876, + "realization": 26, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "26ad4120384171384131fd5dc001e90bbef7876875528b0c2c531e79c14509fa", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04255559204350772, + "kernel_residual": 9.435310641170021e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0778952180224364, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.906583028399484, + "minus_target_entropy": 0.9609127002220231, + "minus_weight": 3.8354966903123433, + "orthogonality_relative_error": 2.304111200143174e-16, + "plus_external_effective_rank": 15.595823864420655, + "plus_external_entropy": 0.8996853347750999, + "plus_target_effective_rank": 21.785533541186076, + "plus_target_entropy": 0.9652807415493139, + "plus_weight": 189.2079775010883, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "834953319ab70e1128af356c3bc910cf1ddfd361f9d840aea1587e9271eae593", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.796640+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "855c409dc7d167c6057c4c87e8808ae2a90e5f48a8e79d0efeda32e4281ca8ec", + "panel_kind": "sparse", + "panel_seed": 619384347507738987, + "realization": 27, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e6441efd64420a8212745f66a319e43aa1a20d2868b0e2820ba72eb20d4df747", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.037710859087816025, + "kernel_residual": 9.371812877319012e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08128604736945222, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.893703292598664, + "minus_target_entropy": 0.9606004305165875, + "minus_weight": 4.127713440294628, + "orthogonality_relative_error": 4.142997201224517e-16, + "plus_external_effective_rank": 14.636844249499218, + "plus_external_entropy": 0.8826742744198447, + "plus_target_effective_rank": 19.89941822424145, + "plus_target_entropy": 0.949280112019775, + "plus_weight": 194.77749030302692, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "d98932ad40c53b10f2e251a38e104aa691e6b02cfcba70b7523255156e20f375", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.840627+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "855c409dc7d167c6057c4c87e8808ae2a90e5f48a8e79d0efeda32e4281ca8ec", + "panel_kind": "isotropic", + "panel_seed": 619384347507738987, + "realization": 27, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "84e2bb130416fc24ac371043ed07d1dfefd6af4e3e5ab1f3c7156b5c2543595e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.037710859087816025, + "kernel_residual": 9.371812877319012e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07937126878061747, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.909258305825506, + "minus_target_entropy": 0.9599264205939072, + "minus_weight": 4.001445417051791, + "orthogonality_relative_error": 4.384885873798812e-16, + "plus_external_effective_rank": 15.104295160418138, + "plus_external_entropy": 0.8933858762921899, + "plus_target_effective_rank": 21.85409148637087, + "plus_target_entropy": 0.966404934644868, + "plus_weight": 193.57151508756027, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "43ac7811f603e8a9e1ae16700573cac3c47d0d3846cea1e22b2dfaab7946f8a3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.887620+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "a008e7318f0e2ed1787e89952570f7c85a75700c9aecd426d3c4d554b8b72c15", + "panel_kind": "sparse", + "panel_seed": 9414262090148031847, + "realization": 28, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7323970c0fa01fbf049a21f8d0ba82f8c36250b6c567d140a394a8f0dd480c19", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03408167318359723, + "kernel_residual": 9.7006216950912e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.09473376791213606, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.008034526554224, + "minus_target_entropy": 0.9634132781388235, + "minus_weight": 4.387222456853992, + "orthogonality_relative_error": 2.999077668848089e-16, + "plus_external_effective_rank": 14.475710777141638, + "plus_external_entropy": 0.8813592044144649, + "plus_target_effective_rank": 18.828209876632016, + "plus_target_entropy": 0.9371736681233145, + "plus_weight": 176.36070936815528, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "46f8bcb586b9e16cb3f1e6e38ea9412d74d09e62fd923e21d64e0b5d3ef428de", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.929590+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "a008e7318f0e2ed1787e89952570f7c85a75700c9aecd426d3c4d554b8b72c15", + "panel_kind": "isotropic", + "panel_seed": 9414262090148031847, + "realization": 28, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "fcc4afba0de3a525de73645482b5a4cb07a0a6470f4a1215c45f01e21cc2d905", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03408167318359723, + "kernel_residual": 9.7006216950912e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06917593228000651, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.0380074961725505, + "minus_target_entropy": 0.966084501263128, + "minus_weight": 3.8867564879053877, + "orthogonality_relative_error": 3.27604255463612e-16, + "plus_external_effective_rank": 13.416996117166219, + "plus_external_entropy": 0.8722461700556435, + "plus_target_effective_rank": 20.793406232567218, + "plus_target_entropy": 0.9585259102084502, + "plus_weight": 216.90301062432692, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "5b3762a69e1c93bd53cf0cfe4f52b585961c995a8348a8efdbdf6184a288c534", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:14.975347+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "f3237348441a24c07c5655af9044fab5023138a041c2f0b1c5c05c2dad6df297", + "panel_kind": "sparse", + "panel_seed": 1505830439293153535, + "realization": 29, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1f3bfbb9c47f142307a2515b8ff3e3331e22955e7b7cd0dffe4bca279e2a50aa", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.041701020043819606, + "kernel_residual": 9.448609638619279e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07716612243151771, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.780102756231253, + "minus_target_entropy": 0.9548532287194299, + "minus_weight": 3.9726420284209, + "orthogonality_relative_error": 2.501311660511251e-16, + "plus_external_effective_rank": 14.638895838189642, + "plus_external_entropy": 0.8897206671376168, + "plus_target_effective_rank": 19.78621225377902, + "plus_target_entropy": 0.9445157395394357, + "plus_weight": 197.90171094271398, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "1abe1bac5677d9c3069d5c3baae2aceaf91e0c341260e73f2a8e3ec2fb2f110a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.016747+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "f3237348441a24c07c5655af9044fab5023138a041c2f0b1c5c05c2dad6df297", + "panel_kind": "isotropic", + "panel_seed": 1505830439293153535, + "realization": 29, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0c48736c8299ffcd680a788895c70a67ca43ee6cd0fffe4a11b3a32ff579ea82", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.041701020043819606, + "kernel_residual": 9.448609638619279e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07430738426332094, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.909871315428448, + "minus_target_entropy": 0.9583777675835344, + "minus_weight": 3.9138853276621344, + "orthogonality_relative_error": 2.563813937155839e-16, + "plus_external_effective_rank": 15.21663302060028, + "plus_external_entropy": 0.8921087460864238, + "plus_target_effective_rank": 22.39907213434284, + "plus_target_entropy": 0.9690910336663062, + "plus_weight": 202.78289992725917, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "f11db895ed27f1ee28b80896f82335ee65309ccbd7278dc0eae10adf0cc208b8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.060666+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d295aba55d51caf1c86ac2aa2972142385f3359ec28807efd4c1938a2c54d27f", + "panel_kind": "sparse", + "panel_seed": 13826739762346464061, + "realization": 30, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "84e7cb63d1d00e87decd5632c5271f90a303b5938db3ee3ba996b7104b823b3a", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.046515867875906225, + "kernel_residual": 1.0166792220563414e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06628480576945835, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.990403432725482, + "minus_target_entropy": 0.9642529618565188, + "minus_weight": 3.522450837059854, + "orthogonality_relative_error": 4.837397164026053e-16, + "plus_external_effective_rank": 14.742983467881308, + "plus_external_entropy": 0.8789145920010278, + "plus_target_effective_rank": 20.400343843677973, + "plus_target_entropy": 0.9503408081174128, + "plus_weight": 205.4593103287845, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "32f6d90753428cd124ad825392fd1091b25a3844b527549641b68246636c389d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.099517+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d295aba55d51caf1c86ac2aa2972142385f3359ec28807efd4c1938a2c54d27f", + "panel_kind": "isotropic", + "panel_seed": 13826739762346464061, + "realization": 30, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "f8bed5ba4fe9c639d9e3da38ac11996a9cf53249ea2a2c59719dd744d099aa35", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.046515867875906225, + "kernel_residual": 1.0166792220563414e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08442343118564147, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.230305189169924, + "minus_target_entropy": 0.9727352469943121, + "minus_weight": 4.2515893392696, + "orthogonality_relative_error": 4.878693091104856e-16, + "plus_external_effective_rank": 15.825621431500611, + "plus_external_entropy": 0.8997316846792153, + "plus_target_effective_rank": 22.66754588251347, + "plus_target_entropy": 0.9721142977052467, + "plus_weight": 192.8442884448262, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "d23bf25943169e4a1ae7e943a5bebe0cad22df49d91d8422aad51b28263a8fab", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.146903+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "990d21c1c2e3c4caa2d5cfd76fc21135f11d2593651646f55caf271d5abe2c31", + "panel_kind": "sparse", + "panel_seed": 1767629917062996345, + "realization": 31, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1ec372357d988b75238c89442c921794d5731cc087e97a261babab37b8ef3e8a", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02696673319787823, + "kernel_residual": 9.158190521276848e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08112129085507856, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.812933306231396, + "minus_target_entropy": 0.9529091866699106, + "minus_weight": 4.238667419246446, + "orthogonality_relative_error": 4.0342971102130916e-16, + "plus_external_effective_rank": 13.93668859881685, + "plus_external_entropy": 0.8766572779394022, + "plus_target_effective_rank": 19.344111272809645, + "plus_target_entropy": 0.9442649597600391, + "plus_weight": 200.43697282894152, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "66556ded0c2844d263bb23b8bd262d55994dbae2719cd283a0067a8d5b4fdf62", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.197361+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "990d21c1c2e3c4caa2d5cfd76fc21135f11d2593651646f55caf271d5abe2c31", + "panel_kind": "isotropic", + "panel_seed": 1767629917062996345, + "realization": 31, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "30d412faedc3c0cfe715443d56319d94e43217746cbbc25a95866dcd6844cfda", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02696673319787823, + "kernel_residual": 9.158190521276848e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07544342029473185, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.264377813975295, + "minus_target_entropy": 0.9748151476961749, + "minus_weight": 4.10724296969088, + "orthogonality_relative_error": 4.445734012613896e-16, + "plus_external_effective_rank": 13.292740001985976, + "plus_external_entropy": 0.8732152682928978, + "plus_target_effective_rank": 21.39605857146837, + "plus_target_entropy": 0.9626915088112893, + "plus_weight": 209.47045029015382, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "0279a5c208425ff284ab0ca7a5f8e86fae580194f48f52dc82d7199b52f46b81", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.247617+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "36779a95a007be60a62b3ae3f80649036a96928714bcd4a75e7882cd3d331664", + "panel_kind": "sparse", + "panel_seed": 14431721005041423857, + "realization": 32, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3691149ec23ffd6d5ab82fbe3eeac22da75e55858a423fb681ac4e7d1ea8026c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02805557985672942, + "kernel_residual": 1.0743698077509832e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.064543955753413, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.903152948727098, + "minus_target_entropy": 0.9591869050985873, + "minus_weight": 3.8494279879752247, + "orthogonality_relative_error": 4.281241160888051e-16, + "plus_external_effective_rank": 12.161960841532924, + "plus_external_entropy": 0.8452074652070601, + "plus_target_effective_rank": 18.86011287302905, + "plus_target_entropy": 0.9363760735116835, + "plus_weight": 230.79858067775956, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "dcefd080a3cc148cc7810bfbbdab56d459413e8d142ff3a9bdfd8d772470b10a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.296543+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "36779a95a007be60a62b3ae3f80649036a96928714bcd4a75e7882cd3d331664", + "panel_kind": "isotropic", + "panel_seed": 14431721005041423857, + "realization": 32, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e74c25c33837297caf767fcc00ec587711a2891eaf84aee1cb39ef0a0b61448a", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02805557985672942, + "kernel_residual": 1.0743698077509832e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06233464417184844, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.852291077782157, + "minus_target_entropy": 0.9545318673295816, + "minus_weight": 3.9076122428397686, + "orthogonality_relative_error": 4.335325494503823e-16, + "plus_external_effective_rank": 12.644572000827628, + "plus_external_entropy": 0.8569251984325927, + "plus_target_effective_rank": 21.456750455332692, + "plus_target_entropy": 0.9624149909888621, + "plus_weight": 242.87249804410308, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "3a7d1b94480696d680fb62f888456e44ff59e0aa4e3615819100748ad1cec809", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.361873+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "77f778e1f406718adff1851b5a105ad6866499a0fc49d9e38391dc4c5e63bffe", + "panel_kind": "sparse", + "panel_seed": 6163674277238423903, + "realization": 33, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "6a8f961c19224de6a247c8356680cba4c7d18516c88259eb6e59e32aae955f76", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02431290869608705, + "kernel_residual": 1.029770387492062e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06533098265473934, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.8192181034859995, + "minus_target_entropy": 0.9581459404917425, + "minus_weight": 4.106309588480727, + "orthogonality_relative_error": 5.566286282437528e-16, + "plus_external_effective_rank": 10.524706261464205, + "plus_external_entropy": 0.8242657816000496, + "plus_target_effective_rank": 17.46542634546007, + "plus_target_entropy": 0.9203259953251238, + "plus_weight": 243.13378435116203, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "c7eda033cd6de6f81e5c512baa2576ebcbc318a3d7e151d1d10bd5a4ff27948a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.412090+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "77f778e1f406718adff1851b5a105ad6866499a0fc49d9e38391dc4c5e63bffe", + "panel_kind": "isotropic", + "panel_seed": 6163674277238423903, + "realization": 33, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0982f69fa26b243c9984eff8ad86f71b0622f5b17cad4b5677d391cbc4b5c57b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02431290869608705, + "kernel_residual": 1.029770387492062e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06091387880232937, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.068055219706227, + "minus_target_entropy": 0.9672876082389736, + "minus_weight": 3.856173522294837, + "orthogonality_relative_error": 5.303219829376822e-16, + "plus_external_effective_rank": 11.226870636370693, + "plus_external_entropy": 0.8445480649236758, + "plus_target_effective_rank": 20.526561474668874, + "plus_target_entropy": 0.9554445930184131, + "plus_weight": 245.44841087638318, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "775e50b2077155fc725978330177c9d013c23b5df3f0e2115429b82e291570e7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.465718+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "8da26b19dc58d564b8b6c3eaaf13f79a469e416c19278fba513af824431f60d0", + "panel_kind": "sparse", + "panel_seed": 9971808617202818391, + "realization": 34, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cd0f28246274e571adc9398b2de40d748d00f8677d69d96293de7ce0e519577c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.0334855292204153, + "kernel_residual": 9.035463246902373e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08483466654712873, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.803233394854467, + "minus_target_entropy": 0.9529946630980187, + "minus_weight": 4.252376407482744, + "orthogonality_relative_error": 2.959706298833491e-16, + "plus_external_effective_rank": 13.255679724046875, + "plus_external_entropy": 0.8620197226530973, + "plus_target_effective_rank": 18.273175571705043, + "plus_target_entropy": 0.928857867857152, + "plus_weight": 191.9028456812836, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "800546126ca328c0ccffd1a90f69b32985ef54a4140c7cf2b112b6e869e22d36", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.509827+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "8da26b19dc58d564b8b6c3eaaf13f79a469e416c19278fba513af824431f60d0", + "panel_kind": "isotropic", + "panel_seed": 9971808617202818391, + "realization": 34, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e42605e9363f6ae67a6a0caaa698385334013548ef3fdda2f06455b42432513f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.0334855292204153, + "kernel_residual": 9.035463246902373e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06630339447949857, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.893952817883276, + "minus_target_entropy": 0.9595361168972232, + "minus_weight": 3.953162667755162, + "orthogonality_relative_error": 3.438135131820729e-16, + "plus_external_effective_rank": 12.800940081265905, + "plus_external_entropy": 0.8620540029797883, + "plus_target_effective_rank": 22.209252271051387, + "plus_target_entropy": 0.9688121540850391, + "plus_weight": 230.51518894211807, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "b06c4c580ef645e56bd6c317a7f756c51a3e0d5dcd816e82b5123cb0f55a4da2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.559715+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "815b510b6c07acc1f54c16630d931ecc1db5e6b341117269d23102f9a9833c01", + "panel_kind": "sparse", + "panel_seed": 10539133455871650115, + "realization": 35, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5ebe25ac3999b85b40851144852b58e4d062352248b803d5b8a9d3d1facc5485", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03157968067103692, + "kernel_residual": 9.330078764929797e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05312925740064551, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.314406806979062, + "minus_target_entropy": 0.928839541755119, + "minus_weight": 3.4126152503844995, + "orthogonality_relative_error": 4.864528701776392e-16, + "plus_external_effective_rank": 12.718062439858942, + "plus_external_entropy": 0.8511549142430684, + "plus_target_effective_rank": 20.34318308301645, + "plus_target_entropy": 0.9515921256179183, + "plus_weight": 250.05746044589864, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "dd8bd118ad3121c22249dad60725b65d9200f411f993f71a12667d5c28755492", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.602966+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "815b510b6c07acc1f54c16630d931ecc1db5e6b341117269d23102f9a9833c01", + "panel_kind": "isotropic", + "panel_seed": 10539133455871650115, + "realization": 35, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3a4de5e33d42b9580e1fdaa184a2e88d9e50953e11943bf528901d4403711917", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03157968067103692, + "kernel_residual": 9.330078764929797e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07171512392362432, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.039109656113277, + "minus_target_entropy": 0.9646646042995715, + "minus_weight": 4.163174132405647, + "orthogonality_relative_error": 4.794460428895919e-16, + "plus_external_effective_rank": 14.561320977211151, + "plus_external_entropy": 0.8803867949307247, + "plus_target_effective_rank": 21.773448781609474, + "plus_target_entropy": 0.964483899163814, + "plus_weight": 223.80241002261738, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "bab86c13748f9df5f68f3bedea6a5a1a4d9588be3377ea3da2f8019698f7c0e8", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.649358+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "9eada57451e660940b85b6d0b10bad62ce1cf9b3f53c4b07ae80fb4e470a27ea", + "panel_kind": "sparse", + "panel_seed": 2158251492828934580, + "realization": 36, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "987b5c7cc596e3b3af2facb09f9e9a98c767446bdaef0d7d4503fcab49e36677", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02162291312462984, + "kernel_residual": 1.0147273484964446e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06451087896703751, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.702888522198516, + "minus_target_entropy": 0.9481710085856364, + "minus_weight": 4.091032064821375, + "orthogonality_relative_error": 9.049333399743384e-16, + "plus_external_effective_rank": 10.175705436368556, + "plus_external_entropy": 0.8274085313051615, + "plus_target_effective_rank": 15.37523896820599, + "plus_target_entropy": 0.9066590902310526, + "plus_weight": 245.4143690250109, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "6072f9673df01a3bdb87e81481de722e542d8834865596851e50e105f1fc6966", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.692005+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "9eada57451e660940b85b6d0b10bad62ce1cf9b3f53c4b07ae80fb4e470a27ea", + "panel_kind": "isotropic", + "panel_seed": 2158251492828934580, + "realization": 36, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "151193604cf07896b407813215699c5c6d96c7d6574164a7850025b46eeaec75", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02162291312462984, + "kernel_residual": 1.0147273484964446e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0716882058718368, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.968117011022208, + "minus_target_entropy": 0.9609362113616182, + "minus_weight": 3.825531556653385, + "orthogonality_relative_error": 8.829350994441617e-16, + "plus_external_effective_rank": 12.304437490277248, + "plus_external_entropy": 0.8636051885582636, + "plus_target_effective_rank": 20.192497332023947, + "plus_target_entropy": 0.953302997011415, + "plus_weight": 205.73168947784018, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "8511d96b42056acf27ce56121ef0a766bf5d3f744a69ddb3db0965562d4c1a0c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.738686+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "bcb7996a6084456dfda3f8d5f1fab87e8f62ae69b5527b54f3be9fcb5d5e0d99", + "panel_kind": "sparse", + "panel_seed": 12216810490095280901, + "realization": 37, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7988f5c5655b22906a5a3a07ed196fc7017e07d27868c58539190cec02430d75", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02069793717279286, + "kernel_residual": 9.983547109539753e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06203904104193104, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.961716429707359, + "minus_target_entropy": 0.960623253860201, + "minus_weight": 3.761545281147348, + "orthogonality_relative_error": 1.110656052317372e-15, + "plus_external_effective_rank": 9.631192252282307, + "plus_external_entropy": 0.8155914716616439, + "plus_target_effective_rank": 16.984990332051208, + "plus_target_entropy": 0.9182433870601603, + "plus_weight": 234.94430818232038, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "1656c533ffcaa57c0217282a576d7a90747e1efe73f962864ef0343118f11806", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.781103+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "bcb7996a6084456dfda3f8d5f1fab87e8f62ae69b5527b54f3be9fcb5d5e0d99", + "panel_kind": "isotropic", + "panel_seed": 12216810490095280901, + "realization": 37, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d6c2e6dd71d38e6099b8f08310ff3a5b48b444589855def34c44346e81c9b309", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02069793717279286, + "kernel_residual": 9.983547109539753e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06422599249171478, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.997004270345313, + "minus_target_entropy": 0.9642251169614926, + "minus_weight": 3.7122999955485834, + "orthogonality_relative_error": 1.1125495625753338e-15, + "plus_external_effective_rank": 11.237078210831998, + "plus_external_entropy": 0.8489010657073353, + "plus_target_effective_rank": 20.616958203176782, + "plus_target_entropy": 0.9575088970317217, + "plus_weight": 223.71614243065784, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "278e92d793ad61653df4e7f6bbe70a7e2d92bbc50dfb416b0c0c5ee2907f115f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.826791+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4b5c3171902195b4d594c667a1ba902b7c11cb3a9b6a6c318496a94d7f6152dd", + "panel_kind": "sparse", + "panel_seed": 18238091485129436858, + "realization": 38, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "b921c906890da072c6a6b0a17484407f1ec420418bc4ba8480c178849a655248", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.048038950543806545, + "kernel_residual": 9.837602849945985e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0867028896462665, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.744898254393439, + "minus_target_entropy": 0.9522409029327411, + "minus_weight": 4.050275389738761, + "orthogonality_relative_error": 2.470927804126754e-16, + "plus_external_effective_rank": 14.844083341286785, + "plus_external_entropy": 0.8839858674917777, + "plus_target_effective_rank": 19.422022218600283, + "plus_target_entropy": 0.9381186297905894, + "plus_weight": 178.66531965988312, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "678b06c479fbdece0d1fb421544379c81e9ce7dec8174c9cf3fa1e9ef56728af", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.867447+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "4b5c3171902195b4d594c667a1ba902b7c11cb3a9b6a6c318496a94d7f6152dd", + "panel_kind": "isotropic", + "panel_seed": 18238091485129436858, + "realization": 38, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "8b6b6f13a93cca3df4aaf977a840af9cedcf7a5acc3f170229cb3111bab2ca6c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.048038950543806545, + "kernel_residual": 9.837602849945985e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08165102136370783, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.052102138820547, + "minus_target_entropy": 0.9661624319546682, + "minus_weight": 4.01410304210797, + "orthogonality_relative_error": 2.7251072560803696e-16, + "plus_external_effective_rank": 15.786137085438167, + "plus_external_entropy": 0.9009707218771162, + "plus_target_effective_rank": 22.59688800979358, + "plus_target_entropy": 0.9718097533018838, + "plus_weight": 188.5331299386056, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "c5a9bf57606ff300dd5efa206fb54e00c0f956e270819b4cc4c13a854363fb40", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.911299+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "e80a160debfcf4078d4f3b6f08e36e025fc035124605fa65e1d37bb2125d149b", + "panel_kind": "sparse", + "panel_seed": 3207291759636131940, + "realization": 39, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "eac6c9de384f6ea6ed9b5489ca5b6f2b6445b629d7113384e489656610c3cd92", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.039518897209372475, + "kernel_residual": 1.0273719121787922e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07515430527125616, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.004811672356531, + "minus_target_entropy": 0.9630819775905803, + "minus_weight": 3.76883855493206, + "orthogonality_relative_error": 2.5835641818702185e-16, + "plus_external_effective_rank": 14.067637183882821, + "plus_external_entropy": 0.878319875779668, + "plus_target_effective_rank": 19.041406376019268, + "plus_target_entropy": 0.9391379659122395, + "plus_weight": 192.98074311855774, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "1625db9e1ed1a4cba55a4892a8b48c218a582aca125ee1ba9a55edb67162f84b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.950375+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "e80a160debfcf4078d4f3b6f08e36e025fc035124605fa65e1d37bb2125d149b", + "panel_kind": "isotropic", + "panel_seed": 3207291759636131940, + "realization": 39, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3863edcd671cbfd871e2dcea9d5754654e4bb1865e0df979eea76c2ff5aa004b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.039518897209372475, + "kernel_residual": 1.0273719121787922e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0748766658632248, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.026970926949175, + "minus_target_entropy": 0.9661131788437467, + "minus_weight": 3.7811898663331514, + "orthogonality_relative_error": 2.7195613505564466e-16, + "plus_external_effective_rank": 14.71850680215643, + "plus_external_entropy": 0.8897362886245386, + "plus_target_effective_rank": 22.024419743466385, + "plus_target_entropy": 0.9668234965110625, + "plus_weight": 194.35969103142958, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "53560586a07af3da6b4d79166d35c39d9e732ee1ea8af61264490ab73d45746a", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:15.994685+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "fb72bb226c488287a1708c52b4416505f055486ee1e2e2546494fa6c70637f9a", + "panel_kind": "sparse", + "panel_seed": 6662868315813809543, + "realization": 40, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "07a4439385fe83869fffb0414a51cf2f8243aab89364a3154e1e43ae4e9c027c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02502586919981035, + "kernel_residual": 9.558798465081992e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06164140885694154, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.104318172257161, + "minus_target_entropy": 0.9677827813930184, + "minus_weight": 4.026935656543123, + "orthogonality_relative_error": 7.020454981062392e-16, + "plus_external_effective_rank": 11.811770446901223, + "plus_external_entropy": 0.8458155698613119, + "plus_target_effective_rank": 19.337371229803534, + "plus_target_entropy": 0.9392051977827722, + "plus_weight": 253.1957501737842, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 26, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "815b43cc2340678ffe000b623d3f0857d38cfac64522791d0250b8a482cc8e41", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.035254+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "fb72bb226c488287a1708c52b4416505f055486ee1e2e2546494fa6c70637f9a", + "panel_kind": "isotropic", + "panel_seed": 6662868315813809543, + "realization": 40, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "760c818a6d7726b4251b3474485ffc66aa323feb7aa29084de1c9cf7b7d1298a", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02502586919981035, + "kernel_residual": 9.558798465081992e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06033756943416116, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.998900087892035, + "minus_target_entropy": 0.9658851273098769, + "minus_weight": 3.920507874553746, + "orthogonality_relative_error": 6.6258508812977e-16, + "plus_external_effective_rank": 13.227096726261891, + "plus_external_entropy": 0.862535191925603, + "plus_target_effective_rank": 20.93703117692301, + "plus_target_entropy": 0.9577306314971631, + "plus_weight": 252.0029170363194, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "4078ba4ff0e2e26a81014d65b8f368fa79be589f79683873c238606906791bbc", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.080757+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "e25a140e3056d91fbfb3fa5ea398bc3a88de509a8afb0ad852f9754b53a7a76b", + "panel_kind": "sparse", + "panel_seed": 8403647489397277179, + "realization": 41, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "906519a5bac690e8ab2c08f94383e46091a0f3db45cd0091bddcb5a5a1d34aba", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03400872649428884, + "kernel_residual": 9.692802728360985e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0755392845953507, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.948661440995042, + "minus_target_entropy": 0.9626011895723015, + "minus_weight": 3.8778455626166304, + "orthogonality_relative_error": 2.63285595804616e-16, + "plus_external_effective_rank": 14.238499153894324, + "plus_external_entropy": 0.8806711237199739, + "plus_target_effective_rank": 19.90474531983833, + "plus_target_entropy": 0.9459532910529257, + "plus_weight": 197.5100994187035, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "73aa3d76268cec17912277e65356c0410456c0847e74971bd6322d47e262edd7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.119787+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "e25a140e3056d91fbfb3fa5ea398bc3a88de509a8afb0ad852f9754b53a7a76b", + "panel_kind": "isotropic", + "panel_seed": 8403647489397277179, + "realization": 41, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "1eaf32766cd58e02f54d825041bf2dd3f9794276efe35f47a3586989dd81e535", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03400872649428884, + "kernel_residual": 9.692802728360985e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07076934353510553, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.700791185235813, + "minus_target_entropy": 0.9511388867965135, + "minus_weight": 3.6431719675242147, + "orthogonality_relative_error": 2.687231375213996e-16, + "plus_external_effective_rank": 14.711479701124375, + "plus_external_entropy": 0.8914146119606206, + "plus_target_effective_rank": 21.85136476021242, + "plus_target_entropy": 0.9662364705961971, + "plus_weight": 198.56490036166235, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "9e233d92ade978d82113578e7333683451241ec6341bba082ec9d176b6bbdac2", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.165100+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "605d0defdf3d3fd0dead7213e10b22752eb01fdde457bb6b37c529c7bbf5cc37", + "panel_kind": "sparse", + "panel_seed": 9797533269871939222, + "realization": 42, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5157e996bfc4e64c30be273226e5c02045147cff923c65a183e585e6797686af", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.026193847047509742, + "kernel_residual": 1.023637585852314e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.055277816734955944, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.339704583530888, + "minus_target_entropy": 0.9338290010421565, + "minus_weight": 3.4559879397953983, + "orthogonality_relative_error": 6.689452668763523e-16, + "plus_external_effective_rank": 12.017864118963107, + "plus_external_entropy": 0.8473930045028154, + "plus_target_effective_rank": 19.315519087584875, + "plus_target_entropy": 0.9404647202073171, + "plus_weight": 243.12025989290905, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "dbe2d45c2eab756ee037d68392a3006eb44ab622105a64bae31dd32918727a16", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.206036+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "605d0defdf3d3fd0dead7213e10b22752eb01fdde457bb6b37c529c7bbf5cc37", + "panel_kind": "isotropic", + "panel_seed": 9797533269871939222, + "realization": 42, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "cdd9ba11bdb4af877ae16ff6120bb0dde38ca42b7a9735584d30a8455757dd94", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.026193847047509742, + "kernel_residual": 1.023637585852314e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06731547259437921, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.946803898331027, + "minus_target_entropy": 0.9619166151752089, + "minus_weight": 4.007668135935188, + "orthogonality_relative_error": 6.535646880834198e-16, + "plus_external_effective_rank": 12.58690399759952, + "plus_external_entropy": 0.8609979182413718, + "plus_target_effective_rank": 20.956166190304252, + "plus_target_entropy": 0.9587523196213195, + "plus_weight": 230.05731345121848, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "2bb718ca1dd45a207944bcb646364bedf838369012c19ae346c2949025503eea", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.251391+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "cc441f7edb6defad68cf2c2983bed05bbc787eb49059e3fb0cea750aba08642d", + "panel_kind": "sparse", + "panel_seed": 16154021174208469419, + "realization": 43, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2732cd3a864d10c3ebf80ebb6eec076307edca4c63f19083c5434b78a9703aa7", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.022269304608184753, + "kernel_residual": 9.425912648055657e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06742166566149393, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.792876544529535, + "minus_target_entropy": 0.9523113680856485, + "minus_weight": 4.229943326426285, + "orthogonality_relative_error": 3.82112192116305e-16, + "plus_external_effective_rank": 10.880787861592875, + "plus_external_entropy": 0.8322453658735965, + "plus_target_effective_rank": 15.018924180737287, + "plus_target_entropy": 0.8918904700618431, + "plus_weight": 242.42084924732018, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 26, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "c6ee8061b3318da3e58736c31f0dde54e4ee6b3e0b8cc7cd0c101f5c4eea8a6c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.292301+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "cc441f7edb6defad68cf2c2983bed05bbc787eb49059e3fb0cea750aba08642d", + "panel_kind": "isotropic", + "panel_seed": 16154021174208469419, + "realization": 43, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "2f13c0ad03e99bfbb738abc16498716a035b6f24d773f4f4926a945184ba8cd6", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.022269304608184753, + "kernel_residual": 9.425912648055657e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07173515371856627, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.7993206009443705, + "minus_target_entropy": 0.9547560400652271, + "minus_weight": 4.037127781664822, + "orthogonality_relative_error": 4.013031209369782e-16, + "plus_external_effective_rank": 13.004466506921183, + "plus_external_entropy": 0.8689782509459495, + "plus_target_effective_rank": 20.62945077758871, + "plus_target_entropy": 0.957084951592126, + "plus_weight": 216.96356080255777, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "d18f2d1064bb79306d407d19a30715d8f1f759bdef0bb550c7785500050e9c9f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.338102+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "457d3bd293bd10298d7b79061a552aad2ddeac37be1fc3771ce0f82007001a94", + "panel_kind": "sparse", + "panel_seed": 11886831641460578176, + "realization": 44, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ab3e4c45a0f36022bbeb2a4344f42d0cc370be62f5184489b8851ae2dd8f0ad4", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03233857788525284, + "kernel_residual": 9.313668085201289e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08719735495336117, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.078127021891789, + "minus_target_entropy": 0.9656777800004775, + "minus_weight": 4.164814233867163, + "orthogonality_relative_error": 2.6248731860421845e-16, + "plus_external_effective_rank": 13.226755345994288, + "plus_external_entropy": 0.8733071324969655, + "plus_target_effective_rank": 19.806581464480114, + "plus_target_entropy": 0.9457023493410647, + "plus_weight": 182.62771288814696, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "9250c0fb0d710c5a8b878c77ad7082cff716e40c3100b483212133eb13e1bc59", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.378323+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "457d3bd293bd10298d7b79061a552aad2ddeac37be1fc3771ce0f82007001a94", + "panel_kind": "isotropic", + "panel_seed": 11886831641460578176, + "realization": 44, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "155541ee9414983b9f174690ff38a4cf909bf1138159f54c60d5f5aa53910457", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03233857788525284, + "kernel_residual": 9.313668085201289e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07835576742665028, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.745784252575066, + "minus_target_entropy": 0.9512491402799261, + "minus_weight": 3.9596496277746938, + "orthogonality_relative_error": 2.8174343736780574e-16, + "plus_external_effective_rank": 13.57540595780099, + "plus_external_entropy": 0.882777605254768, + "plus_target_effective_rank": 21.310357606902986, + "plus_target_entropy": 0.9625674325040574, + "plus_weight": 194.13692311576366, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "098c59c0d15703ef934d5847b7196a24d112240fad50c6b3a26fa82580a302ed", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.423093+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "28d731a34370633435d8f3d94f698dfa214701a7c1b285242bd117627b278342", + "panel_kind": "sparse", + "panel_seed": 17881522337787230694, + "realization": 45, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5a5fe0d32337ebc748f90b5c3493247d350882fc69abf3e9dad01f873e18c949", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.017862708183946523, + "kernel_residual": 9.264379474265396e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05139102397619967, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.559457942919041, + "minus_target_entropy": 0.9447350810424161, + "minus_weight": 3.885257929999615, + "orthogonality_relative_error": 8.507357586620323e-16, + "plus_external_effective_rank": 8.542598472353946, + "plus_external_entropy": 0.7817676173761468, + "plus_target_effective_rank": 17.349219762325095, + "plus_target_entropy": 0.9217011076540378, + "plus_weight": 294.5857543096155, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "6add67265ad7f3c01be722db25c1fcdf13253a04943c91bc78b9455d5d028c87", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.464126+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "28d731a34370633435d8f3d94f698dfa214701a7c1b285242bd117627b278342", + "panel_kind": "isotropic", + "panel_seed": 17881522337787230694, + "realization": 45, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4a6416d09f98f4c5d32fb58e4027ca612b77d5b84a0b76dd7ec8241301895dbc", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.017862708183946523, + "kernel_residual": 9.264379474265396e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05129382589305509, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.645153223074956, + "minus_target_entropy": 0.9479439937757507, + "minus_weight": 3.7098578802070907, + "orthogonality_relative_error": 8.362496807968016e-16, + "plus_external_effective_rank": 9.869415318093951, + "plus_external_entropy": 0.8145510095716753, + "plus_target_effective_rank": 19.647896297226342, + "plus_target_entropy": 0.9464759738485283, + "plus_weight": 281.8339397399008, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "97f9851667fc53e4fd571b87eb93d5f1d5fbf484cdc5bd5aca4c5c027b8fee9d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.508851+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "52dac1585c2139ac72d2827989b68b4123faf105375579e5a02c4e5656efbfcc", + "panel_kind": "sparse", + "panel_seed": 14696773893940220218, + "realization": 46, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "7a4b48cfdd17d33dfb73a08f35fd3ae9a91755205e760772df1b050d53c7e9f3", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03831236941152241, + "kernel_residual": 9.493073913869347e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.09021546883312853, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.855593929248275, + "minus_target_entropy": 0.9566275008949848, + "minus_weight": 4.221250499155497, + "orthogonality_relative_error": 3.933998018803304e-16, + "plus_external_effective_rank": 14.961759653526013, + "plus_external_entropy": 0.8843711690401799, + "plus_target_effective_rank": 19.913849727498352, + "plus_target_entropy": 0.9486209612369317, + "plus_weight": 178.62078701631413, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "db7ead260359fe472b64cc3916e728e27663bd00a81e4fce85521f842a4e2725", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.549117+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "52dac1585c2139ac72d2827989b68b4123faf105375579e5a02c4e5656efbfcc", + "panel_kind": "isotropic", + "panel_seed": 14696773893940220218, + "realization": 46, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ddbf681354806645d9a01e6dc37fa784807ee2dbd9de1ea0258397548d0d3df8", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03831236941152241, + "kernel_residual": 9.493073913869347e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07722885706490738, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.921269741661641, + "minus_target_entropy": 0.9607110297037, + "minus_weight": 4.041320720177114, + "orthogonality_relative_error": 4.46273245296473e-16, + "plus_external_effective_rank": 14.187325166211568, + "plus_external_entropy": 0.8832286341349469, + "plus_target_effective_rank": 21.429789874170503, + "plus_target_entropy": 0.9631705376738899, + "plus_weight": 201.1527794015161, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "dd76834a8f990583c1f04fc9d688abc8639528ee7cab01836bbf4dee16d404ba", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.591746+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "34c5d1709c8858451d0c9de9376b8ac1267e46d81e9aed5f933cdc123f64de77", + "panel_kind": "sparse", + "panel_seed": 8492369121304438099, + "realization": 47, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c5efba8217a235546afe23d8c25161b1d555d56078d6e782f0a0d3fd2dad2880", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04026904206950467, + "kernel_residual": 9.027250007247453e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07245987196661022, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.494109189788115, + "minus_target_entropy": 0.9367270197269056, + "minus_weight": 3.7963361323611684, + "orthogonality_relative_error": 3.3925564185157124e-16, + "plus_external_effective_rank": 15.119520731074205, + "plus_external_entropy": 0.8839839887319959, + "plus_target_effective_rank": 19.82303787780229, + "plus_target_entropy": 0.9456133147887199, + "plus_weight": 201.90496916243453, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "ffd2b2754cef7aeb8037bd3a935c9a8c55a96057999a4eef96d85d9d1149d340", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.630371+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "34c5d1709c8858451d0c9de9376b8ac1267e46d81e9aed5f933cdc123f64de77", + "panel_kind": "isotropic", + "panel_seed": 8492369121304438099, + "realization": 47, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "63347603df776923b17f363cac707103148f4357ce1275eae1a7a298fbb7da2d", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04026904206950467, + "kernel_residual": 9.027250007247453e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07850001228533657, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.055972929849011, + "minus_target_entropy": 0.9673150331162019, + "minus_weight": 4.089242382732605, + "orthogonality_relative_error": 3.4210758216410825e-16, + "plus_external_effective_rank": 15.496683829783938, + "plus_external_entropy": 0.8947756928710727, + "plus_target_effective_rank": 22.337823394262344, + "plus_target_entropy": 0.9692432033907958, + "plus_weight": 200.10695640777925, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "5fd61768a368af98b4c1b314040f3f5f460a327314093133cf8b8c4f54b6c8e7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.672537+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "02b210d3f10b7053a48ef76208e720a548b4f04ed69a24ae9ede47889e3c76d6", + "panel_kind": "sparse", + "panel_seed": 16760624523105391144, + "realization": 48, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "17b969bccd9c53e43344cf6087b307a8ede79d0a3a3210d747c77684cfd6a742", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024166435068516828, + "kernel_residual": 1.0000913715441384e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06480809165357339, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.972536044815611, + "minus_target_entropy": 0.9618414440179434, + "minus_weight": 4.29415964955505, + "orthogonality_relative_error": 2.9379180296505915e-16, + "plus_external_effective_rank": 11.716106247590748, + "plus_external_entropy": 0.8466072879512423, + "plus_target_effective_rank": 19.88207491758332, + "plus_target_entropy": 0.946964423034917, + "plus_weight": 256.3782441062548, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "2801dbdfa368fa0043730b951b98b5cb21de240399905abe054f9683a90d21f7", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.711546+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "02b210d3f10b7053a48ef76208e720a548b4f04ed69a24ae9ede47889e3c76d6", + "panel_kind": "isotropic", + "panel_seed": 16760624523105391144, + "realization": 48, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "695002a2b3be3302d0fd6665a5a8bae0dad12af028c86fdbdbdbdbed90e99240", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024166435068516828, + "kernel_residual": 1.0000913715441384e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06167481919492837, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.694453731528625, + "minus_target_entropy": 0.9482474417066672, + "minus_weight": 3.834799348409473, + "orthogonality_relative_error": 2.966539594655995e-16, + "plus_external_effective_rank": 14.026693407301787, + "plus_external_entropy": 0.8741109926932841, + "plus_target_effective_rank": 21.050461102015667, + "plus_target_entropy": 0.9603888087507672, + "plus_weight": 240.9802380114515, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "4f60f0d283412948e9a3af3094fc36e168da4f24fb58535a44f7f1c08427e465", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.754094+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "ec0284f0eaba622e2d70eed2e027df8f42c4bbcd4d89ddb17f6e0ea8b5f88e56", + "panel_kind": "sparse", + "panel_seed": 1896903169962237912, + "realization": 49, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "3b5a7443ece9583107ee8750f65ecbd9c706227bba42eb410d65b7632fb92f3c", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024421055593207047, + "kernel_residual": 9.484423459040625e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07012405278642665, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.887675455741111, + "minus_target_entropy": 0.9605022675769841, + "minus_weight": 3.976067977661003, + "orthogonality_relative_error": 4.666767873577399e-16, + "plus_external_effective_rank": 11.999699300912, + "plus_external_entropy": 0.8510190777449931, + "plus_target_effective_rank": 18.435343451146917, + "plus_target_entropy": 0.9292724033724191, + "plus_weight": 218.7775528533251, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "30a4aa7f95633f7ad2a31c0037ca938f09b962de5aa10ec9d491d7165e3e3780", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.792679+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "ec0284f0eaba622e2d70eed2e027df8f42c4bbcd4d89ddb17f6e0ea8b5f88e56", + "panel_kind": "isotropic", + "panel_seed": 1896903169962237912, + "realization": 49, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e6e8caae96f6c353dd3353b6abbfb089c82900d03cfa51df25e55b8d0ba22ded", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024421055593207047, + "kernel_residual": 9.484423459040625e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.059530598805394457, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.987368861142755, + "minus_target_entropy": 0.9639738375660297, + "minus_weight": 3.7591435928026584, + "orthogonality_relative_error": 4.764349465141844e-16, + "plus_external_effective_rank": 11.864157129497691, + "plus_external_entropy": 0.8523093360831268, + "plus_target_effective_rank": 20.27728240041017, + "plus_target_entropy": 0.954363134665384, + "plus_weight": 245.009676421824, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "4f872c9e05e73ac3bbd6bdeb80f2acb51bb5b7b6e8f55c2584470f8f6947ceb0", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.835524+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "a100be657d2ccbb7e5379f981fbd4eb4da4cd540a64e2118865153187d9a5e57", + "panel_kind": "sparse", + "panel_seed": 8117014381380433351, + "realization": 50, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "94290456a63c4f136338ec174817a8d319ba16dda9e5cf556eace5e41584e0a1", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03843913849718271, + "kernel_residual": 9.239192584269058e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05411316224946724, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.219210098154999, + "minus_target_entropy": 0.9224173683664569, + "minus_weight": 3.2340581787400335, + "orthogonality_relative_error": 4.347642517788398e-16, + "plus_external_effective_rank": 12.096140205977743, + "plus_external_entropy": 0.8527870376030422, + "plus_target_effective_rank": 19.533324482226536, + "plus_target_entropy": 0.9392036652879329, + "plus_weight": 232.54580092745746, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "f913f4232caf0702b87a916991a9969d9cf542269f432341b5051ea85440d694", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.873699+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "a100be657d2ccbb7e5379f981fbd4eb4da4cd540a64e2118865153187d9a5e57", + "panel_kind": "isotropic", + "panel_seed": 8117014381380433351, + "realization": 50, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e47ee0057fd9365d6433a4c6c217197a1e80bf0009f5aa2a482c49e4d9384f7d", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03843913849718271, + "kernel_residual": 9.239192584269058e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07296868147289996, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.106317425394345, + "minus_target_entropy": 0.9679741307610771, + "minus_weight": 3.9622006015476323, + "orthogonality_relative_error": 4.526239908107396e-16, + "plus_external_effective_rank": 13.675075481880054, + "plus_external_entropy": 0.875941129775982, + "plus_target_effective_rank": 21.4503726969906, + "plus_target_entropy": 0.9629650409193022, + "plus_weight": 209.20062148655597, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "f72109ae56f49795911d719c341af7c1b88bda9228d07b03bee148b743b64b2c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.915723+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2a962f06c1da8720288571ddf6eb2a9fc29d1147e6b59d95bf6fde48e59f4158", + "panel_kind": "sparse", + "panel_seed": 14047963382650668555, + "realization": 51, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5fe8e699553aff1871106456ce1bf61b7db26294080e871d3b2f9c0f776472c4", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03215721518465336, + "kernel_residual": 9.883171931623477e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0704683730925614, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.521310207862921, + "minus_target_entropy": 0.9384662832916205, + "minus_weight": 3.8301870832005593, + "orthogonality_relative_error": 3.004829084111879e-16, + "plus_external_effective_rank": 13.080451445531484, + "plus_external_entropy": 0.862704954536116, + "plus_target_effective_rank": 19.51394660814401, + "plus_target_entropy": 0.9419953062302729, + "plus_weight": 209.68277400059287, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "290b5e351731c0b94c939df2bd654e584f7b569b9ee7253c01dfafaa187fcaca", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.953900+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "2a962f06c1da8720288571ddf6eb2a9fc29d1147e6b59d95bf6fde48e59f4158", + "panel_kind": "isotropic", + "panel_seed": 14047963382650668555, + "realization": 51, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "bff15895dcf03741e49f96ee581834b4b6af21f29e0305c14d8c2264d7042dd3", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03215721518465336, + "kernel_residual": 9.883171931623477e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06768989363759507, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.97774784863008, + "minus_target_entropy": 0.9611887472930127, + "minus_weight": 3.549797227638392, + "orthogonality_relative_error": 3.1440289361895646e-16, + "plus_external_effective_rank": 13.417216763262777, + "plus_external_entropy": 0.8813395249648679, + "plus_target_effective_rank": 21.554697122291863, + "plus_target_entropy": 0.9652190211271025, + "plus_weight": 202.60643683668616, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "0a0d30c55d087d2599da0ca38617a6dbdabb1198594fbc63ec4a70315b9c758c", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:16.995502+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "6ed4cc7e0ca318e51026ab14cae5316c211bea4915bcc5bd8f2db97b93bf5e58", + "panel_kind": "sparse", + "panel_seed": 6069293613950820156, + "realization": 52, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "80c166f9e665b4f88e40f02c327d2fdbfff7d4be57d4155cc395fcda96accb9f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.016725794403252024, + "kernel_residual": 1.0745160579740704e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05542610836987752, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.726650318675205, + "minus_target_entropy": 0.9537671765443556, + "minus_weight": 3.7442607218904818, + "orthogonality_relative_error": 3.9006666581697325e-16, + "plus_external_effective_rank": 10.043058191050495, + "plus_external_entropy": 0.8314134115307467, + "plus_target_effective_rank": 18.626242207528943, + "plus_target_entropy": 0.93622670199247, + "plus_weight": 262.6744959571675, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 26, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "b5a11b9d8137ff3ea6fa1b80a222e42ae6d2ef9d00ada9ad0d8ff8c5aea86981", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.033487+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "6ed4cc7e0ca318e51026ab14cae5316c211bea4915bcc5bd8f2db97b93bf5e58", + "panel_kind": "isotropic", + "panel_seed": 6069293613950820156, + "realization": 52, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c56d7fbcfce7d6ba7731fd2d5ca53ba9cda26943f8a5e67d59caf7f4812111ed", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.016725794403252024, + "kernel_residual": 1.0745160579740704e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0642140151983096, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.806619472750399, + "minus_target_entropy": 0.9569799931061199, + "minus_weight": 3.8918924332574876, + "orthogonality_relative_error": 3.8793922029682197e-16, + "plus_external_effective_rank": 12.184283358822622, + "plus_external_entropy": 0.8559195770321355, + "plus_target_effective_rank": 20.52830966901159, + "plus_target_entropy": 0.9562527443033222, + "plus_weight": 234.58423186421845, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "a5cbff3d0f1b81f6984d8fda6d08310609696879a0a9fd38c89de9fb2995e33e", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.075011+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "90036f47e26990688be9256989ed5fbb4e2d06965ac70a0bbe677b99ec47b543", + "panel_kind": "sparse", + "panel_seed": 15819019725900743756, + "realization": 53, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ed93d38eb1213a0eda41d368481d167afce8504bd878979383e053f616457673", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024442387483140066, + "kernel_residual": 1.0503737428563818e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.04978432013238374, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.025215691790306, + "minus_target_entropy": 0.9655588854587503, + "minus_weight": 3.8274785366350574, + "orthogonality_relative_error": 4.2267992746679557e-16, + "plus_external_effective_rank": 10.420047509577094, + "plus_external_entropy": 0.8182615865394832, + "plus_target_effective_rank": 18.507890260518, + "plus_target_entropy": 0.9250848601062401, + "plus_weight": 299.82100298549284, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 25, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "45545b000165ab8fd391254cb83332c160d183a8a8ebab924295c614941ad541", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.112224+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "90036f47e26990688be9256989ed5fbb4e2d06965ac70a0bbe677b99ec47b543", + "panel_kind": "isotropic", + "panel_seed": 15819019725900743756, + "realization": 53, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9b6a481e9a54aa266cf0698a50d6e7f98e0279a768e4e5d5d716e5cbce0a3080", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.024442387483140066, + "kernel_residual": 1.0503737428563818e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06057990210603284, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.938109072174344, + "minus_target_entropy": 0.9605200173029658, + "minus_weight": 4.139399861602291, + "orthogonality_relative_error": 3.949270992449002e-16, + "plus_external_effective_rank": 12.903762473606932, + "plus_external_entropy": 0.8507889146506253, + "plus_target_effective_rank": 20.946026279886453, + "plus_target_entropy": 0.9578319540405571, + "plus_weight": 264.97489440265974, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "65b57544997458c61fba9960b52df08d65cc8efb0cbd40a01abdbd9a9dcb922b", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.152816+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d1e8ebc6e9511b143ef83b57e11e76aec0a105fee1a12b34b4b9f89e2b63ae5c", + "panel_kind": "sparse", + "panel_seed": 13246710990002478436, + "realization": 54, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9f355a1ea1a1950067d1a52d992dab2d057db7aba6f2a7da2eca9f3d97869fcc", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.037646188873057075, + "kernel_residual": 9.276103082323517e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0778724607325321, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.003647887208307, + "minus_target_entropy": 0.9646454300495064, + "minus_weight": 3.82563468692216, + "orthogonality_relative_error": 3.3294179045147364e-16, + "plus_external_effective_rank": 13.553414358531118, + "plus_external_entropy": 0.8758822323444221, + "plus_target_effective_rank": 20.18872146586509, + "plus_target_entropy": 0.9492687723384228, + "plus_weight": 188.7789111811717, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "97bb7f260824648f802af80de7d1365a8be437b43eecb255f80e2c2622cd6e3d", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.190079+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d1e8ebc6e9511b143ef83b57e11e76aec0a105fee1a12b34b4b9f89e2b63ae5c", + "panel_kind": "isotropic", + "panel_seed": 13246710990002478436, + "realization": 54, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9d29dec7693b1069b0d0e71906b3c703450a8a5941575e7f180e793729a4b103", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.037646188873057075, + "kernel_residual": 9.276103082323517e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08008276097420303, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.85484214156462, + "minus_target_entropy": 0.95733364931975, + "minus_weight": 3.874471288458335, + "orthogonality_relative_error": 3.43446840077589e-16, + "plus_external_effective_rank": 13.95680156566429, + "plus_external_entropy": 0.8871269603732846, + "plus_target_effective_rank": 21.913156068030816, + "plus_target_entropy": 0.9667653999680311, + "plus_weight": 185.69357925447133, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "592a1042482497f9964535e5cb060f12ab22cc8e2fbaff5cb1ee8bc83ae4fa10", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.232894+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "1ecc6616268cf3f6ec52362f4336d9e2b1b48881fa0b23b01165d1060fe32b2d", + "panel_kind": "sparse", + "panel_seed": 2324830867988564616, + "realization": 55, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "61dbfafbd44312f79db9d652578cdc3c2f7dc051fb88cd3d3ab49d9ada7de72b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.027191015384236555, + "kernel_residual": 9.97844655067301e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06646039321186675, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.987499162920886, + "minus_target_entropy": 0.9637755172704525, + "minus_weight": 4.236231486035447, + "orthogonality_relative_error": 3.2565910672957617e-16, + "plus_external_effective_rank": 12.372674472241304, + "plus_external_entropy": 0.8478616072815764, + "plus_target_effective_rank": 20.061127909080728, + "plus_target_entropy": 0.9477634150778369, + "plus_weight": 246.4174807266818, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "7bb8287c5b19ecd6196fbdaeba36496e6ccbb331f9600148ae38590f7c972a16", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.271696+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "1ecc6616268cf3f6ec52362f4336d9e2b1b48881fa0b23b01165d1060fe32b2d", + "panel_kind": "isotropic", + "panel_seed": 2324830867988564616, + "realization": 55, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "4f97fddc1e40f204c3ab4795b63b0c0321b26b42e9647d7a6451fd86bc2b1a8e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.027191015384236555, + "kernel_residual": 9.97844655067301e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06358882536823156, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.924625504874044, + "minus_target_entropy": 0.9565925524430613, + "minus_weight": 4.069466157508311, + "orthogonality_relative_error": 3.2302255104239065e-16, + "plus_external_effective_rank": 12.803377769519587, + "plus_external_entropy": 0.8591709189586358, + "plus_target_effective_rank": 20.777126967362843, + "plus_target_entropy": 0.9566323089996597, + "plus_weight": 247.78047709417413, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "6f3a78cd72654284808929ea5e36f275dad42307b48acf48ba3ec02ceb564591", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.314427+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "422af7550e579b4c040cba3aaf20da66207ec689f0c038b23356c5eb9fb6a4b6", + "panel_kind": "sparse", + "panel_seed": 14962966328289050529, + "realization": 56, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "106582588ee3bc33fb15694ebf34b03d2aa85ef035484dd6727ea8a930eb310f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.034697468975178426, + "kernel_residual": 9.554888773646797e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0883568825774921, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.970543396602764, + "minus_target_entropy": 0.9636929993242136, + "minus_weight": 4.3905336378347375, + "orthogonality_relative_error": 2.1556687059313701e-16, + "plus_external_effective_rank": 13.221749370020813, + "plus_external_entropy": 0.8670869751047701, + "plus_target_effective_rank": 16.954031661791415, + "plus_target_entropy": 0.9076605795272183, + "plus_weight": 189.88104052552845, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "f3755655edc6fd6e6bd6ff191f9279146463e46d017bc0df4158cf65accab6ac", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.351020+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "422af7550e579b4c040cba3aaf20da66207ec689f0c038b23356c5eb9fb6a4b6", + "panel_kind": "isotropic", + "panel_seed": 14962966328289050529, + "realization": 56, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "0755725b2302b69a0a399ec8586fb31e392880898c8d72080d44f3ca50f8f362", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.034697468975178426, + "kernel_residual": 9.554888773646797e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06590200426588991, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.921398094579067, + "minus_target_entropy": 0.9588613251834956, + "minus_weight": 3.81230987394945, + "orthogonality_relative_error": 2.3427313014867256e-16, + "plus_external_effective_rank": 13.334997216079344, + "plus_external_entropy": 0.8683042027765103, + "plus_target_effective_rank": 21.160911510400265, + "plus_target_entropy": 0.9605094616381087, + "plus_weight": 223.70306285152054, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "3c55c89578adf706d23cf566d5baae1324b7d658766a2a85d71eafc141291c14", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.391962+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "8cdb3df5d1f2d0eda80f5f8cbac68dce2c1cbf3410d4663e53b3441773235de7", + "panel_kind": "sparse", + "panel_seed": 17926435067593881341, + "realization": 57, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "becfe16bfa57e92e4ab5c67c6ec9f2a7238f49c1354b04ba817dee4741dd664e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04285823177772459, + "kernel_residual": 9.294823039903429e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08679493131457917, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.727329378731199, + "minus_target_entropy": 0.9533070678961939, + "minus_weight": 3.9621455726702535, + "orthogonality_relative_error": 2.621104957456375e-16, + "plus_external_effective_rank": 14.385815035507465, + "plus_external_entropy": 0.8891778787502628, + "plus_target_effective_rank": 19.251830599161227, + "plus_target_entropy": 0.9411289249779938, + "plus_weight": 174.58380511911307, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "457433e32d364ebbc82018fb64b3c63a3ca085eb52f7bdf41cebde3ec32e2d76", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.429349+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "8cdb3df5d1f2d0eda80f5f8cbac68dce2c1cbf3410d4663e53b3441773235de7", + "panel_kind": "isotropic", + "panel_seed": 17926435067593881341, + "realization": 57, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "d6c157e3d070a79f2c904fec70c1fc3ef8b6bc469537ddecc325d33aacb86a34", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04285823177772459, + "kernel_residual": 9.294823039903429e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08190054070811141, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.091450746137314, + "minus_target_entropy": 0.968354624580777, + "minus_weight": 3.9035576059106867, + "orthogonality_relative_error": 2.608317207295391e-16, + "plus_external_effective_rank": 14.428907861967584, + "plus_external_entropy": 0.8891620198394689, + "plus_target_effective_rank": 21.94171097351204, + "plus_target_entropy": 0.967339812569048, + "plus_weight": 182.75819360981424, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "ce1f81b1786877df67a09e70e3eb07076ebe0cd03d17423c1ae3287fe3fd89c4", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.471557+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "965db5b6f61132dacf4b060ed3a9c69d8237b0826f03015320dc1d3c242603f1", + "panel_kind": "sparse", + "panel_seed": 14163288257799102656, + "realization": 58, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5b5cee8a7bf908a92380c5bba7a8a8bd6e6d0fb8acad1ae72c9349607d8e7b46", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03932241435288355, + "kernel_residual": 9.762347694878459e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08068606819903926, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.111807682491484, + "minus_target_entropy": 0.9692380536970092, + "minus_weight": 4.128261910632498, + "orthogonality_relative_error": 3.196523259929045e-16, + "plus_external_effective_rank": 13.973105839476924, + "plus_external_entropy": 0.877289968742924, + "plus_target_effective_rank": 20.699050671704207, + "plus_target_entropy": 0.9549450470637374, + "plus_weight": 196.31464266718007, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "a0945f8af515aa3c010e84125624f419edac570d55931c40b2a4f18d348f7686", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.508821+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "965db5b6f61132dacf4b060ed3a9c69d8237b0826f03015320dc1d3c242603f1", + "panel_kind": "isotropic", + "panel_seed": 14163288257799102656, + "realization": 58, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "30533fc318a2d973bb915caedef3e45ae41231c4fb8eb69013bdf9097c17489e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03932241435288355, + "kernel_residual": 9.762347694878459e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0751018797061872, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.914268857290263, + "minus_target_entropy": 0.9586025189218659, + "minus_weight": 3.9130383811029823, + "orthogonality_relative_error": 3.253051462973766e-16, + "plus_external_effective_rank": 14.798078816210662, + "plus_external_entropy": 0.8890758899163534, + "plus_target_effective_rank": 22.223634200163122, + "plus_target_entropy": 0.9686487420058987, + "plus_weight": 200.5098324659722, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "19c2e84d1f5c63c2d9b790c63e7ac05e5261ad851d1c59d4f449e6d2471c1daa", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.549795+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "dadfc99483813338a7bc9cc40d24c6029813476c77eb5729a5e9c222bd2aee90", + "panel_kind": "sparse", + "panel_seed": 14882293012189588689, + "realization": 59, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "9433e404d3402eaa84a61bd4f5fe96838ffcc629d8f21f265166e66e30f2ca5b", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03633728057950958, + "kernel_residual": 9.384097187666501e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07420736029433471, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.801273686422592, + "minus_target_entropy": 0.9546174826231777, + "minus_weight": 3.791637270831068, + "orthogonality_relative_error": 3.720459468676297e-16, + "plus_external_effective_rank": 13.501922438194901, + "plus_external_entropy": 0.8676859113263501, + "plus_target_effective_rank": 19.575808383546946, + "plus_target_entropy": 0.9415861049386685, + "plus_weight": 196.72430339407282, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "3661845b0e3d24c5cc38d654394cf4964ae56bb6e689408fb51258b1d56a9fa3", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.588000+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "dadfc99483813338a7bc9cc40d24c6029813476c77eb5729a5e9c222bd2aee90", + "panel_kind": "isotropic", + "panel_seed": 14882293012189588689, + "realization": 59, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "ae5cce6cc82a8404dca6de1e0b4bddfe0bdcef953d24619ad564f41cf65a5927", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.03633728057950958, + "kernel_residual": 9.384097187666501e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07777077302351904, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.014659150349764, + "minus_target_entropy": 0.9661782364697651, + "minus_weight": 3.98000482128359, + "orthogonality_relative_error": 4.133531517015045e-16, + "plus_external_effective_rank": 14.678869366270959, + "plus_external_entropy": 0.8903465905004365, + "plus_target_effective_rank": 22.20026392565734, + "plus_target_entropy": 0.9688485802961357, + "plus_weight": 196.66384274503685, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "855a4c2093c459388f5a5e7d5e4412adc308a1590bbc0f8b80867b2b03cca010", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.631030+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "cbe5c913d9e70deb70fb84e233db3af5b95b0652b5f2921fa30e164b85b1b485", + "panel_kind": "sparse", + "panel_seed": 9472426558819414799, + "realization": 60, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "5b205578731f01249fb19f7403473918c18bbc82c01946d2dd628df00aa2728f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02496383966418628, + "kernel_residual": 9.849216416805847e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05043125156083095, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.759954912363268, + "minus_target_entropy": 0.9552571890984698, + "minus_weight": 3.6569524995887575, + "orthogonality_relative_error": 3.186019692807103e-16, + "plus_external_effective_rank": 10.21790188020221, + "plus_external_entropy": 0.8184336713314004, + "plus_target_effective_rank": 17.636897492071885, + "plus_target_entropy": 0.9261126260867343, + "plus_weight": 282.69325934225503, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 27, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "2267c8e71f845e4610df0450cb7919602e8519cf4ac82f72ab086d756a28967f", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.667470+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "cbe5c913d9e70deb70fb84e233db3af5b95b0652b5f2921fa30e164b85b1b485", + "panel_kind": "isotropic", + "panel_seed": 9472426558819414799, + "realization": 60, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "72f737a7438d0738748622ec6e98bf0b548bfa0ff7c47f281d982edbf26a840f", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.02496383966418628, + "kernel_residual": 9.849216416805847e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.06613608547544156, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.807002917508126, + "minus_target_entropy": 0.9550565554216606, + "minus_weight": 3.9198232707067415, + "orthogonality_relative_error": 3.266281308850504e-16, + "plus_external_effective_rank": 12.587931845802677, + "plus_external_entropy": 0.8581254120300758, + "plus_target_effective_rank": 20.808462275035964, + "plus_target_entropy": 0.9581322524545088, + "plus_weight": 229.1695259418185, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "ea75512d93522597840aa5e219121ae3fcd991813a65a87a3bd713d6ad9ebf82", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.708456+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "04d690e398c7de094fb0a9434e832cb3fbe4c6a804013ec77a46818324d3379e", + "panel_kind": "sparse", + "panel_seed": 3094758090458480140, + "realization": 61, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "874d5a6a1d08f5e474d9ccba62ff9ba6023636434689e167f6c8ecc958a10779", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.035913647182111694, + "kernel_residual": 9.616809060997128e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08357325534487574, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.083307986446312, + "minus_target_entropy": 0.9675252762691392, + "minus_weight": 4.315456935301139, + "orthogonality_relative_error": 3.198297389273064e-16, + "plus_external_effective_rank": 12.864610974811116, + "plus_external_entropy": 0.8761544109986572, + "plus_target_effective_rank": 19.216868060653546, + "plus_target_entropy": 0.9386879210574219, + "plus_weight": 197.82221524944694, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 26, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "a900b266dbffb519944c0c95895dc1bc610bb8481afca2c76f58d131e92d1a51", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.745663+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "04d690e398c7de094fb0a9434e832cb3fbe4c6a804013ec77a46818324d3379e", + "panel_kind": "isotropic", + "panel_seed": 3094758090458480140, + "realization": 61, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "e66234a19de29af1c6865c491f2e8e4a4f9461f478ace085a210fefbf12da254", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.035913647182111694, + "kernel_residual": 9.616809060997128e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.07357704084689615, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.9976464124870486, + "minus_target_entropy": 0.9647877295720158, + "minus_weight": 3.8616320607578185, + "orthogonality_relative_error": 3.2639777034333933e-16, + "plus_external_effective_rank": 14.483578807160086, + "plus_external_entropy": 0.8884834967297529, + "plus_target_effective_rank": 21.851544799057816, + "plus_target_entropy": 0.9665146320973665, + "plus_weight": 202.13976052390188, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "fe62bc284714d4ea00643309f1abcceb2ebb5f33bd78e14894a5d6e2353006b9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.786947+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "b40529d7f84b2c02c164d20870da2d8726f73fdf0da0bb77f9117d80530b38a5", + "panel_kind": "sparse", + "panel_seed": 735977835594361410, + "realization": 62, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "02ded3f71ad4569dd77a1c1a35cb0756671982a0f89fb9de716490785083dd1e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.022077208473463072, + "kernel_residual": 1.0367532680892504e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.043524826173991386, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.433219881992342, + "minus_target_entropy": 0.9399772434478231, + "minus_weight": 3.4715031212252576, + "orthogonality_relative_error": 8.452663893953391e-16, + "plus_external_effective_rank": 10.689917459125642, + "plus_external_entropy": 0.815577894639894, + "plus_target_effective_rank": 19.46557206085253, + "plus_target_entropy": 0.9426670400442516, + "plus_weight": 312.0549728090864, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "4cc4cfae5457779920c0817d8171ab850c67fd793f8bbb4f6958e826790c00e9", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.822891+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "b40529d7f84b2c02c164d20870da2d8726f73fdf0da0bb77f9117d80530b38a5", + "panel_kind": "isotropic", + "panel_seed": 735977835594361410, + "realization": 62, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "eb456c8528ee78eadc08777e84e6c87ebf6465c8c02816c2126073d0040ab90e", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.022077208473463072, + "kernel_residual": 1.0367532680892504e-15 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.05659002334614523, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 6.962125961175115, + "minus_target_entropy": 0.9627457893588793, + "minus_weight": 3.8590918553173736, + "orthogonality_relative_error": 8.012751899262861e-16, + "plus_external_effective_rank": 12.130187475735942, + "plus_external_entropy": 0.852130349258116, + "plus_target_effective_rank": 21.07251266174129, + "plus_target_entropy": 0.9602255413244202, + "plus_weight": 265.0010386792851, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "1b931ff477a9b9007ce59c1adf0e70f2f040c4216f006aeb7db1ced8d4967810", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.862013+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d6118a63b4ff40122e549429fe4309e78ab0f83c176cefbd40caf026d31180bc", + "panel_kind": "sparse", + "panel_seed": 6462186101004937597, + "realization": 63, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "c55f02dff31d438e15bcc42d7d0e4a83cd41fa1a43aaa062d1f594843c4c4fa2", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04890236339354925, + "kernel_residual": 9.33350731896364e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.0819690860247444, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.106753923964923, + "minus_target_entropy": 0.9681438304909481, + "minus_weight": 3.9328971025299726, + "orthogonality_relative_error": 2.0618852898690301e-16, + "plus_external_effective_rank": 15.521735729149622, + "plus_external_entropy": 0.8948185932989486, + "plus_target_effective_rank": 20.8154052698482, + "plus_target_entropy": 0.9556998716025302, + "plus_weight": 183.97112242784186, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + }, + { + "arrays_sha256": "08e0b750805a23ed5eb2c49ab1cf49d1c814be1cf30fd4a188658871b4e8a538", + "checks": { + "branch_sum": true, + "direct_resolvent": true, + "finite_hodge_signature": true, + "finite_response": true, + "full_channel_support": true, + "hodge_orthogonality": true, + "no_outcome_leakage": true, + "safe_arrays_exclude_response_matrices": true, + "target_leakage": true + }, + "generated_utc": "2026-08-01T15:32:17.896882+00:00", + "identity": { + "N": 8, + "charge": 3, + "kernel_identity_hash": "d6118a63b4ff40122e549429fe4309e78ab0f83c176cefbd40caf026d31180bc", + "panel_kind": "isotropic", + "panel_seed": 6462186101004937597, + "realization": 63, + "sector": "adjacent", + "sources": { + "lgeth/hodge_response.py": "acb8bddff8319b17e1f260a9f049c52f00241da8414fff0b8f659400d2280c9e", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/susy_cohomology.py": "4b8c6d62f45a7de1a696fcba7228a575cf1745ab82968732ef3d6238bbf9672a", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe" + }, + "version": "v7" + }, + "identity_hash": "a9eda22596c26afd5490842ecb461280a0a5965355b660bebc5f3f387ee221bc", + "kernel": { + "bps_rank": 27, + "complement_rank": 29, + "gap": 0.04890236339354925, + "kernel_residual": 9.33350731896364e-16 + }, + "passed": true, + "signature": { + "channel_count": 8, + "hodge_balance": 0.08539437709596681, + "minus_external_effective_rank": 1.0, + "minus_external_entropy": 0.0, + "minus_target_effective_rank": 7.0123612782730085, + "minus_target_entropy": 0.9642593000958389, + "minus_weight": 4.003870184244082, + "orthogonality_relative_error": 2.11441376980676e-16, + "plus_external_effective_rank": 16.136944975389884, + "plus_external_entropy": 0.9066247278476562, + "plus_target_effective_rank": 22.440805030320337, + "plus_target_entropy": 0.9701903714063876, + "plus_weight": 179.45017749810555, + "target_rank": 27 + }, + "spectrum_lengths": { + "minus_channel_covariance": 64, + "minus_external_eigenvalues": 1, + "minus_target_eigenvalues": 27, + "plus_channel_covariance": 64, + "plus_external_eigenvalues": 28, + "plus_target_eigenvalues": 27 + } + } + ], + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot.json new file mode 100644 index 000000000..99865b2ba --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot.json @@ -0,0 +1,106 @@ +{ + "arrays_sha256": "1dd2ac57a58f35d51c94b7b1b145aba60a5054ccef3debbdc0aa353961349a02", + "cases": [ + { + "N": 8, + "collapsed_null_quantiles": [ + 0.2881793195620301, + 0.29243105649287354, + 0.2966028983154999 + ], + "hodge_null_quantiles": [ + 0.3065421612499292, + 0.3119337066430775, + 0.317444931738227 + ], + "median_hodge_balance": 0.07040982426906839, + "panel_kind": "isotropic", + "physical_quantiles": [ + 0.2993447558423871, + 0.3473456476442244, + 0.4322302561333196 + ], + "realizations": 64, + "sector": "adjacent" + }, + { + "N": 8, + "collapsed_null_quantiles": [ + 0.30675082164265327, + 0.3110016133852661, + 0.31641085299065735 + ], + "hodge_null_quantiles": [ + 0.3284194758414989, + 0.3346004660957313, + 0.34072193396722594 + ], + "median_hodge_balance": 0.07146412252958581, + "panel_kind": "sparse", + "physical_quantiles": [ + 0.3844510982929914, + 0.4214201895221874, + 0.4982959082592322 + ], + "realizations": 64, + "sector": "adjacent" + }, + { + "N": 8, + "collapsed_null_quantiles": [ + 0.20851992269328554, + 0.20985659397817102, + 0.21130151129640332 + ], + "hodge_null_quantiles": [ + 0.21950045494638384, + 0.22107646417990767, + 0.2227747317965349 + ], + "median_hodge_balance": 1.0, + "panel_kind": "isotropic", + "physical_quantiles": [ + 0.2041486515751545, + 0.2144978352258034, + 0.2252050450502445 + ], + "realizations": 64, + "sector": "central" + }, + { + "N": 8, + "collapsed_null_quantiles": [ + 0.2233835859189909, + 0.22530952276630742, + 0.22771245812229202 + ], + "hodge_null_quantiles": [ + 0.2422130093899726, + 0.24490167076808161, + 0.24753062987171096 + ], + "median_hodge_balance": 1.0, + "panel_kind": "sparse", + "physical_quantiles": [ + 0.2713435732191344, + 0.3588778773960463, + 0.4403876895074276 + ], + "realizations": 64, + "sector": "central" + } + ], + "checks": { + "complete_group_partition": true, + "finite_physical_and_nulls": true, + "null_sample_counts": true, + "safe_aggregate_preexists": true + }, + "generated_utc": "2026-08-01T15:36:10.725028+00:00", + "null_draws_per_realization": 128, + "null_samples": 2000, + "passed": true, + "safe_covariates_sha256": "e432c45725925bf44a128a2afdf8bb6a2d5da86ea53bfdcb45e0efc9ae4d9516", + "uncertainty_unit": "complete_disorder_realization", + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot.npz b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot.npz new file mode 100644 index 000000000..dde81792b Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot.npz differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_N10_banked.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_N10_banked.json new file mode 100644 index 000000000..029efa358 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_N10_banked.json @@ -0,0 +1,1091 @@ +{ + "arrays_sha256": "7134df6e67f92a02a81f715989a11a680877cdb5a7188056d1db2677f15bffb5", + "checks": { + "complete_requested_grid": true, + "finite_outputs": true, + "registered_bootstrap_replicates": true, + "registered_null_replicates": true, + "safe_covariates_preexist": true + }, + "generated_utc": "2026-08-01T16:08:42.050120+00:00", + "groups": [ + { + "N": 10, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.14697176523695696, + 0.14827234254140156, + 0.15000030229188152 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.14946543883393287, + 0.15121420848794176, + 0.15313133957932945 + ], + "median_hodge_balance": 0.13837041292214186, + "null_banks": [ + { + "arrays_sha256": "12b2aea8b0f25d4e37de54a2d8d7d2c4eab4a5721066207ae19f1480d3cce29e", + "metadata_sha256": "096385775c25a0eaa3a603e27cb8fd7ac40ece03b484beb6e00b12d3cbacf7d3", + "realization": 0 + }, + { + "arrays_sha256": "46f8aa51afa24cf2599da43c40b1867acbe3f789b59474dd54c4630574a10afb", + "metadata_sha256": "1821f05c1a7c6d57ee6764f7f4520455b91baea5ac8370f1919fff8435964d2f", + "realization": 1 + }, + { + "arrays_sha256": "35369ce2d8ed039f0d3c43a487a0cd8fad32756db09b3e57922a8f41f6cb6dc5", + "metadata_sha256": "0fc09bfecc1047f3b80bd0bfe5ee945418912653bcbf3357472961927c0cd2d1", + "realization": 2 + }, + { + "arrays_sha256": "21c2d40a659ba81b86721a70df0a7fccaf088add28eb68f7d5105678eb214d39", + "metadata_sha256": "36e2341865c3e6f7f2d4b93e57eacf2d9f22ae6f3402fe6dea7c1321659d6704", + "realization": 3 + }, + { + "arrays_sha256": "eb2ea0964a7946271b4c379ea54739ee1a7667b18027c3457a0aea317ade17b4", + "metadata_sha256": "27eb716e8664878422bbe1bea34354fb381ddd73d1d2f7bc2c5bf215169296b8", + "realization": 4 + }, + { + "arrays_sha256": "2f56598860334e79718b478f3e760fbc5498ccd52b9a9be8c6dbf12e0383de5b", + "metadata_sha256": "5f98739127ab1b8e3185ef3bb0c7bd3980cc767f518845713ab17fefe85d1e32", + "realization": 5 + }, + { + "arrays_sha256": "e0c4657781c703a93d9e18adb77043aa4ccfc10c647bcddf6a1e450a13ad40ec", + "metadata_sha256": "2a4529ad49e2a12f83adac46a550d5475678119bc984e2490fcf55d5f3732e53", + "realization": 6 + }, + { + "arrays_sha256": "a9208214fc80ff18c84db0e4f9f940ef484bb3c626ff78dd89c985fe051d5593", + "metadata_sha256": "15818f4a5e7578535140ed773bfe9e7657940c977b8405238ee6ad570e642f51", + "realization": 7 + }, + { + "arrays_sha256": "4655a42985cf1632a52b851bb70da181a9853a293546270b2835679a4455e4c5", + "metadata_sha256": "6909efd1dc3805aa49aec5e178f30ca82fc5a387784e10b30ab6733b0efe3e1a", + "realization": 8 + }, + { + "arrays_sha256": "6779e66eb68f4ba8104f14e5cb8df25bb8845da890063b10988d4e0db92efe1c", + "metadata_sha256": "a9c64b326dc93b79acb345e091e61ea5f5f634621a9c70ae9978c51b35baedb5", + "realization": 9 + }, + { + "arrays_sha256": "125a562cd836a4d7e5df7bebd2623c1d6ea9b1a351a3e4b200f76233bb03ff4b", + "metadata_sha256": "53b2a48dd9d44e76cf1dc64b140a89aadb6af05c5265456c45b770efe9e9130b", + "realization": 10 + }, + { + "arrays_sha256": "a9b8f1359bd4d4f579390d73ae60f19ea0ed84ba8c5bfe2d45e0a71c4937c54d", + "metadata_sha256": "b2eca6bf52b5fc3480a2699e421433e0bc1e6cc097402db9a23ae081942fb6a4", + "realization": 11 + }, + { + "arrays_sha256": "643a1f5e202504105ba23fd2885f3d57d1519733037a7bac0c014de5ccd30e33", + "metadata_sha256": "90d9af159dde8837be965e349cd0d43912456379d5b6c3e38d252d45f39ea072", + "realization": 12 + }, + { + "arrays_sha256": "73fd5f5fd3d4b517002edb8e2917611ac3e2813e0073744818654716b93ed467", + "metadata_sha256": "dee843cdb1e4ed715e375c408a2c9293692f98dbd17fb399d3654ad152f30fc1", + "realization": 13 + }, + { + "arrays_sha256": "3d353a7b7538336d4bdf3e417d0fbb635db61d18f469a796a53a9d924ebbf297", + "metadata_sha256": "235074e0e468591ba3c42143ebcdd7f7f812b2c38da0421c8983b1a890138f5a", + "realization": 14 + }, + { + "arrays_sha256": "84c1934f9942559ed2cf61ccab2a0d7e6682d207f307a8c6cbefb8a7265a2481", + "metadata_sha256": "becb88118dd130f5bdceb85177e0053d4bda7915d3e389f00b85bd33f552c12a", + "realization": 15 + }, + { + "arrays_sha256": "f1b0ed773d79f7627c346c502cedd57363b6d385b53439edc2d67b0f6fe2383e", + "metadata_sha256": "49c789a1cf1f9d325b20bdafddd3cdf388f425f5faf3ff518aece922b5cef0e2", + "realization": 16 + }, + { + "arrays_sha256": "9d66ca2b1a01bffbc965a800bba375fa78d6e5f375c7b578de70e02f6913df9c", + "metadata_sha256": "26e262c8f7330a88d4e90321b567d1f20b6088c5bee43651f429802086591a78", + "realization": 17 + }, + { + "arrays_sha256": "0b7a13297ff2de604fb35e78b6384d13884c1d2237df1438df2c2ee7582a05b4", + "metadata_sha256": "2d195514c0099cf9c60f963fd03bc41febb77b6ced96d6c7c1d1074bb0f50000", + "realization": 18 + }, + { + "arrays_sha256": "a50aa65e007d522b09c6fd88a06c5fafbf7f280346b93ff6c110aba26864d9fa", + "metadata_sha256": "f0540a55516c8f7357048cd8d056b6536e854af5acdaed34a57e83d0f2bba69f", + "realization": 19 + }, + { + "arrays_sha256": "3aea56f3a003fa536ff7544db6befa5293c5e9a33ad0fc38c4bad822bbf070e9", + "metadata_sha256": "d7b0ec3efdfe5deae363edf73dd578709c960ef012bb54e15f72a63863c67d07", + "realization": 20 + }, + { + "arrays_sha256": "7c63441cbe5176bde7cd5047779cf302c6ff1ee181e83d25f8e40326a8a60626", + "metadata_sha256": "cead2e8046c8a7d9acaf3963e7a36fcc1e137631a2570e8fbe387bce86f9da86", + "realization": 21 + }, + { + "arrays_sha256": "baff01a4bc494c022271ce839415f394934e2e168bb5f2242e02999dda80178a", + "metadata_sha256": "93e404a4d338456dc53915eb62900b48b9cf6bb84fd956d696aae6ccf82b9e91", + "realization": 22 + }, + { + "arrays_sha256": "1c8c864a57671e3696ee65b8139d551c6c20c89f67224fa5afaa7c4356a26129", + "metadata_sha256": "72d822e26e0acc8c7fcc36be1a878ac76106a829100957ed1021eb94146f6664", + "realization": 23 + }, + { + "arrays_sha256": "e73f5723452c5fdf7e6b5d083bf6ebdb3e313a1cc58306e3d0bc5024e4177bf7", + "metadata_sha256": "01e2110361d9282aa2c2cfe557f71d70ecdfd244c2f06baed9b8c4aff115e9e3", + "realization": 24 + }, + { + "arrays_sha256": "5994338ed1cbb199452ce037ba54633ec67d3d09c81f1fdb2832969e32f8eef8", + "metadata_sha256": "65285447d52e355e3a46c3f656ff7c954f01c4ffe021ed41dfeeb232a5a4b4c5", + "realization": 25 + }, + { + "arrays_sha256": "a01cd7dbc759687fb8081d8429f858c58ed1a13f7fbc3186fd6ac4f525f9fc45", + "metadata_sha256": "3c3c2f024c9508d008a93ea6f5018e676992f65c72aee9e3c75d4ea36f4f4c9a", + "realization": 26 + }, + { + "arrays_sha256": "8ac0174c32277478e1e0e49f713daf70933c78f1f7fa603a172428e8b752f7bd", + "metadata_sha256": "60e5b08074bade17c6db643599ae62c24e7b826a587392c73666ee11c7939585", + "realization": 27 + }, + { + "arrays_sha256": "33a54db642b75d74ebbd68033f821e80ab769bee32c034dde78839721dfaa0a3", + "metadata_sha256": "9e747bd372473e73784b6eddb6435effa68d62127977ca1d608701cef7603eb0", + "realization": 28 + }, + { + "arrays_sha256": "4cd17fd2a37474dc639544d7ba76d2b6aaf20e8beec166885e4f3379ae2eab9a", + "metadata_sha256": "298899d5aff126f7710415e5a5655b12f88aa84c2ba7e62f9726bc3dc6a56bfe", + "realization": 29 + }, + { + "arrays_sha256": "e1ac23ac06bbef305b635e0d7642d002daacf36fe3e23bf569971c1770bce06a", + "metadata_sha256": "6c58bce1fad03b486bfee9784757e351f84efd3ad435d552a58e194e9e3ba4e7", + "realization": 30 + }, + { + "arrays_sha256": "b48cc123dd7b5fe89424c0cbfac81904f57d65255aded8ead256b5bb3ef36d46", + "metadata_sha256": "2593d5a3cdae4a757977a2c8446a0f0059df3ce69bae0dc78a6072fcd1fa6cfa", + "realization": 31 + }, + { + "arrays_sha256": "dcd780bab03e7857cad3cb893ca35c7ec2989d5283396ab6d651ac887e78f71d", + "metadata_sha256": "602356df0e9730daf183a2df12b18e50803d6b7e139a1fc4379684c835cd4311", + "realization": 32 + }, + { + "arrays_sha256": "7c47c83c5e7fa702563caa395391cdd77cfa0a23eb27ed9f218a936c0e7b170e", + "metadata_sha256": "5382638aff28a7e32ce3758fd3363d90c4831a992dcae1bd8938b6a06584518d", + "realization": 33 + }, + { + "arrays_sha256": "297f960c6acd0c6c81f6c86ed9ba1f8a722d38ff02104a797100b1fdcbb98864", + "metadata_sha256": "b37e364d071123fa78f76035d7049ec267991ec86615b9521d084a4dcbb1ed21", + "realization": 34 + }, + { + "arrays_sha256": "eb43158636cb7c8f7c63ee53b48d901c482b2edc9ab0068bcfb5176376742357", + "metadata_sha256": "b182b4485873baacc32c8a40e02b691e4400b213954dfbc1a5edba2cebf383ab", + "realization": 35 + }, + { + "arrays_sha256": "573d56f236645e14b69be907fd1f25e95b416cbfe9495fa101544cd37ca181a5", + "metadata_sha256": "57450a3a5cfdaa4b5f4ed4d92c17c082922f23e557ad03b0bfe501b6242e800a", + "realization": 36 + }, + { + "arrays_sha256": "de7a464082ccb24cc5a9732e4ac6af7f07e75e0f5c1225ce09ad434216816c4f", + "metadata_sha256": "4b36f182676a476416eaab660e3e10fd5450f20e4db7b375e935a56fc3ba6b86", + "realization": 37 + }, + { + "arrays_sha256": "7790c42e0d60d1253b52372fe6534e78150d62e8e863193183b77dfdf071f492", + "metadata_sha256": "aa74167d2c442181a19226b63888ef47660a8344dbd6828abb38edca4c85c397", + "realization": 38 + }, + { + "arrays_sha256": "50194676cf04da95725523f000510e099ff84459a9fb425fc674eeff997c1be2", + "metadata_sha256": "a9befda5e75d86a9530a96c1919656a72edface805ccfe06be00b84132c78cb6", + "realization": 39 + }, + { + "arrays_sha256": "dba4a33e5d8b98c3152b608a887bd662a6506efab93af68ca3b14d9f4daa1dab", + "metadata_sha256": "321c767d66e8690c733002e0b9ed6c6e0065fe93c4940137d38033b559608f21", + "realization": 40 + }, + { + "arrays_sha256": "b9dfbe2b3b469f9a9342dc463daeacdb8159c00faef6468b60345b90ce25c195", + "metadata_sha256": "a694ab12cf08d0e90d8b1b7500ffe84d4095a2bdbff8ce04cfe0d199f206f9f3", + "realization": 41 + }, + { + "arrays_sha256": "46a72d1f3510973b530e41c4185a2cc175fd7d77e8d212d04c998739084e62a6", + "metadata_sha256": "9ac2b100796565d2a18723a238d97d35967d95c97da67b1dd4bf15c9b99648a7", + "realization": 42 + }, + { + "arrays_sha256": "998435fc797756740e9c356514ab57421def6afa44cad1602434aca00e0af02b", + "metadata_sha256": "e934eda31f8536240aeb2a8a9f63b3ebdd340b81c3b22db26fa378695abe293f", + "realization": 43 + }, + { + "arrays_sha256": "4c02b0338af7f0737b94a983dee910f57a18e3ad21dd2e914e66aaa8486559e5", + "metadata_sha256": "69cf288c57dc179287144e7f9085ce5a4cb199c39fcbc3730674f7d214591f4f", + "realization": 44 + }, + { + "arrays_sha256": "d42b6fb27daef5ce654f9bcbbbf9fe9caf8a79152300f7d742ae84d992e676a1", + "metadata_sha256": "9d9dffab2d3a1a67bef4be9e9c67dc12078e9dd0103c1ea8b30a341a00fce9cb", + "realization": 45 + }, + { + "arrays_sha256": "189ecdd332b5e2b886d2700e61a5621d5dcaee5790e2dfeaecdd6b627eada25e", + "metadata_sha256": "d5a3ce2064579f826c627f8db5463179013eb8867720a9eda5324598a30dbc38", + "realization": 46 + }, + { + "arrays_sha256": "09ecc6dce5f394701cc3b7db5846bcd7b35242987eb14aea390cd0ab6a6c3c28", + "metadata_sha256": "22057d2289101a80946968abe9d3ef2965f352e3a4bc4eb8ffeaaaf32bd2a426", + "realization": 47 + } + ], + "observed_median": 0.20073119910082154, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.19694060198755714, + 0.2082583902883576 + ], + "realizations": 48, + "sector": "adjacent" + }, + { + "N": 10, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.15280228203687626, + 0.15413349564490572, + 0.15571959826527199 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.15816799904416937, + 0.15990057317658485, + 0.16185676188209575 + ], + "median_hodge_balance": 0.14001760189653722, + "null_banks": [ + { + "arrays_sha256": "9284b0988e141ae56c0026e6ce6eacbefd7ffb819b35c41b1ace35e41c0f7f6e", + "metadata_sha256": "01b84ef06849f03e7dd25bf0ade77ff412d37ee4fdddddd85e2ed9b5aedd1c2b", + "realization": 0 + }, + { + "arrays_sha256": "a01168139ad924c7fc9a3ffd576bb2d96112baccc77661db17a0d27e9c6900c5", + "metadata_sha256": "c7ebf0eb554286b929f1505ba3eac087d89c5956660cf07449c310534c0ab4d7", + "realization": 1 + }, + { + "arrays_sha256": "658d113bc8e2bbb899076269de7c799258fe24d3e66d133bea080c6fc18ea630", + "metadata_sha256": "296402f3f52312ff3c3dad2b9af8c548d72171ab8bb15fb638218e38356fc370", + "realization": 2 + }, + { + "arrays_sha256": "5077f1c54c410375e423304a662cc3fa271dd08d1816f88167ae97764056e729", + "metadata_sha256": "b9d7a99db92f769e01466f196ccfa48b1626aa7799e0a621cd1d8642df3bb2a1", + "realization": 3 + }, + { + "arrays_sha256": "5929350d2b8f6ea0cd44dd0ab7faef26a2969c9940448254d2d14243f5c2125f", + "metadata_sha256": "4d4e2bb8aa8502b1dc381702ad4cc9886b7d06669babfd3c7d18fbc12118a278", + "realization": 4 + }, + { + "arrays_sha256": "c902f47c3f8042f3775a0678cbfd3af42f9e6003e5e99b8d13a611faaa456447", + "metadata_sha256": "749a3feba16ba6331fdeceaaaac6260d26b623dae9a5bc2d356281afe626d1e5", + "realization": 5 + }, + { + "arrays_sha256": "035e11dcdbfbdd8cc93c812d36633f43e84a0ceffb8c50ff7f3d9c4b9d1e5383", + "metadata_sha256": "de60a45c4c800a18fe524f3efee7ac5c3e353d0f8f403427de7c2ce754a7b2d1", + "realization": 6 + }, + { + "arrays_sha256": "04426533bee5b502955ca337218ed5945da95d41db81fa37a10d880ad0638b9d", + "metadata_sha256": "294d142e6b88328a0c02283477e034cc87dc146e05b2ac022078b70918ccd0c6", + "realization": 7 + }, + { + "arrays_sha256": "f52a0e1dd1840a51d4b9b66d868b468375738af500b11bf9f2b78ad1ec4bd9f9", + "metadata_sha256": "5195af065e67b5f4d9697ad4a89356fe1dabce2920d40819d0f8c172437f8a24", + "realization": 8 + }, + { + "arrays_sha256": "e37416e0afc53e319ab094692423c64702515de576610439f440b13985a27c0a", + "metadata_sha256": "0f904de501c6d61338ed2a4e125c72029dbe23fcf140c90e49a7fe0199a7739d", + "realization": 9 + }, + { + "arrays_sha256": "7bed9b3267715f633a1cd739a63f7db710732236581378bc8c7e5dee0c0223e0", + "metadata_sha256": "52fba6e27c671a5e2962c8c868de81bafce9add722c1097db7dbf8c922febcf7", + "realization": 10 + }, + { + "arrays_sha256": "607e69bea29a108b0ee850c1b22d53e1ee6a3f6a20856e2020babd6f755bd576", + "metadata_sha256": "10e5cabc68d1a1d1f684a8e15d19c048ceaa9a1c3f0394d1616c7fbdefc1acd0", + "realization": 11 + }, + { + "arrays_sha256": "c90bf2f85926ae5fd48ca48a7d5787f534ea1085d065b58cc939ec0b1cc4d5bd", + "metadata_sha256": "48f0f3f167281aab5fb56209e57a3a60c1ab8e651407166e5c7f25bc2618e0ae", + "realization": 12 + }, + { + "arrays_sha256": "cdda9d36d01cc1ff0dd7e9a044cf207b734543bbe715358653baa4e2b8a71e75", + "metadata_sha256": "6abf55a0b06e14b6cd882757a76a4b1261993b49c2a231ca3ceaecb91477ed8c", + "realization": 13 + }, + { + "arrays_sha256": "8f6b685360a1bab4bfc4866803a5f7fd6de701fa300589bee517133d7437fda6", + "metadata_sha256": "cf6322789dd38a3ac11f8d6c428606aaffb97d279659f40d7ae84b5f40042ea5", + "realization": 14 + }, + { + "arrays_sha256": "49c25d7c03ad18b07d4e8366e72d17406eb92a6498cd107e32bac7d1026a1dbc", + "metadata_sha256": "5c4acb3040ae5931242e53076f34e8aa9e7d5da2d7e6223e70c0dfb6c4e2bd9e", + "realization": 15 + }, + { + "arrays_sha256": "c962154657743aefab10f9faf2cff2439b94fc719e9bab63cc7da5e8a85902ef", + "metadata_sha256": "54604647a600a266a8f8cb8ff0f9c3406701211235e596041e4aa574ab4190e6", + "realization": 16 + }, + { + "arrays_sha256": "9e20c99cbd03ccc3da32e5378c364e10e7edec86a4ea840ac72c19331cc66448", + "metadata_sha256": "43d578481b58774f81e3dd08b0dd9c6f8edd7f1c84dd14fd4d0f3dd97513d9bd", + "realization": 17 + }, + { + "arrays_sha256": "0feb5c975d261997277ed835d26bca8051c1a45f11bade2cf1409fcd7ad6f0de", + "metadata_sha256": "8acdbb6edd84569a809269b4a0eecf082cce1f74e638706a3a828cf7978e244e", + "realization": 18 + }, + { + "arrays_sha256": "818362eb96103350295ec264bef0d1a9547ef189d55b07179314e850bd9b68f0", + "metadata_sha256": "ed9089926a588ad54f459aa50ce2e328b010d065ff4ee7e5f8bfede56a863aa2", + "realization": 19 + }, + { + "arrays_sha256": "90592b7e8fa4af46e9fcb117a5fa7265bcead6a481322a76bc94dd94c1732e08", + "metadata_sha256": "ab72fa4a80d5eb28b43979883887761649bc08a105e3fed64e4c8539d619aa86", + "realization": 20 + }, + { + "arrays_sha256": "3f1f9324f167d052f4289e7e5ddcf33f65d7c39b11618f312e147231aaec867d", + "metadata_sha256": "9cc5e663816defedd1eb59387048caee601a5fc8406f7f8a27f0d1f967fada47", + "realization": 21 + }, + { + "arrays_sha256": "f63b537796ff5d845243aebad44802c3381b086e136eeb91eef38007826c916c", + "metadata_sha256": "3677817b98650cd8087d33a4cf9e6d33a0f58360ddc297b5919ac11bc88dd3c1", + "realization": 22 + }, + { + "arrays_sha256": "700414986e6d4f26d021911ad70ea4a67843e71664780f59d74d7d4c7fb66a55", + "metadata_sha256": "07070d6beb67c0c657e7c53ac975534e94a3077b311ad4cae3f15e9810486198", + "realization": 23 + }, + { + "arrays_sha256": "2101284eb1e9d396974baa01bd416e5e36b119168155c0b59e36dc3d5674c6f5", + "metadata_sha256": "a373793fb6734c03cb792bccfdcf15e2d66137bc8be04114603f5cd62ead705e", + "realization": 24 + }, + { + "arrays_sha256": "0989fd6202ce8f9d0dabae7fb6a0e9ae64e525eea6e918b75d28758995fc24b0", + "metadata_sha256": "696e4f615e611d90bf58c7b2d1f0777f41dc6f723b36608b5d5bd20f09537bac", + "realization": 25 + }, + { + "arrays_sha256": "049ed873cd174af091791aee7484e33ba91e647eb7dec835181021e6d4be8b89", + "metadata_sha256": "7461d273c379665c3073d0a42b54a2d55a4d280cc6999c181324dce3aaccf3e6", + "realization": 26 + }, + { + "arrays_sha256": "858274e0c651a71986a394fd336dfe4719cd051eccc8fd3c423afc2602e61423", + "metadata_sha256": "2e2871109167deed5011dd915b96135a1f7ff5d1ded0b76092228fe85c2a184a", + "realization": 27 + }, + { + "arrays_sha256": "079bdfe07d0d8231b875e7f44180d09b66c4614a7fd265af91c24a906ec8b9b8", + "metadata_sha256": "c003a6854f0b9f4c0f6865e63e9a24c77df96928d8e5605466881fde92c66f6f", + "realization": 28 + }, + { + "arrays_sha256": "eb6b1211b970e9f20486b1b89e8a7be00b8b34cca7e526610c103b0dd60a96c4", + "metadata_sha256": "b426dab9aebdeb2327c61b29ee3a0453fe4e2b28af5041d5fed2bd9c85838c32", + "realization": 29 + }, + { + "arrays_sha256": "5c0463d69525bbfe1477475715aeccc940d2b5a4b3c6b4aa6e42cc6ae7e3a51d", + "metadata_sha256": "152c947701d398229f057ecf8e43dd1e002a035f97599a14e361d88adac4b371", + "realization": 30 + }, + { + "arrays_sha256": "6daedbda474fc23d7bfa0e1919c439ee45c58dda62827e79b2cc79a6bd2ec974", + "metadata_sha256": "aab528d9c184ffcbd8081fc3e6ad7cb81912d104e918b0b7ea69f2c539f44b29", + "realization": 31 + }, + { + "arrays_sha256": "e10d99e2d6db4fc6925d16bcd2a0daf60ac308ec9dacdc982bec0c02be55ba3d", + "metadata_sha256": "e4c056f6bdc271e01ca95a47706a32f1ae148d120bd95004bba31dc16922ecb8", + "realization": 32 + }, + { + "arrays_sha256": "4d568cf6af94de66c10f34e3fc2e6d140ef9654d791ca7fa3461f5f065b80c64", + "metadata_sha256": "48ae8699d8da1de246622fb23cb1477a01cbbf39e04fc218d5952a0e9829e901", + "realization": 33 + }, + { + "arrays_sha256": "178af73ce22f57312650c04c92f9709938bad45a5ada2c9070a3adf24c56ae52", + "metadata_sha256": "ce51eaa85723eb5dad748757e8a7eccd69132141407e78a0ca0e20b03cd90ae7", + "realization": 34 + }, + { + "arrays_sha256": "0fee466b906b2527352e900b7d0440e130e674c72d9013e14549c15a89d93450", + "metadata_sha256": "e07d1cf107aa6e20bd135edb834c78de6ccf1110b588a5f72a423e6a66d47afa", + "realization": 35 + }, + { + "arrays_sha256": "8b891db7614e7de597b408500e86d58c6510139ae270a54ee2634da5f6eb5732", + "metadata_sha256": "8fa56343dd6dcef976534166a9a6351e365a8c983e8570c014372761cd6ab5da", + "realization": 36 + }, + { + "arrays_sha256": "46ec153442ecdbeb89ed7569ab3bcb6ab896e5b8f31be5a881b011a7cf5e4cae", + "metadata_sha256": "3f7b72641781c099b16498c62362f84fea37fa9a7cc7ade54e6ca60501cf0667", + "realization": 37 + }, + { + "arrays_sha256": "40567e7e2644fe53ba0942c4a36f6320444767f932c3c032644d455605e3c703", + "metadata_sha256": "fcb4bb80a664c323dc49bd525d810ec7c25212933aa3731638efa4e6c3ac9710", + "realization": 38 + }, + { + "arrays_sha256": "1fdcc452e4d83c1dd47505fec52dd70aac613661ccd4e8dd53621ec5eff5d0be", + "metadata_sha256": "1185a5d5673dabfa92bfcf44bd41fa685aea9f34ac827e9d0aac6575be6124ea", + "realization": 39 + }, + { + "arrays_sha256": "23cedf88e7d817442583d36f62ab42928b5987bd435e64eae49ce7aaaeaae2ba", + "metadata_sha256": "ef9cb09abc726166efaf8d7cf4f175c5a5dad10ea260b800b8ee080fe426ec29", + "realization": 40 + }, + { + "arrays_sha256": "4bed72f2e140b59acaf13cff58c06edf0591278a84d0fab475d4c340e14b104c", + "metadata_sha256": "2b7d00e86392808900d473163590ce0183efe75e0bb4dd91873005a729473253", + "realization": 41 + }, + { + "arrays_sha256": "6d9ebad14f6b3a70a1348ecbd83c75249d8203ef54b0eeac64b66e353104958e", + "metadata_sha256": "28fb4135a013b7c93e0dcf14e1c9fc405d1a38b5f7936a1075690fd59e44fb51", + "realization": 42 + }, + { + "arrays_sha256": "d12b9fe842d164e1e3101431b94ad88f8c68a3f07f56a3a13490f74db467bb9d", + "metadata_sha256": "37856a4f2af8f7b4b44f644f881ec6f0e81f574addb0563f0005d4dd0ad788bc", + "realization": 43 + }, + { + "arrays_sha256": "23920433bec92791aa605dd22008504727bfdce1913220b6ae4461649a022967", + "metadata_sha256": "86b04efb41dcbb82b2789fe63d3d147acc936e156f25917a4ae788b5fc5d528c", + "realization": 44 + }, + { + "arrays_sha256": "3bbfa7124542fd0bb3d6215df3dbea093e904797c203ec153fc143c38724ea16", + "metadata_sha256": "7f64057f0f5e27334b4d76276dd4016957d912a4ad0e45f6ad6c50b71f93e07d", + "realization": 45 + }, + { + "arrays_sha256": "09b0bc3b06a04f12a8f67fb8eb4afd2ae98e4ebab403205ec913b03aa230f480", + "metadata_sha256": "053e10c4e695dabff57de936a06090fc06a846dc4e6951a7b74cb64fb00e8799", + "realization": 46 + }, + { + "arrays_sha256": "5e9dbdd6e6cdd0d004befd8d761e1ea006cb6d52e43eee453913e1240c9bdeca", + "metadata_sha256": "337c99f8f2ee3597085605255e4c9a2fd5493b988b16819d5bfe8ac332a0b614", + "realization": 47 + } + ], + "observed_median": 0.3326829386707436, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3277302349036726, + 0.3365367304550048 + ], + "realizations": 48, + "sector": "adjacent" + }, + { + "N": 10, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.12354756576977215, + 0.12380059338068258, + 0.12405028033654811 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.12469691271184806, + 0.12496969707954547, + 0.12524599110490295 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "e374e8a2465a8ff0971bfcbc083a0e0b76f35299864d606abd0aa9d0ec3fecc5", + "metadata_sha256": "bb886102b81857a37cd6452c9f15eccae77638db27aa1cbad6550316a8b4fec2", + "realization": 0 + }, + { + "arrays_sha256": "eaba9a3efe1db6e0d0a4161cd6934427f172d8b422e9ee5c625f048f8326fe64", + "metadata_sha256": "3a2ee0389be1e8700b8990435c8c7fcdf8467a5706755ccee810aee1c9de85ed", + "realization": 1 + }, + { + "arrays_sha256": "6780c8f83e0eaaac3d588e847cd4fab6ded83fb0c871714cc6630fce1be31c18", + "metadata_sha256": "9b7b1124c8663f220639155e5f36301614b4f1857200fa86039879a76b10202f", + "realization": 2 + }, + { + "arrays_sha256": "58371ece7bb623d456192257b6ff64d928d23ed5401939be394210d1f775452f", + "metadata_sha256": "27b22b34f5a870f10042de975a200bb0b2e5e4372e99a15d17511948fccadec0", + "realization": 3 + }, + { + "arrays_sha256": "396f64ea281b2fb856d9a5237b9acf332a6ffae6a750f181df27e0fd3f56dbe9", + "metadata_sha256": "f3a49baea40391394f249070b2875c4a5701ca68b5b83527686c362d121fc45d", + "realization": 4 + }, + { + "arrays_sha256": "48cd57eecc72be0537f9b7be14ee306b28729e2a8a1f5fbd0d79957405650eed", + "metadata_sha256": "39778696c9f6bbf34c7e45d8134ebd90eaaa99e56d81b84bd8422c4af7a97d57", + "realization": 5 + }, + { + "arrays_sha256": "8a033441ca6b320af8319b70c25731a2b2c729091a734323faef8396fe886e1e", + "metadata_sha256": "762c5f846837dc9a50b8bd6ce978179c23626f78b52ad7665eb2754964f075aa", + "realization": 6 + }, + { + "arrays_sha256": "afbb53e999493fad74e3c698a6f04bd21b06c3da9d43bf372b7213d191c7c67d", + "metadata_sha256": "1844b88e7d30a3abe21c8e0eeeeb6889beb148b6dc2ce91defe756353b6351db", + "realization": 7 + }, + { + "arrays_sha256": "9d3f0988f65a5f85349cd27707e4ef6c3f630b19e4be3f67ef28e4009d50e8d9", + "metadata_sha256": "e98d06856ef6eec0d7d3c56bf9bd9bb07d14a80c4206f743283b1940e847e5cc", + "realization": 8 + }, + { + "arrays_sha256": "778fb26f430cab935d6a13d35d6758c5e3f005f8116942b6f8498dad2743a979", + "metadata_sha256": "c0c8450313a916287b689c036e07ac2276383f488b51bce5d64638dfec5ec514", + "realization": 9 + }, + { + "arrays_sha256": "250e1b91c4c6a52348c930d503f45970801ec8bad0d2baa59277137834d0344f", + "metadata_sha256": "cf3ceec74aa9feb31dc352f79588d1341c90bfd2cb7e0425794e0169206a25f7", + "realization": 10 + }, + { + "arrays_sha256": "b23bcb928cd09156e6c53d5e940a914fc41cf2324c1f60e64b9753fcd2558d24", + "metadata_sha256": "4f83281cd78b619d2d2f3c6b003a28f72fa587cb6399e18ee33fab7aa9fee2c2", + "realization": 11 + }, + { + "arrays_sha256": "9e19c2403c197ba3d19b6d8535846d3af0d3e6eceb0c6e0222f7aee429d1aed3", + "metadata_sha256": "f90a4cd6190d3aacecfa4f14b95944a6c37797bed1c5a5a60f3df0f64c786b5e", + "realization": 12 + }, + { + "arrays_sha256": "14dc37e540fccfeaeac4c2937cc97aefa139a9343c92478853766047b6f80c8c", + "metadata_sha256": "914098114a1f6bf6519db2093f7714b2ff18e91a69672630f62553d504e5dacc", + "realization": 13 + }, + { + "arrays_sha256": "3a5e6262da3c7543d61c82f6ec01824746bb650bcb373d642226fe75cd8e0e7c", + "metadata_sha256": "eca5dc3575173b540305de3fbb2515d344ebc9f66a6349398a7c86a7de8f2e46", + "realization": 14 + }, + { + "arrays_sha256": "1cbeefe4f3e98e71baec74ae793c910b34a84651f3ec0b888be4a38e9edce29d", + "metadata_sha256": "53f945951e3645a7e1825d31129fbaf1e5c922737277f7f025e0036b0dccc8a2", + "realization": 15 + }, + { + "arrays_sha256": "312c29c4c288ed3c10202de685dbeaea53a8a5af6454353ebf1eefe005d68fdb", + "metadata_sha256": "8ddafc6922d0f286f006b447e65a315d5b2a11c9cbae7d383bedd8ffe2579e29", + "realization": 16 + }, + { + "arrays_sha256": "ff1168237887749e564d1c1c4d824e334bb8b064f856e795b130418575ba2f38", + "metadata_sha256": "22c2b2396f085e89b802987872d10a87ef3e73517193c993eab025c15fedd998", + "realization": 17 + }, + { + "arrays_sha256": "74bc5811f2e04ad11e8d96f9e6c2a4319920479fe194232821d67ac62b785e8e", + "metadata_sha256": "065204689624be34c89cf390b45912efd1ece4de39339fdd81852c1f819b2875", + "realization": 18 + }, + { + "arrays_sha256": "3bb10d1c8becd00726dc0f72c2c1ae212aee5f0439f0cef8a188fa096bd3f4ed", + "metadata_sha256": "34e88643883a522771adbc853d857c958bf27837cb952c55d01b70d07ef10040", + "realization": 19 + }, + { + "arrays_sha256": "51f28a66f9ad9df092bb987e7a97b6c110c1319a41e9ea2c617aef7ea1027cd5", + "metadata_sha256": "5faddffe805980894ed92d3b23ba9678fed329ac14154c390faa6d534f1548ce", + "realization": 20 + }, + { + "arrays_sha256": "bcc77dfc9e93cea79930fb88056a7c0106744fff4d0e06e814555c83d58c4de7", + "metadata_sha256": "a9c3aaa98ecf5bdd8bd4ab8e7d226b10c087a9e056a9edcaf7953118f648d0a6", + "realization": 21 + }, + { + "arrays_sha256": "ffe8c6959e54860c70bd939c592316f3517cd1243412df64f1181078b8ca3c76", + "metadata_sha256": "60adc1f14ac0b418a037bbb96a24f818c7e635056cd374b1d6b8fe6ddeb6ff08", + "realization": 22 + }, + { + "arrays_sha256": "c9544bd44b9103d9cc01153a31747317f52674997b156c8adda63017eb1f57d6", + "metadata_sha256": "7fbe5c7a8622cc86c8ec043217d0e2be9a3a56a5b93eafddf951ea49b4cf8719", + "realization": 23 + }, + { + "arrays_sha256": "a025c6197225c1d5d5175de6e005e5baae1699b06c43989d3fefcfb863abc6ec", + "metadata_sha256": "40c7cfdd5e431c14935eaf3e0e2af39249a2448a9ac3c7328584fb4c099a10b6", + "realization": 24 + }, + { + "arrays_sha256": "5265ae4b5e9e24e6e8376ca10e056f454375548e162d5f6175f6bd0ae69137c3", + "metadata_sha256": "138cd48bd79f156f2b02fae3e5aba74788195487810b0a64448f17ffc7b5c271", + "realization": 25 + }, + { + "arrays_sha256": "2e128e809b610e9fe0556061ca92df05fbf5af78cc4a22552a74366fd28768ac", + "metadata_sha256": "c80860c3db0e5c9af4f91a99f34f692f0dc607b60741325caea295924e8561e7", + "realization": 26 + }, + { + "arrays_sha256": "6ea77a0ff7d413aa4fbf26d920a27bb5cc8e49613584c8f1e3fb160005df72a3", + "metadata_sha256": "ce7878fd47ccf3a5d80f66e3e494472cf3469a5ecc8b6e40d8cd967d94dffe95", + "realization": 27 + }, + { + "arrays_sha256": "32418286a65666117d98720a86a8f9013251306dc797ec4477f0d87898b255ee", + "metadata_sha256": "878ada5a52c2aac8323c4494afb2e228e127f262ae14bc273bb97c5c0a12622a", + "realization": 28 + }, + { + "arrays_sha256": "ac8b92464cec21c1d1114791662a5391a77dc76472174ed7f6724d38138fe1c6", + "metadata_sha256": "35e3259c604818000290ccca6748cd4439200e9de8beceaee4a88da56408f9f8", + "realization": 29 + }, + { + "arrays_sha256": "12670943bd38c8bb3b2713c1277b56b81b4b446888774df319510e0f7eb53cdd", + "metadata_sha256": "793b528b771502d4870a261e84c577ad40bd5b2d2976defaf3100b9991083dbd", + "realization": 30 + }, + { + "arrays_sha256": "55960c3bb024ec551437e03cd27e69583784bf2d2e3e2dfd45df5d3bde584d0d", + "metadata_sha256": "fe896a8f67a2c9b010a835cb1b841d783c561eedc916f3b298ae2fb817dd5fa0", + "realization": 31 + }, + { + "arrays_sha256": "c58f82bc7c9f0f013deddffe9a4e97e0c9c0c8c8a2360d4eb3906324eb3405a6", + "metadata_sha256": "c26ab338b7cc894cbb84e05fc277afe838f4283a747209f8a2796006e4ad4335", + "realization": 32 + }, + { + "arrays_sha256": "5bfa17ed40d66293267c04ae2b566add94c00b46e0bce35ff5e68943de0cdd99", + "metadata_sha256": "3cbfe9e7fcd592d8185ef198882629662a2bf05c1ffce62d2cd0517b2324ed0c", + "realization": 33 + }, + { + "arrays_sha256": "76b172330e9341e4a48a5db47738e61d4b8f0b0e31926e1fd892cd0edc744e02", + "metadata_sha256": "a5bf0b90b79a5e38b68462e71b5f5aae5c41d9bf720d85ec7d61c5dca9697b00", + "realization": 34 + }, + { + "arrays_sha256": "98880f7f9a07c61b87fea38ae14d16de6c6409f528025ead4797ce7f523e1faa", + "metadata_sha256": "085ed88c153c478648f370ea158faa5c0570a0532407d830bde23f7ac6f6e1ef", + "realization": 35 + }, + { + "arrays_sha256": "2ce91cc906c21847d5bb14efa4d8b96dd1c8eed5edba64301db20e2396960b02", + "metadata_sha256": "5fb0b6d81c87ff320839a8f4a164ca269ecbb26275c6c6fc0a9faa1758d01235", + "realization": 36 + }, + { + "arrays_sha256": "a3891c1985bf14574a0a6c7cc4453bcb0f1c758e7bb4f53313a113524bbf087f", + "metadata_sha256": "eaad75ab2b69839c7c1a3490dda86cab1e78edd8786bb696ba01fb72060f95b0", + "realization": 37 + }, + { + "arrays_sha256": "9bacbc48e6b1873c7fa8cf1c4ca7fb9bb3b2c1b7ca0691ace64ab093cde20666", + "metadata_sha256": "031a1e0bbf2f80c81224e1ae001de3a970228c60fd6f887ae19809b1fe59bf90", + "realization": 38 + }, + { + "arrays_sha256": "e8160da407915bcf201080004cce8f1339fd0c4b5a6e5416de849983388021aa", + "metadata_sha256": "598841639bf4cc92cc20067a55b3d7d6d02835676f5f1031212416065f64f6aa", + "realization": 39 + }, + { + "arrays_sha256": "6ada7e0ccdbe1b1b58825ce6e5b938b9ef43a893b3d14f0e9e7bcec2dd8258fc", + "metadata_sha256": "250345c90a0039abf1ae28d6ff9597cfc0bc6415c849fa70c6e976b2f6bc78dc", + "realization": 40 + }, + { + "arrays_sha256": "a28a23913180bfe39a0bd3b7b3f15e2b9580ccb0c4ba2c0a92954d477f322c00", + "metadata_sha256": "2e2a90bf9122ffae79d5265917233e9ecf6d9bb528ce555c8bd938e7a0052f97", + "realization": 41 + }, + { + "arrays_sha256": "86f40423a2040dcfb1efb28bd13e9b1bb15d3cb701844ba4e0e204ef0dc17c40", + "metadata_sha256": "933b4d31ef2678ab5bd115dac8cb08b3f5eac769410bd93faa6b0e74059d48c2", + "realization": 42 + }, + { + "arrays_sha256": "d18ea3ce9aecc5007f983d539196105ae72b262c632f40057829decd6ccec0f0", + "metadata_sha256": "055f3c606758b5eb37a8b2fc327a04406ad37b1103717f1c17c5761c1ce68696", + "realization": 43 + }, + { + "arrays_sha256": "1c17df8e6d4af3ef7e01025473ae14bb7f892edcf10c88355b33fd92c3be679b", + "metadata_sha256": "7a3fc77882896c9f926def21fb9548cb58e8992fca5ccf8d2eb73420c00fa5fd", + "realization": 44 + }, + { + "arrays_sha256": "b74faa75df7585ccd3211d2de3ffb4f309e3a2dfcfbfcaceda2da6dcbe9b0468", + "metadata_sha256": "83e9669bad211f3a217487ad0a8d7f15079e41d1b9bea359febd9bddc62f2a46", + "realization": 45 + }, + { + "arrays_sha256": "4c7b2ecfdecaa715c1d5781462c6fc05937ef0a229ee3d15ccf6d5014b466d95", + "metadata_sha256": "d8012490610fe667c0d9c5dc1273577400f80855596cdb01f5ca83ff53277328", + "realization": 46 + }, + { + "arrays_sha256": "73672df8b422e7a80f34e2faba193f95b1f9bef08efb5020aadab7de50ab9048", + "metadata_sha256": "2b4910be086f22647812de67a919a90669697eb2ec8a622fefaa2debb677d08e", + "realization": 47 + } + ], + "observed_median": 0.18385937035136762, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.18307874781812727, + 0.18436442290778826 + ], + "realizations": 48, + "sector": "central" + }, + { + "N": 10, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.12719097687925934, + 0.1275507134996125, + 0.12791357917909646 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.13031001749502513, + 0.13087028005219342, + 0.13143794811300344 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "e8bc5cf8c42d760cb0e01aa72c959c2ccdbae8a513899aa6edf715589cb81d7e", + "metadata_sha256": "73465ebe969142f5f7f931eb90893d6d1a48a573ac5422397ab321f295591efc", + "realization": 0 + }, + { + "arrays_sha256": "6b5c8e95b379ba6ce62a17e8c91f2ca613ced06bdf4a2f65edbc38d7cd379c4f", + "metadata_sha256": "62a03dc6a70a6aadb09f9125977a76eced0617a88f5a25423cd8d0abc9efc540", + "realization": 1 + }, + { + "arrays_sha256": "8956a56500f112f4441c2cd62fe8dc2fda5fee3f824feffae388f96763fda793", + "metadata_sha256": "c76389d496a0c1110faea57a806129c3f7e07ffcac8df9d75bbd9317acb15e8d", + "realization": 2 + }, + { + "arrays_sha256": "450b275af961fc110d170e061a7c38f58e8ba6a55fe2cd0ba3282d3052ccc8f4", + "metadata_sha256": "99f6f1bf8e9158612916fd947484e42153413fb32b63b6c4701f9feab6baddee", + "realization": 3 + }, + { + "arrays_sha256": "198fc065df71e865d266b05fd06f9461c8fdad9aac086b1d3fdfbc8d8ce38941", + "metadata_sha256": "7830c99f9ebc50f4b3c6c76042bdc26ac640cbeacba6ecaa67ec848071a8b632", + "realization": 4 + }, + { + "arrays_sha256": "0d7551808d971cf3be0715863943a3603cd98b96d44de5c3a648a1f79214b328", + "metadata_sha256": "ce8573370a89ee7e3e052ba4c7ab7fc146523cbfbeef3f8eeace1eb9d2fd8bf3", + "realization": 5 + }, + { + "arrays_sha256": "a0bb1093426b4637039f5247c6cd77b988ebc952f06cb53d871ac3e7ec59173a", + "metadata_sha256": "e355e05d6826f10b2d8d7ac70bab68a9a0250ee9330f173c303274a68175b5c6", + "realization": 6 + }, + { + "arrays_sha256": "4d93211bf9df5b205b561d3aa4c3f9476f0659ab438649e6ef2851f00d9a679e", + "metadata_sha256": "001d4a52c63f96d782511375e89222890273ca2b077c0e4c227fb4011c786b11", + "realization": 7 + }, + { + "arrays_sha256": "af99d83e08d4b7d6aca685149d8e0e649597feff8c3deb4ffb1541cfa1693397", + "metadata_sha256": "eee4e84a6b28f99de9263e2a68898de6d7156be7d86e8eee4b99d47d72a4a11a", + "realization": 8 + }, + { + "arrays_sha256": "54cf02030b055f806066b98cd7d6983eefed5f06d43a36126bd049218e29f04e", + "metadata_sha256": "242d08aee58cb3272eaa457a3dd1a1c1f9f39750658084dd6859ee3402c4e81b", + "realization": 9 + }, + { + "arrays_sha256": "48beaa7d146c6b9f1da93b649c3fdecd24ca5f7910622db359aa473cda9386d3", + "metadata_sha256": "f0abcc47b3f3b0106b1280898b2353d3b9f611d531851ff0d69252c10915a951", + "realization": 10 + }, + { + "arrays_sha256": "3ca8dfde3f04597fe6662d556811b9d5b7f8dce25dbb32b3e6f4c85c0f8915ff", + "metadata_sha256": "664c4adf6b250f757106b1329cd39a339092a1f20cb6bf74eb4ef45689f287a4", + "realization": 11 + }, + { + "arrays_sha256": "46d8cc1895dfb3f23a3d38d9a472afa2949ccc30248ab2fe873c68ae7f98e664", + "metadata_sha256": "77f84d1e54e9d0e3f0c8322a9bfd7e3c209fcae6ed18a25eb61a1071b34c3d13", + "realization": 12 + }, + { + "arrays_sha256": "e5c0fec56248acde29cd89410e250d383b71d481d3f1722cbe38b724bf196db9", + "metadata_sha256": "a7ecd7067d634a64885b7f99fb0f2ae2af9293c6a4203508d9ac11b5ca8b9ed1", + "realization": 13 + }, + { + "arrays_sha256": "1dc7a051012e609eb64a4b4813d77a41a313ad4e9edaa4ce51c0137324a640e8", + "metadata_sha256": "1c0108ba74a8a36050ca56813ee0679f8904f54e230dc1751efd1b30b1a2992a", + "realization": 14 + }, + { + "arrays_sha256": "f1109359c382de232a439da5bef4e85d577e06abfe8af875fa7fdf0c879b4fe2", + "metadata_sha256": "953134a936a077362d02c4a157d2a4f33041dec10f7098a123e094bb1fbd239a", + "realization": 15 + }, + { + "arrays_sha256": "934d4737a8942f93b32e8cd6cd1e623c843f52c1ad6e288d6e12f0f9f4fa96ce", + "metadata_sha256": "96de573f87b2c77acce78e1be1f9807b44cd40a3b428306b7f6370e23f233e10", + "realization": 16 + }, + { + "arrays_sha256": "425c0d1a3fcbc46a4b5be6c286822d593b67c43cb58332787c24337f0d2588df", + "metadata_sha256": "2e1a5cce290bf92a5c16bbf0910ba0b1bb1d08bbca18d23ee44de213c6ecf2a6", + "realization": 17 + }, + { + "arrays_sha256": "1a7c690565b7825e40058b77a81e64e0099451c96a5ce8a04a912a77ea277abf", + "metadata_sha256": "5e234d6fafee06dc8c97636f00fb881df8b3d12d97e22945d45c1674dc2a6a23", + "realization": 18 + }, + { + "arrays_sha256": "622db28294606fb68eebd8c5f76a4f9e1a7508db4d680774b9421958b228c600", + "metadata_sha256": "aec6cf217d44ad645bc846c60563ae3044153037c7fba0fc109d150c43209e86", + "realization": 19 + }, + { + "arrays_sha256": "60ab74e6ef0fda9076a27e8b6402096c501e4b1ee538841a4dfd85736a4ba28f", + "metadata_sha256": "bd525e264973ae0a1d72890d57e46ef7dc79aa77825b099b9075d4bc30ff3d4e", + "realization": 20 + }, + { + "arrays_sha256": "a1999dd5d461e9a45c50ebbaf73dfa0ac20e1ac1242d121df31a9a136274c15d", + "metadata_sha256": "a8f2c9fa5373b0d5724406c6174b5054a7a9c374cf2dc0dbd04f3f9c8218be1c", + "realization": 21 + }, + { + "arrays_sha256": "eda483fcded719e92057a7a2e688825f9956b1d15ae7c393dfd055b89ab78f49", + "metadata_sha256": "0fc36ff07ac83af3e95c79ac8758b1f04e2eafd0a854ab18d398c425b5f16fc8", + "realization": 22 + }, + { + "arrays_sha256": "8d1f4f3419e34687600952535105ee8313e81802d820453142780987d3327587", + "metadata_sha256": "b6e02c0d88b3b2a51bc35b47bf488d53e2f83c385c7961244eec9d06675aef3d", + "realization": 23 + }, + { + "arrays_sha256": "574443475f30c4f74137b52867f3ac235567afdd54606a68bf9d7e5f41296a02", + "metadata_sha256": "b022708b6cfd0fb83789311ae6419f30f851727b1a4fbbcf59ec14b38aec8c36", + "realization": 24 + }, + { + "arrays_sha256": "50dbb09d43115b50eb103bd8fb3a842e9ab049dba540558885e5339a437e66be", + "metadata_sha256": "ef749b035ebee5975475f77fdf52c95986fc023ccdc45f6eef84410477db79f4", + "realization": 25 + }, + { + "arrays_sha256": "37a22b1857100c3051ac16c9db1e31bdc755e1eec007ad18e2716bd7bd6f9f15", + "metadata_sha256": "419739b2c2a5df421a5fa4fb36d2547fa98d14f7ee4904f5c4dece525a12480e", + "realization": 26 + }, + { + "arrays_sha256": "742ffbb35f93e329392ba0f68d9b87b95124f33328cf38a7eee3f4ddedd43062", + "metadata_sha256": "1ef3dcdda3a84bfdd2b81cd75310aba12c3cf8ae21b68d6810ebb99113c3b81b", + "realization": 27 + }, + { + "arrays_sha256": "de16266cc8e3b6e9f9a805fd71de1938b33c1a048380dfeea379513c8c5b9bdb", + "metadata_sha256": "b3beeb2016c9931ae284da4411cd0fb14fd03c24ba21d897f97b23e9e0861e67", + "realization": 28 + }, + { + "arrays_sha256": "f0959d0f67625631ce773370c842366ec8e1e207cd348f839e5140d9fcea0f9f", + "metadata_sha256": "a747cb15799af4e29a6464e1ffa59cc80cede8431d1b72e5bd089d63e41d06d3", + "realization": 29 + }, + { + "arrays_sha256": "ee6cb7c61e0feaa273072c6efdbf083855c543ef75322985f8f67d6096e998a0", + "metadata_sha256": "e5c7bd9368ec0ab05c201abacec36b26c01760f30b47fc1ce907d5c721fbf53a", + "realization": 30 + }, + { + "arrays_sha256": "96131c59729d37e14c5c231bb55af959fd7e752457f8944693014273688bc3a4", + "metadata_sha256": "cd7fbccdbb67c085e475b9f23d50bb894df690af26df91e12aecda445b2f77be", + "realization": 31 + }, + { + "arrays_sha256": "e1cb330a378218d9a2c8662e68d30432a8d39c49bb4287ecb14cb8860ea3210e", + "metadata_sha256": "167b3adedb0dd4faa38f19e21624bb69b22dd74f281b12793d3ac932a2aa5256", + "realization": 32 + }, + { + "arrays_sha256": "1f4588e27c5250c8739ea7779f484d530d10c7324c118cdb52c49bf199bd3341", + "metadata_sha256": "12041de07e2ec847d06fc913f85f799481b373ee69f6c8fd379cdc3ac7c49587", + "realization": 33 + }, + { + "arrays_sha256": "9508b3d29b035b052cd0b833184b5f561d602f866b1b94d93953ae93d76cc671", + "metadata_sha256": "a62764a175dcb9ea011fcf3b78e67222f7b3a7516d1ff99022a94793e0bc43bb", + "realization": 34 + }, + { + "arrays_sha256": "4fc4048bc8025533554a5361170a547485f3b01f0a78df39a39abbc1cc6d4c23", + "metadata_sha256": "56562fe44733faaf01b794eb5d320e4e7eeca8a55666da527d935a517b963d16", + "realization": 35 + }, + { + "arrays_sha256": "e3c09f44d876120672c7ba532a4c7966bc9d2779b81cfee38906b6f24cde4306", + "metadata_sha256": "84227258376bea3397226dc58c131fd51fcf02afa6839818e9650d8819025b72", + "realization": 36 + }, + { + "arrays_sha256": "918a655e3cf0a94801cd58db45867ac93fde3d4f41dd93ae6ef25aba6f52843e", + "metadata_sha256": "3b2d352484ee3cade8f4fe26ef0e2a10e07974648cddd87c84bbe2c2b232d98b", + "realization": 37 + }, + { + "arrays_sha256": "fc65c6d147c9cf7e35bbfdce5c61c2f8f4ca4d83ff8f88444ec00f5b64cc670d", + "metadata_sha256": "eae43330f5f8a16d995fcd38a77f4a07abc4ab74991b3ef8deff49d6204eac6c", + "realization": 38 + }, + { + "arrays_sha256": "68f2314e3bd8f8bcaf87f7abcc18cef52e358f2927f314f297b4c1097057e9f0", + "metadata_sha256": "f402656bd6cfab25dd0b0588e00a489f47ace4748f47bfbff874c78176c1e9cd", + "realization": 39 + }, + { + "arrays_sha256": "386a7ce2113cc7e42b0fea5a2f1af1b57d30fe3a3aedf4421049af49ee3020c2", + "metadata_sha256": "9823f4ad451bd2523f8a7a80926695fed362ad680c7f5d0213eb38264ae6c214", + "realization": 40 + }, + { + "arrays_sha256": "b5ef0c039fb776b6d608963ceeec7ba2ef44fc519deaf4bbdb445858b55275d7", + "metadata_sha256": "c5371542145184132678a66beaa37ee5f7cd91dc80ede7f79a294cd968c78fa7", + "realization": 41 + }, + { + "arrays_sha256": "8ce3c00c027a013721e874577df5c8b0a2224ccd0e5fc4bfcff5c06835dd9d76", + "metadata_sha256": "999c0c47a671534e88c56f3af44bb6eb962916fb93fc8cbdbfedd1e9c6fb9f14", + "realization": 42 + }, + { + "arrays_sha256": "2aa7acb0a245bcc214c33826ff220bfc8aa946ae9694354774b5acb84ecbcd8c", + "metadata_sha256": "bb7a5514bd5c8c0740f88b16afbd016537ab4ca38b6ce22c10f50df814c81e21", + "realization": 43 + }, + { + "arrays_sha256": "d0afd59d3d4819fbb06d2c8f2a2f7edc3da79b1cd59283dc2a437713c3619031", + "metadata_sha256": "4e060cc1326a22a98805f26544ec876440a6ed0a0d93e6c52866bac4bd843ee7", + "realization": 44 + }, + { + "arrays_sha256": "603c9cdcb9ad8a9603bf50f019d2511eaddc007b52177ce088e96fad73942637", + "metadata_sha256": "d35be8cacd2f02eb35e81edd105360b644c9e705b6fecbe4cab9c889894a3748", + "realization": 45 + }, + { + "arrays_sha256": "65014e6a66107c96520182aca41d42b590e89d59faaf9cdc2649eef641ec9161", + "metadata_sha256": "020b951bb93a1bcb954099b36ef45bbf5d1cc24eb74ddfc39ad09cb59d6fe442", + "realization": 46 + }, + { + "arrays_sha256": "a688ba332ca0daa68e8b9ab79c8f08c5392400c1f3439495b2a9a0ed8469018f", + "metadata_sha256": "eb0b60a32b2977e8ee6a30693a78cb365eca34976b85168517fdec4d736b6210", + "realization": 47 + } + ], + "observed_median": 0.36508816908827135, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3582300374035172, + 0.3713071794566596 + ], + "realizations": 48, + "sector": "central" + } + ], + "null_replicates": 2000, + "passed": true, + "physical_bootstrap_replicates": 10000, + "prediction_coverage": 0.975, + "safe_covariates_sha256": "6f021619e935297bc11fc251e07f8f1bcdf8bbee572d629669e173917ab53e87", + "sources": { + "analyze_susy_hodge_geometric_eth_v7.py": "ddaf04888905bdaca031c1e4a6119fa1cfbf4b126fd115ba775ae6c0a6a9338b", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe", + "run_susy_hodge_null_bank_v7.py": "ce16015e03e721852c73be952f24990b02e45cf787545881b96f42c1271dbc98" + }, + "uncertainty_unit": "complete_disorder_realization", + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_N10_banked.npz b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_N10_banked.npz new file mode 100644 index 000000000..2c397b0c9 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_N10_banked.npz differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_N12_banked.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_N12_banked.json new file mode 100644 index 000000000..bebff9fb3 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_N12_banked.json @@ -0,0 +1,771 @@ +{ + "arrays_sha256": "ba6321524dea6ccffdb7c2fb0de01a0f57c0b05e5abe4e7ca4a626742be78b95", + "checks": { + "complete_requested_grid": true, + "finite_outputs": true, + "registered_bootstrap_replicates": true, + "registered_null_replicates": true, + "safe_covariates_preexist": true + }, + "generated_utc": "2026-08-01T17:14:55.392134+00:00", + "groups": [ + { + "N": 12, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11562674375749774, + 0.11581594627090835, + 0.11600493311726734 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.11611791021218781, + 0.11632422011274265, + 0.11653906977745362 + ], + "median_hodge_balance": 0.1998799111975706, + "null_banks": [ + { + "arrays_sha256": "93d72c73c5e31331e12f449e06cb5365c1702e3b81f20db5e468eaa5531240bd", + "metadata_sha256": "dc2cfc5198680dff6f223a5005749c3dfcfd471cd61d0bc792fedba891fc655a", + "realization": 0 + }, + { + "arrays_sha256": "c3428dd0691ea750ba1c23ae9c658ed4863104ab412cb5258e68c7fedb86cf49", + "metadata_sha256": "f4972db7ae54385a429a5cd2b5638beaf0464f589b163f50265b05842b90fe92", + "realization": 1 + }, + { + "arrays_sha256": "e241474759e36f62783ca8556f6ae3bcf3b1950e52df1c7713fde53e9d0d2646", + "metadata_sha256": "8e4593cd3f16d85ba82831a82bab506cd40890a4e02de3b9771404922d5fc517", + "realization": 2 + }, + { + "arrays_sha256": "2e15ceac6522ae21b2ab72df051f7072b095361533b8f59631f9d6681d3b80fd", + "metadata_sha256": "88f28a8089ccb1aba4a3bd8aa7c001e9fdb2c21d06d8151aff8ade27a5ba1ead", + "realization": 3 + }, + { + "arrays_sha256": "f91a8b9a79fad2bea7a9320ec7f7afc5dc7651d54ad18ea09d2d37a7fc5f4252", + "metadata_sha256": "3f823e16a883b25f2ca66877b7065d06a7bb0fdc033d13df088c6a0f406e8b8f", + "realization": 4 + }, + { + "arrays_sha256": "6070427ef1a9b78e035f0b23921edc4f102d49e024e5a27d989b8aa568f730f2", + "metadata_sha256": "00c620be7ecd2a2055ce662cc77b5a04d012c9bf6bcae6a38abc5f30d0ceb1fd", + "realization": 5 + }, + { + "arrays_sha256": "3d76b4800427953738ca8c0890eab15e23137a4d93658ddd23ec0ace3d8399a3", + "metadata_sha256": "5470df773938b67174c13718a35bb66f0ea1ba59b801684064728221d528661e", + "realization": 6 + }, + { + "arrays_sha256": "5e0a165956addfe1c46e649a4afe1fe0b7a6dde713f4bed6e92bfa0d9674f68f", + "metadata_sha256": "9d4768232d40f6a2f1e28e1fa58a728c13816345d74e1a004d947d3a31a19abd", + "realization": 7 + }, + { + "arrays_sha256": "8d14c10d7c3d231a2178d9e9e00515a49dd8e61dc1b99408c17c791f1a5dcf34", + "metadata_sha256": "1fe7f2439738fdfe83bd37e58bd4fc63b586d6e34b22a259643b8fe8407f0b3c", + "realization": 8 + }, + { + "arrays_sha256": "83fb2c1e7beccf62ea01bae3f640919341355ad2563697680b5cf57f50976d13", + "metadata_sha256": "1285f2ae7e696d2278f25092acd4630958ea3b1ad929562eac43fd7deb863d8f", + "realization": 9 + }, + { + "arrays_sha256": "28f7faf83e6f99a94a3bbd5f79424788beccfa0894c6ffbd8b073f6a1ced4b76", + "metadata_sha256": "c60a98c887a2f8b31575ca4736d1a2ad5e78095dcc49dd87d5e5dc1718382346", + "realization": 10 + }, + { + "arrays_sha256": "e76207bd5e10487998161cbc4b96051e7929d3c5efaa5d663b1869ebd93b6d94", + "metadata_sha256": "68954d49eb3100c05182cb5652caabf4ab1f654f6e5857d063ef2ef1e258c6df", + "realization": 11 + }, + { + "arrays_sha256": "0b530ffbaf6f99ffb7b328b2a52fef6fa34fb66d65ceaef842803bf5a4dade0c", + "metadata_sha256": "7a9266933b4f0ffa09044306375222493d09d0d3c1c77fcd3cc4e043f575ae51", + "realization": 12 + }, + { + "arrays_sha256": "9b6169629c4faf0a65bac93fbbdebb6655a8680c946d3e299a67ca5de6da54e2", + "metadata_sha256": "1b8bf635647c16106911c411f88313afd0fafb8f1b5a8979f9d68e5eec4bdd4d", + "realization": 13 + }, + { + "arrays_sha256": "ddd2540f7e807153a6c9fa26a890000310e6d5ad5b8884f64b416d88aa1ec23c", + "metadata_sha256": "688de65b8d820e9c00842d3e3f0e848e829ddde9c4f8335187f8e78a89c518f4", + "realization": 14 + }, + { + "arrays_sha256": "ba0aebeacef9058229f823e48fab18589bd5330b1871ed0ebbcb79a4d1a33281", + "metadata_sha256": "8f0372c83dc97e09050802202372f2ea68ff31941118a26e137ac05785d7ef02", + "realization": 15 + }, + { + "arrays_sha256": "a241fa203dd94f24dd6571cd8bf76baf6b671f69abf4bde3f959b9bdb01de28b", + "metadata_sha256": "ea84a77ef39c908274192fba1b81f5be027281386a3ee2ad6ee2c8f2bc360df5", + "realization": 16 + }, + { + "arrays_sha256": "14125d7c36948181c3f787b6a1e7478e7d8e553ec85f33bae31a3646d7163315", + "metadata_sha256": "6e6fa9131efa931c670e72c7f877e684dce4a6d5dd07ec82fb47e93420592d97", + "realization": 17 + }, + { + "arrays_sha256": "ddb142966a372b37702ecc47a7df9a4127a25fe4438f3f48163c4f10470157bf", + "metadata_sha256": "7829ed0c9048cc6bd3300724341d28bb5556ed28cc6c20bab19e778888241489", + "realization": 18 + }, + { + "arrays_sha256": "0fa055f8e3075822aba6c1d5dbcb340ef5120bf94ca74faf9971b9ecb240a292", + "metadata_sha256": "040eb8fe2e71457af216cac0c5548778e85e10f0388dae9d8ccbbe5c6072af47", + "realization": 19 + }, + { + "arrays_sha256": "bd1707dfab836451c49bb2109e0cd99ede1fca912f935c7bceaa0e086149dac3", + "metadata_sha256": "c02c41ada79ae62e1dd4e24680e28cd3453f0ddc04341095abf1899c7e579124", + "realization": 20 + }, + { + "arrays_sha256": "5d97bf01a9ffb5186e67a5f51e94b186c7c3fb4f2fb823467ad1a7677eebe069", + "metadata_sha256": "e536a54c53124e32cc37143f4210a2d1f130d4b2e2fa3d84c547dad322853dca", + "realization": 21 + }, + { + "arrays_sha256": "5af6cc78890bf3fc85941c71a16bccd5137e24ec02f6e8846c78e9f64956f1ed", + "metadata_sha256": "9bc106cf162f8651bbaa5f6da2165895a5550f2153ad4c3caa6e152e4aaeadff", + "realization": 22 + }, + { + "arrays_sha256": "8b5817b70d0c8866cb5942f8dc3ead508141310764d15676db3e5ba34e275a5f", + "metadata_sha256": "b4c751ba5066ea15a2c8408ce92d4e3f960e0837aaa827cfb21cccdc7d643512", + "realization": 23 + }, + { + "arrays_sha256": "a9ce7d42abaccc0e2ff454b2220a2c1965addd037d6a79fdb8555f8f53490450", + "metadata_sha256": "90813298e72ef653194a2cb85cb74d4cad29103a2aec98b878bc2a36bf85fb19", + "realization": 24 + }, + { + "arrays_sha256": "c65e5c84de88659e989d45fec7851d1bb6bca407e399af0f079daa114da2ad31", + "metadata_sha256": "e0b9807c895876ceaf90fdd8c6fb2c71a0d2ebeccd96ecf8126003cbfca79724", + "realization": 25 + }, + { + "arrays_sha256": "2965dcde2597c69758ab6dc94711e088d65336de04d6911a8e95186be19493b5", + "metadata_sha256": "bb178d3e32b0b8c4e321b503806282f8130606313f12c3046e412a94133d2815", + "realization": 26 + }, + { + "arrays_sha256": "49e3a10b9759e93e295ef60a623998325928e3b2244833fd241c627f940ba01b", + "metadata_sha256": "0808dc618f8903b1855a9771d6352f46b8bf0118beedac800a8eb268d2309d43", + "realization": 27 + }, + { + "arrays_sha256": "c87cba77f96e96de0c54d49cc98d4589bdbce28283f5b0a964bec922862594e8", + "metadata_sha256": "9cfe4557efec36237e39fc77cc151d9cdccb13dd7f49062a038078e577adeaec", + "realization": 28 + }, + { + "arrays_sha256": "eb1dccd7afa5a727958e1cdf15666dee8094aa14194a72a5b65d889772a9ac47", + "metadata_sha256": "b1f67ef785d977496be6bb346f53dcc602d73ed9043ed8fd1946a1b9c9ca3b85", + "realization": 29 + }, + { + "arrays_sha256": "a0bceba2f4a233215e922bc7c8d08dc1cfce005b23ed8ad6e2070cc491b5980f", + "metadata_sha256": "ed99cbd2a63f57179597675590fcf0df84faa39016df477badde1fdf29b82d65", + "realization": 30 + }, + { + "arrays_sha256": "d76bba82b2799e3d7727e7e6a0e6e1726e1858ec79a5610530dd11970a84dd8f", + "metadata_sha256": "9a83de6ffed3e4bc5f39c9ae1342f98a539208827bf59e479641ae83f3520467", + "realization": 31 + } + ], + "observed_median": 0.1455538020363032, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.14303643414095735, + 0.1475576386964763 + ], + "realizations": 32, + "sector": "adjacent" + }, + { + "N": 12, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11653550918409035, + 0.11677938950236749, + 0.11704279833978756 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.11754400876960917, + 0.11785329696356348, + 0.11816821284249375 + ], + "median_hodge_balance": 0.20304955102017233, + "null_banks": [ + { + "arrays_sha256": "6295e43d8b066e587de5eb0081e9e35534a13fac7e41d976e051c1e5fd65bc17", + "metadata_sha256": "d3ccaf826ee7c2db7a09aff5e316c0a58fda1783348ff3dc110ef861e13e6b6e", + "realization": 0 + }, + { + "arrays_sha256": "27a297e1100d86adc18773e93406182c724504092eca903627cabb570705dd00", + "metadata_sha256": "973adb32e9df0e77051c809031081b45717a0c6ecb194175a2a61fea3ea7e2d9", + "realization": 1 + }, + { + "arrays_sha256": "b113c827bdf362d17bace67d13b8b941651063d17eca813a7594741f9d1199e5", + "metadata_sha256": "ab6b133a2fd225b02dd815239e851b8ec9d5466439e99f9508a8dd2ac69eb644", + "realization": 2 + }, + { + "arrays_sha256": "7c7cc27dad0a1dea57c16ee78bd51285fe7557a2c9a7cf4a0d26a33d012d135a", + "metadata_sha256": "0834559c9abf99744717b8fb660ba49da469cff33914afc16dfa43ab598b1e1a", + "realization": 3 + }, + { + "arrays_sha256": "a331c9611bf4e6404c67cec2c6fb3a0db2b2d6e7aaab53dd5bd50c8a8bf241a8", + "metadata_sha256": "cfe366ef911f84f87ba519ed5d97d5e473d05bbce91400dcfd4c512fe388248f", + "realization": 4 + }, + { + "arrays_sha256": "9af07ba8527b2969d0738bcaf2a2d77bec3dccbeb6d3b12c02fd4496d304c2b6", + "metadata_sha256": "155c6a82e749c2e93d85e00da213a3ab0ee7f98a60c1944c1fb9bed34bb760ee", + "realization": 5 + }, + { + "arrays_sha256": "274acda5a9d51241a73e49318934cb8a22896fdaa1c3c14540813b6354f1631a", + "metadata_sha256": "7ffbf33870caa20fff28b18cdf887ef014eb198a782393fdd91142f7748729e5", + "realization": 6 + }, + { + "arrays_sha256": "a00c0d087274c20f267d39b4b4cb5c148b749c0c6d52f80f13f3bcf5db6f3954", + "metadata_sha256": "b4b5b3271dc1bbf8cc43e1ea0b37f441bc8fe23111bbb58266bfd3874f6e2213", + "realization": 7 + }, + { + "arrays_sha256": "c4cc4284cbae78865dd8eec113fcd8fb2437246548b2b613e49cddb3625e9585", + "metadata_sha256": "7e45fe031db32016f502101819d4cf91613fb9b9f1e5aa17860abf71c7779a50", + "realization": 8 + }, + { + "arrays_sha256": "673f3c19d0d36037bf7d0a55654c2c19553a6b7467047d63bd3a1754c46ea4b8", + "metadata_sha256": "8e4744ebaec126005471c500ce9d274fdd255b0095d6157b3b7181e3cdde8c05", + "realization": 9 + }, + { + "arrays_sha256": "de2c8dcd9a3a47d7335d0af37fc390ce13b3dc5f748034f9e3fab1fbba5996bd", + "metadata_sha256": "f2bddccb651e2c23031f42ab1e78360e2e5a876255babb43100c0006057c2f1d", + "realization": 10 + }, + { + "arrays_sha256": "1306ed2f1f1b38a4f574cbdeb4d522f1b6edb447eca3c85a33ca319907236277", + "metadata_sha256": "dc2f48e993727e64ad32954077329ea6fe12f226eca787d190a7359c8639e9e2", + "realization": 11 + }, + { + "arrays_sha256": "f1721dda5d7d20af93e11192dbddc7c1b437c58952c14d0f46aae0b0ccdc95fe", + "metadata_sha256": "9084e131eb07d404a52545fa7184d5b954a8992d198498b865bd26355a9ee304", + "realization": 12 + }, + { + "arrays_sha256": "55c41e0db6b603fa392718dbdacdbbaf2bb9b12344db3b7ff7a9ffdd9a1ea4d1", + "metadata_sha256": "1223b4af181929db6e5dd514cc1783ef4948ebb618205a62acfd7e540643f96a", + "realization": 13 + }, + { + "arrays_sha256": "f845550590021742adb988cc35d0ba87780c776063b1d035606c3c412b243205", + "metadata_sha256": "f5da11a1c2c31851a0db5d3790e403d2c6a400beff3cde15b53151ee76c833db", + "realization": 14 + }, + { + "arrays_sha256": "dfe01d14a160e3ba3a8debaadb41c40ab101b928303773358a4ac88eaa5ff396", + "metadata_sha256": "77983323fbe61608095651a3f599ba2edb97b1f1b05fff922ae978f18c000ad9", + "realization": 15 + }, + { + "arrays_sha256": "b8d81ae843c89287ff6476caa1831e81b680c1a16f9a0cf919bff2e27719f94a", + "metadata_sha256": "1f982ec22dd4a17d312a03ed534ba53a8d614b2cdf9af9827df4e05d0e51d8e0", + "realization": 16 + }, + { + "arrays_sha256": "bab482952e5ed39928387bc94cf9f2a0b45be95c39738a54f6e6a7056421139c", + "metadata_sha256": "f5ce915e3b0e94b506673e7f75448c080ffcd3d3661ec9c030e56493805fa5f4", + "realization": 17 + }, + { + "arrays_sha256": "7d2998d5654f4caaf74599ad5c3dce3a64e269f4a2b193a7e0c07af38f66c962", + "metadata_sha256": "8e7e3e100087a8fb23e96f80ff603f2285666ec223ee65ffdf9fee1a704f7cf4", + "realization": 18 + }, + { + "arrays_sha256": "d3adb10b6f8cba653f2e2b4a6b2b614282550e54a8001a2826c1ed6089872b69", + "metadata_sha256": "cfd412db593d795cc07dfe2c0166b4fd2e9802e359d0a4c37579b4683e00357f", + "realization": 19 + }, + { + "arrays_sha256": "349f6d329d978da2b6ec1d1d9739e3347f8e35c880a837e2998d7116a6176a83", + "metadata_sha256": "0c35c4824a64b1cf1e42799d8a4a4df92e1b2dfb11b61008ec76d1afc5d9f241", + "realization": 20 + }, + { + "arrays_sha256": "119ecdfb9b5e238cd44b73d0d13f6b8fb8df57242510cddf20e39fe2f9d5f518", + "metadata_sha256": "9d0772100999d60a3277e297b15d7e247d0bfe228a8ac6d4a945d929818e1894", + "realization": 21 + }, + { + "arrays_sha256": "1eea7811e2771b0c42e22c83ad898431d92f76f0b7cffdc3a22c1f24a29eb522", + "metadata_sha256": "1ac4d5b8a4846fa38d236b8b3ca9b8db3d28a9c8be5563a70d101b54629ed688", + "realization": 22 + }, + { + "arrays_sha256": "5e47af01b7c9c15e3e5aba1df3c83f13f069e5c8c539ff8036853a5f1ff95f9b", + "metadata_sha256": "497afb80aa6cd8627763ce3a44825f5d661914078a034bb222ddea97ba154bc5", + "realization": 23 + }, + { + "arrays_sha256": "2894fe2a6198e17bad873c598c60feed9cc8d1dffbe2cca584a5c8bf1796edcd", + "metadata_sha256": "369a4a569fe45b87c779a047f675fff62d3c25dc4599c5eff7323bd3f6bfb1af", + "realization": 24 + }, + { + "arrays_sha256": "edc2ba31774ec0a0b536e4be78e65a9a1196ef9644d42b507e44419b6300d85b", + "metadata_sha256": "d943b0bd0ac1f2753302c13b3a79d642d851b926907b719242b6b5fa05066de9", + "realization": 25 + }, + { + "arrays_sha256": "add66316095507864a2384d7a37bca01f7cfe4d8d17a975edf5071ee32107f6f", + "metadata_sha256": "f1dcf67b305703c6ac79dfe12c343d150dbcf3e8c39b4c3f7961e8872a89413d", + "realization": 26 + }, + { + "arrays_sha256": "898c638319878397dd788dac8da53b1dbabeb98e2c260284b135ff7b9da3c795", + "metadata_sha256": "0fab88d8124736c1a99400fb696aa73a051240a860aa206208326ccfe8b78bf5", + "realization": 27 + }, + { + "arrays_sha256": "90211f72e94b91e7f57a41b936082c1c1aaf8382325bd00e4a9cdf4d3c642cc1", + "metadata_sha256": "7d5f48933c2aba3d0d5fb9ad4b1936635d46274a77ce87078807850f0dc80ca6", + "realization": 28 + }, + { + "arrays_sha256": "2d6230c3e95f28ffa75ee250d98a8214d2c06e193d8b3d8b0062fff10757bb98", + "metadata_sha256": "ecefbf7a0d3deb9da88a32a948636ee4065a571ec3c94274d716c77449781a4c", + "realization": 29 + }, + { + "arrays_sha256": "05d12aedca05111de31469d758084d80dc48b432d06190ebd84327adc64894e3", + "metadata_sha256": "2131d684fa42e5ff2a089053172c482142a4608d15fb5385447c452c354fdbfc", + "realization": 30 + }, + { + "arrays_sha256": "3e0ba8253ca91d2cfe7a4230f7b94bbaafd0a43614d0c0a29b9430b6b0c91c2e", + "metadata_sha256": "8914737f638888b05ec83eb7e231ed9d8e51caf5e3a5000236453950bdbe2f59", + "realization": 31 + } + ], + "observed_median": 0.30799929044283475, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3017947804697443, + 0.3137684915691576 + ], + "realizations": 32, + "sector": "adjacent" + }, + { + "N": 12, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11279238387872889, + 0.11282147828827586, + 0.11285685034000596 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.1127383177366043, + 0.11277130222361338, + 0.1128063131866758 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "39eabf0716d5f70ab54f3d8a7986b5e6bf53cbc678601044e30c1fa72c5ebcde", + "metadata_sha256": "c483781d54be8115cb6b1636f07470161b30b60301b441c4a669bee7aa23f32d", + "realization": 0 + }, + { + "arrays_sha256": "0a1bede9ca227a0be9ae8994babbcc68c6f43d8b289bdf7ceead7110f59ceced", + "metadata_sha256": "a8f749bb2b254d3a48501af8c8ee49c2b73a7049e0ed4b085bc30e76746e2f68", + "realization": 1 + }, + { + "arrays_sha256": "2c95b9b23c4f1789b49eb4f9da845f59c630e6f37c94089a9adb254122fd36e4", + "metadata_sha256": "d03167484e3e072cd72e651d80e3ce11f22e65e568be1a30ecf7d5053441627e", + "realization": 2 + }, + { + "arrays_sha256": "5031a362d6b78e203e0cdde730a124def9522f734d859844df37e656f26ae1e5", + "metadata_sha256": "59492d5db4ab2b536b245c4c2e32d61ae238522075f1e1decd80be18039fc189", + "realization": 3 + }, + { + "arrays_sha256": "f796cec58355e5a217ed19b7fedc24cca9c7231d68604c9164a071eabbf69a2f", + "metadata_sha256": "9caf8f23d001caf3ce782e8475cbcebc6dca291eaff911d2edd6f14077bffe1b", + "realization": 4 + }, + { + "arrays_sha256": "43cc763a595e604a4e08e2ffa16b364ee0685c0011d4e9bd78ecc8f162b35df1", + "metadata_sha256": "53250a11910f15412121ba64dc7e9e9aadb0ca17f3e066facea8f2280d00d942", + "realization": 5 + }, + { + "arrays_sha256": "5eb12d4efe1d5ffeaf8c98ee32d3bf9af49b61fd90e0641fe74cc13e9d730d39", + "metadata_sha256": "149235b0dc6c49dc55c07f34483c6b92cc3c9600130bd6e4158edab936df10fd", + "realization": 6 + }, + { + "arrays_sha256": "99b381c67c4a3be2f098f1ae7dddf5c11d841d49b84a2a7be96514e9cfacec2a", + "metadata_sha256": "788d17e4c84b11b42f27a1e59e5f39ba13d5f28adf95151a8e527cc3d85ae02a", + "realization": 7 + }, + { + "arrays_sha256": "ed0b9309c6d7d0f4081432ebae7f0df4b3244e51ebe6cd49034b65b4c3494781", + "metadata_sha256": "ba6255d5ad211f1a02a20c60f3856925e4d0c4ae479c0e9aa5ca725d9bac7d8d", + "realization": 8 + }, + { + "arrays_sha256": "8dcbba96f6ce35299c702f2ca8239a5388ec4e28c057341038b4134dcdde8828", + "metadata_sha256": "c5fbd6dc542ee5fcb4070e7676781cd92ef2dd2062897562d55c9cf6211268bc", + "realization": 9 + }, + { + "arrays_sha256": "a8e505e41ba60163db39036bbb026e4e4ff07788e6b5fca3747f8489da46f099", + "metadata_sha256": "3440dee8c812e29bb0d65517f05cac624f0902e3fee45af9a713f71b036b0bff", + "realization": 10 + }, + { + "arrays_sha256": "0720b141a9452923373f8a6fcc37805177b0ef0bde9303771b78ceea49628ba7", + "metadata_sha256": "c21c7f6184d187d3f047de2ad86f198d2a5824fdb681c40b18d89b8948e55ff4", + "realization": 11 + }, + { + "arrays_sha256": "5ed8d947c24c093a2338bcdf72e1f7157b98bd0b4309cc2ccf65c067f61093ab", + "metadata_sha256": "fcc433308daf020805cf0a4f07075f82d0466e0d5c8202e39741af6ea89532d9", + "realization": 12 + }, + { + "arrays_sha256": "b801592e7c1b9566d8091370221ecd29c5489e0c049f1f08b87f2256dd9305c4", + "metadata_sha256": "471935e03b4679706020953efdb355b0602ac562830929e68de5fb9233123530", + "realization": 13 + }, + { + "arrays_sha256": "3910156a6de0e7c6c33d2ff6bc17da0c141202d04ffac58d0d04581fb6ee39ad", + "metadata_sha256": "4378c43c64e652ed1a7c9f783e28b589ad05c283e7a59dcd9dc2a7e9fcb2b5f4", + "realization": 14 + }, + { + "arrays_sha256": "1540d7fe3a5bb912c56286fff51264aefeca3f3f3298efc95e478b9db4394e60", + "metadata_sha256": "8270b7ce104a4ed6e743deb16c188384516afa1ac3b8f2b71f7016a344633d9d", + "realization": 15 + }, + { + "arrays_sha256": "783b385a237d23444303dd72be753bcdb081498d00a06d97234934823aa5c511", + "metadata_sha256": "5d3392ff9794175c6622a797f6505ad29ea74399107a4fa6dcfdaae39bdeb704", + "realization": 16 + }, + { + "arrays_sha256": "b587d854136db8b51e99fbe4686bfe67c8876d5aaeec8e43e02cb2f2b0c239c6", + "metadata_sha256": "da7b442102cac0dc638ce7767c44b51559bbca1c42009d9577030281e68da253", + "realization": 17 + }, + { + "arrays_sha256": "c9af54614b2d32d5c1651b90cb2b94ef3079f756194d45e08b88750849e8fcb5", + "metadata_sha256": "9a32fd40f74602cafd55736b7ad2612d942969eab356e25ab928fc40e90e03f2", + "realization": 18 + }, + { + "arrays_sha256": "69bfe64bfe84686e782e99545f14b495e26b8a06d192f114f177a97aab47ee42", + "metadata_sha256": "fab0cbe18dacdae282ccff6fc26a2f2c255fd3141fb95cdfdc8f4b17555b0eb2", + "realization": 19 + }, + { + "arrays_sha256": "71540460007eb40ea4463188b8c6c2fa8876ac0657e1a79e94ea57382d99eace", + "metadata_sha256": "ae47f705bac8f00e785029e5d1d8e7d07063f2a7953b1bb6fce29339e8dbc8f4", + "realization": 20 + }, + { + "arrays_sha256": "a5c34b53b815d20f9ba52ac32f51e23d0a70a9f1807b1baf822232c5b08a6dc2", + "metadata_sha256": "d77dff93869446433482d6de448b6f3a543ab18f7708ab7cb1b14fa31d72bf29", + "realization": 21 + }, + { + "arrays_sha256": "18d1616cbf1945652d4e75e211f9499ad57abd64a3361fdef3a2deb68b29d776", + "metadata_sha256": "025349b10cea8c5094acd4a2d6d2c3d54f6f56076c5e28788a3d6f105f61abaf", + "realization": 22 + }, + { + "arrays_sha256": "8515493492410dde08f2599233f50bc2a779d7ced1c359b9681c3640afebb377", + "metadata_sha256": "b492d5319ccc6f1d6e9e9275f5114f3b0adf4c20a414fe7cd5d92d36d9573f24", + "realization": 23 + }, + { + "arrays_sha256": "0da5ade0ba2c79dc549b303ffb19c633228bf4f9cb0ff3a4be72175e477618e7", + "metadata_sha256": "a40b2500a6aa9a9b8bceb254c932c64715692dd4550d8c8b88839496a72efeae", + "realization": 24 + }, + { + "arrays_sha256": "98fca051c41014460206b61be3a79075d6eb02f9a2a3cfd578ef6d91f8ed2859", + "metadata_sha256": "9070764e76f06d92da44ef838939f97bafccb807ae3826b85da93f4945f0f51b", + "realization": 25 + }, + { + "arrays_sha256": "5d7da8a4e388c3cd7fac108b432ec9802dc39a8ac4a15b2a5135cc15d8bead02", + "metadata_sha256": "73c61ef0b3f3d213c79b5a02ada91ba7f83b10ac285995ba60b93cc68aba91d2", + "realization": 26 + }, + { + "arrays_sha256": "3c4091d2eafef1887e3c0b357b92b79910fdf67752b7799534876ae9c28bcb34", + "metadata_sha256": "70277620e91df611d95d4b03d6423eb0606c838c81c77771307c134f701a2375", + "realization": 27 + }, + { + "arrays_sha256": "e2d34183de8270bcffd3949f0bf48de4b77ecf35cfc0eca1be28e19a87e9dec4", + "metadata_sha256": "96360e14e6bb6e28088373504b22d6344475aee688edfd5197f67f456d906e1a", + "realization": 28 + }, + { + "arrays_sha256": "430711e8f5a8496884e7d42f006efbb8c98eb55ca122f741b7209866032435c4", + "metadata_sha256": "f822f62296da8f225d9b92d103752641f57f59867306617f0984a820a15effad", + "realization": 29 + }, + { + "arrays_sha256": "5f75b9b6d20dab158273e0da76d484f48525adc94f59d5f7cc4a9aec3547155e", + "metadata_sha256": "aa746965caf49c907df3bdfd028aafa7f6868d0c584fc0a02e5b0af221a7b976", + "realization": 30 + }, + { + "arrays_sha256": "99ce32aff5c3d13eba4fc9f2f3a3661aafffd23365a2df3bb67b6f1a89a90dec", + "metadata_sha256": "56b68c7c5a89fa2cb853f0d3eff9a025a0641b1f6a1479236d864a26effb0fa1", + "realization": 31 + } + ], + "observed_median": 0.1758398360594558, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.17501819690750547, + 0.1762804126020616 + ], + "realizations": 32, + "sector": "central" + }, + { + "N": 12, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11302005029615277, + 0.11306530368482279, + 0.11311431333015237 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.11320492572703314, + 0.11325918904630874, + 0.11331421373353018 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "71707e9992e64d86525ad773fb28849585213f6381803b2b0777ece4727a5701", + "metadata_sha256": "c4ca211323853dc572c47b93d85f73789beb13eed9df8e626d87dcdfcf8bcc6b", + "realization": 0 + }, + { + "arrays_sha256": "ddceab7e434f07d728d20c1ffe6b4067e8ec468349282c0b38f7bb5ef7e9ac93", + "metadata_sha256": "59180248a4412e7519816ca85b7772ed819d0dd0f0fecb1ccae7d84eeac9a58f", + "realization": 1 + }, + { + "arrays_sha256": "cc6dd0cd91fe05ab3ec8f7495cb00bf3a04c4c885207de44ddd892b3abf91d9b", + "metadata_sha256": "32de84ca7e7505f0e6c9f78a284c452d7c1959d79a957d7c4c764901598076e3", + "realization": 2 + }, + { + "arrays_sha256": "1d2ca7c9a81079cc338cb2e78969456019e98a6749885691fb34c600210748b2", + "metadata_sha256": "0be5a8ac9a2d86222df74bef9724b61f68b24f5fbd844a69053fec70f18843d6", + "realization": 3 + }, + { + "arrays_sha256": "9ee9923ad88a32db01c58a74a8fccd4e189681592a9b871dc1833472b0a8f6d6", + "metadata_sha256": "042f35c6092ec0dc81c1d41d219cd7b26dd44ca81748e21d6397a758bab1749f", + "realization": 4 + }, + { + "arrays_sha256": "bb0d0df8ea03892e4f7496520ca9635b70639f7f7f30a77302b01e648da810e4", + "metadata_sha256": "2ec162d2f94a1d7ce0573144a06e0410054096ea7128aff06f6e376ea4ffd364", + "realization": 5 + }, + { + "arrays_sha256": "44329461a9b5a1ccb1df747a669d42d1a6f38d720a7872d42ce71cfd3239dddd", + "metadata_sha256": "7ded7fc66837459cc2314252cadfe450d69309b20d3eb6942e02f423280b26d8", + "realization": 6 + }, + { + "arrays_sha256": "ee5ea78b28f637ac2a19939a748f4703cdd576902bd12b8b12e5bede786695f2", + "metadata_sha256": "7a5887b3088b4d7446af34f09291e564c928df6d4fbda305167ef67b84a37cef", + "realization": 7 + }, + { + "arrays_sha256": "4dad209b278d4e2dca484f5a631c280ded9d41eeb8616d5df4b5a5da004e075f", + "metadata_sha256": "3c0386cf66a6bef718f7c50d4a35517a403f7fce3f67b0760ea43baffaea49b9", + "realization": 8 + }, + { + "arrays_sha256": "076de75110454679d5cd40dcfac8e74807f0f22cfd1dc32a2f1725b3a8082cef", + "metadata_sha256": "adc5fd58b95ab02fd56b031d7a4df7d7d61c277e3865382f3082e0a38c96227b", + "realization": 9 + }, + { + "arrays_sha256": "f74afe2ad85b5aba89e40ce7757a5dedcfa6c9d7d9d3a925b3781f0089520ca1", + "metadata_sha256": "14cd5b9006a3ffbe2db46238bceffd7727e0082414ddc9868bbb6a5bf9a096fa", + "realization": 10 + }, + { + "arrays_sha256": "24e49082ecdecddeafac8c627e4d9bf472a8855754a74d6f995db3eef5b49b2b", + "metadata_sha256": "d7d9f35a9c5673d4d01fb30a6f5d40aca84820529be473fc80d5601a185b565f", + "realization": 11 + }, + { + "arrays_sha256": "860ed34e094dfe214ed93abaae02c681177e64018c11ea8ef8a127ccb6682248", + "metadata_sha256": "f15a1ec151f1e3f6849ad65a82580bbcdcddd80b3c722f8ed664108453da5820", + "realization": 12 + }, + { + "arrays_sha256": "266b470e4809dd1429646fb1d1aa85c4efaaf1086d53eaf10c2735efe13506ee", + "metadata_sha256": "236bc6f90c3334ffb41ce6aa5f36d8fbd314e4eef526ddb63e256955a02d0636", + "realization": 13 + }, + { + "arrays_sha256": "e69a34ea0d55dd1984fcc4f95b79df188e7062b87de8cb6d6fa7f2b26d5d6410", + "metadata_sha256": "96332f6cc786eefe03913c81876e94d4f9370f5eda80100ea2c363d59c72b24c", + "realization": 14 + }, + { + "arrays_sha256": "54b1a0616752d9df4b9fc2596d9d7de82b5d44d22bb7d1906b661f492921d271", + "metadata_sha256": "482b21be326cb8136006c217a5ea5c809678319e0acfa3e032db3234c6d18bd6", + "realization": 15 + }, + { + "arrays_sha256": "9b5ae475eec7cc10700c330f9f9cae5e4445dca38c9aabd1005a39ff28228166", + "metadata_sha256": "67324ba73faf7acebcf56ac70dfad572c98f5fe617195099a34cd0f266f73030", + "realization": 16 + }, + { + "arrays_sha256": "67e221dafd6bc2984560cdce1fe08bebfe9b77843ab4788465cc5809756703f2", + "metadata_sha256": "c07e531884d8e430cdfb0de8689407c69d8bc00899f7cb7da0d702bd45208a9c", + "realization": 17 + }, + { + "arrays_sha256": "0b4fc80a2e252782c750d1101295d9ba9858d5d7db1ac93dbe5f39092707c981", + "metadata_sha256": "2f98ba35a7460da11856a9caf03ba21b69edbcc86c8fa730991a1f6b85c2b7e6", + "realization": 18 + }, + { + "arrays_sha256": "d0271f89f765a3dd14ef72e60a04a05ebd36f0f8f44f9fc334e0d983669c0073", + "metadata_sha256": "11f91f529f5aff15edb1831393a00ef78f1355568f1461ab2eb8f8877d43c45b", + "realization": 19 + }, + { + "arrays_sha256": "29326e8d5ea015856d4725405b6c006246fd0851ae11046554c5d4af5da23fef", + "metadata_sha256": "780b40e217cfe9dc7f48e4e6290faf227fea210b46f544c381a9610c133740d0", + "realization": 20 + }, + { + "arrays_sha256": "88a56dfd95877efa47f5cf835f980e496b1e89ea384672729a4b398295d7607c", + "metadata_sha256": "ccfa25b213a0b12d34b6244945383a1aa6fcc78ec561b5655246d8fda1215ad3", + "realization": 21 + }, + { + "arrays_sha256": "759b4a0eeff52d56840a4f555f8b1487f7a0ae6fe2b0851beac285da6a3b32de", + "metadata_sha256": "5a1020671739db14ff00792ab81ff6bf1ac2186d1f71bd96e42c2d2ea59a7360", + "realization": 22 + }, + { + "arrays_sha256": "b3f3bbe3e5b2ba39532f9f2dd7a911d580ecbcf73d35d993fe73dc941e0e6dc1", + "metadata_sha256": "ca4ed10744865e489863326067e9fcbcb7209b249eda108676684f8d881709cf", + "realization": 23 + }, + { + "arrays_sha256": "c96b940385f6f9ed97e6676066ffa4b27c20fdfbad67e333dffebd0fac9484ff", + "metadata_sha256": "b453d086109da994599b0ffe2d90c187e50b6342e3f47f3aa5c6356833b1fadb", + "realization": 24 + }, + { + "arrays_sha256": "660ca562eca25d5db05925e45a03f4180c8153e15463ae774f997ebfa09c7614", + "metadata_sha256": "a4583fc4be9b25f8e7ba25f2d01e1b70a278da2c1e2117910873ac07e2f9bcd0", + "realization": 25 + }, + { + "arrays_sha256": "9bdb7328ac028ee09a3c2b707857fb8ce24dd638f2f558cd8cfa9028fe86fd63", + "metadata_sha256": "4a2596a9d545ea020ebe2e542affe16c98649bfd164f19cdcda0880d38a3bf9f", + "realization": 26 + }, + { + "arrays_sha256": "ae9049ce7fe0e152e28e89fda236abcd3e663fc03c6d2edec20bfe7807a5b433", + "metadata_sha256": "f147e1f90205fe09a859505f789600ab83e89077b365db3c9e3936e7a44f4b1a", + "realization": 27 + }, + { + "arrays_sha256": "35758b032d95c843ae5a0496933bf57ccad7ad523b597a01a490cac699c2990b", + "metadata_sha256": "92a19b3d6054f81d92820573384e09a5016ee5c6f81204ed691c5dba09dc6234", + "realization": 28 + }, + { + "arrays_sha256": "aedfa0b0f7ef46297d0996d4a398daf8558c811f7bac355b2b974383ca98b72f", + "metadata_sha256": "2926123a3539b397af98d24335fdf41b70bcb967e83ca52b83f9f334c7d70fa0", + "realization": 29 + }, + { + "arrays_sha256": "f3dabf9c509cb6e96cb5d6df46a0ed8bb60671ffbc89aa04ced7b4e625a7e9c8", + "metadata_sha256": "d897321b0d03a3621c83f343f6cd6dbe121dd59f79c7c62f69ef89adfb85dca4", + "realization": 30 + }, + { + "arrays_sha256": "5263d4c66a1b6614df17e0e37b3b71a4d155c8455333b6292169f768dbcfde98", + "metadata_sha256": "e2f4c35b0de80e0c418a0f83eaab5f4e0f265382e439d1a7c56fe95e3a96e36d", + "realization": 31 + } + ], + "observed_median": 0.37696338917315897, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3695751849042101, + 0.3793322651479647 + ], + "realizations": 32, + "sector": "central" + } + ], + "null_replicates": 2000, + "passed": true, + "physical_bootstrap_replicates": 10000, + "prediction_coverage": 0.975, + "safe_covariates_sha256": "43ce991a4b9253735a27392fcad82c8e5b6c59176d9ec70f89e7aeb3e7e86658", + "sources": { + "analyze_susy_hodge_geometric_eth_v7.py": "ddaf04888905bdaca031c1e4a6119fa1cfbf4b126fd115ba775ae6c0a6a9338b", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe", + "run_susy_hodge_null_bank_v7.py": "ce16015e03e721852c73be952f24990b02e45cf787545881b96f42c1271dbc98" + }, + "uncertainty_unit": "complete_disorder_realization", + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_N12_banked.npz b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_N12_banked.npz new file mode 100644 index 000000000..7f0db8960 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_N12_banked.npz differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_banked.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_banked.json new file mode 100644 index 000000000..05d140ef2 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_banked.json @@ -0,0 +1,1411 @@ +{ + "arrays_sha256": "5d61f53a39d334225700d6ecf42e48acc5b668a72bfed4a214a943d25891539d", + "checks": { + "complete_requested_grid": true, + "finite_outputs": true, + "registered_bootstrap_replicates": true, + "registered_null_replicates": true, + "safe_covariates_preexist": true + }, + "generated_utc": "2026-08-01T15:57:25.743496+00:00", + "groups": [ + { + "N": 8, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.28774443822769635, + 0.2923719696932815, + 0.29747553580253777 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.3059263591384163, + 0.312032433068657, + 0.31831694112765746 + ], + "median_hodge_balance": 0.07040982426906839, + "null_banks": [ + { + "arrays_sha256": "7e4e820c450f1e3921d889e56fd5dd8f1cc0b85efebb0e01082f72896eadd975", + "metadata_sha256": "3dfd016bb6cffc1bb3cea44405bd5280344c764350ac059703b2cd7af9449afc", + "realization": 0 + }, + { + "arrays_sha256": "5f2b5ee2045d7e634ea2eb75be49f59d044c694db0d31dd96b554075d16baf64", + "metadata_sha256": "426b5d1187b3c2609ffc029b233659fa5d7f51dbceb53049b1411582ce42a2c7", + "realization": 1 + }, + { + "arrays_sha256": "e821d455d25eeb8440515614400268c3f0091781c64cc042d2447b8056df6259", + "metadata_sha256": "b2ecdc748cb7bafdf6ae3709e2a4a32fc1db34ed18e5074f5a9d103d7131f2b0", + "realization": 2 + }, + { + "arrays_sha256": "a7a8d2092c29178d35912a48018e334d1d8e025a24288af6ba3a3e2ce65eaec2", + "metadata_sha256": "3206a8d888f29b824c67418a84a5c7b7dd7c2d2318c431a9eb358fbe52609375", + "realization": 3 + }, + { + "arrays_sha256": "8eebc9f3ff729229002bbff88eb1599faae9681fd7aec883a3c73e0559a2a826", + "metadata_sha256": "728581e912fe0ee4cbdf3066fdd0dc6160bdbb82dbf258e515e0d11e28d73fd8", + "realization": 4 + }, + { + "arrays_sha256": "c613197503272fc266f8aea0f6746f3a16c0e9c4845ba71c91f5e4d9df165997", + "metadata_sha256": "16357f2902cfb4cacaa672f9bec6c8882756684d39de8ec27ee3f0739abdd840", + "realization": 5 + }, + { + "arrays_sha256": "584c834366b823aee9effb07a037b555f39fe7efc3a24bda79004f52557d8c4b", + "metadata_sha256": "8f3bacf052da6950912eb5ebc5776e397806bdcb25928e68e8774c94d1465592", + "realization": 6 + }, + { + "arrays_sha256": "71a95506502428f05bdbd1fed08f5bace55dac555c8975f99f53ea65f0bd2e87", + "metadata_sha256": "9e05a0d39b40afca583d4950bd7fc0df1cbdc15b38406ad50e28fb2846b21a3b", + "realization": 7 + }, + { + "arrays_sha256": "85c77b070a9c54276bc752de236c1c658f3f999cd1b92f0ecc53f0a8649ea71b", + "metadata_sha256": "3dce74e5717170ecad93c4de0e68a4454cb19be3df4706c8ea024a4241faaba6", + "realization": 8 + }, + { + "arrays_sha256": "a9b039b58718984c9643c6984dd524ebc9bbedcaa82140b530ae5f698f755b36", + "metadata_sha256": "0e4f603d7eee9972673ae54f75878e0534dfe5defac2f785ff60de1648baa301", + "realization": 9 + }, + { + "arrays_sha256": "90e82fda00d060444958a4b38f7fa5b2728e91e7b4fffbc69aca75f50ad852fc", + "metadata_sha256": "574932aeb9b422627ba393a783a7fb8924128448d0d1ac51302e1900c60df1ba", + "realization": 10 + }, + { + "arrays_sha256": "95b821b9a32ae48211a34b3b8819e6c0758a041f7a6cbb471148d0fabebdaa2b", + "metadata_sha256": "217223c8912f1bbe708dadb2e0a12ba9fa5e6b36e3a6bd583d4f864bf0c41637", + "realization": 11 + }, + { + "arrays_sha256": "f182e61e5d9880bdfe13b1e7b148ddebf13bf12e00e018798fe85fda84f00490", + "metadata_sha256": "2c9453e6cbeb420dc8a6cf80a7bcb33221f23a7594610310369a79a30c358e1a", + "realization": 12 + }, + { + "arrays_sha256": "d9634ea5aa3830b539c122ffc2024ceb09ec73398d23f785baae66b001b66fcb", + "metadata_sha256": "ba0d05489fc8d01eed51fc4c1eecd10ac981e9df32b9080cd80cc4578ac2edff", + "realization": 13 + }, + { + "arrays_sha256": "85e233efd41b6223f3988f25135d922407ad1f0c288f2bef39b718f1d529e35f", + "metadata_sha256": "5b1ce1bd4f1e6fbab140cec48b0b62bc2f914b10b4ccd43efdef40181eb4b469", + "realization": 14 + }, + { + "arrays_sha256": "e4289b64b3dce047b9fd985f6adcdc0a3e3252f7ff3b8281da3d939092b94900", + "metadata_sha256": "cac306e55cc899f1bf75bc99ccf1c649e342b09c325229724acae01529109365", + "realization": 15 + }, + { + "arrays_sha256": "a63b9e21218662bebf0c4d088c4b2c839e6bfd28fe3bbc0261f6d01fd5006249", + "metadata_sha256": "744076addebecf804a815872fc7e81114ad6a9d71ca6f28a81c111e8d3788ef7", + "realization": 16 + }, + { + "arrays_sha256": "b66785aa3497256bb2cea0b6a986c3bca2fa26266184862c65f90112421a555c", + "metadata_sha256": "5bf89be8cd9fd3f57a2618cc003767bb31981e2f968b6ca07e529643b6ec5b36", + "realization": 17 + }, + { + "arrays_sha256": "11e79fc31c5cc3e182f8ef0f562a2c87ccf634d12a1db3076bac07470d44dcb1", + "metadata_sha256": "9e739c2f1ed1871341c81027a95e84a55be69b335b8a7b140a0419cfcf409c7d", + "realization": 18 + }, + { + "arrays_sha256": "d97a9e0429300a547d19779538fd414a0e9d2c2d5bfdaa67cb1b3ca5cb2a6b33", + "metadata_sha256": "6fe0176819c9e58364ef790a9eae7e6611961f7bfcef945880306110dd915f65", + "realization": 19 + }, + { + "arrays_sha256": "ea18c6209433f98d01e626e32adb32e7f3746ead049030007824f8354f678ba5", + "metadata_sha256": "aed9b8af87dac7d5a7a957998217221d289301db393cccdbca049f515bb0d80e", + "realization": 20 + }, + { + "arrays_sha256": "dce799fb13a12d2b60416f3ab8cbae52488cbaeb416c3d66a81d394eb1ebc824", + "metadata_sha256": "db22fcb0c7126ef751ffca375878c37f5fdf4885e3e2c62f4b2c01b50cf9cd3c", + "realization": 21 + }, + { + "arrays_sha256": "7f139c15fecfd3bd6aef20c2dac7990b820632f4746dd896582be8ddef362150", + "metadata_sha256": "85b3979fb070e3c863d83fb7fd6d2a37d342a1f26e70c6e09da64eab06496d6f", + "realization": 22 + }, + { + "arrays_sha256": "e4a16f1648a879ea59b7cd2d115741020af65ebcbc8ebf27af067ff935a3a25e", + "metadata_sha256": "3201185d7b672b7e48ce3eae311a5236305d989e99b6ee377ebad0f474f91270", + "realization": 23 + }, + { + "arrays_sha256": "b33c0d85db8c3dfdcf3abbfe84699e963fd790b9108b8488790c7cc18e95dc12", + "metadata_sha256": "29a56b3311a1f6afa2af8b5b9d69aa752523c44103d9a6652b0ed4e033b4282c", + "realization": 24 + }, + { + "arrays_sha256": "69eaf9db38244cbab7e0a89673366293c994f5c8bdeeee19927d6d3e5d8c5535", + "metadata_sha256": "1714c7aa1d0d396fce816046490428fca0685ff2bce1a98558195430dded6c97", + "realization": 25 + }, + { + "arrays_sha256": "99c7786255d17f345a12fed9a1bc5e14f9fef6038df201c4d6b45b6bc3c026c0", + "metadata_sha256": "8d815aaccdec229e70760c18f4dee8a588faf9b6607b6a865cdedbc2e936ef3a", + "realization": 26 + }, + { + "arrays_sha256": "1a0ac3542fa92251ff91ea6d34b14feb35b747aa9bda371a5e70acde9aaf422b", + "metadata_sha256": "8c5c71f09ed0e9515336909c215494c03cc31c4bb93364fe5f2f980bc59743a2", + "realization": 27 + }, + { + "arrays_sha256": "7ca331246d1467e2c96f4097f5ffe5d72d2960e6e25c4a19dc56c9e9d0bd6868", + "metadata_sha256": "c93aed73436e1fc63abcf3ada6bc560fa2b424a83fedd38333198e5419f117bd", + "realization": 28 + }, + { + "arrays_sha256": "4863b7c2f3e14f69b89b42cd8cc2c1f1fe9c59f3a8b70ea9c38245277cbd881a", + "metadata_sha256": "2262f4eb6f11bf168573f431e63f5c9f508b1a05002f60a8bae31bf994f41383", + "realization": 29 + }, + { + "arrays_sha256": "415755781cb1e33e7765b8ea14cd908c4d7beca78546123e66b0c04e1953c20d", + "metadata_sha256": "f28edfd549d07cf345b7e14cc4d213776cdaaf53d1d30679f938611c0bb35ce6", + "realization": 30 + }, + { + "arrays_sha256": "a3750fd2d886546440304c53b32133fde8d98a063935cbd6e235d34d58284ae8", + "metadata_sha256": "b14943201c15195b67b2bafefee856ab80fd1ffe1356d97792056818b85ebf5c", + "realization": 31 + }, + { + "arrays_sha256": "d02260472d42a4842285518d8e1c98c576c0b1463ebad8c4b215da7332450566", + "metadata_sha256": "46970f4a17ccd61a3b30029bdd6f96e2b5dbd806f17d7c14abc80d2996ca7c1a", + "realization": 32 + }, + { + "arrays_sha256": "81ff3b0e0317c3bbef179366f3349b5c1244b5b2a2082a3a7d0b62ea5195666c", + "metadata_sha256": "411acdf5488a70841b15c5e89dee4c7c3b2c2592b8a5a78cc5f89703fd5bd547", + "realization": 33 + }, + { + "arrays_sha256": "d081b259e270deddfec2893fd445246d6a0664f9da9bbdecb8496867d30ff8f7", + "metadata_sha256": "eb281ffe125c7ae297d34e8892686e788c10cc5626d42d8566b02dfd8a499658", + "realization": 34 + }, + { + "arrays_sha256": "fe7caf952a54586ad05bca871603d0d73281ec9ed7d7d87854d92a87ec0641a4", + "metadata_sha256": "f94011e8d522a44a8bf42e8a38c92efe8102a5ea01ba84b5f4a2d37e7853a13e", + "realization": 35 + }, + { + "arrays_sha256": "2166c1c4df9f59ed10da26646934950916dff33df3e780103e2701cb5d88d619", + "metadata_sha256": "305b266fd5ce59d2fe2f204db5fa402211862ac10b5c0c6482112f61e6c111cb", + "realization": 36 + }, + { + "arrays_sha256": "ef1ac6691de4fd6cb8e48a888e60d68e01125e554bc24f22e100e89e04b6a08f", + "metadata_sha256": "246e59a96bd94cb8ba7c3dd19ea8c3d57e0392f24145d7b99088762e0ae59301", + "realization": 37 + }, + { + "arrays_sha256": "fdf76204d2d7f24750a9fef68c19e4a56a5754b97dd0586a6fdb3aa11209488c", + "metadata_sha256": "59cae7517ada9bfeb4a2f20f20560e9eaf41dcfbc8d228090cbb4a2df9211fbd", + "realization": 38 + }, + { + "arrays_sha256": "f73e711baec36161053aecf09d3a427c3180bd8c28d6aa81eaa466d866c7aa68", + "metadata_sha256": "5a85797032a5e103652761faef137c1567f74aff1a8efb394c08a043916b5a02", + "realization": 39 + }, + { + "arrays_sha256": "9ef7f26b96c37b046e48911784430b468b31f2c1e5c07f7d54c30efc572141c7", + "metadata_sha256": "3d6aec77022cf4a9d9e2949973e2883dfb0bf0a10ac855efa7ca9db6fd049318", + "realization": 40 + }, + { + "arrays_sha256": "4b34e6df5d11668e4f57bf92290d53f537978023ccf8f7fbc1f19798d5e952b0", + "metadata_sha256": "4d3cff581ee92d10c2686166a66ee7c6ed8f5d301b0ab2db1e21b484112019e0", + "realization": 41 + }, + { + "arrays_sha256": "f0ab0be182f4e781204bd2b458e07b76db9754719ddaf4cf3955b22b6c2511c9", + "metadata_sha256": "d317a01ab9e55a558685feb6257548d668ff19d87bf7103ad2f65b00e120b4b8", + "realization": 42 + }, + { + "arrays_sha256": "221b995bf5de99c432d7846a34e9850f17e9506e01bd67e7a451c218114f4e27", + "metadata_sha256": "d7de9f96ebe541888c47333d513a9a67e1d7e34e807734574df294c68246f92e", + "realization": 43 + }, + { + "arrays_sha256": "c4221bacaed1027386e3acdbaa64e01130af7c2fcad5751167760d3835698569", + "metadata_sha256": "d45d62a5818b7d58e51f7208ad437731e39a33cf70c044e344b31c53bf303558", + "realization": 44 + }, + { + "arrays_sha256": "3a3fafe51d483d7e40202a2dfc1b460f340bed00ec9a9d9d9c400835179ad1c8", + "metadata_sha256": "a326da978a071e34046484e268cabb488ca18f8969246b748971520050cba300", + "realization": 45 + }, + { + "arrays_sha256": "cab548f23cb10decca232fae69b30a41403b925e8a4c444fddce5bb69c711818", + "metadata_sha256": "99aa1416434f28cbc606b0048e495a80788435e87927e8d812f9db55c26689a5", + "realization": 46 + }, + { + "arrays_sha256": "b7fcc506e264de69b2ad4b9a74bc3b1385c04650099eda48f4a5639d8562f4fd", + "metadata_sha256": "a842c741f0121fde7462cae5bf009b388cdb4e7156257c6d82cec863671df4fc", + "realization": 47 + }, + { + "arrays_sha256": "51253eab4bed3429e76c4e9ee66d1d6468ffb1d562121511f7bc30db76f7e2e4", + "metadata_sha256": "3e23a7e3ad54c83a17abcb6124210f1ec9781ce83e3872db68de32cb337380f4", + "realization": 48 + }, + { + "arrays_sha256": "3daff8369b98eb6fd41cde8dc3b215120335a180a61e2b79248387a650e3cf01", + "metadata_sha256": "8047d6dddc4a9ac99a247c9898d573650d37256efd8e83213549aa952ab3700a", + "realization": 49 + }, + { + "arrays_sha256": "aa704cd81fddfa33539ec459f4fdea4a0582708f77c78f6543b4e599a1fb611b", + "metadata_sha256": "2b748867ac598bc7389fa696c1739ac6d24f7250861cd0efa2ab1dad1faed673", + "realization": 50 + }, + { + "arrays_sha256": "e8560a879d50cc5b66a80eacfde868b7000e220494a1dc553f5f5c88974d7605", + "metadata_sha256": "cbd0ab6f3732bbb36f7304f235f204f0046b6a18c190a468587be3b4e4a8e37f", + "realization": 51 + }, + { + "arrays_sha256": "cada546af06194ccddaa2142fd30c1d14329661c3bda7aa3404840ea46e5537b", + "metadata_sha256": "0e8dec3026aaec22885686ae085e8a1a8bcd0748c082980e5681d88d19f235c6", + "realization": 52 + }, + { + "arrays_sha256": "df6001e2388006de4aacbf7f32756703d75148aadda915402e96593003bbadfe", + "metadata_sha256": "da5584cbdc11b39ef50f8d0ebbc7bec11cd29cd49c69808dd69076ca56944469", + "realization": 53 + }, + { + "arrays_sha256": "25d9143238813a04dbd6b7d7c9ee342b45b51396232506b2ddf0ab5a83530e77", + "metadata_sha256": "e199dc888ea7b2de2fdbc5c77b18e75fd57f0baace859d05467a01c5885e66be", + "realization": 54 + }, + { + "arrays_sha256": "34fecbd9e49b031a2b65ddea5df32c8d71cff5aff67ddd276f188cb6db1f7209", + "metadata_sha256": "b63c590a9d8f2d1f6ebdb8e61bb2442957cb9dbae5c8ca5ef1dfc979db8a6a45", + "realization": 55 + }, + { + "arrays_sha256": "fd50eee8d0f350f485ca0db54f3cd3a9cbd5e1ca732b5834c5412e8bd35dd93d", + "metadata_sha256": "36a333cce5f66ca8dbc8a63e605984c180decc4afe1663b8f3f2d5fa169dca38", + "realization": 56 + }, + { + "arrays_sha256": "e715721223022dc3f2ab7f1d23a1f72b288e4bc522442d0e60fd60fdc5e64e61", + "metadata_sha256": "0fd84230852654f9dd0ddf0cf48ca2b15e10fdb7b7c3f5490bf0549af3e850a6", + "realization": 57 + }, + { + "arrays_sha256": "0a942be9b78844be357d2fb991b7e5ed179137a1163e5529c0606e6f32cd136f", + "metadata_sha256": "52852b5de3339bd8c87aa38f4f06c36e0bc3c2e4a46bd1f9c6b5ea70887c937e", + "realization": 58 + }, + { + "arrays_sha256": "6150f9dfbe18411bb31643e60184a91df5f3df4ac00c693b9cb085957696fd01", + "metadata_sha256": "0480543c0f755af003017ae43b9a9ed13704be65511a22b572ef833e49785107", + "realization": 59 + }, + { + "arrays_sha256": "754135a046b184931081182a8fd0dda67a61a0378621372d6b960d682910ba1c", + "metadata_sha256": "984d2758dd685732330d632f32d08cec2861a32abbc4d09e5bef6ac6af7f302a", + "realization": 60 + }, + { + "arrays_sha256": "a344747a67f2f0e6d54f6b94e94ecea6db7b9e5a12c384f618ac5ea7c29e9aac", + "metadata_sha256": "9565a1766c17b1daa4f63f5c831e7d4881d93119824c342711ee83a6752ca797", + "realization": 61 + }, + { + "arrays_sha256": "515a473de52604c2933aeb366b8fafc1579882b73e8636df2aeba9c89491d03c", + "metadata_sha256": "97b75282143c51c703db365b08703b5858be2c7cab60d654d96728cedc84c140", + "realization": 62 + }, + { + "arrays_sha256": "1b5d28ce95123d9ec301ecbd28149273f82867bf85eb5d1aa948907beaf532df", + "metadata_sha256": "d694f1efcc1aac6fb6cfed8814335d0962501b5d7c3697a9fa3de2bbce443611", + "realization": 63 + } + ], + "observed_median": 0.3473456476442244, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.33998881412401927, + 0.35539578968897517 + ], + "realizations": 64, + "sector": "adjacent" + }, + { + "N": 8, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.3057881860688608, + 0.31137835043300116, + 0.31677833243100345 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.3277032710171455, + 0.3343214104998873, + 0.3415163074349069 + ], + "median_hodge_balance": 0.07146412252958581, + "null_banks": [ + { + "arrays_sha256": "4a71f07c0e5c660fbbbecc1f47560e70bcaf094ac5aad34213c481dd63d63294", + "metadata_sha256": "2d3ccaf2c6495436f3a35cdea0812600ffd81e86c601ad8ed1c938639e62fc1e", + "realization": 0 + }, + { + "arrays_sha256": "71293782f040eb92223ec4d01a28404b5008dcfa128d6e8fb218c61465cb0451", + "metadata_sha256": "be74bf29116fbc56ec295a1612ff586d6f5e660193ff9897816f40390c3f33ef", + "realization": 1 + }, + { + "arrays_sha256": "5da89d02f9a43808e2ecce2523bf58d48aad6721fe0b212e81302ff86f15ceaa", + "metadata_sha256": "766c99cd710239e31c833166c802c4e4ec87b32ddb94d8d0d36e2ef068dc59fc", + "realization": 2 + }, + { + "arrays_sha256": "85e3546836f0001004d949eadd2408875ce0afd28b7a0c0eab0c4fad24ba6379", + "metadata_sha256": "77dbc140d21ba6ce0ec0c0fbea9c0a50653cb1cd36c8eb92f75fdea196fdad8a", + "realization": 3 + }, + { + "arrays_sha256": "5e648686ba4cf787a59890896b28e778e5e4d36c2ea299280f0ff7b5b969be45", + "metadata_sha256": "f5d3c4c863059880f5c7a7478fa1c0a0ce8363c8db3981f081ceeccac7d147eb", + "realization": 4 + }, + { + "arrays_sha256": "36e67c8fbd0e1dbb536f780b285868edcaaf99a8155e16c0f02180cc74425d5d", + "metadata_sha256": "81335e0b0b365050aba8478008d953bdcabdb6dcfd51363a40f2328fed6c6ded", + "realization": 5 + }, + { + "arrays_sha256": "854b09042971e52f3e3a6cbfe343df9e5e84b0de0a6cee10dccc0f37689ba587", + "metadata_sha256": "6e50701efbf8d41c1fbe14c8f6b4c81625d58d81937fa80c6691a2762942b66f", + "realization": 6 + }, + { + "arrays_sha256": "2d856a13d486125679df3ca6ae055f9f9565e45ef13947bb6fa73d51a3ce33ba", + "metadata_sha256": "5f4ac976f9c23ec39e601484388f0e1a377d296db0da1e6260eaac6f35cde5dc", + "realization": 7 + }, + { + "arrays_sha256": "9ab3247bb2cb415755fef35d838e6c40f1d4715e314f2638f9e3ed86c54ae530", + "metadata_sha256": "96371d7cc16c6dd229bb9caa4e5d4b3c6b98f4d1663b4ce04cd3baa03787cc74", + "realization": 8 + }, + { + "arrays_sha256": "7a9032658a36ba78f329a12d1700cc2806756a21ddfbf130162086e5142e1b1b", + "metadata_sha256": "5ac1a7bdaa6a10b315e9ff0fa5a4e5f93a03b10fb43b0e213daee09ba1a14f79", + "realization": 9 + }, + { + "arrays_sha256": "883b7a5c0accdc3e3102c37aecbc208be1700269c96d9c8c27358b079cf3e1c4", + "metadata_sha256": "5050035111c33e4037fa8fae7490ad4ef89635de318e7dbb03b01e5eaf65fbb9", + "realization": 10 + }, + { + "arrays_sha256": "c60391692b0e21eab4ed30fb335b2e9952fdefdd3575a4b69f1091363c2eb967", + "metadata_sha256": "676f25bb5e1c501e7ab60abe68588a30ce885de0e9495692e81face631258aae", + "realization": 11 + }, + { + "arrays_sha256": "67d18ec337994ced9e8dfc5bd417346909c28ad3e97e40c7e9a1341c118e76cf", + "metadata_sha256": "d2d7c71deb94e0dca633ca8c85bc0a8bca18eec3f2bac16dc8300cc3b33d6465", + "realization": 12 + }, + { + "arrays_sha256": "048b43a21cb45cd4db4e0b5f218630ddad6b0d937f08e029b02a129a953db586", + "metadata_sha256": "0f0dcc77b32704680feb62cbff1ccee998f7ba7f549381bf06957cb663ad54a6", + "realization": 13 + }, + { + "arrays_sha256": "a1d17f2a560975a58f9c08ab70de6a906c75bac9877393b3484fed7ec84278fc", + "metadata_sha256": "fbbca5c43e077a2e5649f3d20cffeed888cd8fe19a7d0cb0b3385f32a447a465", + "realization": 14 + }, + { + "arrays_sha256": "6b95ee27b4ae3e3d6b92e3a4c8f102cf805b75131c3a8137ffd5c09d444088f1", + "metadata_sha256": "660681f42644933e010b18e927695dadf0c048b5cd9ebfe0649d2ae127aa9e55", + "realization": 15 + }, + { + "arrays_sha256": "1926c8b15068394570738a1656f75f03278b170272297027b72658e7f92bb9b6", + "metadata_sha256": "1bff2ab792c4c59212bb23a9ed74172f74bc86c9260053eca764457601269404", + "realization": 16 + }, + { + "arrays_sha256": "e3877490b22de8e07031d5c1326703e02000e33f00603a9527d4e0f7f075b009", + "metadata_sha256": "6a705795ef1a8f1ddcded46205c8a0f361c8bb864a2bbad0c48cbd1f79e0624a", + "realization": 17 + }, + { + "arrays_sha256": "30648db876acc8fb837a4cd3aedd9d01dcd4e5f3eae06695399fefa16f72a337", + "metadata_sha256": "370424291a045c2088bb953660c41ac0a00b45852c0073b3726782220ebe3bb7", + "realization": 18 + }, + { + "arrays_sha256": "830e11ada74fd2232d183f3128fb2323e12923fe6599ed5fb3a2c31e2914a965", + "metadata_sha256": "4bd0ae8e314541c0a57d8427f62d112db826a7f420f6488167a4e4aa884c5357", + "realization": 19 + }, + { + "arrays_sha256": "fb28182556675c28c562b9921f81398f38fe2288ae0cef95bbe4e8ba8104dd91", + "metadata_sha256": "b3f913f534d0039d253811b87aa249dcef919862c9cd843a78a748d948aacb73", + "realization": 20 + }, + { + "arrays_sha256": "cafc794c81de01d75221ec8e5e04453f88b6260ed8698fe22fb9388be7dc4beb", + "metadata_sha256": "a89860cdf5ab27770cda88f8ffaa8e91c3239a0bf778aae36bfe37709391eaa8", + "realization": 21 + }, + { + "arrays_sha256": "f8c520c802db0344ba4ecc5f04797156888b27ce8e2e443b64a5beea9ab8ffb5", + "metadata_sha256": "4ae10ba66002e7264b46586865f800f71daf912a49b62194fcd10562ba065d0d", + "realization": 22 + }, + { + "arrays_sha256": "b0e5b55b581e8b83429860a79c6bac5e4ba31c54363028ce6df12becf3f9c7cb", + "metadata_sha256": "d176cf6e32b5d8da3f398d54ca4a7da5e761862a9b511e9ba0484cd5c077dc10", + "realization": 23 + }, + { + "arrays_sha256": "e1871217326e24894fd7979a0adc93d9e7e5eb522c817d356ee034884f2c340a", + "metadata_sha256": "41147a25149bbac289fc3ce85896df3292dcf0b96da150be08b32507e1cfa39c", + "realization": 24 + }, + { + "arrays_sha256": "7b6ee2739bf964c26b53f7aa0a6107c87e8735a322a35dc7e0cae13fd362ed48", + "metadata_sha256": "2ca911d5db2e76a761f8182fa78eb910ef9d6d4ba13d520862270bc63837bf0f", + "realization": 25 + }, + { + "arrays_sha256": "6e36550760f983b784d91913f0e33cf63731524d733bbc02e4659e075c059c7e", + "metadata_sha256": "47b4beb8e00359eac1597ae2e5d2f00ec38b07b99067da95d3a510a7d43a2922", + "realization": 26 + }, + { + "arrays_sha256": "47ebf84fc14e2501b327381dfd72b607a1410c9a393689b94e228b426b4bb0b0", + "metadata_sha256": "985de16d4de9458e4508dac8f5ed320128da9e0444ff1395b9c49e3d36247287", + "realization": 27 + }, + { + "arrays_sha256": "8044ae04c63c5ae91aca8ba0727df048a5c42dfa3842f07aba4ce3fad5f233e2", + "metadata_sha256": "6f9444612258ea287649cf740c2ff5c852b202bd1174fea90b3ce241689211e5", + "realization": 28 + }, + { + "arrays_sha256": "3ad4725c4eb7adc0a285ac023d7e16bf86e5484289b7eea98bc8489f24fc9620", + "metadata_sha256": "1a17091f3c4413ea11d279392fefe449118916d182f0a0fefd0170cff50e3540", + "realization": 29 + }, + { + "arrays_sha256": "0508f3451d86dbc83644b0d1038e907e4b69583fc7fe67c1ae56f9c91a1a25f1", + "metadata_sha256": "6c269bfb3c0da730cd21a6b710ddbeed5291ea7ff6c544dfee4a187baf47d469", + "realization": 30 + }, + { + "arrays_sha256": "ede2af9c679a4dc56fe8e04456b22be63cc670bfb16f232bed03b2d9da6b3e6b", + "metadata_sha256": "337af29b23b6796f323957973aa4cec9b984a892d6a4ef5c8fb0790ca93d0883", + "realization": 31 + }, + { + "arrays_sha256": "877bf57b09521f48281d5787407f7d2f314ebf3ff3f15ba1e5cb6f4cd8847cee", + "metadata_sha256": "745b03a843845805c647a68f9bfd560ace63977dc16d403d1af873cbf52a4f0d", + "realization": 32 + }, + { + "arrays_sha256": "940e0a63b669409e96d27719aa68a72d310a4a5ddecedc95ee977432b305cbab", + "metadata_sha256": "dc2baa2c57d7025583c4fd5fec662d4c62bcc71deab16a92e63bb1b49bcb7e74", + "realization": 33 + }, + { + "arrays_sha256": "d1252f6fca445850490cdf30336cd3f9dbd46cb9b94bcf24f238c5fc40d58b3a", + "metadata_sha256": "a8dda9eba86ae7727e06579cdc58647479a62e56abac704696087d4481ebad01", + "realization": 34 + }, + { + "arrays_sha256": "545d66c31365b447227cdc45be506612f80faadd9b33685dfef55f43007085b1", + "metadata_sha256": "5f484c7998e6ee1d0b63d20529195b3c8c330729a9c3a227d1065cb33fab91a0", + "realization": 35 + }, + { + "arrays_sha256": "b8d563285328141baf014e8e8dc9f3cc07d191152431f59f89af28c45d54def3", + "metadata_sha256": "eb17c4d64cb62bb1fe9e3bde0d356a9a398b0ffc0a1b634f349d43084150cb55", + "realization": 36 + }, + { + "arrays_sha256": "9bf4a76d9eea5e204ff4b2c39871bf99242ad0f7caacc55e7eabe6b5930b32d4", + "metadata_sha256": "966fc585eacc07eb7c41bff39b298e86eb27c58de6843a0693b4332376db599d", + "realization": 37 + }, + { + "arrays_sha256": "08a07b3bfb555a2b53be899f2406b04941c04ad6edd19d75d75de4c7e870489e", + "metadata_sha256": "8e85e56064dde10e9f23c6d6832f1011b67629fee054fbf888712a1a87b586d0", + "realization": 38 + }, + { + "arrays_sha256": "8b5ce38c72f93f46b35383cf0c781b20b047049a73151bc9247619e933b5ef0e", + "metadata_sha256": "df895563293f8804eb5ec1bef8d1740684901d65d0adc7a995ab06f4435591d2", + "realization": 39 + }, + { + "arrays_sha256": "6ef9ab76b970220bbd5a939f2ba28f0c8156616ddcf1fcd16a63099e83a5af87", + "metadata_sha256": "41e1842062ace61dce876c064795aa1bacb2469020239beb3f243bb92ff44c91", + "realization": 40 + }, + { + "arrays_sha256": "bb0d34594d5f28ef805b7b48b47bff9b7f204348c48cf09f6412d79bcfc11ba3", + "metadata_sha256": "128914394ebe3c26e3798286f61319fb80fbaf17fe387aeea3bb1f00bc837a5a", + "realization": 41 + }, + { + "arrays_sha256": "7fae870ce113fb69b68a7f09233e9cc0953ef670f179014c787dc274a1470943", + "metadata_sha256": "1825a199194734513c110c6907428ab7126b7fbb7750dc42965fbbb4a3d9877c", + "realization": 42 + }, + { + "arrays_sha256": "f231dd3c56b519e6f19c16cc505bd4012d8b44c7805acc65f7d0d1d8bed5eef5", + "metadata_sha256": "f2c1e8fb9e3fdd7ec4ffdcd7d8d24f156b95254f72017b0d0c40a6ece2170325", + "realization": 43 + }, + { + "arrays_sha256": "8312b13d0966dba8c161678045f4b10d48b4b20000d12d7203bd3e0af492f880", + "metadata_sha256": "7abd64b7926e50ff8237d84e5e2ba5ff85211782614b50f3d269ec0c191c9896", + "realization": 44 + }, + { + "arrays_sha256": "e13fdeec074bf12340591e141d7aa5b035599f46f94d33abb59a272bbbd7f9f5", + "metadata_sha256": "44665ee402f48e34370430573403e1789fd34d26e015f53a2ff314baa1bf9f0d", + "realization": 45 + }, + { + "arrays_sha256": "b9b3855171bd8aee849bfd82f00097e8c87eed110cdd59692615bc116a3c91b0", + "metadata_sha256": "bb959d40badad7e308bf92f92aa096a5fc6f7110c49c8548868f91e0559c9033", + "realization": 46 + }, + { + "arrays_sha256": "121028fca73cb5466fe18322cccd403d03904362f6c4be61fac578fd5378015f", + "metadata_sha256": "0dec90287014a239220a4c335fcdd032b57b3618a8ab6925a4e267dd16b4b798", + "realization": 47 + }, + { + "arrays_sha256": "0985ec641e15f3372ee2f9a9e6a83d803cb804cd879371973f96412056ccbdc5", + "metadata_sha256": "05c1e0e1c870cb12064fd202042be1043d74f785721d3cc7359b02f370f750dc", + "realization": 48 + }, + { + "arrays_sha256": "f3f90cb07be47d9cef4d3dbe21d966dac8bc288fbb4c39447ded5f9cb21c8f82", + "metadata_sha256": "b053665662bf973cbf23053ed13584ca61a4611181413c72852bd873a3eb58c1", + "realization": 49 + }, + { + "arrays_sha256": "92d3838792b70f9f2cc610ccb22891232fb3cd7b7cb0dd37bf7e7b1d8a3e42ab", + "metadata_sha256": "f7b6b329f1a234a076a1b161ff589968118ed508113a188bf5557573155929c2", + "realization": 50 + }, + { + "arrays_sha256": "222e397b309ab4e370422d7cfe66d7d6af76055b0defb8d06db489151342baa3", + "metadata_sha256": "24549e52791fe9bfc7c58aa967221b9baf1fcb422adf16b2a2bcdef57d9465c4", + "realization": 51 + }, + { + "arrays_sha256": "421f29ddc2d25f8c03924a07b11c392f72b9e72ceb7d98fc223f70a68671ad8f", + "metadata_sha256": "530433411091f70dbcb6a72a02d0bf45a0681960359390efd389b0a3b3100647", + "realization": 52 + }, + { + "arrays_sha256": "fac5026cd3be96db586dcc977cdc5d10e03aa7c7dd28e20fd4d3110d8f5c968c", + "metadata_sha256": "fb270f11dfb1e2b2d5dd85af0c88ad69a0bd7f729db80d06f2d82606fc6e0a0c", + "realization": 53 + }, + { + "arrays_sha256": "d81f2390caa9cf828b460ba0c05e70a05c4e5d584f161bda49f21cd176278516", + "metadata_sha256": "9c581c3df5632594c4f542b8151449311f2b988571e8c62af96a85643d5ca85e", + "realization": 54 + }, + { + "arrays_sha256": "20ce2893c4fb83e995b5af8787d6f3eb8c8b906a408f27526249faaa54f80611", + "metadata_sha256": "7c12c9a634629df706a0d83acdff4413e4c4094a14654a1796011f5a0374b348", + "realization": 55 + }, + { + "arrays_sha256": "485ba5ecb5e8214afa7bda46800265e0083749dba1a0f89fe4dc9a1ca5debb54", + "metadata_sha256": "50677b1b657750e9386865b2abbf1addce2df70d55b87aea0ccd8c6c21ea0b5d", + "realization": 56 + }, + { + "arrays_sha256": "e58223be2ba03a84a19c89ef5410550fa86b303c37d561c366dfc27f740de3f8", + "metadata_sha256": "43b81610fd756f101bf1bf9e2cea9557721b933ae32f8f77abb3e16f8ff3a59c", + "realization": 57 + }, + { + "arrays_sha256": "ecd33f3b8d1cf44be4b7fbe54a1e04960f9e3cecb679f0982b4d51b94f7ac69e", + "metadata_sha256": "f83cb466b82214aa7e5c236c5cc166ea2c50ba78c6dd107bab46596f13ca6acb", + "realization": 58 + }, + { + "arrays_sha256": "92a2f5c466bd7c23c6716cff431ecf591c9f6e64f0f77bce6605b07d108002df", + "metadata_sha256": "4e7db9ad1306bf8710a130fe887b68b2269d847bb37aa4b4d71553cfc8fbcc06", + "realization": 59 + }, + { + "arrays_sha256": "d1396b8a7d4c52f5a509c9595d05ea9af8c99dfc856760e6a5cb12102dcc2ed4", + "metadata_sha256": "fdfe0c0adff0469cb0a8dbbcece9108ba967d1b5fdf8a15f71ec7c60840f1519", + "realization": 60 + }, + { + "arrays_sha256": "7219dc4e7cb59aa46f623b12f988f53e67a9b1cd947df03fc44d44ffe77fac59", + "metadata_sha256": "435d13b0b26dfffa8140431d0fd6c462e1ea12fcd7bd5df73af06f658c6a1b93", + "realization": 61 + }, + { + "arrays_sha256": "2215a26700357d3641feea8a23bc78e6ea56ef7a53695318409c2a815b1d7dd0", + "metadata_sha256": "e7fa05cfd42a4a9da6f55a1d6411862408dbf2315c995b89ec18f768f6cadc8c", + "realization": 62 + }, + { + "arrays_sha256": "3dc7322f0cbf9b3a60be4e6dccb42393c1ce96e46f1c9e1c72a48194732aa63f", + "metadata_sha256": "a7f702bdc28bc4663549d7f40643812f9b070afa64bd708c1c0712af896941e4", + "realization": 63 + } + ], + "observed_median": 0.4214201895221874, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.4126581626544304, + 0.43022143872255464 + ], + "realizations": 64, + "sector": "adjacent" + }, + { + "N": 8, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.208296575246959, + 0.2098604897075424, + 0.21141356711284964 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.21919373485072516, + 0.2211378800339962, + 0.22312587488350194 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "fde5ede4a59f43f00ba6dc0b588d722178bad5f7b7ab99fcfbc0b68f2bbf7dbb", + "metadata_sha256": "51a4dcda1ce78dd288476c8e2228580df2b58be891dc8f9e65c61d89d9a77aad", + "realization": 0 + }, + { + "arrays_sha256": "52261414a7fd29a83debecda4717dd48ed12328091f1726c3e07422bf71e6553", + "metadata_sha256": "74cd99598253e60d8ab4ec67711abe6cfb7a06e4818ecaa36ea06fcccfab55d5", + "realization": 1 + }, + { + "arrays_sha256": "72add21bb254f9c8d8b1caea0d5bf799ab27bcdc065ed2cde0a327ce003353f4", + "metadata_sha256": "454073ed6158a7dc8166c8be4f4751b25d919d7378676777c25d2db3a1464864", + "realization": 2 + }, + { + "arrays_sha256": "cf4b73e3e148de0744cb6489a7c218cb1ca75aa2dc0b3b25d7e88816b304036b", + "metadata_sha256": "b72680320d254397c4c6f9e835e93615286ad78e2baeb974676e92e15680253c", + "realization": 3 + }, + { + "arrays_sha256": "c768bfa190967ddfe631fd371e733bf207b83730d1a6c2836241bb35460b521b", + "metadata_sha256": "fe2c2b430e867598db55743f90cacb28ce56f6ce791cc76a84d63ab1ba787624", + "realization": 4 + }, + { + "arrays_sha256": "665b1537e6ac516146cfa88d0eb05d037ff1555b380f008c04748172db3c3069", + "metadata_sha256": "44c53d66db5ebf0f690e3c3834b706f65f70f0a04012f08983b9a1dcd8b93994", + "realization": 5 + }, + { + "arrays_sha256": "4742b0cce2a636cd1816a941d05d21b44988f4e3707a4ab0cb01f911fef6e4a4", + "metadata_sha256": "8591f30826700b51d0ad808cc301773df9ade23422db6045a3e56086512e7f3a", + "realization": 6 + }, + { + "arrays_sha256": "72f8f4bac4c29bcbc0e929c8b308f41ef87deb6f3816fd542b49843ba37e3f6a", + "metadata_sha256": "4871372cbcc2d4fce599b8911f13df19b87d0e66ce8f6ffd6241e09f5d8c6161", + "realization": 7 + }, + { + "arrays_sha256": "bc80d180ae42e4213f17ec6b57a84dec68423861672ce0f3fd7ba97a7e7da8eb", + "metadata_sha256": "2fdffa958856463941f496d4a9b8ee982edb72e3e796f1d90b590c65a80a98f3", + "realization": 8 + }, + { + "arrays_sha256": "465b7936550fe0face0801c9befe5e760bca85e5c9b2ee296673efa7d67120b2", + "metadata_sha256": "8321d2a3ef0cf370ceba6e65923a875ae45c49f1ce3a2c66e41eaac2eb86a67d", + "realization": 9 + }, + { + "arrays_sha256": "3821ef0fb3bd0885b4443995a9fbea2535dddf8c8759edfef498a279c89e5583", + "metadata_sha256": "11f1bcb9faad4383eddec5a7fd3da09178953ff1ab707adab53443985c40e263", + "realization": 10 + }, + { + "arrays_sha256": "b53125476970423b1e20b67e518c5f67a3a8dc57221eda2e211866667e1d2225", + "metadata_sha256": "65bf2f7c428badc22e9c1e80e7c4ece59458607b0d0045be75b3f06346e8047a", + "realization": 11 + }, + { + "arrays_sha256": "1a209fbf7af04aca31745929b41244330177794c224d2442c850aaea2762dc50", + "metadata_sha256": "fee41d68cfedd677158962cef0beecd69d15043b8ebbf0d922778c70137cec9c", + "realization": 12 + }, + { + "arrays_sha256": "cc224a42c513cfa026acc8db966de63488d96c4b7c56df8c21adb4ba794f70b0", + "metadata_sha256": "e8ba8dfed10b10a527c3138907eaa70b50f7d01ccf1ce24920193fc6f4ee229e", + "realization": 13 + }, + { + "arrays_sha256": "08b5225283a6a0dab2635a96fd24a3a0f3a79cc75c376a20942e56e2a1e0c1bd", + "metadata_sha256": "0e7a688adf0c7e8ce8f9c35bf4553da7d7123cb55fd7101217d7bc5c87947b03", + "realization": 14 + }, + { + "arrays_sha256": "ec340bc932bc40dbcc68f85954b8365158d4683fe793a52a8ce63ea87076c602", + "metadata_sha256": "c16eef248530e1f650b8838648ea97c9296ff4b2eff3f720884a9338d9343fe3", + "realization": 15 + }, + { + "arrays_sha256": "5e7c62a4ac53ef6e746ae28fb9b1a3d6f791e925968ee1f7e14f2c92f86543da", + "metadata_sha256": "edfdf871cf2110b9de1dd47fa5d9b92d4f3783686c322ff2c6a63485aead27ba", + "realization": 16 + }, + { + "arrays_sha256": "bd0261138dc45cbcf33a785582e115d0a1582c64da52e6c141cedc30ee0cf403", + "metadata_sha256": "979903a48202ad39cf133dab5d6c45cd6498f9fa7953ba66e16c3c2e194ea9a8", + "realization": 17 + }, + { + "arrays_sha256": "c66915ceb189d9035bff7f23adbfce23a2f3ddce34352ca60c7e029030e7b99c", + "metadata_sha256": "4658a666874da2b0733128cf56f86ea6a2b2eb84772352a19aa319e24b1f4da8", + "realization": 18 + }, + { + "arrays_sha256": "aa27db6cd06f0e9252e16849858f0fee89855e0947a3aabe949967a13559fc54", + "metadata_sha256": "918da874db63db0fe8f56740da067a75ad7cd6f32add723a1c5419138657adcf", + "realization": 19 + }, + { + "arrays_sha256": "3b057101264cec1335042b560a3dff962e09e7e166fa50aa0a2e2a0bd0b0ec09", + "metadata_sha256": "551acc16f91112a1cee4e013196df48d18f28eccae4f6ad36538e04577344c90", + "realization": 20 + }, + { + "arrays_sha256": "a09e6f0dc9a7d5b8bd1f64c7846b72db36a460346965b5a3b35ce069dbcee56b", + "metadata_sha256": "14131cdfb12ee6d2dee42764e3c290cb1f0706030bede65d2de156f3bd170c15", + "realization": 21 + }, + { + "arrays_sha256": "3f43b7157e5cdf0075d21f41cd3688448dced7bfe313ab8166f1e6f9d556400c", + "metadata_sha256": "26c61228962ce71e95961b0fd12b6644ca29d1f4880f0e5d9302ea780b6b01aa", + "realization": 22 + }, + { + "arrays_sha256": "4985f3a2f89057ed9acc86722c5843979cacfed6381f86f88cafe9253f12f4a6", + "metadata_sha256": "20d01f226a631285015d8306452ef1d23971f1bc22045adb26eb36dd11e2f340", + "realization": 23 + }, + { + "arrays_sha256": "4e3f6c91a3b4cb6c8d5bfb703580d0d7baf0ad6b1ba986bfc0753286d6b618df", + "metadata_sha256": "6a2a1106a9202dfbca97be29fa11fbd78092d01bf8a7fbed300e61cb2729e47c", + "realization": 24 + }, + { + "arrays_sha256": "9f0c59896b76ed346d625bd014ae79e4bf45106aa3b8e79d34825b127722c915", + "metadata_sha256": "3f409b78502aa9cb76e2cbfbf2e93a5eb61bbd5a74207b0fad75c973ba3f15ba", + "realization": 25 + }, + { + "arrays_sha256": "e7be39ffd2e9af41d491bd502aa54809137075f3c877702aed6b5088c7896e1d", + "metadata_sha256": "1e012adf8c247c337091d79c7266a39ccac2bf2e8f0af0c542e6c285e26b5a64", + "realization": 26 + }, + { + "arrays_sha256": "3149fed9666452bdd15d6b9a77491b268649434cf7fe3a46b958b910f309ce1d", + "metadata_sha256": "215c6dd3016833725d34b8acb5fc0acd0712aa9ed660fcc97ff5d7dae0f0db19", + "realization": 27 + }, + { + "arrays_sha256": "23227feae2a51ee786df7c9ee6f130f25802426f1fb14f9af6d41019798aea40", + "metadata_sha256": "8e02e515f20d409292c3cc7c03f61cba306ce725ae0b110229e5d04a5fee628f", + "realization": 28 + }, + { + "arrays_sha256": "55289c5fa377817987b2f29168e8d2f39c0d5838a79d43b9d71d874737e02d0a", + "metadata_sha256": "c93db0becc09dfec535fc07e6e7067166707d84045a38700487a7fd4250ab6c2", + "realization": 29 + }, + { + "arrays_sha256": "d367bc791ba0fac1539e830cc30047571b0ae38efdc634d19425490c77e6d36e", + "metadata_sha256": "94d35178eb56c5db88fe5f5cd4f6bb4714c2782a6eaf087ba63d539735547bc5", + "realization": 30 + }, + { + "arrays_sha256": "029a9ef702fad719c402458a535460b8ed44dfae1debc1f33b838f67b30fec7b", + "metadata_sha256": "048a8c3f740c3afdb1dbfdea74456fc5322aa01c3fd73f3d99c3cc1bb7ee0768", + "realization": 31 + }, + { + "arrays_sha256": "d2cc653c229c0a8ca5f0450e9c87e0bd0e2d2bbdc4266de0633940bb2f7a9633", + "metadata_sha256": "337056bd55242a282adf09d7356a7af589bc92c954ec27bec6c415cae538c370", + "realization": 32 + }, + { + "arrays_sha256": "5a325cb514453d8518f2fc9c7b37cd8dabfe65f2473709805bfc823ac3aaad06", + "metadata_sha256": "b3cd1650e85e65f9e7c15277656faa124d3f926a41a57a26310b40adf4dce809", + "realization": 33 + }, + { + "arrays_sha256": "2e4a8e7e27f2f01c8882a5dc617cb9231b2f6644476f4e316ccf6d914d1e88ec", + "metadata_sha256": "ec65aaf2406f8dc6cef73da323e92b17c3d1053f65e79459ad51d813739c84e1", + "realization": 34 + }, + { + "arrays_sha256": "6ad6d35f1fec93316bf3181c925edbed0e1dcfb0e49049b4293c249c97b7d35a", + "metadata_sha256": "4a8ce45b29299a64bcc01f7384e8faf21bd386f4daf90cf5aeb2c9800c5d1757", + "realization": 35 + }, + { + "arrays_sha256": "e550d7a159f867511a0a2684cab01106adaf898097567e9c4c0779812e8f823a", + "metadata_sha256": "3ec26df79db08062bd09f2f3348ee5ebc6dd6bd1df490ff94ab264975da1d1a6", + "realization": 36 + }, + { + "arrays_sha256": "0d7d3190076a9251eb1ba5ac8b9ffee3f539fc1f36b2d809f9d9cecaac865673", + "metadata_sha256": "869ca0075b3536be689428c4db907acf93230a71fe6f400f67d00d90e0735e2f", + "realization": 37 + }, + { + "arrays_sha256": "909aff89c5682973789b304f1259292efdbd7888b12bb02ad0a861b0d244c489", + "metadata_sha256": "03206d1869dd502b17ecb2512942936ab1395249143b6d4846936d2d6a4773de", + "realization": 38 + }, + { + "arrays_sha256": "b967f61248f39144f47dbb0feed2390ddafab896ed22d696f44c00203cbe2153", + "metadata_sha256": "481c483f26bb07a69197232574d40298b223c098608dce98d3a247001ddbce0f", + "realization": 39 + }, + { + "arrays_sha256": "2a523da657ba7866e59c634b6a0094153f85600ab55b9741d419c6f79dc94ae3", + "metadata_sha256": "3d006bc1e2b18c2f5d84d652fb0a413f0a0eb5954bc2ed270ac3a146d1e2c791", + "realization": 40 + }, + { + "arrays_sha256": "263d83f1c45ae8cc46940adb3ba8108071efb69879f3134208eab26d33bf8b8f", + "metadata_sha256": "57178de22de1a744e75b220d690bacaf74b07c1ae3b5d8941130a437e817fef5", + "realization": 41 + }, + { + "arrays_sha256": "3546e809af5123b25edc34deab9dca56a47bdeaf668b2a23a9e3fa07985b4b21", + "metadata_sha256": "2d37703a3dadaef904b74a0ebcd201373364497529cbfda985ea1229a49d1d2a", + "realization": 42 + }, + { + "arrays_sha256": "e0b81731b73e657d9db5859220f71c57844a541970954c2870bf29ac44b21746", + "metadata_sha256": "ebfe80a36ae044b18f1891ddfdeb43958fc7c7e30c870022892c9dc432e794ea", + "realization": 43 + }, + { + "arrays_sha256": "554d17b9f19de8275b8cdc2877f2f573e4bd409c328d37012604eeb012ac19c4", + "metadata_sha256": "1751795936b20fe7f16bb1718101bf832598ce01b133b4b1ef6fea9fb492890e", + "realization": 44 + }, + { + "arrays_sha256": "8faa2921a6fe3cc12372f46a7feecf3d880ddae469cfb57087f6ccda8c26aac6", + "metadata_sha256": "6ad8f1777e4ec50e7d81a0473c373dd1763ec0e2b2fd5fa1c465f5af9153b1ce", + "realization": 45 + }, + { + "arrays_sha256": "4d29ca7077894e11bc32edfe779630d552c036b774f57f591db46dd5e07a343c", + "metadata_sha256": "dbe3358d98a8d289c822d621e782051c4414a4f99d553b5ef4f5523419d8314f", + "realization": 46 + }, + { + "arrays_sha256": "92755041495ed91494c38caa2c0e5347238c059064a8578bae4c835b0c090cfd", + "metadata_sha256": "298300ff56d969bd0c062c20208e8443690e56b6150c2e291f1a6758d2d2a51e", + "realization": 47 + }, + { + "arrays_sha256": "57a6040a352113e12f35811900ed7a11c3448d34cd2bd3172b36a1e611710c39", + "metadata_sha256": "7262d060424f208b32c5fe6a4c7d56b635bbe12160ecf1286784c706f49a0f72", + "realization": 48 + }, + { + "arrays_sha256": "a564cc62aff47ac40d4155f729b15d1a942ce6af9e00979195031765e9011980", + "metadata_sha256": "d68c735f3309cec2845a34b3aee3952f5852d61aed07089da98d48fb1ee905de", + "realization": 49 + }, + { + "arrays_sha256": "b0a837dfc2d3858f4faf4adccbfbd6d4f428f87b3556d35fa8258c436650f826", + "metadata_sha256": "14f1ca8bf693bbe590af2d2509fb4c26432241b12033a5030d2f0b891c34b437", + "realization": 50 + }, + { + "arrays_sha256": "70c2eb395ee7b57f33673d9c833b663414eb11e877e23ec4635eba3a2516b7b5", + "metadata_sha256": "96a342d3ca7afc6b5bef5e4a7d4dafe92047059c9840e9114990f60e8db8f203", + "realization": 51 + }, + { + "arrays_sha256": "f7fb6f25ce15d1067b0c10745340c1c8d67b2a8b0ad3157724524a6f01e1aa2e", + "metadata_sha256": "fdfa7363c7e4a74f4ff1babfb8c5b68aeee7068e2cf366d3419c106df2cd6859", + "realization": 52 + }, + { + "arrays_sha256": "0bdee0ac4955619b553924f5216d01e95ad3085ae5896c72a5cefe7fb6047030", + "metadata_sha256": "c08d09e0e44c481250bf70d99050a518a8fe2f47dca17ac16474481ab290d534", + "realization": 53 + }, + { + "arrays_sha256": "f413fea322287b9ce8b837f75fa66b9f09d4e6bc2a4eb25e086fcdd3a33a40d3", + "metadata_sha256": "12fd82adf8714c52725d652ce9f53a0c8a3be1a093b4461b9b8546841cfd84b1", + "realization": 54 + }, + { + "arrays_sha256": "7850e99d056c8f54a2256d47ebc89b562489d117391ea398accc6d50a9f8a1e6", + "metadata_sha256": "c9b58ba30e699acc5bfd1b47934564bac2d02fb5c8b5da8dd7353bc45004d750", + "realization": 55 + }, + { + "arrays_sha256": "ba76d6efbbc1592f108a3689dcf16a12f0242def9c44a89256d22b1ae9fc6df4", + "metadata_sha256": "ff4c71b85ddd2306cb83699cb2d7f974c809980e6cb22d29329a70fcde8ba772", + "realization": 56 + }, + { + "arrays_sha256": "5500930cef24dd9376340c008e9930f693992f7a50eeb61f55fab36b7a11fef0", + "metadata_sha256": "dd1c5f0c2028293780cedc3608886e6ea78e94faf8aec5aff2c507d59946ee58", + "realization": 57 + }, + { + "arrays_sha256": "8ae7ba7246d4e551219cf603d2f2cf0ea99220cf81e1535cefeeafea47e640c8", + "metadata_sha256": "44047c9c85b677944199e175fafaa3a5c47dcca5f0b07e8d536430cc0e7834cd", + "realization": 58 + }, + { + "arrays_sha256": "edda91a20e337e516430a5e86f047f1ae83af016117193a8c0b8abd45bbb9ad9", + "metadata_sha256": "96d67509278bb4702d62d5fdf8b27d2e1ca2c6d6b07133a7296abf5a597f6354", + "realization": 59 + }, + { + "arrays_sha256": "028337035f3f2c341d1a227f16a9cf98d06506e9e2d2850c58471f7ef69f9378", + "metadata_sha256": "a3c6f482fc99ffb8b121a4066ba8950738481b433b202fcad8c4d5ca549271e3", + "realization": 60 + }, + { + "arrays_sha256": "622992b845f8f90587d9331233f351684a961c9f1f6fdc914eeb7851ca70d89e", + "metadata_sha256": "ec4206ed0e3832e3af3f79ab1de6b34bcb50876abd5fc79bfcd4094d843c1968", + "realization": 61 + }, + { + "arrays_sha256": "98dcab22df1ace436c31711268e2dda1a46dcc7b8ef64e6459a8cc04c7ca7a14", + "metadata_sha256": "3c8c16b2eac8b332a0d26f4bcba007f84f8b0e07ba7e25d5e82fb6e3e1c612d6", + "realization": 62 + }, + { + "arrays_sha256": "c34c72dc428e7715ec81111ad1c8bcfb5697b0aab7f5c2012750619d56fa5976", + "metadata_sha256": "d617d0cabe81a8cbd5f600b60a91b7983b5a55ff2328d6f9f4bee2f710e01387", + "realization": 63 + } + ], + "observed_median": 0.2144978352258034, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.2119918398218324, + 0.21709852949971428 + ], + "realizations": 64, + "sector": "central" + }, + { + "N": 8, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.2230705351105154, + 0.2253842662139643, + 0.2279418505155369 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.2414682892862224, + 0.2446097093216335, + 0.24767586208084383 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "87f4b818b585e91973b0f7e61a8727f9c53a607924082a6b44f4504c846d7302", + "metadata_sha256": "e1d34054700f403531c33aad208b2be2a664f5c02488efb39dbaac28c40169ac", + "realization": 0 + }, + { + "arrays_sha256": "a323ae57cab1876a48bcb0c29ccef6e1d8f6b82eb96a6e18424bf6ca7239bd68", + "metadata_sha256": "20bb8f1d3c0587086c8a67a86e7c0bbad222826f28eaf42c37cc199f5a58e4c2", + "realization": 1 + }, + { + "arrays_sha256": "d9f3889e07c00ccc4f581329306a145e3715d2d47d2f1f2b0dcf3252471f0a5c", + "metadata_sha256": "35d041a4687e48216505036a20721f43625e34c7075c7865932078e1325c88f0", + "realization": 2 + }, + { + "arrays_sha256": "e1e26346e3957fe5e04b2c21c093c1cf52f28ec0b34d164f412451d7d1bcfc15", + "metadata_sha256": "576a93de8ca0638d13775909009aa0c4af578619c842dc832657340770663920", + "realization": 3 + }, + { + "arrays_sha256": "99ea13b632a4adb89461189589c50f47cc8b89cc29c3751c8e99c63b5f55f24c", + "metadata_sha256": "cb047d7bdb5cb7c40a007745023476bfebb4b4ce327e4766ff12b12b04c0e28e", + "realization": 4 + }, + { + "arrays_sha256": "1170696596d1c129416db581c00aa912a2d3b840ee5123cb87e8e546f55f9dda", + "metadata_sha256": "845979e19a18e3fcce34737b49edba413d543599316e976ac07e4feb40a3a0bb", + "realization": 5 + }, + { + "arrays_sha256": "6c83e35b540c6697e4e9dfcc67ba60e325e9ae6a2c5101e8d874b05866a50db1", + "metadata_sha256": "810465a253290b03cb73e84adfe98618a9462c2cf52d07d2304f06159861b719", + "realization": 6 + }, + { + "arrays_sha256": "2daa35ffd3aacad0a4248b443d05921ef33e140ded627cd6197c4a53f9bcb158", + "metadata_sha256": "3335f2adc9d293a10fcf8a8cb73d05abe82a988df2f9a07db0cec24f17dc4241", + "realization": 7 + }, + { + "arrays_sha256": "b931272609f3eb15020e66e401100582a71c7a9292888d3fedca410c236b7f2c", + "metadata_sha256": "fe18e4ec7936202125b779892a2a87c2a61cee51c4d63cf7f4c73dd8aab98005", + "realization": 8 + }, + { + "arrays_sha256": "408e946141c6f329f80bdc35ed9e1edad6ac6c22ba4a5e1b24d2c4e3beb7581e", + "metadata_sha256": "7fb358b2d50756f677c2ddc85df95c9d5ac1ded2f5aca13a129988db7591bf71", + "realization": 9 + }, + { + "arrays_sha256": "db02f0e93d4fc12a99b91559827397088461c55b6e72dfd12d97cb79338b0d5f", + "metadata_sha256": "4e07b5fe0348c45353edf16a294585f844d564379ef29b4e2b3b17ec8fd98c7d", + "realization": 10 + }, + { + "arrays_sha256": "3de270bea118329e8b723da7ccafbab298eabe715129085467ff54c3a494c6e6", + "metadata_sha256": "21d9d2f04ebf122dbbd94da79454bb6a56a6e539c44ac71dadf64ff7167de035", + "realization": 11 + }, + { + "arrays_sha256": "e6711bdb0face28fd3ca87cc9ea19b3ed8a747ea366e32724b46bcb5a9fca613", + "metadata_sha256": "de987752e9375901157e3af3bd16c698823974671b81d32566a69ac0ac44b647", + "realization": 12 + }, + { + "arrays_sha256": "fca154901f7dd4d268829d7413e22874f1e5a3a2efd7231f8a0b208a914567db", + "metadata_sha256": "e93be2c5389d6d241af82086921285a723062cba715b150c04f709502d0f56ab", + "realization": 13 + }, + { + "arrays_sha256": "c31dc61f02b6199c0ac8cd79a799354a0fe1f6a803e3dd42a295c35819e7aa4d", + "metadata_sha256": "99ab8d207c4b250444103927595837b6240f1172f7554a784584dbbafb33a80e", + "realization": 14 + }, + { + "arrays_sha256": "0d4a7ad82648c7ee29c65e559ee9292ba65b54c8a354fb4f9f68cec6af66c3d2", + "metadata_sha256": "30495313fa1f672c65be246b221e0554eec8b6030968d198c3c7f0a3d76d75a2", + "realization": 15 + }, + { + "arrays_sha256": "431439e7d8ad73f3a568678d9c855d77b457c28770eb52719f3f6d6a5e64c8a0", + "metadata_sha256": "c276e6ca46c2dd94001d3c1648308cf868878b1de68c1f16c6425b6beda4b750", + "realization": 16 + }, + { + "arrays_sha256": "99e0bd87edc55310aae8af1997c94fdbbade63ecea068f614d34f1ec15810315", + "metadata_sha256": "0f82ca3f9c65d5b1850b0e44bf5478a7abf457648218f576bba819d1cfd69fec", + "realization": 17 + }, + { + "arrays_sha256": "a92c415feadc8dc6c2ad654cf83b647b959f5e91252163afdbde00f7f9258b45", + "metadata_sha256": "ab67138b59e947cd5c4bb07d7e309cc471c6acd6cd250a0c8cfb99b5ca1e6361", + "realization": 18 + }, + { + "arrays_sha256": "1b92631e9fad6ee80b6b185e0caa23dcf06097fcf9483383637585d49944f45f", + "metadata_sha256": "a3df9828871df88b4e77be73512662c7e36e5ac13340e20285ab225701af7094", + "realization": 19 + }, + { + "arrays_sha256": "1b4975d38023701021c4b115916373da82bdb86ec99013cf4f24a5e74f0dcd0b", + "metadata_sha256": "d96e8c451541829f2d9b6644dc6c188bed0b274341dd48e01b5b9424e2155c93", + "realization": 20 + }, + { + "arrays_sha256": "49f1dbca6d4054412c5b75865561f484334181c756c5898d7ca641aec58b402f", + "metadata_sha256": "b689c5fb6eafa195a71d522a19db4e89193bbe75fc373fa14d092379a55cb2cc", + "realization": 21 + }, + { + "arrays_sha256": "3adb50b877d659a188affbe1284705bed52acab0e3f86c067fa404b616892700", + "metadata_sha256": "da153de75d222415d97486bcb1072f194cc2d37d7b002e6ed8127a0661e67acd", + "realization": 22 + }, + { + "arrays_sha256": "47a695f672164f3a33699ce2e1b99b5727afab3ca9b942edfe879d001da2fc56", + "metadata_sha256": "7a10118815bda349a676618c0341cda6d46839bbf7c80de58aca22fe0e87a4e1", + "realization": 23 + }, + { + "arrays_sha256": "029a04422d219b68839f8df27c804ebad59161b86cc0263bf41546ef0e1d9162", + "metadata_sha256": "a9ff3e7876960b9f275385115075d1ba5003878e7546812ba78ac3b4fcf417cd", + "realization": 24 + }, + { + "arrays_sha256": "13c5d8529e9535ea39d263bfff5412f996f02792f38f7863e38470ad1cc024c6", + "metadata_sha256": "6a6433f5f5de958514078c81778b8f07a46d9c34d65fb986ca9eb3c4c643be86", + "realization": 25 + }, + { + "arrays_sha256": "ccb747c0009d0273f1c0858563676dc02dc77d54d6bd6a75e9a175098ab1260e", + "metadata_sha256": "890df8232a0b26508205d59e67fe2595f20514544716e0107d876dc80af689ce", + "realization": 26 + }, + { + "arrays_sha256": "5eb3ccdc4edcbc1a74bf156eba59be0570dd80caa9e655670261501783214875", + "metadata_sha256": "24dfcfb26a7e37e869a6f629ea46011e453c832bfcf58a423094600aacd0bd6b", + "realization": 27 + }, + { + "arrays_sha256": "b2f1a88df71f88090bc07c02974a2c6a89fe25cd476c2c7145fc33e354514925", + "metadata_sha256": "78573b337ff8ed27d60c39ec7636fc7e908248f24a16e1215c60937c7eadd349", + "realization": 28 + }, + { + "arrays_sha256": "9c01e1528b5e71a631c210c2924804fcbe429e8b152430473ea02a004e415d8f", + "metadata_sha256": "486f28c8b25cfcc6e82b5d8297246a096c9cdf6feba2275367313ac8bf32758d", + "realization": 29 + }, + { + "arrays_sha256": "de925274f03b6822c95e9a9e60c6865792d51c754d1372b926e1589548b5a906", + "metadata_sha256": "85212b60b75a5fcf320fd5bd071d243d3f9ea1cf0a66c1a263fef1ae328d7332", + "realization": 30 + }, + { + "arrays_sha256": "73abc7fadc5943f3e371fe39510a1a8cfb42a588fd99feea7c47f3be9a36c9b7", + "metadata_sha256": "ad175bf90bd2d22242111e38d8e108046fe80d4144214a16a4652e96f28b848e", + "realization": 31 + }, + { + "arrays_sha256": "330023e7777fa868dc2f3be5ee110db29f6d0db3ebf47275a153ec3a8d99b2fd", + "metadata_sha256": "68dd4b41c27313c60b61519cb1efc4e00ae42476b0ceb2f65d13e379805dfc66", + "realization": 32 + }, + { + "arrays_sha256": "9890d5deca1a463a25e0b99b8f8eee8243bca48591eb93a51b18d5944bda3159", + "metadata_sha256": "9c49f1854906b0d06c2a732c1a8c830517c9f06d0ee51d58d6b32f80e100bf23", + "realization": 33 + }, + { + "arrays_sha256": "a665c418bcddb1b8d132761326c9224dc5d5d770ec78fafd7ee0726d62c6e13d", + "metadata_sha256": "984bca1c4e65275c31ff37e24dca3f09d1cf1f606ca7dadb4889a9491056705f", + "realization": 34 + }, + { + "arrays_sha256": "9a77fc8739d04810d259338f393bf5854a0530f99031c85b93d05831c7c53352", + "metadata_sha256": "5fc39987664b517a7eddc8128483052c39f398c2a5578081435dece2c72d0f84", + "realization": 35 + }, + { + "arrays_sha256": "7bb2f7f95c2d0f1b9cb5a65c24ef6f8c616426e3b1be11642304c03e0b5ad301", + "metadata_sha256": "fdfadff76f8e0ae41223c5e3629e11c4e8bd2f29edbc29a38a51a66dc19af58f", + "realization": 36 + }, + { + "arrays_sha256": "5fd163805b1740e204e0dc27289e10706058f5cd1101a08506d9810311391786", + "metadata_sha256": "d549454affa56557a08bad26cf9d11cbac684cbfd629becebc5782e863915630", + "realization": 37 + }, + { + "arrays_sha256": "23a195b563acb5097dd19c7ed8afe2365ab3f58bb3de245ba56e9749e6fbd489", + "metadata_sha256": "74f57255fce8100d6c56387a71bc1b3c8b65b7354547668dd71446c0deb8662d", + "realization": 38 + }, + { + "arrays_sha256": "5f9a5e23263a1732804da280b7126a174b4a79061df4964c1fdd21ce8c00aca8", + "metadata_sha256": "f9325d6f93cf3e7a8e4b5c175aa49307e879726321d34dbb65eca00767c6ac60", + "realization": 39 + }, + { + "arrays_sha256": "d49a73f12de2f91f7d4440fb6e4c5e94c2c0bfedfd01f2dbe5c6bacf786cfe04", + "metadata_sha256": "0db556c44018f4a8b0662f5be51e26456826dc7df0ac43ff87bf2d8adb089d32", + "realization": 40 + }, + { + "arrays_sha256": "f7f425f0a8da29e6455aa475c978f69f0e1916f8cf2617330205bf9bc47d0d67", + "metadata_sha256": "a2072d8f9c039bea203f5166f2b34c50e3290b7c7c773ba34a1e4ff04868685a", + "realization": 41 + }, + { + "arrays_sha256": "1e7f29486b734ccdd688356d935e82fcd0a593f1b6129f08b6dba8c73ffea436", + "metadata_sha256": "36a7b08cc0099af10daf95be5f2d27dede343b2dca97c04b93e340773457ce20", + "realization": 42 + }, + { + "arrays_sha256": "6908b8506dd5d7004148252d16789a9d65e17edf980d8adaa5cbf03d13ff079c", + "metadata_sha256": "eb1a31d36e18f5a6642387f4dd20fc860f9f26889284f6eb7a2e1ee8d387942c", + "realization": 43 + }, + { + "arrays_sha256": "569ae8f1a16d1639a788ee6e8f1fc2c2eaab934fe1acc5fafa9704638c8e4e55", + "metadata_sha256": "8d77cf21133a784cec69b3e0c65ff646aa72ce6e5cbff8cb907f5566c71b7ee2", + "realization": 44 + }, + { + "arrays_sha256": "734c979a770f410286b73cd76db4fabf6d194c27a7ed6a6b2185c08e84cbde3d", + "metadata_sha256": "396056b5b183bca93e3aed9444b3009810871894d7799d8e67bd6b7985b0a53d", + "realization": 45 + }, + { + "arrays_sha256": "cfba4ff746bae2892104da8654780901c9ab7ce808670337c3ce2528b62da246", + "metadata_sha256": "9c1ba26d020bdbf63d27a1038448c40c850068ee4f77d81b4b3390c24c9000ad", + "realization": 46 + }, + { + "arrays_sha256": "ed24695abbe170efa0613f9fdf240971a98a0f5a40782a6a92f8e6100d6c17c7", + "metadata_sha256": "969215461bf3db8badb6daaeb9001dd0f7374ce68410370b1651a03513cbe121", + "realization": 47 + }, + { + "arrays_sha256": "866cb66208a82809f74bb0a409d39b569e53e318f5265cad2db3acfc43e89fa3", + "metadata_sha256": "b7aeda3dc42b53110c706f52751318bba5b10392de07774d34aed63c3f758cb3", + "realization": 48 + }, + { + "arrays_sha256": "72db63adfd1167ecc2e5912f48d701073f6f8f4e5db61c712e7d7543fc8194b7", + "metadata_sha256": "298ceb76d555665228110ce4252bd971356e8931cf71a1d36c308ae7aeabb356", + "realization": 49 + }, + { + "arrays_sha256": "863268d37866f152cd5c9a2becef7237daadfbc2122f71c0e5ec10a4352c0ab8", + "metadata_sha256": "5dd525c35dca35439cc25619dae9a790ce36725c5096d8ff2991c70783e0ecf5", + "realization": 50 + }, + { + "arrays_sha256": "f85893e26963276b8367fd1a8b875204e6a7e891a887a9aa89f135b00c0ddf7f", + "metadata_sha256": "c56e1082b6f2084ca9efc53ec5eab9c96384bc55f86f84c353170fb4d2f89077", + "realization": 51 + }, + { + "arrays_sha256": "39448bccbc2120e74ac49370c97ad34efa9ff633431a29bf3fdfe55244c03e1e", + "metadata_sha256": "2a7df86b4bd372607301f9187c8acb4ac9bdfbe408f20be652494e65a0be55b4", + "realization": 52 + }, + { + "arrays_sha256": "f740c7eeebf10fb013180c1b2ba47d00456b6eccf1325a6733b4a301927a65f7", + "metadata_sha256": "ac8e0688e14e20e491e302f7d9a97b181238945e7c5b9cce0b53e0876a852b66", + "realization": 53 + }, + { + "arrays_sha256": "f12ef37df82b1182aed31c4092cacf8dff81a1645182fb3ff27f45d61b78adc7", + "metadata_sha256": "c650cd63c8c8c9e8ade52427356f9f598e7444ad6ced2c90d36382233e8ead3d", + "realization": 54 + }, + { + "arrays_sha256": "98aef7e4fb60148cc5e2cc3a7e2ae6a2c9c9af24b750e6f48438f35c3d25322a", + "metadata_sha256": "f149bee8d3985b364990d9f8f9ac5c928ea93199dc7ff01c84164b43a2a03a89", + "realization": 55 + }, + { + "arrays_sha256": "246d697b95feac151aa56b3c677bdf5c2b47a0143f05d110b1d17170c826a218", + "metadata_sha256": "cbecad8c707eee086fd9ff9e4dd96ad0c6c7e811b07277335b4359eaafcb0305", + "realization": 56 + }, + { + "arrays_sha256": "2c34ebd25a6d40d48060e94f157dcb4414994f131fb8f538c152580cee4afb2c", + "metadata_sha256": "703a4c7260a8e1371a4e25175d4769fd7b6bf50898cbe0fd8f5bc486ab24ad16", + "realization": 57 + }, + { + "arrays_sha256": "0c54da30c345a8193ca7073bfe6fdf8cc9ea93d6400e82cb4ad10f6bd1124e18", + "metadata_sha256": "1601c5a36a2db031792a851eb1f1e685c0213e9311747f46d19c169163dd8951", + "realization": 58 + }, + { + "arrays_sha256": "99ebfd4d0242ce2b513912e6253afb679c1f7ae184ad27e14866b4c09e9a931b", + "metadata_sha256": "d4de7ad8ba0200770e9612579dd6b13509aee46f62a1048be7ca9c29a7df1aa6", + "realization": 59 + }, + { + "arrays_sha256": "1fe481efd484f2edb5dfeb41cb670e5f0cc45274a4ea658be68ec9e67354a467", + "metadata_sha256": "466d3a9e1530fdd4e8d5dd51a7f855f8e151a158cd0c6ff60f6e6696430d781c", + "realization": 60 + }, + { + "arrays_sha256": "07a1df017c333c5b97c1500decd094e483ed5a7d767d5e8b5cc54007174b6b66", + "metadata_sha256": "e2eab424a3fde3a834bd6d89104efa1b4a3a6e6ee7152236817e57362b313e5f", + "realization": 61 + }, + { + "arrays_sha256": "0de1e1d2fc2d0cddf34f63904886e2ba75934e5f6b7eb1b1a797fadb8462bcf8", + "metadata_sha256": "fac4cbd109650d742ef61413b323d2d307e9958157a076cad34a50ae4c14d686", + "realization": 62 + }, + { + "arrays_sha256": "5b9fdf05a75a1655f2b2e86193142792bd62056eaf28955c087b3debd67f8a9d", + "metadata_sha256": "94aad428ec867a5a63956a87b0f4018e2012703493d2058b9a0fdbaf0276ea65", + "realization": 63 + } + ], + "observed_median": 0.3588778773960463, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3467447519390082, + 0.3720889925062879 + ], + "realizations": 64, + "sector": "central" + } + ], + "null_replicates": 2000, + "passed": true, + "physical_bootstrap_replicates": 10000, + "prediction_coverage": 0.975, + "safe_covariates_sha256": "e432c45725925bf44a128a2afdf8bb6a2d5da86ea53bfdcb45e0efc9ae4d9516", + "sources": { + "analyze_susy_hodge_geometric_eth_v7.py": "ddaf04888905bdaca031c1e4a6119fa1cfbf4b126fd115ba775ae6c0a6a9338b", + "lgeth/hodge_wick.py": "f80fc96fa1408c0df2e15d4f804bac17feef9c59e9fbc511dd5052ef591e04c7", + "lgeth/wick_channels.py": "e1faedf5c98f660756e077445a88d05013bc6810f5b0f69aa8fc0dc6fe13469b", + "run_susy_hodge_geometric_eth_v7.py": "5e19899855b917a8b455510ce76ab47ac15396395668ad0538b7137caaec9cbe", + "run_susy_hodge_null_bank_v7.py": "ce16015e03e721852c73be952f24990b02e45cf787545881b96f42c1271dbc98" + }, + "uncertainty_unit": "complete_disorder_realization", + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_banked.npz b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_banked.npz new file mode 100644 index 000000000..6b4e5c137 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_banked.npz differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_combined.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_combined.json new file mode 100644 index 000000000..2ba1fadfb --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_combined.json @@ -0,0 +1,3244 @@ +{ + "arrays_sha256": "d1061c85fda0fb91b2974fe7389f577b6b657173b1f906e41868674b12d0cc6b", + "checks": { + "all_sources_passed": true, + "common_complete_realization_protocol": true, + "complete_array_grid": true, + "complete_registered_grid": true, + "finite_arrays": true, + "positive_registered_counts": true, + "unique_group_identities": true + }, + "generated_utc": "2026-08-04T01:30:53.737870+00:00", + "groups": [ + { + "N": 8, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.28774443822769635, + 0.2923719696932815, + 0.29747553580253777 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.3059263591384163, + 0.312032433068657, + 0.31831694112765746 + ], + "median_hodge_balance": 0.07040982426906839, + "null_banks": [ + { + "arrays_sha256": "7e4e820c450f1e3921d889e56fd5dd8f1cc0b85efebb0e01082f72896eadd975", + "metadata_sha256": "3dfd016bb6cffc1bb3cea44405bd5280344c764350ac059703b2cd7af9449afc", + "realization": 0 + }, + { + "arrays_sha256": "5f2b5ee2045d7e634ea2eb75be49f59d044c694db0d31dd96b554075d16baf64", + "metadata_sha256": "426b5d1187b3c2609ffc029b233659fa5d7f51dbceb53049b1411582ce42a2c7", + "realization": 1 + }, + { + "arrays_sha256": "e821d455d25eeb8440515614400268c3f0091781c64cc042d2447b8056df6259", + "metadata_sha256": "b2ecdc748cb7bafdf6ae3709e2a4a32fc1db34ed18e5074f5a9d103d7131f2b0", + "realization": 2 + }, + { + "arrays_sha256": "a7a8d2092c29178d35912a48018e334d1d8e025a24288af6ba3a3e2ce65eaec2", + "metadata_sha256": "3206a8d888f29b824c67418a84a5c7b7dd7c2d2318c431a9eb358fbe52609375", + "realization": 3 + }, + { + "arrays_sha256": "8eebc9f3ff729229002bbff88eb1599faae9681fd7aec883a3c73e0559a2a826", + "metadata_sha256": "728581e912fe0ee4cbdf3066fdd0dc6160bdbb82dbf258e515e0d11e28d73fd8", + "realization": 4 + }, + { + "arrays_sha256": "c613197503272fc266f8aea0f6746f3a16c0e9c4845ba71c91f5e4d9df165997", + "metadata_sha256": "16357f2902cfb4cacaa672f9bec6c8882756684d39de8ec27ee3f0739abdd840", + "realization": 5 + }, + { + "arrays_sha256": "584c834366b823aee9effb07a037b555f39fe7efc3a24bda79004f52557d8c4b", + "metadata_sha256": "8f3bacf052da6950912eb5ebc5776e397806bdcb25928e68e8774c94d1465592", + "realization": 6 + }, + { + "arrays_sha256": "71a95506502428f05bdbd1fed08f5bace55dac555c8975f99f53ea65f0bd2e87", + "metadata_sha256": "9e05a0d39b40afca583d4950bd7fc0df1cbdc15b38406ad50e28fb2846b21a3b", + "realization": 7 + }, + { + "arrays_sha256": "85c77b070a9c54276bc752de236c1c658f3f999cd1b92f0ecc53f0a8649ea71b", + "metadata_sha256": "3dce74e5717170ecad93c4de0e68a4454cb19be3df4706c8ea024a4241faaba6", + "realization": 8 + }, + { + "arrays_sha256": "a9b039b58718984c9643c6984dd524ebc9bbedcaa82140b530ae5f698f755b36", + "metadata_sha256": "0e4f603d7eee9972673ae54f75878e0534dfe5defac2f785ff60de1648baa301", + "realization": 9 + }, + { + "arrays_sha256": "90e82fda00d060444958a4b38f7fa5b2728e91e7b4fffbc69aca75f50ad852fc", + "metadata_sha256": "574932aeb9b422627ba393a783a7fb8924128448d0d1ac51302e1900c60df1ba", + "realization": 10 + }, + { + "arrays_sha256": "95b821b9a32ae48211a34b3b8819e6c0758a041f7a6cbb471148d0fabebdaa2b", + "metadata_sha256": "217223c8912f1bbe708dadb2e0a12ba9fa5e6b36e3a6bd583d4f864bf0c41637", + "realization": 11 + }, + { + "arrays_sha256": "f182e61e5d9880bdfe13b1e7b148ddebf13bf12e00e018798fe85fda84f00490", + "metadata_sha256": "2c9453e6cbeb420dc8a6cf80a7bcb33221f23a7594610310369a79a30c358e1a", + "realization": 12 + }, + { + "arrays_sha256": "d9634ea5aa3830b539c122ffc2024ceb09ec73398d23f785baae66b001b66fcb", + "metadata_sha256": "ba0d05489fc8d01eed51fc4c1eecd10ac981e9df32b9080cd80cc4578ac2edff", + "realization": 13 + }, + { + "arrays_sha256": "85e233efd41b6223f3988f25135d922407ad1f0c288f2bef39b718f1d529e35f", + "metadata_sha256": "5b1ce1bd4f1e6fbab140cec48b0b62bc2f914b10b4ccd43efdef40181eb4b469", + "realization": 14 + }, + { + "arrays_sha256": "e4289b64b3dce047b9fd985f6adcdc0a3e3252f7ff3b8281da3d939092b94900", + "metadata_sha256": "cac306e55cc899f1bf75bc99ccf1c649e342b09c325229724acae01529109365", + "realization": 15 + }, + { + "arrays_sha256": "a63b9e21218662bebf0c4d088c4b2c839e6bfd28fe3bbc0261f6d01fd5006249", + "metadata_sha256": "744076addebecf804a815872fc7e81114ad6a9d71ca6f28a81c111e8d3788ef7", + "realization": 16 + }, + { + "arrays_sha256": "b66785aa3497256bb2cea0b6a986c3bca2fa26266184862c65f90112421a555c", + "metadata_sha256": "5bf89be8cd9fd3f57a2618cc003767bb31981e2f968b6ca07e529643b6ec5b36", + "realization": 17 + }, + { + "arrays_sha256": "11e79fc31c5cc3e182f8ef0f562a2c87ccf634d12a1db3076bac07470d44dcb1", + "metadata_sha256": "9e739c2f1ed1871341c81027a95e84a55be69b335b8a7b140a0419cfcf409c7d", + "realization": 18 + }, + { + "arrays_sha256": "d97a9e0429300a547d19779538fd414a0e9d2c2d5bfdaa67cb1b3ca5cb2a6b33", + "metadata_sha256": "6fe0176819c9e58364ef790a9eae7e6611961f7bfcef945880306110dd915f65", + "realization": 19 + }, + { + "arrays_sha256": "ea18c6209433f98d01e626e32adb32e7f3746ead049030007824f8354f678ba5", + "metadata_sha256": "aed9b8af87dac7d5a7a957998217221d289301db393cccdbca049f515bb0d80e", + "realization": 20 + }, + { + "arrays_sha256": "dce799fb13a12d2b60416f3ab8cbae52488cbaeb416c3d66a81d394eb1ebc824", + "metadata_sha256": "db22fcb0c7126ef751ffca375878c37f5fdf4885e3e2c62f4b2c01b50cf9cd3c", + "realization": 21 + }, + { + "arrays_sha256": "7f139c15fecfd3bd6aef20c2dac7990b820632f4746dd896582be8ddef362150", + "metadata_sha256": "85b3979fb070e3c863d83fb7fd6d2a37d342a1f26e70c6e09da64eab06496d6f", + "realization": 22 + }, + { + "arrays_sha256": "e4a16f1648a879ea59b7cd2d115741020af65ebcbc8ebf27af067ff935a3a25e", + "metadata_sha256": "3201185d7b672b7e48ce3eae311a5236305d989e99b6ee377ebad0f474f91270", + "realization": 23 + }, + { + "arrays_sha256": "b33c0d85db8c3dfdcf3abbfe84699e963fd790b9108b8488790c7cc18e95dc12", + "metadata_sha256": "29a56b3311a1f6afa2af8b5b9d69aa752523c44103d9a6652b0ed4e033b4282c", + "realization": 24 + }, + { + "arrays_sha256": "69eaf9db38244cbab7e0a89673366293c994f5c8bdeeee19927d6d3e5d8c5535", + "metadata_sha256": "1714c7aa1d0d396fce816046490428fca0685ff2bce1a98558195430dded6c97", + "realization": 25 + }, + { + "arrays_sha256": "99c7786255d17f345a12fed9a1bc5e14f9fef6038df201c4d6b45b6bc3c026c0", + "metadata_sha256": "8d815aaccdec229e70760c18f4dee8a588faf9b6607b6a865cdedbc2e936ef3a", + "realization": 26 + }, + { + "arrays_sha256": "1a0ac3542fa92251ff91ea6d34b14feb35b747aa9bda371a5e70acde9aaf422b", + "metadata_sha256": "8c5c71f09ed0e9515336909c215494c03cc31c4bb93364fe5f2f980bc59743a2", + "realization": 27 + }, + { + "arrays_sha256": "7ca331246d1467e2c96f4097f5ffe5d72d2960e6e25c4a19dc56c9e9d0bd6868", + "metadata_sha256": "c93aed73436e1fc63abcf3ada6bc560fa2b424a83fedd38333198e5419f117bd", + "realization": 28 + }, + { + "arrays_sha256": "4863b7c2f3e14f69b89b42cd8cc2c1f1fe9c59f3a8b70ea9c38245277cbd881a", + "metadata_sha256": "2262f4eb6f11bf168573f431e63f5c9f508b1a05002f60a8bae31bf994f41383", + "realization": 29 + }, + { + "arrays_sha256": "415755781cb1e33e7765b8ea14cd908c4d7beca78546123e66b0c04e1953c20d", + "metadata_sha256": "f28edfd549d07cf345b7e14cc4d213776cdaaf53d1d30679f938611c0bb35ce6", + "realization": 30 + }, + { + "arrays_sha256": "a3750fd2d886546440304c53b32133fde8d98a063935cbd6e235d34d58284ae8", + "metadata_sha256": "b14943201c15195b67b2bafefee856ab80fd1ffe1356d97792056818b85ebf5c", + "realization": 31 + }, + { + "arrays_sha256": "d02260472d42a4842285518d8e1c98c576c0b1463ebad8c4b215da7332450566", + "metadata_sha256": "46970f4a17ccd61a3b30029bdd6f96e2b5dbd806f17d7c14abc80d2996ca7c1a", + "realization": 32 + }, + { + "arrays_sha256": "81ff3b0e0317c3bbef179366f3349b5c1244b5b2a2082a3a7d0b62ea5195666c", + "metadata_sha256": "411acdf5488a70841b15c5e89dee4c7c3b2c2592b8a5a78cc5f89703fd5bd547", + "realization": 33 + }, + { + "arrays_sha256": "d081b259e270deddfec2893fd445246d6a0664f9da9bbdecb8496867d30ff8f7", + "metadata_sha256": "eb281ffe125c7ae297d34e8892686e788c10cc5626d42d8566b02dfd8a499658", + "realization": 34 + }, + { + "arrays_sha256": "fe7caf952a54586ad05bca871603d0d73281ec9ed7d7d87854d92a87ec0641a4", + "metadata_sha256": "f94011e8d522a44a8bf42e8a38c92efe8102a5ea01ba84b5f4a2d37e7853a13e", + "realization": 35 + }, + { + "arrays_sha256": "2166c1c4df9f59ed10da26646934950916dff33df3e780103e2701cb5d88d619", + "metadata_sha256": "305b266fd5ce59d2fe2f204db5fa402211862ac10b5c0c6482112f61e6c111cb", + "realization": 36 + }, + { + "arrays_sha256": "ef1ac6691de4fd6cb8e48a888e60d68e01125e554bc24f22e100e89e04b6a08f", + "metadata_sha256": "246e59a96bd94cb8ba7c3dd19ea8c3d57e0392f24145d7b99088762e0ae59301", + "realization": 37 + }, + { + "arrays_sha256": "fdf76204d2d7f24750a9fef68c19e4a56a5754b97dd0586a6fdb3aa11209488c", + "metadata_sha256": "59cae7517ada9bfeb4a2f20f20560e9eaf41dcfbc8d228090cbb4a2df9211fbd", + "realization": 38 + }, + { + "arrays_sha256": "f73e711baec36161053aecf09d3a427c3180bd8c28d6aa81eaa466d866c7aa68", + "metadata_sha256": "5a85797032a5e103652761faef137c1567f74aff1a8efb394c08a043916b5a02", + "realization": 39 + }, + { + "arrays_sha256": "9ef7f26b96c37b046e48911784430b468b31f2c1e5c07f7d54c30efc572141c7", + "metadata_sha256": "3d6aec77022cf4a9d9e2949973e2883dfb0bf0a10ac855efa7ca9db6fd049318", + "realization": 40 + }, + { + "arrays_sha256": "4b34e6df5d11668e4f57bf92290d53f537978023ccf8f7fbc1f19798d5e952b0", + "metadata_sha256": "4d3cff581ee92d10c2686166a66ee7c6ed8f5d301b0ab2db1e21b484112019e0", + "realization": 41 + }, + { + "arrays_sha256": "f0ab0be182f4e781204bd2b458e07b76db9754719ddaf4cf3955b22b6c2511c9", + "metadata_sha256": "d317a01ab9e55a558685feb6257548d668ff19d87bf7103ad2f65b00e120b4b8", + "realization": 42 + }, + { + "arrays_sha256": "221b995bf5de99c432d7846a34e9850f17e9506e01bd67e7a451c218114f4e27", + "metadata_sha256": "d7de9f96ebe541888c47333d513a9a67e1d7e34e807734574df294c68246f92e", + "realization": 43 + }, + { + "arrays_sha256": "c4221bacaed1027386e3acdbaa64e01130af7c2fcad5751167760d3835698569", + "metadata_sha256": "d45d62a5818b7d58e51f7208ad437731e39a33cf70c044e344b31c53bf303558", + "realization": 44 + }, + { + "arrays_sha256": "3a3fafe51d483d7e40202a2dfc1b460f340bed00ec9a9d9d9c400835179ad1c8", + "metadata_sha256": "a326da978a071e34046484e268cabb488ca18f8969246b748971520050cba300", + "realization": 45 + }, + { + "arrays_sha256": "cab548f23cb10decca232fae69b30a41403b925e8a4c444fddce5bb69c711818", + "metadata_sha256": "99aa1416434f28cbc606b0048e495a80788435e87927e8d812f9db55c26689a5", + "realization": 46 + }, + { + "arrays_sha256": "b7fcc506e264de69b2ad4b9a74bc3b1385c04650099eda48f4a5639d8562f4fd", + "metadata_sha256": "a842c741f0121fde7462cae5bf009b388cdb4e7156257c6d82cec863671df4fc", + "realization": 47 + }, + { + "arrays_sha256": "51253eab4bed3429e76c4e9ee66d1d6468ffb1d562121511f7bc30db76f7e2e4", + "metadata_sha256": "3e23a7e3ad54c83a17abcb6124210f1ec9781ce83e3872db68de32cb337380f4", + "realization": 48 + }, + { + "arrays_sha256": "3daff8369b98eb6fd41cde8dc3b215120335a180a61e2b79248387a650e3cf01", + "metadata_sha256": "8047d6dddc4a9ac99a247c9898d573650d37256efd8e83213549aa952ab3700a", + "realization": 49 + }, + { + "arrays_sha256": "aa704cd81fddfa33539ec459f4fdea4a0582708f77c78f6543b4e599a1fb611b", + "metadata_sha256": "2b748867ac598bc7389fa696c1739ac6d24f7250861cd0efa2ab1dad1faed673", + "realization": 50 + }, + { + "arrays_sha256": "e8560a879d50cc5b66a80eacfde868b7000e220494a1dc553f5f5c88974d7605", + "metadata_sha256": "cbd0ab6f3732bbb36f7304f235f204f0046b6a18c190a468587be3b4e4a8e37f", + "realization": 51 + }, + { + "arrays_sha256": "cada546af06194ccddaa2142fd30c1d14329661c3bda7aa3404840ea46e5537b", + "metadata_sha256": "0e8dec3026aaec22885686ae085e8a1a8bcd0748c082980e5681d88d19f235c6", + "realization": 52 + }, + { + "arrays_sha256": "df6001e2388006de4aacbf7f32756703d75148aadda915402e96593003bbadfe", + "metadata_sha256": "da5584cbdc11b39ef50f8d0ebbc7bec11cd29cd49c69808dd69076ca56944469", + "realization": 53 + }, + { + "arrays_sha256": "25d9143238813a04dbd6b7d7c9ee342b45b51396232506b2ddf0ab5a83530e77", + "metadata_sha256": "e199dc888ea7b2de2fdbc5c77b18e75fd57f0baace859d05467a01c5885e66be", + "realization": 54 + }, + { + "arrays_sha256": "34fecbd9e49b031a2b65ddea5df32c8d71cff5aff67ddd276f188cb6db1f7209", + "metadata_sha256": "b63c590a9d8f2d1f6ebdb8e61bb2442957cb9dbae5c8ca5ef1dfc979db8a6a45", + "realization": 55 + }, + { + "arrays_sha256": "fd50eee8d0f350f485ca0db54f3cd3a9cbd5e1ca732b5834c5412e8bd35dd93d", + "metadata_sha256": "36a333cce5f66ca8dbc8a63e605984c180decc4afe1663b8f3f2d5fa169dca38", + "realization": 56 + }, + { + "arrays_sha256": "e715721223022dc3f2ab7f1d23a1f72b288e4bc522442d0e60fd60fdc5e64e61", + "metadata_sha256": "0fd84230852654f9dd0ddf0cf48ca2b15e10fdb7b7c3f5490bf0549af3e850a6", + "realization": 57 + }, + { + "arrays_sha256": "0a942be9b78844be357d2fb991b7e5ed179137a1163e5529c0606e6f32cd136f", + "metadata_sha256": "52852b5de3339bd8c87aa38f4f06c36e0bc3c2e4a46bd1f9c6b5ea70887c937e", + "realization": 58 + }, + { + "arrays_sha256": "6150f9dfbe18411bb31643e60184a91df5f3df4ac00c693b9cb085957696fd01", + "metadata_sha256": "0480543c0f755af003017ae43b9a9ed13704be65511a22b572ef833e49785107", + "realization": 59 + }, + { + "arrays_sha256": "754135a046b184931081182a8fd0dda67a61a0378621372d6b960d682910ba1c", + "metadata_sha256": "984d2758dd685732330d632f32d08cec2861a32abbc4d09e5bef6ac6af7f302a", + "realization": 60 + }, + { + "arrays_sha256": "a344747a67f2f0e6d54f6b94e94ecea6db7b9e5a12c384f618ac5ea7c29e9aac", + "metadata_sha256": "9565a1766c17b1daa4f63f5c831e7d4881d93119824c342711ee83a6752ca797", + "realization": 61 + }, + { + "arrays_sha256": "515a473de52604c2933aeb366b8fafc1579882b73e8636df2aeba9c89491d03c", + "metadata_sha256": "97b75282143c51c703db365b08703b5858be2c7cab60d654d96728cedc84c140", + "realization": 62 + }, + { + "arrays_sha256": "1b5d28ce95123d9ec301ecbd28149273f82867bf85eb5d1aa948907beaf532df", + "metadata_sha256": "d694f1efcc1aac6fb6cfed8814335d0962501b5d7c3697a9fa3de2bbce443611", + "realization": 63 + } + ], + "observed_median": 0.3473456476442244, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.33998881412401927, + 0.35539578968897517 + ], + "realizations": 64, + "sector": "adjacent" + }, + { + "N": 8, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.3057881860688608, + 0.31137835043300116, + 0.31677833243100345 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.3277032710171455, + 0.3343214104998873, + 0.3415163074349069 + ], + "median_hodge_balance": 0.07146412252958581, + "null_banks": [ + { + "arrays_sha256": "4a71f07c0e5c660fbbbecc1f47560e70bcaf094ac5aad34213c481dd63d63294", + "metadata_sha256": "2d3ccaf2c6495436f3a35cdea0812600ffd81e86c601ad8ed1c938639e62fc1e", + "realization": 0 + }, + { + "arrays_sha256": "71293782f040eb92223ec4d01a28404b5008dcfa128d6e8fb218c61465cb0451", + "metadata_sha256": "be74bf29116fbc56ec295a1612ff586d6f5e660193ff9897816f40390c3f33ef", + "realization": 1 + }, + { + "arrays_sha256": "5da89d02f9a43808e2ecce2523bf58d48aad6721fe0b212e81302ff86f15ceaa", + "metadata_sha256": "766c99cd710239e31c833166c802c4e4ec87b32ddb94d8d0d36e2ef068dc59fc", + "realization": 2 + }, + { + "arrays_sha256": "85e3546836f0001004d949eadd2408875ce0afd28b7a0c0eab0c4fad24ba6379", + "metadata_sha256": "77dbc140d21ba6ce0ec0c0fbea9c0a50653cb1cd36c8eb92f75fdea196fdad8a", + "realization": 3 + }, + { + "arrays_sha256": "5e648686ba4cf787a59890896b28e778e5e4d36c2ea299280f0ff7b5b969be45", + "metadata_sha256": "f5d3c4c863059880f5c7a7478fa1c0a0ce8363c8db3981f081ceeccac7d147eb", + "realization": 4 + }, + { + "arrays_sha256": "36e67c8fbd0e1dbb536f780b285868edcaaf99a8155e16c0f02180cc74425d5d", + "metadata_sha256": "81335e0b0b365050aba8478008d953bdcabdb6dcfd51363a40f2328fed6c6ded", + "realization": 5 + }, + { + "arrays_sha256": "854b09042971e52f3e3a6cbfe343df9e5e84b0de0a6cee10dccc0f37689ba587", + "metadata_sha256": "6e50701efbf8d41c1fbe14c8f6b4c81625d58d81937fa80c6691a2762942b66f", + "realization": 6 + }, + { + "arrays_sha256": "2d856a13d486125679df3ca6ae055f9f9565e45ef13947bb6fa73d51a3ce33ba", + "metadata_sha256": "5f4ac976f9c23ec39e601484388f0e1a377d296db0da1e6260eaac6f35cde5dc", + "realization": 7 + }, + { + "arrays_sha256": "9ab3247bb2cb415755fef35d838e6c40f1d4715e314f2638f9e3ed86c54ae530", + "metadata_sha256": "96371d7cc16c6dd229bb9caa4e5d4b3c6b98f4d1663b4ce04cd3baa03787cc74", + "realization": 8 + }, + { + "arrays_sha256": "7a9032658a36ba78f329a12d1700cc2806756a21ddfbf130162086e5142e1b1b", + "metadata_sha256": "5ac1a7bdaa6a10b315e9ff0fa5a4e5f93a03b10fb43b0e213daee09ba1a14f79", + "realization": 9 + }, + { + "arrays_sha256": "883b7a5c0accdc3e3102c37aecbc208be1700269c96d9c8c27358b079cf3e1c4", + "metadata_sha256": "5050035111c33e4037fa8fae7490ad4ef89635de318e7dbb03b01e5eaf65fbb9", + "realization": 10 + }, + { + "arrays_sha256": "c60391692b0e21eab4ed30fb335b2e9952fdefdd3575a4b69f1091363c2eb967", + "metadata_sha256": "676f25bb5e1c501e7ab60abe68588a30ce885de0e9495692e81face631258aae", + "realization": 11 + }, + { + "arrays_sha256": "67d18ec337994ced9e8dfc5bd417346909c28ad3e97e40c7e9a1341c118e76cf", + "metadata_sha256": "d2d7c71deb94e0dca633ca8c85bc0a8bca18eec3f2bac16dc8300cc3b33d6465", + "realization": 12 + }, + { + "arrays_sha256": "048b43a21cb45cd4db4e0b5f218630ddad6b0d937f08e029b02a129a953db586", + "metadata_sha256": "0f0dcc77b32704680feb62cbff1ccee998f7ba7f549381bf06957cb663ad54a6", + "realization": 13 + }, + { + "arrays_sha256": "a1d17f2a560975a58f9c08ab70de6a906c75bac9877393b3484fed7ec84278fc", + "metadata_sha256": "fbbca5c43e077a2e5649f3d20cffeed888cd8fe19a7d0cb0b3385f32a447a465", + "realization": 14 + }, + { + "arrays_sha256": "6b95ee27b4ae3e3d6b92e3a4c8f102cf805b75131c3a8137ffd5c09d444088f1", + "metadata_sha256": "660681f42644933e010b18e927695dadf0c048b5cd9ebfe0649d2ae127aa9e55", + "realization": 15 + }, + { + "arrays_sha256": "1926c8b15068394570738a1656f75f03278b170272297027b72658e7f92bb9b6", + "metadata_sha256": "1bff2ab792c4c59212bb23a9ed74172f74bc86c9260053eca764457601269404", + "realization": 16 + }, + { + "arrays_sha256": "e3877490b22de8e07031d5c1326703e02000e33f00603a9527d4e0f7f075b009", + "metadata_sha256": "6a705795ef1a8f1ddcded46205c8a0f361c8bb864a2bbad0c48cbd1f79e0624a", + "realization": 17 + }, + { + "arrays_sha256": "30648db876acc8fb837a4cd3aedd9d01dcd4e5f3eae06695399fefa16f72a337", + "metadata_sha256": "370424291a045c2088bb953660c41ac0a00b45852c0073b3726782220ebe3bb7", + "realization": 18 + }, + { + "arrays_sha256": "830e11ada74fd2232d183f3128fb2323e12923fe6599ed5fb3a2c31e2914a965", + "metadata_sha256": "4bd0ae8e314541c0a57d8427f62d112db826a7f420f6488167a4e4aa884c5357", + "realization": 19 + }, + { + "arrays_sha256": "fb28182556675c28c562b9921f81398f38fe2288ae0cef95bbe4e8ba8104dd91", + "metadata_sha256": "b3f913f534d0039d253811b87aa249dcef919862c9cd843a78a748d948aacb73", + "realization": 20 + }, + { + "arrays_sha256": "cafc794c81de01d75221ec8e5e04453f88b6260ed8698fe22fb9388be7dc4beb", + "metadata_sha256": "a89860cdf5ab27770cda88f8ffaa8e91c3239a0bf778aae36bfe37709391eaa8", + "realization": 21 + }, + { + "arrays_sha256": "f8c520c802db0344ba4ecc5f04797156888b27ce8e2e443b64a5beea9ab8ffb5", + "metadata_sha256": "4ae10ba66002e7264b46586865f800f71daf912a49b62194fcd10562ba065d0d", + "realization": 22 + }, + { + "arrays_sha256": "b0e5b55b581e8b83429860a79c6bac5e4ba31c54363028ce6df12becf3f9c7cb", + "metadata_sha256": "d176cf6e32b5d8da3f398d54ca4a7da5e761862a9b511e9ba0484cd5c077dc10", + "realization": 23 + }, + { + "arrays_sha256": "e1871217326e24894fd7979a0adc93d9e7e5eb522c817d356ee034884f2c340a", + "metadata_sha256": "41147a25149bbac289fc3ce85896df3292dcf0b96da150be08b32507e1cfa39c", + "realization": 24 + }, + { + "arrays_sha256": "7b6ee2739bf964c26b53f7aa0a6107c87e8735a322a35dc7e0cae13fd362ed48", + "metadata_sha256": "2ca911d5db2e76a761f8182fa78eb910ef9d6d4ba13d520862270bc63837bf0f", + "realization": 25 + }, + { + "arrays_sha256": "6e36550760f983b784d91913f0e33cf63731524d733bbc02e4659e075c059c7e", + "metadata_sha256": "47b4beb8e00359eac1597ae2e5d2f00ec38b07b99067da95d3a510a7d43a2922", + "realization": 26 + }, + { + "arrays_sha256": "47ebf84fc14e2501b327381dfd72b607a1410c9a393689b94e228b426b4bb0b0", + "metadata_sha256": "985de16d4de9458e4508dac8f5ed320128da9e0444ff1395b9c49e3d36247287", + "realization": 27 + }, + { + "arrays_sha256": "8044ae04c63c5ae91aca8ba0727df048a5c42dfa3842f07aba4ce3fad5f233e2", + "metadata_sha256": "6f9444612258ea287649cf740c2ff5c852b202bd1174fea90b3ce241689211e5", + "realization": 28 + }, + { + "arrays_sha256": "3ad4725c4eb7adc0a285ac023d7e16bf86e5484289b7eea98bc8489f24fc9620", + "metadata_sha256": "1a17091f3c4413ea11d279392fefe449118916d182f0a0fefd0170cff50e3540", + "realization": 29 + }, + { + "arrays_sha256": "0508f3451d86dbc83644b0d1038e907e4b69583fc7fe67c1ae56f9c91a1a25f1", + "metadata_sha256": "6c269bfb3c0da730cd21a6b710ddbeed5291ea7ff6c544dfee4a187baf47d469", + "realization": 30 + }, + { + "arrays_sha256": "ede2af9c679a4dc56fe8e04456b22be63cc670bfb16f232bed03b2d9da6b3e6b", + "metadata_sha256": "337af29b23b6796f323957973aa4cec9b984a892d6a4ef5c8fb0790ca93d0883", + "realization": 31 + }, + { + "arrays_sha256": "877bf57b09521f48281d5787407f7d2f314ebf3ff3f15ba1e5cb6f4cd8847cee", + "metadata_sha256": "745b03a843845805c647a68f9bfd560ace63977dc16d403d1af873cbf52a4f0d", + "realization": 32 + }, + { + "arrays_sha256": "940e0a63b669409e96d27719aa68a72d310a4a5ddecedc95ee977432b305cbab", + "metadata_sha256": "dc2baa2c57d7025583c4fd5fec662d4c62bcc71deab16a92e63bb1b49bcb7e74", + "realization": 33 + }, + { + "arrays_sha256": "d1252f6fca445850490cdf30336cd3f9dbd46cb9b94bcf24f238c5fc40d58b3a", + "metadata_sha256": "a8dda9eba86ae7727e06579cdc58647479a62e56abac704696087d4481ebad01", + "realization": 34 + }, + { + "arrays_sha256": "545d66c31365b447227cdc45be506612f80faadd9b33685dfef55f43007085b1", + "metadata_sha256": "5f484c7998e6ee1d0b63d20529195b3c8c330729a9c3a227d1065cb33fab91a0", + "realization": 35 + }, + { + "arrays_sha256": "b8d563285328141baf014e8e8dc9f3cc07d191152431f59f89af28c45d54def3", + "metadata_sha256": "eb17c4d64cb62bb1fe9e3bde0d356a9a398b0ffc0a1b634f349d43084150cb55", + "realization": 36 + }, + { + "arrays_sha256": "9bf4a76d9eea5e204ff4b2c39871bf99242ad0f7caacc55e7eabe6b5930b32d4", + "metadata_sha256": "966fc585eacc07eb7c41bff39b298e86eb27c58de6843a0693b4332376db599d", + "realization": 37 + }, + { + "arrays_sha256": "08a07b3bfb555a2b53be899f2406b04941c04ad6edd19d75d75de4c7e870489e", + "metadata_sha256": "8e85e56064dde10e9f23c6d6832f1011b67629fee054fbf888712a1a87b586d0", + "realization": 38 + }, + { + "arrays_sha256": "8b5ce38c72f93f46b35383cf0c781b20b047049a73151bc9247619e933b5ef0e", + "metadata_sha256": "df895563293f8804eb5ec1bef8d1740684901d65d0adc7a995ab06f4435591d2", + "realization": 39 + }, + { + "arrays_sha256": "6ef9ab76b970220bbd5a939f2ba28f0c8156616ddcf1fcd16a63099e83a5af87", + "metadata_sha256": "41e1842062ace61dce876c064795aa1bacb2469020239beb3f243bb92ff44c91", + "realization": 40 + }, + { + "arrays_sha256": "bb0d34594d5f28ef805b7b48b47bff9b7f204348c48cf09f6412d79bcfc11ba3", + "metadata_sha256": "128914394ebe3c26e3798286f61319fb80fbaf17fe387aeea3bb1f00bc837a5a", + "realization": 41 + }, + { + "arrays_sha256": "7fae870ce113fb69b68a7f09233e9cc0953ef670f179014c787dc274a1470943", + "metadata_sha256": "1825a199194734513c110c6907428ab7126b7fbb7750dc42965fbbb4a3d9877c", + "realization": 42 + }, + { + "arrays_sha256": "f231dd3c56b519e6f19c16cc505bd4012d8b44c7805acc65f7d0d1d8bed5eef5", + "metadata_sha256": "f2c1e8fb9e3fdd7ec4ffdcd7d8d24f156b95254f72017b0d0c40a6ece2170325", + "realization": 43 + }, + { + "arrays_sha256": "8312b13d0966dba8c161678045f4b10d48b4b20000d12d7203bd3e0af492f880", + "metadata_sha256": "7abd64b7926e50ff8237d84e5e2ba5ff85211782614b50f3d269ec0c191c9896", + "realization": 44 + }, + { + "arrays_sha256": "e13fdeec074bf12340591e141d7aa5b035599f46f94d33abb59a272bbbd7f9f5", + "metadata_sha256": "44665ee402f48e34370430573403e1789fd34d26e015f53a2ff314baa1bf9f0d", + "realization": 45 + }, + { + "arrays_sha256": "b9b3855171bd8aee849bfd82f00097e8c87eed110cdd59692615bc116a3c91b0", + "metadata_sha256": "bb959d40badad7e308bf92f92aa096a5fc6f7110c49c8548868f91e0559c9033", + "realization": 46 + }, + { + "arrays_sha256": "121028fca73cb5466fe18322cccd403d03904362f6c4be61fac578fd5378015f", + "metadata_sha256": "0dec90287014a239220a4c335fcdd032b57b3618a8ab6925a4e267dd16b4b798", + "realization": 47 + }, + { + "arrays_sha256": "0985ec641e15f3372ee2f9a9e6a83d803cb804cd879371973f96412056ccbdc5", + "metadata_sha256": "05c1e0e1c870cb12064fd202042be1043d74f785721d3cc7359b02f370f750dc", + "realization": 48 + }, + { + "arrays_sha256": "f3f90cb07be47d9cef4d3dbe21d966dac8bc288fbb4c39447ded5f9cb21c8f82", + "metadata_sha256": "b053665662bf973cbf23053ed13584ca61a4611181413c72852bd873a3eb58c1", + "realization": 49 + }, + { + "arrays_sha256": "92d3838792b70f9f2cc610ccb22891232fb3cd7b7cb0dd37bf7e7b1d8a3e42ab", + "metadata_sha256": "f7b6b329f1a234a076a1b161ff589968118ed508113a188bf5557573155929c2", + "realization": 50 + }, + { + "arrays_sha256": "222e397b309ab4e370422d7cfe66d7d6af76055b0defb8d06db489151342baa3", + "metadata_sha256": "24549e52791fe9bfc7c58aa967221b9baf1fcb422adf16b2a2bcdef57d9465c4", + "realization": 51 + }, + { + "arrays_sha256": "421f29ddc2d25f8c03924a07b11c392f72b9e72ceb7d98fc223f70a68671ad8f", + "metadata_sha256": "530433411091f70dbcb6a72a02d0bf45a0681960359390efd389b0a3b3100647", + "realization": 52 + }, + { + "arrays_sha256": "fac5026cd3be96db586dcc977cdc5d10e03aa7c7dd28e20fd4d3110d8f5c968c", + "metadata_sha256": "fb270f11dfb1e2b2d5dd85af0c88ad69a0bd7f729db80d06f2d82606fc6e0a0c", + "realization": 53 + }, + { + "arrays_sha256": "d81f2390caa9cf828b460ba0c05e70a05c4e5d584f161bda49f21cd176278516", + "metadata_sha256": "9c581c3df5632594c4f542b8151449311f2b988571e8c62af96a85643d5ca85e", + "realization": 54 + }, + { + "arrays_sha256": "20ce2893c4fb83e995b5af8787d6f3eb8c8b906a408f27526249faaa54f80611", + "metadata_sha256": "7c12c9a634629df706a0d83acdff4413e4c4094a14654a1796011f5a0374b348", + "realization": 55 + }, + { + "arrays_sha256": "485ba5ecb5e8214afa7bda46800265e0083749dba1a0f89fe4dc9a1ca5debb54", + "metadata_sha256": "50677b1b657750e9386865b2abbf1addce2df70d55b87aea0ccd8c6c21ea0b5d", + "realization": 56 + }, + { + "arrays_sha256": "e58223be2ba03a84a19c89ef5410550fa86b303c37d561c366dfc27f740de3f8", + "metadata_sha256": "43b81610fd756f101bf1bf9e2cea9557721b933ae32f8f77abb3e16f8ff3a59c", + "realization": 57 + }, + { + "arrays_sha256": "ecd33f3b8d1cf44be4b7fbe54a1e04960f9e3cecb679f0982b4d51b94f7ac69e", + "metadata_sha256": "f83cb466b82214aa7e5c236c5cc166ea2c50ba78c6dd107bab46596f13ca6acb", + "realization": 58 + }, + { + "arrays_sha256": "92a2f5c466bd7c23c6716cff431ecf591c9f6e64f0f77bce6605b07d108002df", + "metadata_sha256": "4e7db9ad1306bf8710a130fe887b68b2269d847bb37aa4b4d71553cfc8fbcc06", + "realization": 59 + }, + { + "arrays_sha256": "d1396b8a7d4c52f5a509c9595d05ea9af8c99dfc856760e6a5cb12102dcc2ed4", + "metadata_sha256": "fdfe0c0adff0469cb0a8dbbcece9108ba967d1b5fdf8a15f71ec7c60840f1519", + "realization": 60 + }, + { + "arrays_sha256": "7219dc4e7cb59aa46f623b12f988f53e67a9b1cd947df03fc44d44ffe77fac59", + "metadata_sha256": "435d13b0b26dfffa8140431d0fd6c462e1ea12fcd7bd5df73af06f658c6a1b93", + "realization": 61 + }, + { + "arrays_sha256": "2215a26700357d3641feea8a23bc78e6ea56ef7a53695318409c2a815b1d7dd0", + "metadata_sha256": "e7fa05cfd42a4a9da6f55a1d6411862408dbf2315c995b89ec18f768f6cadc8c", + "realization": 62 + }, + { + "arrays_sha256": "3dc7322f0cbf9b3a60be4e6dccb42393c1ce96e46f1c9e1c72a48194732aa63f", + "metadata_sha256": "a7f702bdc28bc4663549d7f40643812f9b070afa64bd708c1c0712af896941e4", + "realization": 63 + } + ], + "observed_median": 0.4214201895221874, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.4126581626544304, + 0.43022143872255464 + ], + "realizations": 64, + "sector": "adjacent" + }, + { + "N": 8, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.208296575246959, + 0.2098604897075424, + 0.21141356711284964 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.21919373485072516, + 0.2211378800339962, + 0.22312587488350194 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "fde5ede4a59f43f00ba6dc0b588d722178bad5f7b7ab99fcfbc0b68f2bbf7dbb", + "metadata_sha256": "51a4dcda1ce78dd288476c8e2228580df2b58be891dc8f9e65c61d89d9a77aad", + "realization": 0 + }, + { + "arrays_sha256": "52261414a7fd29a83debecda4717dd48ed12328091f1726c3e07422bf71e6553", + "metadata_sha256": "74cd99598253e60d8ab4ec67711abe6cfb7a06e4818ecaa36ea06fcccfab55d5", + "realization": 1 + }, + { + "arrays_sha256": "72add21bb254f9c8d8b1caea0d5bf799ab27bcdc065ed2cde0a327ce003353f4", + "metadata_sha256": "454073ed6158a7dc8166c8be4f4751b25d919d7378676777c25d2db3a1464864", + "realization": 2 + }, + { + "arrays_sha256": "cf4b73e3e148de0744cb6489a7c218cb1ca75aa2dc0b3b25d7e88816b304036b", + "metadata_sha256": "b72680320d254397c4c6f9e835e93615286ad78e2baeb974676e92e15680253c", + "realization": 3 + }, + { + "arrays_sha256": "c768bfa190967ddfe631fd371e733bf207b83730d1a6c2836241bb35460b521b", + "metadata_sha256": "fe2c2b430e867598db55743f90cacb28ce56f6ce791cc76a84d63ab1ba787624", + "realization": 4 + }, + { + "arrays_sha256": "665b1537e6ac516146cfa88d0eb05d037ff1555b380f008c04748172db3c3069", + "metadata_sha256": "44c53d66db5ebf0f690e3c3834b706f65f70f0a04012f08983b9a1dcd8b93994", + "realization": 5 + }, + { + "arrays_sha256": "4742b0cce2a636cd1816a941d05d21b44988f4e3707a4ab0cb01f911fef6e4a4", + "metadata_sha256": "8591f30826700b51d0ad808cc301773df9ade23422db6045a3e56086512e7f3a", + "realization": 6 + }, + { + "arrays_sha256": "72f8f4bac4c29bcbc0e929c8b308f41ef87deb6f3816fd542b49843ba37e3f6a", + "metadata_sha256": "4871372cbcc2d4fce599b8911f13df19b87d0e66ce8f6ffd6241e09f5d8c6161", + "realization": 7 + }, + { + "arrays_sha256": "bc80d180ae42e4213f17ec6b57a84dec68423861672ce0f3fd7ba97a7e7da8eb", + "metadata_sha256": "2fdffa958856463941f496d4a9b8ee982edb72e3e796f1d90b590c65a80a98f3", + "realization": 8 + }, + { + "arrays_sha256": "465b7936550fe0face0801c9befe5e760bca85e5c9b2ee296673efa7d67120b2", + "metadata_sha256": "8321d2a3ef0cf370ceba6e65923a875ae45c49f1ce3a2c66e41eaac2eb86a67d", + "realization": 9 + }, + { + "arrays_sha256": "3821ef0fb3bd0885b4443995a9fbea2535dddf8c8759edfef498a279c89e5583", + "metadata_sha256": "11f1bcb9faad4383eddec5a7fd3da09178953ff1ab707adab53443985c40e263", + "realization": 10 + }, + { + "arrays_sha256": "b53125476970423b1e20b67e518c5f67a3a8dc57221eda2e211866667e1d2225", + "metadata_sha256": "65bf2f7c428badc22e9c1e80e7c4ece59458607b0d0045be75b3f06346e8047a", + "realization": 11 + }, + { + "arrays_sha256": "1a209fbf7af04aca31745929b41244330177794c224d2442c850aaea2762dc50", + "metadata_sha256": "fee41d68cfedd677158962cef0beecd69d15043b8ebbf0d922778c70137cec9c", + "realization": 12 + }, + { + "arrays_sha256": "cc224a42c513cfa026acc8db966de63488d96c4b7c56df8c21adb4ba794f70b0", + "metadata_sha256": "e8ba8dfed10b10a527c3138907eaa70b50f7d01ccf1ce24920193fc6f4ee229e", + "realization": 13 + }, + { + "arrays_sha256": "08b5225283a6a0dab2635a96fd24a3a0f3a79cc75c376a20942e56e2a1e0c1bd", + "metadata_sha256": "0e7a688adf0c7e8ce8f9c35bf4553da7d7123cb55fd7101217d7bc5c87947b03", + "realization": 14 + }, + { + "arrays_sha256": "ec340bc932bc40dbcc68f85954b8365158d4683fe793a52a8ce63ea87076c602", + "metadata_sha256": "c16eef248530e1f650b8838648ea97c9296ff4b2eff3f720884a9338d9343fe3", + "realization": 15 + }, + { + "arrays_sha256": "5e7c62a4ac53ef6e746ae28fb9b1a3d6f791e925968ee1f7e14f2c92f86543da", + "metadata_sha256": "edfdf871cf2110b9de1dd47fa5d9b92d4f3783686c322ff2c6a63485aead27ba", + "realization": 16 + }, + { + "arrays_sha256": "bd0261138dc45cbcf33a785582e115d0a1582c64da52e6c141cedc30ee0cf403", + "metadata_sha256": "979903a48202ad39cf133dab5d6c45cd6498f9fa7953ba66e16c3c2e194ea9a8", + "realization": 17 + }, + { + "arrays_sha256": "c66915ceb189d9035bff7f23adbfce23a2f3ddce34352ca60c7e029030e7b99c", + "metadata_sha256": "4658a666874da2b0733128cf56f86ea6a2b2eb84772352a19aa319e24b1f4da8", + "realization": 18 + }, + { + "arrays_sha256": "aa27db6cd06f0e9252e16849858f0fee89855e0947a3aabe949967a13559fc54", + "metadata_sha256": "918da874db63db0fe8f56740da067a75ad7cd6f32add723a1c5419138657adcf", + "realization": 19 + }, + { + "arrays_sha256": "3b057101264cec1335042b560a3dff962e09e7e166fa50aa0a2e2a0bd0b0ec09", + "metadata_sha256": "551acc16f91112a1cee4e013196df48d18f28eccae4f6ad36538e04577344c90", + "realization": 20 + }, + { + "arrays_sha256": "a09e6f0dc9a7d5b8bd1f64c7846b72db36a460346965b5a3b35ce069dbcee56b", + "metadata_sha256": "14131cdfb12ee6d2dee42764e3c290cb1f0706030bede65d2de156f3bd170c15", + "realization": 21 + }, + { + "arrays_sha256": "3f43b7157e5cdf0075d21f41cd3688448dced7bfe313ab8166f1e6f9d556400c", + "metadata_sha256": "26c61228962ce71e95961b0fd12b6644ca29d1f4880f0e5d9302ea780b6b01aa", + "realization": 22 + }, + { + "arrays_sha256": "4985f3a2f89057ed9acc86722c5843979cacfed6381f86f88cafe9253f12f4a6", + "metadata_sha256": "20d01f226a631285015d8306452ef1d23971f1bc22045adb26eb36dd11e2f340", + "realization": 23 + }, + { + "arrays_sha256": "4e3f6c91a3b4cb6c8d5bfb703580d0d7baf0ad6b1ba986bfc0753286d6b618df", + "metadata_sha256": "6a2a1106a9202dfbca97be29fa11fbd78092d01bf8a7fbed300e61cb2729e47c", + "realization": 24 + }, + { + "arrays_sha256": "9f0c59896b76ed346d625bd014ae79e4bf45106aa3b8e79d34825b127722c915", + "metadata_sha256": "3f409b78502aa9cb76e2cbfbf2e93a5eb61bbd5a74207b0fad75c973ba3f15ba", + "realization": 25 + }, + { + "arrays_sha256": "e7be39ffd2e9af41d491bd502aa54809137075f3c877702aed6b5088c7896e1d", + "metadata_sha256": "1e012adf8c247c337091d79c7266a39ccac2bf2e8f0af0c542e6c285e26b5a64", + "realization": 26 + }, + { + "arrays_sha256": "3149fed9666452bdd15d6b9a77491b268649434cf7fe3a46b958b910f309ce1d", + "metadata_sha256": "215c6dd3016833725d34b8acb5fc0acd0712aa9ed660fcc97ff5d7dae0f0db19", + "realization": 27 + }, + { + "arrays_sha256": "23227feae2a51ee786df7c9ee6f130f25802426f1fb14f9af6d41019798aea40", + "metadata_sha256": "8e02e515f20d409292c3cc7c03f61cba306ce725ae0b110229e5d04a5fee628f", + "realization": 28 + }, + { + "arrays_sha256": "55289c5fa377817987b2f29168e8d2f39c0d5838a79d43b9d71d874737e02d0a", + "metadata_sha256": "c93db0becc09dfec535fc07e6e7067166707d84045a38700487a7fd4250ab6c2", + "realization": 29 + }, + { + "arrays_sha256": "d367bc791ba0fac1539e830cc30047571b0ae38efdc634d19425490c77e6d36e", + "metadata_sha256": "94d35178eb56c5db88fe5f5cd4f6bb4714c2782a6eaf087ba63d539735547bc5", + "realization": 30 + }, + { + "arrays_sha256": "029a9ef702fad719c402458a535460b8ed44dfae1debc1f33b838f67b30fec7b", + "metadata_sha256": "048a8c3f740c3afdb1dbfdea74456fc5322aa01c3fd73f3d99c3cc1bb7ee0768", + "realization": 31 + }, + { + "arrays_sha256": "d2cc653c229c0a8ca5f0450e9c87e0bd0e2d2bbdc4266de0633940bb2f7a9633", + "metadata_sha256": "337056bd55242a282adf09d7356a7af589bc92c954ec27bec6c415cae538c370", + "realization": 32 + }, + { + "arrays_sha256": "5a325cb514453d8518f2fc9c7b37cd8dabfe65f2473709805bfc823ac3aaad06", + "metadata_sha256": "b3cd1650e85e65f9e7c15277656faa124d3f926a41a57a26310b40adf4dce809", + "realization": 33 + }, + { + "arrays_sha256": "2e4a8e7e27f2f01c8882a5dc617cb9231b2f6644476f4e316ccf6d914d1e88ec", + "metadata_sha256": "ec65aaf2406f8dc6cef73da323e92b17c3d1053f65e79459ad51d813739c84e1", + "realization": 34 + }, + { + "arrays_sha256": "6ad6d35f1fec93316bf3181c925edbed0e1dcfb0e49049b4293c249c97b7d35a", + "metadata_sha256": "4a8ce45b29299a64bcc01f7384e8faf21bd386f4daf90cf5aeb2c9800c5d1757", + "realization": 35 + }, + { + "arrays_sha256": "e550d7a159f867511a0a2684cab01106adaf898097567e9c4c0779812e8f823a", + "metadata_sha256": "3ec26df79db08062bd09f2f3348ee5ebc6dd6bd1df490ff94ab264975da1d1a6", + "realization": 36 + }, + { + "arrays_sha256": "0d7d3190076a9251eb1ba5ac8b9ffee3f539fc1f36b2d809f9d9cecaac865673", + "metadata_sha256": "869ca0075b3536be689428c4db907acf93230a71fe6f400f67d00d90e0735e2f", + "realization": 37 + }, + { + "arrays_sha256": "909aff89c5682973789b304f1259292efdbd7888b12bb02ad0a861b0d244c489", + "metadata_sha256": "03206d1869dd502b17ecb2512942936ab1395249143b6d4846936d2d6a4773de", + "realization": 38 + }, + { + "arrays_sha256": "b967f61248f39144f47dbb0feed2390ddafab896ed22d696f44c00203cbe2153", + "metadata_sha256": "481c483f26bb07a69197232574d40298b223c098608dce98d3a247001ddbce0f", + "realization": 39 + }, + { + "arrays_sha256": "2a523da657ba7866e59c634b6a0094153f85600ab55b9741d419c6f79dc94ae3", + "metadata_sha256": "3d006bc1e2b18c2f5d84d652fb0a413f0a0eb5954bc2ed270ac3a146d1e2c791", + "realization": 40 + }, + { + "arrays_sha256": "263d83f1c45ae8cc46940adb3ba8108071efb69879f3134208eab26d33bf8b8f", + "metadata_sha256": "57178de22de1a744e75b220d690bacaf74b07c1ae3b5d8941130a437e817fef5", + "realization": 41 + }, + { + "arrays_sha256": "3546e809af5123b25edc34deab9dca56a47bdeaf668b2a23a9e3fa07985b4b21", + "metadata_sha256": "2d37703a3dadaef904b74a0ebcd201373364497529cbfda985ea1229a49d1d2a", + "realization": 42 + }, + { + "arrays_sha256": "e0b81731b73e657d9db5859220f71c57844a541970954c2870bf29ac44b21746", + "metadata_sha256": "ebfe80a36ae044b18f1891ddfdeb43958fc7c7e30c870022892c9dc432e794ea", + "realization": 43 + }, + { + "arrays_sha256": "554d17b9f19de8275b8cdc2877f2f573e4bd409c328d37012604eeb012ac19c4", + "metadata_sha256": "1751795936b20fe7f16bb1718101bf832598ce01b133b4b1ef6fea9fb492890e", + "realization": 44 + }, + { + "arrays_sha256": "8faa2921a6fe3cc12372f46a7feecf3d880ddae469cfb57087f6ccda8c26aac6", + "metadata_sha256": "6ad8f1777e4ec50e7d81a0473c373dd1763ec0e2b2fd5fa1c465f5af9153b1ce", + "realization": 45 + }, + { + "arrays_sha256": "4d29ca7077894e11bc32edfe779630d552c036b774f57f591db46dd5e07a343c", + "metadata_sha256": "dbe3358d98a8d289c822d621e782051c4414a4f99d553b5ef4f5523419d8314f", + "realization": 46 + }, + { + "arrays_sha256": "92755041495ed91494c38caa2c0e5347238c059064a8578bae4c835b0c090cfd", + "metadata_sha256": "298300ff56d969bd0c062c20208e8443690e56b6150c2e291f1a6758d2d2a51e", + "realization": 47 + }, + { + "arrays_sha256": "57a6040a352113e12f35811900ed7a11c3448d34cd2bd3172b36a1e611710c39", + "metadata_sha256": "7262d060424f208b32c5fe6a4c7d56b635bbe12160ecf1286784c706f49a0f72", + "realization": 48 + }, + { + "arrays_sha256": "a564cc62aff47ac40d4155f729b15d1a942ce6af9e00979195031765e9011980", + "metadata_sha256": "d68c735f3309cec2845a34b3aee3952f5852d61aed07089da98d48fb1ee905de", + "realization": 49 + }, + { + "arrays_sha256": "b0a837dfc2d3858f4faf4adccbfbd6d4f428f87b3556d35fa8258c436650f826", + "metadata_sha256": "14f1ca8bf693bbe590af2d2509fb4c26432241b12033a5030d2f0b891c34b437", + "realization": 50 + }, + { + "arrays_sha256": "70c2eb395ee7b57f33673d9c833b663414eb11e877e23ec4635eba3a2516b7b5", + "metadata_sha256": "96a342d3ca7afc6b5bef5e4a7d4dafe92047059c9840e9114990f60e8db8f203", + "realization": 51 + }, + { + "arrays_sha256": "f7fb6f25ce15d1067b0c10745340c1c8d67b2a8b0ad3157724524a6f01e1aa2e", + "metadata_sha256": "fdfa7363c7e4a74f4ff1babfb8c5b68aeee7068e2cf366d3419c106df2cd6859", + "realization": 52 + }, + { + "arrays_sha256": "0bdee0ac4955619b553924f5216d01e95ad3085ae5896c72a5cefe7fb6047030", + "metadata_sha256": "c08d09e0e44c481250bf70d99050a518a8fe2f47dca17ac16474481ab290d534", + "realization": 53 + }, + { + "arrays_sha256": "f413fea322287b9ce8b837f75fa66b9f09d4e6bc2a4eb25e086fcdd3a33a40d3", + "metadata_sha256": "12fd82adf8714c52725d652ce9f53a0c8a3be1a093b4461b9b8546841cfd84b1", + "realization": 54 + }, + { + "arrays_sha256": "7850e99d056c8f54a2256d47ebc89b562489d117391ea398accc6d50a9f8a1e6", + "metadata_sha256": "c9b58ba30e699acc5bfd1b47934564bac2d02fb5c8b5da8dd7353bc45004d750", + "realization": 55 + }, + { + "arrays_sha256": "ba76d6efbbc1592f108a3689dcf16a12f0242def9c44a89256d22b1ae9fc6df4", + "metadata_sha256": "ff4c71b85ddd2306cb83699cb2d7f974c809980e6cb22d29329a70fcde8ba772", + "realization": 56 + }, + { + "arrays_sha256": "5500930cef24dd9376340c008e9930f693992f7a50eeb61f55fab36b7a11fef0", + "metadata_sha256": "dd1c5f0c2028293780cedc3608886e6ea78e94faf8aec5aff2c507d59946ee58", + "realization": 57 + }, + { + "arrays_sha256": "8ae7ba7246d4e551219cf603d2f2cf0ea99220cf81e1535cefeeafea47e640c8", + "metadata_sha256": "44047c9c85b677944199e175fafaa3a5c47dcca5f0b07e8d536430cc0e7834cd", + "realization": 58 + }, + { + "arrays_sha256": "edda91a20e337e516430a5e86f047f1ae83af016117193a8c0b8abd45bbb9ad9", + "metadata_sha256": "96d67509278bb4702d62d5fdf8b27d2e1ca2c6d6b07133a7296abf5a597f6354", + "realization": 59 + }, + { + "arrays_sha256": "028337035f3f2c341d1a227f16a9cf98d06506e9e2d2850c58471f7ef69f9378", + "metadata_sha256": "a3c6f482fc99ffb8b121a4066ba8950738481b433b202fcad8c4d5ca549271e3", + "realization": 60 + }, + { + "arrays_sha256": "622992b845f8f90587d9331233f351684a961c9f1f6fdc914eeb7851ca70d89e", + "metadata_sha256": "ec4206ed0e3832e3af3f79ab1de6b34bcb50876abd5fc79bfcd4094d843c1968", + "realization": 61 + }, + { + "arrays_sha256": "98dcab22df1ace436c31711268e2dda1a46dcc7b8ef64e6459a8cc04c7ca7a14", + "metadata_sha256": "3c8c16b2eac8b332a0d26f4bcba007f84f8b0e07ba7e25d5e82fb6e3e1c612d6", + "realization": 62 + }, + { + "arrays_sha256": "c34c72dc428e7715ec81111ad1c8bcfb5697b0aab7f5c2012750619d56fa5976", + "metadata_sha256": "d617d0cabe81a8cbd5f600b60a91b7983b5a55ff2328d6f9f4bee2f710e01387", + "realization": 63 + } + ], + "observed_median": 0.2144978352258034, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.2119918398218324, + 0.21709852949971428 + ], + "realizations": 64, + "sector": "central" + }, + { + "N": 8, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.2230705351105154, + 0.2253842662139643, + 0.2279418505155369 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.2414682892862224, + 0.2446097093216335, + 0.24767586208084383 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "87f4b818b585e91973b0f7e61a8727f9c53a607924082a6b44f4504c846d7302", + "metadata_sha256": "e1d34054700f403531c33aad208b2be2a664f5c02488efb39dbaac28c40169ac", + "realization": 0 + }, + { + "arrays_sha256": "a323ae57cab1876a48bcb0c29ccef6e1d8f6b82eb96a6e18424bf6ca7239bd68", + "metadata_sha256": "20bb8f1d3c0587086c8a67a86e7c0bbad222826f28eaf42c37cc199f5a58e4c2", + "realization": 1 + }, + { + "arrays_sha256": "d9f3889e07c00ccc4f581329306a145e3715d2d47d2f1f2b0dcf3252471f0a5c", + "metadata_sha256": "35d041a4687e48216505036a20721f43625e34c7075c7865932078e1325c88f0", + "realization": 2 + }, + { + "arrays_sha256": "e1e26346e3957fe5e04b2c21c093c1cf52f28ec0b34d164f412451d7d1bcfc15", + "metadata_sha256": "576a93de8ca0638d13775909009aa0c4af578619c842dc832657340770663920", + "realization": 3 + }, + { + "arrays_sha256": "99ea13b632a4adb89461189589c50f47cc8b89cc29c3751c8e99c63b5f55f24c", + "metadata_sha256": "cb047d7bdb5cb7c40a007745023476bfebb4b4ce327e4766ff12b12b04c0e28e", + "realization": 4 + }, + { + "arrays_sha256": "1170696596d1c129416db581c00aa912a2d3b840ee5123cb87e8e546f55f9dda", + "metadata_sha256": "845979e19a18e3fcce34737b49edba413d543599316e976ac07e4feb40a3a0bb", + "realization": 5 + }, + { + "arrays_sha256": "6c83e35b540c6697e4e9dfcc67ba60e325e9ae6a2c5101e8d874b05866a50db1", + "metadata_sha256": "810465a253290b03cb73e84adfe98618a9462c2cf52d07d2304f06159861b719", + "realization": 6 + }, + { + "arrays_sha256": "2daa35ffd3aacad0a4248b443d05921ef33e140ded627cd6197c4a53f9bcb158", + "metadata_sha256": "3335f2adc9d293a10fcf8a8cb73d05abe82a988df2f9a07db0cec24f17dc4241", + "realization": 7 + }, + { + "arrays_sha256": "b931272609f3eb15020e66e401100582a71c7a9292888d3fedca410c236b7f2c", + "metadata_sha256": "fe18e4ec7936202125b779892a2a87c2a61cee51c4d63cf7f4c73dd8aab98005", + "realization": 8 + }, + { + "arrays_sha256": "408e946141c6f329f80bdc35ed9e1edad6ac6c22ba4a5e1b24d2c4e3beb7581e", + "metadata_sha256": "7fb358b2d50756f677c2ddc85df95c9d5ac1ded2f5aca13a129988db7591bf71", + "realization": 9 + }, + { + "arrays_sha256": "db02f0e93d4fc12a99b91559827397088461c55b6e72dfd12d97cb79338b0d5f", + "metadata_sha256": "4e07b5fe0348c45353edf16a294585f844d564379ef29b4e2b3b17ec8fd98c7d", + "realization": 10 + }, + { + "arrays_sha256": "3de270bea118329e8b723da7ccafbab298eabe715129085467ff54c3a494c6e6", + "metadata_sha256": "21d9d2f04ebf122dbbd94da79454bb6a56a6e539c44ac71dadf64ff7167de035", + "realization": 11 + }, + { + "arrays_sha256": "e6711bdb0face28fd3ca87cc9ea19b3ed8a747ea366e32724b46bcb5a9fca613", + "metadata_sha256": "de987752e9375901157e3af3bd16c698823974671b81d32566a69ac0ac44b647", + "realization": 12 + }, + { + "arrays_sha256": "fca154901f7dd4d268829d7413e22874f1e5a3a2efd7231f8a0b208a914567db", + "metadata_sha256": "e93be2c5389d6d241af82086921285a723062cba715b150c04f709502d0f56ab", + "realization": 13 + }, + { + "arrays_sha256": "c31dc61f02b6199c0ac8cd79a799354a0fe1f6a803e3dd42a295c35819e7aa4d", + "metadata_sha256": "99ab8d207c4b250444103927595837b6240f1172f7554a784584dbbafb33a80e", + "realization": 14 + }, + { + "arrays_sha256": "0d4a7ad82648c7ee29c65e559ee9292ba65b54c8a354fb4f9f68cec6af66c3d2", + "metadata_sha256": "30495313fa1f672c65be246b221e0554eec8b6030968d198c3c7f0a3d76d75a2", + "realization": 15 + }, + { + "arrays_sha256": "431439e7d8ad73f3a568678d9c855d77b457c28770eb52719f3f6d6a5e64c8a0", + "metadata_sha256": "c276e6ca46c2dd94001d3c1648308cf868878b1de68c1f16c6425b6beda4b750", + "realization": 16 + }, + { + "arrays_sha256": "99e0bd87edc55310aae8af1997c94fdbbade63ecea068f614d34f1ec15810315", + "metadata_sha256": "0f82ca3f9c65d5b1850b0e44bf5478a7abf457648218f576bba819d1cfd69fec", + "realization": 17 + }, + { + "arrays_sha256": "a92c415feadc8dc6c2ad654cf83b647b959f5e91252163afdbde00f7f9258b45", + "metadata_sha256": "ab67138b59e947cd5c4bb07d7e309cc471c6acd6cd250a0c8cfb99b5ca1e6361", + "realization": 18 + }, + { + "arrays_sha256": "1b92631e9fad6ee80b6b185e0caa23dcf06097fcf9483383637585d49944f45f", + "metadata_sha256": "a3df9828871df88b4e77be73512662c7e36e5ac13340e20285ab225701af7094", + "realization": 19 + }, + { + "arrays_sha256": "1b4975d38023701021c4b115916373da82bdb86ec99013cf4f24a5e74f0dcd0b", + "metadata_sha256": "d96e8c451541829f2d9b6644dc6c188bed0b274341dd48e01b5b9424e2155c93", + "realization": 20 + }, + { + "arrays_sha256": "49f1dbca6d4054412c5b75865561f484334181c756c5898d7ca641aec58b402f", + "metadata_sha256": "b689c5fb6eafa195a71d522a19db4e89193bbe75fc373fa14d092379a55cb2cc", + "realization": 21 + }, + { + "arrays_sha256": "3adb50b877d659a188affbe1284705bed52acab0e3f86c067fa404b616892700", + "metadata_sha256": "da153de75d222415d97486bcb1072f194cc2d37d7b002e6ed8127a0661e67acd", + "realization": 22 + }, + { + "arrays_sha256": "47a695f672164f3a33699ce2e1b99b5727afab3ca9b942edfe879d001da2fc56", + "metadata_sha256": "7a10118815bda349a676618c0341cda6d46839bbf7c80de58aca22fe0e87a4e1", + "realization": 23 + }, + { + "arrays_sha256": "029a04422d219b68839f8df27c804ebad59161b86cc0263bf41546ef0e1d9162", + "metadata_sha256": "a9ff3e7876960b9f275385115075d1ba5003878e7546812ba78ac3b4fcf417cd", + "realization": 24 + }, + { + "arrays_sha256": "13c5d8529e9535ea39d263bfff5412f996f02792f38f7863e38470ad1cc024c6", + "metadata_sha256": "6a6433f5f5de958514078c81778b8f07a46d9c34d65fb986ca9eb3c4c643be86", + "realization": 25 + }, + { + "arrays_sha256": "ccb747c0009d0273f1c0858563676dc02dc77d54d6bd6a75e9a175098ab1260e", + "metadata_sha256": "890df8232a0b26508205d59e67fe2595f20514544716e0107d876dc80af689ce", + "realization": 26 + }, + { + "arrays_sha256": "5eb3ccdc4edcbc1a74bf156eba59be0570dd80caa9e655670261501783214875", + "metadata_sha256": "24dfcfb26a7e37e869a6f629ea46011e453c832bfcf58a423094600aacd0bd6b", + "realization": 27 + }, + { + "arrays_sha256": "b2f1a88df71f88090bc07c02974a2c6a89fe25cd476c2c7145fc33e354514925", + "metadata_sha256": "78573b337ff8ed27d60c39ec7636fc7e908248f24a16e1215c60937c7eadd349", + "realization": 28 + }, + { + "arrays_sha256": "9c01e1528b5e71a631c210c2924804fcbe429e8b152430473ea02a004e415d8f", + "metadata_sha256": "486f28c8b25cfcc6e82b5d8297246a096c9cdf6feba2275367313ac8bf32758d", + "realization": 29 + }, + { + "arrays_sha256": "de925274f03b6822c95e9a9e60c6865792d51c754d1372b926e1589548b5a906", + "metadata_sha256": "85212b60b75a5fcf320fd5bd071d243d3f9ea1cf0a66c1a263fef1ae328d7332", + "realization": 30 + }, + { + "arrays_sha256": "73abc7fadc5943f3e371fe39510a1a8cfb42a588fd99feea7c47f3be9a36c9b7", + "metadata_sha256": "ad175bf90bd2d22242111e38d8e108046fe80d4144214a16a4652e96f28b848e", + "realization": 31 + }, + { + "arrays_sha256": "330023e7777fa868dc2f3be5ee110db29f6d0db3ebf47275a153ec3a8d99b2fd", + "metadata_sha256": "68dd4b41c27313c60b61519cb1efc4e00ae42476b0ceb2f65d13e379805dfc66", + "realization": 32 + }, + { + "arrays_sha256": "9890d5deca1a463a25e0b99b8f8eee8243bca48591eb93a51b18d5944bda3159", + "metadata_sha256": "9c49f1854906b0d06c2a732c1a8c830517c9f06d0ee51d58d6b32f80e100bf23", + "realization": 33 + }, + { + "arrays_sha256": "a665c418bcddb1b8d132761326c9224dc5d5d770ec78fafd7ee0726d62c6e13d", + "metadata_sha256": "984bca1c4e65275c31ff37e24dca3f09d1cf1f606ca7dadb4889a9491056705f", + "realization": 34 + }, + { + "arrays_sha256": "9a77fc8739d04810d259338f393bf5854a0530f99031c85b93d05831c7c53352", + "metadata_sha256": "5fc39987664b517a7eddc8128483052c39f398c2a5578081435dece2c72d0f84", + "realization": 35 + }, + { + "arrays_sha256": "7bb2f7f95c2d0f1b9cb5a65c24ef6f8c616426e3b1be11642304c03e0b5ad301", + "metadata_sha256": "fdfadff76f8e0ae41223c5e3629e11c4e8bd2f29edbc29a38a51a66dc19af58f", + "realization": 36 + }, + { + "arrays_sha256": "5fd163805b1740e204e0dc27289e10706058f5cd1101a08506d9810311391786", + "metadata_sha256": "d549454affa56557a08bad26cf9d11cbac684cbfd629becebc5782e863915630", + "realization": 37 + }, + { + "arrays_sha256": "23a195b563acb5097dd19c7ed8afe2365ab3f58bb3de245ba56e9749e6fbd489", + "metadata_sha256": "74f57255fce8100d6c56387a71bc1b3c8b65b7354547668dd71446c0deb8662d", + "realization": 38 + }, + { + "arrays_sha256": "5f9a5e23263a1732804da280b7126a174b4a79061df4964c1fdd21ce8c00aca8", + "metadata_sha256": "f9325d6f93cf3e7a8e4b5c175aa49307e879726321d34dbb65eca00767c6ac60", + "realization": 39 + }, + { + "arrays_sha256": "d49a73f12de2f91f7d4440fb6e4c5e94c2c0bfedfd01f2dbe5c6bacf786cfe04", + "metadata_sha256": "0db556c44018f4a8b0662f5be51e26456826dc7df0ac43ff87bf2d8adb089d32", + "realization": 40 + }, + { + "arrays_sha256": "f7f425f0a8da29e6455aa475c978f69f0e1916f8cf2617330205bf9bc47d0d67", + "metadata_sha256": "a2072d8f9c039bea203f5166f2b34c50e3290b7c7c773ba34a1e4ff04868685a", + "realization": 41 + }, + { + "arrays_sha256": "1e7f29486b734ccdd688356d935e82fcd0a593f1b6129f08b6dba8c73ffea436", + "metadata_sha256": "36a7b08cc0099af10daf95be5f2d27dede343b2dca97c04b93e340773457ce20", + "realization": 42 + }, + { + "arrays_sha256": "6908b8506dd5d7004148252d16789a9d65e17edf980d8adaa5cbf03d13ff079c", + "metadata_sha256": "eb1a31d36e18f5a6642387f4dd20fc860f9f26889284f6eb7a2e1ee8d387942c", + "realization": 43 + }, + { + "arrays_sha256": "569ae8f1a16d1639a788ee6e8f1fc2c2eaab934fe1acc5fafa9704638c8e4e55", + "metadata_sha256": "8d77cf21133a784cec69b3e0c65ff646aa72ce6e5cbff8cb907f5566c71b7ee2", + "realization": 44 + }, + { + "arrays_sha256": "734c979a770f410286b73cd76db4fabf6d194c27a7ed6a6b2185c08e84cbde3d", + "metadata_sha256": "396056b5b183bca93e3aed9444b3009810871894d7799d8e67bd6b7985b0a53d", + "realization": 45 + }, + { + "arrays_sha256": "cfba4ff746bae2892104da8654780901c9ab7ce808670337c3ce2528b62da246", + "metadata_sha256": "9c1ba26d020bdbf63d27a1038448c40c850068ee4f77d81b4b3390c24c9000ad", + "realization": 46 + }, + { + "arrays_sha256": "ed24695abbe170efa0613f9fdf240971a98a0f5a40782a6a92f8e6100d6c17c7", + "metadata_sha256": "969215461bf3db8badb6daaeb9001dd0f7374ce68410370b1651a03513cbe121", + "realization": 47 + }, + { + "arrays_sha256": "866cb66208a82809f74bb0a409d39b569e53e318f5265cad2db3acfc43e89fa3", + "metadata_sha256": "b7aeda3dc42b53110c706f52751318bba5b10392de07774d34aed63c3f758cb3", + "realization": 48 + }, + { + "arrays_sha256": "72db63adfd1167ecc2e5912f48d701073f6f8f4e5db61c712e7d7543fc8194b7", + "metadata_sha256": "298ceb76d555665228110ce4252bd971356e8931cf71a1d36c308ae7aeabb356", + "realization": 49 + }, + { + "arrays_sha256": "863268d37866f152cd5c9a2becef7237daadfbc2122f71c0e5ec10a4352c0ab8", + "metadata_sha256": "5dd525c35dca35439cc25619dae9a790ce36725c5096d8ff2991c70783e0ecf5", + "realization": 50 + }, + { + "arrays_sha256": "f85893e26963276b8367fd1a8b875204e6a7e891a887a9aa89f135b00c0ddf7f", + "metadata_sha256": "c56e1082b6f2084ca9efc53ec5eab9c96384bc55f86f84c353170fb4d2f89077", + "realization": 51 + }, + { + "arrays_sha256": "39448bccbc2120e74ac49370c97ad34efa9ff633431a29bf3fdfe55244c03e1e", + "metadata_sha256": "2a7df86b4bd372607301f9187c8acb4ac9bdfbe408f20be652494e65a0be55b4", + "realization": 52 + }, + { + "arrays_sha256": "f740c7eeebf10fb013180c1b2ba47d00456b6eccf1325a6733b4a301927a65f7", + "metadata_sha256": "ac8e0688e14e20e491e302f7d9a97b181238945e7c5b9cce0b53e0876a852b66", + "realization": 53 + }, + { + "arrays_sha256": "f12ef37df82b1182aed31c4092cacf8dff81a1645182fb3ff27f45d61b78adc7", + "metadata_sha256": "c650cd63c8c8c9e8ade52427356f9f598e7444ad6ced2c90d36382233e8ead3d", + "realization": 54 + }, + { + "arrays_sha256": "98aef7e4fb60148cc5e2cc3a7e2ae6a2c9c9af24b750e6f48438f35c3d25322a", + "metadata_sha256": "f149bee8d3985b364990d9f8f9ac5c928ea93199dc7ff01c84164b43a2a03a89", + "realization": 55 + }, + { + "arrays_sha256": "246d697b95feac151aa56b3c677bdf5c2b47a0143f05d110b1d17170c826a218", + "metadata_sha256": "cbecad8c707eee086fd9ff9e4dd96ad0c6c7e811b07277335b4359eaafcb0305", + "realization": 56 + }, + { + "arrays_sha256": "2c34ebd25a6d40d48060e94f157dcb4414994f131fb8f538c152580cee4afb2c", + "metadata_sha256": "703a4c7260a8e1371a4e25175d4769fd7b6bf50898cbe0fd8f5bc486ab24ad16", + "realization": 57 + }, + { + "arrays_sha256": "0c54da30c345a8193ca7073bfe6fdf8cc9ea93d6400e82cb4ad10f6bd1124e18", + "metadata_sha256": "1601c5a36a2db031792a851eb1f1e685c0213e9311747f46d19c169163dd8951", + "realization": 58 + }, + { + "arrays_sha256": "99ebfd4d0242ce2b513912e6253afb679c1f7ae184ad27e14866b4c09e9a931b", + "metadata_sha256": "d4de7ad8ba0200770e9612579dd6b13509aee46f62a1048be7ca9c29a7df1aa6", + "realization": 59 + }, + { + "arrays_sha256": "1fe481efd484f2edb5dfeb41cb670e5f0cc45274a4ea658be68ec9e67354a467", + "metadata_sha256": "466d3a9e1530fdd4e8d5dd51a7f855f8e151a158cd0c6ff60f6e6696430d781c", + "realization": 60 + }, + { + "arrays_sha256": "07a1df017c333c5b97c1500decd094e483ed5a7d767d5e8b5cc54007174b6b66", + "metadata_sha256": "e2eab424a3fde3a834bd6d89104efa1b4a3a6e6ee7152236817e57362b313e5f", + "realization": 61 + }, + { + "arrays_sha256": "0de1e1d2fc2d0cddf34f63904886e2ba75934e5f6b7eb1b1a797fadb8462bcf8", + "metadata_sha256": "fac4cbd109650d742ef61413b323d2d307e9958157a076cad34a50ae4c14d686", + "realization": 62 + }, + { + "arrays_sha256": "5b9fdf05a75a1655f2b2e86193142792bd62056eaf28955c087b3debd67f8a9d", + "metadata_sha256": "94aad428ec867a5a63956a87b0f4018e2012703493d2058b9a0fdbaf0276ea65", + "realization": 63 + } + ], + "observed_median": 0.3588778773960463, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3467447519390082, + 0.3720889925062879 + ], + "realizations": 64, + "sector": "central" + }, + { + "N": 10, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.14697176523695696, + 0.14827234254140156, + 0.15000030229188152 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.14946543883393287, + 0.15121420848794176, + 0.15313133957932945 + ], + "median_hodge_balance": 0.13837041292214186, + "null_banks": [ + { + "arrays_sha256": "12b2aea8b0f25d4e37de54a2d8d7d2c4eab4a5721066207ae19f1480d3cce29e", + "metadata_sha256": "096385775c25a0eaa3a603e27cb8fd7ac40ece03b484beb6e00b12d3cbacf7d3", + "realization": 0 + }, + { + "arrays_sha256": "46f8aa51afa24cf2599da43c40b1867acbe3f789b59474dd54c4630574a10afb", + "metadata_sha256": "1821f05c1a7c6d57ee6764f7f4520455b91baea5ac8370f1919fff8435964d2f", + "realization": 1 + }, + { + "arrays_sha256": "35369ce2d8ed039f0d3c43a487a0cd8fad32756db09b3e57922a8f41f6cb6dc5", + "metadata_sha256": "0fc09bfecc1047f3b80bd0bfe5ee945418912653bcbf3357472961927c0cd2d1", + "realization": 2 + }, + { + "arrays_sha256": "21c2d40a659ba81b86721a70df0a7fccaf088add28eb68f7d5105678eb214d39", + "metadata_sha256": "36e2341865c3e6f7f2d4b93e57eacf2d9f22ae6f3402fe6dea7c1321659d6704", + "realization": 3 + }, + { + "arrays_sha256": "eb2ea0964a7946271b4c379ea54739ee1a7667b18027c3457a0aea317ade17b4", + "metadata_sha256": "27eb716e8664878422bbe1bea34354fb381ddd73d1d2f7bc2c5bf215169296b8", + "realization": 4 + }, + { + "arrays_sha256": "2f56598860334e79718b478f3e760fbc5498ccd52b9a9be8c6dbf12e0383de5b", + "metadata_sha256": "5f98739127ab1b8e3185ef3bb0c7bd3980cc767f518845713ab17fefe85d1e32", + "realization": 5 + }, + { + "arrays_sha256": "e0c4657781c703a93d9e18adb77043aa4ccfc10c647bcddf6a1e450a13ad40ec", + "metadata_sha256": "2a4529ad49e2a12f83adac46a550d5475678119bc984e2490fcf55d5f3732e53", + "realization": 6 + }, + { + "arrays_sha256": "a9208214fc80ff18c84db0e4f9f940ef484bb3c626ff78dd89c985fe051d5593", + "metadata_sha256": "15818f4a5e7578535140ed773bfe9e7657940c977b8405238ee6ad570e642f51", + "realization": 7 + }, + { + "arrays_sha256": "4655a42985cf1632a52b851bb70da181a9853a293546270b2835679a4455e4c5", + "metadata_sha256": "6909efd1dc3805aa49aec5e178f30ca82fc5a387784e10b30ab6733b0efe3e1a", + "realization": 8 + }, + { + "arrays_sha256": "6779e66eb68f4ba8104f14e5cb8df25bb8845da890063b10988d4e0db92efe1c", + "metadata_sha256": "a9c64b326dc93b79acb345e091e61ea5f5f634621a9c70ae9978c51b35baedb5", + "realization": 9 + }, + { + "arrays_sha256": "125a562cd836a4d7e5df7bebd2623c1d6ea9b1a351a3e4b200f76233bb03ff4b", + "metadata_sha256": "53b2a48dd9d44e76cf1dc64b140a89aadb6af05c5265456c45b770efe9e9130b", + "realization": 10 + }, + { + "arrays_sha256": "a9b8f1359bd4d4f579390d73ae60f19ea0ed84ba8c5bfe2d45e0a71c4937c54d", + "metadata_sha256": "b2eca6bf52b5fc3480a2699e421433e0bc1e6cc097402db9a23ae081942fb6a4", + "realization": 11 + }, + { + "arrays_sha256": "643a1f5e202504105ba23fd2885f3d57d1519733037a7bac0c014de5ccd30e33", + "metadata_sha256": "90d9af159dde8837be965e349cd0d43912456379d5b6c3e38d252d45f39ea072", + "realization": 12 + }, + { + "arrays_sha256": "73fd5f5fd3d4b517002edb8e2917611ac3e2813e0073744818654716b93ed467", + "metadata_sha256": "dee843cdb1e4ed715e375c408a2c9293692f98dbd17fb399d3654ad152f30fc1", + "realization": 13 + }, + { + "arrays_sha256": "3d353a7b7538336d4bdf3e417d0fbb635db61d18f469a796a53a9d924ebbf297", + "metadata_sha256": "235074e0e468591ba3c42143ebcdd7f7f812b2c38da0421c8983b1a890138f5a", + "realization": 14 + }, + { + "arrays_sha256": "84c1934f9942559ed2cf61ccab2a0d7e6682d207f307a8c6cbefb8a7265a2481", + "metadata_sha256": "becb88118dd130f5bdceb85177e0053d4bda7915d3e389f00b85bd33f552c12a", + "realization": 15 + }, + { + "arrays_sha256": "f1b0ed773d79f7627c346c502cedd57363b6d385b53439edc2d67b0f6fe2383e", + "metadata_sha256": "49c789a1cf1f9d325b20bdafddd3cdf388f425f5faf3ff518aece922b5cef0e2", + "realization": 16 + }, + { + "arrays_sha256": "9d66ca2b1a01bffbc965a800bba375fa78d6e5f375c7b578de70e02f6913df9c", + "metadata_sha256": "26e262c8f7330a88d4e90321b567d1f20b6088c5bee43651f429802086591a78", + "realization": 17 + }, + { + "arrays_sha256": "0b7a13297ff2de604fb35e78b6384d13884c1d2237df1438df2c2ee7582a05b4", + "metadata_sha256": "2d195514c0099cf9c60f963fd03bc41febb77b6ced96d6c7c1d1074bb0f50000", + "realization": 18 + }, + { + "arrays_sha256": "a50aa65e007d522b09c6fd88a06c5fafbf7f280346b93ff6c110aba26864d9fa", + "metadata_sha256": "f0540a55516c8f7357048cd8d056b6536e854af5acdaed34a57e83d0f2bba69f", + "realization": 19 + }, + { + "arrays_sha256": "3aea56f3a003fa536ff7544db6befa5293c5e9a33ad0fc38c4bad822bbf070e9", + "metadata_sha256": "d7b0ec3efdfe5deae363edf73dd578709c960ef012bb54e15f72a63863c67d07", + "realization": 20 + }, + { + "arrays_sha256": "7c63441cbe5176bde7cd5047779cf302c6ff1ee181e83d25f8e40326a8a60626", + "metadata_sha256": "cead2e8046c8a7d9acaf3963e7a36fcc1e137631a2570e8fbe387bce86f9da86", + "realization": 21 + }, + { + "arrays_sha256": "baff01a4bc494c022271ce839415f394934e2e168bb5f2242e02999dda80178a", + "metadata_sha256": "93e404a4d338456dc53915eb62900b48b9cf6bb84fd956d696aae6ccf82b9e91", + "realization": 22 + }, + { + "arrays_sha256": "1c8c864a57671e3696ee65b8139d551c6c20c89f67224fa5afaa7c4356a26129", + "metadata_sha256": "72d822e26e0acc8c7fcc36be1a878ac76106a829100957ed1021eb94146f6664", + "realization": 23 + }, + { + "arrays_sha256": "e73f5723452c5fdf7e6b5d083bf6ebdb3e313a1cc58306e3d0bc5024e4177bf7", + "metadata_sha256": "01e2110361d9282aa2c2cfe557f71d70ecdfd244c2f06baed9b8c4aff115e9e3", + "realization": 24 + }, + { + "arrays_sha256": "5994338ed1cbb199452ce037ba54633ec67d3d09c81f1fdb2832969e32f8eef8", + "metadata_sha256": "65285447d52e355e3a46c3f656ff7c954f01c4ffe021ed41dfeeb232a5a4b4c5", + "realization": 25 + }, + { + "arrays_sha256": "a01cd7dbc759687fb8081d8429f858c58ed1a13f7fbc3186fd6ac4f525f9fc45", + "metadata_sha256": "3c3c2f024c9508d008a93ea6f5018e676992f65c72aee9e3c75d4ea36f4f4c9a", + "realization": 26 + }, + { + "arrays_sha256": "8ac0174c32277478e1e0e49f713daf70933c78f1f7fa603a172428e8b752f7bd", + "metadata_sha256": "60e5b08074bade17c6db643599ae62c24e7b826a587392c73666ee11c7939585", + "realization": 27 + }, + { + "arrays_sha256": "33a54db642b75d74ebbd68033f821e80ab769bee32c034dde78839721dfaa0a3", + "metadata_sha256": "9e747bd372473e73784b6eddb6435effa68d62127977ca1d608701cef7603eb0", + "realization": 28 + }, + { + "arrays_sha256": "4cd17fd2a37474dc639544d7ba76d2b6aaf20e8beec166885e4f3379ae2eab9a", + "metadata_sha256": "298899d5aff126f7710415e5a5655b12f88aa84c2ba7e62f9726bc3dc6a56bfe", + "realization": 29 + }, + { + "arrays_sha256": "e1ac23ac06bbef305b635e0d7642d002daacf36fe3e23bf569971c1770bce06a", + "metadata_sha256": "6c58bce1fad03b486bfee9784757e351f84efd3ad435d552a58e194e9e3ba4e7", + "realization": 30 + }, + { + "arrays_sha256": "b48cc123dd7b5fe89424c0cbfac81904f57d65255aded8ead256b5bb3ef36d46", + "metadata_sha256": "2593d5a3cdae4a757977a2c8446a0f0059df3ce69bae0dc78a6072fcd1fa6cfa", + "realization": 31 + }, + { + "arrays_sha256": "dcd780bab03e7857cad3cb893ca35c7ec2989d5283396ab6d651ac887e78f71d", + "metadata_sha256": "602356df0e9730daf183a2df12b18e50803d6b7e139a1fc4379684c835cd4311", + "realization": 32 + }, + { + "arrays_sha256": "7c47c83c5e7fa702563caa395391cdd77cfa0a23eb27ed9f218a936c0e7b170e", + "metadata_sha256": "5382638aff28a7e32ce3758fd3363d90c4831a992dcae1bd8938b6a06584518d", + "realization": 33 + }, + { + "arrays_sha256": "297f960c6acd0c6c81f6c86ed9ba1f8a722d38ff02104a797100b1fdcbb98864", + "metadata_sha256": "b37e364d071123fa78f76035d7049ec267991ec86615b9521d084a4dcbb1ed21", + "realization": 34 + }, + { + "arrays_sha256": "eb43158636cb7c8f7c63ee53b48d901c482b2edc9ab0068bcfb5176376742357", + "metadata_sha256": "b182b4485873baacc32c8a40e02b691e4400b213954dfbc1a5edba2cebf383ab", + "realization": 35 + }, + { + "arrays_sha256": "573d56f236645e14b69be907fd1f25e95b416cbfe9495fa101544cd37ca181a5", + "metadata_sha256": "57450a3a5cfdaa4b5f4ed4d92c17c082922f23e557ad03b0bfe501b6242e800a", + "realization": 36 + }, + { + "arrays_sha256": "de7a464082ccb24cc5a9732e4ac6af7f07e75e0f5c1225ce09ad434216816c4f", + "metadata_sha256": "4b36f182676a476416eaab660e3e10fd5450f20e4db7b375e935a56fc3ba6b86", + "realization": 37 + }, + { + "arrays_sha256": "7790c42e0d60d1253b52372fe6534e78150d62e8e863193183b77dfdf071f492", + "metadata_sha256": "aa74167d2c442181a19226b63888ef47660a8344dbd6828abb38edca4c85c397", + "realization": 38 + }, + { + "arrays_sha256": "50194676cf04da95725523f000510e099ff84459a9fb425fc674eeff997c1be2", + "metadata_sha256": "a9befda5e75d86a9530a96c1919656a72edface805ccfe06be00b84132c78cb6", + "realization": 39 + }, + { + "arrays_sha256": "dba4a33e5d8b98c3152b608a887bd662a6506efab93af68ca3b14d9f4daa1dab", + "metadata_sha256": "321c767d66e8690c733002e0b9ed6c6e0065fe93c4940137d38033b559608f21", + "realization": 40 + }, + { + "arrays_sha256": "b9dfbe2b3b469f9a9342dc463daeacdb8159c00faef6468b60345b90ce25c195", + "metadata_sha256": "a694ab12cf08d0e90d8b1b7500ffe84d4095a2bdbff8ce04cfe0d199f206f9f3", + "realization": 41 + }, + { + "arrays_sha256": "46a72d1f3510973b530e41c4185a2cc175fd7d77e8d212d04c998739084e62a6", + "metadata_sha256": "9ac2b100796565d2a18723a238d97d35967d95c97da67b1dd4bf15c9b99648a7", + "realization": 42 + }, + { + "arrays_sha256": "998435fc797756740e9c356514ab57421def6afa44cad1602434aca00e0af02b", + "metadata_sha256": "e934eda31f8536240aeb2a8a9f63b3ebdd340b81c3b22db26fa378695abe293f", + "realization": 43 + }, + { + "arrays_sha256": "4c02b0338af7f0737b94a983dee910f57a18e3ad21dd2e914e66aaa8486559e5", + "metadata_sha256": "69cf288c57dc179287144e7f9085ce5a4cb199c39fcbc3730674f7d214591f4f", + "realization": 44 + }, + { + "arrays_sha256": "d42b6fb27daef5ce654f9bcbbbf9fe9caf8a79152300f7d742ae84d992e676a1", + "metadata_sha256": "9d9dffab2d3a1a67bef4be9e9c67dc12078e9dd0103c1ea8b30a341a00fce9cb", + "realization": 45 + }, + { + "arrays_sha256": "189ecdd332b5e2b886d2700e61a5621d5dcaee5790e2dfeaecdd6b627eada25e", + "metadata_sha256": "d5a3ce2064579f826c627f8db5463179013eb8867720a9eda5324598a30dbc38", + "realization": 46 + }, + { + "arrays_sha256": "09ecc6dce5f394701cc3b7db5846bcd7b35242987eb14aea390cd0ab6a6c3c28", + "metadata_sha256": "22057d2289101a80946968abe9d3ef2965f352e3a4bc4eb8ffeaaaf32bd2a426", + "realization": 47 + } + ], + "observed_median": 0.20073119910082154, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.19694060198755714, + 0.2082583902883576 + ], + "realizations": 48, + "sector": "adjacent" + }, + { + "N": 10, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.15280228203687626, + 0.15413349564490572, + 0.15571959826527199 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.15816799904416937, + 0.15990057317658485, + 0.16185676188209575 + ], + "median_hodge_balance": 0.14001760189653722, + "null_banks": [ + { + "arrays_sha256": "9284b0988e141ae56c0026e6ce6eacbefd7ffb819b35c41b1ace35e41c0f7f6e", + "metadata_sha256": "01b84ef06849f03e7dd25bf0ade77ff412d37ee4fdddddd85e2ed9b5aedd1c2b", + "realization": 0 + }, + { + "arrays_sha256": "a01168139ad924c7fc9a3ffd576bb2d96112baccc77661db17a0d27e9c6900c5", + "metadata_sha256": "c7ebf0eb554286b929f1505ba3eac087d89c5956660cf07449c310534c0ab4d7", + "realization": 1 + }, + { + "arrays_sha256": "658d113bc8e2bbb899076269de7c799258fe24d3e66d133bea080c6fc18ea630", + "metadata_sha256": "296402f3f52312ff3c3dad2b9af8c548d72171ab8bb15fb638218e38356fc370", + "realization": 2 + }, + { + "arrays_sha256": "5077f1c54c410375e423304a662cc3fa271dd08d1816f88167ae97764056e729", + "metadata_sha256": "b9d7a99db92f769e01466f196ccfa48b1626aa7799e0a621cd1d8642df3bb2a1", + "realization": 3 + }, + { + "arrays_sha256": "5929350d2b8f6ea0cd44dd0ab7faef26a2969c9940448254d2d14243f5c2125f", + "metadata_sha256": "4d4e2bb8aa8502b1dc381702ad4cc9886b7d06669babfd3c7d18fbc12118a278", + "realization": 4 + }, + { + "arrays_sha256": "c902f47c3f8042f3775a0678cbfd3af42f9e6003e5e99b8d13a611faaa456447", + "metadata_sha256": "749a3feba16ba6331fdeceaaaac6260d26b623dae9a5bc2d356281afe626d1e5", + "realization": 5 + }, + { + "arrays_sha256": "035e11dcdbfbdd8cc93c812d36633f43e84a0ceffb8c50ff7f3d9c4b9d1e5383", + "metadata_sha256": "de60a45c4c800a18fe524f3efee7ac5c3e353d0f8f403427de7c2ce754a7b2d1", + "realization": 6 + }, + { + "arrays_sha256": "04426533bee5b502955ca337218ed5945da95d41db81fa37a10d880ad0638b9d", + "metadata_sha256": "294d142e6b88328a0c02283477e034cc87dc146e05b2ac022078b70918ccd0c6", + "realization": 7 + }, + { + "arrays_sha256": "f52a0e1dd1840a51d4b9b66d868b468375738af500b11bf9f2b78ad1ec4bd9f9", + "metadata_sha256": "5195af065e67b5f4d9697ad4a89356fe1dabce2920d40819d0f8c172437f8a24", + "realization": 8 + }, + { + "arrays_sha256": "e37416e0afc53e319ab094692423c64702515de576610439f440b13985a27c0a", + "metadata_sha256": "0f904de501c6d61338ed2a4e125c72029dbe23fcf140c90e49a7fe0199a7739d", + "realization": 9 + }, + { + "arrays_sha256": "7bed9b3267715f633a1cd739a63f7db710732236581378bc8c7e5dee0c0223e0", + "metadata_sha256": "52fba6e27c671a5e2962c8c868de81bafce9add722c1097db7dbf8c922febcf7", + "realization": 10 + }, + { + "arrays_sha256": "607e69bea29a108b0ee850c1b22d53e1ee6a3f6a20856e2020babd6f755bd576", + "metadata_sha256": "10e5cabc68d1a1d1f684a8e15d19c048ceaa9a1c3f0394d1616c7fbdefc1acd0", + "realization": 11 + }, + { + "arrays_sha256": "c90bf2f85926ae5fd48ca48a7d5787f534ea1085d065b58cc939ec0b1cc4d5bd", + "metadata_sha256": "48f0f3f167281aab5fb56209e57a3a60c1ab8e651407166e5c7f25bc2618e0ae", + "realization": 12 + }, + { + "arrays_sha256": "cdda9d36d01cc1ff0dd7e9a044cf207b734543bbe715358653baa4e2b8a71e75", + "metadata_sha256": "6abf55a0b06e14b6cd882757a76a4b1261993b49c2a231ca3ceaecb91477ed8c", + "realization": 13 + }, + { + "arrays_sha256": "8f6b685360a1bab4bfc4866803a5f7fd6de701fa300589bee517133d7437fda6", + "metadata_sha256": "cf6322789dd38a3ac11f8d6c428606aaffb97d279659f40d7ae84b5f40042ea5", + "realization": 14 + }, + { + "arrays_sha256": "49c25d7c03ad18b07d4e8366e72d17406eb92a6498cd107e32bac7d1026a1dbc", + "metadata_sha256": "5c4acb3040ae5931242e53076f34e8aa9e7d5da2d7e6223e70c0dfb6c4e2bd9e", + "realization": 15 + }, + { + "arrays_sha256": "c962154657743aefab10f9faf2cff2439b94fc719e9bab63cc7da5e8a85902ef", + "metadata_sha256": "54604647a600a266a8f8cb8ff0f9c3406701211235e596041e4aa574ab4190e6", + "realization": 16 + }, + { + "arrays_sha256": "9e20c99cbd03ccc3da32e5378c364e10e7edec86a4ea840ac72c19331cc66448", + "metadata_sha256": "43d578481b58774f81e3dd08b0dd9c6f8edd7f1c84dd14fd4d0f3dd97513d9bd", + "realization": 17 + }, + { + "arrays_sha256": "0feb5c975d261997277ed835d26bca8051c1a45f11bade2cf1409fcd7ad6f0de", + "metadata_sha256": "8acdbb6edd84569a809269b4a0eecf082cce1f74e638706a3a828cf7978e244e", + "realization": 18 + }, + { + "arrays_sha256": "818362eb96103350295ec264bef0d1a9547ef189d55b07179314e850bd9b68f0", + "metadata_sha256": "ed9089926a588ad54f459aa50ce2e328b010d065ff4ee7e5f8bfede56a863aa2", + "realization": 19 + }, + { + "arrays_sha256": "90592b7e8fa4af46e9fcb117a5fa7265bcead6a481322a76bc94dd94c1732e08", + "metadata_sha256": "ab72fa4a80d5eb28b43979883887761649bc08a105e3fed64e4c8539d619aa86", + "realization": 20 + }, + { + "arrays_sha256": "3f1f9324f167d052f4289e7e5ddcf33f65d7c39b11618f312e147231aaec867d", + "metadata_sha256": "9cc5e663816defedd1eb59387048caee601a5fc8406f7f8a27f0d1f967fada47", + "realization": 21 + }, + { + "arrays_sha256": "f63b537796ff5d845243aebad44802c3381b086e136eeb91eef38007826c916c", + "metadata_sha256": "3677817b98650cd8087d33a4cf9e6d33a0f58360ddc297b5919ac11bc88dd3c1", + "realization": 22 + }, + { + "arrays_sha256": "700414986e6d4f26d021911ad70ea4a67843e71664780f59d74d7d4c7fb66a55", + "metadata_sha256": "07070d6beb67c0c657e7c53ac975534e94a3077b311ad4cae3f15e9810486198", + "realization": 23 + }, + { + "arrays_sha256": "2101284eb1e9d396974baa01bd416e5e36b119168155c0b59e36dc3d5674c6f5", + "metadata_sha256": "a373793fb6734c03cb792bccfdcf15e2d66137bc8be04114603f5cd62ead705e", + "realization": 24 + }, + { + "arrays_sha256": "0989fd6202ce8f9d0dabae7fb6a0e9ae64e525eea6e918b75d28758995fc24b0", + "metadata_sha256": "696e4f615e611d90bf58c7b2d1f0777f41dc6f723b36608b5d5bd20f09537bac", + "realization": 25 + }, + { + "arrays_sha256": "049ed873cd174af091791aee7484e33ba91e647eb7dec835181021e6d4be8b89", + "metadata_sha256": "7461d273c379665c3073d0a42b54a2d55a4d280cc6999c181324dce3aaccf3e6", + "realization": 26 + }, + { + "arrays_sha256": "858274e0c651a71986a394fd336dfe4719cd051eccc8fd3c423afc2602e61423", + "metadata_sha256": "2e2871109167deed5011dd915b96135a1f7ff5d1ded0b76092228fe85c2a184a", + "realization": 27 + }, + { + "arrays_sha256": "079bdfe07d0d8231b875e7f44180d09b66c4614a7fd265af91c24a906ec8b9b8", + "metadata_sha256": "c003a6854f0b9f4c0f6865e63e9a24c77df96928d8e5605466881fde92c66f6f", + "realization": 28 + }, + { + "arrays_sha256": "eb6b1211b970e9f20486b1b89e8a7be00b8b34cca7e526610c103b0dd60a96c4", + "metadata_sha256": "b426dab9aebdeb2327c61b29ee3a0453fe4e2b28af5041d5fed2bd9c85838c32", + "realization": 29 + }, + { + "arrays_sha256": "5c0463d69525bbfe1477475715aeccc940d2b5a4b3c6b4aa6e42cc6ae7e3a51d", + "metadata_sha256": "152c947701d398229f057ecf8e43dd1e002a035f97599a14e361d88adac4b371", + "realization": 30 + }, + { + "arrays_sha256": "6daedbda474fc23d7bfa0e1919c439ee45c58dda62827e79b2cc79a6bd2ec974", + "metadata_sha256": "aab528d9c184ffcbd8081fc3e6ad7cb81912d104e918b0b7ea69f2c539f44b29", + "realization": 31 + }, + { + "arrays_sha256": "e10d99e2d6db4fc6925d16bcd2a0daf60ac308ec9dacdc982bec0c02be55ba3d", + "metadata_sha256": "e4c056f6bdc271e01ca95a47706a32f1ae148d120bd95004bba31dc16922ecb8", + "realization": 32 + }, + { + "arrays_sha256": "4d568cf6af94de66c10f34e3fc2e6d140ef9654d791ca7fa3461f5f065b80c64", + "metadata_sha256": "48ae8699d8da1de246622fb23cb1477a01cbbf39e04fc218d5952a0e9829e901", + "realization": 33 + }, + { + "arrays_sha256": "178af73ce22f57312650c04c92f9709938bad45a5ada2c9070a3adf24c56ae52", + "metadata_sha256": "ce51eaa85723eb5dad748757e8a7eccd69132141407e78a0ca0e20b03cd90ae7", + "realization": 34 + }, + { + "arrays_sha256": "0fee466b906b2527352e900b7d0440e130e674c72d9013e14549c15a89d93450", + "metadata_sha256": "e07d1cf107aa6e20bd135edb834c78de6ccf1110b588a5f72a423e6a66d47afa", + "realization": 35 + }, + { + "arrays_sha256": "8b891db7614e7de597b408500e86d58c6510139ae270a54ee2634da5f6eb5732", + "metadata_sha256": "8fa56343dd6dcef976534166a9a6351e365a8c983e8570c014372761cd6ab5da", + "realization": 36 + }, + { + "arrays_sha256": "46ec153442ecdbeb89ed7569ab3bcb6ab896e5b8f31be5a881b011a7cf5e4cae", + "metadata_sha256": "3f7b72641781c099b16498c62362f84fea37fa9a7cc7ade54e6ca60501cf0667", + "realization": 37 + }, + { + "arrays_sha256": "40567e7e2644fe53ba0942c4a36f6320444767f932c3c032644d455605e3c703", + "metadata_sha256": "fcb4bb80a664c323dc49bd525d810ec7c25212933aa3731638efa4e6c3ac9710", + "realization": 38 + }, + { + "arrays_sha256": "1fdcc452e4d83c1dd47505fec52dd70aac613661ccd4e8dd53621ec5eff5d0be", + "metadata_sha256": "1185a5d5673dabfa92bfcf44bd41fa685aea9f34ac827e9d0aac6575be6124ea", + "realization": 39 + }, + { + "arrays_sha256": "23cedf88e7d817442583d36f62ab42928b5987bd435e64eae49ce7aaaeaae2ba", + "metadata_sha256": "ef9cb09abc726166efaf8d7cf4f175c5a5dad10ea260b800b8ee080fe426ec29", + "realization": 40 + }, + { + "arrays_sha256": "4bed72f2e140b59acaf13cff58c06edf0591278a84d0fab475d4c340e14b104c", + "metadata_sha256": "2b7d00e86392808900d473163590ce0183efe75e0bb4dd91873005a729473253", + "realization": 41 + }, + { + "arrays_sha256": "6d9ebad14f6b3a70a1348ecbd83c75249d8203ef54b0eeac64b66e353104958e", + "metadata_sha256": "28fb4135a013b7c93e0dcf14e1c9fc405d1a38b5f7936a1075690fd59e44fb51", + "realization": 42 + }, + { + "arrays_sha256": "d12b9fe842d164e1e3101431b94ad88f8c68a3f07f56a3a13490f74db467bb9d", + "metadata_sha256": "37856a4f2af8f7b4b44f644f881ec6f0e81f574addb0563f0005d4dd0ad788bc", + "realization": 43 + }, + { + "arrays_sha256": "23920433bec92791aa605dd22008504727bfdce1913220b6ae4461649a022967", + "metadata_sha256": "86b04efb41dcbb82b2789fe63d3d147acc936e156f25917a4ae788b5fc5d528c", + "realization": 44 + }, + { + "arrays_sha256": "3bbfa7124542fd0bb3d6215df3dbea093e904797c203ec153fc143c38724ea16", + "metadata_sha256": "7f64057f0f5e27334b4d76276dd4016957d912a4ad0e45f6ad6c50b71f93e07d", + "realization": 45 + }, + { + "arrays_sha256": "09b0bc3b06a04f12a8f67fb8eb4afd2ae98e4ebab403205ec913b03aa230f480", + "metadata_sha256": "053e10c4e695dabff57de936a06090fc06a846dc4e6951a7b74cb64fb00e8799", + "realization": 46 + }, + { + "arrays_sha256": "5e9dbdd6e6cdd0d004befd8d761e1ea006cb6d52e43eee453913e1240c9bdeca", + "metadata_sha256": "337c99f8f2ee3597085605255e4c9a2fd5493b988b16819d5bfe8ac332a0b614", + "realization": 47 + } + ], + "observed_median": 0.3326829386707436, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3277302349036726, + 0.3365367304550048 + ], + "realizations": 48, + "sector": "adjacent" + }, + { + "N": 10, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.12354756576977215, + 0.12380059338068258, + 0.12405028033654811 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.12469691271184806, + 0.12496969707954547, + 0.12524599110490295 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "e374e8a2465a8ff0971bfcbc083a0e0b76f35299864d606abd0aa9d0ec3fecc5", + "metadata_sha256": "bb886102b81857a37cd6452c9f15eccae77638db27aa1cbad6550316a8b4fec2", + "realization": 0 + }, + { + "arrays_sha256": "eaba9a3efe1db6e0d0a4161cd6934427f172d8b422e9ee5c625f048f8326fe64", + "metadata_sha256": "3a2ee0389be1e8700b8990435c8c7fcdf8467a5706755ccee810aee1c9de85ed", + "realization": 1 + }, + { + "arrays_sha256": "6780c8f83e0eaaac3d588e847cd4fab6ded83fb0c871714cc6630fce1be31c18", + "metadata_sha256": "9b7b1124c8663f220639155e5f36301614b4f1857200fa86039879a76b10202f", + "realization": 2 + }, + { + "arrays_sha256": "58371ece7bb623d456192257b6ff64d928d23ed5401939be394210d1f775452f", + "metadata_sha256": "27b22b34f5a870f10042de975a200bb0b2e5e4372e99a15d17511948fccadec0", + "realization": 3 + }, + { + "arrays_sha256": "396f64ea281b2fb856d9a5237b9acf332a6ffae6a750f181df27e0fd3f56dbe9", + "metadata_sha256": "f3a49baea40391394f249070b2875c4a5701ca68b5b83527686c362d121fc45d", + "realization": 4 + }, + { + "arrays_sha256": "48cd57eecc72be0537f9b7be14ee306b28729e2a8a1f5fbd0d79957405650eed", + "metadata_sha256": "39778696c9f6bbf34c7e45d8134ebd90eaaa99e56d81b84bd8422c4af7a97d57", + "realization": 5 + }, + { + "arrays_sha256": "8a033441ca6b320af8319b70c25731a2b2c729091a734323faef8396fe886e1e", + "metadata_sha256": "762c5f846837dc9a50b8bd6ce978179c23626f78b52ad7665eb2754964f075aa", + "realization": 6 + }, + { + "arrays_sha256": "afbb53e999493fad74e3c698a6f04bd21b06c3da9d43bf372b7213d191c7c67d", + "metadata_sha256": "1844b88e7d30a3abe21c8e0eeeeb6889beb148b6dc2ce91defe756353b6351db", + "realization": 7 + }, + { + "arrays_sha256": "9d3f0988f65a5f85349cd27707e4ef6c3f630b19e4be3f67ef28e4009d50e8d9", + "metadata_sha256": "e98d06856ef6eec0d7d3c56bf9bd9bb07d14a80c4206f743283b1940e847e5cc", + "realization": 8 + }, + { + "arrays_sha256": "778fb26f430cab935d6a13d35d6758c5e3f005f8116942b6f8498dad2743a979", + "metadata_sha256": "c0c8450313a916287b689c036e07ac2276383f488b51bce5d64638dfec5ec514", + "realization": 9 + }, + { + "arrays_sha256": "250e1b91c4c6a52348c930d503f45970801ec8bad0d2baa59277137834d0344f", + "metadata_sha256": "cf3ceec74aa9feb31dc352f79588d1341c90bfd2cb7e0425794e0169206a25f7", + "realization": 10 + }, + { + "arrays_sha256": "b23bcb928cd09156e6c53d5e940a914fc41cf2324c1f60e64b9753fcd2558d24", + "metadata_sha256": "4f83281cd78b619d2d2f3c6b003a28f72fa587cb6399e18ee33fab7aa9fee2c2", + "realization": 11 + }, + { + "arrays_sha256": "9e19c2403c197ba3d19b6d8535846d3af0d3e6eceb0c6e0222f7aee429d1aed3", + "metadata_sha256": "f90a4cd6190d3aacecfa4f14b95944a6c37797bed1c5a5a60f3df0f64c786b5e", + "realization": 12 + }, + { + "arrays_sha256": "14dc37e540fccfeaeac4c2937cc97aefa139a9343c92478853766047b6f80c8c", + "metadata_sha256": "914098114a1f6bf6519db2093f7714b2ff18e91a69672630f62553d504e5dacc", + "realization": 13 + }, + { + "arrays_sha256": "3a5e6262da3c7543d61c82f6ec01824746bb650bcb373d642226fe75cd8e0e7c", + "metadata_sha256": "eca5dc3575173b540305de3fbb2515d344ebc9f66a6349398a7c86a7de8f2e46", + "realization": 14 + }, + { + "arrays_sha256": "1cbeefe4f3e98e71baec74ae793c910b34a84651f3ec0b888be4a38e9edce29d", + "metadata_sha256": "53f945951e3645a7e1825d31129fbaf1e5c922737277f7f025e0036b0dccc8a2", + "realization": 15 + }, + { + "arrays_sha256": "312c29c4c288ed3c10202de685dbeaea53a8a5af6454353ebf1eefe005d68fdb", + "metadata_sha256": "8ddafc6922d0f286f006b447e65a315d5b2a11c9cbae7d383bedd8ffe2579e29", + "realization": 16 + }, + { + "arrays_sha256": "ff1168237887749e564d1c1c4d824e334bb8b064f856e795b130418575ba2f38", + "metadata_sha256": "22c2b2396f085e89b802987872d10a87ef3e73517193c993eab025c15fedd998", + "realization": 17 + }, + { + "arrays_sha256": "74bc5811f2e04ad11e8d96f9e6c2a4319920479fe194232821d67ac62b785e8e", + "metadata_sha256": "065204689624be34c89cf390b45912efd1ece4de39339fdd81852c1f819b2875", + "realization": 18 + }, + { + "arrays_sha256": "3bb10d1c8becd00726dc0f72c2c1ae212aee5f0439f0cef8a188fa096bd3f4ed", + "metadata_sha256": "34e88643883a522771adbc853d857c958bf27837cb952c55d01b70d07ef10040", + "realization": 19 + }, + { + "arrays_sha256": "51f28a66f9ad9df092bb987e7a97b6c110c1319a41e9ea2c617aef7ea1027cd5", + "metadata_sha256": "5faddffe805980894ed92d3b23ba9678fed329ac14154c390faa6d534f1548ce", + "realization": 20 + }, + { + "arrays_sha256": "bcc77dfc9e93cea79930fb88056a7c0106744fff4d0e06e814555c83d58c4de7", + "metadata_sha256": "a9c3aaa98ecf5bdd8bd4ab8e7d226b10c087a9e056a9edcaf7953118f648d0a6", + "realization": 21 + }, + { + "arrays_sha256": "ffe8c6959e54860c70bd939c592316f3517cd1243412df64f1181078b8ca3c76", + "metadata_sha256": "60adc1f14ac0b418a037bbb96a24f818c7e635056cd374b1d6b8fe6ddeb6ff08", + "realization": 22 + }, + { + "arrays_sha256": "c9544bd44b9103d9cc01153a31747317f52674997b156c8adda63017eb1f57d6", + "metadata_sha256": "7fbe5c7a8622cc86c8ec043217d0e2be9a3a56a5b93eafddf951ea49b4cf8719", + "realization": 23 + }, + { + "arrays_sha256": "a025c6197225c1d5d5175de6e005e5baae1699b06c43989d3fefcfb863abc6ec", + "metadata_sha256": "40c7cfdd5e431c14935eaf3e0e2af39249a2448a9ac3c7328584fb4c099a10b6", + "realization": 24 + }, + { + "arrays_sha256": "5265ae4b5e9e24e6e8376ca10e056f454375548e162d5f6175f6bd0ae69137c3", + "metadata_sha256": "138cd48bd79f156f2b02fae3e5aba74788195487810b0a64448f17ffc7b5c271", + "realization": 25 + }, + { + "arrays_sha256": "2e128e809b610e9fe0556061ca92df05fbf5af78cc4a22552a74366fd28768ac", + "metadata_sha256": "c80860c3db0e5c9af4f91a99f34f692f0dc607b60741325caea295924e8561e7", + "realization": 26 + }, + { + "arrays_sha256": "6ea77a0ff7d413aa4fbf26d920a27bb5cc8e49613584c8f1e3fb160005df72a3", + "metadata_sha256": "ce7878fd47ccf3a5d80f66e3e494472cf3469a5ecc8b6e40d8cd967d94dffe95", + "realization": 27 + }, + { + "arrays_sha256": "32418286a65666117d98720a86a8f9013251306dc797ec4477f0d87898b255ee", + "metadata_sha256": "878ada5a52c2aac8323c4494afb2e228e127f262ae14bc273bb97c5c0a12622a", + "realization": 28 + }, + { + "arrays_sha256": "ac8b92464cec21c1d1114791662a5391a77dc76472174ed7f6724d38138fe1c6", + "metadata_sha256": "35e3259c604818000290ccca6748cd4439200e9de8beceaee4a88da56408f9f8", + "realization": 29 + }, + { + "arrays_sha256": "12670943bd38c8bb3b2713c1277b56b81b4b446888774df319510e0f7eb53cdd", + "metadata_sha256": "793b528b771502d4870a261e84c577ad40bd5b2d2976defaf3100b9991083dbd", + "realization": 30 + }, + { + "arrays_sha256": "55960c3bb024ec551437e03cd27e69583784bf2d2e3e2dfd45df5d3bde584d0d", + "metadata_sha256": "fe896a8f67a2c9b010a835cb1b841d783c561eedc916f3b298ae2fb817dd5fa0", + "realization": 31 + }, + { + "arrays_sha256": "c58f82bc7c9f0f013deddffe9a4e97e0c9c0c8c8a2360d4eb3906324eb3405a6", + "metadata_sha256": "c26ab338b7cc894cbb84e05fc277afe838f4283a747209f8a2796006e4ad4335", + "realization": 32 + }, + { + "arrays_sha256": "5bfa17ed40d66293267c04ae2b566add94c00b46e0bce35ff5e68943de0cdd99", + "metadata_sha256": "3cbfe9e7fcd592d8185ef198882629662a2bf05c1ffce62d2cd0517b2324ed0c", + "realization": 33 + }, + { + "arrays_sha256": "76b172330e9341e4a48a5db47738e61d4b8f0b0e31926e1fd892cd0edc744e02", + "metadata_sha256": "a5bf0b90b79a5e38b68462e71b5f5aae5c41d9bf720d85ec7d61c5dca9697b00", + "realization": 34 + }, + { + "arrays_sha256": "98880f7f9a07c61b87fea38ae14d16de6c6409f528025ead4797ce7f523e1faa", + "metadata_sha256": "085ed88c153c478648f370ea158faa5c0570a0532407d830bde23f7ac6f6e1ef", + "realization": 35 + }, + { + "arrays_sha256": "2ce91cc906c21847d5bb14efa4d8b96dd1c8eed5edba64301db20e2396960b02", + "metadata_sha256": "5fb0b6d81c87ff320839a8f4a164ca269ecbb26275c6c6fc0a9faa1758d01235", + "realization": 36 + }, + { + "arrays_sha256": "a3891c1985bf14574a0a6c7cc4453bcb0f1c758e7bb4f53313a113524bbf087f", + "metadata_sha256": "eaad75ab2b69839c7c1a3490dda86cab1e78edd8786bb696ba01fb72060f95b0", + "realization": 37 + }, + { + "arrays_sha256": "9bacbc48e6b1873c7fa8cf1c4ca7fb9bb3b2c1b7ca0691ace64ab093cde20666", + "metadata_sha256": "031a1e0bbf2f80c81224e1ae001de3a970228c60fd6f887ae19809b1fe59bf90", + "realization": 38 + }, + { + "arrays_sha256": "e8160da407915bcf201080004cce8f1339fd0c4b5a6e5416de849983388021aa", + "metadata_sha256": "598841639bf4cc92cc20067a55b3d7d6d02835676f5f1031212416065f64f6aa", + "realization": 39 + }, + { + "arrays_sha256": "6ada7e0ccdbe1b1b58825ce6e5b938b9ef43a893b3d14f0e9e7bcec2dd8258fc", + "metadata_sha256": "250345c90a0039abf1ae28d6ff9597cfc0bc6415c849fa70c6e976b2f6bc78dc", + "realization": 40 + }, + { + "arrays_sha256": "a28a23913180bfe39a0bd3b7b3f15e2b9580ccb0c4ba2c0a92954d477f322c00", + "metadata_sha256": "2e2a90bf9122ffae79d5265917233e9ecf6d9bb528ce555c8bd938e7a0052f97", + "realization": 41 + }, + { + "arrays_sha256": "86f40423a2040dcfb1efb28bd13e9b1bb15d3cb701844ba4e0e204ef0dc17c40", + "metadata_sha256": "933b4d31ef2678ab5bd115dac8cb08b3f5eac769410bd93faa6b0e74059d48c2", + "realization": 42 + }, + { + "arrays_sha256": "d18ea3ce9aecc5007f983d539196105ae72b262c632f40057829decd6ccec0f0", + "metadata_sha256": "055f3c606758b5eb37a8b2fc327a04406ad37b1103717f1c17c5761c1ce68696", + "realization": 43 + }, + { + "arrays_sha256": "1c17df8e6d4af3ef7e01025473ae14bb7f892edcf10c88355b33fd92c3be679b", + "metadata_sha256": "7a3fc77882896c9f926def21fb9548cb58e8992fca5ccf8d2eb73420c00fa5fd", + "realization": 44 + }, + { + "arrays_sha256": "b74faa75df7585ccd3211d2de3ffb4f309e3a2dfcfbfcaceda2da6dcbe9b0468", + "metadata_sha256": "83e9669bad211f3a217487ad0a8d7f15079e41d1b9bea359febd9bddc62f2a46", + "realization": 45 + }, + { + "arrays_sha256": "4c7b2ecfdecaa715c1d5781462c6fc05937ef0a229ee3d15ccf6d5014b466d95", + "metadata_sha256": "d8012490610fe667c0d9c5dc1273577400f80855596cdb01f5ca83ff53277328", + "realization": 46 + }, + { + "arrays_sha256": "73672df8b422e7a80f34e2faba193f95b1f9bef08efb5020aadab7de50ab9048", + "metadata_sha256": "2b4910be086f22647812de67a919a90669697eb2ec8a622fefaa2debb677d08e", + "realization": 47 + } + ], + "observed_median": 0.18385937035136762, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.18307874781812727, + 0.18436442290778826 + ], + "realizations": 48, + "sector": "central" + }, + { + "N": 10, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.12719097687925934, + 0.1275507134996125, + 0.12791357917909646 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.13031001749502513, + 0.13087028005219342, + 0.13143794811300344 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "e8bc5cf8c42d760cb0e01aa72c959c2ccdbae8a513899aa6edf715589cb81d7e", + "metadata_sha256": "73465ebe969142f5f7f931eb90893d6d1a48a573ac5422397ab321f295591efc", + "realization": 0 + }, + { + "arrays_sha256": "6b5c8e95b379ba6ce62a17e8c91f2ca613ced06bdf4a2f65edbc38d7cd379c4f", + "metadata_sha256": "62a03dc6a70a6aadb09f9125977a76eced0617a88f5a25423cd8d0abc9efc540", + "realization": 1 + }, + { + "arrays_sha256": "8956a56500f112f4441c2cd62fe8dc2fda5fee3f824feffae388f96763fda793", + "metadata_sha256": "c76389d496a0c1110faea57a806129c3f7e07ffcac8df9d75bbd9317acb15e8d", + "realization": 2 + }, + { + "arrays_sha256": "450b275af961fc110d170e061a7c38f58e8ba6a55fe2cd0ba3282d3052ccc8f4", + "metadata_sha256": "99f6f1bf8e9158612916fd947484e42153413fb32b63b6c4701f9feab6baddee", + "realization": 3 + }, + { + "arrays_sha256": "198fc065df71e865d266b05fd06f9461c8fdad9aac086b1d3fdfbc8d8ce38941", + "metadata_sha256": "7830c99f9ebc50f4b3c6c76042bdc26ac640cbeacba6ecaa67ec848071a8b632", + "realization": 4 + }, + { + "arrays_sha256": "0d7551808d971cf3be0715863943a3603cd98b96d44de5c3a648a1f79214b328", + "metadata_sha256": "ce8573370a89ee7e3e052ba4c7ab7fc146523cbfbeef3f8eeace1eb9d2fd8bf3", + "realization": 5 + }, + { + "arrays_sha256": "a0bb1093426b4637039f5247c6cd77b988ebc952f06cb53d871ac3e7ec59173a", + "metadata_sha256": "e355e05d6826f10b2d8d7ac70bab68a9a0250ee9330f173c303274a68175b5c6", + "realization": 6 + }, + { + "arrays_sha256": "4d93211bf9df5b205b561d3aa4c3f9476f0659ab438649e6ef2851f00d9a679e", + "metadata_sha256": "001d4a52c63f96d782511375e89222890273ca2b077c0e4c227fb4011c786b11", + "realization": 7 + }, + { + "arrays_sha256": "af99d83e08d4b7d6aca685149d8e0e649597feff8c3deb4ffb1541cfa1693397", + "metadata_sha256": "eee4e84a6b28f99de9263e2a68898de6d7156be7d86e8eee4b99d47d72a4a11a", + "realization": 8 + }, + { + "arrays_sha256": "54cf02030b055f806066b98cd7d6983eefed5f06d43a36126bd049218e29f04e", + "metadata_sha256": "242d08aee58cb3272eaa457a3dd1a1c1f9f39750658084dd6859ee3402c4e81b", + "realization": 9 + }, + { + "arrays_sha256": "48beaa7d146c6b9f1da93b649c3fdecd24ca5f7910622db359aa473cda9386d3", + "metadata_sha256": "f0abcc47b3f3b0106b1280898b2353d3b9f611d531851ff0d69252c10915a951", + "realization": 10 + }, + { + "arrays_sha256": "3ca8dfde3f04597fe6662d556811b9d5b7f8dce25dbb32b3e6f4c85c0f8915ff", + "metadata_sha256": "664c4adf6b250f757106b1329cd39a339092a1f20cb6bf74eb4ef45689f287a4", + "realization": 11 + }, + { + "arrays_sha256": "46d8cc1895dfb3f23a3d38d9a472afa2949ccc30248ab2fe873c68ae7f98e664", + "metadata_sha256": "77f84d1e54e9d0e3f0c8322a9bfd7e3c209fcae6ed18a25eb61a1071b34c3d13", + "realization": 12 + }, + { + "arrays_sha256": "e5c0fec56248acde29cd89410e250d383b71d481d3f1722cbe38b724bf196db9", + "metadata_sha256": "a7ecd7067d634a64885b7f99fb0f2ae2af9293c6a4203508d9ac11b5ca8b9ed1", + "realization": 13 + }, + { + "arrays_sha256": "1dc7a051012e609eb64a4b4813d77a41a313ad4e9edaa4ce51c0137324a640e8", + "metadata_sha256": "1c0108ba74a8a36050ca56813ee0679f8904f54e230dc1751efd1b30b1a2992a", + "realization": 14 + }, + { + "arrays_sha256": "f1109359c382de232a439da5bef4e85d577e06abfe8af875fa7fdf0c879b4fe2", + "metadata_sha256": "953134a936a077362d02c4a157d2a4f33041dec10f7098a123e094bb1fbd239a", + "realization": 15 + }, + { + "arrays_sha256": "934d4737a8942f93b32e8cd6cd1e623c843f52c1ad6e288d6e12f0f9f4fa96ce", + "metadata_sha256": "96de573f87b2c77acce78e1be1f9807b44cd40a3b428306b7f6370e23f233e10", + "realization": 16 + }, + { + "arrays_sha256": "425c0d1a3fcbc46a4b5be6c286822d593b67c43cb58332787c24337f0d2588df", + "metadata_sha256": "2e1a5cce290bf92a5c16bbf0910ba0b1bb1d08bbca18d23ee44de213c6ecf2a6", + "realization": 17 + }, + { + "arrays_sha256": "1a7c690565b7825e40058b77a81e64e0099451c96a5ce8a04a912a77ea277abf", + "metadata_sha256": "5e234d6fafee06dc8c97636f00fb881df8b3d12d97e22945d45c1674dc2a6a23", + "realization": 18 + }, + { + "arrays_sha256": "622db28294606fb68eebd8c5f76a4f9e1a7508db4d680774b9421958b228c600", + "metadata_sha256": "aec6cf217d44ad645bc846c60563ae3044153037c7fba0fc109d150c43209e86", + "realization": 19 + }, + { + "arrays_sha256": "60ab74e6ef0fda9076a27e8b6402096c501e4b1ee538841a4dfd85736a4ba28f", + "metadata_sha256": "bd525e264973ae0a1d72890d57e46ef7dc79aa77825b099b9075d4bc30ff3d4e", + "realization": 20 + }, + { + "arrays_sha256": "a1999dd5d461e9a45c50ebbaf73dfa0ac20e1ac1242d121df31a9a136274c15d", + "metadata_sha256": "a8f2c9fa5373b0d5724406c6174b5054a7a9c374cf2dc0dbd04f3f9c8218be1c", + "realization": 21 + }, + { + "arrays_sha256": "eda483fcded719e92057a7a2e688825f9956b1d15ae7c393dfd055b89ab78f49", + "metadata_sha256": "0fc36ff07ac83af3e95c79ac8758b1f04e2eafd0a854ab18d398c425b5f16fc8", + "realization": 22 + }, + { + "arrays_sha256": "8d1f4f3419e34687600952535105ee8313e81802d820453142780987d3327587", + "metadata_sha256": "b6e02c0d88b3b2a51bc35b47bf488d53e2f83c385c7961244eec9d06675aef3d", + "realization": 23 + }, + { + "arrays_sha256": "574443475f30c4f74137b52867f3ac235567afdd54606a68bf9d7e5f41296a02", + "metadata_sha256": "b022708b6cfd0fb83789311ae6419f30f851727b1a4fbbcf59ec14b38aec8c36", + "realization": 24 + }, + { + "arrays_sha256": "50dbb09d43115b50eb103bd8fb3a842e9ab049dba540558885e5339a437e66be", + "metadata_sha256": "ef749b035ebee5975475f77fdf52c95986fc023ccdc45f6eef84410477db79f4", + "realization": 25 + }, + { + "arrays_sha256": "37a22b1857100c3051ac16c9db1e31bdc755e1eec007ad18e2716bd7bd6f9f15", + "metadata_sha256": "419739b2c2a5df421a5fa4fb36d2547fa98d14f7ee4904f5c4dece525a12480e", + "realization": 26 + }, + { + "arrays_sha256": "742ffbb35f93e329392ba0f68d9b87b95124f33328cf38a7eee3f4ddedd43062", + "metadata_sha256": "1ef3dcdda3a84bfdd2b81cd75310aba12c3cf8ae21b68d6810ebb99113c3b81b", + "realization": 27 + }, + { + "arrays_sha256": "de16266cc8e3b6e9f9a805fd71de1938b33c1a048380dfeea379513c8c5b9bdb", + "metadata_sha256": "b3beeb2016c9931ae284da4411cd0fb14fd03c24ba21d897f97b23e9e0861e67", + "realization": 28 + }, + { + "arrays_sha256": "f0959d0f67625631ce773370c842366ec8e1e207cd348f839e5140d9fcea0f9f", + "metadata_sha256": "a747cb15799af4e29a6464e1ffa59cc80cede8431d1b72e5bd089d63e41d06d3", + "realization": 29 + }, + { + "arrays_sha256": "ee6cb7c61e0feaa273072c6efdbf083855c543ef75322985f8f67d6096e998a0", + "metadata_sha256": "e5c7bd9368ec0ab05c201abacec36b26c01760f30b47fc1ce907d5c721fbf53a", + "realization": 30 + }, + { + "arrays_sha256": "96131c59729d37e14c5c231bb55af959fd7e752457f8944693014273688bc3a4", + "metadata_sha256": "cd7fbccdbb67c085e475b9f23d50bb894df690af26df91e12aecda445b2f77be", + "realization": 31 + }, + { + "arrays_sha256": "e1cb330a378218d9a2c8662e68d30432a8d39c49bb4287ecb14cb8860ea3210e", + "metadata_sha256": "167b3adedb0dd4faa38f19e21624bb69b22dd74f281b12793d3ac932a2aa5256", + "realization": 32 + }, + { + "arrays_sha256": "1f4588e27c5250c8739ea7779f484d530d10c7324c118cdb52c49bf199bd3341", + "metadata_sha256": "12041de07e2ec847d06fc913f85f799481b373ee69f6c8fd379cdc3ac7c49587", + "realization": 33 + }, + { + "arrays_sha256": "9508b3d29b035b052cd0b833184b5f561d602f866b1b94d93953ae93d76cc671", + "metadata_sha256": "a62764a175dcb9ea011fcf3b78e67222f7b3a7516d1ff99022a94793e0bc43bb", + "realization": 34 + }, + { + "arrays_sha256": "4fc4048bc8025533554a5361170a547485f3b01f0a78df39a39abbc1cc6d4c23", + "metadata_sha256": "56562fe44733faaf01b794eb5d320e4e7eeca8a55666da527d935a517b963d16", + "realization": 35 + }, + { + "arrays_sha256": "e3c09f44d876120672c7ba532a4c7966bc9d2779b81cfee38906b6f24cde4306", + "metadata_sha256": "84227258376bea3397226dc58c131fd51fcf02afa6839818e9650d8819025b72", + "realization": 36 + }, + { + "arrays_sha256": "918a655e3cf0a94801cd58db45867ac93fde3d4f41dd93ae6ef25aba6f52843e", + "metadata_sha256": "3b2d352484ee3cade8f4fe26ef0e2a10e07974648cddd87c84bbe2c2b232d98b", + "realization": 37 + }, + { + "arrays_sha256": "fc65c6d147c9cf7e35bbfdce5c61c2f8f4ca4d83ff8f88444ec00f5b64cc670d", + "metadata_sha256": "eae43330f5f8a16d995fcd38a77f4a07abc4ab74991b3ef8deff49d6204eac6c", + "realization": 38 + }, + { + "arrays_sha256": "68f2314e3bd8f8bcaf87f7abcc18cef52e358f2927f314f297b4c1097057e9f0", + "metadata_sha256": "f402656bd6cfab25dd0b0588e00a489f47ace4748f47bfbff874c78176c1e9cd", + "realization": 39 + }, + { + "arrays_sha256": "386a7ce2113cc7e42b0fea5a2f1af1b57d30fe3a3aedf4421049af49ee3020c2", + "metadata_sha256": "9823f4ad451bd2523f8a7a80926695fed362ad680c7f5d0213eb38264ae6c214", + "realization": 40 + }, + { + "arrays_sha256": "b5ef0c039fb776b6d608963ceeec7ba2ef44fc519deaf4bbdb445858b55275d7", + "metadata_sha256": "c5371542145184132678a66beaa37ee5f7cd91dc80ede7f79a294cd968c78fa7", + "realization": 41 + }, + { + "arrays_sha256": "8ce3c00c027a013721e874577df5c8b0a2224ccd0e5fc4bfcff5c06835dd9d76", + "metadata_sha256": "999c0c47a671534e88c56f3af44bb6eb962916fb93fc8cbdbfedd1e9c6fb9f14", + "realization": 42 + }, + { + "arrays_sha256": "2aa7acb0a245bcc214c33826ff220bfc8aa946ae9694354774b5acb84ecbcd8c", + "metadata_sha256": "bb7a5514bd5c8c0740f88b16afbd016537ab4ca38b6ce22c10f50df814c81e21", + "realization": 43 + }, + { + "arrays_sha256": "d0afd59d3d4819fbb06d2c8f2a2f7edc3da79b1cd59283dc2a437713c3619031", + "metadata_sha256": "4e060cc1326a22a98805f26544ec876440a6ed0a0d93e6c52866bac4bd843ee7", + "realization": 44 + }, + { + "arrays_sha256": "603c9cdcb9ad8a9603bf50f019d2511eaddc007b52177ce088e96fad73942637", + "metadata_sha256": "d35be8cacd2f02eb35e81edd105360b644c9e705b6fecbe4cab9c889894a3748", + "realization": 45 + }, + { + "arrays_sha256": "65014e6a66107c96520182aca41d42b590e89d59faaf9cdc2649eef641ec9161", + "metadata_sha256": "020b951bb93a1bcb954099b36ef45bbf5d1cc24eb74ddfc39ad09cb59d6fe442", + "realization": 46 + }, + { + "arrays_sha256": "a688ba332ca0daa68e8b9ab79c8f08c5392400c1f3439495b2a9a0ed8469018f", + "metadata_sha256": "eb0b60a32b2977e8ee6a30693a78cb365eca34976b85168517fdec4d736b6210", + "realization": 47 + } + ], + "observed_median": 0.36508816908827135, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3582300374035172, + 0.3713071794566596 + ], + "realizations": 48, + "sector": "central" + }, + { + "N": 12, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11562674375749774, + 0.11581594627090835, + 0.11600493311726734 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.11611791021218781, + 0.11632422011274265, + 0.11653906977745362 + ], + "median_hodge_balance": 0.1998799111975706, + "null_banks": [ + { + "arrays_sha256": "93d72c73c5e31331e12f449e06cb5365c1702e3b81f20db5e468eaa5531240bd", + "metadata_sha256": "dc2cfc5198680dff6f223a5005749c3dfcfd471cd61d0bc792fedba891fc655a", + "realization": 0 + }, + { + "arrays_sha256": "c3428dd0691ea750ba1c23ae9c658ed4863104ab412cb5258e68c7fedb86cf49", + "metadata_sha256": "f4972db7ae54385a429a5cd2b5638beaf0464f589b163f50265b05842b90fe92", + "realization": 1 + }, + { + "arrays_sha256": "e241474759e36f62783ca8556f6ae3bcf3b1950e52df1c7713fde53e9d0d2646", + "metadata_sha256": "8e4593cd3f16d85ba82831a82bab506cd40890a4e02de3b9771404922d5fc517", + "realization": 2 + }, + { + "arrays_sha256": "2e15ceac6522ae21b2ab72df051f7072b095361533b8f59631f9d6681d3b80fd", + "metadata_sha256": "88f28a8089ccb1aba4a3bd8aa7c001e9fdb2c21d06d8151aff8ade27a5ba1ead", + "realization": 3 + }, + { + "arrays_sha256": "f91a8b9a79fad2bea7a9320ec7f7afc5dc7651d54ad18ea09d2d37a7fc5f4252", + "metadata_sha256": "3f823e16a883b25f2ca66877b7065d06a7bb0fdc033d13df088c6a0f406e8b8f", + "realization": 4 + }, + { + "arrays_sha256": "6070427ef1a9b78e035f0b23921edc4f102d49e024e5a27d989b8aa568f730f2", + "metadata_sha256": "00c620be7ecd2a2055ce662cc77b5a04d012c9bf6bcae6a38abc5f30d0ceb1fd", + "realization": 5 + }, + { + "arrays_sha256": "3d76b4800427953738ca8c0890eab15e23137a4d93658ddd23ec0ace3d8399a3", + "metadata_sha256": "5470df773938b67174c13718a35bb66f0ea1ba59b801684064728221d528661e", + "realization": 6 + }, + { + "arrays_sha256": "5e0a165956addfe1c46e649a4afe1fe0b7a6dde713f4bed6e92bfa0d9674f68f", + "metadata_sha256": "9d4768232d40f6a2f1e28e1fa58a728c13816345d74e1a004d947d3a31a19abd", + "realization": 7 + }, + { + "arrays_sha256": "8d14c10d7c3d231a2178d9e9e00515a49dd8e61dc1b99408c17c791f1a5dcf34", + "metadata_sha256": "1fe7f2439738fdfe83bd37e58bd4fc63b586d6e34b22a259643b8fe8407f0b3c", + "realization": 8 + }, + { + "arrays_sha256": "83fb2c1e7beccf62ea01bae3f640919341355ad2563697680b5cf57f50976d13", + "metadata_sha256": "1285f2ae7e696d2278f25092acd4630958ea3b1ad929562eac43fd7deb863d8f", + "realization": 9 + }, + { + "arrays_sha256": "28f7faf83e6f99a94a3bbd5f79424788beccfa0894c6ffbd8b073f6a1ced4b76", + "metadata_sha256": "c60a98c887a2f8b31575ca4736d1a2ad5e78095dcc49dd87d5e5dc1718382346", + "realization": 10 + }, + { + "arrays_sha256": "e76207bd5e10487998161cbc4b96051e7929d3c5efaa5d663b1869ebd93b6d94", + "metadata_sha256": "68954d49eb3100c05182cb5652caabf4ab1f654f6e5857d063ef2ef1e258c6df", + "realization": 11 + }, + { + "arrays_sha256": "0b530ffbaf6f99ffb7b328b2a52fef6fa34fb66d65ceaef842803bf5a4dade0c", + "metadata_sha256": "7a9266933b4f0ffa09044306375222493d09d0d3c1c77fcd3cc4e043f575ae51", + "realization": 12 + }, + { + "arrays_sha256": "9b6169629c4faf0a65bac93fbbdebb6655a8680c946d3e299a67ca5de6da54e2", + "metadata_sha256": "1b8bf635647c16106911c411f88313afd0fafb8f1b5a8979f9d68e5eec4bdd4d", + "realization": 13 + }, + { + "arrays_sha256": "ddd2540f7e807153a6c9fa26a890000310e6d5ad5b8884f64b416d88aa1ec23c", + "metadata_sha256": "688de65b8d820e9c00842d3e3f0e848e829ddde9c4f8335187f8e78a89c518f4", + "realization": 14 + }, + { + "arrays_sha256": "ba0aebeacef9058229f823e48fab18589bd5330b1871ed0ebbcb79a4d1a33281", + "metadata_sha256": "8f0372c83dc97e09050802202372f2ea68ff31941118a26e137ac05785d7ef02", + "realization": 15 + }, + { + "arrays_sha256": "a241fa203dd94f24dd6571cd8bf76baf6b671f69abf4bde3f959b9bdb01de28b", + "metadata_sha256": "ea84a77ef39c908274192fba1b81f5be027281386a3ee2ad6ee2c8f2bc360df5", + "realization": 16 + }, + { + "arrays_sha256": "14125d7c36948181c3f787b6a1e7478e7d8e553ec85f33bae31a3646d7163315", + "metadata_sha256": "6e6fa9131efa931c670e72c7f877e684dce4a6d5dd07ec82fb47e93420592d97", + "realization": 17 + }, + { + "arrays_sha256": "ddb142966a372b37702ecc47a7df9a4127a25fe4438f3f48163c4f10470157bf", + "metadata_sha256": "7829ed0c9048cc6bd3300724341d28bb5556ed28cc6c20bab19e778888241489", + "realization": 18 + }, + { + "arrays_sha256": "0fa055f8e3075822aba6c1d5dbcb340ef5120bf94ca74faf9971b9ecb240a292", + "metadata_sha256": "040eb8fe2e71457af216cac0c5548778e85e10f0388dae9d8ccbbe5c6072af47", + "realization": 19 + }, + { + "arrays_sha256": "bd1707dfab836451c49bb2109e0cd99ede1fca912f935c7bceaa0e086149dac3", + "metadata_sha256": "c02c41ada79ae62e1dd4e24680e28cd3453f0ddc04341095abf1899c7e579124", + "realization": 20 + }, + { + "arrays_sha256": "5d97bf01a9ffb5186e67a5f51e94b186c7c3fb4f2fb823467ad1a7677eebe069", + "metadata_sha256": "e536a54c53124e32cc37143f4210a2d1f130d4b2e2fa3d84c547dad322853dca", + "realization": 21 + }, + { + "arrays_sha256": "5af6cc78890bf3fc85941c71a16bccd5137e24ec02f6e8846c78e9f64956f1ed", + "metadata_sha256": "9bc106cf162f8651bbaa5f6da2165895a5550f2153ad4c3caa6e152e4aaeadff", + "realization": 22 + }, + { + "arrays_sha256": "8b5817b70d0c8866cb5942f8dc3ead508141310764d15676db3e5ba34e275a5f", + "metadata_sha256": "b4c751ba5066ea15a2c8408ce92d4e3f960e0837aaa827cfb21cccdc7d643512", + "realization": 23 + }, + { + "arrays_sha256": "a9ce7d42abaccc0e2ff454b2220a2c1965addd037d6a79fdb8555f8f53490450", + "metadata_sha256": "90813298e72ef653194a2cb85cb74d4cad29103a2aec98b878bc2a36bf85fb19", + "realization": 24 + }, + { + "arrays_sha256": "c65e5c84de88659e989d45fec7851d1bb6bca407e399af0f079daa114da2ad31", + "metadata_sha256": "e0b9807c895876ceaf90fdd8c6fb2c71a0d2ebeccd96ecf8126003cbfca79724", + "realization": 25 + }, + { + "arrays_sha256": "2965dcde2597c69758ab6dc94711e088d65336de04d6911a8e95186be19493b5", + "metadata_sha256": "bb178d3e32b0b8c4e321b503806282f8130606313f12c3046e412a94133d2815", + "realization": 26 + }, + { + "arrays_sha256": "49e3a10b9759e93e295ef60a623998325928e3b2244833fd241c627f940ba01b", + "metadata_sha256": "0808dc618f8903b1855a9771d6352f46b8bf0118beedac800a8eb268d2309d43", + "realization": 27 + }, + { + "arrays_sha256": "c87cba77f96e96de0c54d49cc98d4589bdbce28283f5b0a964bec922862594e8", + "metadata_sha256": "9cfe4557efec36237e39fc77cc151d9cdccb13dd7f49062a038078e577adeaec", + "realization": 28 + }, + { + "arrays_sha256": "eb1dccd7afa5a727958e1cdf15666dee8094aa14194a72a5b65d889772a9ac47", + "metadata_sha256": "b1f67ef785d977496be6bb346f53dcc602d73ed9043ed8fd1946a1b9c9ca3b85", + "realization": 29 + }, + { + "arrays_sha256": "a0bceba2f4a233215e922bc7c8d08dc1cfce005b23ed8ad6e2070cc491b5980f", + "metadata_sha256": "ed99cbd2a63f57179597675590fcf0df84faa39016df477badde1fdf29b82d65", + "realization": 30 + }, + { + "arrays_sha256": "d76bba82b2799e3d7727e7e6a0e6e1726e1858ec79a5610530dd11970a84dd8f", + "metadata_sha256": "9a83de6ffed3e4bc5f39c9ae1342f98a539208827bf59e479641ae83f3520467", + "realization": 31 + } + ], + "observed_median": 0.1455538020363032, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.14303643414095735, + 0.1475576386964763 + ], + "realizations": 32, + "sector": "adjacent" + }, + { + "N": 12, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11653550918409035, + 0.11677938950236749, + 0.11704279833978756 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.11754400876960917, + 0.11785329696356348, + 0.11816821284249375 + ], + "median_hodge_balance": 0.20304955102017233, + "null_banks": [ + { + "arrays_sha256": "6295e43d8b066e587de5eb0081e9e35534a13fac7e41d976e051c1e5fd65bc17", + "metadata_sha256": "d3ccaf826ee7c2db7a09aff5e316c0a58fda1783348ff3dc110ef861e13e6b6e", + "realization": 0 + }, + { + "arrays_sha256": "27a297e1100d86adc18773e93406182c724504092eca903627cabb570705dd00", + "metadata_sha256": "973adb32e9df0e77051c809031081b45717a0c6ecb194175a2a61fea3ea7e2d9", + "realization": 1 + }, + { + "arrays_sha256": "b113c827bdf362d17bace67d13b8b941651063d17eca813a7594741f9d1199e5", + "metadata_sha256": "ab6b133a2fd225b02dd815239e851b8ec9d5466439e99f9508a8dd2ac69eb644", + "realization": 2 + }, + { + "arrays_sha256": "7c7cc27dad0a1dea57c16ee78bd51285fe7557a2c9a7cf4a0d26a33d012d135a", + "metadata_sha256": "0834559c9abf99744717b8fb660ba49da469cff33914afc16dfa43ab598b1e1a", + "realization": 3 + }, + { + "arrays_sha256": "a331c9611bf4e6404c67cec2c6fb3a0db2b2d6e7aaab53dd5bd50c8a8bf241a8", + "metadata_sha256": "cfe366ef911f84f87ba519ed5d97d5e473d05bbce91400dcfd4c512fe388248f", + "realization": 4 + }, + { + "arrays_sha256": "9af07ba8527b2969d0738bcaf2a2d77bec3dccbeb6d3b12c02fd4496d304c2b6", + "metadata_sha256": "155c6a82e749c2e93d85e00da213a3ab0ee7f98a60c1944c1fb9bed34bb760ee", + "realization": 5 + }, + { + "arrays_sha256": "274acda5a9d51241a73e49318934cb8a22896fdaa1c3c14540813b6354f1631a", + "metadata_sha256": "7ffbf33870caa20fff28b18cdf887ef014eb198a782393fdd91142f7748729e5", + "realization": 6 + }, + { + "arrays_sha256": "a00c0d087274c20f267d39b4b4cb5c148b749c0c6d52f80f13f3bcf5db6f3954", + "metadata_sha256": "b4b5b3271dc1bbf8cc43e1ea0b37f441bc8fe23111bbb58266bfd3874f6e2213", + "realization": 7 + }, + { + "arrays_sha256": "c4cc4284cbae78865dd8eec113fcd8fb2437246548b2b613e49cddb3625e9585", + "metadata_sha256": "7e45fe031db32016f502101819d4cf91613fb9b9f1e5aa17860abf71c7779a50", + "realization": 8 + }, + { + "arrays_sha256": "673f3c19d0d36037bf7d0a55654c2c19553a6b7467047d63bd3a1754c46ea4b8", + "metadata_sha256": "8e4744ebaec126005471c500ce9d274fdd255b0095d6157b3b7181e3cdde8c05", + "realization": 9 + }, + { + "arrays_sha256": "de2c8dcd9a3a47d7335d0af37fc390ce13b3dc5f748034f9e3fab1fbba5996bd", + "metadata_sha256": "f2bddccb651e2c23031f42ab1e78360e2e5a876255babb43100c0006057c2f1d", + "realization": 10 + }, + { + "arrays_sha256": "1306ed2f1f1b38a4f574cbdeb4d522f1b6edb447eca3c85a33ca319907236277", + "metadata_sha256": "dc2f48e993727e64ad32954077329ea6fe12f226eca787d190a7359c8639e9e2", + "realization": 11 + }, + { + "arrays_sha256": "f1721dda5d7d20af93e11192dbddc7c1b437c58952c14d0f46aae0b0ccdc95fe", + "metadata_sha256": "9084e131eb07d404a52545fa7184d5b954a8992d198498b865bd26355a9ee304", + "realization": 12 + }, + { + "arrays_sha256": "55c41e0db6b603fa392718dbdacdbbaf2bb9b12344db3b7ff7a9ffdd9a1ea4d1", + "metadata_sha256": "1223b4af181929db6e5dd514cc1783ef4948ebb618205a62acfd7e540643f96a", + "realization": 13 + }, + { + "arrays_sha256": "f845550590021742adb988cc35d0ba87780c776063b1d035606c3c412b243205", + "metadata_sha256": "f5da11a1c2c31851a0db5d3790e403d2c6a400beff3cde15b53151ee76c833db", + "realization": 14 + }, + { + "arrays_sha256": "dfe01d14a160e3ba3a8debaadb41c40ab101b928303773358a4ac88eaa5ff396", + "metadata_sha256": "77983323fbe61608095651a3f599ba2edb97b1f1b05fff922ae978f18c000ad9", + "realization": 15 + }, + { + "arrays_sha256": "b8d81ae843c89287ff6476caa1831e81b680c1a16f9a0cf919bff2e27719f94a", + "metadata_sha256": "1f982ec22dd4a17d312a03ed534ba53a8d614b2cdf9af9827df4e05d0e51d8e0", + "realization": 16 + }, + { + "arrays_sha256": "bab482952e5ed39928387bc94cf9f2a0b45be95c39738a54f6e6a7056421139c", + "metadata_sha256": "f5ce915e3b0e94b506673e7f75448c080ffcd3d3661ec9c030e56493805fa5f4", + "realization": 17 + }, + { + "arrays_sha256": "7d2998d5654f4caaf74599ad5c3dce3a64e269f4a2b193a7e0c07af38f66c962", + "metadata_sha256": "8e7e3e100087a8fb23e96f80ff603f2285666ec223ee65ffdf9fee1a704f7cf4", + "realization": 18 + }, + { + "arrays_sha256": "d3adb10b6f8cba653f2e2b4a6b2b614282550e54a8001a2826c1ed6089872b69", + "metadata_sha256": "cfd412db593d795cc07dfe2c0166b4fd2e9802e359d0a4c37579b4683e00357f", + "realization": 19 + }, + { + "arrays_sha256": "349f6d329d978da2b6ec1d1d9739e3347f8e35c880a837e2998d7116a6176a83", + "metadata_sha256": "0c35c4824a64b1cf1e42799d8a4a4df92e1b2dfb11b61008ec76d1afc5d9f241", + "realization": 20 + }, + { + "arrays_sha256": "119ecdfb9b5e238cd44b73d0d13f6b8fb8df57242510cddf20e39fe2f9d5f518", + "metadata_sha256": "9d0772100999d60a3277e297b15d7e247d0bfe228a8ac6d4a945d929818e1894", + "realization": 21 + }, + { + "arrays_sha256": "1eea7811e2771b0c42e22c83ad898431d92f76f0b7cffdc3a22c1f24a29eb522", + "metadata_sha256": "1ac4d5b8a4846fa38d236b8b3ca9b8db3d28a9c8be5563a70d101b54629ed688", + "realization": 22 + }, + { + "arrays_sha256": "5e47af01b7c9c15e3e5aba1df3c83f13f069e5c8c539ff8036853a5f1ff95f9b", + "metadata_sha256": "497afb80aa6cd8627763ce3a44825f5d661914078a034bb222ddea97ba154bc5", + "realization": 23 + }, + { + "arrays_sha256": "2894fe2a6198e17bad873c598c60feed9cc8d1dffbe2cca584a5c8bf1796edcd", + "metadata_sha256": "369a4a569fe45b87c779a047f675fff62d3c25dc4599c5eff7323bd3f6bfb1af", + "realization": 24 + }, + { + "arrays_sha256": "edc2ba31774ec0a0b536e4be78e65a9a1196ef9644d42b507e44419b6300d85b", + "metadata_sha256": "d943b0bd0ac1f2753302c13b3a79d642d851b926907b719242b6b5fa05066de9", + "realization": 25 + }, + { + "arrays_sha256": "add66316095507864a2384d7a37bca01f7cfe4d8d17a975edf5071ee32107f6f", + "metadata_sha256": "f1dcf67b305703c6ac79dfe12c343d150dbcf3e8c39b4c3f7961e8872a89413d", + "realization": 26 + }, + { + "arrays_sha256": "898c638319878397dd788dac8da53b1dbabeb98e2c260284b135ff7b9da3c795", + "metadata_sha256": "0fab88d8124736c1a99400fb696aa73a051240a860aa206208326ccfe8b78bf5", + "realization": 27 + }, + { + "arrays_sha256": "90211f72e94b91e7f57a41b936082c1c1aaf8382325bd00e4a9cdf4d3c642cc1", + "metadata_sha256": "7d5f48933c2aba3d0d5fb9ad4b1936635d46274a77ce87078807850f0dc80ca6", + "realization": 28 + }, + { + "arrays_sha256": "2d6230c3e95f28ffa75ee250d98a8214d2c06e193d8b3d8b0062fff10757bb98", + "metadata_sha256": "ecefbf7a0d3deb9da88a32a948636ee4065a571ec3c94274d716c77449781a4c", + "realization": 29 + }, + { + "arrays_sha256": "05d12aedca05111de31469d758084d80dc48b432d06190ebd84327adc64894e3", + "metadata_sha256": "2131d684fa42e5ff2a089053172c482142a4608d15fb5385447c452c354fdbfc", + "realization": 30 + }, + { + "arrays_sha256": "3e0ba8253ca91d2cfe7a4230f7b94bbaafd0a43614d0c0a29b9430b6b0c91c2e", + "metadata_sha256": "8914737f638888b05ec83eb7e231ed9d8e51caf5e3a5000236453950bdbe2f59", + "realization": 31 + } + ], + "observed_median": 0.30799929044283475, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3017947804697443, + 0.3137684915691576 + ], + "realizations": 32, + "sector": "adjacent" + }, + { + "N": 12, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11279238387872889, + 0.11282147828827586, + 0.11285685034000596 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.1127383177366043, + 0.11277130222361338, + 0.1128063131866758 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "39eabf0716d5f70ab54f3d8a7986b5e6bf53cbc678601044e30c1fa72c5ebcde", + "metadata_sha256": "c483781d54be8115cb6b1636f07470161b30b60301b441c4a669bee7aa23f32d", + "realization": 0 + }, + { + "arrays_sha256": "0a1bede9ca227a0be9ae8994babbcc68c6f43d8b289bdf7ceead7110f59ceced", + "metadata_sha256": "a8f749bb2b254d3a48501af8c8ee49c2b73a7049e0ed4b085bc30e76746e2f68", + "realization": 1 + }, + { + "arrays_sha256": "2c95b9b23c4f1789b49eb4f9da845f59c630e6f37c94089a9adb254122fd36e4", + "metadata_sha256": "d03167484e3e072cd72e651d80e3ce11f22e65e568be1a30ecf7d5053441627e", + "realization": 2 + }, + { + "arrays_sha256": "5031a362d6b78e203e0cdde730a124def9522f734d859844df37e656f26ae1e5", + "metadata_sha256": "59492d5db4ab2b536b245c4c2e32d61ae238522075f1e1decd80be18039fc189", + "realization": 3 + }, + { + "arrays_sha256": "f796cec58355e5a217ed19b7fedc24cca9c7231d68604c9164a071eabbf69a2f", + "metadata_sha256": "9caf8f23d001caf3ce782e8475cbcebc6dca291eaff911d2edd6f14077bffe1b", + "realization": 4 + }, + { + "arrays_sha256": "43cc763a595e604a4e08e2ffa16b364ee0685c0011d4e9bd78ecc8f162b35df1", + "metadata_sha256": "53250a11910f15412121ba64dc7e9e9aadb0ca17f3e066facea8f2280d00d942", + "realization": 5 + }, + { + "arrays_sha256": "5eb12d4efe1d5ffeaf8c98ee32d3bf9af49b61fd90e0641fe74cc13e9d730d39", + "metadata_sha256": "149235b0dc6c49dc55c07f34483c6b92cc3c9600130bd6e4158edab936df10fd", + "realization": 6 + }, + { + "arrays_sha256": "99b381c67c4a3be2f098f1ae7dddf5c11d841d49b84a2a7be96514e9cfacec2a", + "metadata_sha256": "788d17e4c84b11b42f27a1e59e5f39ba13d5f28adf95151a8e527cc3d85ae02a", + "realization": 7 + }, + { + "arrays_sha256": "ed0b9309c6d7d0f4081432ebae7f0df4b3244e51ebe6cd49034b65b4c3494781", + "metadata_sha256": "ba6255d5ad211f1a02a20c60f3856925e4d0c4ae479c0e9aa5ca725d9bac7d8d", + "realization": 8 + }, + { + "arrays_sha256": "8dcbba96f6ce35299c702f2ca8239a5388ec4e28c057341038b4134dcdde8828", + "metadata_sha256": "c5fbd6dc542ee5fcb4070e7676781cd92ef2dd2062897562d55c9cf6211268bc", + "realization": 9 + }, + { + "arrays_sha256": "a8e505e41ba60163db39036bbb026e4e4ff07788e6b5fca3747f8489da46f099", + "metadata_sha256": "3440dee8c812e29bb0d65517f05cac624f0902e3fee45af9a713f71b036b0bff", + "realization": 10 + }, + { + "arrays_sha256": "0720b141a9452923373f8a6fcc37805177b0ef0bde9303771b78ceea49628ba7", + "metadata_sha256": "c21c7f6184d187d3f047de2ad86f198d2a5824fdb681c40b18d89b8948e55ff4", + "realization": 11 + }, + { + "arrays_sha256": "5ed8d947c24c093a2338bcdf72e1f7157b98bd0b4309cc2ccf65c067f61093ab", + "metadata_sha256": "fcc433308daf020805cf0a4f07075f82d0466e0d5c8202e39741af6ea89532d9", + "realization": 12 + }, + { + "arrays_sha256": "b801592e7c1b9566d8091370221ecd29c5489e0c049f1f08b87f2256dd9305c4", + "metadata_sha256": "471935e03b4679706020953efdb355b0602ac562830929e68de5fb9233123530", + "realization": 13 + }, + { + "arrays_sha256": "3910156a6de0e7c6c33d2ff6bc17da0c141202d04ffac58d0d04581fb6ee39ad", + "metadata_sha256": "4378c43c64e652ed1a7c9f783e28b589ad05c283e7a59dcd9dc2a7e9fcb2b5f4", + "realization": 14 + }, + { + "arrays_sha256": "1540d7fe3a5bb912c56286fff51264aefeca3f3f3298efc95e478b9db4394e60", + "metadata_sha256": "8270b7ce104a4ed6e743deb16c188384516afa1ac3b8f2b71f7016a344633d9d", + "realization": 15 + }, + { + "arrays_sha256": "783b385a237d23444303dd72be753bcdb081498d00a06d97234934823aa5c511", + "metadata_sha256": "5d3392ff9794175c6622a797f6505ad29ea74399107a4fa6dcfdaae39bdeb704", + "realization": 16 + }, + { + "arrays_sha256": "b587d854136db8b51e99fbe4686bfe67c8876d5aaeec8e43e02cb2f2b0c239c6", + "metadata_sha256": "da7b442102cac0dc638ce7767c44b51559bbca1c42009d9577030281e68da253", + "realization": 17 + }, + { + "arrays_sha256": "c9af54614b2d32d5c1651b90cb2b94ef3079f756194d45e08b88750849e8fcb5", + "metadata_sha256": "9a32fd40f74602cafd55736b7ad2612d942969eab356e25ab928fc40e90e03f2", + "realization": 18 + }, + { + "arrays_sha256": "69bfe64bfe84686e782e99545f14b495e26b8a06d192f114f177a97aab47ee42", + "metadata_sha256": "fab0cbe18dacdae282ccff6fc26a2f2c255fd3141fb95cdfdc8f4b17555b0eb2", + "realization": 19 + }, + { + "arrays_sha256": "71540460007eb40ea4463188b8c6c2fa8876ac0657e1a79e94ea57382d99eace", + "metadata_sha256": "ae47f705bac8f00e785029e5d1d8e7d07063f2a7953b1bb6fce29339e8dbc8f4", + "realization": 20 + }, + { + "arrays_sha256": "a5c34b53b815d20f9ba52ac32f51e23d0a70a9f1807b1baf822232c5b08a6dc2", + "metadata_sha256": "d77dff93869446433482d6de448b6f3a543ab18f7708ab7cb1b14fa31d72bf29", + "realization": 21 + }, + { + "arrays_sha256": "18d1616cbf1945652d4e75e211f9499ad57abd64a3361fdef3a2deb68b29d776", + "metadata_sha256": "025349b10cea8c5094acd4a2d6d2c3d54f6f56076c5e28788a3d6f105f61abaf", + "realization": 22 + }, + { + "arrays_sha256": "8515493492410dde08f2599233f50bc2a779d7ced1c359b9681c3640afebb377", + "metadata_sha256": "b492d5319ccc6f1d6e9e9275f5114f3b0adf4c20a414fe7cd5d92d36d9573f24", + "realization": 23 + }, + { + "arrays_sha256": "0da5ade0ba2c79dc549b303ffb19c633228bf4f9cb0ff3a4be72175e477618e7", + "metadata_sha256": "a40b2500a6aa9a9b8bceb254c932c64715692dd4550d8c8b88839496a72efeae", + "realization": 24 + }, + { + "arrays_sha256": "98fca051c41014460206b61be3a79075d6eb02f9a2a3cfd578ef6d91f8ed2859", + "metadata_sha256": "9070764e76f06d92da44ef838939f97bafccb807ae3826b85da93f4945f0f51b", + "realization": 25 + }, + { + "arrays_sha256": "5d7da8a4e388c3cd7fac108b432ec9802dc39a8ac4a15b2a5135cc15d8bead02", + "metadata_sha256": "73c61ef0b3f3d213c79b5a02ada91ba7f83b10ac285995ba60b93cc68aba91d2", + "realization": 26 + }, + { + "arrays_sha256": "3c4091d2eafef1887e3c0b357b92b79910fdf67752b7799534876ae9c28bcb34", + "metadata_sha256": "70277620e91df611d95d4b03d6423eb0606c838c81c77771307c134f701a2375", + "realization": 27 + }, + { + "arrays_sha256": "e2d34183de8270bcffd3949f0bf48de4b77ecf35cfc0eca1be28e19a87e9dec4", + "metadata_sha256": "96360e14e6bb6e28088373504b22d6344475aee688edfd5197f67f456d906e1a", + "realization": 28 + }, + { + "arrays_sha256": "430711e8f5a8496884e7d42f006efbb8c98eb55ca122f741b7209866032435c4", + "metadata_sha256": "f822f62296da8f225d9b92d103752641f57f59867306617f0984a820a15effad", + "realization": 29 + }, + { + "arrays_sha256": "5f75b9b6d20dab158273e0da76d484f48525adc94f59d5f7cc4a9aec3547155e", + "metadata_sha256": "aa746965caf49c907df3bdfd028aafa7f6868d0c584fc0a02e5b0af221a7b976", + "realization": 30 + }, + { + "arrays_sha256": "99ce32aff5c3d13eba4fc9f2f3a3661aafffd23365a2df3bb67b6f1a89a90dec", + "metadata_sha256": "56b68c7c5a89fa2cb853f0d3eff9a025a0641b1f6a1479236d864a26effb0fa1", + "realization": 31 + } + ], + "observed_median": 0.1758398360594558, + "panel_kind": "isotropic", + "physical_bootstrap_interval": [ + 0.17501819690750547, + 0.1762804126020616 + ], + "realizations": 32, + "sector": "central" + }, + { + "N": 12, + "collapsed_covered": false, + "collapsed_prediction_interval": [ + 0.11302005029615277, + 0.11306530368482279, + 0.11311431333015237 + ], + "hodge_covered": false, + "hodge_prediction_interval": [ + 0.11320492572703314, + 0.11325918904630874, + 0.11331421373353018 + ], + "median_hodge_balance": 1.0, + "null_banks": [ + { + "arrays_sha256": "71707e9992e64d86525ad773fb28849585213f6381803b2b0777ece4727a5701", + "metadata_sha256": "c4ca211323853dc572c47b93d85f73789beb13eed9df8e626d87dcdfcf8bcc6b", + "realization": 0 + }, + { + "arrays_sha256": "ddceab7e434f07d728d20c1ffe6b4067e8ec468349282c0b38f7bb5ef7e9ac93", + "metadata_sha256": "59180248a4412e7519816ca85b7772ed819d0dd0f0fecb1ccae7d84eeac9a58f", + "realization": 1 + }, + { + "arrays_sha256": "cc6dd0cd91fe05ab3ec8f7495cb00bf3a04c4c885207de44ddd892b3abf91d9b", + "metadata_sha256": "32de84ca7e7505f0e6c9f78a284c452d7c1959d79a957d7c4c764901598076e3", + "realization": 2 + }, + { + "arrays_sha256": "1d2ca7c9a81079cc338cb2e78969456019e98a6749885691fb34c600210748b2", + "metadata_sha256": "0be5a8ac9a2d86222df74bef9724b61f68b24f5fbd844a69053fec70f18843d6", + "realization": 3 + }, + { + "arrays_sha256": "9ee9923ad88a32db01c58a74a8fccd4e189681592a9b871dc1833472b0a8f6d6", + "metadata_sha256": "042f35c6092ec0dc81c1d41d219cd7b26dd44ca81748e21d6397a758bab1749f", + "realization": 4 + }, + { + "arrays_sha256": "bb0d0df8ea03892e4f7496520ca9635b70639f7f7f30a77302b01e648da810e4", + "metadata_sha256": "2ec162d2f94a1d7ce0573144a06e0410054096ea7128aff06f6e376ea4ffd364", + "realization": 5 + }, + { + "arrays_sha256": "44329461a9b5a1ccb1df747a669d42d1a6f38d720a7872d42ce71cfd3239dddd", + "metadata_sha256": "7ded7fc66837459cc2314252cadfe450d69309b20d3eb6942e02f423280b26d8", + "realization": 6 + }, + { + "arrays_sha256": "ee5ea78b28f637ac2a19939a748f4703cdd576902bd12b8b12e5bede786695f2", + "metadata_sha256": "7a5887b3088b4d7446af34f09291e564c928df6d4fbda305167ef67b84a37cef", + "realization": 7 + }, + { + "arrays_sha256": "4dad209b278d4e2dca484f5a631c280ded9d41eeb8616d5df4b5a5da004e075f", + "metadata_sha256": "3c0386cf66a6bef718f7c50d4a35517a403f7fce3f67b0760ea43baffaea49b9", + "realization": 8 + }, + { + "arrays_sha256": "076de75110454679d5cd40dcfac8e74807f0f22cfd1dc32a2f1725b3a8082cef", + "metadata_sha256": "adc5fd58b95ab02fd56b031d7a4df7d7d61c277e3865382f3082e0a38c96227b", + "realization": 9 + }, + { + "arrays_sha256": "f74afe2ad85b5aba89e40ce7757a5dedcfa6c9d7d9d3a925b3781f0089520ca1", + "metadata_sha256": "14cd5b9006a3ffbe2db46238bceffd7727e0082414ddc9868bbb6a5bf9a096fa", + "realization": 10 + }, + { + "arrays_sha256": "24e49082ecdecddeafac8c627e4d9bf472a8855754a74d6f995db3eef5b49b2b", + "metadata_sha256": "d7d9f35a9c5673d4d01fb30a6f5d40aca84820529be473fc80d5601a185b565f", + "realization": 11 + }, + { + "arrays_sha256": "860ed34e094dfe214ed93abaae02c681177e64018c11ea8ef8a127ccb6682248", + "metadata_sha256": "f15a1ec151f1e3f6849ad65a82580bbcdcddd80b3c722f8ed664108453da5820", + "realization": 12 + }, + { + "arrays_sha256": "266b470e4809dd1429646fb1d1aa85c4efaaf1086d53eaf10c2735efe13506ee", + "metadata_sha256": "236bc6f90c3334ffb41ce6aa5f36d8fbd314e4eef526ddb63e256955a02d0636", + "realization": 13 + }, + { + "arrays_sha256": "e69a34ea0d55dd1984fcc4f95b79df188e7062b87de8cb6d6fa7f2b26d5d6410", + "metadata_sha256": "96332f6cc786eefe03913c81876e94d4f9370f5eda80100ea2c363d59c72b24c", + "realization": 14 + }, + { + "arrays_sha256": "54b1a0616752d9df4b9fc2596d9d7de82b5d44d22bb7d1906b661f492921d271", + "metadata_sha256": "482b21be326cb8136006c217a5ea5c809678319e0acfa3e032db3234c6d18bd6", + "realization": 15 + }, + { + "arrays_sha256": "9b5ae475eec7cc10700c330f9f9cae5e4445dca38c9aabd1005a39ff28228166", + "metadata_sha256": "67324ba73faf7acebcf56ac70dfad572c98f5fe617195099a34cd0f266f73030", + "realization": 16 + }, + { + "arrays_sha256": "67e221dafd6bc2984560cdce1fe08bebfe9b77843ab4788465cc5809756703f2", + "metadata_sha256": "c07e531884d8e430cdfb0de8689407c69d8bc00899f7cb7da0d702bd45208a9c", + "realization": 17 + }, + { + "arrays_sha256": "0b4fc80a2e252782c750d1101295d9ba9858d5d7db1ac93dbe5f39092707c981", + "metadata_sha256": "2f98ba35a7460da11856a9caf03ba21b69edbcc86c8fa730991a1f6b85c2b7e6", + "realization": 18 + }, + { + "arrays_sha256": "d0271f89f765a3dd14ef72e60a04a05ebd36f0f8f44f9fc334e0d983669c0073", + "metadata_sha256": "11f91f529f5aff15edb1831393a00ef78f1355568f1461ab2eb8f8877d43c45b", + "realization": 19 + }, + { + "arrays_sha256": "29326e8d5ea015856d4725405b6c006246fd0851ae11046554c5d4af5da23fef", + "metadata_sha256": "780b40e217cfe9dc7f48e4e6290faf227fea210b46f544c381a9610c133740d0", + "realization": 20 + }, + { + "arrays_sha256": "88a56dfd95877efa47f5cf835f980e496b1e89ea384672729a4b398295d7607c", + "metadata_sha256": "ccfa25b213a0b12d34b6244945383a1aa6fcc78ec561b5655246d8fda1215ad3", + "realization": 21 + }, + { + "arrays_sha256": "759b4a0eeff52d56840a4f555f8b1487f7a0ae6fe2b0851beac285da6a3b32de", + "metadata_sha256": "5a1020671739db14ff00792ab81ff6bf1ac2186d1f71bd96e42c2d2ea59a7360", + "realization": 22 + }, + { + "arrays_sha256": "b3f3bbe3e5b2ba39532f9f2dd7a911d580ecbcf73d35d993fe73dc941e0e6dc1", + "metadata_sha256": "ca4ed10744865e489863326067e9fcbcb7209b249eda108676684f8d881709cf", + "realization": 23 + }, + { + "arrays_sha256": "c96b940385f6f9ed97e6676066ffa4b27c20fdfbad67e333dffebd0fac9484ff", + "metadata_sha256": "b453d086109da994599b0ffe2d90c187e50b6342e3f47f3aa5c6356833b1fadb", + "realization": 24 + }, + { + "arrays_sha256": "660ca562eca25d5db05925e45a03f4180c8153e15463ae774f997ebfa09c7614", + "metadata_sha256": "a4583fc4be9b25f8e7ba25f2d01e1b70a278da2c1e2117910873ac07e2f9bcd0", + "realization": 25 + }, + { + "arrays_sha256": "9bdb7328ac028ee09a3c2b707857fb8ce24dd638f2f558cd8cfa9028fe86fd63", + "metadata_sha256": "4a2596a9d545ea020ebe2e542affe16c98649bfd164f19cdcda0880d38a3bf9f", + "realization": 26 + }, + { + "arrays_sha256": "ae9049ce7fe0e152e28e89fda236abcd3e663fc03c6d2edec20bfe7807a5b433", + "metadata_sha256": "f147e1f90205fe09a859505f789600ab83e89077b365db3c9e3936e7a44f4b1a", + "realization": 27 + }, + { + "arrays_sha256": "35758b032d95c843ae5a0496933bf57ccad7ad523b597a01a490cac699c2990b", + "metadata_sha256": "92a19b3d6054f81d92820573384e09a5016ee5c6f81204ed691c5dba09dc6234", + "realization": 28 + }, + { + "arrays_sha256": "aedfa0b0f7ef46297d0996d4a398daf8558c811f7bac355b2b974383ca98b72f", + "metadata_sha256": "2926123a3539b397af98d24335fdf41b70bcb967e83ca52b83f9f334c7d70fa0", + "realization": 29 + }, + { + "arrays_sha256": "f3dabf9c509cb6e96cb5d6df46a0ed8bb60671ffbc89aa04ced7b4e625a7e9c8", + "metadata_sha256": "d897321b0d03a3621c83f343f6cd6dbe121dd59f79c7c62f69ef89adfb85dca4", + "realization": 30 + }, + { + "arrays_sha256": "5263d4c66a1b6614df17e0e37b3b71a4d155c8455333b6292169f768dbcfde98", + "metadata_sha256": "e2f4c35b0de80e0c418a0f83eaab5f4e0f265382e439d1a7c56fe95e3a96e36d", + "realization": 31 + } + ], + "observed_median": 0.37696338917315897, + "panel_kind": "sparse", + "physical_bootstrap_interval": [ + 0.3695751849042101, + 0.3793322651479647 + ], + "realizations": 32, + "sector": "central" + } + ], + "null_replicates": 2000, + "passed": true, + "physical_bootstrap_replicates": 10000, + "prediction_coverage": 0.975, + "registered_sizes": [ + 8, + 10, + 12 + ], + "source_pilot_artifacts": [ + { + "json_file": "susy_hodge_v7_outcomes_pilot_banked.json", + "json_sha256": "0756c0bc9060dde11d3c2488a3e50b1a0e2de36a64c966dc72899d99312352a3", + "npz_file": "susy_hodge_v7_outcomes_pilot_banked.npz", + "npz_sha256": "5d61f53a39d334225700d6ecf42e48acc5b668a72bfed4a214a943d25891539d", + "safe_covariates_sha256": "e432c45725925bf44a128a2afdf8bb6a2d5da86ea53bfdcb45e0efc9ae4d9516" + }, + { + "json_file": "susy_hodge_v7_outcomes_pilot_N10_banked.json", + "json_sha256": "d3889abd554f253f3444fb1a8132f4338109564f41d467717308adcc363c0c4c", + "npz_file": "susy_hodge_v7_outcomes_pilot_N10_banked.npz", + "npz_sha256": "7134df6e67f92a02a81f715989a11a680877cdb5a7188056d1db2677f15bffb5", + "safe_covariates_sha256": "6f021619e935297bc11fc251e07f8f1bcdf8bbee572d629669e173917ab53e87" + }, + { + "json_file": "susy_hodge_v7_outcomes_pilot_N12_banked.json", + "json_sha256": "3476c13eeda0a525d4dbfa926c44c7a2ffbe652ab9d683ed9a9eb32f8d5bc6e4", + "npz_file": "susy_hodge_v7_outcomes_pilot_N12_banked.npz", + "npz_sha256": "ba6321524dea6ccffdb7c2fb0de01a0f57c0b05e5abe4e7ca4a626742be78b95", + "safe_covariates_sha256": "43ce991a4b9253735a27392fcad82c8e5b6c59176d9ec70f89e7aeb3e7e86658" + } + ], + "sources": { + "merge_susy_hodge_pilot_v7.py": "c0315df95119048a2ea73d134e3e0ad84f1948cac35d84e6cde24b1e8671346f" + }, + "uncertainty_unit": "complete_disorder_realization", + "version": "v7" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_combined.npz b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_combined.npz new file mode 100644 index 000000000..04e715230 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/susy_hodge_v7_outcomes_pilot_combined.npz differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/topological_holonomy_delivery_audit_v3.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/topological_holonomy_delivery_audit_v3.json new file mode 100644 index 000000000..19f498cbb --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/topological_holonomy_delivery_audit_v3.json @@ -0,0 +1,72 @@ +{ + "alias_audit_sha256": "f70681610ee709917ddbf67a6e37801fafe5b203391430d7c090467c3af3ec02", + "arrays_sha256": "f459fa37facf82c6f67c44f4961749095fb0817516ff16d6ca6814bbaf952208", + "checks": { + "alias_artifacts_present": true, + "alias_failure_retained": true, + "alias_hashes": true, + "branch_recomputed": true, + "checkpoint:output/topology_v3_checkpoints/N3_mesh16_twist_bundle_v3.json": true, + "checkpoint:output/topology_v3_checkpoints/N3_mesh16_twist_bundle_v3.npz": true, + "checkpoint:output/topology_v3_checkpoints/N3_mesh20_twist_bundle_v3.json": true, + "checkpoint:output/topology_v3_checkpoints/N3_mesh20_twist_bundle_v3.npz": true, + "checkpoint:output/topology_v3_checkpoints/N4_mesh16_twist_bundle_v3.json": true, + "checkpoint:output/topology_v3_checkpoints/N4_mesh16_twist_bundle_v3.npz": true, + "checkpoint:output/topology_v3_checkpoints/N4_mesh20_twist_bundle_v3.json": true, + "checkpoint:output/topology_v3_checkpoints/N4_mesh20_twist_bundle_v3.npz": true, + "chern_fixed": true, + "cue_reference_count": true, + "deformed_but_non_cue": true, + "determinant_trace_agreement": true, + "exact_isospectral_construction": true, + "figure_pdf_hash": true, + "figure_png_hash": true, + "figure_source_json_hash": true, + "figure_source_npz_hash": true, + "gauge_invariance": true, + "mesh_agreement": true, + "positive_gap_branch_overlap": true, + "registered_g_grid": true, + "registered_generator_seeds": true, + "registered_meshes": true, + "registered_sizes": true, + "result_npz_hash": true, + "runner_checks": true, + "size_0_commuting_control": true, + "size_0_cue_count": true, + "size_0_loop_shapes": true, + "size_0_seed_shapes": true, + "size_1_commuting_control": true, + "size_1_cue_count": true, + "size_1_loop_shapes": true, + "size_1_seed_shapes": true, + "supported_branch": true + }, + "figure": { + "pdf": "output/figure_7_topological_holonomy_v3.pdf", + "pdf_sha256": "11e101309d975a61a3efedb1025c2552149c7f1a6f72433594f4adb1c0a16258", + "png": "output/figure_7_topological_holonomy_v3.png", + "png_sha256": "4c19bc37413ea4cdbece1ef84023b505d3d279264e2107601907cb72d2d731ff" + }, + "generated_utc": "2026-07-28T17:54:42.800600+00:00", + "passed": true, + "registered_meshes": [ + 16, + 20 + ], + "registered_sizes": [ + [ + 3, + 8, + 16 + ], + [ + 4, + 10, + 25 + ] + ], + "result_branch": "fixed_chern_deformed_holonomy", + "result_sha256": "ff15e7cd2f947b43da5a5973bb82c50319b164877883d187c7c46b2a073823c6", + "version": "v3" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/topological_holonomy_mesh12_alias_audit_v3.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/topological_holonomy_mesh12_alias_audit_v3.json new file mode 100644 index 000000000..c8f7745b8 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/topological_holonomy_mesh12_alias_audit_v3.json @@ -0,0 +1,309 @@ +{ + "checkpoint_hashes": { + "output/topology_v3_checkpoints/N3_mesh12_twist_bundle_v3.json": "17bfc614ccf071f75e5eb52092b45722184cd11aff2a7a1c674ed4baf85146e0", + "output/topology_v3_checkpoints/N3_mesh12_twist_bundle_v3.npz": "2957b7cffebb2da83c31e4dec0d8d586861b3b904fb35f10e973b0d101067ff1", + "output/topology_v3_checkpoints/N3_mesh16_twist_bundle_v3.json": "f540829edc6f8903eca596873e145b19900533c2a4f0e8a63d5bd0d70091e56a", + "output/topology_v3_checkpoints/N3_mesh16_twist_bundle_v3.npz": "3618cca495411df6d1e6811e66fe7e108a17e6f81605cca6af4b3c09cf0541d8", + "output/topology_v3_checkpoints/N4_mesh12_twist_bundle_v3.json": "c58d9eae3c0b75a061410f591e2879c68a32e60c4634fc60eb097f5234104c20", + "output/topology_v3_checkpoints/N4_mesh12_twist_bundle_v3.npz": "712a49732df613a1514f9e2ab9a9c1be8d54a7bb4bcab4ffafaa192e85fb8e4e", + "output/topology_v3_checkpoints/N4_mesh16_twist_bundle_v3.json": "cba044e2b0171b4fc59a4226d59ed21e6cdb828e89d9fd6f95c5ee7fc83a9129", + "output/topology_v3_checkpoints/N4_mesh16_twist_bundle_v3.npz": "1fba58f6126a2f9a52d08c175871c52a912e6cdcc409d67aafe2c3a7ac02b46d" + }, + "checks": { + "branch_margin": false, + "cue_reference_count": true, + "determinant_trace_agreement": false, + "gap_open": true, + "isospectral_orbit": true, + "kernel_count": true, + "mesh_chern_agreement": true, + "mesh_chern_integer": false, + "overlap_floor": true, + "random_gauge_invariance": true + }, + "configuration": { + "commuting_seed": 20260728499, + "convergence_mesh": 16, + "cue_samples": 10000, + "g_values": [ + 0.0, + 0.25, + 0.5, + 0.75, + 1.0 + ], + "generator_seeds": [ + 20260728400, + 20260728401, + 20260728402, + 20260728403, + 20260728404, + 20260728405, + 20260728406, + 20260728407 + ], + "primary_mesh": 12, + "production": true, + "sizes": [ + [ + 3, + 8, + 16 + ], + [ + 4, + 10, + 25 + ] + ], + "workers": 4 + }, + "environment": { + "numpy": "2.3.5", + "platform": "macOS-15.6-arm64-arm-64bit", + "python": "3.12.11" + }, + "generated_utc": "2026-07-28T16:30:03.788138+00:00", + "npz_sha256": "06c649b89a6e3760a817807283dce4f0f7f3c474dd324e86433844ca2b781bae", + "random_gauge_errors": { + "chern_error": 3.552713678800501e-15, + "wilson_phase_error": 5.743459592220056e-15 + }, + "result_branch": "topology_mesh_unresolved", + "runtime_seconds": 478.42586700000174, + "sizes": [ + { + "N": 3, + "all_chern_equal": true, + "base_chern_convergence": 6.000000000000008, + "base_chern_integer": 6, + "base_chern_primary": 5.999999999999997, + "base_form_factor_residual": 1.9990780190641377, + "base_gap_ratio": 0.2924367496449049, + "commuting_chern_range": [ + 5.9999999999999964, + 6.000000000000004 + ], + "convergence_endpoint_chern_range": [ + 5.999999999999995, + 6.000000000000008 + ], + "convergence_mesh": 16, + "cue_compatible_at_largest_g": false, + "cue_form_simultaneous_critical": 4.040319013665091, + "cue_gap_ratio_interval": [ + 0.45932310720759545, + 0.6015274327754949, + 0.7321866384754452 + ], + "cue_nonplateau_stop": 8, + "determinant_phase_x_base": [ + -4.440892098500626e-15, + -3.118500107520022, + 0.040212522242805804, + -3.094821844618201, + 0.04079506619388316, + -3.117917558669181, + -8.881784197001252e-16, + 3.117917558669173, + -0.04079506619387782, + 3.0948218446181888, + -0.04021252224281202, + 3.11850010752002 + ], + "determinant_phase_x_final_seed0": [ + 2.1452307034110616, + -1.6792603171869225, + 1.203833261579449, + -1.8246167521381491, + 1.561622867184648, + -1.3355405222660086, + 2.105560861976697, + -0.7236234522682279, + 2.655149659410647, + -0.23506581304166385, + 3.105938532315879, + -0.27904332392358455 + ], + "final_form_factor_residual_interval": [ + 1.8079849123479288, + 1.8968048705812155, + 1.9822032923375865 + ], + "final_gap_ratio_interval": [ + 0.3093846459438337, + 0.3234155312276142, + 0.3620258799615005 + ], + "form_factor_improvement_interval": [ + 0.06315386260135944, + 0.10077491699078762, + 0.1387856180622456 + ], + "gap_change_interval": [ + 0.024790862825224025, + 0.03548294890478528, + 0.04926845701059167 + ], + "gap_ratio_by_g": [ + [ + 0.2924367496449049, + 0.2924367496449049, + 0.2924367496449049 + ], + [ + 0.2938826111243452, + 0.29853425555698915, + 0.30485389883132685 + ], + [ + 0.29723129646117835, + 0.3089103492653077, + 0.3165056742296904 + ], + [ + 0.2970429780050293, + 0.31517074517569177, + 0.3351300118636338 + ], + [ + 0.3093846459438337, + 0.3234155312276142, + 0.3620258799615005 + ] + ], + "holonomy_change_significant": true, + "isospectrality_mode": "exact_coordinate_identity_under_periodic_ambient_conjugation", + "maximum_determinant_trace_difference": 2.6645352591003757e-15, + "maximum_energy_spectrum_error": 0.0, + "maximum_gap_error": 0.0, + "minimum_branch_margin": 1.2841769211583953, + "minimum_external_gap": 0.05174136811818207, + "minimum_overlap_singular_value": 0.7582403521234089, + "n_flux": 8, + "primary_chern_range": [ + 5.99999999999999, + 6.000000000000007 + ], + "primary_mesh": 12, + "rank": 16 + }, + { + "N": 4, + "all_chern_equal": false, + "base_chern_convergence": 10.000000000000004, + "base_chern_integer": 10, + "base_chern_primary": 9.999999999999993, + "base_form_factor_residual": 2.724638571622605, + "base_gap_ratio": 0.29688094565520734, + "commuting_chern_range": [ + 9.999999999999988, + 9.999999999999998 + ], + "convergence_endpoint_chern_range": [ + 9.999999999999993, + 10.000000000000012 + ], + "convergence_mesh": 16, + "cue_compatible_at_largest_g": false, + "cue_form_simultaneous_critical": 4.453446695467018, + "cue_gap_ratio_interval": [ + 0.48664305097240024, + 0.6007916301768441, + 0.7091120263514404 + ], + "cue_nonplateau_stop": 12, + "determinant_phase_x_base": [ + -1.865174681370263e-14, + 1.0684032000977763, + 2.131138135614621, + -3.0991437506252337, + -2.0576144993325447, + -1.0259543324291551, + -1.3322676295501878e-14, + 1.02595433242914, + 2.0576144993325234, + 3.0991437506252195, + -2.131138135614644, + -1.0684032000977906 + ], + "determinant_phase_x_final_seed0": [ + -1.1354756022022576, + 0.8704507149017278, + -2.655164165904091, + -0.4447881016555029, + 0.4821469096896602, + -0.02733383991564977, + -1.0557078242741085, + -0.74873075295861, + 1.0111088143257931, + 2.7766638203414944, + -2.448629793753009, + -1.9318821087517806 + ], + "final_form_factor_residual_interval": [ + 2.4822322867514464, + 2.6975462443124014, + 2.765993154701743 + ], + "final_gap_ratio_interval": [ + 0.32198983298129813, + 0.33183320410746847, + 0.3466449410976708 + ], + "form_factor_improvement_interval": [ + -0.0034882228413267123, + 0.07438144751300291, + 0.15962765018463318 + ], + "gap_change_interval": [ + 0.029599549508006855, + 0.03615977205372693, + 0.042976215742489 + ], + "gap_ratio_by_g": [ + [ + 0.29688094565520734, + 0.29688094565520734, + 0.29688094565520734 + ], + [ + 0.29430297492629465, + 0.29732552077556634, + 0.3012775182481053 + ], + [ + 0.2982679860075359, + 0.3119267960119273, + 0.31604504069939676 + ], + [ + 0.3111514234635634, + 0.3200796865067025, + 0.3285029797921481 + ], + [ + 0.32198983298129813, + 0.33183320410746847, + 0.3466449410976708 + ] + ], + "holonomy_change_significant": true, + "isospectrality_mode": "exact_coordinate_identity_under_periodic_ambient_conjugation", + "maximum_determinant_trace_difference": 2.0, + "maximum_energy_spectrum_error": 0.0, + "maximum_gap_error": 0.0, + "minimum_branch_margin": -0.23203567784856194, + "minimum_external_gap": 0.09469522123228812, + "minimum_overlap_singular_value": 0.7343169926313038, + "n_flux": 10, + "primary_chern_range": [ + 8.000000000000002, + 10.00000000000001 + ], + "primary_mesh": 12, + "rank": 25 + } + ], + "version": "v3" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/topological_holonomy_v3.json b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/topological_holonomy_v3.json new file mode 100644 index 000000000..f57fe74e7 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/topological_holonomy_v3.json @@ -0,0 +1,332 @@ +{ + "checkpoint_hashes": { + "output/topology_v3_checkpoints/N3_mesh16_twist_bundle_v3.json": "f540829edc6f8903eca596873e145b19900533c2a4f0e8a63d5bd0d70091e56a", + "output/topology_v3_checkpoints/N3_mesh16_twist_bundle_v3.npz": "3618cca495411df6d1e6811e66fe7e108a17e6f81605cca6af4b3c09cf0541d8", + "output/topology_v3_checkpoints/N3_mesh20_twist_bundle_v3.json": "93f199f1053c9c3da2ff6fc2410236e62914a31502c0b5cb11bdf1317ed9da54", + "output/topology_v3_checkpoints/N3_mesh20_twist_bundle_v3.npz": "db1a4af4eb28a79df92369463ca00dc0c131535b01ec0483ee0214d2b73fb6e6", + "output/topology_v3_checkpoints/N4_mesh16_twist_bundle_v3.json": "cba044e2b0171b4fc59a4226d59ed21e6cdb828e89d9fd6f95c5ee7fc83a9129", + "output/topology_v3_checkpoints/N4_mesh16_twist_bundle_v3.npz": "1fba58f6126a2f9a52d08c175871c52a912e6cdcc409d67aafe2c3a7ac02b46d", + "output/topology_v3_checkpoints/N4_mesh20_twist_bundle_v3.json": "80d51533991111a29775a72f98ad94184d146d9f10d970b5429c7389ac85834d", + "output/topology_v3_checkpoints/N4_mesh20_twist_bundle_v3.npz": "d756a5ef23d8ac6e4f77e556ad4694e4724abd9711a7f4565ae43540c22b4f30" + }, + "checks": { + "branch_margin": true, + "cue_reference_count": true, + "determinant_trace_agreement": true, + "gap_open": true, + "isospectral_orbit": true, + "kernel_count": true, + "mesh_chern_agreement": true, + "mesh_chern_integer": true, + "overlap_floor": true, + "random_gauge_invariance": true + }, + "configuration": { + "commuting_seed": 20260728499, + "convergence_mesh": 20, + "cue_samples": 10000, + "g_values": [ + 0.0, + 0.25, + 0.5, + 0.75, + 1.0 + ], + "generator_seeds": [ + 20260728400, + 20260728401, + 20260728402, + 20260728403, + 20260728404, + 20260728405, + 20260728406, + 20260728407 + ], + "mesh_upgrade_rationale": "mesh12 aliases one N4 seed at g=1; mesh16 and mesh20 are the accepted converged pair", + "primary_mesh": 16, + "production": true, + "sizes": [ + [ + 3, + 8, + 16 + ], + [ + 4, + 10, + 25 + ] + ], + "workers": 4 + }, + "environment": { + "numpy": "2.3.5", + "platform": "macOS-15.6-arm64-arm-64bit", + "python": "3.12.11" + }, + "generated_utc": "2026-07-28T17:02:36.097544+00:00", + "mesh_alias_audit": { + "json": "output/topological_holonomy_mesh12_alias_audit_v3.json", + "json_sha256": "f70681610ee709917ddbf67a6e37801fafe5b203391430d7c090467c3af3ec02", + "npz": "output/topological_holonomy_mesh12_alias_audit_v3.npz", + "npz_sha256": "06c649b89a6e3760a817807283dce4f0f7f3c474dd324e86433844ca2b781bae" + }, + "npz_sha256": "f459fa37facf82c6f67c44f4961749095fb0817516ff16d6ca6814bbaf952208", + "random_gauge_errors": { + "chern_error": 1.4210854715202004e-14, + "wilson_phase_error": 6.854278595401724e-15 + }, + "result_branch": "fixed_chern_deformed_holonomy", + "runtime_seconds": 796.3286967079985, + "sizes": [ + { + "N": 3, + "all_chern_equal": true, + "base_chern_convergence": 5.999999999999992, + "base_chern_integer": 6, + "base_chern_primary": 6.000000000000008, + "base_form_factor_residual": 2.0007870666635097, + "base_gap_ratio": 0.28849403034174614, + "commuting_chern_range": [ + 5.999999999999999, + 6.000000000000008 + ], + "convergence_endpoint_chern_range": [ + 5.999999999999983, + 6.000000000000016 + ], + "convergence_mesh": 20, + "cue_compatible_at_largest_g": false, + "cue_form_simultaneous_critical": 4.040319013665091, + "cue_gap_ratio_interval": [ + 0.45932310720759545, + 0.6015274327754949, + 0.7321866384754452 + ], + "cue_nonplateau_stop": 8, + "determinant_phase_x_base": [ + -6.462178297730347e-15, + -2.337076810780534, + 1.6062193961189957, + -0.7389241033561584, + -3.09104560882685, + 0.8323221348637835, + -1.5347369839765668, + 2.375762084784151, + -8.881784197001252e-15, + -2.3757620847841574, + 1.534736983976565, + -0.832322134863787, + 3.091045608826843, + 0.7389241033561496, + -1.606219396118986, + 2.337076810780528 + ], + "determinant_phase_x_final_seed0": [ + 2.2454878906793443, + -0.6765328698615356, + 2.9222577932068208, + 0.506283531479143, + -1.7287481156963305, + 2.3982202399393886, + 0.24404002542339498, + -1.9242454473982291, + 2.2092297311502707, + 0.07181419435803017, + -2.096843280217749, + 1.9961433339912085, + -0.1652234238114643, + -2.3336217017658676, + 1.5979775293091036, + -1.0937149906959105 + ], + "final_form_factor_residual_interval": [ + 1.8026889455555912, + 1.8920963483955333, + 1.9803746894500902 + ], + "final_gap_ratio_interval": [ + 0.3083682088396634, + 0.3211490061571388, + 0.35753863754806864 + ], + "form_factor_improvement_interval": [ + 0.06688879916463916, + 0.10420257129969823, + 0.14329861946049058 + ], + "gap_change_interval": [ + 0.02776830512270827, + 0.0380030887409316, + 0.05068408673223983 + ], + "gap_ratio_by_g": [ + [ + 0.28849403034174614, + 0.28849403034174614, + 0.28849403034174614 + ], + [ + 0.2954969911688561, + 0.2986664021663044, + 0.30136521326735277 + ], + [ + 0.2989874811158394, + 0.3086268711805841, + 0.31860295516441334 + ], + [ + 0.29455671175218856, + 0.3133798587975503, + 0.3312152066135331 + ], + [ + 0.3083682088396634, + 0.3211490061571388, + 0.35753863754806864 + ] + ], + "holonomy_change_significant": true, + "isospectrality_mode": "exact_coordinate_identity_under_periodic_ambient_conjugation", + "maximum_determinant_trace_difference": 1.7763568394002505e-15, + "maximum_energy_spectrum_error": 0.0, + "maximum_gap_error": 0.0, + "minimum_branch_margin": 2.0664262050334177, + "minimum_external_gap": 0.05174136811818207, + "minimum_overlap_singular_value": 0.8532507186567644, + "n_flux": 8, + "primary_chern_range": [ + 5.999999999999991, + 6.0000000000000115 + ], + "primary_mesh": 16, + "rank": 16 + }, + { + "N": 4, + "all_chern_equal": true, + "base_chern_convergence": 10.000000000000007, + "base_chern_integer": 10, + "base_chern_primary": 10.000000000000004, + "base_form_factor_residual": 2.725204138515438, + "base_gap_ratio": 0.3099772541531685, + "commuting_chern_range": [ + 9.999999999999982, + 10.000000000000004 + ], + "convergence_endpoint_chern_range": [ + 9.999999999999964, + 10.000000000000021 + ], + "convergence_mesh": 20, + "cue_compatible_at_largest_g": false, + "cue_form_simultaneous_critical": 4.453446695467018, + "cue_gap_ratio_interval": [ + 0.48664305097240024, + 0.6007916301768441, + 0.7091120263514404 + ], + "cue_nonplateau_stop": 12, + "determinant_phase_x_base": [ + -1.7763568394002505e-15, + 2.3723134790334774, + -1.5410064219030393, + 0.8243320772045875, + -3.099436177829827, + -0.7464370735867197, + 1.6006246643735051, + -2.3400483253279285, + -2.398081733190338e-14, + 2.340048325327913, + -1.6006246643735318, + 0.7464370735867267, + 3.0994361778298165, + -0.8243320772046141, + 1.5410064219030215, + -2.372313479033476 + ], + "determinant_phase_x_final_seed0": [ + -1.2453699057580307, + 1.699692311154675, + -1.0345417125113257, + 2.5600415168037567, + -0.5986221458250972, + 1.7915371175110564, + -2.9348347145056235, + -2.05293137072418, + -1.2035350383211592, + 0.443577218399921, + 3.0728988239887145, + -0.17002422802931377, + 2.68128750827685, + -1.1709851664332374, + 0.883025072000674, + 2.8031697851003554 + ], + "final_form_factor_residual_interval": [ + 2.4849772114027777, + 2.7074328640368925, + 2.7786443943635883 + ], + "final_gap_ratio_interval": [ + 0.32378757501780847, + 0.3317537354489108, + 0.34410932074928857 + ], + "form_factor_improvement_interval": [ + -0.012558663084553612, + 0.06566834713787378, + 0.1529437569546682 + ], + "gap_change_interval": [ + 0.01804628131689567, + 0.02304091398107431, + 0.028350326857310683 + ], + "gap_ratio_by_g": [ + [ + 0.3099772541531685, + 0.3099772541531685, + 0.3099772541531685 + ], + [ + 0.2991934892150269, + 0.3018554335669982, + 0.30570759750854193 + ], + [ + 0.3012063402387577, + 0.3084508324490812, + 0.3142702991463689 + ], + [ + 0.30691564668956783, + 0.31377435769419126, + 0.3254795233842568 + ], + [ + 0.32378757501780847, + 0.3317537354489108, + 0.34410932074928857 + ] + ], + "holonomy_change_significant": true, + "isospectrality_mode": "exact_coordinate_identity_under_periodic_ambient_conjugation", + "maximum_determinant_trace_difference": 3.552713678800501e-15, + "maximum_energy_spectrum_error": 0.0, + "maximum_gap_error": 0.0, + "minimum_branch_margin": 1.179800007321263, + "minimum_external_gap": 0.09469522123228812, + "minimum_overlap_singular_value": 0.8369320542808095, + "n_flux": 10, + "primary_chern_range": [ + 9.99999999999998, + 10.000000000000027 + ], + "primary_mesh": 16, + "rank": 25 + } + ], + "version": "v3" +} \ No newline at end of file diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/topological_holonomy_v3.npz b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/topological_holonomy_v3.npz new file mode 100644 index 000000000..7ac0fa3b6 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/output/topological_holonomy_v3.npz differ diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/requirements.txt b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/requirements.txt new file mode 100644 index 000000000..261b165e5 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/requirements.txt @@ -0,0 +1,7 @@ +numpy==2.3.5 +scipy==1.16.3 +matplotlib==3.10.8 +Pillow==12.0.0 +pypdf==6.7.0 +pytest==9.0.2 +PyYAML==6.0.3 diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_covariance_model_v1.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_covariance_model_v1.py new file mode 100644 index 000000000..615afb2c1 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_covariance_model_v1.py @@ -0,0 +1,458 @@ +#!/usr/bin/env python3 +"""Fit and test a held-out covariance-deformed Geometric-ETH model.""" + +from __future__ import annotations + +import argparse +import json +import platform +import time +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np + +from lgeth.grassmann import ( + coordinate_participation, + covariance_deformed_rows, + frame_overlap, + haar_frame_overlap_mean, + polarization_imbalance, + principal_angles, + regularize_covariance, +) +from lgeth.jacobi import ( + canonical_channel_form, + normalized_curvature, + sample_jacobi_compression, +) +from lgeth.statistics import bulk_gap_ratio_per_spectrum, histogram_l1 + + +VERSION = "v1" +REGISTERED_DIAGNOSTIC_ROWS = 1_024 +REGISTERED_MODEL_SAMPLES = 10_000 +CANDIDATE_FLOORS = (0.002, 0.005, 0.01, 0.02, 0.05) +HISTOGRAM_EDGES = np.linspace(-1.0, 1.0, 161) + + +def _channel( + coefficients: np.ndarray, + channel_basis: np.ndarray, + tangent_gram: np.ndarray, +) -> np.ndarray: + norm_squared = float(coefficients @ tangent_gram @ coefficients) + if norm_squared <= 0.0: + raise RuntimeError("cached tangent has zero many-body norm") + return ( + np.tensordot(coefficients, channel_basis, axes=(0, 0)) + / np.sqrt(norm_squared) + ) + + +def _physical_rows( + arrays: Any, + indices: np.ndarray, +): + channel_basis = arrays["channel_basis"] + tangent_gram = arrays["tangent_gram"] + coefficients_v = arrays["tangent_coefficients_v"] + coefficients_w = arrays["tangent_coefficients_w"] + for raw_index in indices: + index = int(raw_index) + channel_v = _channel( + coefficients_v[index], channel_basis, tangent_gram + ) + channel_w = _channel( + coefficients_w[index], channel_basis, tangent_gram + ) + yield normalized_curvature( + channel_v, + channel_w, + rtol=1e-10, + ).Y + + +def _training_geometry( + arrays: Any, + indices: np.ndarray, +) -> tuple[np.ndarray, dict[str, np.ndarray | float]]: + dimension = int(arrays["channel_basis"].shape[2] * 2) + rank = int(arrays["normalized_spectra"].shape[1]) + mean_projector = np.zeros((dimension, dimension), dtype=complex) + per_block = np.zeros((8, dimension, dimension), dtype=complex) + block_count = np.zeros(8, dtype=int) + participation = np.empty(indices.size, dtype=float) + polarization = np.empty(indices.size, dtype=float) + frame_overlaps = np.empty(indices.size // 2, dtype=float) + angles: list[np.ndarray] = [] + previous = None + pair = 0 + second_sum = 0.0 + fourth_sum = 0.0 + entry_count = 0 + for position, (index, rows) in enumerate( + zip(indices, _physical_rows(arrays, indices), strict=True) + ): + projector = rows.conj().T @ rows + mean_projector += projector + block = int(arrays["seed_block"][int(index)]) + per_block[block] += projector + block_count[block] += 1 + participation[position] = coordinate_participation(rows)["fraction"] + polarization[position] = polarization_imbalance(rows) + squared = np.abs(rows).ravel() ** 2 + second_sum += float(np.sum(squared)) + fourth_sum += float(np.sum(squared * squared)) + entry_count += squared.size + if position % 2 == 0: + previous = rows + elif previous is not None: + frame_overlaps[pair] = frame_overlap(previous, rows) + angles.append(principal_angles(previous, rows)) + previous = None + pair += 1 + mean_projector /= indices.size + for block in range(8): + if block_count[block]: + per_block[block] /= block_count[block] + isotropic = (rank / dimension) * np.eye(dimension) + anisotropy = float( + np.linalg.norm(mean_projector - isotropic) + / np.linalg.norm(isotropic) + ) + principal = np.concatenate(angles) if angles else np.empty(0) + second = second_sum / entry_count + fourth_ratio = (fourth_sum / entry_count) / (second * second) + diagnostics: dict[str, np.ndarray | float] = { + "mean_projector_by_seed_block": per_block, + "seed_block_counts": block_count, + "participation": participation, + "polarization": polarization, + "frame_overlaps": frame_overlaps, + "principal_angles": principal, + "relative_frobenius_anisotropy": anisotropy, + "entry_fourth_ratio": fourth_ratio, + } + return mean_projector, diagnostics + + +def _spectra_from_deformed( + rank: int, + covariance: np.ndarray, + floor: float, + samples: int, + seed: int, + progress_label: str | None = None, +) -> np.ndarray: + dimension = covariance.shape[0] + form = canonical_channel_form(dimension // 2) + spectra = np.empty((samples, rank), dtype=np.float32) + rng = np.random.default_rng(seed) + for index, rows in enumerate( + covariance_deformed_rows( + rank, + covariance, + samples, + rng, + floor_fraction=floor, + ) + ): + omega = rows @ form @ rows.conj().T + spectra[index] = np.linalg.eigvalsh( + 0.5 * (omega + omega.conj().T) + ) + if ( + progress_label is not None + and (index + 1) % max(1, samples // 4) == 0 + ): + print( + f"{progress_label}: {index + 1}/{samples}", + flush=True, + ) + return spectra + + +def _comparison( + physical: np.ndarray, + haar: np.ndarray, + deformed: np.ndarray, +) -> dict[str, Any]: + haar_l1 = histogram_l1(physical, haar, HISTOGRAM_EDGES) + deformed_l1 = histogram_l1(physical, deformed, HISTOGRAM_EDGES) + physical_gap = bulk_gap_ratio_per_spectrum(physical) + haar_gap = bulk_gap_ratio_per_spectrum(haar) + deformed_gap = bulk_gap_ratio_per_spectrum(deformed) + moments = {} + for order in (2, 4, 6, 8): + moments[str(order)] = { + "physical": float(np.mean(physical.astype(float) ** order)), + "haar": float(np.mean(haar.astype(float) ** order)), + "deformed": float(np.mean(deformed.astype(float) ** order)), + } + improvement = (haar_l1 - deformed_l1) / haar_l1 + gap_difference = abs( + float(np.mean(physical_gap)) - float(np.mean(deformed_gap)) + ) + if improvement >= 0.25 and gap_difference < 0.025: + branch = "leading_covariance_capture" + elif improvement > 0.05: + branch = "partial_capture" + else: + branch = "no_held_out_improvement" + return { + "density_l1": { + "physical_vs_haar": haar_l1, + "physical_vs_deformed": deformed_l1, + "relative_improvement": improvement, + }, + "mean_gap_ratio": { + "physical": float(np.mean(physical_gap)), + "haar": float(np.mean(haar_gap)), + "deformed": float(np.mean(deformed_gap)), + "physical_deformed_absolute_difference": gap_difference, + }, + "moments": moments, + "result_branch": branch, + } + + +def run( + physical_npz: Path, + output_json: Path, + output_npz: Path, + diagnostic_rows: int = REGISTERED_DIAGNOSTIC_ROWS, + model_samples: int = REGISTERED_MODEL_SAMPLES, +) -> dict[str, Any]: + """Fit on train, choose the floor on validation, and report only test.""" + + started = time.perf_counter() + row_count = int(diagnostic_rows) + sample_count = int(model_samples) + if row_count < 16 or sample_count < 16: + raise ValueError("require at least 16 diagnostic rows and spectra") + with np.load(physical_npz) as arrays: + train_all = arrays["train_indices"] + validation_indices = arrays["validation_indices"] + test_indices = arrays["test_indices"] + if row_count > train_all.size: + raise ValueError("diagnostic_rows exceeds the training split") + diagnostic_indices = train_all[:row_count] + mean_projector, geometry = _training_geometry( + arrays, + diagnostic_indices, + ) + rank = int(arrays["normalized_spectra"].shape[1]) + dimension = int(mean_projector.shape[0]) + physical_validation = arrays["normalized_spectra"][ + validation_indices + ].astype(float) + physical_test = arrays["normalized_spectra"][test_indices].astype( + float + ) + validation_samples = min(max(32, sample_count // 20), 512) + validation_scores: dict[str, dict[str, float]] = {} + validation_spectra = np.empty( + (len(CANDIDATE_FLOORS), validation_samples, rank), + dtype=np.float32, + ) + for floor_index, floor in enumerate(CANDIDATE_FLOORS): + candidate = _spectra_from_deformed( + rank, + mean_projector, + floor, + validation_samples, + seed=20260728200, + ) + validation_spectra[floor_index] = candidate + density_l1 = histogram_l1( + physical_validation, + candidate, + HISTOGRAM_EDGES, + ) + physical_gap = float( + np.mean(bulk_gap_ratio_per_spectrum(physical_validation)) + ) + candidate_gap = float( + np.mean(bulk_gap_ratio_per_spectrum(candidate)) + ) + gap_difference = abs(physical_gap - candidate_gap) + validation_scores[str(floor)] = { + "density_l1": density_l1, + "gap_ratio_difference": gap_difference, + "selection_score": density_l1 + 0.5 * gap_difference, + } + selected_floor = min( + CANDIDATE_FLOORS, + key=lambda floor: validation_scores[str(floor)][ + "selection_score" + ], + ) + haar_spectra = sample_jacobi_compression( + rank, + dimension // 2, + sample_count, + seed=20260728210, + ).astype(np.float32) + print(f"Haar reference: {sample_count}/{sample_count}", flush=True) + deformed_spectra = _spectra_from_deformed( + rank, + mean_projector, + selected_floor, + sample_count, + seed=20260728220, + progress_label="deformed model", + ) + comparison = _comparison( + physical_test, + haar_spectra, + deformed_spectra, + ) + regularized = regularize_covariance( + mean_projector, + floor_fraction=selected_floor, + ) + covariance_eigenvalues = np.linalg.eigvalsh(regularized) + frame_baseline = haar_frame_overlap_mean(rank, dimension) + geometry_summary = { + "relative_frobenius_anisotropy": float( + geometry["relative_frobenius_anisotropy"] + ), + "mean_participation_fraction": float( + np.mean(geometry["participation"]) + ), + "mean_absolute_polarization": float( + np.mean(np.abs(geometry["polarization"])) + ), + "mean_frame_overlap": float(np.mean(geometry["frame_overlaps"])), + "haar_frame_overlap": frame_baseline, + "mean_principal_angle": float( + np.mean(geometry["principal_angles"]) + ), + "entry_fourth_ratio": float(geometry["entry_fourth_ratio"]), + } + checks = { + "train_validation_test_disjoint": bool( + np.intersect1d(diagnostic_indices, validation_indices).size == 0 + and np.intersect1d(diagnostic_indices, test_indices).size == 0 + and np.intersect1d(validation_indices, test_indices).size == 0 + ), + "covariance_fit_uses_requested_training_rows": ( + diagnostic_indices.size == row_count + ), + "all_candidate_floors_scored": ( + len(validation_scores) == len(CANDIDATE_FLOORS) + ), + "selected_floor_is_registered": selected_floor in CANDIDATE_FLOORS, + "model_shapes_match": bool( + haar_spectra.shape == (sample_count, rank) + and deformed_spectra.shape == (sample_count, rank) + ), + "all_spectra_bounded": bool( + np.max(np.abs(haar_spectra)) <= 1.0 + 2e-7 + and np.max(np.abs(deformed_spectra)) <= 1.0 + 2e-7 + ), + "branch_registered": comparison["result_branch"] + in { + "leading_covariance_capture", + "partial_capture", + "no_held_out_improvement", + }, + } + result = { + "schema_version": 1, + "version": VERSION, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "physical_source": str(physical_npz), + "rank": rank, + "ambient_channel_dimension": dimension, + "diagnostic_training_rows": row_count, + "validation_model_samples_per_floor": validation_samples, + "haar_samples": sample_count, + "deformed_samples": sample_count, + "candidate_floors": list(CANDIDATE_FLOORS), + "validation_scores": validation_scores, + "selected_floor": selected_floor, + "training_geometry": geometry_summary, + "held_out_test": comparison, + "checks": checks, + "all_checks_pass": bool(all(checks.values())), + "runtime_seconds": time.perf_counter() - started, + "environment": { + "python": platform.python_version(), + "numpy": np.__version__, + "platform": platform.platform(), + }, + } + output_json.parent.mkdir(parents=True, exist_ok=True) + output_npz.parent.mkdir(parents=True, exist_ok=True) + output_json.write_text( + json.dumps(result, indent=2) + "\n", + encoding="utf-8", + ) + np.savez_compressed( + output_npz, + mean_projector=mean_projector, + covariance_eigenvalues=covariance_eigenvalues, + diagnostic_indices=diagnostic_indices, + validation_indices=validation_indices, + test_indices=test_indices, + validation_spectra=validation_spectra, + candidate_floors=np.asarray(CANDIDATE_FLOORS), + haar_spectra=haar_spectra, + deformed_spectra=deformed_spectra, + mean_projector_by_seed_block=geometry[ + "mean_projector_by_seed_block" + ], + seed_block_counts=geometry["seed_block_counts"], + physical_participation=geometry["participation"], + physical_polarization=geometry["polarization"], + physical_frame_overlaps=geometry["frame_overlaps"], + physical_principal_angles=geometry["principal_angles"], + ) + return result + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--physical-npz", + type=Path, + default=Path("output/physical_ensemble_v1.npz"), + ) + parser.add_argument( + "--output-json", + type=Path, + default=Path("output/covariance_model_v1.json"), + ) + parser.add_argument( + "--output-npz", + type=Path, + default=Path("output/covariance_model_v1.npz"), + ) + parser.add_argument( + "--diagnostic-rows", + type=int, + default=REGISTERED_DIAGNOSTIC_ROWS, + ) + parser.add_argument( + "--model-samples", + type=int, + default=REGISTERED_MODEL_SAMPLES, + ) + args = parser.parse_args() + result = run( + args.physical_npz, + args.output_json, + args.output_npz, + diagnostic_rows=args.diagnostic_rows, + model_samples=args.model_samples, + ) + print(json.dumps(result, indent=2)) + if not result["all_checks_pass"]: + raise SystemExit("covariance-model audit failed") + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_full_recompute_v1.sh b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_full_recompute_v1.sh new file mode 100755 index 000000000..5d730d47d --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_full_recompute_v1.sh @@ -0,0 +1,11 @@ +#!/usr/bin/env bash +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "${SCRIPT_DIR}" + +bash run_large_scale_article_v1.sh +bash run_spectral_silence_article_v2.sh +FULL_RECOMPUTE=1 bash run_geometric_eth_topology_article_v3.sh +python make_release_manifest_v1.py +python verify_release_contract_v1.py diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_geometric_eth_topology_article_v3.sh b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_geometric_eth_topology_article_v3.sh new file mode 100755 index 000000000..a91bb88a6 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_geometric_eth_topology_article_v3.sh @@ -0,0 +1,41 @@ +#!/usr/bin/env bash +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +REPO_ROOT="$(cd "${SCRIPT_DIR}/../../.." && pwd)" +ARTICLE_DIR="${REPO_ROOT}/overleaf_sync/geometric_eth_large_scale" +export SOURCE_DATE_EPOCH="${SOURCE_DATE_EPOCH:-1785283200}" + +cd "${SCRIPT_DIR}" + +if [[ "${FULL_RECOMPUTE:-0}" == "1" ]]; then + python run_matrix_element_geometric_eth_v3.py + python run_topological_holonomy_v3.py --workers "${TOPOLOGY_WORKERS:-4}" + python make_matrix_element_geometric_eth_figure_v3.py + python verify_matrix_element_geometric_eth_v3.py + python make_topological_holonomy_figure_v3.py + python verify_topological_holonomy_v3.py + python make_geometric_eth_topology_assets_v3.py + python verify_matrix_element_topology_theory_v3.py +fi + +if [[ "${VALIDATE_CITATIONS:-0}" == "1" ]]; then + python validate_citations_v1.py +fi +cp output/figure_6_wick_factorization_v3.pdf \ + "${ARTICLE_DIR}/figures/figure_6_wick_factorization_v3.pdf" +cp output/figure_7_topological_holonomy_v3.pdf \ + "${ARTICLE_DIR}/figures/figure_7_topological_holonomy_v3.pdf" + +cd "${ARTICLE_DIR}" +latexmk -C main.tex +latexmk -pdf -interaction=nonstopmode -halt-on-error main.tex + +cd "${SCRIPT_DIR}" +python verify_geometric_eth_topology_article_v3.py +PYTHONPATH="${SCRIPT_DIR}${PYTHONPATH:+:${PYTHONPATH}}" python -m pytest -q \ + tests/test_geometric_eth_topology_assets_v3.py \ + tests/test_matrix_element_topology_theory_v3.py \ + tests/test_geometric_eth_topology_article_v3.py +python make_release_manifest_v1.py +python verify_release_contract_v1.py diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_large_scale_article_v1.sh b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_large_scale_article_v1.sh new file mode 100755 index 000000000..879ca3175 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_large_scale_article_v1.sh @@ -0,0 +1,38 @@ +#!/usr/bin/env bash +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +REPO_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)" +ARTICLE_DIR="$REPO_ROOT/overleaf_sync/geometric_eth_large_scale" +OUTPUT_DIR="$SCRIPT_DIR/output" + +cd "$SCRIPT_DIR" +python run_physical_ensemble_v1.py +python run_covariance_model_v1.py +python run_rank_scaling_v1.py +python run_statistical_analysis_v1.py +python make_large_scale_figures_v1.py +python validate_citations_v1.py + +for stem in \ + figure_1_physical_law_v1 \ + figure_2_scale_hierarchy_v1 \ + figure_3_atom_crossover_v1 \ + figure_4_finite_size_v1 \ + figure_5_covariance_mechanism_v1 +do + cp "$OUTPUT_DIR/$stem.pdf" "$ARTICLE_DIR/figures/$stem.pdf" +done +cp "$OUTPUT_DIR/generated_numbers_v1.tex" \ + "$ARTICLE_DIR/generated/generated_numbers_v1.tex" +cp "$OUTPUT_DIR/generated_tables_v1.tex" \ + "$ARTICLE_DIR/generated/generated_tables_v1.tex" + +cd "$ARTICLE_DIR" +latexmk -pdf -interaction=nonstopmode -halt-on-error main.tex +cp main.pdf \ + "$OUTPUT_DIR/from_local_repulsion_to_global_geometry_v1.pdf" + +cd "$SCRIPT_DIR" +python -m pytest -q tests | tee "$OUTPUT_DIR/pytest_v1.txt" +python verify_large_scale_article_v1.py diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_matrix_element_geometric_eth_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_matrix_element_geometric_eth_v3.py new file mode 100644 index 000000000..2850f4737 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_matrix_element_geometric_eth_v3.py @@ -0,0 +1,575 @@ +#!/usr/bin/env python3 +"""Run gauge-invariant four-channel tests on a genuine many-body sequence.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import platform +import time +from dataclasses import asdict +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np + +from lgeth.lattice import build_kapit_laughlin_parent +from lgeth.manybody_response import ( + SiteResponseCache, + audit_unregistered_small_case, + build_site_response_cache, + registered_fixed_two_qh_cases, + solve_kernel_frame, +) +from lgeth.wick_channels import ( + assemble_channels, + covariance_matched_wick, + fourier_density_panel, + gaussian_r4_reference, + local_density_panels, +) + + +VERSION = "v3" +SCRIPT_ROOT = Path(__file__).resolve().parent +OUTPUT_ROOT = SCRIPT_ROOT / "output" +OUTPUT_JSON = OUTPUT_ROOT / "matrix_element_geometric_eth_v3.json" +OUTPUT_NPZ = OUTPUT_ROOT / "matrix_element_geometric_eth_v3.npz" +CHECKPOINT_ROOT = OUTPUT_ROOT / "matrix_element_v3_checkpoints" +REGISTERED_PANELS = 24 +REGISTERED_PANEL_SIZE = 8 +REGISTERED_GAUSSIAN_SAMPLES = 2_000 +REGISTERED_SEED = 20260728320 +RELATIVE_SHIFTS = (1e-3, 5e-4) + + +def _sha256_file(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for chunk in iter(lambda: handle.read(1 << 20), b""): + digest.update(chunk) + return digest.hexdigest() + + +def _json_hash(payload: dict[str, Any]) -> str: + encoded = json.dumps( + payload, + sort_keys=True, + separators=(",", ":"), + ).encode("utf-8") + return hashlib.sha256(encoded).hexdigest() + + +def _atomic_json(path: Path, payload: dict[str, Any]) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text( + json.dumps(payload, indent=2, sort_keys=True), + encoding="utf-8", + ) + temporary.replace(path) + + +def _atomic_npz(path: Path, **arrays: np.ndarray) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + with temporary.open("wb") as handle: + np.savez_compressed(handle, **arrays) + temporary.replace(path) + + +def _checkpoint_identity(case) -> dict[str, Any]: + sources = ( + SCRIPT_ROOT / "lgeth" / "manybody_response.py", + SCRIPT_ROOT / "lgeth" / "lattice.py", + SCRIPT_ROOT / "lgeth" / "combinatorics.py", + ) + return { + "version": VERSION, + "case": asdict(case), + "relative_shifts": list(RELATIVE_SHIFTS), + "sources": { + str(path.relative_to(SCRIPT_ROOT)): _sha256_file(path) + for path in sources + }, + "numpy": np.__version__, + } + + +def _checkpoint_paths( + checkpoint_dir: Path, + N: int, +) -> tuple[Path, Path]: + stem = checkpoint_dir / f"N{int(N)}_site_response_v3" + return stem.with_suffix(".json"), stem.with_suffix(".npz") + + +def _load_checkpoint( + checkpoint_dir: Path, + case, +) -> tuple[SiteResponseCache, dict[str, Any]] | None: + metadata_path, arrays_path = _checkpoint_paths(checkpoint_dir, case.N) + if not metadata_path.exists() or not arrays_path.exists(): + return None + metadata = json.loads(metadata_path.read_text(encoding="utf-8")) + identity = _checkpoint_identity(case) + if metadata.get("identity_hash") != _json_hash(identity): + return None + if metadata.get("identity") != identity: + return None + if not all(metadata.get("checks", {}).values()): + return None + with np.load(arrays_path, allow_pickle=False) as arrays: + cache = SiteResponseCache( + case=case, + site_indices=tuple( + int(value) for value in arrays["site_indices"] + ), + solutions=np.asarray(arrays["solutions"], dtype=complex), + tangent_gram=np.asarray(arrays["tangent_gram"]), + external_gap=float(metadata["external_gap"]), + shift_values=tuple( + float(value) for value in metadata["shift_values"] + ), + maximum_relative_residual=float( + metadata["maximum_relative_residual"] + ), + maximum_shift_difference=float( + metadata["maximum_shift_difference"] + ), + maximum_kernel_leakage=float( + metadata["maximum_kernel_leakage"] + ), + ) + return cache, metadata + + +def _build_checkpoint( + checkpoint_dir: Path, + case, + seed: int, +) -> tuple[SiteResponseCache, dict[str, Any]]: + started = time.perf_counter() + system = build_kapit_laughlin_parent( + case.N, + case.n_flux, + case.theta_x, + case.theta_y, + ) + kernel = solve_kernel_frame(system, case, seed=seed) + cache = build_site_response_cache( + system, + kernel, + relative_shifts=RELATIVE_SHIFTS, + ) + checks = { + "kernel_count": kernel.observed_rank == case.expected_rank, + "external_gap": kernel.external_gap > 1e-8, + "kernel_residual": kernel.residual_norm + < (1e-8 if kernel.method == "dense" else 5e-7), + "kernel_orthonormality": kernel.orthonormality_error < 1e-9, + "resolvent_residual": cache.maximum_relative_residual < 2e-3, + "resolvent_shift_stability": cache.maximum_shift_difference < 5e-2, + "kernel_leakage": cache.maximum_kernel_leakage < 1e-7, + } + identity = _checkpoint_identity(case) + metadata = { + "identity": identity, + "identity_hash": _json_hash(identity), + "case": asdict(case), + "basis_dimension": system.basis.dimension, + "physical_sites": system.orbitals.shape[0], + "lattice_length": system.length, + "kernel_method": kernel.method, + "observed_rank": kernel.observed_rank, + "external_gap": kernel.external_gap, + "kernel_residual_norm": kernel.residual_norm, + "kernel_orthonormality_error": kernel.orthonormality_error, + "shift_values": list(cache.shift_values), + "maximum_relative_residual": cache.maximum_relative_residual, + "maximum_shift_difference": cache.maximum_shift_difference, + "maximum_kernel_leakage": cache.maximum_kernel_leakage, + "runtime_seconds": time.perf_counter() - started, + "checks": checks, + } + if not all(checks.values()): + raise RuntimeError( + f"many-body response checkpoint failed for N={case.N}: {checks}" + ) + metadata_path, arrays_path = _checkpoint_paths( + checkpoint_dir, + case.N, + ) + _atomic_npz( + arrays_path, + site_indices=np.asarray(cache.site_indices, dtype=np.int16), + solutions=cache.solutions, + tangent_gram=cache.tangent_gram, + ) + metadata["arrays_sha256"] = _sha256_file(arrays_path) + _atomic_json(metadata_path, metadata) + return cache, metadata + + +def _seeded_unitary(dimension: int, seed: int) -> np.ndarray: + rng = np.random.default_rng(int(seed)) + matrix = rng.normal(size=(dimension, dimension)) + matrix = matrix + 1j * rng.normal(size=matrix.shape) + unitary, _ = np.linalg.qr(matrix) + return unitary + + +def _gauge_invariance_error( + channels: np.ndarray, + seed: int, +) -> float: + values = np.asarray(channels, dtype=complex) + reference = covariance_matched_wick(values).R4 + label = _seeded_unitary(values.shape[0], seed) + target = _seeded_unitary(values.shape[2], seed + 1) + rng = np.random.default_rng(seed + 2) + external_phases = np.exp( + 2j * np.pi * rng.random(values.shape[1]) + ) + transformed = np.einsum( + "mn,a,naj,jk->mak", + label, + external_phases, + values, + target, + optimize=True, + ) + observed = covariance_matched_wick(transformed).R4 + return abs(observed - reference) + + +def _pooled_spectrum(spectra: list[np.ndarray]) -> np.ndarray: + if not spectra: + raise ValueError("cannot pool an empty covariance spectrum") + maximum = max(values.size for values in spectra) + padded = np.zeros((len(spectra), maximum), dtype=float) + for index, values in enumerate(spectra): + normalized = np.asarray(values, dtype=float) + normalized = normalized / np.sum(normalized) + padded[index, -normalized.size :] = normalized + pooled = np.mean(padded, axis=0) + return pooled[pooled > 1e-14 * np.max(pooled)] + + +def _case_statistics( + cache: SiteResponseCache, + metadata: dict[str, Any], + panels: int, + gaussian_samples: int, + seed: int, +) -> tuple[dict[str, Any], dict[str, np.ndarray]]: + length = int(metadata["lattice_length"]) + panel_coefficients = local_density_panels( + length=length, + panel_size=REGISTERED_PANEL_SIZE, + panels=panels, + seed=seed, + ) + physical_R4 = np.empty(panels, dtype=float) + A_left = np.empty(panels, dtype=float) + B_right = np.empty(panels, dtype=float) + condition = np.empty(panels, dtype=float) + left_spectra: list[np.ndarray] = [] + right_spectra: list[np.ndarray] = [] + first_channels: np.ndarray | None = None + for panel in range(panels): + channels = assemble_channels(cache, panel_coefficients[panel]) + if first_channels is None: + first_channels = channels + result = covariance_matched_wick(channels) + physical_R4[panel] = result.R4 + A_left[panel] = result.A_left + B_right[panel] = result.B_right + condition[panel] = ( + result.channel_covariance_eigenvalues[-1] + / result.channel_covariance_eigenvalues[0] + ) + left_spectra.append(result.left_eigenvalues) + right_spectra.append(result.right_eigenvalues) + if first_channels is None: + raise RuntimeError("no physical operator panels were evaluated") + structured_channels = assemble_channels( + cache, + fourier_density_panel(length, REGISTERED_PANEL_SIZE), + ) + structured = covariance_matched_wick(structured_channels) + pooled_left = _pooled_spectrum(left_spectra) + pooled_right = _pooled_spectrum(right_spectra) + reproducibility_first = gaussian_r4_reference( + pooled_left, + pooled_right, + REGISTERED_PANEL_SIZE, + samples=min(16, gaussian_samples), + seed=seed + 100, + ) + reproducibility_second = gaussian_r4_reference( + pooled_left, + pooled_right, + REGISTERED_PANEL_SIZE, + samples=min(16, gaussian_samples), + seed=seed + 100, + ) + reference = gaussian_r4_reference( + pooled_left, + pooled_right, + REGISTERED_PANEL_SIZE, + samples=gaussian_samples, + seed=seed + 200, + ) + quantiles = np.quantile(reference, [0.025, 0.5, 0.975]) + case_checks = dict(metadata["checks"]) + case_checks.update( + { + "channel_support": bool(np.all(np.isfinite(condition))), + "gauge_invariance": _gauge_invariance_error( + first_channels, + seed + 300, + ) + < 2e-9, + "reference_reproducibility": bool( + np.array_equal( + reproducibility_first, + reproducibility_second, + ) + ), + } + ) + summary = { + "N": cache.case.N, + "n_flux": cache.case.n_flux, + "rank": cache.case.expected_rank, + "basis_dimension": metadata["basis_dimension"], + "physical_sites": metadata["physical_sites"], + "lattice_length": length, + "kernel_method": metadata["kernel_method"], + "external_gap": metadata["external_gap"], + "kernel_residual_norm": metadata["kernel_residual_norm"], + "kernel_orthonormality_error": metadata[ + "kernel_orthonormality_error" + ], + "maximum_relative_residual": metadata[ + "maximum_relative_residual" + ], + "maximum_shift_difference": metadata[ + "maximum_shift_difference" + ], + "maximum_kernel_leakage": metadata[ + "maximum_kernel_leakage" + ], + "physical_R4": physical_R4.tolist(), + "physical_R4_median": float(np.median(physical_R4)), + "physical_R4_interval": np.quantile( + physical_R4, + [0.025, 0.975], + ).tolist(), + "structured_R4": structured.R4, + "gaussian_R4_interval": quantiles.tolist(), + "physical_excess": float(np.median(physical_R4) - quantiles[1]), + "A_left_median": float(np.median(A_left)), + "B_right_median": float(np.median(B_right)), + "channel_condition_maximum": float(np.max(condition)), + "gauge_invariance_error": _gauge_invariance_error( + first_channels, + seed + 300, + ), + "checks": case_checks, + } + arrays = { + "physical_R4": physical_R4, + "A_left": A_left, + "B_right": B_right, + "channel_condition": condition, + "gaussian_R4": reference, + "pooled_left_eigenvalues": pooled_left, + "pooled_right_eigenvalues": pooled_right, + "structured_R4": np.asarray(structured.R4), + } + return summary, arrays + + +def select_result_branch(payload: dict[str, Any]) -> str: + """Select the preregistered matrix-element result branch.""" + + cases = payload.get("cases", []) + checks = payload.get("checks", {}) + if len(cases) != 3 or not all(checks.values()): + return "manybody_sequence_incomplete" + medians = np.asarray( + [case["physical_R4_median"] for case in cases], + dtype=float, + ) + upper = np.asarray( + [case["gaussian_R4_interval"][2] for case in cases], + dtype=float, + ) + slope = float(np.polyfit([3.0, 4.0, 5.0], medians, 1)[0]) + if medians[-1] <= upper[-1] and slope < 0.0: + return "wick_compatible_trend" + if medians[-1] > upper[-1] and np.count_nonzero(medians > upper) >= 2: + return "deformed_geometric_eth" + return "no_matrix_element_eth_trend" + + +def run( + output_json: Path = OUTPUT_JSON, + output_npz: Path = OUTPUT_NPZ, + checkpoint_dir: Path = CHECKPOINT_ROOT, + case_indices: tuple[int, ...] = (0, 1, 2), + panels: int = REGISTERED_PANELS, + gaussian_samples: int = REGISTERED_GAUSSIAN_SAMPLES, + production: bool = True, + seed: int = REGISTERED_SEED, +) -> dict[str, Any]: + """Run the registered or reduced matrix-element calculation.""" + + started = time.perf_counter() + panel_count = int(panels) + reference_count = int(gaussian_samples) + if panel_count < 2 or reference_count < 8: + raise ValueError("require at least two panels and eight references") + registered = registered_fixed_two_qh_cases() + selected = tuple(registered[int(index)] for index in case_indices) + if not selected: + raise ValueError("at least one many-body case is required") + excluded = audit_unregistered_small_case(2, 6, 0.17, 0.29) + case_summaries: list[dict[str, Any]] = [] + case_arrays: list[dict[str, np.ndarray]] = [] + for offset, case in enumerate(selected): + loaded = _load_checkpoint(checkpoint_dir, case) + reused = loaded is not None + if loaded is None: + cache, metadata = _build_checkpoint( + checkpoint_dir, + case, + seed=seed + 10 * offset, + ) + else: + cache, metadata = loaded + summary, arrays = _case_statistics( + cache, + metadata, + panels=panel_count, + gaussian_samples=reference_count, + seed=seed + 1_000 * offset, + ) + summary["checkpoint_reused"] = reused + summary["checkpoint_identity_hash"] = metadata["identity_hash"] + case_summaries.append(summary) + case_arrays.append(arrays) + all_case_checks = { + key: all(case["checks"].get(key, False) for case in case_summaries) + for key in { + key + for case in case_summaries + for key in case["checks"] + } + } + checks = { + "kernel_count": all_case_checks.get("kernel_count", False), + "external_gap": all_case_checks.get("external_gap", False), + "resolvent_residual": all_case_checks.get( + "resolvent_residual", + False, + ), + "channel_support": all_case_checks.get("channel_support", False), + "gauge_invariance": all_case_checks.get("gauge_invariance", False), + "reference_reproducibility": all_case_checks.get( + "reference_reproducibility", + False, + ), + "n2_excluded_before_production": ( + excluded.expected_rank == 9 + and excluded.observed_rank == 12 + and not excluded.accepted + ), + } + payload: dict[str, Any] = { + "version": VERSION, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "configuration": { + "case_indices": list(case_indices), + "panel_size": REGISTERED_PANEL_SIZE, + "panels": panel_count, + "gaussian_samples": reference_count, + "seed": int(seed), + "relative_shifts": list(RELATIVE_SHIFTS), + "production": bool(production), + }, + "excluded_small_case": asdict(excluded), + "cases": case_summaries, + "checks": checks, + "runtime_seconds": time.perf_counter() - started, + "environment": { + "python": platform.python_version(), + "numpy": np.__version__, + "platform": platform.platform(), + }, + } + if len(case_summaries) == 3: + medians = np.asarray( + [case["physical_R4_median"] for case in case_summaries] + ) + payload["descriptive_slope_per_particle"] = float( + np.polyfit([3.0, 4.0, 5.0], medians, 1)[0] + ) + else: + payload["descriptive_slope_per_particle"] = None + payload["result_branch"] = select_result_branch(payload) + output_arrays: dict[str, np.ndarray] = { + "N": np.asarray([case["N"] for case in case_summaries]), + "rank": np.asarray([case["rank"] for case in case_summaries]), + "external_gap": np.asarray( + [case["external_gap"] for case in case_summaries] + ), + } + for index, arrays in enumerate(case_arrays): + for key, values in arrays.items(): + output_arrays[f"case_{index}_{key}"] = np.asarray(values) + _atomic_npz(output_npz, **output_arrays) + payload["npz_sha256"] = _sha256_file(output_npz) + _atomic_json(output_json, payload) + if production and ( + len(case_summaries) != 3 + or not all(checks.values()) + ): + raise RuntimeError("production matrix-element gates failed") + return payload + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--reduced", + action="store_true", + help="run the N=3 smoke configuration", + ) + arguments = parser.parse_args() + if arguments.reduced: + payload = run( + case_indices=(0,), + panels=3, + gaussian_samples=32, + production=False, + ) + else: + payload = run() + print(json.dumps( + { + "result_branch": payload["result_branch"], + "checks": payload["checks"], + "runtime_seconds": payload["runtime_seconds"], + }, + indent=2, + sort_keys=True, + )) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_physical_ensemble_v1.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_physical_ensemble_v1.py new file mode 100644 index 000000000..1c70a1f7a --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_physical_ensemble_v1.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +"""Generate the high-statistics physical Berry-curvature ensemble.""" + +from __future__ import annotations + +import argparse +import json +import platform +import time +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np + +from lgeth.channels import ( + build_physical_channel_cache, + cached_channel, + curvature_from_channels, + normalized_potential, +) +from lgeth.jacobi import jacobi_parameters, normalized_curvature + + +VERSION = "v1" +REGISTERED_SAMPLES = 20_000 +REGISTERED_SEED_BLOCKS = 8 +REGISTERED_SEED = 20260728110 + + +def _split_indices(count: int, seed: int) -> tuple[np.ndarray, ...]: + if count == REGISTERED_SAMPLES: + sizes = (12_000, 4_000, 4_000) + else: + train = int(round(0.625 * count)) + validation = (count - train) // 2 + sizes = (train, validation, count - train - validation) + permutation = np.random.default_rng(seed).permutation(count) + first = sizes[0] + second = first + sizes[1] + return ( + np.sort(permutation[:first]), + np.sort(permutation[first:second]), + np.sort(permutation[second:]), + ) + + +def run( + output_json: Path, + output_npz: Path, + samples: int = REGISTERED_SAMPLES, + seed_blocks: int = REGISTERED_SEED_BLOCKS, + seed: int = REGISTERED_SEED, +) -> dict[str, Any]: + """Generate physical spectra and fixed train/validation/test indices.""" + + started = time.perf_counter() + count = int(samples) + blocks = int(seed_blocks) + if count < 64 or blocks < 2 or count < blocks: + raise ValueError("require samples>=64 and 2<=seed_blocks<=samples") + cache = build_physical_channel_cache() + D = cache.rank + M = cache.external_dimension + parameters = jacobi_parameters(D, M) + if parameters.plus_atoms or parameters.minus_atoms: + raise RuntimeError("the registered physical ensemble must be atom free") + sites = cache.channel_basis.shape[0] + raw_spectra = np.empty((count, D), dtype=np.float32) + normalized_spectra = np.empty((count, D), dtype=np.float32) + coefficients_v = np.empty((count, sites), dtype=np.float32) + coefficients_w = np.empty_like(coefficients_v) + active_ranks = np.empty(count, dtype=np.int16) + curvature_ranks = np.empty(count, dtype=np.int16) + seed_block = np.empty(count, dtype=np.int16) + block_indices = np.array_split(np.arange(count), blocks) + child_sequences = np.random.SeedSequence(seed).spawn(blocks) + for block, indices in enumerate(block_indices): + rng = np.random.default_rng(child_sequences[block]) + for sample in indices: + potential_v = normalized_potential(rng, sites) + potential_w = normalized_potential(rng, sites) + channel_v = cached_channel(potential_v, cache) + channel_w = cached_channel(potential_w, cache) + raw = np.linalg.eigvalsh( + curvature_from_channels(channel_v, channel_w) + ) + normalized = normalized_curvature( + channel_v, + channel_w, + rtol=1e-10, + ) + normalized_values = np.linalg.eigvalsh(normalized.omega) + raw_spectra[sample] = raw + normalized_spectra[sample] = normalized_values + coefficients_v[sample] = potential_v + coefficients_w[sample] = potential_w + active_ranks[sample] = normalized.rank + cutoff = 1e-10 * float(np.max(np.abs(raw))) + curvature_ranks[sample] = np.count_nonzero(np.abs(raw) > cutoff) + seed_block[sample] = block + print( + f"physical block {block + 1}/{blocks}: " + f"{indices[-1] + 1}/{count} samples", + flush=True, + ) + train_indices, validation_indices, test_indices = _split_indices( + count, + seed + 1, + ) + observed_atoms = int( + np.count_nonzero( + np.isclose( + np.abs(normalized_spectra), + 1.0, + atol=2e-7, + rtol=0.0, + ) + ) + ) + checks = { + "registered_rank_is_50": D == 50, + "parent_kernel_exact": cache.kernel_bandwidth < 1e-10, + "parent_gap_open": cache.external_gap > 1e-3, + "all_active_ranks_are_full": bool(np.all(active_ranks == D)), + "all_curvature_ranks_are_full": bool(np.all(curvature_ranks == D)), + "normalized_spectra_bounded": bool( + np.max(np.abs(normalized_spectra)) <= 1.0 + 2e-7 + ), + "no_exact_atoms": observed_atoms == 0, + "split_complete_and_disjoint": bool( + np.array_equal( + np.sort( + np.concatenate( + [train_indices, validation_indices, test_indices] + ) + ), + np.arange(count), + ) + and np.intersect1d(train_indices, validation_indices).size == 0 + and np.intersect1d(train_indices, test_indices).size == 0 + and np.intersect1d(validation_indices, test_indices).size == 0 + ), + "all_seed_blocks_nonempty": bool( + np.array_equal(np.unique(seed_block), np.arange(blocks)) + ), + } + result = { + "schema_version": 1, + "version": VERSION, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "physical_case": {"N": cache.N, "n": cache.n_flux, "D": D, "M": M}, + "sample_count": count, + "seed": int(seed), + "seed_blocks": blocks, + "split": { + "train": int(train_indices.size), + "validation": int(validation_indices.size), + "test": int(test_indices.size), + "split_seed": int(seed + 1), + }, + "parent": { + "kernel_bandwidth": cache.kernel_bandwidth, + "external_gap": cache.external_gap, + }, + "jacobi_parameters": { + "interior_dimension": parameters.interior_dimension, + "exponent": parameters.exponent, + "plus_atoms": parameters.plus_atoms, + "minus_atoms": parameters.minus_atoms, + }, + "observed_exact_atoms": observed_atoms, + "checks": checks, + "all_checks_pass": bool(all(checks.values())), + "runtime_seconds": time.perf_counter() - started, + "environment": { + "python": platform.python_version(), + "numpy": np.__version__, + "platform": platform.platform(), + }, + } + output_json.parent.mkdir(parents=True, exist_ok=True) + output_npz.parent.mkdir(parents=True, exist_ok=True) + output_json.write_text( + json.dumps(result, indent=2) + "\n", + encoding="utf-8", + ) + np.savez_compressed( + output_npz, + normalized_spectra=normalized_spectra, + raw_spectra=raw_spectra, + tangent_coefficients_v=coefficients_v, + tangent_coefficients_w=coefficients_w, + train_indices=train_indices.astype(np.int32), + validation_indices=validation_indices.astype(np.int32), + test_indices=test_indices.astype(np.int32), + seed_block=seed_block, + active_ranks=active_ranks, + curvature_ranks=curvature_ranks, + channel_basis=cache.channel_basis, + tangent_gram=cache.tangent_gram, + ) + return result + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--output-json", + type=Path, + default=Path("output/physical_ensemble_v1.json"), + ) + parser.add_argument( + "--output-npz", + type=Path, + default=Path("output/physical_ensemble_v1.npz"), + ) + parser.add_argument("--samples", type=int, default=REGISTERED_SAMPLES) + parser.add_argument( + "--seed-blocks", type=int, default=REGISTERED_SEED_BLOCKS + ) + args = parser.parse_args() + result = run( + args.output_json, + args.output_npz, + samples=args.samples, + seed_blocks=args.seed_blocks, + ) + print(json.dumps(result, indent=2)) + if not result["all_checks_pass"]: + raise SystemExit("physical-ensemble audit failed") + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_quick_verify_v1.sh b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_quick_verify_v1.sh new file mode 100755 index 000000000..6409b1de5 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_quick_verify_v1.sh @@ -0,0 +1,15 @@ +#!/usr/bin/env bash +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "${SCRIPT_DIR}" + +python verify_release_contract_v1.py +PYTHONPATH="${SCRIPT_DIR}${PYTHONPATH:+:${PYTHONPATH}}" python -m pytest -q \ + tests/test_independent_core.py \ + tests/test_form_factors_v2.py \ + tests/test_controls_v2.py \ + tests/test_holonomy_v3.py \ + tests/test_wick_channels_v3.py \ + tests/test_matrix_element_topology_theory_v3.py \ + tests/test_release_contract_v1.py diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_rank_scaling_v1.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_rank_scaling_v1.py new file mode 100644 index 000000000..7006daddb --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_rank_scaling_v1.py @@ -0,0 +1,472 @@ +#!/usr/bin/env python3 +"""Compute the root-response Jacobi crossover through active rank 800.""" + +from __future__ import annotations + +import argparse +import json +import platform +import time +from dataclasses import dataclass +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np + +from lgeth.channels import root_response_partition +from lgeth.jacobi import jacobi_parameters, sample_jacobi_wishart +from lgeth.statistics import bulk_gap_ratio_per_spectrum, histogram_l1 + + +VERSION = "v1" +ALGORITHM_VERSION = 1 +REGISTERED_CASES = ( + (8, 2_000), + (10, 2_000), + (12, 2_000), + (14, 1_000), + (16, 1_000), + (18, 500), + (20, 250), +) +RESPONSE_ENTRY_CEILING = 1_200_000 + + +@dataclass(frozen=True) +class ResponseAssembler: + """Sparse lookup for a root-space one-body response block.""" + + D: int + M: int + row: np.ndarray + column: np.ndarray + destination: np.ndarray + source: np.ndarray + population: np.ndarray + + def channel(self, tangent: np.ndarray) -> np.ndarray: + values = self.population * tangent[self.destination, self.source] + matrix = np.zeros((self.D, self.M), dtype=float) + np.add.at(matrix, (self.row, self.column), values) + return matrix + + +def build_response_assembler(partition) -> ResponseAssembler: + """Precompute the nonzero one-body representation map.""" + + target_column = { + int(basis_index): column + for column, basis_index in enumerate( + partition.descendant_external + ) + } + state_index = { + state: index for index, state in enumerate(partition.states) + } + rows: list[int] = [] + columns: list[int] = [] + destinations: list[int] = [] + sources: list[int] = [] + populations: list[int] = [] + for row, basis_index in enumerate(partition.zero_modes): + state = partition.states[int(basis_index)] + for source, population in enumerate(state): + if population == 0: + continue + for destination in range(len(state)): + if destination == source: + continue + updated = list(state) + updated[source] -= 1 + updated[destination] += 1 + target_index = state_index[tuple(updated)] + column = target_column.get(target_index) + if column is not None: + rows.append(row) + columns.append(column) + destinations.append(destination) + sources.append(source) + populations.append(population) + return ResponseAssembler( + D=len(partition.zero_modes), + M=len(partition.descendant_external), + row=np.asarray(rows, dtype=np.int32), + column=np.asarray(columns, dtype=np.int32), + destination=np.asarray(destinations, dtype=np.int16), + source=np.asarray(sources, dtype=np.int16), + population=np.asarray(populations, dtype=float), + ) + + +def _random_symmetric_tangent( + rng: np.random.Generator, + orbitals: int, +) -> np.ndarray: + upper = rng.integers( + -16, + 17, + size=(orbitals, orbitals), + dtype=np.int64, + ) + tangent = np.triu(upper, 1) + tangent += tangent.T + np.fill_diagonal( + tangent, + rng.integers(-16, 17, size=orbitals, dtype=np.int64), + ) + return tangent.astype(float) + + +def qr_normalized_curvature( + channel_v: np.ndarray, + channel_w: np.ndarray, +) -> tuple[np.ndarray, np.ndarray, float]: + """Return row isometry and normalized-curvature spectrum by thin QR.""" + + doubled = np.concatenate([channel_v, channel_w], axis=1) + q, triangular = np.linalg.qr(doubled.T, mode="reduced") + diagonal = np.abs(np.diag(triangular)) + condition_indicator = float(np.min(diagonal) / np.max(diagonal)) + if condition_indicator <= 1e-12: + raise RuntimeError("root-response channel lost active rank") + rows = q.T + M = channel_v.shape[1] + plus = rows[:, :M] + minus = rows[:, M:] + omega = 1j * ( + plus @ minus.T - minus @ plus.T + ) + spectrum = np.linalg.eigvalsh( + 0.5 * (omega + omega.conj().T) + ) + return rows, spectrum, condition_indicator + + +def _row_diagnostics(rows: np.ndarray, M: int) -> tuple[float, float]: + weights = np.sum(rows * rows, axis=0) + rank = float(rows.shape[0]) + effective = rank * rank / float(np.sum(weights * weights)) + participation = effective / rows.shape[1] + polarization = abs( + float(np.sum(weights[:M]) - np.sum(weights[M:])) / rank + ) + return participation, polarization + + +def _strip_atoms( + spectra: np.ndarray, + plus_atoms: int, + minus_atoms: int, +) -> tuple[np.ndarray, np.ndarray, float]: + labels = np.zeros_like(spectra, dtype=bool) + maximum_residual = 0.0 + if minus_atoms: + labels[:, :minus_atoms] = True + labels[:, -plus_atoms:] = True + maximum_residual = max( + float(np.max(np.abs(spectra[:, :minus_atoms] + 1.0))), + float(np.max(np.abs(spectra[:, -plus_atoms:] - 1.0))), + ) + interior = spectra[~labels].reshape( + spectra.shape[0], + spectra.shape[1] - plus_atoms - minus_atoms, + ) + return interior, labels, maximum_residual + + +def _checkpoint_paths(directory: Path, n: int) -> tuple[Path, Path]: + return directory / f"n{n}_v1.json", directory / f"n{n}_v1.npz" + + +def _computed_case( + n: int, + samples: int, + checkpoint_dir: Path, +) -> tuple[dict[str, Any], dict[str, np.ndarray]]: + json_path, npz_path = _checkpoint_paths(checkpoint_dir, n) + if json_path.exists() and npz_path.exists(): + result = json.loads(json_path.read_text(encoding="utf-8")) + if ( + result.get("algorithm_version") == ALGORITHM_VERSION + and result.get("samples") == samples + and result.get("status") == "computed" + ): + with np.load(npz_path) as arrays: + return result, {key: arrays[key] for key in arrays.files} + started = time.perf_counter() + partition = root_response_partition(3, n) + assembler = build_response_assembler(partition) + D, M = assembler.D, assembler.M + parameters = jacobi_parameters(D, M) + count = int(samples) + spectra = np.empty((count, D), dtype=np.float32) + participation = np.empty(count, dtype=np.float32) + polarization = np.empty(count, dtype=np.float32) + condition_indicator = np.empty(count, dtype=np.float32) + seed_block = np.empty(count, dtype=np.int16) + frame_pair_count = min(count // 2, 64 if D <= 352 else 24) + frame_overlaps = np.empty(frame_pair_count, dtype=np.float32) + previous = None + pair = 0 + blocks = min(8, count) + child_sequences = np.random.SeedSequence( + 20260728300 + n + ).spawn(blocks) + index_blocks = np.array_split(np.arange(count), blocks) + for block, indices in enumerate(index_blocks): + rng = np.random.default_rng(child_sequences[block]) + for sample in indices: + tangent_v = _random_symmetric_tangent(rng, n) + tangent_w = _random_symmetric_tangent(rng, n) + channel_v = assembler.channel(tangent_v) + channel_w = assembler.channel(tangent_w) + rows, values, indicator = qr_normalized_curvature( + channel_v, + channel_w, + ) + spectra[sample] = values + condition_indicator[sample] = indicator + participation[sample], polarization[sample] = _row_diagnostics( + rows, + M, + ) + seed_block[sample] = block + if pair < frame_pair_count: + if sample % 2 == 0: + previous = rows + elif previous is not None: + frame_overlaps[pair] = np.linalg.norm( + previous @ rows.T + ) ** 2 + pair += 1 + previous = None + print( + f"root n={n}, D={D}, block {block + 1}/{blocks}: " + f"{indices[-1] + 1}/{count}", + flush=True, + ) + interior, atom_labels, atom_residual = _strip_atoms( + spectra, + parameters.plus_atoms, + parameters.minus_atoms, + ) + reference_full, reference_interior, reference_atom_labels = ( + sample_jacobi_wishart( + D, + M, + count, + seed=20260728400 + n, + ) + ) + physical_ratios = bulk_gap_ratio_per_spectrum(interior) + reference_ratios = bulk_gap_ratio_per_spectrum(reference_interior) + density_l1 = histogram_l1( + interior, + reference_interior, + np.linspace(-1.0, 1.0, 161), + ) + arrays = { + "full_spectra": spectra, + "interior_spectra": interior.astype(np.float32), + "atom_labels": atom_labels, + "reference_full_spectra": reference_full.astype(np.float32), + "reference_interior_spectra": reference_interior.astype( + np.float32 + ), + "reference_atom_labels": reference_atom_labels, + "gap_ratios": physical_ratios.astype(np.float32), + "reference_gap_ratios": reference_ratios.astype(np.float32), + "seed_block": seed_block, + "participation": participation, + "polarization": polarization, + "frame_overlaps": frame_overlaps, + "condition_indicator": condition_indicator, + } + result = { + "algorithm_version": ALGORITHM_VERSION, + "status": "computed", + "N": 3, + "n": n, + "D": D, + "M": M, + "samples": count, + "ambient_hilbert_dimension": len(partition.states), + "response_entries": D * 2 * M, + "response_nonzero_terms": int(assembler.row.size), + "interior_dimension": parameters.interior_dimension, + "plus_atoms_per_matrix": parameters.plus_atoms, + "minus_atoms_per_matrix": parameters.minus_atoms, + "observed_plus_atoms_per_matrix": int( + np.mean(np.sum(atom_labels[:, -parameters.plus_atoms :], axis=1)) + ) + if parameters.plus_atoms + else 0, + "observed_minus_atoms_per_matrix": int( + np.mean(np.sum(atom_labels[:, : parameters.minus_atoms], axis=1)) + ) + if parameters.minus_atoms + else 0, + "maximum_atom_residual": atom_residual, + "mean_gap_ratio": float(np.mean(physical_ratios)), + "reference_mean_gap_ratio": float(np.mean(reference_ratios)), + "gap_ratio_difference": abs( + float(np.mean(physical_ratios)) + - float(np.mean(reference_ratios)) + ), + "interior_density_l1": density_l1, + "mean_participation": float(np.mean(participation)), + "mean_polarization": float(np.mean(polarization)), + "mean_frame_overlap": float(np.mean(frame_overlaps)), + "minimum_condition_indicator": float( + np.min(condition_indicator) + ), + "seed_blocks": blocks, + "frame_pairs": frame_pair_count, + "runtime_seconds": time.perf_counter() - started, + } + checkpoint_dir.mkdir(parents=True, exist_ok=True) + json_path.write_text( + json.dumps(result, indent=2) + "\n", + encoding="utf-8", + ) + np.savez_compressed(npz_path, **arrays) + return result, arrays + + +def run( + output_json: Path, + output_npz: Path, + cases: tuple[tuple[int, int], ...] = REGISTERED_CASES, + response_entry_ceiling: int = RESPONSE_ENTRY_CEILING, +) -> dict[str, Any]: + """Run registered cases with per-size resumable checkpoints.""" + + started = time.perf_counter() + checkpoint_dir = ( + output_npz.parent / f"{output_npz.stem}_checkpoints" + ) + case_results: list[dict[str, Any]] = [] + saved_arrays: dict[str, np.ndarray] = {} + for n, samples in cases: + partition = root_response_partition(3, n) + D = len(partition.zero_modes) + M = len(partition.descendant_external) + entries = D * 2 * M + if entries > int(response_entry_ceiling): + result = { + "status": "resource_rejected", + "N": 3, + "n": n, + "D": D, + "M": M, + "samples": int(samples), + "response_entries": entries, + "response_entry_ceiling": int(response_entry_ceiling), + } + arrays = {} + else: + result, arrays = _computed_case( + n, + int(samples), + checkpoint_dir, + ) + case_results.append(result) + for key, value in arrays.items(): + saved_arrays[f"n{n}_{key}"] = value + computed = [case for case in case_results if case["status"] == "computed"] + registered = tuple(cases) == REGISTERED_CASES + checks = { + "registered_dimensions_match": all( + (case["D"], case["M"]) + == { + 8: (16, 80), + 10: (50, 140), + 12: (112, 216), + 14: (210, 308), + 16: (352, 416), + 18: (546, 540), + 20: (800, 680), + }[case["n"]] + for case in case_results + ), + "statuses_explicit": all( + case["status"] in {"computed", "resource_rejected"} + for case in case_results + ), + "registered_run_has_no_rejections": ( + not registered + or all(case["status"] == "computed" for case in case_results) + ), + "registered_sample_counts_unchanged": ( + not registered + or all( + case["samples"] == samples + for case, (_, samples) in zip( + case_results, + REGISTERED_CASES, + strict=True, + ) + ) + ), + "atom_counts_match_intersection_theorem": all( + case["observed_plus_atoms_per_matrix"] + == max(case["D"] - case["M"], 0) + and case["observed_minus_atoms_per_matrix"] + == max(case["D"] - case["M"], 0) + for case in computed + ), + "atom_residual_below_tolerance": all( + case["maximum_atom_residual"] < 2e-5 for case in computed + ), + } + result = { + "schema_version": 1, + "version": VERSION, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "registered_cases": [ + {"n": n, "samples": samples} + for n, samples in REGISTERED_CASES + ], + "response_entry_ceiling": int(response_entry_ceiling), + "cases": case_results, + "checks": checks, + "all_checks_pass": bool(all(checks.values())), + "runtime_seconds": time.perf_counter() - started, + "environment": { + "python": platform.python_version(), + "numpy": np.__version__, + "platform": platform.platform(), + }, + } + output_json.parent.mkdir(parents=True, exist_ok=True) + output_npz.parent.mkdir(parents=True, exist_ok=True) + output_json.write_text( + json.dumps(result, indent=2) + "\n", + encoding="utf-8", + ) + np.savez_compressed(output_npz, **saved_arrays) + return result + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--output-json", + type=Path, + default=Path("output/rank_scaling_v1.json"), + ) + parser.add_argument( + "--output-npz", + type=Path, + default=Path("output/rank_scaling_v1.npz"), + ) + args = parser.parse_args() + result = run(args.output_json, args.output_npz) + print(json.dumps(result, indent=2)) + if not result["all_checks_pass"]: + raise SystemExit("rank-scaling audit failed") + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_spectral_silence_article_v2.sh b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_spectral_silence_article_v2.sh new file mode 100755 index 000000000..09e504324 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_spectral_silence_article_v2.sh @@ -0,0 +1,23 @@ +#!/usr/bin/env bash +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +REPO_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)" +ARTICLE_DIR="$REPO_ROOT/overleaf_sync/geometric_eth_large_scale" +OUTPUT_DIR="$SCRIPT_DIR/output" +PYTHON_BIN="/Users/thomasjwang/miniforge3/bin/python3.12" + +cd "$SCRIPT_DIR" +"$PYTHON_BIN" run_spectral_silence_v2.py +"$PYTHON_BIN" run_spectral_silence_statistics_v2.py +"$PYTHON_BIN" make_spectral_silence_figures_v2.py + +cd "$ARTICLE_DIR" +latexmk -pdf -interaction=nonstopmode -halt-on-error main.tex +cp main.pdf \ + "$OUTPUT_DIR/spectral_silence_and_geometric_chaos_v2.pdf" + +cd "$SCRIPT_DIR" +"$PYTHON_BIN" -m pytest -q tests \ + | tee "$OUTPUT_DIR/pytest_v2.txt" +"$PYTHON_BIN" verify_spectral_silence_article_v2.py diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_spectral_silence_statistics_v2.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_spectral_silence_statistics_v2.py new file mode 100644 index 000000000..bae4a633d --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_spectral_silence_statistics_v2.py @@ -0,0 +1,721 @@ +#!/usr/bin/env python3 +"""Simultaneous-band inference for spectral silence and geometric chaos.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import platform +import time +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np + +from lgeth.statistics import ( + CurveBand, + matrix_bootstrap_band, + number_variance_matrix_curves, + unfold_spectra, +) + + +VERSION = "v2" +REGISTERED_BOOTSTRAP_REPLICATES = 10_000 +REGISTERED_SEED = 20260728220 +RATIO_EDGES = np.linspace(0.0, 1.0, 61) +LENGTHS = np.linspace(0.25, 8.0, 32) +TAU_MIN = 0.25 +TAU_MAX = 1.50 + + +def _default_output(name: str) -> Path: + return Path(__file__).resolve().parent / "output" / name + + +def _sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for block in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(block) + return digest.hexdigest() + + +def registered_compatibility_onset( + grid: np.ndarray, + lower: np.ndarray, + upper: np.ndarray, + minimum: float, + maximum: float, +) -> float | None: + """Return the first point after which all registered bands contain zero.""" + + values = np.asarray(grid, dtype=float) + low = np.asarray(lower, dtype=float) + high = np.asarray(upper, dtype=float) + if values.ndim != 1 or low.shape != values.shape or high.shape != values.shape: + raise ValueError("grid and confidence bounds must be matching vectors") + if np.any(low > high): + raise ValueError("lower confidence bound exceeds upper bound") + indices = np.flatnonzero( + (values >= float(minimum)) & (values <= float(maximum)) + ) + if indices.size == 0: + raise ValueError("registered interval contains no grid points") + compatible = (low[indices] <= 0.0) & (high[indices] >= 0.0) + for offset, index in enumerate(indices): + if bool(np.all(compatible[offset:])): + return float(values[index]) + return None + + +def registered_compatibility_extent( + grid: np.ndarray, + lower: np.ndarray, + upper: np.ndarray, + minimum: float, + maximum: float, +) -> float | None: + """Return the largest initial scale with uninterrupted compatibility.""" + + values = np.asarray(grid, dtype=float) + low = np.asarray(lower, dtype=float) + high = np.asarray(upper, dtype=float) + if values.ndim != 1 or low.shape != values.shape or high.shape != values.shape: + raise ValueError("grid and confidence bounds must be matching vectors") + indices = np.flatnonzero( + (values >= float(minimum)) & (values <= float(maximum)) + ) + if indices.size == 0: + raise ValueError("registered interval contains no grid points") + compatible = (low[indices] <= 0.0) & (high[indices] >= 0.0) + if not bool(compatible[0]): + return None + stop = 0 + while stop + 1 < compatible.size and bool(compatible[stop + 1]): + stop += 1 + return float(values[indices[stop]]) + + +def _partition_matrix_curves( + spectra: np.ndarray, + times: np.ndarray, +) -> np.ndarray: + values = np.asarray(spectra, dtype=float) + grid = np.asarray(times, dtype=float) + if values.ndim != 2 or values.shape[1] < 2: + raise ValueError("spectra must be a matrix with at least two levels") + partition = np.empty( + (values.shape[0], grid.size), + dtype=np.complex128, + ) + for start in range(0, values.shape[0], 512): + stop = min(start + 512, values.shape[0]) + phases = np.exp( + -2j + * np.pi + * values[start:stop, :, None] + * grid[None, None, :] + ) + partition[start:stop] = np.sum(phases, axis=1) + mean_partition = np.mean(partition, axis=0) + return ( + np.abs(partition) ** 2 + - np.abs(mean_partition)[None, :] ** 2 + ) / values.shape[1] + + +def _ratio_values(spectrum: np.ndarray) -> np.ndarray: + ordered = np.sort(np.asarray(spectrum, dtype=float)) + trim = int(np.floor(0.15 * ordered.size)) + bulk = ordered[trim : ordered.size - trim if trim else ordered.size] + gaps = np.diff(bulk) + left = gaps[:-1] + right = gaps[1:] + denominator = np.maximum(left, right) + scale = max(float(np.ptp(bulk)), 1.0) + tolerance = 1e-11 * scale + ratios = np.zeros_like(denominator) + keep = denominator > tolerance + ratios[keep] = ( + np.minimum(left[keep], right[keep]) / denominator[keep] + ) + return ratios + + +def _ratio_matrix_curves( + spectra: np.ndarray, +) -> tuple[np.ndarray, np.ndarray]: + values = np.asarray(spectra, dtype=float) + width = np.diff(RATIO_EDGES) + curves = np.empty( + (values.shape[0], RATIO_EDGES.size - 1), + dtype=np.float32, + ) + means = np.empty(values.shape[0], dtype=float) + for matrix, spectrum in enumerate(values): + ratios = _ratio_values(spectrum) + counts, _ = np.histogram(ratios, bins=RATIO_EDGES) + curves[matrix] = counts / (np.sum(counts) * width) + means[matrix] = float(np.mean(ratios)) + return curves, means + + +def _curve_sets( + spectra: np.ndarray, + times: np.ndarray, + include_number: bool, +) -> dict[str, np.ndarray]: + unfolded = unfold_spectra(spectra, "ensemble_cdf") + ratio, ratio_mean = _ratio_matrix_curves(spectra) + result = { + "form": _partition_matrix_curves(unfolded, times), + "ratio": ratio, + "ratio_mean": ratio_mean[:, None], + } + if include_number: + result["number"] = number_variance_matrix_curves( + unfolded, + LENGTHS, + ) + return result + + +def _reduced_units( + curves: np.ndarray, + groups: np.ndarray | None, +) -> np.ndarray: + values = np.asarray(curves, dtype=float) + if groups is None: + return values + labels = np.asarray(groups) + if labels.shape != (values.shape[0],): + raise ValueError("groups must provide one label per curve") + return np.asarray( + [ + np.mean(values[labels == label], axis=0) + for label in np.unique(labels) + ] + ) + + +def _independent_difference_band( + first_curves: np.ndarray, + second_curves: np.ndarray, + replicates: int, + seed: int, + first_groups: np.ndarray | None = None, + second_groups: np.ndarray | None = None, +) -> CurveBand: + first = _reduced_units(first_curves, first_groups) + second = _reduced_units(second_curves, second_groups) + if first.shape[1] != second.shape[1]: + raise ValueError("difference curves must share one grid") + if first.shape[0] < 2 or second.shape[0] < 2: + raise ValueError("each difference ensemble needs two units") + first_mean = np.mean(first, axis=0) + second_mean = np.mean(second, axis=0) + mean = first_mean - second_mean + first_centered = first - first_mean + second_centered = second - second_mean + covariance = ( + first_centered.T @ first_centered + / (first.shape[0] * (first.shape[0] - 1)) + + second_centered.T @ second_centered + / (second.shape[0] * (second.shape[0] - 1)) + ) + covariance = 0.5 * (covariance + covariance.T) + eigenvalues, eigenvectors = np.linalg.eigh(covariance) + cutoff = max(float(eigenvalues[-1]) * 1e-13, 0.0) + keep = eigenvalues > cutoff + factor = ( + eigenvectors[:, keep] * np.sqrt(eigenvalues[keep])[None, :] + ) + rng = np.random.default_rng(int(seed)) + draws = mean + rng.normal( + size=(int(replicates), int(np.count_nonzero(keep))) + ) @ factor.T + pointwise_lower, pointwise_upper = np.quantile( + draws, + (0.025, 0.975), + axis=0, + ) + standard_error = np.std(draws, axis=0, ddof=1) + safe = np.maximum(standard_error, 1e-15) + maximum = np.max(np.abs((draws - mean) / safe), axis=1) + critical = float(np.quantile(maximum, 0.95)) + return CurveBand( + mean=mean, + lower=mean - critical * standard_error, + upper=mean + critical * standard_error, + pointwise_lower=pointwise_lower, + pointwise_upper=pointwise_upper, + standard_error=standard_error, + critical_value=critical, + replicates=int(replicates), + units=int(first.shape[0] + second.shape[0]), + method="independent_unit_gaussian_multiplier", + ) + + +def _store_band( + prefix: str, + band: CurveBand, + output: dict[str, np.ndarray], +) -> None: + output[f"{prefix}_mean"] = band.mean.astype(np.float32) + output[f"{prefix}_lower"] = band.lower.astype(np.float32) + output[f"{prefix}_upper"] = band.upper.astype(np.float32) + output[f"{prefix}_pointwise_lower"] = ( + band.pointwise_lower.astype(np.float32) + ) + output[f"{prefix}_pointwise_upper"] = ( + band.pointwise_upper.astype(np.float32) + ) + output[f"{prefix}_standard_error"] = ( + band.standard_error.astype(np.float32) + ) + + +def run( + output_json: Path, + output_npz: Path, + bootstrap_replicates: int = REGISTERED_BOOTSTRAP_REPLICATES, +) -> dict[str, Any]: + """Run simultaneous-band inference for every v2 control.""" + + started = time.perf_counter() + draws = int(bootstrap_replicates) + if draws < 500: + raise ValueError("bootstrap_replicates must be at least 500") + script_dir = Path(__file__).resolve().parent + source_json_path = script_dir / "output" / "spectral_silence_v2.json" + source_npz_path = script_dir / "output" / "spectral_silence_v2.npz" + source_json = json.loads( + source_json_path.read_text(encoding="utf-8") + ) + source = np.load(source_npz_path, allow_pickle=False) + if not source_json["all_checks_pass"]: + raise RuntimeError("spectral-silence source audit failed") + times = np.asarray(source["times"], dtype=float) + analytic = np.asarray(source["jacobi_connected_D50"], dtype=float) + structured_sets = _curve_sets( + source["structured_spectra"], + times, + include_number=True, + ) + physical_sets = _curve_sets( + source["physical_test_spectra"], + times, + include_number=True, + ) + haar_sets = _curve_sets( + source["haar_spectra"], + times, + include_number=True, + ) + output: dict[str, np.ndarray] = { + "times": times.astype(np.float32), + "ratio_centers": ( + 0.5 * (RATIO_EDGES[:-1] + RATIO_EDGES[1:]) + ).astype(np.float32), + "lengths": LENGTHS.astype(np.float32), + "jacobi_connected_D50": analytic.astype(np.float32), + } + base_specs = ( + ( + "structured", + structured_sets, + source["structured_orbit_id"], + 0, + ), + ( + "physical", + physical_sets, + source["physical_seed_block"], + 20, + ), + ("haar", haar_sets, None, 40), + ) + band_metadata: dict[str, Any] = {} + base_bands: dict[str, dict[str, CurveBand]] = {} + for label, sets, groups, offset in base_specs: + base_bands[label] = {} + band_metadata[label] = {} + for curve_index, curve_name in enumerate( + ("form", "ratio", "ratio_mean", "number") + ): + band = matrix_bootstrap_band( + sets[curve_name], + replicates=draws, + seed=REGISTERED_SEED + offset + curve_index, + groups=groups, + ) + base_bands[label][curve_name] = band + _store_band(f"{label}_{curve_name}", band, output) + band_metadata[label][curve_name] = { + "units": band.units, + "method": band.method, + "critical_value": band.critical_value, + } + physical_residual = CurveBand( + mean=base_bands["physical"]["form"].mean - analytic, + lower=base_bands["physical"]["form"].lower - analytic, + upper=base_bands["physical"]["form"].upper - analytic, + pointwise_lower=( + base_bands["physical"]["form"].pointwise_lower - analytic + ), + pointwise_upper=( + base_bands["physical"]["form"].pointwise_upper - analytic + ), + standard_error=base_bands["physical"]["form"].standard_error, + critical_value=base_bands["physical"]["form"].critical_value, + replicates=draws, + units=base_bands["physical"]["form"].units, + method="physical_minus_exact_finite_jacobi", + ) + structured_residual = CurveBand( + mean=base_bands["structured"]["form"].mean - analytic, + lower=base_bands["structured"]["form"].lower - analytic, + upper=base_bands["structured"]["form"].upper - analytic, + pointwise_lower=( + base_bands["structured"]["form"].pointwise_lower - analytic + ), + pointwise_upper=( + base_bands["structured"]["form"].pointwise_upper - analytic + ), + standard_error=base_bands["structured"]["form"].standard_error, + critical_value=base_bands["structured"]["form"].critical_value, + replicates=draws, + units=base_bands["structured"]["form"].units, + method="structured_minus_exact_finite_jacobi", + ) + _store_band("physical_form_residual", physical_residual, output) + _store_band("structured_form_residual", structured_residual, output) + number_residual = _independent_difference_band( + physical_sets["number"], + haar_sets["number"], + replicates=draws, + seed=REGISTERED_SEED + 60, + first_groups=source["physical_seed_block"], + ) + _store_band("physical_haar_number_residual", number_residual, output) + tau_onset = registered_compatibility_onset( + times, + physical_residual.lower, + physical_residual.upper, + minimum=TAU_MIN, + maximum=TAU_MAX, + ) + length_extent = registered_compatibility_extent( + LENGTHS, + number_residual.lower, + number_residual.upper, + minimum=float(LENGTHS[0]), + maximum=float(LENGTHS[-1]), + ) + g_values = np.asarray(source["g_values"], dtype=float) + g_count = g_values.size + g_form_arrays = { + name: np.empty((g_count, times.size), dtype=np.float32) + for name in ("mean", "lower", "upper", "standard_error") + } + g_ratio_arrays = { + name: np.empty( + (g_count, RATIO_EDGES.size - 1), + dtype=np.float32, + ) + for name in ("mean", "lower", "upper", "standard_error") + } + g_ratio_scalar = { + name: np.empty(g_count, dtype=np.float32) + for name in ("mean", "lower", "upper") + } + g_tau_onset: list[float | None] = [] + for index, g in enumerate(g_values): + sets = _curve_sets( + source["g_spectra"][index], + times, + include_number=False, + ) + groups = source["g_seed_block"][index] + form_band = matrix_bootstrap_band( + sets["form"], + replicates=draws, + seed=REGISTERED_SEED + 100 + 4 * index, + groups=groups, + ) + ratio_band = matrix_bootstrap_band( + sets["ratio"], + replicates=draws, + seed=REGISTERED_SEED + 101 + 4 * index, + groups=groups, + ) + scalar_band = matrix_bootstrap_band( + sets["ratio_mean"], + replicates=draws, + seed=REGISTERED_SEED + 102 + 4 * index, + groups=groups, + ) + for name in ("mean", "lower", "upper", "standard_error"): + g_form_arrays[name][index] = getattr(form_band, name) + g_ratio_arrays[name][index] = getattr(ratio_band, name) + for name in ("mean", "lower", "upper"): + g_ratio_scalar[name][index] = float( + getattr(scalar_band, name)[0] + ) + g_tau_onset.append( + registered_compatibility_onset( + times, + form_band.lower - analytic, + form_band.upper - analytic, + minimum=TAU_MIN, + maximum=TAU_MAX, + ) + ) + for name, values in g_form_arrays.items(): + output[f"g_form_{name}"] = values + for name, values in g_ratio_arrays.items(): + output[f"g_ratio_{name}"] = values + for name, values in g_ratio_scalar.items(): + output[f"g_ratio_scalar_{name}"] = values + output["g_values"] = g_values.astype(np.float32) + alpha_values = np.asarray(source["alpha_values"], dtype=float) + alpha_count = alpha_values.size + energy_gap = { + name: np.empty(alpha_count, dtype=np.float32) + for name in ("mean", "lower", "upper") + } + energy_form = { + name: np.empty((alpha_count, times.size), dtype=np.float32) + for name in ("mean", "lower", "upper", "standard_error") + } + for index, alpha in enumerate(alpha_values): + sets = _curve_sets( + source["energy_spectra_alpha"][index], + times, + include_number=False, + ) + gap_band = matrix_bootstrap_band( + sets["ratio_mean"], + replicates=draws, + seed=REGISTERED_SEED + 200 + 3 * index, + ) + form_band = matrix_bootstrap_band( + sets["form"], + replicates=draws, + seed=REGISTERED_SEED + 201 + 3 * index, + ) + for name in ("mean", "lower", "upper"): + energy_gap[name][index] = float(getattr(gap_band, name)[0]) + for name in ("mean", "lower", "upper", "standard_error"): + energy_form[name][index] = getattr(form_band, name) + for name, values in energy_gap.items(): + output[f"energy_gap_ratio_{name}"] = values + for name, values in energy_form.items(): + output[f"energy_form_{name}"] = values + output["alpha_values"] = alpha_values.astype(np.float32) + output["projector_distance_alpha"] = source[ + "projector_distance_alpha" + ] + output["curvature_error_alpha"] = source["curvature_error_alpha"] + output["rank_D"] = source["rank_D"] + output["rank_interior"] = source["rank_interior"] + output["rank_atom_each"] = source["rank_atom_each"] + output["rank_physical_connected_full"] = source[ + "rank_physical_connected_full" + ] + output["rank_reference_connected_full"] = source[ + "rank_reference_connected_full" + ] + compatible_g_indices = [ + index + for index, onset in enumerate(g_tau_onset) + if onset is not None + and np.count_nonzero( + (times >= onset) & (times <= TAU_MAX) + ) + >= 8 + ] + first_compatible_g = ( + float(g_values[compatible_g_indices[0]]) + if compatible_g_indices + else None + ) + haar_ratio_lower = float( + base_bands["haar"]["ratio_mean"].lower[0] + ) + haar_ratio_upper = float( + base_bands["haar"]["ratio_mean"].upper[0] + ) + local_compatible_indices = [ + index + for index in range(g_count) + if float(g_ratio_scalar["upper"][index]) >= haar_ratio_lower + and float(g_ratio_scalar["lower"][index]) <= haar_ratio_upper + ] + first_local_g = ( + float(g_values[local_compatible_indices[0]]) + if local_compatible_indices + else None + ) + tau_index = int(np.argmin(np.abs(times - 0.5))) + length_index = -1 + structured_rejects = bool( + structured_residual.lower[tau_index] > 0.0 + or structured_residual.upper[tau_index] < 0.0 + ) + physical_window = bool( + tau_onset is not None + and np.count_nonzero( + (times >= tau_onset) & (times <= TAU_MAX) + ) + >= 8 + ) + long_range_resolved = bool( + number_residual.lower[length_index] > 0.0 + or number_residual.upper[length_index] < 0.0 + ) + spectral_separated = bool( + energy_gap["upper"][0] < energy_gap["lower"][-1] + ) + checks = { + "source_artifact_passes": bool(source_json["all_checks_pass"]), + "structured_control_rejects_jacobi": structured_rejects, + "physical_has_registered_jacobi_window": physical_window, + "geometry_axis_crossover_resolved": ( + first_compatible_g is not None + ), + "local_to_ramp_hierarchy_resolved": bool( + first_local_g is not None + and first_compatible_g is not None + and first_local_g < first_compatible_g + ), + "spectral_axis_confidence_separated": spectral_separated, + "fixed_projector_invariance_retained": bool( + np.max(source["projector_distance_alpha"]) < 1e-12 + and np.max(source["curvature_error_alpha"]) < 1e-12 + ), + "long_range_memory_resolved": long_range_resolved, + "atom_plateau_data_retained": bool( + int(source["rank_atom_each"][-1]) == 120 + and abs( + float( + source["rank_interior"][-1] + / source["rank_D"][-1] + ) + - 0.7 + ) + < 1e-12 + ), + } + result = { + "schema_version": 2, + "version": VERSION, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "source_sha256": { + "json": _sha256(source_json_path), + "npz": _sha256(source_npz_path), + }, + "bootstrap_replicates": draws, + "registered_windows": { + "tau_minimum": TAU_MIN, + "tau_maximum": TAU_MAX, + "number_minimum": float(LENGTHS[0]), + "number_maximum": float(LENGTHS[-1]), + }, + "outcomes": { + "physical_tau_compatibility_onset": tau_onset, + "number_variance_compatibility_extent": length_extent, + "g_tau_compatibility_onsets": g_tau_onset, + "first_g_with_registered_jacobi_window": first_compatible_g, + "first_g_with_haar_gap_ratio_interval": first_local_g, + "haar_gap_ratio_interval": { + "mean": float( + base_bands["haar"]["ratio_mean"].mean[0] + ), + "lower": haar_ratio_lower, + "upper": haar_ratio_upper, + }, + "tau_0p5": { + "structured": float( + base_bands["structured"]["form"].mean[tau_index] + ), + "physical": float( + base_bands["physical"]["form"].mean[tau_index] + ), + "haar": float( + base_bands["haar"]["form"].mean[tau_index] + ), + "analytic_jacobi": float(analytic[tau_index]), + }, + "number_variance_L8_residual": { + "mean": float(number_residual.mean[length_index]), + "lower": float(number_residual.lower[length_index]), + "upper": float(number_residual.upper[length_index]), + }, + "energy_gap_ratio_endpoints": { + "poisson": float(energy_gap["mean"][0]), + "poisson_lower": float(energy_gap["lower"][0]), + "poisson_upper": float(energy_gap["upper"][0]), + "gue": float(energy_gap["mean"][-1]), + "gue_lower": float(energy_gap["lower"][-1]), + "gue_upper": float(energy_gap["upper"][-1]), + }, + }, + "band_metadata": band_metadata, + "checks": checks, + "all_checks_pass": bool(all(checks.values())), + "runtime_seconds": time.perf_counter() - started, + "environment": { + "python": platform.python_version(), + "numpy": np.__version__, + "platform": platform.platform(), + }, + } + output_json.parent.mkdir(parents=True, exist_ok=True) + output_npz.parent.mkdir(parents=True, exist_ok=True) + output_json.write_text( + json.dumps(result, indent=2) + "\n", + encoding="utf-8", + ) + np.savez_compressed(output_npz, **output) + return result + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--output-json", + type=Path, + default=_default_output( + "spectral_silence_statistics_v2.json" + ), + ) + parser.add_argument( + "--output-npz", + type=Path, + default=_default_output( + "spectral_silence_statistics_v2.npz" + ), + ) + parser.add_argument( + "--bootstrap-replicates", + type=int, + default=REGISTERED_BOOTSTRAP_REPLICATES, + ) + args = parser.parse_args() + result = run( + args.output_json, + args.output_npz, + bootstrap_replicates=args.bootstrap_replicates, + ) + print(json.dumps(result, indent=2)) + if not result["all_checks_pass"]: + raise SystemExit("spectral-silence statistical audit failed") + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_spectral_silence_v2.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_spectral_silence_v2.py new file mode 100644 index 000000000..c19ab15c1 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_spectral_silence_v2.py @@ -0,0 +1,684 @@ +#!/usr/bin/env python3 +"""Generate the spectral-silence and independent-chaos control artifact.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import platform +import time +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np + +from lgeth.channels import ( + build_physical_channel_cache, + cached_channel, +) +from lgeth.controls import ( + fixed_projector_spectral_ensemble, + fourier_tangent_pairs, + scrambled_tangent_pair, +) +from lgeth.form_factors import ( + atom_raw_decomposition, + degenerate_energy_form_factor, + finite_jacobi_form_factor, + form_factor_parts, +) +from lgeth.jacobi import normalized_curvature +from lgeth.statistics import unfold_spectra + + +VERSION = "v2" +REGISTERED_SEED = 20260728210 +G_VALUES = np.asarray( + [0.0, 0.02, 0.05, 0.10, 0.20, 0.40, 0.70, 1.0], + dtype=float, +) +ALPHA_VALUES = np.asarray( + [0.0, 0.10, 0.20, 0.35, 0.50, 0.70, 0.85, 1.0], + dtype=float, +) +TIMES = np.linspace(0.0, 3.0, 121) +REGISTERED_SAMPLES_PER_G = 4000 +REGISTERED_SPECTRAL_SAMPLES = 4000 +REGISTERED_QUADRATURE_ORDER = 512 +REGISTERED_RANK_FORM_FACTOR_SAMPLES = 500 +RANK_LABELS = ("n8", "n10", "n12", "n14", "n16", "n18", "n20") + + +def _sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for block in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(block) + return digest.hexdigest() + + +def _default_output(name: str) -> Path: + return Path(__file__).resolve().parent / "output" / name + + +def _connected_parts(spectra: np.ndarray) -> tuple[np.ndarray, ...]: + unfolded = unfold_spectra(spectra, "ensemble_cdf") + parts = form_factor_parts(unfolded, TIMES) + return parts.raw, parts.disconnected, parts.connected + + +def _structured_control( + cache, +) -> dict[str, np.ndarray]: + pairs = fourier_tangent_pairs(5) + spectra = np.empty((len(pairs), cache.rank), dtype=np.float32) + active_ranks = np.empty(len(pairs), dtype=np.int16) + unique_counts = np.empty(len(pairs), dtype=np.int16) + momenta = np.empty((len(pairs), 2), dtype=np.int16) + orbit_keys = np.empty((len(pairs), 2), dtype=np.int16) + orbit_lookup = { + key: index + for index, key in enumerate( + sorted({pair.orbit_key for pair in pairs}) + ) + } + orbit_id = np.empty(len(pairs), dtype=np.int16) + for index, pair in enumerate(pairs): + channel_v = cached_channel(pair.v, cache) + channel_w = cached_channel(pair.w, cache) + normalized = normalized_curvature( + channel_v, + channel_w, + rtol=1e-10, + ) + spectrum = np.linalg.eigvalsh(normalized.omega) + spectra[index] = spectrum + active_ranks[index] = normalized.rank + unique_counts[index] = np.unique( + np.round(spectrum, 10) + ).size + momenta[index] = (pair.kx, pair.ky) + orbit_keys[index] = pair.orbit_key + orbit_id[index] = orbit_lookup[pair.orbit_key] + raw, disconnected, connected = _connected_parts(spectra) + return { + "spectra": spectra, + "active_ranks": active_ranks, + "unique_counts": unique_counts, + "momenta": momenta, + "orbit_keys": orbit_keys, + "orbit_id": orbit_id, + "raw": raw, + "disconnected": disconnected, + "connected": connected, + } + + +def _geometry_axis( + cache, + samples_per_g: int, + seed: int, +) -> dict[str, np.ndarray]: + count = int(samples_per_g) + if count < 24: + raise ValueError("samples_per_g must be at least 24") + positive_g = G_VALUES[1:] + pairs = fourier_tangent_pairs(5) + spectra = np.empty( + (positive_g.size, count, cache.rank), + dtype=np.float32, + ) + active_ranks = np.empty( + (positive_g.size, count), + dtype=np.int16, + ) + unique_counts = np.empty_like(active_ranks) + momentum_index = np.empty_like(active_ranks) + seed_block = np.empty_like(active_ranks) + child_sequences = np.random.SeedSequence(seed).spawn( + positive_g.size + ) + for g_index, (g, child) in enumerate( + zip(positive_g, child_sequences, strict=True) + ): + rng = np.random.default_rng(child) + blocks = np.array_split(np.arange(count), 8) + for block, indices in enumerate(blocks): + for sample in indices: + pair_index = int(sample % len(pairs)) + pair = pairs[pair_index] + random_v = rng.normal(size=pair.v.size) + random_w = rng.normal(size=pair.w.size) + coefficients_v, coefficients_w = scrambled_tangent_pair( + pair, + random_v, + random_w, + float(g), + cache.tangent_gram, + ) + channel_v = cached_channel(coefficients_v, cache) + channel_w = cached_channel(coefficients_w, cache) + normalized = normalized_curvature( + channel_v, + channel_w, + rtol=1e-10, + ) + spectrum = np.linalg.eigvalsh(normalized.omega) + spectra[g_index, sample] = spectrum + active_ranks[g_index, sample] = normalized.rank + unique_counts[g_index, sample] = np.unique( + np.round(spectrum, 10) + ).size + momentum_index[g_index, sample] = pair_index + seed_block[g_index, sample] = block + print( + f"geometry axis g={g:.2f}: {count} spectra", + flush=True, + ) + raw = np.empty((positive_g.size, TIMES.size), dtype=float) + disconnected = np.empty_like(raw) + connected = np.empty_like(raw) + for index in range(positive_g.size): + raw[index], disconnected[index], connected[index] = ( + _connected_parts(spectra[index]) + ) + return { + "g_values": positive_g, + "spectra": spectra, + "active_ranks": active_ranks, + "unique_counts": unique_counts, + "momentum_index": momentum_index, + "seed_block": seed_block, + "raw": raw, + "disconnected": disconnected, + "connected": connected, + } + + +def _rank_form_factors( + scaling: np.lib.npyio.NpzFile, + scaling_metadata: dict[str, Any], + requested_samples: int, +) -> dict[str, np.ndarray]: + cases = scaling_metadata["cases"] + rank_count = len(cases) + physical_continuous = np.empty( + (rank_count, TIMES.size), + dtype=float, + ) + physical_full = np.empty_like(physical_continuous) + reference_continuous = np.empty_like(physical_continuous) + reference_full = np.empty_like(physical_continuous) + raw_full = np.empty_like(physical_continuous) + raw_atom_atom = np.empty_like(physical_continuous) + raw_atom_continuum = np.empty_like(physical_continuous) + raw_continuum_continuum = np.empty_like(physical_continuous) + dimensions = np.empty(rank_count, dtype=np.int16) + channels = np.empty(rank_count, dtype=np.int16) + interiors = np.empty(rank_count, dtype=np.int16) + atoms = np.empty(rank_count, dtype=np.int16) + sample_counts = np.empty(rank_count, dtype=np.int32) + for index, (label, case) in enumerate( + zip(RANK_LABELS, cases, strict=True) + ): + physical = scaling[f"{label}_interior_spectra"] + reference = scaling[f"{label}_reference_interior_spectra"] + count = min( + int(requested_samples), + int(physical.shape[0]), + ) + indices = np.linspace( + 0, + physical.shape[0] - 1, + count, + dtype=int, + ) + physical_sample = np.asarray(physical[indices], dtype=float) + reference_sample = np.asarray(reference[indices], dtype=float) + physical_parts = form_factor_parts( + unfold_spectra(physical_sample, "ensemble_cdf"), + TIMES, + ) + reference_parts = form_factor_parts( + unfold_spectra(reference_sample, "ensemble_cdf"), + TIMES, + ) + D = int(case["D"]) + M = int(case["M"]) + k = int(case["interior_dimension"]) + atom_each = int(case["plus_atoms_per_matrix"]) + physical_continuous[index] = physical_parts.connected + reference_continuous[index] = reference_parts.connected + physical_full[index] = (k / D) * physical_parts.connected + reference_full[index] = (k / D) * reference_parts.connected + decomposition = atom_raw_decomposition( + reference_sample, + minus_atoms=atom_each, + plus_atoms=atom_each, + times=TIMES, + ) + raw_full[index] = decomposition["full"] + raw_atom_atom[index] = decomposition["atom_atom"] + raw_atom_continuum[index] = decomposition["atom_continuum"] + raw_continuum_continuum[index] = decomposition[ + "continuum_continuum" + ] + dimensions[index] = D + channels[index] = M + interiors[index] = k + atoms[index] = atom_each + sample_counts[index] = count + return { + "D": dimensions, + "M": channels, + "interior": interiors, + "atom_each": atoms, + "sample_count": sample_counts, + "physical_connected_continuous": physical_continuous, + "physical_connected_full": physical_full, + "reference_connected_continuous": reference_continuous, + "reference_connected_full": reference_full, + "reference_raw_full": raw_full, + "reference_raw_atom_atom": raw_atom_atom, + "reference_raw_atom_continuum": raw_atom_continuum, + "reference_raw_continuum_continuum": ( + raw_continuum_continuum + ), + } + + +def run( + output_json: Path, + output_npz: Path, + samples_per_g: int = REGISTERED_SAMPLES_PER_G, + spectral_samples: int = REGISTERED_SPECTRAL_SAMPLES, + quadrature_order: int = REGISTERED_QUADRATURE_ORDER, + rank_form_factor_samples: int = ( + REGISTERED_RANK_FORM_FACTOR_SAMPLES + ), +) -> dict[str, Any]: + """Generate all A+B control and finite-Jacobi data.""" + + started = time.perf_counter() + script_dir = Path(__file__).resolve().parent + physical_path = script_dir / "output" / "physical_ensemble_v1.npz" + physical_json_path = ( + script_dir / "output" / "physical_ensemble_v1.json" + ) + covariance_path = script_dir / "output" / "covariance_model_v1.npz" + covariance_json_path = ( + script_dir / "output" / "covariance_model_v1.json" + ) + scaling_path = script_dir / "output" / "rank_scaling_v1.npz" + scaling_json_path = script_dir / "output" / "rank_scaling_v1.json" + input_paths = ( + physical_path, + physical_json_path, + covariance_path, + covariance_json_path, + scaling_path, + scaling_json_path, + ) + for path in input_paths: + if not path.is_file(): + raise FileNotFoundError(path) + physical_metadata = json.loads( + physical_json_path.read_text(encoding="utf-8") + ) + covariance_metadata = json.loads( + covariance_json_path.read_text(encoding="utf-8") + ) + scaling_metadata = json.loads( + scaling_json_path.read_text(encoding="utf-8") + ) + physical = np.load(physical_path, allow_pickle=False) + covariance = np.load(covariance_path, allow_pickle=False) + scaling = np.load(scaling_path, allow_pickle=False) + cache = build_physical_channel_cache() + structured = _structured_control(cache) + geometry = _geometry_axis( + cache, + samples_per_g=int(samples_per_g), + seed=REGISTERED_SEED, + ) + test_indices = physical["test_indices"] + physical_test_spectra = np.asarray( + physical["normalized_spectra"][test_indices], + dtype=np.float32, + ) + physical_raw, physical_disconnected, physical_connected = ( + _connected_parts(physical_test_spectra) + ) + haar_spectra = np.asarray( + covariance["haar_spectra"], + dtype=np.float32, + ) + haar_raw, haar_disconnected, haar_connected = _connected_parts( + haar_spectra + ) + exact_energy = degenerate_energy_form_factor(cache.rank, TIMES) + analytic_jacobi = finite_jacobi_form_factor( + cache.rank, + cache.external_dimension, + TIMES, + quadrature_order=int(quadrature_order), + ) + fixed = fixed_projector_spectral_ensemble( + dimension=cache.rank, + samples=int(spectral_samples), + alphas=ALPHA_VALUES, + seed=REGISTERED_SEED + 1, + reference_curvature_spectrum=physical_test_spectra[0], + times=TIMES, + ) + rank = _rank_form_factors( + scaling, + scaling_metadata, + requested_samples=int(rank_form_factor_samples), + ) + atom_relation_error = float( + np.max( + np.abs( + rank["reference_connected_full"] + - ( + rank["interior"] / rank["D"] + )[:, None] + * rank["reference_connected_continuous"] + ) + ) + ) + raw_closure_error = float( + np.max( + np.abs( + rank["reference_raw_full"] + - rank["reference_raw_atom_atom"] + - rank["reference_raw_atom_continuum"] + - rank["reference_raw_continuum_continuum"] + ) + ) + ) + checks = { + "input_v1_artifacts_pass": bool( + physical_metadata["all_checks_pass"] + and covariance_metadata["all_checks_pass"] + and scaling_metadata["all_checks_pass"] + ), + "exact_energy_silence": bool( + np.max( + np.abs(exact_energy.raw - cache.rank) + ) + < 1e-12 + and np.max(np.abs(exact_energy.connected)) < 1e-12 + ), + "structured_control_full_rank": bool( + np.all(structured["active_ranks"] == cache.rank) + ), + "structured_control_multiplets": bool( + np.max(structured["unique_counts"]) <= 10 + ), + "geometry_axis_full_rank": bool( + np.all(geometry["active_ranks"] == cache.rank) + ), + "geometry_axis_exact_parent": bool( + cache.kernel_bandwidth < 1e-10 + and cache.external_gap > 1e-3 + and abs( + cache.kernel_bandwidth + - physical_metadata["parent"]["kernel_bandwidth"] + ) + < 1e-12 + and abs( + cache.external_gap + - physical_metadata["parent"]["external_gap"] + ) + < 1e-12 + ), + "fixed_projector_invariance": bool( + np.max(fixed.projector_distance) < 1e-12 + and np.max(fixed.curvature_spectrum_error) < 1e-12 + ), + "spectral_axis_resolved": bool( + fixed.mean_gap_ratio[-1] + > fixed.mean_gap_ratio[0] + 0.12 + ), + "finite_jacobi_mass_and_basis": bool( + analytic_jacobi.mass_error < 2e-8 + and analytic_jacobi.orthogonality_error < 2e-8 + and abs(analytic_jacobi.connected_continuous[0]) < 1e-9 + ), + "atom_plateau_theorem": bool( + atom_relation_error < 1e-12 + and raw_closure_error < 1e-12 + ), + } + result = { + "schema_version": 2, + "version": VERSION, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "registered_seed": REGISTERED_SEED, + "sample_counts": { + "structured_momenta": int( + structured["spectra"].shape[0] + ), + "structured_orbits": int( + np.unique(structured["orbit_id"]).size + ), + "per_positive_g": int(samples_per_g), + "fixed_projector_per_alpha": int(spectral_samples), + "rank_form_factor_requested": int( + rank_form_factor_samples + ), + "rank_form_factor_actual": ( + rank["sample_count"].astype(int).tolist() + ), + "physical_test": int(physical_test_spectra.shape[0]), + "haar_reference": int(haar_spectra.shape[0]), + }, + "grids": { + "g": G_VALUES.tolist(), + "alpha": ALPHA_VALUES.tolist(), + "times": { + "minimum": float(TIMES[0]), + "maximum": float(TIMES[-1]), + "points": int(TIMES.size), + }, + }, + "physical_case": { + "N": cache.N, + "n": cache.n_flux, + "D": cache.rank, + "M": cache.external_dimension, + "kernel_bandwidth": cache.kernel_bandwidth, + "external_gap": cache.external_gap, + }, + "structured_control": { + "minimum_active_rank": int( + np.min(structured["active_ranks"]) + ), + "maximum_distinct_eigenvalues": int( + np.max(structured["unique_counts"]) + ), + }, + "fixed_projector_control": { + "poisson_endpoint_gap_ratio": float( + fixed.mean_gap_ratio[0] + ), + "gue_endpoint_gap_ratio": float( + fixed.mean_gap_ratio[-1] + ), + "maximum_projector_distance": float( + np.max(fixed.projector_distance) + ), + "maximum_curvature_spectrum_error": float( + np.max(fixed.curvature_spectrum_error) + ), + }, + "finite_jacobi": { + "quadrature_order": int(quadrature_order), + "mass_error": analytic_jacobi.mass_error, + "orthogonality_error": ( + analytic_jacobi.orthogonality_error + ), + "atom_relation_error": atom_relation_error, + "raw_atom_closure_error": raw_closure_error, + }, + "inputs": { + str(path.relative_to(script_dir)): _sha256(path) + for path in input_paths + }, + "checks": checks, + "all_checks_pass": bool(all(checks.values())), + "runtime_seconds": time.perf_counter() - started, + "environment": { + "python": platform.python_version(), + "numpy": np.__version__, + "platform": platform.platform(), + }, + } + output_json.parent.mkdir(parents=True, exist_ok=True) + output_npz.parent.mkdir(parents=True, exist_ok=True) + output_json.write_text( + json.dumps(result, indent=2) + "\n", + encoding="utf-8", + ) + np.savez_compressed( + output_npz, + times=TIMES.astype(np.float32), + energy_raw=exact_energy.raw.astype(np.float32), + energy_disconnected=exact_energy.disconnected.astype(np.float32), + energy_connected=exact_energy.connected.astype(np.float32), + jacobi_connected_D50=( + analytic_jacobi.connected_continuous.astype(np.float32) + ), + structured_spectra=structured["spectra"], + structured_active_ranks=structured["active_ranks"], + structured_unique_counts=structured["unique_counts"], + structured_momenta=structured["momenta"], + structured_orbit_keys=structured["orbit_keys"], + structured_orbit_id=structured["orbit_id"], + structured_raw=structured["raw"].astype(np.float32), + structured_disconnected=( + structured["disconnected"].astype(np.float32) + ), + structured_connected=structured["connected"].astype( + np.float32 + ), + physical_test_spectra=physical_test_spectra, + physical_raw=physical_raw.astype(np.float32), + physical_disconnected=physical_disconnected.astype(np.float32), + physical_connected=physical_connected.astype(np.float32), + physical_seed_block=physical["seed_block"][test_indices], + haar_spectra=haar_spectra, + haar_raw=haar_raw.astype(np.float32), + haar_disconnected=haar_disconnected.astype(np.float32), + haar_connected=haar_connected.astype(np.float32), + g_values=geometry["g_values"].astype(np.float32), + g_spectra=geometry["spectra"], + g_active_ranks=geometry["active_ranks"], + g_unique_counts=geometry["unique_counts"], + g_momentum_index=geometry["momentum_index"], + g_seed_block=geometry["seed_block"], + g_raw=geometry["raw"].astype(np.float32), + g_disconnected=geometry["disconnected"].astype(np.float32), + g_connected=geometry["connected"].astype(np.float32), + alpha_values=fixed.alphas.astype(np.float32), + energy_spectra_alpha=fixed.energy_spectra, + energy_gap_ratio_alpha=fixed.mean_gap_ratio.astype(np.float32), + energy_raw_alpha=fixed.energy_raw.astype(np.float32), + energy_disconnected_alpha=( + fixed.energy_disconnected.astype(np.float32) + ), + energy_connected_alpha=fixed.energy_connected.astype( + np.float32 + ), + projector_distance_alpha=fixed.projector_distance.astype( + np.float64 + ), + curvature_error_alpha=( + fixed.curvature_spectrum_error.astype(np.float64) + ), + rank_D=rank["D"], + rank_M=rank["M"], + rank_interior=rank["interior"], + rank_atom_each=rank["atom_each"], + rank_form_factor_sample_count=rank["sample_count"], + rank_physical_connected_continuous=( + rank["physical_connected_continuous"].astype(np.float32) + ), + rank_physical_connected_full=( + rank["physical_connected_full"].astype(np.float32) + ), + rank_reference_connected_continuous=( + rank["reference_connected_continuous"].astype(np.float32) + ), + rank_reference_connected_full=( + rank["reference_connected_full"].astype(np.float32) + ), + rank_reference_raw_full=( + rank["reference_raw_full"].astype(np.float32) + ), + rank_reference_raw_atom_atom=( + rank["reference_raw_atom_atom"].astype(np.float32) + ), + rank_reference_raw_atom_continuum=( + rank["reference_raw_atom_continuum"].astype(np.float32) + ), + rank_reference_raw_continuum_continuum=( + rank["reference_raw_continuum_continuum"].astype( + np.float32 + ) + ), + ) + return result + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--output-json", + type=Path, + default=_default_output("spectral_silence_v2.json"), + ) + parser.add_argument( + "--output-npz", + type=Path, + default=_default_output("spectral_silence_v2.npz"), + ) + parser.add_argument( + "--samples-per-g", + type=int, + default=REGISTERED_SAMPLES_PER_G, + ) + parser.add_argument( + "--spectral-samples", + type=int, + default=REGISTERED_SPECTRAL_SAMPLES, + ) + parser.add_argument( + "--quadrature-order", + type=int, + default=REGISTERED_QUADRATURE_ORDER, + ) + parser.add_argument( + "--rank-form-factor-samples", + type=int, + default=REGISTERED_RANK_FORM_FACTOR_SAMPLES, + ) + args = parser.parse_args() + result = run( + args.output_json, + args.output_npz, + samples_per_g=args.samples_per_g, + spectral_samples=args.spectral_samples, + quadrature_order=args.quadrature_order, + rank_form_factor_samples=args.rank_form_factor_samples, + ) + print(json.dumps(result, indent=2)) + if not result["all_checks_pass"]: + raise SystemExit("spectral-silence production audit failed") + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_statistical_analysis_v1.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_statistical_analysis_v1.py new file mode 100644 index 000000000..8d4b47dd3 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_statistical_analysis_v1.py @@ -0,0 +1,597 @@ +#!/usr/bin/env python3 +"""Matrix-level inference for the large-scale Geometric-ETH ensembles.""" + +from __future__ import annotations + +import argparse +import json +import platform +import time +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np +from scipy.ndimage import gaussian_filter1d + +from lgeth.statistics import ( + bulk_gap_ratio_per_spectrum, + fit_size_models, + matrix_bootstrap_band, + number_variance_matrix_curves, + unfold_spectra, +) + + +VERSION = "v1" +BOOTSTRAP_REPLICATES = 10_000 +DENSITY_GRID = np.linspace(-1.05, 1.05, 301) +KDE_BANDWIDTH = 0.025 +RATIO_EDGES = np.linspace(0.0, 1.0, 61) +LENGTHS = np.linspace(0.25, 8.0, 32) +FORM_FACTOR_TIMES = np.linspace(0.0, 3.0, 61) + + +def _kde_matrix_curves( + spectra: np.ndarray, + grid: np.ndarray, + bandwidth: float, +) -> np.ndarray: + values = np.asarray(spectra, dtype=float) + result = np.empty((values.shape[0], grid.size), dtype=np.float32) + normalization = bandwidth * np.sqrt(2.0 * np.pi) + for start in range(0, values.shape[0], 256): + stop = min(start + 256, values.shape[0]) + difference = ( + grid[None, :, None] - values[start:stop, None, :] + ) / bandwidth + curves = np.mean( + np.exp(-0.5 * difference * difference), + axis=2, + ) / normalization + integral = np.trapezoid(curves, grid, axis=1) + result[start:stop] = curves / integral[:, None] + return result + + +def _ratio_matrix_curves(spectra: np.ndarray) -> np.ndarray: + values = np.sort(np.asarray(spectra, dtype=float), axis=1) + curves = np.empty( + (values.shape[0], RATIO_EDGES.size - 1), + dtype=np.float32, + ) + width = np.diff(RATIO_EDGES) + for matrix, levels in enumerate(values): + trim = int(np.floor(0.15 * levels.size)) + bulk = levels[trim : levels.size - trim] + gaps = np.diff(bulk) + ratios = np.minimum(gaps[:-1], gaps[1:]) / np.maximum( + gaps[:-1], + gaps[1:], + ) + counts, _ = np.histogram(ratios, bins=RATIO_EDGES) + curves[matrix] = counts / (np.sum(counts) * width) + return curves + + +def _rigidity_from_number( + number_curves: np.ndarray, + lengths: np.ndarray, +) -> np.ndarray: + result = np.empty_like(number_curves) + extended_x = np.concatenate([[0.0], lengths]) + for column, length in enumerate(lengths): + x = extended_x[: column + 2] + values = np.concatenate( + [ + np.zeros((number_curves.shape[0], 1)), + number_curves[:, : column + 1], + ], + axis=1, + ) + kernel = length**3 - 2.0 * length * length * x + x**3 + result[:, column] = ( + 2.0 + / length**4 + * np.trapezoid(values * kernel[None, :], x, axis=1) + ) + return result + + +def _form_factor_matrix_curves( + unfolded: np.ndarray, + times: np.ndarray, +) -> np.ndarray: + levels = unfolded.shape[1] + partition = np.empty( + (unfolded.shape[0], times.size), + dtype=np.complex128, + ) + for start in range(0, unfolded.shape[0], 512): + stop = min(start + 512, unfolded.shape[0]) + phases = np.exp( + -2j + * np.pi + * unfolded[start:stop, :, None] + * times[None, None, :] + ) + partition[start:stop] = np.sum(phases, axis=1) + mean_partition = np.mean(partition, axis=0) + return ( + np.abs(partition) ** 2 + - np.abs(mean_partition)[None, :] ** 2 + ) / levels + + +def _band_arrays(prefix: str, band, output: dict[str, np.ndarray]) -> None: + output[f"{prefix}_mean"] = band.mean.astype(np.float32) + output[f"{prefix}_lower"] = band.lower.astype(np.float32) + output[f"{prefix}_upper"] = band.upper.astype(np.float32) + output[f"{prefix}_pointwise_lower"] = band.pointwise_lower.astype( + np.float32 + ) + output[f"{prefix}_pointwise_upper"] = band.pointwise_upper.astype( + np.float32 + ) + output[f"{prefix}_standard_error"] = band.standard_error.astype( + np.float32 + ) + + +def _curve_suite( + spectra: np.ndarray, + seed: int, + output: dict[str, np.ndarray], + prefix: str, + groups: np.ndarray | None, + replicates: int, +) -> dict[str, Any]: + density_curves = _kde_matrix_curves( + spectra, + DENSITY_GRID, + KDE_BANDWIDTH, + ) + ratio_curves = _ratio_matrix_curves(spectra) + unfolded = unfold_spectra(spectra, "ensemble_cdf") + number_curves = number_variance_matrix_curves(unfolded, LENGTHS) + rigidity_curves = _rigidity_from_number(number_curves, LENGTHS) + form_curves = _form_factor_matrix_curves( + unfolded, + FORM_FACTOR_TIMES, + ) + moments = np.column_stack( + [np.mean(spectra.astype(float) ** order, axis=1) for order in (2,4,6,8)] + ) + curve_sets = { + "density": density_curves, + "ratio": ratio_curves, + "number": number_curves, + "rigidity": rigidity_curves, + "form_factor": form_curves, + "moments": moments, + } + metadata: dict[str, Any] = {} + for offset, (name, curves) in enumerate(curve_sets.items()): + band = matrix_bootstrap_band( + curves, + replicates=replicates, + seed=seed + offset, + groups=groups, + ) + _band_arrays(f"{prefix}_{name}", band, output) + metadata[name] = { + "method": band.method, + "units": band.units, + "replicates": band.replicates, + "critical_value": band.critical_value, + } + return metadata + + +def _smoothed_density( + spectra: np.ndarray, + bandwidth: float, +) -> np.ndarray: + fine_edges = np.linspace(-1.1, 1.1, 2202) + density, _ = np.histogram( + spectra.ravel(), + bins=fine_edges, + density=True, + ) + centers = 0.5 * (fine_edges[:-1] + fine_edges[1:]) + spacing = centers[1] - centers[0] + smoothed = gaussian_filter1d( + density, + bandwidth / spacing, + mode="constant", + ) + interpolated = np.interp(DENSITY_GRID, centers, smoothed) + return interpolated / np.trapezoid(interpolated, DENSITY_GRID) + + +def _sensitivity( + physical: np.ndarray, + haar: np.ndarray, + deformed: np.ndarray, +) -> dict[str, Any]: + bandwidth_results = {} + for bandwidth in (0.015, 0.02, 0.025, 0.035, 0.05): + first = _smoothed_density(physical, bandwidth) + second = _smoothed_density(haar, bandwidth) + third = _smoothed_density(deformed, bandwidth) + bandwidth_results[str(bandwidth)] = { + "physical_haar_l1": float( + np.trapezoid(np.abs(first - second), DENSITY_GRID) + ), + "physical_deformed_l1": float( + np.trapezoid(np.abs(first - third), DENSITY_GRID) + ), + } + bulk_results = {} + for fraction in (0.5, 0.6, 0.7, 0.8, 0.9): + bulk_results[str(fraction)] = { + "physical": float( + np.mean( + bulk_gap_ratio_per_spectrum( + physical, + bulk_fraction=fraction, + ) + ) + ), + "haar": float( + np.mean( + bulk_gap_ratio_per_spectrum( + haar, + bulk_fraction=fraction, + ) + ) + ), + "deformed": float( + np.mean( + bulk_gap_ratio_per_spectrum( + deformed, + bulk_fraction=fraction, + ) + ) + ), + } + unfolding_results = {} + for method in ("ensemble_cdf", "polynomial"): + unfolding_results[method] = {} + for name, spectra in ( + ("physical", physical), + ("haar", haar), + ("deformed", deformed), + ): + unfolded = unfold_spectra(spectra, method) + unfolding_results[method][name] = float( + np.mean(bulk_gap_ratio_per_spectrum(unfolded)) + ) + binning_results = {} + for bins in (30, 50, 70): + edges = np.linspace(0.0, 1.0, bins + 1) + distributions = {} + for name, spectra in ( + ("physical", physical), + ("haar", haar), + ("deformed", deformed), + ): + ordered = np.sort(spectra, axis=1) + gaps = np.diff(ordered, axis=1) + ratios = np.minimum(gaps[:, :-1], gaps[:, 1:]) / np.maximum( + gaps[:, :-1], gaps[:, 1:] + ) + distributions[name], _ = np.histogram( + ratios, + bins=edges, + density=True, + ) + binning_results[str(bins)] = { + "physical_haar_l1": float( + np.sum( + np.abs( + distributions["physical"] - distributions["haar"] + ) + * np.diff(edges) + ) + ), + "physical_deformed_l1": float( + np.sum( + np.abs( + distributions["physical"] + - distributions["deformed"] + ) + * np.diff(edges) + ) + ), + } + return { + "bandwidth": bandwidth_results, + "bulk_fraction": bulk_results, + "unfolding": unfolding_results, + "ratio_binning": binning_results, + } + + +def _scaling_inference( + scaling_json: dict[str, Any], + scaling_arrays: Any, +) -> tuple[dict[str, Any], dict[str, np.ndarray]]: + cases = scaling_json["cases"] + D = np.asarray([case["D"] for case in cases], dtype=float) + M = np.asarray([case["M"] for case in cases], dtype=float) + density = np.asarray( + [case["interior_density_l1"] for case in cases], + dtype=float, + ) + gap = np.asarray( + [case["gap_ratio_difference"] for case in cases], + dtype=float, + ) + participation = np.asarray( + [case["mean_participation"] for case in cases], + dtype=float, + ) + density_se = np.empty(D.size) + gap_se = np.empty(D.size) + participation_se = np.empty(D.size) + for index, case in enumerate(cases): + n = case["n"] + labels = scaling_arrays[f"n{n}_seed_block"] + root = scaling_arrays[f"n{n}_interior_spectra"] + reference = scaling_arrays[f"n{n}_reference_interior_spectra"] + root_ratio = scaling_arrays[f"n{n}_gap_ratios"] + reference_ratio = scaling_arrays[f"n{n}_reference_gap_ratios"] + root_participation = scaling_arrays[f"n{n}_participation"] + block_density = [] + block_gap = [] + block_participation = [] + edges = np.linspace(-1.0, 1.0, 161) + reference_density, _ = np.histogram( + reference.ravel(), + bins=edges, + density=True, + ) + for block in np.unique(labels): + keep = labels == block + block_hist, _ = np.histogram( + root[keep].ravel(), + bins=edges, + density=True, + ) + block_density.append( + np.sum(np.abs(block_hist - reference_density) * np.diff(edges)) + ) + block_gap.append( + abs( + float(np.mean(root_ratio[keep])) + - float(np.mean(reference_ratio)) + ) + ) + block_participation.append( + float(np.mean(root_participation[keep])) + ) + density_se[index] = np.std(block_density, ddof=1) / np.sqrt( + len(block_density) + ) + gap_se[index] = np.std(block_gap, ddof=1) / np.sqrt(len(block_gap)) + participation_se[index] = np.std( + block_participation, + ddof=1, + ) / np.sqrt(len(block_participation)) + density_se = np.maximum(density_se, 1e-4) + gap_se = np.maximum(gap_se, 1e-4) + participation_se = np.maximum(participation_se, 1e-5) + fits = { + "density_l1": fit_size_models(D, density, density_se), + "gap_ratio_difference": fit_size_models(D, gap, gap_se), + "participation_deficit": fit_size_models( + D, + 1.0 - participation, + participation_se, + ), + } + arrays = { + "scaling_D": D.astype(np.float32), + "scaling_M": M.astype(np.float32), + "scaling_density_l1": density.astype(np.float32), + "scaling_density_se": density_se.astype(np.float32), + "scaling_gap_difference": gap.astype(np.float32), + "scaling_gap_se": gap_se.astype(np.float32), + "scaling_participation": participation.astype(np.float32), + "scaling_participation_se": participation_se.astype(np.float32), + "scaling_atom_weight": np.asarray( + [ + 2.0 * case["plus_atoms_per_matrix"] / case["D"] + for case in cases + ], + dtype=np.float32, + ), + } + return fits, arrays + + +def run( + physical_npz: Path, + covariance_npz: Path, + scaling_json_path: Path, + scaling_npz: Path, + output_json: Path, + output_npz: Path, + bootstrap_replicates: int = BOOTSTRAP_REPLICATES, +) -> dict[str, Any]: + """Generate confidence bands, long-range diagnostics, and size fits.""" + + started = time.perf_counter() + replicates = int(bootstrap_replicates) + if replicates < 100: + raise ValueError("at least 100 bootstrap replicates are required") + with np.load(physical_npz) as physical_arrays: + test_indices = physical_arrays["test_indices"] + physical = physical_arrays["normalized_spectra"][ + test_indices + ].astype(float) + physical_groups = physical_arrays["seed_block"][test_indices] + with np.load(covariance_npz) as covariance_arrays: + haar = covariance_arrays["haar_spectra"].astype(float) + deformed = covariance_arrays["deformed_spectra"].astype(float) + scaling_json = json.loads( + scaling_json_path.read_text(encoding="utf-8") + ) + output_arrays: dict[str, np.ndarray] = { + "density_grid": DENSITY_GRID.astype(np.float32), + "ratio_centers": ( + 0.5 * (RATIO_EDGES[:-1] + RATIO_EDGES[1:]) + ).astype(np.float32), + "lengths": LENGTHS.astype(np.float32), + "form_factor_times": FORM_FACTOR_TIMES.astype(np.float32), + "moment_orders": np.asarray([2, 4, 6, 8], dtype=np.int16), + } + ensemble_metadata = {} + for offset, (name, spectra, groups) in enumerate( + ( + ("physical", physical, physical_groups), + ("haar", haar, None), + ("deformed", deformed, None), + ) + ): + print(f"statistical curves: {name}", flush=True) + ensemble_metadata[name] = _curve_suite( + spectra, + seed=20260728600 + 20 * offset, + output=output_arrays, + prefix=name, + groups=groups, + replicates=replicates, + ) + sensitivity = _sensitivity(physical, haar, deformed) + with np.load(scaling_npz) as scaling_arrays: + fits, scaling_output = _scaling_inference( + scaling_json, + scaling_arrays, + ) + output_arrays.update(scaling_output) + density_band_ordering = all( + values["physical_deformed_l1"] + < values["physical_haar_l1"] + for values in sensitivity["bandwidth"].values() + ) + checks = { + "registered_bootstrap_count": ( + replicates == BOOTSTRAP_REPLICATES + ), + "physical_uses_seed_block_hierarchy": ( + ensemble_metadata["physical"]["density"]["method"] + == "hierarchical_seed_block_bootstrap" + ), + "reference_uses_matrix_level_inference": ( + ensemble_metadata["haar"]["density"]["method"].startswith( + "matrix_" + ) + and ensemble_metadata["deformed"]["density"][ + "method" + ].startswith("matrix_") + ), + "covariance_improvement_bandwidth_stable": density_band_ordering, + "all_size_fits_registered": all( + fit["best_by_loo"] in {"D^-1/2", "D^-1", "free"} + for fit in fits.values() + ), + "all_curves_finite": all( + bool(np.all(np.isfinite(value))) + for value in output_arrays.values() + ), + } + result = { + "schema_version": 1, + "version": VERSION, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "sources": { + "physical": str(physical_npz), + "covariance": str(covariance_npz), + "scaling_json": str(scaling_json_path), + "scaling_npz": str(scaling_npz), + }, + "bootstrap_replicates": replicates, + "kde_bandwidth": KDE_BANDWIDTH, + "bulk_fraction": 0.7, + "unfolding": "ensemble_cdf", + "physical_test_matrices": int(physical.shape[0]), + "haar_matrices": int(haar.shape[0]), + "deformed_matrices": int(deformed.shape[0]), + "ensemble_inference": ensemble_metadata, + "sensitivity": sensitivity, + "finite_size_fits": fits, + "checks": checks, + "all_checks_pass": bool(all(checks.values())), + "runtime_seconds": time.perf_counter() - started, + "environment": { + "python": platform.python_version(), + "numpy": np.__version__, + "platform": platform.platform(), + }, + } + output_json.parent.mkdir(parents=True, exist_ok=True) + output_npz.parent.mkdir(parents=True, exist_ok=True) + output_json.write_text( + json.dumps(result, indent=2) + "\n", + encoding="utf-8", + ) + np.savez_compressed(output_npz, **output_arrays) + return result + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--physical-npz", + type=Path, + default=Path("output/physical_ensemble_v1.npz"), + ) + parser.add_argument( + "--covariance-npz", + type=Path, + default=Path("output/covariance_model_v1.npz"), + ) + parser.add_argument( + "--scaling-json", + type=Path, + default=Path("output/rank_scaling_v1.json"), + ) + parser.add_argument( + "--scaling-npz", + type=Path, + default=Path("output/rank_scaling_v1.npz"), + ) + parser.add_argument( + "--output-json", + type=Path, + default=Path("output/statistical_analysis_v1.json"), + ) + parser.add_argument( + "--output-npz", + type=Path, + default=Path("output/statistical_analysis_v1.npz"), + ) + parser.add_argument( + "--bootstrap-replicates", + type=int, + default=BOOTSTRAP_REPLICATES, + ) + args = parser.parse_args() + result = run( + args.physical_npz, + args.covariance_npz, + args.scaling_json, + args.scaling_npz, + args.output_json, + args.output_npz, + bootstrap_replicates=args.bootstrap_replicates, + ) + print(json.dumps(result, indent=2)) + if not result["all_checks_pass"]: + raise SystemExit("statistical-analysis audit failed") + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_susy_hodge_delivery_v7.sh b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_susy_hodge_delivery_v7.sh new file mode 100755 index 000000000..a28662215 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_susy_hodge_delivery_v7.sh @@ -0,0 +1,22 @@ +#!/usr/bin/env bash +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +REPO_DIR="$(cd "$SCRIPT_DIR/../../.." && pwd)" +MANUSCRIPT_DIR="$REPO_DIR/overleaf_sync/cohomological_geometric_eth" +PYTHON_BIN="${PYTHON_BIN:-python3}" + +export PYTHONPATH="$SCRIPT_DIR${PYTHONPATH:+:$PYTHONPATH}" + +"$PYTHON_BIN" "$SCRIPT_DIR/merge_susy_hodge_pilot_v7.py" +"$PYTHON_BIN" "$SCRIPT_DIR/make_susy_hodge_figure_v7.py" +"$PYTHON_BIN" "$SCRIPT_DIR/make_susy_hodge_manuscript_assets_v7.py" +( + cd "$MANUSCRIPT_DIR" + latexmk -pdf -interaction=nonstopmode -halt-on-error main.tex + latexmk -pdf -interaction=nonstopmode -halt-on-error supplement.tex +) +cp "$MANUSCRIPT_DIR/main.pdf" "$SCRIPT_DIR/output/response_complex_memory_v7.pdf" +cp "$MANUSCRIPT_DIR/supplement.pdf" "$SCRIPT_DIR/output/response_complex_memory_supplement_v7.pdf" +"$PYTHON_BIN" "$SCRIPT_DIR/verify_susy_hodge_delivery_v7.py" +"$PYTHON_BIN" "$SCRIPT_DIR/verify_susy_hodge_manuscript_v7.py" diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_susy_hodge_geometric_eth_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_susy_hodge_geometric_eth_v7.py new file mode 100644 index 000000000..cf46a371f --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_susy_hodge_geometric_eth_v7.py @@ -0,0 +1,901 @@ +#!/usr/bin/env python3 +"""Checkpointed and sealed N=2 SYK Hodge-response runner v7.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np + +from lgeth.hodge_response import ( + coupling_panels, + hodge_response, + hodge_signature, + scalable_covariance_matched_wick, +) +from lgeth.hodge_response import HodgeSignature +from lgeth.hodge_wick import hodge_gaussian_r4_reference +from lgeth.susy_cohomology import ( + BPSFrame, + charge_basis, + charge_hamiltonian, + cubic_supercharge, + expected_generic_bps_rank, + normalized_complex_couplings, + solve_bps_frame, +) +from lgeth.wick_channels import gaussian_r4_reference + + +VERSION = "v7" +SCRIPT_ROOT = Path(__file__).resolve().parent +OUTPUT_ROOT = SCRIPT_ROOT / "output" +CHECKPOINT_ROOT = OUTPUT_ROOT / "susy_hodge_v7_checkpoints" +REGISTERED_SIZES = (8, 10, 12, 14) +REGISTERED_SECTORS = ("central", "adjacent") +REGISTERED_PANEL_KINDS = ("sparse", "isotropic") +PANEL_SIZE = 8 +REALIZATION_COUNTS = {8: 64, 10: 48, 12: 32, 14: 24} +NULL_REPLICATES = 2_000 +NULL_DRAWS_PER_REALIZATION = 128 +BASE_SEED = 2026080111 +FORBIDDEN_SAFE_TOKENS = ("r4", "four_point", "connected") +PILOT_SAFE_JSON = OUTPUT_ROOT / "susy_hodge_v7_covariates_pilot.json" +PILOT_JSON = OUTPUT_ROOT / "susy_hodge_v7_outcomes_pilot.json" +PILOT_NPZ = OUTPUT_ROOT / "susy_hodge_v7_outcomes_pilot.npz" + + +def _atomic_json(path: Path, payload: dict[str, Any]) -> None: + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text( + json.dumps(payload, indent=2, sort_keys=True), + encoding="utf-8", + ) + temporary.replace(path) + + +def _atomic_npz(path: Path, **arrays: np.ndarray) -> None: + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + with temporary.open("wb") as handle: + np.savez_compressed(handle, **arrays) + temporary.replace(path) + + +def _atomic_text(path: Path, value: str) -> None: + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(value, encoding="utf-8") + temporary.replace(path) + + +def sha256(path: Path) -> str: + digest = hashlib.sha256() + with Path(path).open("rb") as handle: + for block in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(block) + return digest.hexdigest() + + +def _json_hash(payload: dict[str, Any]) -> str: + return hashlib.sha256( + json.dumps(payload, sort_keys=True, separators=(",", ":")).encode() + ).hexdigest() + + +def _derived_seed(*parts: object) -> int: + label = "|".join(str(item) for item in (BASE_SEED, VERSION, *parts)) + return int.from_bytes(hashlib.sha256(label.encode()).digest()[:8], "big") + + +def _source_hashes() -> dict[str, str]: + paths = ( + Path(__file__).resolve(), + SCRIPT_ROOT / "lgeth" / "susy_cohomology.py", + SCRIPT_ROOT / "lgeth" / "hodge_response.py", + SCRIPT_ROOT / "lgeth" / "hodge_wick.py", + SCRIPT_ROOT / "lgeth" / "wick_channels.py", + ) + return {str(path.relative_to(SCRIPT_ROOT)): sha256(path) for path in paths} + + +def _sector_charge(N: int, sector: str) -> int: + modes = int(N) + label = str(sector) + if modes % 2: + raise ValueError("registered SUSY sequence requires even N") + if label == "central": + return modes // 2 + if label == "adjacent": + return modes // 2 - 1 + raise ValueError(f"sector must be one of {REGISTERED_SECTORS}") + + +def _validate_case( + N: int, + sector: str, + realization: int, + *, + reduced: bool, +) -> tuple[int, str, int, int]: + modes = int(N) + label = str(sector) + index = int(realization) + charge = _sector_charge(modes, label) + if not reduced: + if modes not in REGISTERED_SIZES: + raise ValueError(f"N must be one of {REGISTERED_SIZES}") + if not 0 <= index < REALIZATION_COUNTS[modes]: + raise ValueError("realization is outside the registered range") + elif modes < 6 or index < 0: + raise ValueError("invalid reduced realization") + return modes, label, index, charge + + +def kernel_paths( + root: Path, + N: int, + sector: str, + realization: int, +) -> tuple[Path, Path]: + stem = ( + Path(root) + / "kernels" + / f"N{int(N)}_{sector}_seed{int(realization):03d}_{VERSION}" + ) + return stem.with_suffix(".json"), stem.with_suffix(".npz") + + +def panel_paths( + root: Path, + N: int, + sector: str, + realization: int, + panel_kind: str, +) -> tuple[Path, Path, Path]: + stem = ( + Path(root) + / "panels" + / ( + f"N{int(N)}_{sector}_seed{int(realization):03d}_" + f"{panel_kind}_{VERSION}" + ) + ) + return ( + stem.with_suffix(".json"), + stem.with_suffix(".npz"), + Path(str(stem) + ".outcome.json"), + ) + + +def prepare_realization( + N: int, + sector: str, + realization: int, + *, + root: Path = CHECKPOINT_ROOT, + reduced: bool = False, + force: bool = False, +) -> dict[str, Any]: + """Solve and checkpoint one coupling realization without any four-point data.""" + + modes, label, index, charge = _validate_case( + N, + sector, + realization, + reduced=reduced, + ) + coupling_seed = _derived_seed(modes, label, index, "couplings") + identity = { + "version": VERSION, + "N": modes, + "sector": label, + "charge": charge, + "realization": index, + "coupling_seed": coupling_seed, + "expected_rank": expected_generic_bps_rank(modes, charge), + "reduced": bool(reduced), + "sources": _source_hashes(), + } + identity_hash = _json_hash(identity) + metadata_path, arrays_path = kernel_paths(root, modes, label, index) + if not force and metadata_path.is_file() and arrays_path.is_file(): + metadata = json.loads(metadata_path.read_text(encoding="utf-8")) + if ( + metadata.get("identity") == identity + and metadata.get("identity_hash") == identity_hash + and metadata.get("arrays_sha256") == sha256(arrays_path) + and all(metadata.get("checks", {}).values()) + ): + return metadata + raise ValueError("SUSY realization checkpoint identity mismatch") + couplings = normalized_complex_couplings(modes, coupling_seed) + frame = solve_bps_frame(modes, charge, couplings, dense_cutoff=4096) + _atomic_npz( + arrays_path, + couplings=couplings, + projector_frame=frame.projector_frame, + complement_frame=frame.complement_frame, + positive_energies=frame.positive_energies, + ) + checks = { + "expected_bps_rank": frame.projector_frame.shape[1] + == identity["expected_rank"], + "open_external_gap": frame.gap > 1e-10, + "kernel_residual": frame.kernel_residual < 1e-8, + "orthonormal_frame": frame.orthogonality_error < 1e-10, + "unit_coupling_norm": abs(float(np.linalg.norm(couplings)) - 1.0) + < 1e-13, + } + metadata = { + "identity": identity, + "identity_hash": identity_hash, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "hilbert_dimension": len(frame.basis), + "bps_rank": frame.projector_frame.shape[1], + "complement_rank": frame.complement_frame.shape[1], + "gap": frame.gap, + "kernel_residual": frame.kernel_residual, + "orthogonality_error": frame.orthogonality_error, + "arrays_sha256": sha256(arrays_path), + "checks": checks, + "passed": all(checks.values()), + } + if not metadata["passed"]: + raise RuntimeError(f"SUSY realization audit failed: {checks}") + _atomic_json(metadata_path, metadata) + return metadata + + +def _load_frame( + root: Path, + N: int, + sector: str, + realization: int, +) -> tuple[dict[str, Any], np.ndarray, BPSFrame]: + metadata_path, arrays_path = kernel_paths(root, N, sector, realization) + if not metadata_path.is_file() or not arrays_path.is_file(): + raise FileNotFoundError("missing SUSY realization checkpoint") + metadata = json.loads(metadata_path.read_text(encoding="utf-8")) + if metadata.get("arrays_sha256") != sha256(arrays_path): + raise ValueError("SUSY realization array hash mismatch") + with np.load(arrays_path) as arrays: + couplings = np.asarray(arrays["couplings"], dtype=complex) + projector = np.asarray(arrays["projector_frame"], dtype=complex) + complement = np.asarray(arrays["complement_frame"], dtype=complex) + energies = np.asarray(arrays["positive_energies"], dtype=float) + charge = int(metadata["identity"]["charge"]) + q_in = cubic_supercharge(N, charge - 3, couplings) + q_out = cubic_supercharge(N, charge, couplings) + hamiltonian = charge_hamiltonian(N, charge, couplings) + frame = BPSFrame( + N=int(N), + charge=charge, + basis=charge_basis(N, charge), + projector_frame=projector, + complement_frame=complement, + positive_energies=energies, + gap=float(energies[0]), + kernel_residual=float(metadata["kernel_residual"]), + orthogonality_error=float(metadata["orthogonality_error"]), + expected_rank=int(metadata["identity"]["expected_rank"]), + q_in=q_in, + q_out=q_out, + hamiltonian=hamiltonian, + ) + return metadata, couplings, frame + + +def _signature_arrays(signature: Any) -> dict[str, np.ndarray]: + return { + "minus_channel_covariance": signature.minus_channel_covariance, + "plus_channel_covariance": signature.plus_channel_covariance, + "minus_target_eigenvalues": signature.minus_target_eigenvalues, + "plus_target_eigenvalues": signature.plus_target_eigenvalues, + "minus_external_eigenvalues": signature.minus_external_eigenvalues, + "plus_external_eigenvalues": signature.plus_external_eigenvalues, + } + + +def _signature_from_safe( + safe: dict[str, Any], + arrays: Any, +) -> HodgeSignature: + scalars = safe["signature"] + return HodgeSignature( + channel_count=int(scalars["channel_count"]), + target_rank=int(scalars["target_rank"]), + minus_weight=float(scalars["minus_weight"]), + plus_weight=float(scalars["plus_weight"]), + hodge_balance=float(scalars["hodge_balance"]), + minus_channel_covariance=np.asarray( + arrays["minus_channel_covariance"], dtype=complex + ), + plus_channel_covariance=np.asarray( + arrays["plus_channel_covariance"], dtype=complex + ), + minus_target_eigenvalues=np.asarray( + arrays["minus_target_eigenvalues"], dtype=float + ), + plus_target_eigenvalues=np.asarray( + arrays["plus_target_eigenvalues"], dtype=float + ), + minus_external_eigenvalues=np.asarray( + arrays["minus_external_eigenvalues"], dtype=float + ), + plus_external_eigenvalues=np.asarray( + arrays["plus_external_eigenvalues"], dtype=float + ), + minus_target_effective_rank=float( + scalars["minus_target_effective_rank"] + ), + plus_target_effective_rank=float(scalars["plus_target_effective_rank"]), + minus_external_effective_rank=float( + scalars["minus_external_effective_rank"] + ), + plus_external_effective_rank=float( + scalars["plus_external_effective_rank"] + ), + minus_target_entropy=float(scalars["minus_target_entropy"]), + plus_target_entropy=float(scalars["plus_target_entropy"]), + minus_external_entropy=float(scalars["minus_external_entropy"]), + plus_external_entropy=float(scalars["plus_external_entropy"]), + orthogonality_relative_error=float( + scalars["orthogonality_relative_error"] + ), + ) + + +def _safe_serialization_check(payload: dict[str, Any]) -> bool: + serialized = json.dumps(payload, sort_keys=True).lower() + return not any(token in serialized for token in FORBIDDEN_SAFE_TOKENS) + + +def _positive_covariance_spectrum(values: np.ndarray) -> np.ndarray: + spectrum = np.maximum(np.asarray(values, dtype=float), 0.0) + largest = float(np.max(spectrum)) + if largest <= 0.0: + raise ValueError("covariance spectrum has no positive support") + return spectrum[spectrum > 1e-12 * largest] + + +def _banked_complete_medians( + banks: np.ndarray, + replicates: int, + seed: int, +) -> np.ndarray: + """Draw one bank entry per realization and aggregate by the median.""" + + values = np.asarray(banks, dtype=float) + count = int(replicates) + if values.ndim != 2 or min(values.shape) < 1 or count < 1: + raise ValueError("null banks and replicate count are invalid") + rng = np.random.default_rng(int(seed)) + selections = rng.integers( + 0, + values.shape[1], + size=(count, values.shape[0]), + ) + realization_indices = np.arange(values.shape[0])[None, :] + draws = values[realization_indices, selections] + return np.median(draws, axis=1) + + +def run_panel( + N: int, + sector: str, + realization: int, + panel_kind: str, + *, + root: Path = CHECKPOINT_ROOT, + reduced: bool = False, + force: bool = False, +) -> dict[str, Any]: + """Evaluate one panel while isolating the physical statistic in a sidecar.""" + + modes, label, index, _ = _validate_case( + N, + sector, + realization, + reduced=reduced, + ) + kind = str(panel_kind) + if kind not in REGISTERED_PANEL_KINDS: + raise ValueError(f"panel kind must be one of {REGISTERED_PANEL_KINDS}") + safe_path, arrays_path, outcome_path = panel_paths( + root, + modes, + label, + index, + kind, + ) + if not force and safe_path.is_file() and arrays_path.is_file() and outcome_path.is_file(): + safe = json.loads(safe_path.read_text(encoding="utf-8")) + outcome = json.loads(outcome_path.read_text(encoding="utf-8")) + if ( + safe.get("arrays_sha256") == sha256(arrays_path) + and outcome.get("safe_identity_hash") == safe.get("identity_hash") + and all(safe.get("checks", {}).values()) + ): + return {"safe": safe, "outcome": outcome} + raise ValueError("SUSY panel checkpoint identity mismatch") + kernel, couplings, frame = _load_frame(root, modes, label, index) + panel_seed = _derived_seed(modes, label, index, "panels") + tangents = coupling_panels(couplings, PANEL_SIZE, panel_seed)[kind] + response = hodge_response(frame, couplings, tangents) + signature = hodge_signature(response) + statistic = scalable_covariance_matched_wick(response.total) + safe_identity = { + "version": VERSION, + "N": modes, + "sector": label, + "charge": frame.charge, + "realization": index, + "panel_kind": kind, + "panel_seed": panel_seed, + "kernel_identity_hash": kernel["identity_hash"], + "sources": _source_hashes(), + } + safe_identity_hash = _json_hash(safe_identity) + arrays = { + "tangents": tangents, + **_signature_arrays(signature), + "total_target_eigenvalues": statistic.left_eigenvalues, + "total_external_eigenvalues": statistic.right_eigenvalues, + } + _atomic_npz(arrays_path, **arrays) + signature_scalars = { + "channel_count": signature.channel_count, + "target_rank": signature.target_rank, + "minus_weight": signature.minus_weight, + "plus_weight": signature.plus_weight, + "hodge_balance": signature.hodge_balance, + "minus_target_effective_rank": signature.minus_target_effective_rank, + "plus_target_effective_rank": signature.plus_target_effective_rank, + "minus_external_effective_rank": signature.minus_external_effective_rank, + "plus_external_effective_rank": signature.plus_external_effective_rank, + "minus_target_entropy": signature.minus_target_entropy, + "plus_target_entropy": signature.plus_target_entropy, + "minus_external_entropy": signature.minus_external_entropy, + "plus_external_entropy": signature.plus_external_entropy, + "orthogonality_relative_error": signature.orthogonality_relative_error, + } + checks = { + **response.checks, + "full_channel_support": len(statistic.channel_covariance_eigenvalues) + == PANEL_SIZE, + "safe_arrays_exclude_response_matrices": set(arrays) + == { + "tangents", + "minus_channel_covariance", + "plus_channel_covariance", + "minus_target_eigenvalues", + "plus_target_eigenvalues", + "minus_external_eigenvalues", + "plus_external_eigenvalues", + "total_target_eigenvalues", + "total_external_eigenvalues", + }, + "finite_hodge_signature": all( + np.isfinite(value) for value in signature_scalars.values() + ), + } + safe = { + "identity": safe_identity, + "identity_hash": safe_identity_hash, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "kernel": { + "bps_rank": kernel["bps_rank"], + "complement_rank": kernel["complement_rank"], + "gap": kernel["gap"], + "kernel_residual": kernel["kernel_residual"], + }, + "signature": signature_scalars, + "spectrum_lengths": { + key: int(np.asarray(value).size) + for key, value in _signature_arrays(signature).items() + }, + "arrays_sha256": sha256(arrays_path), + "checks": checks, + "passed": all(checks.values()), + } + safe["checks"]["no_outcome_leakage"] = _safe_serialization_check(safe) + safe["passed"] = all(safe["checks"].values()) + if not safe["passed"]: + raise RuntimeError(f"safe SUSY panel audit failed: {safe['checks']}") + _atomic_json(safe_path, safe) + outcome = { + "version": VERSION, + "N": modes, + "sector": label, + "realization": index, + "panel_kind": kind, + "safe_identity_hash": safe_identity_hash, + "safe_arrays_sha256": safe["arrays_sha256"], + "R4": float(statistic.R4), + } + if not np.isfinite(outcome["R4"]): + raise RuntimeError("physical response statistic is not finite") + _atomic_json(outcome_path, outcome) + return {"safe": safe, "outcome": outcome} + + +def write_safe_covariates( + cases: list[tuple[int, str, int, str]], + *, + root: Path = CHECKPOINT_ROOT, + output_json: Path, +) -> dict[str, Any]: + """Aggregate safe panel records without opening outcome sidecars.""" + + records: list[dict[str, Any]] = [] + for case in cases: + safe_path, arrays_path, _ = panel_paths(root, *case) + if not safe_path.is_file() or not arrays_path.is_file(): + raise FileNotFoundError("missing safe SUSY panel checkpoint") + safe = json.loads(safe_path.read_text(encoding="utf-8")) + if safe.get("arrays_sha256") != sha256(arrays_path): + raise ValueError("safe SUSY panel array hash mismatch") + if not all(safe.get("checks", {}).values()): + raise ValueError("safe SUSY panel contains a failed check") + records.append(safe) + payload = { + "version": VERSION, + "records": records, + "checks": { + "complete_requested_grid": len(records) == len(cases), + "all_safe_checks": all( + all(record["checks"].values()) for record in records + ), + }, + } + payload["checks"]["no_outcome_leakage"] = _safe_serialization_check(payload) + payload["passed"] = all(payload["checks"].values()) + if not payload["passed"]: + raise RuntimeError(f"safe covariate audit failed: {payload['checks']}") + _atomic_json(output_json, payload) + return payload + + +def aggregate_pilot( + cases: list[tuple[int, str, int, str]], + *, + root: Path = CHECKPOINT_ROOT, + null_samples: int = NULL_REPLICATES, + null_draws_per_realization: int = NULL_DRAWS_PER_REALIZATION, + seed: int = BASE_SEED, + safe_output_json: Path = PILOT_SAFE_JSON, + output_json: Path = PILOT_JSON, + output_npz: Path = PILOT_NPZ, +) -> dict[str, Any]: + """Open sequential pilot outcomes after a complete safe-covariate audit.""" + + if ( + int(null_samples) < 1 + or int(null_draws_per_realization) < 1 + or not cases + ): + raise ValueError("pilot aggregation requires cases and null samples") + write_safe_covariates(cases, root=root, output_json=safe_output_json) + grouped: dict[tuple[int, str, str], list[tuple[int, dict, Any, float]]] = {} + for case in sorted(cases): + safe_path, arrays_path, outcome_path = panel_paths(root, *case) + safe = json.loads(safe_path.read_text(encoding="utf-8")) + outcome = json.loads(outcome_path.read_text(encoding="utf-8")) + if ( + outcome.get("safe_identity_hash") != safe.get("identity_hash") + or outcome.get("safe_arrays_sha256") != safe.get("arrays_sha256") + or safe.get("arrays_sha256") != sha256(arrays_path) + ): + raise ValueError("pilot outcome identity mismatch") + with np.load(arrays_path) as loaded: + copied = {key: np.asarray(loaded[key]) for key in loaded.files} + group = (int(case[0]), str(case[1]), str(case[3])) + grouped.setdefault(group, []).append( + (int(case[2]), safe, copied, float(outcome["R4"])) + ) + output_arrays: dict[str, np.ndarray] = {} + summaries: list[dict[str, Any]] = [] + for (N, sector, panel_kind), records in sorted(grouped.items()): + records.sort(key=lambda item: item[0]) + physical = np.asarray([item[3] for item in records], dtype=float) + signatures = [ + _signature_from_safe(item[1], item[2]) for item in records + ] + collapsed_draws = [] + hodge_draws = [] + for realization, _, arrays, _ in records: + collapsed_draws.append( + gaussian_r4_reference( + _positive_covariance_spectrum( + arrays["total_target_eigenvalues"] + ), + _positive_covariance_spectrum( + arrays["total_external_eigenvalues"] + ), + PANEL_SIZE, + int(null_draws_per_realization), + _derived_seed(seed, N, sector, panel_kind, realization, "collapsed"), + ) + ) + for realization, signature in zip( + [item[0] for item in records], + signatures, + strict=True, + ): + hodge_draws.append( + hodge_gaussian_r4_reference( + signature, + PANEL_SIZE, + int(null_draws_per_realization), + _derived_seed( + seed, + N, + sector, + panel_kind, + realization, + "hodge_bank", + ), + ) + ) + collapsed = _banked_complete_medians( + np.asarray(collapsed_draws), + int(null_samples), + _derived_seed(seed, N, sector, panel_kind, "collapsed_aggregate"), + ) + hodge = _banked_complete_medians( + np.asarray(hodge_draws), + int(null_samples), + _derived_seed(seed, N, sector, panel_kind, "hodge_aggregate"), + ) + key = f"N{N}_{sector}_{panel_kind}" + output_arrays[f"{key}_physical"] = physical + output_arrays[f"{key}_collapsed_null"] = collapsed + output_arrays[f"{key}_hodge_null"] = hodge + summaries.append( + { + "N": N, + "sector": sector, + "panel_kind": panel_kind, + "realizations": len(records), + "physical_quantiles": np.quantile( + physical, [0.025, 0.5, 0.975] + ).tolist(), + "collapsed_null_quantiles": np.quantile( + collapsed, [0.025, 0.5, 0.975] + ).tolist(), + "hodge_null_quantiles": np.quantile( + hodge, [0.025, 0.5, 0.975] + ).tolist(), + "median_hodge_balance": float( + np.median([item.hodge_balance for item in signatures]) + ), + } + ) + _atomic_npz(output_npz, **output_arrays) + checks = { + "complete_group_partition": sum( + item["realizations"] for item in summaries + ) + == len(cases), + "finite_physical_and_nulls": all( + np.all(np.isfinite(values)) for values in output_arrays.values() + ), + "null_sample_counts": all( + values.shape == (int(null_samples),) + for key, values in output_arrays.items() + if key.endswith("_null") + ), + "safe_aggregate_preexists": Path(safe_output_json).is_file(), + } + payload = { + "version": VERSION, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "uncertainty_unit": "complete_disorder_realization", + "null_samples": int(null_samples), + "null_draws_per_realization": int(null_draws_per_realization), + "cases": summaries, + "safe_covariates_sha256": sha256(safe_output_json), + "arrays_sha256": sha256(output_npz), + "checks": checks, + "passed": all(checks.values()), + } + if not payload["passed"]: + raise RuntimeError(f"SUSY pilot aggregation failed: {checks}") + _atomic_json(output_json, payload) + return payload + + +def registered_case_grid( + sizes: tuple[int, ...] | list[int], +) -> list[tuple[int, str, int, str]]: + """Return the frozen complete pilot grid for the requested sizes.""" + + cases: list[tuple[int, str, int, str]] = [] + for N in tuple(int(value) for value in sizes): + if N not in REGISTERED_SIZES: + raise ValueError(f"N must be one of {REGISTERED_SIZES}") + for sector in REGISTERED_SECTORS: + for realization in range(REALIZATION_COUNTS[N]): + for panel_kind in REGISTERED_PANEL_KINDS: + cases.append((N, sector, realization, panel_kind)) + return cases + + +def run_registered_pilot( + sizes: tuple[int, ...] | list[int], + *, + root: Path = CHECKPOINT_ROOT, + null_samples: int = NULL_REPLICATES, + force: bool = False, +) -> dict[str, Any]: + """Run the complete registered grid and aggregate its sequential outcomes.""" + + requested = tuple(int(value) for value in sizes) + cases = registered_case_grid(requested) + for N in requested: + for sector in REGISTERED_SECTORS: + for realization in range(REALIZATION_COUNTS[N]): + prepare_realization( + N, + sector, + realization, + root=root, + force=force, + ) + for panel_kind in REGISTERED_PANEL_KINDS: + run_panel( + N, + sector, + realization, + panel_kind, + root=root, + force=force, + ) + return aggregate_pilot( + cases, + root=root, + null_samples=int(null_samples), + seed=BASE_SEED, + safe_output_json=PILOT_SAFE_JSON, + output_json=PILOT_JSON, + output_npz=PILOT_NPZ, + ) + + +def _parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(description=__doc__) + subparsers = parser.add_subparsers(dest="command", required=True) + realization = subparsers.add_parser("realization") + realization.add_argument("--N", type=int, required=True) + realization.add_argument("--sector", choices=REGISTERED_SECTORS, required=True) + realization.add_argument("--realization", type=int, required=True) + realization.add_argument("--force", action="store_true") + panel = subparsers.add_parser("panel") + panel.add_argument("--N", type=int, required=True) + panel.add_argument("--sector", choices=REGISTERED_SECTORS, required=True) + panel.add_argument("--realization", type=int, required=True) + panel.add_argument("--panel-kind", choices=REGISTERED_PANEL_KINDS, required=True) + panel.add_argument("--force", action="store_true") + pilot = subparsers.add_parser("pilot") + pilot.add_argument("--sizes", type=int, nargs="+", required=True) + pilot.add_argument("--null-samples", type=int, default=NULL_REPLICATES) + pilot.add_argument("--force", action="store_true") + return parser + + +def main() -> None: + args = _parser().parse_args() + if args.command == "realization": + payload = prepare_realization( + args.N, + args.sector, + args.realization, + force=args.force, + ) + elif args.command == "panel": + payload = run_panel( + args.N, + args.sector, + args.realization, + args.panel_kind, + force=args.force, + )["safe"] + else: + payload = run_registered_pilot( + args.sizes, + null_samples=args.null_samples, + force=args.force, + ) + print(json.dumps(payload, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() + + +def seal_file_hash(source: Path, seal: Path) -> str: + source = Path(source) + if not source.is_file(): + raise FileNotFoundError("missing prediction file to seal") + digest = sha256(source) + _atomic_text(Path(seal), f"{digest} {source.name}\n") + return digest + + +def _validate_file_hash(source: Path, seal: Path) -> str: + source = Path(source) + seal = Path(seal) + if not seal.is_file(): + raise FileNotFoundError("missing prediction hash seal") + if not source.is_file(): + raise FileNotFoundError("missing sealed prediction file") + fields = seal.read_text(encoding="utf-8").strip().split() + if len(fields) != 2 or fields[1] != source.name: + raise ValueError("prediction hash seal format mismatch") + if fields[0] != sha256(source): + raise ValueError("prediction hash seal mismatch") + return fields[0] + + +def unseal_outcomes( + cases: list[tuple[int, str, int, str]], + *, + root: Path = CHECKPOINT_ROOT, + prediction_json: Path, + prediction_seal: Path, + output_json: Path, + output_npz: Path, +) -> dict[str, Any]: + """Open physical sidecars only after validating the prediction seal.""" + + prediction_hash = _validate_file_hash(prediction_json, prediction_seal) + records: list[dict[str, Any]] = [] + values: list[float] = [] + for case in cases: + safe_path, arrays_path, outcome_path = panel_paths(root, *case) + if not safe_path.is_file() or not arrays_path.is_file() or not outcome_path.is_file(): + raise FileNotFoundError("missing sealed SUSY panel files") + safe = json.loads(safe_path.read_text(encoding="utf-8")) + outcome = json.loads(outcome_path.read_text(encoding="utf-8")) + if ( + outcome.get("safe_identity_hash") != safe.get("identity_hash") + or outcome.get("safe_arrays_sha256") != safe.get("arrays_sha256") + or safe.get("arrays_sha256") != sha256(arrays_path) + ): + raise ValueError("outcome identity mismatch") + if tuple( + outcome[key] + for key in ("N", "sector", "realization", "panel_kind") + ) != tuple(case): + raise ValueError("outcome case identity mismatch") + value = float(outcome["R4"]) + if not np.isfinite(value): + raise ValueError("unsealed outcome is not finite") + values.append(value) + records.append(outcome) + physical = np.asarray(values, dtype=float) + _atomic_npz(output_npz, physical_R4=physical) + payload = { + "version": VERSION, + "prediction_sha256": prediction_hash, + "unsealed_utc": datetime.now(timezone.utc).isoformat(), + "records": records, + "arrays_sha256": sha256(output_npz), + "checks": { + "complete_requested_grid": len(records) == len(cases), + "finite_outcomes": bool(np.all(np.isfinite(physical))), + }, + } + payload["passed"] = all(payload["checks"].values()) + _atomic_json(output_json, payload) + return payload diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_susy_hodge_null_bank_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_susy_hodge_null_bank_v7.py new file mode 100644 index 000000000..7fee669ac --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_susy_hodge_null_bank_v7.py @@ -0,0 +1,204 @@ +#!/usr/bin/env python3 +"""Generate safe per-realization Gaussian null banks without opening outcomes.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np + +from lgeth.hodge_wick import hodge_gaussian_r4_reference +from lgeth.wick_channels import gaussian_r4_reference +from run_susy_hodge_geometric_eth_v7 import ( + CHECKPOINT_ROOT, + NULL_DRAWS_PER_REALIZATION, + PANEL_SIZE, + REGISTERED_PANEL_KINDS, + REGISTERED_SECTORS, + SCRIPT_ROOT, + VERSION, + _atomic_json, + _atomic_npz, + _derived_seed, + _positive_covariance_spectrum, + _signature_from_safe, + panel_paths, + sha256, +) + + +OUTPUT_ROOT = SCRIPT_ROOT / "output" / "susy_hodge_v7_null_banks" +FORBIDDEN_SAFE_TOKENS = ("r4", "four_point", "connected") + + +def _array_hash(values: np.ndarray) -> str: + array = np.ascontiguousarray(values) + return hashlib.sha256(array.view(np.uint8)).hexdigest() + + +def _source_hashes() -> dict[str, str]: + paths = ( + Path(__file__).resolve(), + SCRIPT_ROOT / "run_susy_hodge_geometric_eth_v7.py", + SCRIPT_ROOT / "lgeth" / "hodge_response.py", + SCRIPT_ROOT / "lgeth" / "hodge_wick.py", + SCRIPT_ROOT / "lgeth" / "wick_channels.py", + ) + return {str(path.relative_to(SCRIPT_ROOT)): sha256(path) for path in paths} + + +def null_bank_paths( + output_root: Path, + N: int, + sector: str, + realization: int, + panel_kind: str, +) -> tuple[Path, Path]: + stem = Path(output_root) / ( + f"N{int(N)}_{sector}_seed{int(realization):03d}_{panel_kind}_{VERSION}_null" + ) + return stem.with_suffix(".json"), stem.with_suffix(".npz") + + +def write_null_bank( + N: int, + sector: str, + realization: int, + panel_kind: str, + *, + checkpoint_root: Path = CHECKPOINT_ROOT, + output_root: Path = OUTPUT_ROOT, + draws: int = NULL_DRAWS_PER_REALIZATION, + force: bool = False, +) -> dict[str, Any]: + """Write collapsed and Hodge null draws using only safe covariance data.""" + + count = int(draws) + if count < 1: + raise ValueError("null bank requires at least one draw") + safe_path, safe_arrays_path, _ = panel_paths( + checkpoint_root, + N, + sector, + realization, + panel_kind, + ) + if not safe_path.is_file() or not safe_arrays_path.is_file(): + raise FileNotFoundError("missing safe panel data for null bank") + safe = json.loads(safe_path.read_text(encoding="utf-8")) + if safe.get("arrays_sha256") != sha256(safe_arrays_path): + raise ValueError("safe panel array hash mismatch") + if not all(safe.get("checks", {}).values()): + raise ValueError("safe panel contains a failed gate") + metadata_path, arrays_path = null_bank_paths( + output_root, + N, + sector, + realization, + panel_kind, + ) + identity = { + "version": VERSION, + "N": int(N), + "sector": str(sector), + "realization": int(realization), + "panel_kind": str(panel_kind), + "draws": count, + "safe_identity_hash": safe["identity_hash"], + "safe_arrays_sha256": safe["arrays_sha256"], + "sources": _source_hashes(), + } + identity_hash = hashlib.sha256( + json.dumps(identity, sort_keys=True, separators=(",", ":")).encode() + ).hexdigest() + if not force and metadata_path.is_file() and arrays_path.is_file(): + metadata = json.loads(metadata_path.read_text(encoding="utf-8")) + if ( + metadata.get("identity") == identity + and metadata.get("identity_hash") == identity_hash + and metadata.get("arrays_sha256") == sha256(arrays_path) + and all(metadata.get("checks", {}).values()) + ): + return metadata + raise ValueError("null bank checkpoint identity mismatch") + with np.load(safe_arrays_path) as loaded: + copied = {key: np.asarray(loaded[key]) for key in loaded.files} + signature = _signature_from_safe(safe, copied) + collapsed = gaussian_r4_reference( + _positive_covariance_spectrum(copied["total_target_eigenvalues"]), + _positive_covariance_spectrum(copied["total_external_eigenvalues"]), + PANEL_SIZE, + count, + _derived_seed(N, sector, realization, panel_kind, "collapsed_bank"), + ) + hodge = hodge_gaussian_r4_reference( + signature, + PANEL_SIZE, + count, + _derived_seed(N, sector, realization, panel_kind, "hodge_bank"), + ) + _atomic_npz( + arrays_path, + collapsed_null=collapsed, + hodge_null=hodge, + ) + checks = { + "finite_collapsed_null": bool(np.all(np.isfinite(collapsed))), + "finite_hodge_null": bool(np.all(np.isfinite(hodge))), + "registered_draw_count": collapsed.shape == (count,) + and hodge.shape == (count,), + "safe_source_hash": safe["arrays_sha256"] == sha256(safe_arrays_path), + } + metadata = { + "identity": identity, + "identity_hash": identity_hash, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "draws": count, + "collapsed_sha256": _array_hash(collapsed), + "hodge_sha256": _array_hash(hodge), + "arrays_sha256": sha256(arrays_path), + "checks": checks, + "passed": all(checks.values()), + } + serialized = json.dumps(metadata, sort_keys=True).lower() + metadata["checks"]["no_outcome_leakage"] = not any( + token in serialized for token in FORBIDDEN_SAFE_TOKENS + ) + metadata["passed"] = all(metadata["checks"].values()) + if not metadata["passed"]: + raise RuntimeError(f"null bank audit failed: {metadata['checks']}") + _atomic_json(metadata_path, metadata) + return metadata + + +def _parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--N", type=int, required=True) + parser.add_argument("--sector", choices=REGISTERED_SECTORS, required=True) + parser.add_argument("--realization", type=int, required=True) + parser.add_argument("--panel-kind", choices=REGISTERED_PANEL_KINDS, required=True) + parser.add_argument("--draws", type=int, default=NULL_DRAWS_PER_REALIZATION) + parser.add_argument("--force", action="store_true") + return parser + + +def main() -> None: + args = _parser().parse_args() + payload = write_null_bank( + args.N, + args.sector, + args.realization, + args.panel_kind, + draws=args.draws, + force=args.force, + ) + print(json.dumps(payload, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_topological_holonomy_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_topological_holonomy_v3.py new file mode 100644 index 000000000..85c3ff5a1 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/run_topological_holonomy_v3.py @@ -0,0 +1,877 @@ +#!/usr/bin/env python3 +"""Run fixed-Chern isospectral Wilson-holonomy statistics.""" + +from __future__ import annotations + +import argparse +import concurrent.futures +import hashlib +import json +import platform +import time +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np + +from lgeth.bundle_geometry import ( + analyze_frame_bundle, + random_local_gauge, + sorted_wilson_eigenphases, +) +from lgeth.holonomy import ( + cue_wilson_reference, + deform_orbital_mesh, + wilson_statistics, +) +from lgeth.lattice import BosonBasis +from lgeth.twist_bundle import ( + default_checkpoint_path, + load_twist_bundle, +) + + +VERSION = "v3" +SCRIPT_ROOT = Path(__file__).resolve().parent +OUTPUT_ROOT = SCRIPT_ROOT / "output" +OUTPUT_JSON = OUTPUT_ROOT / "topological_holonomy_v3.json" +OUTPUT_NPZ = OUTPUT_ROOT / "topological_holonomy_v3.npz" +REGISTERED_SIZES = ((3, 8, 16), (4, 10, 25)) +REGISTERED_PRIMARY_MESH = 16 +REGISTERED_CONVERGENCE_MESH = 20 +REGISTERED_G = (0.0, 0.25, 0.5, 0.75, 1.0) +REGISTERED_GENERATOR_SEEDS = tuple(20260728400 + index for index in range(8)) +REGISTERED_COMMUTING_SEED = 20260728499 +REGISTERED_CUE_SAMPLES = 10_000 +REGISTERED_SEED = 20260728480 +REGISTERED_BOOTSTRAP_SAMPLES = 20_000 +MESH_ALIAS_AUDIT_JSON = ( + OUTPUT_ROOT / "topological_holonomy_mesh12_alias_audit_v3.json" +) +MESH_ALIAS_AUDIT_NPZ = ( + OUTPUT_ROOT / "topological_holonomy_mesh12_alias_audit_v3.npz" +) + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def _atomic_json(path: Path, payload: dict[str, Any]) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text( + json.dumps(payload, indent=2, sort_keys=True), + encoding="utf-8", + ) + temporary.replace(path) + + +def _atomic_npz(path: Path, **arrays: np.ndarray) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + with temporary.open("wb") as handle: + np.savez_compressed(handle, **arrays) + temporary.replace(path) + + +def _raw_bundle_arrays( + N: int, + mesh: int, +) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + metadata = default_checkpoint_path(N, mesh) + arrays_path = metadata.with_suffix(".npz") + with np.load(arrays_path, allow_pickle=False) as arrays: + return ( + np.asarray(arrays["energies"], dtype=float), + np.asarray(arrays["external_gap"], dtype=float), + np.asarray(arrays["coefficient_frames"], dtype=complex), + np.asarray(arrays["orbital_frames"], dtype=complex), + ) + + +def _geometry_record( + geometry, + k_values: np.ndarray, +) -> dict[str, Any]: + statistics = wilson_statistics(geometry, k_values=k_values) + return { + "chern_determinant": geometry.chern_determinant, + "chern_trace_log": geometry.chern_trace_log, + "branch_margin": geometry.determinant_branch_margin, + "minimum_overlap": geometry.minimum_overlap_singular_value, + "maximum_link_error": geometry.maximum_link_unitarity_error, + "maximum_plaquette_error": ( + geometry.maximum_plaquette_unitarity_error + ), + "gap_ratio": np.asarray(statistics["gap_ratio"]), + "mean_gap_ratio": float(statistics["mean_gap_ratio"]), + "form_factor": np.asarray(statistics["form_factor"]), + "mean_form_factor": np.asarray(statistics["mean_form_factor"]), + "determinant_phase_x": np.asarray( + statistics["determinant_phase_x"] + ), + "determinant_phase_y": np.asarray( + statistics["determinant_phase_y"] + ), + } + + +def _seed_worker(arguments: tuple[Any, ...]) -> dict[str, Any]: + ( + N, + n_flux, + rank, + primary_mesh, + convergence_mesh, + positive_g, + seed, + commuting, + ) = arguments + _, _, coefficients, orbitals = _raw_bundle_arrays(N, primary_mesh) + basis = BosonBasis(n_flux, N) + k_values = np.arange(1, rank + 1, dtype=int) + primary_records: list[dict[str, Any]] = [] + for coupling in positive_g: + deformed = deform_orbital_mesh( + orbitals, + g=float(coupling), + seed=int(seed), + commuting=bool(commuting), + ) + geometry = analyze_frame_bundle( + coefficients, + deformed, + basis, + ) + primary_records.append(_geometry_record(geometry, k_values)) + endpoint_record = None + if not commuting: + _, _, endpoint_coefficients, endpoint_orbitals = _raw_bundle_arrays( + N, + convergence_mesh, + ) + endpoint_deformed = deform_orbital_mesh( + endpoint_orbitals, + g=float(positive_g[-1]), + seed=int(seed), + commuting=False, + ) + endpoint_geometry = analyze_frame_bundle( + endpoint_coefficients, + endpoint_deformed, + basis, + ) + endpoint_record = _geometry_record( + endpoint_geometry, + k_values, + ) + return { + "N": int(N), + "seed": int(seed), + "commuting": bool(commuting), + "primary": primary_records, + "endpoint": endpoint_record, + } + + +def _run_workers( + arguments: list[tuple[Any, ...]], + workers: int, +) -> list[dict[str, Any]]: + if int(workers) <= 1: + return [_seed_worker(item) for item in arguments] + results: list[dict[str, Any]] = [] + with concurrent.futures.ProcessPoolExecutor( + max_workers=int(workers) + ) as executor: + futures = [executor.submit(_seed_worker, item) for item in arguments] + for future in concurrent.futures.as_completed(futures): + result = future.result() + results.append(result) + print( + f"completed N={result['N']} seed={result['seed']} " + f"commuting={result['commuting']}", + flush=True, + ) + return results + + +def _interval(values: np.ndarray) -> list[float]: + return np.quantile( + np.asarray(values, dtype=float), + [0.025, 0.5, 0.975], + ).tolist() + + +def _bootstrap_mean_interval( + values: np.ndarray, + seed: int, + samples: int = REGISTERED_BOOTSTRAP_SAMPLES, +) -> list[float]: + """Return a seed-cluster bootstrap interval for the mean.""" + + observations = np.asarray(values, dtype=float) + if observations.ndim != 1 or observations.size < 1: + raise ValueError("bootstrap values must be a nonempty vector") + if observations.size == 1: + value = float(observations[0]) + return [value, value, value] + rng = np.random.default_rng(int(seed)) + indices = rng.integers( + 0, + observations.size, + size=(int(samples), observations.size), + ) + means = np.mean(observations[indices], axis=1) + return np.quantile(means, [0.025, 0.5, 0.975]).tolist() + + +def _cue_simultaneous_band( + form_factor: np.ndarray, + stop: int, +) -> tuple[np.ndarray, np.ndarray, np.ndarray, float]: + """Build an empirical 95% simultaneous CUE band over ``k < stop``.""" + + values = np.asarray(form_factor, dtype=float) + if values.ndim != 2 or not 1 <= int(stop) <= values.shape[1]: + raise ValueError("invalid CUE form-factor window") + window = values[:, : int(stop)] + center = np.mean(window, axis=0) + scale = np.std(window, axis=0, ddof=1) + if np.any(scale <= 0.0): + raise RuntimeError("CUE reference has a singular pointwise scale") + maximum_standardized_deviation = np.max( + np.abs((window - center[None, :]) / scale[None, :]), + axis=1, + ) + critical = float( + np.quantile(maximum_standardized_deviation, 0.95) + ) + return ( + center, + center - critical * scale, + center + critical * scale, + critical, + ) + + +def _size_summary( + size: tuple[int, int, int], + primary_mesh: int, + convergence_mesh: int, + g_values: tuple[float, ...], + seeds: tuple[int, ...], + records: list[dict[str, Any]], + commuting_record: dict[str, Any], + cue_samples: int, + cue_seed: int, +) -> tuple[dict[str, Any], dict[str, np.ndarray]]: + N, n_flux, rank = size + primary_base = load_twist_bundle( + default_checkpoint_path(N, primary_mesh), + N, + n_flux, + rank, + primary_mesh, + ) + convergence_base = load_twist_bundle( + default_checkpoint_path(N, convergence_mesh), + N, + n_flux, + rank, + convergence_mesh, + ) + k_values = np.arange(1, rank + 1, dtype=int) + base_record = _geometry_record(primary_base.geometry, k_values) + convergence_base_record = _geometry_record( + convergence_base.geometry, + k_values, + ) + by_seed = { + int(record["seed"]): record + for record in records + if record["N"] == N and not record["commuting"] + } + if set(by_seed) != set(seeds): + raise RuntimeError(f"missing noncommuting records for N={N}") + positive_count = len(g_values) - 1 + gap_mean = np.empty((len(seeds), len(g_values)), dtype=float) + form_mean = np.empty( + (len(seeds), len(g_values), rank), + dtype=float, + ) + loop_count = 2 * primary_mesh + gap_loops = np.empty( + (len(seeds), len(g_values), loop_count), + dtype=float, + ) + form_loops = np.empty( + (len(seeds), len(g_values), loop_count, rank), + dtype=float, + ) + chern = np.empty((len(seeds), len(g_values)), dtype=float) + trace_chern = np.empty_like(chern) + branch_margin = np.empty_like(chern) + minimum_overlap = np.empty_like(chern) + endpoint_chern = np.empty(len(seeds), dtype=float) + endpoint_trace_chern = np.empty(len(seeds), dtype=float) + endpoint_branch_margin = np.empty(len(seeds), dtype=float) + endpoint_overlap = np.empty(len(seeds), dtype=float) + endpoint_gap_loops = np.empty( + (len(seeds), 2 * convergence_mesh), + dtype=float, + ) + endpoint_form_loops = np.empty( + (len(seeds), 2 * convergence_mesh, rank), + dtype=float, + ) + for seed_index, seed in enumerate(seeds): + gap_mean[seed_index, 0] = base_record["mean_gap_ratio"] + form_mean[seed_index, 0] = base_record["mean_form_factor"] + gap_loops[seed_index, 0] = base_record["gap_ratio"] + form_loops[seed_index, 0] = base_record["form_factor"] + chern[seed_index, 0] = base_record["chern_determinant"] + trace_chern[seed_index, 0] = base_record["chern_trace_log"] + branch_margin[seed_index, 0] = base_record["branch_margin"] + minimum_overlap[seed_index, 0] = base_record["minimum_overlap"] + record = by_seed[seed] + if len(record["primary"]) != positive_count: + raise RuntimeError("deformation grid is incomplete") + for offset, point in enumerate(record["primary"], start=1): + gap_mean[seed_index, offset] = point["mean_gap_ratio"] + form_mean[seed_index, offset] = point["mean_form_factor"] + gap_loops[seed_index, offset] = point["gap_ratio"] + form_loops[seed_index, offset] = point["form_factor"] + chern[seed_index, offset] = point["chern_determinant"] + trace_chern[seed_index, offset] = point["chern_trace_log"] + branch_margin[seed_index, offset] = point["branch_margin"] + minimum_overlap[seed_index, offset] = point["minimum_overlap"] + endpoint = record["endpoint"] + endpoint_chern[seed_index] = endpoint["chern_determinant"] + endpoint_trace_chern[seed_index] = endpoint["chern_trace_log"] + endpoint_branch_margin[seed_index] = endpoint["branch_margin"] + endpoint_overlap[seed_index] = endpoint["minimum_overlap"] + endpoint_gap_loops[seed_index] = endpoint["gap_ratio"] + endpoint_form_loops[seed_index] = endpoint["form_factor"] + commuting_gap = np.empty(len(g_values), dtype=float) + commuting_form = np.empty((len(g_values), rank), dtype=float) + commuting_chern = np.empty(len(g_values), dtype=float) + commuting_gap_loops = np.empty( + (len(g_values), loop_count), + dtype=float, + ) + commuting_form_loops = np.empty( + (len(g_values), loop_count, rank), + dtype=float, + ) + commuting_gap[0] = base_record["mean_gap_ratio"] + commuting_form[0] = base_record["mean_form_factor"] + commuting_chern[0] = base_record["chern_determinant"] + commuting_gap_loops[0] = base_record["gap_ratio"] + commuting_form_loops[0] = base_record["form_factor"] + for offset, point in enumerate( + commuting_record["primary"], + start=1, + ): + commuting_gap[offset] = point["mean_gap_ratio"] + commuting_form[offset] = point["mean_form_factor"] + commuting_chern[offset] = point["chern_determinant"] + commuting_gap_loops[offset] = point["gap_ratio"] + commuting_form_loops[offset] = point["form_factor"] + cue = cue_wilson_reference( + D=rank, + samples=int(cue_samples), + k_values=k_values, + seed=int(cue_seed), + ) + cue_gap_interval = _interval(cue["gap_ratio"]) + nonplateau_stop = max(2, rank // 2) + ( + cue_form_window_mean, + cue_form_simultaneous_lower, + cue_form_simultaneous_upper, + cue_form_simultaneous_critical, + ) = _cue_simultaneous_band( + cue["form_factor"], + stop=nonplateau_stop, + ) + cue_form_mean = np.mean(cue["form_factor"], axis=0) + gap_by_g = [ + _interval(gap_mean[:, index]) + for index in range(len(g_values)) + ] + form_by_g = np.median(form_mean, axis=0) + final_gap_compatible = ( + cue_gap_interval[0] + <= gap_by_g[-1][1] + <= cue_gap_interval[2] + ) + nonplateau = slice(0, max(2, rank // 2)) + final_form_compatible = bool(np.all( + ( + form_by_g[-1, :nonplateau_stop] + >= cue_form_simultaneous_lower + ) + & ( + form_by_g[-1, :nonplateau_stop] + <= cue_form_simultaneous_upper + ) + )) + base_residual = float( + np.sqrt( + np.mean( + ( + base_record["mean_form_factor"][nonplateau] + - cue_form_mean[nonplateau] + ) + ** 2 + ) + ) + ) + final_residual = np.sqrt( + np.mean( + ( + form_mean[:, -1, nonplateau] + - cue_form_mean[None, nonplateau] + ) + ** 2, + axis=1, + ) + ) + residual_improvement = base_residual - final_residual + gap_change = gap_mean[:, -1] - gap_mean[:, 0] + gap_change_interval = _bootstrap_mean_interval( + gap_change, + seed=cue_seed + 10_000, + ) + improvement_interval = _bootstrap_mean_interval( + residual_improvement, + seed=cue_seed + 20_000, + ) + change_significant = ( + gap_change_interval[0] > 0.0 + or gap_change_interval[2] < 0.0 + or improvement_interval[0] > 0.0 + or improvement_interval[2] < 0.0 + ) + base_integer = int(round(base_record["chern_determinant"])) + all_chern_values = np.concatenate( + [ + chern.ravel(), + endpoint_chern, + commuting_chern, + np.asarray( + [convergence_base_record["chern_determinant"]] + ), + ] + ) + summary = { + "N": N, + "n_flux": n_flux, + "rank": rank, + "primary_mesh": primary_mesh, + "convergence_mesh": convergence_mesh, + "base_chern_integer": base_integer, + "base_chern_primary": base_record["chern_determinant"], + "base_chern_convergence": convergence_base_record[ + "chern_determinant" + ], + "primary_chern_range": [ + float(np.min(chern)), + float(np.max(chern)), + ], + "convergence_endpoint_chern_range": [ + float(np.min(endpoint_chern)), + float(np.max(endpoint_chern)), + ], + "commuting_chern_range": [ + float(np.min(commuting_chern)), + float(np.max(commuting_chern)), + ], + "minimum_branch_margin": float( + min( + np.min(branch_margin), + np.min(endpoint_branch_margin), + base_record["branch_margin"], + convergence_base_record["branch_margin"], + ) + ), + "minimum_overlap_singular_value": float( + min( + np.min(minimum_overlap), + np.min(endpoint_overlap), + base_record["minimum_overlap"], + convergence_base_record["minimum_overlap"], + ) + ), + "maximum_determinant_trace_difference": float( + max( + np.max(np.abs(chern - trace_chern)), + np.max( + np.abs(endpoint_chern - endpoint_trace_chern) + ), + ) + ), + "maximum_energy_spectrum_error": 0.0, + "maximum_gap_error": 0.0, + "isospectrality_mode": ( + "exact_coordinate_identity_under_periodic_ambient_conjugation" + ), + "minimum_external_gap": float( + min( + np.min(primary_base.external_gap), + np.min(convergence_base.external_gap), + ) + ), + "gap_ratio_by_g": gap_by_g, + "base_gap_ratio": base_record["mean_gap_ratio"], + "final_gap_ratio_interval": gap_by_g[-1], + "cue_gap_ratio_interval": cue_gap_interval, + "gap_change_interval": gap_change_interval, + "base_form_factor_residual": base_residual, + "final_form_factor_residual_interval": _interval(final_residual), + "form_factor_improvement_interval": improvement_interval, + "cue_form_simultaneous_critical": ( + cue_form_simultaneous_critical + ), + "cue_nonplateau_stop": nonplateau_stop, + "cue_compatible_at_largest_g": ( + final_gap_compatible and final_form_compatible + ), + "holonomy_change_significant": bool(change_significant), + "all_chern_equal": bool( + np.max(np.abs(all_chern_values - base_integer)) < 1e-8 + ), + "determinant_phase_x_base": base_record[ + "determinant_phase_x" + ].tolist(), + "determinant_phase_x_final_seed0": by_seed[seeds[0]][ + "primary" + ][-1]["determinant_phase_x"].tolist(), + } + arrays = { + "gap_mean": gap_mean, + "form_mean": form_mean, + "gap_loops": gap_loops, + "form_loops": form_loops, + "chern": chern, + "trace_chern": trace_chern, + "branch_margin": branch_margin, + "minimum_overlap": minimum_overlap, + "endpoint_chern": endpoint_chern, + "endpoint_trace_chern": endpoint_trace_chern, + "endpoint_branch_margin": endpoint_branch_margin, + "endpoint_overlap": endpoint_overlap, + "endpoint_gap_loops": endpoint_gap_loops, + "endpoint_form_loops": endpoint_form_loops, + "commuting_gap": commuting_gap, + "commuting_form": commuting_form, + "commuting_chern": commuting_chern, + "commuting_gap_loops": commuting_gap_loops, + "commuting_form_loops": commuting_form_loops, + "cue_gap": cue["gap_ratio"], + "cue_form": cue["form_factor"], + "cue_form_simultaneous_mean": cue_form_window_mean, + "cue_form_simultaneous_lower": cue_form_simultaneous_lower, + "cue_form_simultaneous_upper": cue_form_simultaneous_upper, + "base_form": base_record["mean_form_factor"], + "base_determinant_phase_x": base_record[ + "determinant_phase_x" + ], + "final_determinant_phase_x": by_seed[seeds[0]][ + "primary" + ][-1]["determinant_phase_x"], + } + return summary, arrays + + +def _random_gauge_error( + size: tuple[int, int, int], + mesh: int, + g: float, + seed: int, +) -> dict[str, float]: + N, n_flux, rank = size + _, _, coefficients, orbitals = _raw_bundle_arrays(N, mesh) + deformed = deform_orbital_mesh( + orbitals, + g=float(g), + seed=int(seed), + commuting=False, + ) + basis = BosonBasis(n_flux, N) + original = analyze_frame_bundle(coefficients, deformed, basis) + transformed = analyze_frame_bundle( + random_local_gauge(coefficients, seed=seed + 50_000), + deformed, + basis, + ) + original_phases = sorted_wilson_eigenphases(original) + transformed_phases = sorted_wilson_eigenphases(transformed) + return { + "chern_error": abs( + original.chern_determinant + - transformed.chern_determinant + ), + "wilson_phase_error": float( + np.max( + np.abs( + np.exp(1j * original_phases) + - np.exp(1j * transformed_phases) + ) + ) + ), + } + + +def select_topology_branch(payload: dict[str, Any]) -> str: + """Select the preregistered topology/holonomy result branch.""" + + if not all(payload.get("checks", {}).values()): + return "topology_mesh_unresolved" + sizes = payload.get("sizes", []) + if sizes and all( + size["cue_compatible_at_largest_g"] for size in sizes + ): + return "fixed_chern_chaotic_holonomy" + if any(size["holonomy_change_significant"] for size in sizes): + return "fixed_chern_deformed_holonomy" + return "topology_without_holonomy_crossover" + + +def run( + output_json: Path = OUTPUT_JSON, + output_npz: Path = OUTPUT_NPZ, + sizes: tuple[tuple[int, int, int], ...] = REGISTERED_SIZES, + primary_mesh: int = REGISTERED_PRIMARY_MESH, + convergence_mesh: int = REGISTERED_CONVERGENCE_MESH, + g_values: tuple[float, ...] = REGISTERED_G, + generator_seeds: tuple[int, ...] = REGISTERED_GENERATOR_SEEDS, + cue_samples: int = REGISTERED_CUE_SAMPLES, + workers: int = 4, + production: bool = True, +) -> dict[str, Any]: + """Run the registered or reduced closed-surface calculation.""" + + started = time.perf_counter() + if ( + len(g_values) < 2 + or g_values[0] != 0.0 + or any(right <= left for left, right in zip(g_values, g_values[1:])) + ): + raise ValueError("g grid must be strictly increasing from zero") + positive_g = tuple(float(value) for value in g_values[1:]) + validated_checkpoints: dict[str, str] = {} + base_bundles = [] + for N, n_flux, rank in sizes: + for mesh in (primary_mesh, convergence_mesh): + path = default_checkpoint_path(N, mesh) + bundle = load_twist_bundle( + path, + N, + n_flux, + rank, + mesh, + ) + base_bundles.append(bundle) + validated_checkpoints[str(path.relative_to(SCRIPT_ROOT))] = ( + _sha256(path) + ) + arrays_path = path.with_suffix(".npz") + validated_checkpoints[ + str(arrays_path.relative_to(SCRIPT_ROOT)) + ] = _sha256(arrays_path) + worker_arguments: list[tuple[Any, ...]] = [] + for N, n_flux, rank in sizes: + for seed in generator_seeds: + worker_arguments.append( + ( + N, + n_flux, + rank, + primary_mesh, + convergence_mesh, + positive_g, + seed, + False, + ) + ) + worker_arguments.append( + ( + N, + n_flux, + rank, + primary_mesh, + convergence_mesh, + positive_g, + REGISTERED_COMMUTING_SEED, + True, + ) + ) + records = _run_workers(worker_arguments, workers=workers) + size_summaries: list[dict[str, Any]] = [] + size_arrays: list[dict[str, np.ndarray]] = [] + for size_index, size in enumerate(sizes): + commuting = next( + record + for record in records + if record["N"] == size[0] and record["commuting"] + ) + summary, arrays = _size_summary( + size=size, + primary_mesh=primary_mesh, + convergence_mesh=convergence_mesh, + g_values=g_values, + seeds=generator_seeds, + records=records, + commuting_record=commuting, + cue_samples=cue_samples, + cue_seed=REGISTERED_SEED + size_index, + ) + size_summaries.append(summary) + size_arrays.append(arrays) + gauge = _random_gauge_error( + sizes[0], + primary_mesh, + g_values[-1], + generator_seeds[0], + ) + checks = { + "kernel_count": all( + bundle.observed_rank_min + == bundle.observed_rank_max + == bundle.rank + for bundle in base_bundles + ), + "gap_open": all( + float(np.min(bundle.external_gap)) > 0.0 + for bundle in base_bundles + ), + "mesh_chern_integer": all( + size["all_chern_equal"] for size in size_summaries + ), + "mesh_chern_agreement": all( + abs( + size["base_chern_primary"] + - size["base_chern_convergence"] + ) + < 1e-8 + for size in size_summaries + ), + "determinant_trace_agreement": all( + size["maximum_determinant_trace_difference"] < 1e-8 + for size in size_summaries + ), + "branch_margin": all( + size["minimum_branch_margin"] > 0.0 + for size in size_summaries + ), + "overlap_floor": all( + size["minimum_overlap_singular_value"] > 5e-2 + for size in size_summaries + ), + "random_gauge_invariance": ( + gauge["chern_error"] < 1e-9 + and gauge["wilson_phase_error"] < 1e-8 + ), + "isospectral_orbit": all( + size["maximum_energy_spectrum_error"] < 1e-13 + and size["maximum_gap_error"] < 1e-13 + for size in size_summaries + ), + "cue_reference_count": int(cue_samples) >= 64, + } + payload: dict[str, Any] = { + "version": VERSION, + "generated_utc": datetime.now(timezone.utc).isoformat(), + "configuration": { + "sizes": [list(size) for size in sizes], + "primary_mesh": int(primary_mesh), + "convergence_mesh": int(convergence_mesh), + "g_values": list(g_values), + "generator_seeds": list(generator_seeds), + "commuting_seed": REGISTERED_COMMUTING_SEED, + "cue_samples": int(cue_samples), + "workers": int(workers), + "production": bool(production), + "mesh_upgrade_rationale": ( + "mesh12 aliases one N4 seed at g=1; mesh16 and mesh20 " + "are the accepted converged pair" + ), + }, + "sizes": size_summaries, + "random_gauge_errors": gauge, + "checks": checks, + "checkpoint_hashes": validated_checkpoints, + "mesh_alias_audit": { + "json": str(MESH_ALIAS_AUDIT_JSON.relative_to(SCRIPT_ROOT)), + "json_sha256": ( + _sha256(MESH_ALIAS_AUDIT_JSON) + if MESH_ALIAS_AUDIT_JSON.exists() + else None + ), + "npz": str(MESH_ALIAS_AUDIT_NPZ.relative_to(SCRIPT_ROOT)), + "npz_sha256": ( + _sha256(MESH_ALIAS_AUDIT_NPZ) + if MESH_ALIAS_AUDIT_NPZ.exists() + else None + ), + }, + "runtime_seconds": time.perf_counter() - started, + "environment": { + "python": platform.python_version(), + "numpy": np.__version__, + "platform": platform.platform(), + }, + } + payload["result_branch"] = select_topology_branch(payload) + output_arrays: dict[str, np.ndarray] = { + "g_values": np.asarray(g_values, dtype=float), + "generator_seeds": np.asarray(generator_seeds, dtype=np.int64), + } + for size_index, arrays in enumerate(size_arrays): + for key, values in arrays.items(): + output_arrays[f"size_{size_index}_{key}"] = np.asarray(values) + _atomic_npz(output_npz, **output_arrays) + payload["npz_sha256"] = _sha256(output_npz) + _atomic_json(output_json, payload) + if production and not all(checks.values()): + raise RuntimeError(f"production topology gates failed: {checks}") + return payload + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--reduced", action="store_true") + parser.add_argument("--workers", type=int, default=4) + arguments = parser.parse_args() + if arguments.reduced: + payload = run( + sizes=((3, 8, 16),), + primary_mesh=6, + convergence_mesh=8, + g_values=(0.0, 0.25), + generator_seeds=(20260728400,), + cue_samples=64, + workers=1, + production=False, + output_json=OUTPUT_ROOT / "topological_holonomy_reduced_v3.json", + output_npz=OUTPUT_ROOT / "topological_holonomy_reduced_v3.npz", + ) + else: + payload = run(workers=arguments.workers) + print(json.dumps( + { + "result_branch": payload["result_branch"], + "checks": payload["checks"], + "runtime_seconds": payload["runtime_seconds"], + }, + indent=2, + sort_keys=True, + )) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/run_susy_hodge_N14_null_v7_array.sbatch b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/run_susy_hodge_N14_null_v7_array.sbatch new file mode 100644 index 000000000..56a1e6a84 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/run_susy_hodge_N14_null_v7_array.sbatch @@ -0,0 +1,54 @@ +#!/bin/bash +#SBATCH --job-name=qgeom-susy-N14-null-v7 +#SBATCH --account=giggleliu +#SBATCH --partition=xhacnormalb +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --cpus-per-task=16 +#SBATCH --mem=32G +#SBATCH --time=48:00:00 +#SBATCH --output=logs/%x-%A_%a.out +#SBATCH --error=logs/%x-%A_%a.err + +set -euo pipefail +umask 0002 + +ARRAY_ID="${SLURM_ARRAY_TASK_ID:?submit with an N14 null array}" +WORKER_COUNT="${N14_NULL_WORKERS:-48}" +PROJECT_ROOT="${QGEOM_REMOTE_ROOT:-/work/share/giggleliu/Chaos-of-Quantum-Geometry}" + +if [[ "$WORKER_COUNT" -lt 1 || "$ARRAY_ID" -ge "$WORKER_COUNT" ]]; then + echo "invalid N14 null worker mapping" >&2 + exit 2 +fi + +export PATH="/public/software/apps/anaconda3/2023.09/bin:$PATH" +export LC_ALL=C +export LANG=C +export OMP_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export OPENBLAS_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export MKL_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export NUMEXPR_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export PYTHONPATH="$PROJECT_ROOT/01_task_folder/task_05/script" + +cd "$PROJECT_ROOT/01_task_folder/task_05/script" +mkdir -p logs output/susy_hodge_v7_null_banks + +for ((LOGICAL_ID=ARRAY_ID; LOGICAL_ID<48; LOGICAL_ID+=WORKER_COUNT)); do + SECTOR_INDEX=$((LOGICAL_ID / 24)) + REALIZATION=$((LOGICAL_ID % 24)) + case "$SECTOR_INDEX" in + 0) SECTOR="central" ;; + 1) SECTOR="adjacent" ;; + *) exit 2 ;; + esac + echo "logical_task=${LOGICAL_ID} N=14 sector=${SECTOR} realization=${REALIZATION}" + for PANEL_KIND in sparse isotropic; do + python3 -u run_susy_hodge_null_bank_v7.py \ + --N 14 \ + --sector "$SECTOR" \ + --realization "$REALIZATION" \ + --panel-kind "$PANEL_KIND" \ + --draws 128 + done +done diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/run_susy_hodge_N14_v7_array.sbatch b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/run_susy_hodge_N14_v7_array.sbatch new file mode 100644 index 000000000..b1daf8e61 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/run_susy_hodge_N14_v7_array.sbatch @@ -0,0 +1,61 @@ +#!/bin/bash +#SBATCH --job-name=qgeom-susy-N14-v7 +#SBATCH --account=giggleliu +#SBATCH --partition=xhacnormalb +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --cpus-per-task=16 +#SBATCH --mem=32G +#SBATCH --time=48:00:00 +#SBATCH --output=logs/%x-%A_%a.out +#SBATCH --error=logs/%x-%A_%a.err + +set -euo pipefail +umask 0002 + +ARRAY_ID="${SLURM_ARRAY_TASK_ID:?submit with an N14 response array}" +WORKER_COUNT="${N14_RESPONSE_WORKERS:-16}" +PROJECT_ROOT="${QGEOM_REMOTE_ROOT:-/work/share/giggleliu/Chaos-of-Quantum-Geometry}" + +if [[ "$WORKER_COUNT" -lt 1 || "$ARRAY_ID" -ge "$WORKER_COUNT" ]]; then + echo "invalid N14 response worker mapping" >&2 + exit 2 +fi + +export PATH="/public/software/apps/anaconda3/2023.09/bin:$PATH" +export LC_ALL=C +export LANG=C +export OMP_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export OPENBLAS_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export MKL_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export NUMEXPR_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export PYTHONPATH="$PROJECT_ROOT/01_task_folder/task_05/script" + +cd "$PROJECT_ROOT/01_task_folder/task_05/script" +mkdir -p logs output/susy_hodge_v7_checkpoints output/susy_hodge_v7_null_banks + +# Forty-eight realization jobs (24 per sector), quota-safely bundled into 16 +# workers. This stage writes responses only; null banks run independently. +for ((LOGICAL_ID=ARRAY_ID; LOGICAL_ID<48; LOGICAL_ID+=WORKER_COUNT)); do + SECTOR_INDEX=$((LOGICAL_ID / 24)) + REALIZATION=$((LOGICAL_ID % 24)) + case "$SECTOR_INDEX" in + 0) SECTOR="central" ;; + 1) SECTOR="adjacent" ;; + *) exit 2 ;; + esac + + echo "logical_task=${LOGICAL_ID} N=14 sector=${SECTOR} realization=${REALIZATION}" + python3 -u run_susy_hodge_geometric_eth_v7.py realization \ + --N 14 \ + --sector "$SECTOR" \ + --realization "$REALIZATION" + + for PANEL_KIND in sparse isotropic; do + python3 -u run_susy_hodge_geometric_eth_v7.py panel \ + --N 14 \ + --sector "$SECTOR" \ + --realization "$REALIZATION" \ + --panel-kind "$PANEL_KIND" + done +done diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/run_susy_hodge_pilot_v7_array.sbatch b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/run_susy_hodge_pilot_v7_array.sbatch new file mode 100644 index 000000000..80ff00964 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/run_susy_hodge_pilot_v7_array.sbatch @@ -0,0 +1,71 @@ +#!/bin/bash +#SBATCH --job-name=qgeom-susy-pilot-v7 +#SBATCH --account=giggleliu +#SBATCH --partition=xhacnormalb +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --cpus-per-task=8 +#SBATCH --mem=16G +#SBATCH --time=24:00:00 +#SBATCH --output=logs/%x-%A_%a.out +#SBATCH --error=logs/%x-%A_%a.err + +set -euo pipefail +umask 0002 + +ARRAY_ID="${SLURM_ARRAY_TASK_ID:?submit with --array=0-7}" +PROJECT_ROOT="${QGEOM_REMOTE_ROOT:-/work/share/giggleliu/Chaos-of-Quantum-Geometry}" + +export PATH="/public/software/apps/anaconda3/2023.09/bin:$PATH" +export LC_ALL=C +export LANG=C +export OMP_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export OPENBLAS_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export MKL_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export NUMEXPR_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export PYTHONPATH="$PROJECT_ROOT/01_task_folder/task_05/script" + +cd "$PROJECT_ROOT/01_task_folder/task_05/script" +mkdir -p logs output/susy_hodge_v7_checkpoints output/susy_hodge_v7_null_banks + +# The remote account is often close to its submitted-job cap. Preserve the +# registered 160 logical jobs but bundle them into eight quota-safe workers. +for ((TASK_ID=ARRAY_ID; TASK_ID<160; TASK_ID+=8)); do + if [[ "$TASK_ID" -lt 96 ]]; then + N=10 + COUNT=48 + LOCAL_ID="$TASK_ID" + else + N=12 + COUNT=32 + LOCAL_ID=$((TASK_ID - 96)) + fi + + SECTOR_INDEX=$((LOCAL_ID / COUNT)) + REALIZATION=$((LOCAL_ID % COUNT)) + case "$SECTOR_INDEX" in + 0) SECTOR="central" ;; + 1) SECTOR="adjacent" ;; + *) exit 2 ;; + esac + + echo "logical_task=${TASK_ID} N=${N} sector=${SECTOR} realization=${REALIZATION}" + python3 -u run_susy_hodge_geometric_eth_v7.py realization \ + --N "$N" \ + --sector "$SECTOR" \ + --realization "$REALIZATION" + + for PANEL_KIND in sparse isotropic; do + python3 -u run_susy_hodge_geometric_eth_v7.py panel \ + --N "$N" \ + --sector "$SECTOR" \ + --realization "$REALIZATION" \ + --panel-kind "$PANEL_KIND" + python3 -u run_susy_hodge_null_bank_v7.py \ + --N "$N" \ + --sector "$SECTOR" \ + --realization "$REALIZATION" \ + --panel-kind "$PANEL_KIND" \ + --draws 128 + done +done diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/seal_susy_hodge_N14_v7.sbatch b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/seal_susy_hodge_N14_v7.sbatch new file mode 100644 index 000000000..337b94056 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/seal_susy_hodge_N14_v7.sbatch @@ -0,0 +1,30 @@ +#!/bin/bash +#SBATCH --job-name=qgeom-susy-N14-seal-v7 +#SBATCH --account=giggleliu +#SBATCH --partition=xhacnormalb +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --cpus-per-task=8 +#SBATCH --mem=16G +#SBATCH --time=02:00:00 +#SBATCH --output=logs/%x-%j.out +#SBATCH --error=logs/%x-%j.err + +set -euo pipefail +umask 0002 + +PROJECT_ROOT="${QGEOM_REMOTE_ROOT:-/work/share/giggleliu/Chaos-of-Quantum-Geometry}" +export PATH="/public/software/apps/anaconda3/2023.09/bin:$PATH" +export LC_ALL=C +export LANG=C +export OMP_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export OPENBLAS_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export MKL_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export NUMEXPR_NUM_THREADS="${SLURM_CPUS_PER_TASK}" +export PYTHONPATH="$PROJECT_ROOT/01_task_folder/task_05/script" + +cd "$PROJECT_ROOT/01_task_folder/task_05/script" +mkdir -p logs output +python3 -u analyze_susy_hodge_geometric_eth_v7.py predict --null-replicates 2000 +sha256sum output/susy_hodge_v7_N14_prediction.json +echo "prediction sealed; stop here for independent inspection" diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/submit_susy_hodge_N14_v7.sh b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/submit_susy_hodge_N14_v7.sh new file mode 100644 index 000000000..5e106118c --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/submit_susy_hodge_N14_v7.sh @@ -0,0 +1,13 @@ +#!/bin/bash +set -euo pipefail + +mkdir -p logs +ARRAY_JOB=$(sbatch --parsable --array=0-15%8 run_susy_hodge_N14_v7_array.sbatch) +NULL_JOB=$(sbatch --parsable --dependency="afterok:${ARRAY_JOB}" --array=0-47%16 run_susy_hodge_N14_null_v7_array.sbatch) +SEAL_JOB=$(sbatch --parsable --dependency="afterok:${NULL_JOB}" seal_susy_hodge_N14_v7.sbatch) + +echo "N14_response_array_job=${ARRAY_JOB}" +echo "N14_null_array_job=${NULL_JOB}" +echo "N14_prediction_seal_job=${SEAL_JOB}" +echo "workflow stops after the prediction hash is printed" +echo "opening outcome sidecars requires a separate, explicit command" diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/submit_susy_hodge_pilot_v7.sh b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/submit_susy_hodge_pilot_v7.sh new file mode 100644 index 000000000..9bf16e4c6 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/slurm/submit_susy_hodge_pilot_v7.sh @@ -0,0 +1,9 @@ +#!/bin/bash +set -euo pipefail + +mkdir -p logs +ARRAY_JOB=$(sbatch --parsable --array=0-7%8 run_susy_hodge_pilot_v7_array.sbatch) + +echo "response_and_null_array_job=${ARRAY_JOB}" +echo "N10/N12 outcomes are sequential-pilot data; eight workers cover 160 registered logical jobs" +echo "aggregate only after the complete array passes" diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_bundle_geometry_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_bundle_geometry_v3.py new file mode 100644 index 000000000..af7cf45d5 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_bundle_geometry_v3.py @@ -0,0 +1,144 @@ +"""Tests for task-local closed-surface non-Abelian bundle geometry.""" + +from __future__ import annotations + +import numpy as np +import pytest +from scipy.linalg import expm + +from lgeth.bundle_geometry import ( + analyze_ambient_frame_mesh, + apply_bosonic_fock_lift, + manybody_frame_overlap, + polar_unitary, + random_local_gauge, + sorted_wilson_eigenphases, +) +from lgeth.lattice import BosonBasis + + +def _seeded_unitary(dimension: int, seed: int) -> np.ndarray: + rng = np.random.default_rng(seed) + matrix = rng.normal(size=(dimension, dimension)) + matrix = matrix + 1j * rng.normal(size=matrix.shape) + unitary, _ = np.linalg.qr(matrix) + return unitary + + +def _qiwuzhang_lower_band_mesh(mesh: int, mass: float) -> np.ndarray: + frames = np.empty((mesh, mesh, 2, 1), dtype=complex) + momenta = 2.0 * np.pi * np.arange(mesh) / mesh + for ix, kx in enumerate(momenta): + for iy, ky in enumerate(momenta): + hamiltonian = np.array( + [ + [ + mass + np.cos(kx) + np.cos(ky), + np.sin(kx) - 1j * np.sin(ky), + ], + [ + np.sin(kx) + 1j * np.sin(ky), + -mass - np.cos(kx) - np.cos(ky), + ], + ], + dtype=complex, + ) + _, vectors = np.linalg.eigh(hamiltonian) + frames[ix, iy, :, 0] = vectors[:, 0] + return frames + + +def _synthetic_rank_three_bundle(mesh: int) -> np.ndarray: + rng = np.random.default_rng(5) + generators = [] + for _ in range(2): + matrix = rng.normal(size=(6, 6)) + matrix = matrix + 1j * rng.normal(size=matrix.shape) + matrix = 0.5 * (matrix + matrix.conj().T) + generators.append(matrix / np.linalg.norm(matrix)) + base = _seeded_unitary(6, seed=6)[:, :3] + frames = np.empty((mesh, mesh, 6, 3), dtype=complex) + angles = 2 * np.pi * np.arange(mesh) / mesh + for ix, theta_x in enumerate(angles): + for iy, theta_y in enumerate(angles): + unitary = expm(0.4j * np.sin(theta_x) * generators[0]) + unitary = unitary @ expm( + 0.3j * np.sin(theta_y) * generators[1] + ) + frames[ix, iy] = unitary @ base + return frames + + +def test_one_particle_fock_lift_equals_single_particle_overlap() -> None: + basis = BosonBasis(n_orbitals=4, n_particles=1) + overlap = _seeded_unitary(4, seed=1) + frames = np.eye(4, dtype=complex) + basis_to_orbital = np.zeros((4, 4), dtype=complex) + for basis_index, state in enumerate(basis.states): + basis_to_orbital[state.index(1), basis_index] = 1.0 + np.testing.assert_allclose( + apply_bosonic_fock_lift(basis, overlap, frames), + basis_to_orbital.conj().T @ overlap @ basis_to_orbital, + atol=1e-12, + ) + + +def test_identity_orbital_overlap_reduces_to_coefficient_overlap() -> None: + basis = BosonBasis(n_orbitals=4, n_particles=2) + left = _seeded_unitary(basis.dimension, seed=2)[:, :3] + right = _seeded_unitary(basis.dimension, seed=3)[:, :3] + orbitals = _seeded_unitary(6, seed=4)[:, :4] + observed = manybody_frame_overlap( + basis, + left, + right, + orbitals, + orbitals, + ) + np.testing.assert_allclose( + observed, + left.conj().T @ right, + atol=1e-12, + ) + + +def test_polar_link_is_unitary_and_retains_singular_values() -> None: + rng = np.random.default_rng(7) + matrix = rng.normal(size=(6, 6)) + matrix = matrix + 1j * rng.normal(size=matrix.shape) + unitary, values = polar_unitary(matrix) + np.testing.assert_allclose( + unitary.conj().T @ unitary, + np.eye(6), + atol=1e-12, + ) + np.testing.assert_allclose( + values, + np.linalg.svd(matrix, compute_uv=False), + ) + + +def test_rank_one_qwz_bundle_has_unit_chern_number() -> None: + frames = _qiwuzhang_lower_band_mesh(mesh=20, mass=-1.0) + result = analyze_ambient_frame_mesh(frames) + assert abs(round(result.chern_determinant)) == 1 + assert abs( + result.chern_determinant - result.chern_trace_log + ) < 1e-10 + + +def test_bundle_outputs_are_invariant_under_local_ud_gauges() -> None: + bundle = _synthetic_rank_three_bundle(mesh=5) + original = analyze_ambient_frame_mesh(bundle) + transformed = analyze_ambient_frame_mesh( + random_local_gauge(bundle, seed=8) + ) + assert transformed.chern_determinant == pytest.approx( + original.chern_determinant, + abs=1e-10, + ) + np.testing.assert_allclose( + np.exp(1j * sorted_wilson_eigenphases(transformed)), + np.exp(1j * sorted_wilson_eigenphases(original)), + atol=1e-9, + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_controls_v2.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_controls_v2.py new file mode 100644 index 000000000..b1a2e8dd7 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_controls_v2.py @@ -0,0 +1,109 @@ +"""Causal-control tests for spectral and geometric chaos channels.""" + +from __future__ import annotations + +import numpy as np + +from lgeth.channels import ( + build_physical_channel_cache, + cached_channel, +) +from lgeth.controls import ( + fixed_projector_spectral_ensemble, + fourier_tangent_pairs, + scrambled_tangent_pair, +) +from lgeth.jacobi import normalized_curvature + + +def test_fourier_pairs_cover_all_nonzero_momenta_without_fake_phase_samples(): + pairs = fourier_tangent_pairs(5) + assert len(pairs) == 24 + assert {(pair.kx, pair.ky) for pair in pairs} == { + (kx, ky) + for ky in range(5) + for kx in range(5) + if (kx, ky) != (0, 0) + } + assert len({pair.orbit_key for pair in pairs}) == 12 + assert all(abs(pair.v.mean()) < 1e-14 for pair in pairs) + assert all(abs(pair.w.mean()) < 1e-14 for pair in pairs) + assert all(abs(np.linalg.norm(pair.v) - 1.0) < 1e-14 for pair in pairs) + assert all(abs(np.linalg.norm(pair.w) - 1.0) < 1e-14 for pair in pairs) + + +def test_scrambling_endpoints_are_exact(): + pair = fourier_tangent_pairs(5)[0] + random_v = np.arange(25.0) - 12.0 + random_w = np.roll(random_v, 3) + gram = np.eye(25) + v0, w0 = scrambled_tangent_pair( + pair, + random_v, + random_w, + 0.0, + gram, + ) + v1, w1 = scrambled_tangent_pair( + pair, + random_v, + random_w, + 1.0, + gram, + ) + centered_v = random_v - random_v.mean() + centered_w = random_w - random_w.mean() + assert abs(abs(v0 @ pair.v) - 1.0) < 1e-12 + assert abs(abs(w0 @ pair.w) - 1.0) < 1e-12 + assert ( + abs( + abs(v1 @ centered_v) + / np.linalg.norm(centered_v) + - 1.0 + ) + < 1e-12 + ) + assert ( + abs( + abs(w1 @ centered_w) + / np.linalg.norm(centered_w) + - 1.0 + ) + < 1e-12 + ) + + +def test_fixed_projector_changes_energy_not_geometry(): + control = fixed_projector_spectral_ensemble( + dimension=50, + samples=256, + alphas=np.array([0.0, 1.0]), + seed=19, + reference_curvature_spectrum=np.linspace(-0.9, 0.9, 50), + ) + assert ( + control.mean_gap_ratio[-1] + > control.mean_gap_ratio[0] + 0.12 + ) + assert np.max(control.projector_distance) < 1e-13 + assert np.max(control.curvature_spectrum_error) < 1e-14 + assert control.energy_spectra.shape == (2, 256, 50) + + +def test_physical_fourier_controls_are_full_rank_but_multiplet_structured(): + cache = build_physical_channel_cache() + unique_counts = [] + for pair in fourier_tangent_pairs(5): + channel_v = cached_channel(pair.v, cache) + channel_w = cached_channel(pair.w, cache) + normalized = normalized_curvature( + channel_v, + channel_w, + rtol=1e-10, + ) + spectrum = np.linalg.eigvalsh(normalized.omega) + assert normalized.rank == cache.rank == 50 + unique_counts.append( + np.unique(np.round(spectrum, 10)).size + ) + assert max(unique_counts) <= 10 diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_covariance_model_runner.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_covariance_model_runner.py new file mode 100644 index 000000000..8485f896d --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_covariance_model_runner.py @@ -0,0 +1,41 @@ +from __future__ import annotations + +import importlib +from pathlib import Path + +import numpy as np + + +physical_runner = importlib.import_module("run_physical_ensemble_v1") +covariance_runner = importlib.import_module("run_covariance_model_v1") + + +def test_reduced_covariance_model_uses_strict_splits(tmp_path: Path) -> None: + physical_npz = tmp_path / "physical.npz" + physical_runner.run( + tmp_path / "physical.json", + physical_npz, + samples=96, + seed_blocks=8, + ) + result = covariance_runner.run( + physical_npz, + tmp_path / "covariance.json", + tmp_path / "covariance.npz", + diagnostic_rows=32, + model_samples=32, + ) + assert result["all_checks_pass"] + assert result["diagnostic_training_rows"] == 32 + assert result["haar_samples"] == 32 + assert result["deformed_samples"] == 32 + assert len(result["validation_scores"]) == 5 + with np.load(tmp_path / "covariance.npz") as arrays: + assert arrays["haar_spectra"].shape == (32, 50) + assert arrays["deformed_spectra"].shape == (32, 50) + train = arrays["diagnostic_indices"] + validation = arrays["validation_indices"] + test = arrays["test_indices"] + assert np.intersect1d(train, validation).size == 0 + assert np.intersect1d(train, test).size == 0 + assert np.intersect1d(validation, test).size == 0 diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_form_factors_v2.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_form_factors_v2.py new file mode 100644 index 000000000..08690264a --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_form_factors_v2.py @@ -0,0 +1,152 @@ +"""Analytic and empirical form-factor tests for the v2 expansion.""" + +from __future__ import annotations + +import numpy as np +import pytest + +from lgeth.form_factors import ( + atom_raw_decomposition, + degenerate_energy_form_factor, + finite_jacobi_form_factor, + form_factor_parts, +) +from lgeth.jacobi import sample_jacobi_compression +from lgeth.statistics import unfold_spectra + + +def test_exact_degenerate_energy_is_raw_constant_and_connected_zero(): + times = np.linspace(0.0, 4.0, 41) + parts = degenerate_energy_form_factor(50, times) + assert np.allclose(parts.raw, 50.0, atol=1e-14) + assert np.allclose(parts.disconnected, 50.0, atol=1e-14) + assert np.allclose(parts.connected, 0.0, atol=1e-14) + assert parts.normalization == 50 + + +def test_form_factor_decomposition_closes(): + spectra = np.array( + [ + [-1.0, 0.2, 0.9], + [-0.8, 0.0, 1.1], + [-0.7, 0.1, 0.8], + ] + ) + parts = form_factor_parts( + spectra, + np.linspace(0.0, 2.0, 9), + phase_scale=2.0 * np.pi, + ) + assert np.allclose( + parts.raw, + parts.disconnected + parts.connected, + atol=1e-14, + ) + assert np.all(parts.connected >= -1e-14) + + +def test_form_factor_rejects_invalid_inputs(): + times = np.linspace(0.0, 1.0, 5) + for invalid in ( + np.ones(5), + np.ones((0, 4)), + np.ones((3, 0)), + np.array([[0.0, np.nan]]), + ): + try: + form_factor_parts(invalid, times) + except ValueError: + pass + else: + raise AssertionError("invalid spectra were accepted") + + +def test_finite_jacobi_connected_starts_at_zero_and_reaches_plateau(): + result = finite_jacobi_form_factor( + 16, + 80, + np.array([0.0, 4.0]), + quadrature_order=256, + ) + assert abs(result.connected_continuous[0]) < 2e-10 + assert result.connected_continuous[-1] > 0.95 + assert result.plateau_full == pytest.approx(1.0) + + +def test_boundary_atoms_suppress_full_connected_plateau_exactly(): + result = finite_jacobi_form_factor( + 800, + 680, + np.array([0.0, 4.0]), + quadrature_order=768, + ) + assert result.interior_dimension == 560 + assert result.atom_count_each == 120 + assert np.allclose( + result.connected_full, + (560.0 / 800.0) * result.connected_continuous, + atol=2e-10, + ) + assert result.plateau_full == pytest.approx(0.7) + + +def test_raw_atom_decomposition_closes(): + decomposition = atom_raw_decomposition( + np.array([[-0.4, 0.3], [-0.2, 0.6]]), + minus_atoms=1, + plus_atoms=1, + times=np.linspace(0.0, 2.0, 17), + ) + assert np.allclose( + decomposition["full"], + decomposition["atom_atom"] + + decomposition["atom_continuum"] + + decomposition["continuum_continuum"], + atol=1e-14, + ) + + +def test_finite_jacobi_curve_matches_independent_monte_carlo(): + times = np.linspace(0.25, 2.5, 46) + spectra = sample_jacobi_compression( + r=16, + M=80, + samples=1500, + seed=20260728191, + ) + empirical = form_factor_parts( + unfold_spectra(spectra, "ensemble_cdf"), + times, + ).connected + analytic = finite_jacobi_form_factor( + 16, + 80, + times, + quadrature_order=256, + ).connected_continuous + assert np.max(np.abs(empirical - analytic)) < 0.075 + + +def test_rank50_quadrature_is_stable_on_registered_time_window(): + times = np.linspace(0.0, 3.0, 61) + first = finite_jacobi_form_factor( + 50, + 170, + times, + quadrature_order=384, + ) + second = finite_jacobi_form_factor( + 50, + 170, + times, + quadrature_order=512, + ) + assert ( + np.max( + np.abs( + first.connected_continuous + - second.connected_continuous + ) + ) + < 5e-5 + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_geometric_eth_topology_article_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_geometric_eth_topology_article_v3.py new file mode 100644 index 000000000..47c8e4639 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_geometric_eth_topology_article_v3.py @@ -0,0 +1,34 @@ +"""Delivery tests for the integrated v3 article.""" + +from __future__ import annotations + +import json + +from verify_geometric_eth_topology_article_v3 import ( + AUDIT_JSON, + FINAL_PDF, +) + + +def test_final_article_audit_passes() -> None: + audit = json.loads(AUDIT_JSON.read_text(encoding="utf-8")) + assert audit["passed"] is True + assert all(audit["checks"].values()) + assert audit["matrix_branch"] == "deformed_geometric_eth" + assert audit["topology_branch"] == "fixed_chern_deformed_holonomy" + assert audit["page_count"] == 17 + assert audit["main_pdf_sha256"] == audit["archived_pdf_sha256"] + assert FINAL_PDF.exists() + + +def test_delivery_audit_links_all_seven_figures() -> None: + audit = json.loads(AUDIT_JSON.read_text(encoding="utf-8")) + assert len(audit["figures"]) == 7 + assert all(item["exists"] for item in audit["figures"]) + assert all(item["source_hash_matches"] for item in audit["figures"]) + + +def test_delivery_audit_records_every_rendered_page() -> None: + audit = json.loads(AUDIT_JSON.read_text(encoding="utf-8")) + assert len(audit["rendered_pages"]) == audit["page_count"] + assert all(item["sha256"] for item in audit["rendered_pages"]) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_geometric_eth_topology_assets_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_geometric_eth_topology_assets_v3.py new file mode 100644 index 000000000..5d8a7219b --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_geometric_eth_topology_assets_v3.py @@ -0,0 +1,73 @@ +"""Tests for generated v3 manuscript assets.""" + +from __future__ import annotations + +import hashlib +import json +import re +from pathlib import Path + +import pytest + + +SCRIPT_ROOT = Path(__file__).resolve().parents[1] +OUTPUT = SCRIPT_ROOT / "output" +NUMBERS = OUTPUT / "generated_numbers_v3.tex" +TABLES = OUTPUT / "generated_tables_v3.tex" +MANIFEST = OUTPUT / "geometric_eth_topology_assets_v3.json" + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def _macros() -> dict[str, str]: + pattern = re.compile(r"\\newcommand\{\\([^}]+)\}\{(.*)\}") + result: dict[str, str] = {} + for line in NUMBERS.read_text(encoding="utf-8").splitlines(): + match = pattern.fullmatch(line) + if match: + result[match.group(1)] = match.group(2) + return result + + +def test_generated_macros_match_raw_v3_results() -> None: + matrix = json.loads( + (OUTPUT / "matrix_element_geometric_eth_v3.json").read_text() + ) + topology = json.loads( + (OUTPUT / "topological_holonomy_v3.json").read_text() + ) + macros = _macros() + assert float(macros["LargestNRFour"]) == pytest.approx( + matrix["cases"][-1]["physical_R4_median"], + abs=5e-6, + ) + assert int(macros["TopologyNFourChern"]) == topology["sizes"][-1][ + "base_chern_integer" + ] + assert macros["MatrixElementBranch"].replace(r"\_", "_") == matrix[ + "result_branch" + ] + assert macros["TopologyBranch"].replace(r"\_", "_") == topology[ + "result_branch" + ] + + +def test_generated_tables_contain_all_registered_rows() -> None: + text = TABLES.read_text(encoding="utf-8") + assert "3 & 8 & 16 & 120" in text + assert "5 & 12 & 36 & 4368" in text + assert "4 & 25 & 10" in text + + +def test_asset_manifest_hashes_all_outputs() -> None: + manifest = json.loads(MANIFEST.read_text(encoding="utf-8")) + assert manifest["output_hashes"]["output/generated_numbers_v3.tex"] == _sha256( + NUMBERS + ) + assert manifest["output_hashes"]["output/generated_tables_v3.tex"] == _sha256( + TABLES + ) + assert manifest["matrix_branch"] == "deformed_geometric_eth" + assert manifest["topology_branch"] == "fixed_chern_deformed_holonomy" diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_hodge_response_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_hodge_response_v7.py new file mode 100644 index 000000000..a68de084d --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_hodge_response_v7.py @@ -0,0 +1,277 @@ +"""Exact/coexact response identities for the N=2 SYK BPS fiber.""" + +from __future__ import annotations + +import numpy as np + +from lgeth.hodge_response import ( + HodgeResponse, + coupling_panels, + decomposable_curvature, + external_covariance_eigenvalues_scalable, + hodge_response, + hodge_signature, + project_moduli_tangents, + projector_derivative_from_response, + scalable_covariance_matched_wick, +) +from lgeth.susy_cohomology import ( + analytic_decomposable_curvature_multiplicities, + cubic_triples, + decomposable_couplings, + decomposable_tangent, + normalized_complex_couplings, + solve_bps_frame, +) +from lgeth.wick_channels import ( + covariance_matched_wick, + external_covariance_eigenvalues, +) + + +def _generic_tangent(N: int, seed: int) -> np.ndarray: + rng = np.random.default_rng(seed) + tangent = rng.normal(size=len(cubic_triples(N))) + 1j * rng.normal( + size=len(cubic_triples(N)) + ) + return tangent / np.linalg.norm(tangent) + + +def test_hodge_branches_are_orthogonal_and_equal_direct_resolvent() -> None: + couplings = normalized_complex_couplings(6, seed=29) + frame = solve_bps_frame(6, 3, couplings, dense_cutoff=64) + tangent = _generic_tangent(6, seed=31) + result = hodge_response(frame, couplings, tangent[None, :]) + cross = result.minus[0].conj().T @ result.plus[0] + scale = np.linalg.norm(result.minus[0]) * np.linalg.norm(result.plus[0]) + assert np.linalg.norm(cross) / scale < 2e-12 + assert np.allclose(result.total, result.minus + result.plus, atol=2e-12) + assert np.allclose(result.total, result.direct, atol=2e-11) + assert result.branch_sum_relative_error < 2e-13 + assert result.direct_relative_error < 2e-11 + assert result.orthogonality_relative_error < 2e-12 + assert result.target_leakage < 2e-12 + assert all(result.checks.values()) + + +def test_response_reproduces_centered_projector_derivative() -> None: + couplings = normalized_complex_couplings(6, seed=37) + frame = solve_bps_frame(6, 3, couplings, dense_cutoff=64) + tangent = _generic_tangent(6, seed=41) + response = hodge_response(frame, couplings, tangent[None, :]) + analytic = projector_derivative_from_response( + frame.projector_frame, + response.total[0], + ) + errors: list[float] = [] + for step in (2e-4, 1e-4): + plus = solve_bps_frame( + 6, + 3, + couplings + step * tangent, + dense_cutoff=64, + ).projector_frame + minus = solve_bps_frame( + 6, + 3, + couplings - step * tangent, + dense_cutoff=64, + ).projector_frame + finite = ( + plus @ plus.conj().T - minus @ minus.conj().T + ) / (2.0 * step) + errors.append(float(np.linalg.norm(finite - analytic) / np.linalg.norm(analytic))) + assert errors[1] < 2e-6 + assert errors[0] / errors[1] > 3.5 + + +def test_multiple_tangents_preserve_shapes_and_linearity() -> None: + couplings = normalized_complex_couplings(6, seed=43) + frame = solve_bps_frame(6, 2, couplings, dense_cutoff=64) + first = _generic_tangent(6, seed=47) + second = _generic_tangent(6, seed=53) + combined = hodge_response( + frame, + couplings, + np.stack([first, second, first + 2.0 * second]), + ) + assert combined.total.shape == (3, 15, 9) + assert np.allclose( + combined.total[2], + combined.total[0] + 2.0 * combined.total[1], + atol=3e-11, + ) + + +def test_registered_panels_remove_radial_phase_and_have_full_support() -> None: + couplings = normalized_complex_couplings(8, seed=59) + panels = coupling_panels(couplings, panel_size=8, seed=61) + assert set(panels) == {"sparse", "isotropic"} + assert not np.allclose(panels["sparse"], panels["isotropic"]) + for values in panels.values(): + assert values.shape == (8, 56) + assert np.max(np.abs(values @ couplings.conj())) < 2e-13 + assert np.allclose( + values @ values.conj().T, + np.eye(8), + atol=2e-13, + ) + + +def test_moduli_projection_rejects_rank_deficient_candidates() -> None: + couplings = normalized_complex_couplings(8, seed=67) + candidate = np.zeros(56, dtype=complex) + candidate[0] = 1.0 + with np.testing.assert_raises_regex(ValueError, "full rank"): + project_moduli_tangents( + couplings, + np.stack([candidate, candidate]), + ) + + +def _synthetic_response(minus: np.ndarray, plus: np.ndarray) -> HodgeResponse: + total = minus + plus + return HodgeResponse( + minus=minus, + plus=plus, + total=total, + direct=total.copy(), + branch_sum_relative_error=0.0, + direct_relative_error=0.0, + orthogonality_relative_error=0.0, + target_leakage=0.0, + checks={"synthetic": True}, + ) + + +def test_hodge_signature_resolves_one_sided_and_balanced_limits() -> None: + rng = np.random.default_rng(71) + minus = rng.normal(size=(8, 12, 5)) + 1j * rng.normal(size=(8, 12, 5)) + zero = np.zeros_like(minus) + one_sided = hodge_signature(_synthetic_response(minus, zero)) + assert one_sided.hodge_balance == 0.0 + assert one_sided.minus_weight > 0.0 + assert one_sided.plus_weight == 0.0 + balanced = hodge_signature(_synthetic_response(minus, minus.copy())) + assert abs(balanced.hodge_balance - 1.0) < 2e-14 + + +def test_hodge_signature_is_gauge_invariant() -> None: + couplings = normalized_complex_couplings(6, seed=73) + frame = solve_bps_frame(6, 3, couplings, dense_cutoff=64) + panels = coupling_panels(couplings, panel_size=8, seed=79) + response = hodge_response(frame, couplings, panels["isotropic"]) + reference = hodge_signature(response) + rng = np.random.default_rng(83) + ambient, _ = np.linalg.qr( + rng.normal(size=(20, 20)) + 1j * rng.normal(size=(20, 20)) + ) + target, _ = np.linalg.qr( + rng.normal(size=(18, 18)) + 1j * rng.normal(size=(18, 18)) + ) + rotated_minus = np.einsum( + "ij,mjk,kl->mil", + ambient, + response.minus, + target, + optimize=True, + ) + rotated_plus = np.einsum( + "ij,mjk,kl->mil", + ambient, + response.plus, + target, + optimize=True, + ) + rotated = hodge_signature(_synthetic_response(rotated_minus, rotated_plus)) + assert np.isclose(reference.hodge_balance, rotated.hodge_balance, atol=1e-13) + assert np.allclose( + reference.minus_target_eigenvalues, + rotated.minus_target_eigenvalues, + atol=2e-12, + ) + assert np.allclose( + reference.plus_external_eigenvalues, + rotated.plus_external_eigenvalues, + atol=2e-12, + ) + assert np.allclose( + reference.minus_channel_covariance, + rotated.minus_channel_covariance, + atol=2e-12, + ) + + +def test_scalable_external_spectrum_and_statistic_match_immutable_code() -> None: + rng = np.random.default_rng(89) + # ambient=7 is much smaller than labels*rank=40, exercising the N=14 path. + channels = rng.normal(size=(8, 7, 5)) + 1j * rng.normal(size=(8, 7, 5)) + reference_spectrum = external_covariance_eigenvalues(channels) + scalable_spectrum = external_covariance_eigenvalues_scalable(channels) + assert np.allclose(reference_spectrum, scalable_spectrum, atol=2e-12) + reference = covariance_matched_wick(channels) + scalable = scalable_covariance_matched_wick(channels) + assert np.isclose(reference.R4, scalable.R4, atol=2e-13) + assert np.isclose(reference.A_left, scalable.A_left, atol=2e-13) + assert np.isclose(reference.B_right, scalable.B_right, atol=2e-13) + assert np.allclose(reference.tensor, scalable.tensor, atol=2e-13) + assert np.allclose( + reference.right_eigenvalues, + scalable.right_eigenvalues, + atol=2e-12, + ) + + +def _assert_atomic_spectrum( + matrix: np.ndarray, + alpha: float, + multiplicities: dict[str, int], +) -> None: + eigenvalues = np.linalg.eigvalsh(0.5 * (matrix + matrix.conj().T)) + target = 1.0 / alpha**2 + assert np.count_nonzero(np.isclose(eigenvalues, -target, atol=2e-11)) == ( + multiplicities["negative"] + ) + assert np.count_nonzero(np.isclose(eigenvalues, 0.0, atol=2e-11)) == ( + multiplicities["zero"] + ) + assert np.count_nonzero(np.isclose(eigenvalues, target, atol=2e-11)) == ( + multiplicities["positive"] + ) + + +def test_decomposable_diagonal_curvature_recovers_exact_atoms() -> None: + alpha = 1.7 + couplings = decomposable_couplings(6, alpha) + frame = solve_bps_frame(6, 3, couplings, dense_cutoff=64) + tangent = decomposable_tangent(6, "12", 3) + response = hodge_response(frame, couplings, tangent[None, :]) + curvature = decomposable_curvature(response, 0) + _assert_atomic_spectrum( + curvature, + alpha, + analytic_decomposable_curvature_multiplicities(6, 3, "diagonal"), + ) + + +def test_decomposable_off_diagonal_curvature_recovers_exact_atoms() -> None: + alpha = 1.7 + couplings = decomposable_couplings(6, alpha) + frame = solve_bps_frame(6, 3, couplings, dense_cutoff=64) + tangents = np.stack( + [ + decomposable_tangent(6, "12", 3), + decomposable_tangent(6, "13", 4), + ] + ) + response = hodge_response(frame, couplings, tangents) + curvature = decomposable_curvature(response, 0, 1) + _assert_atomic_spectrum( + curvature, + alpha, + analytic_decomposable_curvature_multiplicities( + 6, + 3, + "off_diagonal", + ), + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_hodge_wick_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_hodge_wick_v7.py new file mode 100644 index 000000000..9dddd9436 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_hodge_wick_v7.py @@ -0,0 +1,132 @@ +"""Finite-size Gaussian nulls conditioned on safe Hodge signatures.""" + +from __future__ import annotations + +from dataclasses import replace + +import numpy as np + +from lgeth.hodge_response import HodgeSignature +from lgeth.hodge_wick import ( + complete_realization_null, + hodge_gaussian_r4_reference, + sample_hodge_gaussian_channels, +) +from lgeth.wick_channels import gaussian_r4_reference + + +def _signature(minus_weight: float, plus_weight: float) -> HodgeSignature: + minus_target = np.asarray([0.42, 0.27, 0.18, 0.09, 0.04]) + plus_target = np.asarray([0.36, 0.25, 0.20, 0.12, 0.07]) + minus_external = np.asarray([0.51, 0.31, 0.18]) + plus_external = np.asarray([0.40, 0.28, 0.20, 0.12]) + total = minus_weight + plus_weight + balance = 0.0 if total == 0 else 4.0 * minus_weight * plus_weight / total**2 + return HodgeSignature( + channel_count=8, + target_rank=5, + minus_weight=minus_weight, + plus_weight=plus_weight, + hodge_balance=balance, + minus_channel_covariance=np.eye(8), + plus_channel_covariance=np.eye(8), + minus_target_eigenvalues=minus_target, + plus_target_eigenvalues=plus_target, + minus_external_eigenvalues=minus_external, + plus_external_eigenvalues=plus_external, + minus_target_effective_rank=3.5, + plus_target_effective_rank=4.0, + minus_external_effective_rank=2.5, + plus_external_effective_rank=3.2, + minus_target_entropy=0.8, + plus_target_entropy=0.9, + minus_external_entropy=0.8, + plus_external_entropy=0.9, + orthogonality_relative_error=0.0, + ) + + +def test_one_sided_hodge_reference_is_exact_existing_regression() -> None: + signature = _signature(1.0, 0.0) + observed = hodge_gaussian_r4_reference(signature, 8, 32, 89) + expected = gaussian_r4_reference( + signature.minus_target_eigenvalues, + signature.minus_external_eigenvalues, + 8, + 32, + 89, + ) + assert np.array_equal(observed, expected) + + +def test_two_sided_sampler_has_direct_sum_shape_and_is_deterministic() -> None: + signature = _signature(0.4, 0.6) + first = sample_hodge_gaussian_channels( + signature, + 8, + np.random.default_rng(97), + ) + second = sample_hodge_gaussian_channels( + signature, + 8, + np.random.default_rng(97), + ) + assert first.shape == (8, 7, 5) + assert np.array_equal(first, second) + assert np.all(np.isfinite(first.real)) + assert np.all(np.isfinite(first.imag)) + + +def test_common_branch_weight_rescaling_does_not_change_null_draws() -> None: + signature = _signature(0.4, 0.6) + scaled = replace(signature, minus_weight=4.0, plus_weight=6.0) + first = sample_hodge_gaussian_channels( + signature, + 8, + np.random.default_rng(101), + ) + second = sample_hodge_gaussian_channels( + scaled, + 8, + np.random.default_rng(101), + ) + assert np.array_equal(first, second) + + +def test_branch_channel_covariance_changes_two_sided_null_draw() -> None: + signature = _signature(0.4, 0.6) + covariance = np.full((8, 8), 0.15, dtype=complex) + np.fill_diagonal(covariance, 1.0) + correlated = replace(signature, plus_channel_covariance=covariance) + first = sample_hodge_gaussian_channels( + signature, + 8, + np.random.default_rng(102), + ) + second = sample_hodge_gaussian_channels( + correlated, + 8, + np.random.default_rng(102), + ) + assert not np.allclose(first, second) + + +def test_hodge_r4_and_complete_realization_nulls_are_reproducible() -> None: + first_signature = _signature(0.45, 0.55) + second_signature = _signature(0.30, 0.70) + first = hodge_gaussian_r4_reference(first_signature, 8, 24, 103) + second = hodge_gaussian_r4_reference(first_signature, 8, 24, 103) + assert np.array_equal(first, second) + assert np.all(np.isfinite(first)) + aggregate_first = complete_realization_null( + [first_signature, second_signature], + samples=20, + seed=107, + ) + aggregate_second = complete_realization_null( + [first_signature, second_signature], + samples=20, + seed=107, + ) + assert aggregate_first.shape == (20,) + assert np.array_equal(aggregate_first, aggregate_second) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_holonomy_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_holonomy_v3.py new file mode 100644 index 000000000..b4debe0d2 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_holonomy_v3.py @@ -0,0 +1,132 @@ +"""Tests for periodic isospectral holonomy deformations and CUE statistics.""" + +from __future__ import annotations + +import numpy as np +import pytest + +from lgeth.bundle_geometry import analyze_frame_bundle +from lgeth.holonomy import ( + ambient_unitary, + cue_wilson_reference, + deform_orbital_mesh, + local_generator_pair, + wilson_statistics, +) +from lgeth.lattice import BosonBasis +from lgeth.twist_bundle import build_twist_bundle + + +def _nearest_neighbor_support_only( + matrix: np.ndarray, + length: int, +) -> bool: + sites = length * length + for left in range(sites): + lx, ly = left % length, left // length + for right in range(sites): + if left == right or abs(matrix[left, right]) < 1e-12: + continue + rx, ry = right % length, right // length + dx = min(abs(lx - rx), length - abs(lx - rx)) + dy = min(abs(ly - ry), length - abs(ly - ry)) + if dx + dy != 1: + return False + return True + + +def test_generator_pair_is_hermitian_local_and_noncommuting() -> None: + gx, gy = local_generator_pair(length=4, seed=41, commuting=False) + np.testing.assert_allclose(gx, gx.conj().T) + np.testing.assert_allclose(gy, gy.conj().T) + assert _nearest_neighbor_support_only(gx, length=4) + assert _nearest_neighbor_support_only(gy, length=4) + assert np.linalg.norm(gx @ gy - gy @ gx) > 1e-3 + + +def test_commuting_control_generators_commute() -> None: + gx, gy = local_generator_pair(length=4, seed=42, commuting=True) + assert np.linalg.norm(gx @ gy - gy @ gx) < 1e-14 + + +def test_ambient_unitary_is_periodic_and_unitary() -> None: + generators = local_generator_pair(4, seed=41, commuting=False) + first = ambient_unitary(0.2, 0.7, 0.8, generators) + wrapped = ambient_unitary( + 0.2 + 2 * np.pi, + 0.7 - 2 * np.pi, + 0.8, + generators, + ) + np.testing.assert_allclose(first, wrapped, atol=1e-12) + np.testing.assert_allclose( + first.conj().T @ first, + np.eye(first.shape[0]), + atol=1e-12, + ) + + +def test_periodic_orbit_preserves_gap_and_chern() -> None: + bundle = build_twist_bundle(N=3, n_flux=8, rank=16, mesh=6) + deformed_orbitals = deform_orbital_mesh( + bundle.orbital_frames, + g=0.7, + seed=43, + commuting=False, + ) + geometry = analyze_frame_bundle( + bundle.coefficient_frames, + deformed_orbitals, + BosonBasis(bundle.n_flux, bundle.N), + ) + assert geometry.chern_determinant == pytest.approx( + bundle.geometry.chern_determinant, + abs=1e-9, + ) + assert np.min(bundle.external_gap) > 0.0 + + +def test_wilson_statistics_are_common_phase_invariant() -> None: + bundle = build_twist_bundle(N=3, n_flux=8, rank=16, mesh=3) + original = wilson_statistics(bundle.geometry) + shifted_geometry = bundle.geometry + shifted_x = np.exp(0.37j) * shifted_geometry.wilson_x + shifted_y = np.exp(-0.29j) * shifted_geometry.wilson_y + shifted = wilson_statistics( + shifted_geometry, + wilson_x=shifted_x, + wilson_y=shifted_y, + ) + np.testing.assert_allclose( + shifted["gap_ratio"], + original["gap_ratio"], + atol=1e-12, + ) + np.testing.assert_allclose( + shifted["form_factor"], + original["form_factor"], + atol=1e-10, + ) + + +def test_cue_reference_is_seed_reproducible() -> None: + first = cue_wilson_reference( + D=8, + samples=64, + k_values=np.arange(1, 9), + seed=51, + ) + second = cue_wilson_reference( + D=8, + samples=64, + k_values=np.arange(1, 9), + seed=51, + ) + np.testing.assert_array_equal( + first["gap_ratio"], + second["gap_ratio"], + ) + np.testing.assert_array_equal( + first["form_factor"], + second["form_factor"], + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_independent_core.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_independent_core.py new file mode 100644 index 000000000..fbf2917b6 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_independent_core.py @@ -0,0 +1,65 @@ +from __future__ import annotations + +import ast +from pathlib import Path + +import numpy as np + +from lgeth.combinatorics import laughlin_zero_mode_count +from lgeth.jacobi import ( + haar_row_isometry, + jacobi_parameters, + normalized_curvature, + sample_jacobi_interior, +) +from lgeth.channels import root_response_partition + + +SCRIPT_ROOT = Path(__file__).resolve().parents[1] + + +def test_task05_imports_are_isolated() -> None: + for source in SCRIPT_ROOT.rglob("*.py"): + tree = ast.parse(source.read_text(encoding="utf-8")) + for node in ast.walk(tree): + if isinstance(node, ast.Import): + modules = [alias.name for alias in node.names] + elif isinstance(node, ast.ImportFrom): + modules = [node.module or ""] + else: + continue + assert all("task_04" not in module for module in modules) + assert all("gaccess" not in module for module in modules) + + +def test_registered_rank_and_external_dimension() -> None: + assert laughlin_zero_mode_count(3, 20) == 800 + partition = root_response_partition(3, 20) + assert len(partition.zero_modes) == 800 + assert len(partition.descendant_external) == 680 + + +def test_atom_multiplicity_and_interior_labels() -> None: + parameters = jacobi_parameters(800, 680) + assert parameters.plus_atoms == 120 + assert parameters.minus_atoms == 120 + assert parameters.interior_dimension == 560 + interior, labels = sample_jacobi_interior(8, 6, 3, 2026072801) + assert interior.shape == (3, 4) + assert labels.shape == (3, 8) + assert np.all(labels.sum(axis=1) == 4) + + +def test_whitening_isometry_identity() -> None: + rng = np.random.default_rng(2026072802) + rows = haar_row_isometry(8, 20, rng) + channel_v = rows[:, :10] + channel_w = rows[:, 10:] + normalized = normalized_curvature(channel_v, channel_w) + assert normalized.rank == 8 + np.testing.assert_allclose( + normalized.Y @ normalized.Y.conj().T, + np.eye(8), + atol=1e-10, + rtol=0.0, + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_large_scale_delivery.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_large_scale_delivery.py new file mode 100644 index 000000000..faaf0bbc0 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_large_scale_delivery.py @@ -0,0 +1,34 @@ +from __future__ import annotations + +import importlib +from pathlib import Path + +import pytest + + +verifier = importlib.import_module("verify_large_scale_article_v1") +EXTERNAL_PHYSICAL = ( + Path(__file__).resolve().parents[1] + / "output" + / "physical_ensemble_v1.npz" +) + + +@pytest.mark.skipif( + not EXTERNAL_PHYSICAL.exists(), + reason=( + "activates with production arrays listed in release_manifest_v1.json" + ), +) +def test_registered_delivery_gates_pass(tmp_path: Path) -> None: + audit = verifier.run(tmp_path / "audit.json") + assert audit["all_checks_pass"] + assert audit["registered_scale"] == { + "physical_matrices": 20_000, + "haar_matrices": 10_000, + "deformed_matrices": 10_000, + "root_matrices": 8_750, + "maximum_rank": 800, + } + assert audit["pdf"]["pages"] == 10 + assert len(audit["rendered_pages"]) == 10 diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_large_scale_figures.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_large_scale_figures.py new file mode 100644 index 000000000..9c86eee95 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_large_scale_figures.py @@ -0,0 +1,35 @@ +from __future__ import annotations + +import json +from pathlib import Path + +from PIL import Image +from pypdf import PdfReader + + +def test_registered_figure_package() -> None: + output = Path(__file__).resolve().parents[1] / "output" + manifest = json.loads( + (output / "figure_manifest_v1.json").read_text(encoding="utf-8") + ) + assert manifest["atom_annotations"] == { + "D546_each_boundary": 6, + "D800_each_boundary": 120, + "D800_total_weight": 0.30, + } + assert len(manifest["inputs"]) == 7 + for figure in manifest["figures"].values(): + pdf = Path(figure["pdf"]) + png = Path(figure["png"]) + reader = PdfReader(str(pdf)) + width = float(reader.pages[0].mediabox.width) / 72.0 + assert abs(width - 7.0) < 0.01 + with Image.open(png) as image: + assert image.width >= 2100 + assert image.info["dpi"][0] >= 299.0 + numbers = (output / "generated_numbers_v1.tex").read_text( + encoding="utf-8" + ) + assert r"\newcommand{\LargestRank}{800}" in numbers + assert r"\newcommand{\LargestAtomMultiplicity}{120}" in numbers + assert r"\newcommand{\BootstrapReplicates}{10000}" in numbers diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_large_scale_statistics.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_large_scale_statistics.py new file mode 100644 index 000000000..2855f6e59 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_large_scale_statistics.py @@ -0,0 +1,59 @@ +from __future__ import annotations + +import numpy as np + +from lgeth.statistics import ( + connected_form_factor, + fit_size_models, + matrix_bootstrap_band, + sample_gue_spectra, + sample_poisson_spectra, + spectral_rigidity, + unfold_spectra, +) + + +def test_simultaneous_band_contract() -> None: + rng = np.random.default_rng(20260728700) + curves = rng.normal(size=(40, 12)) + band = matrix_bootstrap_band(curves, 500, 20260728701) + assert band.mean.shape == (12,) + assert np.all(band.lower <= band.mean) + assert np.all(band.mean <= band.upper) + assert band.critical_value > 1.0 + groups = np.repeat(np.arange(8), 5) + hierarchical = matrix_bootstrap_band( + curves, + 500, + 20260728702, + groups=groups, + ) + assert hierarchical.units == 8 + assert hierarchical.method == "hierarchical_seed_block_bootstrap" + + +def test_gue_is_more_rigid_than_poisson() -> None: + poisson = unfold_spectra( + sample_poisson_spectra(240, 60, 20260728703), + "ensemble_cdf", + ) + gue = unfold_spectra( + sample_gue_spectra(240, 60, 20260728704), + "ensemble_cdf", + ) + lengths = (1.0, 2.0, 3.0, 4.0) + poisson_rigidity = spectral_rigidity(poisson, lengths) + gue_rigidity = spectral_rigidity(gue, lengths) + assert poisson_rigidity[-1] > gue_rigidity[-1] + form = connected_form_factor(gue, (0.0, 0.2, 0.5, 1.0)) + assert abs(form[0]) < 1e-12 + assert np.all(np.isfinite(form)) + + +def test_finite_size_model_selection_recovers_half_power() -> None: + D = np.asarray([16, 32, 64, 128, 256, 512, 1024], dtype=float) + values = 0.02 + 1.5 * D ** -0.5 + sigma = np.full_like(D, 0.003) + fits = fit_size_models(D, values, sigma) + assert fits["best_by_loo"] in {"D^-1/2", "free"} + assert abs(fits["models"]["free"]["exponent"] - 0.5) < 0.05 diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_manybody_response_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_manybody_response_v3.py new file mode 100644 index 000000000..66c6814dc --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_manybody_response_v3.py @@ -0,0 +1,136 @@ +"""Tests for the genuine particle-number response backend.""" + +from __future__ import annotations + +import numpy as np +import pytest + +from lgeth.lattice import build_kapit_laughlin_parent +from lgeth.manybody_response import ( + ManyBodyCase, + audit_unregistered_small_case, + build_site_response_cache, + dense_resolvent_response, + registered_fixed_two_qh_cases, + response_pair_grams, + rotate_response_target_gauge, + solve_kernel_frame, +) + + +def _seeded_unitary(dimension: int, seed: int) -> np.ndarray: + rng = np.random.default_rng(seed) + matrix = rng.normal(size=(dimension, dimension)) + matrix = matrix + 1j * rng.normal(size=matrix.shape) + unitary, _ = np.linalg.qr(matrix) + return unitary + + +def test_registered_sequence_is_fixed_two_quasiholes() -> None: + cases = registered_fixed_two_qh_cases() + assert [ + (case.N, case.n_flux, case.expected_rank) + for case in cases + ] == [(3, 8, 16), (4, 10, 25), (5, 12, 36)] + assert all(case.n_flux == 2 * case.N + 2 for case in cases) + + +def test_n2_physical_parent_is_rejected_by_counting_gate() -> None: + audit = audit_unregistered_small_case( + N=2, + n_flux=6, + theta_x=0.17, + theta_y=0.29, + ) + assert audit.expected_rank == 9 + assert audit.observed_rank == 12 + assert audit.accepted is False + + +@pytest.mark.parametrize( + ("N", "n_flux", "rank"), + [(3, 8, 16), (4, 10, 25)], +) +def test_dense_kernel_has_registered_rank_and_open_gap( + N: int, + n_flux: int, + rank: int, +) -> None: + case = ManyBodyCase(N, n_flux, rank, 0.17, 0.29) + system = build_kapit_laughlin_parent( + N, + n_flux, + case.theta_x, + case.theta_y, + ) + kernel = solve_kernel_frame(system, case, seed=20260728301) + assert kernel.frame.shape == (system.basis.dimension, rank) + assert kernel.external_gap > 0.0 + assert kernel.residual_norm < 1e-10 + assert kernel.orthonormality_error < 1e-11 + assert kernel.method == "dense" + + +def test_richardson_response_matches_dense_spectral_inverse() -> None: + case = registered_fixed_two_qh_cases()[0] + system = build_kapit_laughlin_parent( + case.N, + case.n_flux, + case.theta_x, + case.theta_y, + ) + kernel = solve_kernel_frame(system, case, seed=20260728302) + cache = build_site_response_cache( + system, + kernel, + relative_shifts=(1e-3, 5e-4), + site_indices=(0, 3), + ) + exact = dense_resolvent_response( + system, + kernel, + site_indices=(0, 3), + ) + relative = np.linalg.norm(cache.solutions - exact) / np.linalg.norm(exact) + assert relative < 2e-4 + assert cache.maximum_relative_residual < 2e-4 + assert cache.maximum_kernel_leakage < 1e-10 + + +def test_kernel_rotation_does_not_change_site_response_grams() -> None: + case = registered_fixed_two_qh_cases()[0] + system = build_kapit_laughlin_parent( + case.N, + case.n_flux, + case.theta_x, + case.theta_y, + ) + kernel = solve_kernel_frame(system, case, seed=20260728303) + cache = build_site_response_cache( + system, + kernel, + relative_shifts=(1e-3, 5e-4), + site_indices=(0, 1, 2), + ) + unitary = _seeded_unitary(case.expected_rank, seed=11) + rotated = rotate_response_target_gauge(cache, unitary) + original_grams = response_pair_grams(cache.solutions) + rotated_grams = response_pair_grams(rotated.solutions) + original_invariant = np.einsum( + "stij,uvji->stuv", + original_grams, + original_grams, + optimize=True, + ) + rotated_invariant = np.einsum( + "stij,uvji->stuv", + rotated_grams, + rotated_grams, + optimize=True, + ) + np.testing.assert_allclose( + original_invariant, + rotated_invariant, + atol=2e-9, + rtol=2e-9, + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_matrix_element_geometric_eth_delivery_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_matrix_element_geometric_eth_delivery_v3.py new file mode 100644 index 000000000..fd8cfaaf2 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_matrix_element_geometric_eth_delivery_v3.py @@ -0,0 +1,40 @@ +"""Fail-closed delivery tests for the matrix-element extension.""" + +from __future__ import annotations + +import copy +import json +from pathlib import Path + +import pytest + +from run_matrix_element_geometric_eth_v3 import OUTPUT_JSON +from verify_matrix_element_geometric_eth_v3 import ( + AUDIT_JSON, + audit_payload, +) + + +def test_matrix_element_delivery_audit_passes_all_gates() -> None: + audit = json.loads(AUDIT_JSON.read_text(encoding="utf-8")) + assert audit["passed"] is True + assert all(audit["checks"].values()) + assert audit["result_branch"] == "deformed_geometric_eth" + assert audit["registered_cases"] == [[3, 8, 16], [4, 10, 25], [5, 12, 36]] + + +def test_audit_rejects_branch_metric_mismatch() -> None: + payload = json.loads(OUTPUT_JSON.read_text(encoding="utf-8")) + corrupted = copy.deepcopy(payload) + corrupted["result_branch"] = "wick_compatible_trend" + corrupted["cases"][-1]["physical_R4_median"] = 100.0 + with pytest.raises(AssertionError): + audit_payload(corrupted) + + +def test_audit_records_figure_and_checkpoint_hashes() -> None: + audit = json.loads(AUDIT_JSON.read_text(encoding="utf-8")) + assert len(audit["checkpoint_hashes"]) == 6 + assert audit["figure"]["pdf_sha256"] + assert audit["figure"]["png_sha256"] + assert Path(audit["figure"]["pdf"]).name == "figure_6_wick_factorization_v3.pdf" diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_matrix_element_geometric_eth_figure_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_matrix_element_geometric_eth_figure_v3.py new file mode 100644 index 000000000..4583b90fa --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_matrix_element_geometric_eth_figure_v3.py @@ -0,0 +1,47 @@ +"""Publication-asset tests for the matrix-element Geometric-ETH figure.""" + +from __future__ import annotations + +import hashlib +import json +from pathlib import Path + +from PIL import Image + + +SCRIPT_ROOT = Path(__file__).resolve().parents[1] +OUTPUT = SCRIPT_ROOT / "output" +ARTIFACT_JSON = OUTPUT / "matrix_element_geometric_eth_v3.json" +MANIFEST = OUTPUT / "figure_manifest_v3.json" +FIGURE_PNG = OUTPUT / "figure_6_wick_factorization_v3.png" +FIGURE_PDF = OUTPUT / "figure_6_wick_factorization_v3.pdf" + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def test_figure_6_has_registered_dimensions_and_source_hash() -> None: + manifest = json.loads(MANIFEST.read_text(encoding="utf-8")) + figure = manifest["figure_6_wick_factorization_v3"] + assert figure["width_inches"] == 7.0 + assert figure["png_width_pixels"] == 2100 + assert figure["source_sha256"] == _sha256(ARTIFACT_JSON) + assert figure["pdf_sha256"] == _sha256(FIGURE_PDF) + assert figure["png_sha256"] == _sha256(FIGURE_PNG) + with Image.open(FIGURE_PNG) as image: + assert image.width == 2100 + assert image.height >= 1450 + + +def test_figure_6_manifest_records_result_branch() -> None: + artifact = json.loads(ARTIFACT_JSON.read_text(encoding="utf-8")) + manifest = json.loads(MANIFEST.read_text(encoding="utf-8")) + figure = manifest["figure_6_wick_factorization_v3"] + assert figure["result_branch"] == artifact["result_branch"] + assert figure["panels"] == [ + "genuine_manybody_sequence", + "four_channel_residual", + "non_gaussian_excess", + "covariance_geometry", + ] diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_matrix_element_geometric_eth_runner_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_matrix_element_geometric_eth_runner_v3.py new file mode 100644 index 000000000..737636f51 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_matrix_element_geometric_eth_runner_v3.py @@ -0,0 +1,91 @@ +"""Runner tests for the matrix-element Geometric-ETH production artifact.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import numpy as np +import pytest + +from run_matrix_element_geometric_eth_v3 import ( + OUTPUT_JSON, + run, + select_result_branch, +) + + +def test_reduced_runner_emits_all_gate_families(tmp_path: Path) -> None: + result = run( + output_json=tmp_path / "result.json", + output_npz=tmp_path / "result.npz", + checkpoint_dir=tmp_path / "checkpoints", + case_indices=(0,), + panels=3, + gaussian_samples=32, + production=False, + ) + assert set(result["checks"]) >= { + "kernel_count", + "external_gap", + "resolvent_residual", + "channel_support", + "gauge_invariance", + "reference_reproducibility", + } + assert result["configuration"]["panel_size"] == 8 + assert result["cases"][0]["N"] == 3 + assert result["cases"][0]["rank"] == 16 + assert result["result_branch"] in { + "wick_compatible_trend", + "deformed_geometric_eth", + "no_matrix_element_eth_trend", + "manybody_sequence_incomplete", + } + + +def test_reduced_runner_reuses_hash_identical_checkpoint( + tmp_path: Path, +) -> None: + arguments = { + "output_json": tmp_path / "first.json", + "output_npz": tmp_path / "first.npz", + "checkpoint_dir": tmp_path / "checkpoints", + "case_indices": (0,), + "panels": 2, + "gaussian_samples": 8, + "production": False, + } + first = run(**arguments) + arguments["output_json"] = tmp_path / "second.json" + arguments["output_npz"] = tmp_path / "second.npz" + second = run(**arguments) + assert first["cases"][0]["checkpoint_reused"] is False + assert second["cases"][0]["checkpoint_reused"] is True + np.testing.assert_allclose( + first["cases"][0]["physical_R4"], + second["cases"][0]["physical_R4"], + ) + + +@pytest.mark.skipif( + not OUTPUT_JSON.exists(), + reason="production artifact has not been generated", +) +def test_production_artifact_uses_true_particle_number_sequence() -> None: + payload = json.loads(OUTPUT_JSON.read_text(encoding="utf-8")) + assert [row["N"] for row in payload["cases"]] == [3, 4, 5] + assert [row["rank"] for row in payload["cases"]] == [16, 25, 36] + assert all( + row["n_flux"] == 2 * row["N"] + 2 + for row in payload["cases"] + ) + + +@pytest.mark.skipif( + not OUTPUT_JSON.exists(), + reason="production artifact has not been generated", +) +def test_claim_branch_is_recomputed_from_raw_metrics() -> None: + payload = json.loads(OUTPUT_JSON.read_text(encoding="utf-8")) + assert payload["result_branch"] == select_result_branch(payload) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_matrix_element_topology_theory_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_matrix_element_topology_theory_v3.py new file mode 100644 index 000000000..ecd7a8148 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_matrix_element_topology_theory_v3.py @@ -0,0 +1,27 @@ +"""Executable theory tests for the v3 manuscript derivations.""" + +from __future__ import annotations + +from verify_matrix_element_topology_theory_v3 import ( + gauge_and_gram_check, + periodic_unitary_chern_check, + wick_identity_check, +) + + +def test_wick_coefficients_match_direct_monte_carlo() -> None: + result = wick_identity_check(samples=8_000) + assert result["relative_error"] < 0.065 + + +def test_gauge_invariance_and_gram_reduction() -> None: + result = gauge_and_gram_check() + assert result["R4_error"] < 1e-10 + assert result["tensor_error"] < 1e-10 + assert result["gram_spectrum_error"] < 1e-10 + + +def test_periodic_unitary_orbit_keeps_synthetic_chern() -> None: + result = periodic_unitary_chern_check(mesh=20) + assert result["chern_error"] < 1e-10 + assert result["minimum_branch_margin"] > 0.0 diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_physical_ensemble_runner.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_physical_ensemble_runner.py new file mode 100644 index 000000000..4e790aa14 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_physical_ensemble_runner.py @@ -0,0 +1,38 @@ +from __future__ import annotations + +import importlib +from pathlib import Path + +import numpy as np + + +runner = importlib.import_module("run_physical_ensemble_v1") + + +def test_reduced_physical_run_is_deterministic(tmp_path: Path) -> None: + first_json = tmp_path / "first.json" + first_npz = tmp_path / "first.npz" + second_json = tmp_path / "second.json" + second_npz = tmp_path / "second.npz" + first = runner.run(first_json, first_npz, samples=96, seed_blocks=8) + second = runner.run(second_json, second_npz, samples=96, seed_blocks=8) + assert first["split"] == { + "train": 60, + "validation": 18, + "test": 18, + "split_seed": runner.REGISTERED_SEED + 1, + } + assert first["all_checks_pass"] and second["all_checks_pass"] + with np.load(first_npz) as left, np.load(second_npz) as right: + np.testing.assert_array_equal( + left["normalized_spectra"], right["normalized_spectra"] + ) + assert left["normalized_spectra"].shape == (96, 50) + assert np.all(left["active_ranks"] == 50) + assert np.unique(left["seed_block"]).size == 8 + train = left["train_indices"] + validation = left["validation_indices"] + test = left["test_indices"] + assert np.intersect1d(train, validation).size == 0 + assert np.intersect1d(train, test).size == 0 + assert np.intersect1d(validation, test).size == 0 diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_rank_scaling_runner.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_rank_scaling_runner.py new file mode 100644 index 000000000..9d517747a --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_rank_scaling_runner.py @@ -0,0 +1,59 @@ +from __future__ import annotations + +import importlib +from pathlib import Path + +import numpy as np + +from lgeth.jacobi import sample_jacobi_wishart + + +runner = importlib.import_module("run_rank_scaling_v1") + + +def test_qr_curvature_matches_metric_normalization() -> None: + from lgeth.jacobi import normalized_curvature + + rng = np.random.default_rng(20260728500) + first = rng.normal(size=(7, 9)) + second = rng.normal(size=(7, 9)) + _, qr_spectrum, _ = runner.qr_normalized_curvature(first, second) + direct = normalized_curvature(first, second) + np.testing.assert_allclose( + qr_spectrum, + np.linalg.eigvalsh(direct.omega), + atol=1e-10, + rtol=0.0, + ) + + +def test_exact_wishart_jacobi_atoms() -> None: + full, interior, labels = sample_jacobi_wishart( + 8, 6, 4, 20260728501 + ) + assert full.shape == (4, 8) + assert interior.shape == (4, 4) + assert np.all(full[:, :2] == -1.0) + assert np.all(full[:, -2:] == 1.0) + assert np.all(labels.sum(axis=1) == 4) + + +def test_reduced_runner_and_explicit_resource_rejection( + tmp_path: Path, +) -> None: + result = runner.run( + tmp_path / "scaling.json", + tmp_path / "scaling.npz", + cases=((8, 4),), + ) + assert result["all_checks_pass"] + assert result["cases"][0]["D"] == 16 + assert result["cases"][0]["M"] == 80 + rejected = runner.run( + tmp_path / "rejected.json", + tmp_path / "rejected.npz", + cases=((20, 4),), + response_entry_ceiling=100, + ) + assert rejected["all_checks_pass"] + assert rejected["cases"][0]["status"] == "resource_rejected" diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_release_contract_v1.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_release_contract_v1.py new file mode 100644 index 000000000..db3ee030f --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_release_contract_v1.py @@ -0,0 +1,73 @@ +from __future__ import annotations + +import copy +import json +from pathlib import Path + +import pytest + +from make_release_manifest_v1 import build_manifest +from verify_release_contract_v1 import verify_manifest + + +SCRIPT_ROOT = Path(__file__).resolve().parents[1] +OUTPUT = SCRIPT_ROOT / "output" +REPO_ROOT = SCRIPT_ROOT.parents[2] +RELEASE_MANIFEST = OUTPUT / "release_manifest_v1.json" + + +def _production_manifest() -> dict: + return json.loads(RELEASE_MANIFEST.read_text(encoding="utf-8")) + + +def test_release_manifest_captures_public_contract() -> None: + manifest = build_manifest( + repo_root=REPO_ROOT, + bulk_output=OUTPUT, + generated_utc="2026-07-30T00:00:00+00:00", + ) + + assert manifest["schema_version"] == 1 + assert manifest["release_id"] == "task05-geometric-chaos-v1" + assert manifest["result_branches"] == { + "matrix_element": "deformed_geometric_eth", + "topology": "fixed_chern_deformed_holonomy", + } + assert manifest["paper"]["page_count"] == 17 + assert len(manifest["paper"]["sha256"]) == 64 + assert len(manifest["figures"]) == 7 + assert all(len(item["sha256"]) == 64 for item in manifest["figures"]) + assert manifest["verification"]["quick"] == "bash run_quick_verify_v1.sh" + assert manifest["verification"]["full"] == "bash run_full_recompute_v1.sh" + + report = verify_manifest(RELEASE_MANIFEST, repo_root=REPO_ROOT) + assert report["passed"] + assert all(report["checks"].values()) + + +def test_release_verifier_detects_changed_result_label( + tmp_path: Path, +) -> None: + manifest = copy.deepcopy(_production_manifest()) + manifest["result_branches"]["matrix_element"] = "full_haar" + path = tmp_path / "changed.json" + path.write_text(json.dumps(manifest), encoding="utf-8") + + report = verify_manifest(path, repo_root=REPO_ROOT) + assert report["passed"] is False + assert report["checks"]["registered_result_branches"] is False + + +def test_release_verifier_detects_blob_above_policy( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + path = tmp_path / "manifest.json" + path.write_text( + json.dumps(_production_manifest()), + encoding="utf-8", + ) + + monkeypatch.setenv("TASK05_RELEASE_MAX_TRACKED_BYTES", "1") + report = verify_manifest(path, repo_root=REPO_ROOT) + assert report["passed"] is False + assert report["checks"]["tracked_blob_limit"] is False diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_spectral_silence_delivery_v2.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_spectral_silence_delivery_v2.py new file mode 100644 index 000000000..42bae1c21 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_spectral_silence_delivery_v2.py @@ -0,0 +1,55 @@ +from __future__ import annotations + +import importlib +from pathlib import Path + +import pytest + + +verifier = importlib.import_module( + "verify_spectral_silence_article_v2" +) +EXTERNAL_SPECTRAL = ( + Path(__file__).resolve().parents[1] + / "output" + / "spectral_silence_v2.npz" +) + + +@pytest.mark.skipif( + not EXTERNAL_SPECTRAL.exists(), + reason=( + "activates with production arrays listed in release_manifest_v1.json" + ), +) +def test_registered_spectral_silence_delivery_passes( + tmp_path: Path, +) -> None: + audit = verifier.run(tmp_path / "audit.json") + assert audit["all_checks_pass"] + assert audit["pdf"]["title"] == ( + "Spectral Silence and Geometric Chaos in an Exactly Degenerate " + "Topological Manifold" + ) + assert 10 <= audit["pdf"]["pages"] <= 15 + assert len(audit["rendered_pages"]) == audit["pdf"]["pages"] + assert audit["supported_conclusion"] == { + "energy_connected_sff": 0.0, + "physical_jacobi_tau_onset": 0.25, + "geometric_local_onset": 0.20000000298023224, + "geometric_ramp_onset": 0.4000000059604645, + "number_variance_compatibility_extent": 1.0, + "D800_connected_plateau": 0.7, + } + assert audit["registered_scale"] == { + "physical_matrices": 20_000, + "physical_test_matrices": 4_000, + "structured_momenta": 24, + "structured_orbits": 12, + "geometric_interpolation_matrices": 28_000, + "spectral_interpolation_matrices": 32_000, + "haar_matrices": 10_000, + "root_matrices": 8_750, + "maximum_rank": 800, + "bootstrap_replicates": 10_000, + } diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_spectral_silence_figures_v2.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_spectral_silence_figures_v2.py new file mode 100644 index 000000000..7712f2c88 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_spectral_silence_figures_v2.py @@ -0,0 +1,72 @@ +"""Publication-figure contract for the v2 article.""" + +from __future__ import annotations + +import json +from pathlib import Path + +from PIL import Image +from pypdf import PdfReader +import pytest + +from make_spectral_silence_figures_v2 import run + + +EXTERNAL_SPECTRAL = ( + Path(__file__).resolve().parents[1] + / "output" + / "spectral_silence_v2.npz" +) + + +def _audit_manifest(manifest_path: Path) -> None: + manifest = json.loads( + manifest_path.read_text(encoding="utf-8") + ) + assert len(manifest["figures"]) == 5 + assert manifest["scientific_annotations"] == { + "energy_raw": 50.0, + "energy_connected": 0.0, + "local_g": 0.2, + "ramp_g": 0.4, + "number_extent": 1.0, + "D800_atom_each": 120, + "D800_connected_plateau": 0.7, + } + for figure in manifest["figures"].values(): + pdf = Path(figure["pdf"]) + png = Path(figure["png"]) + assert pdf.is_file() and png.is_file() + width = ( + float(PdfReader(str(pdf)).pages[0].mediabox.width) + / 72.0 + ) + assert abs(width - 7.0) < 0.01 + with Image.open(png) as image: + assert image.width >= 2100 + assert image.info["dpi"][0] >= 299.0 + assert len(figure["pdf_sha256"]) == 64 + assert len(figure["png_sha256"]) == 64 + + +@pytest.mark.skipif( + not EXTERNAL_SPECTRAL.exists(), + reason=( + "activates with production arrays listed in release_manifest_v1.json" + ), +) +def test_reduced_figure_build(tmp_path): + result = run(tmp_path) + assert result["all_checks_pass"] + _audit_manifest(tmp_path / "figure_manifest_v2.json") + numbers = (tmp_path / "generated_numbers_v2.tex").read_text( + encoding="utf-8" + ) + assert r"\newcommand{\EnergyRawSFF}{50}" in numbers + assert r"\newcommand{\GeometricLocalOnset}{0.20}" in numbers + assert r"\newcommand{\GeometricRampOnset}{0.40}" in numbers + + +def test_registered_figure_package(): + output = Path(__file__).resolve().parents[1] / "output" + _audit_manifest(output / "figure_manifest_v2.json") diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_spectral_silence_runner_v2.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_spectral_silence_runner_v2.py new file mode 100644 index 000000000..962ca3fbe --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_spectral_silence_runner_v2.py @@ -0,0 +1,51 @@ +"""Reduced-run tests for the spectral-silence production artifact.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import numpy as np +import pytest + +from run_spectral_silence_v2 import run + + +EXTERNAL_PHYSICAL = ( + Path(__file__).resolve().parents[1] + / "output" + / "physical_ensemble_v1.npz" +) + + +@pytest.mark.skipif( + not EXTERNAL_PHYSICAL.exists(), + reason=( + "activates with production arrays listed in release_manifest_v1.json" + ), +) +def test_reduced_spectral_silence_runner(tmp_path): + output_json = tmp_path / "spectral_silence_v2.json" + output_npz = tmp_path / "spectral_silence_v2.npz" + result = run( + output_json, + output_npz, + samples_per_g=64, + spectral_samples=64, + quadrature_order=128, + rank_form_factor_samples=64, + ) + assert result["checks"]["exact_energy_silence"] + assert result["checks"]["structured_control_full_rank"] + assert result["checks"]["structured_control_multiplets"] + assert result["checks"]["fixed_projector_invariance"] + assert result["checks"]["spectral_axis_resolved"] + assert result["checks"]["atom_plateau_theorem"] + assert result["all_checks_pass"] + loaded = json.loads(output_json.read_text(encoding="utf-8")) + assert loaded["sample_counts"]["per_positive_g"] == 64 + arrays = np.load(output_npz, allow_pickle=False) + assert arrays["structured_spectra"].shape == (24, 50) + assert arrays["g_spectra"].shape == (7, 64, 50) + assert arrays["energy_spectra_alpha"].shape == (8, 64, 50) + assert arrays["rank_reference_connected_full"].shape[0] == 7 diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_spectral_silence_statistics_v2.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_spectral_silence_statistics_v2.py new file mode 100644 index 000000000..3ac3af4e5 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_spectral_silence_statistics_v2.py @@ -0,0 +1,87 @@ +"""Inference tests for the spectral-silence expansion.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import numpy as np +import pytest + +from run_spectral_silence_statistics_v2 import ( + registered_compatibility_extent, + registered_compatibility_onset, + run, +) + + +EXTERNAL_SPECTRAL = ( + Path(__file__).resolve().parents[1] + / "output" + / "spectral_silence_v2.npz" +) + + +def test_registered_crossover_requires_all_later_nonplateau_points(): + grid = np.array([0.2, 0.4, 0.6, 0.8]) + lower = np.array([0.1, -0.1, -0.1, -0.1]) + upper = np.array([0.2, 0.1, 0.1, 0.1]) + assert ( + registered_compatibility_onset( + grid, + lower, + upper, + minimum=0.2, + maximum=0.8, + ) + == 0.4 + ) + + +def test_unresolved_crossover_is_explicit(): + assert ( + registered_compatibility_onset( + np.array([0.2, 0.4]), + np.array([0.1, 0.1]), + np.array([0.2, 0.2]), + minimum=0.2, + maximum=0.4, + ) + is None + ) + + +def test_compatibility_extent_stops_before_first_resolved_deviation(): + extent = registered_compatibility_extent( + np.array([0.5, 1.0, 1.5, 2.0]), + np.array([-0.1, -0.1, 0.05, 0.1]), + np.array([0.1, 0.1, 0.15, 0.2]), + minimum=0.5, + maximum=2.0, + ) + assert extent == 1.0 + + +@pytest.mark.skipif( + not EXTERNAL_SPECTRAL.exists(), + reason=( + "activates with production arrays listed in release_manifest_v1.json" + ), +) +def test_production_statistics_artifact(tmp_path): + output_json = tmp_path / "statistics.json" + output_npz = tmp_path / "statistics.npz" + result = run( + output_json, + output_npz, + bootstrap_replicates=500, + ) + assert result["checks"]["structured_control_rejects_jacobi"] + assert result["checks"]["physical_has_registered_jacobi_window"] + assert result["checks"]["spectral_axis_confidence_separated"] + assert result["all_checks_pass"] + loaded = json.loads(output_json.read_text(encoding="utf-8")) + assert loaded["bootstrap_replicates"] == 500 + arrays = np.load(output_npz, allow_pickle=False) + assert arrays["g_form_mean"].shape[0] == 7 + assert arrays["energy_gap_ratio_mean"].shape[0] == 8 diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_cohomology_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_cohomology_v7.py new file mode 100644 index 000000000..1c7b38a9d --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_cohomology_v7.py @@ -0,0 +1,111 @@ +"""Algebra and rank tests for the charge-resolved N=2 SYK complex.""" + +from __future__ import annotations + +from math import comb + +import numpy as np + +from lgeth.susy_cohomology import ( + analytic_decomposable_curvature_multiplicities, + charge_basis, + charge_hamiltonian, + cubic_supercharge, + cubic_triples, + decomposable_bps_rank, + decomposable_couplings, + decomposable_tangent, + expected_generic_bps_rank, + normalized_complex_couplings, + solve_bps_frame, +) + + +def test_charge_bases_and_cubic_triples_have_exact_counts() -> None: + assert len(charge_basis(8, 3)) == comb(8, 3) + assert charge_basis(8, -1) == () + assert charge_basis(8, 9) == () + triples = cubic_triples(8) + assert len(triples) == comb(8, 3) + assert triples[0] == (0, 1, 2) + assert triples[-1] == (5, 6, 7) + + +def test_cubic_supercharge_is_nontrivially_nilpotent() -> None: + couplings = normalized_complex_couplings(8, seed=7) + q1 = cubic_supercharge(8, 1, couplings) + q4 = cubic_supercharge(8, 4, couplings) + product = (q4 @ q1).toarray() + assert product.shape == (8, 8) + assert np.linalg.norm(product) < 2e-14 + assert np.linalg.norm(q1.toarray()) > 0.0 + assert np.linalg.norm(q4.toarray()) > 0.0 + + +def test_charge_hamiltonian_is_positive_hermitian() -> None: + couplings = normalized_complex_couplings(6, seed=11) + hamiltonian = charge_hamiltonian(6, 3, couplings).toarray() + assert hamiltonian.shape == (20, 20) + assert np.allclose(hamiltonian, hamiltonian.conj().T, atol=1e-13) + eigenvalues = np.linalg.eigvalsh(hamiltonian) + assert float(eigenvalues[0]) > -1e-12 + assert float(eigenvalues[-1]) > 1e-4 + + +def test_registered_even_charge_sectors_have_exact_generic_bps_ranks() -> None: + couplings = normalized_complex_couplings(6, seed=17) + central = solve_bps_frame(6, 3, couplings, dense_cutoff=64) + adjacent = solve_bps_frame(6, 2, couplings, dense_cutoff=64) + assert expected_generic_bps_rank(6, 3) == 18 + assert expected_generic_bps_rank(6, 2) == 9 + assert central.projector_frame.shape == (20, 18) + assert adjacent.projector_frame.shape == (15, 9) + for frame in (central, adjacent): + assert frame.gap > 1e-8 + assert frame.kernel_residual < 1e-11 + assert frame.orthogonality_error < 1e-12 + assert frame.complement_frame.shape[1] == len(frame.positive_energies) + + +def test_bps_projector_is_deterministic_at_fixed_couplings() -> None: + couplings = normalized_complex_couplings(6, seed=23) + first = solve_bps_frame(6, 3, couplings, dense_cutoff=64) + second = solve_bps_frame(6, 3, couplings, dense_cutoff=64) + first_projector = first.projector_frame @ first.projector_frame.conj().T + second_projector = second.projector_frame @ second.projector_frame.conj().T + assert np.allclose(first_projector, second_projector, atol=2e-13) + + +def test_odd_system_size_is_outside_registered_rank_contract() -> None: + with np.testing.assert_raises_regex(ValueError, "even N"): + expected_generic_bps_rank(7, 3) + + +def test_decomposable_rank_and_tangent_contracts() -> None: + couplings = decomposable_couplings(8, alpha=1.7) + triples = cubic_triples(8) + assert np.count_nonzero(couplings) == 1 + assert couplings[triples.index((0, 1, 2))] == 1.7 + tangent = decomposable_tangent(8, "12", 3) + assert np.count_nonzero(tangent) == 1 + assert tangent[triples.index((0, 1, 3))] == 1.0 + assert decomposable_bps_rank(8, 4) == 60 + frame = solve_bps_frame( + 8, + 4, + couplings, + dense_cutoff=128, + expected_rank_override=decomposable_bps_rank(8, 4), + ) + assert frame.projector_frame.shape == (70, 60) + + +def test_decomposable_multiplicity_formulas_are_complete() -> None: + diagonal = analytic_decomposable_curvature_multiplicities(6, 3, "diagonal") + off_diagonal = analytic_decomposable_curvature_multiplicities( + 6, + 3, + "off_diagonal", + ) + assert diagonal == {"negative": 1, "zero": 16, "positive": 1} + assert off_diagonal == {"negative": 2, "zero": 14, "positive": 2} diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_analysis_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_analysis_v7.py new file mode 100644 index 000000000..90560ef50 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_analysis_v7.py @@ -0,0 +1,214 @@ +"""Sealed prediction and complete-realization inference tests for v7.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import numpy as np +import pytest + +from analyze_susy_hodge_geometric_eth_v7 import ( + aggregate_pilot_from_banks, + score_unsealed_n14, + select_frozen_branch, + write_n14_prediction, +) +from run_susy_hodge_geometric_eth_v7 import ( + panel_paths, + prepare_realization, + run_panel, +) +from run_susy_hodge_null_bank_v7 import write_null_bank + + +def _reduced_prediction_fixture( + tmp_path: Path, + *, + delete_outcomes: bool = True, +) -> list[tuple[int, str, int, str]]: + checkpoint_root = tmp_path / "checkpoints" + bank_root = tmp_path / "banks" + cases: list[tuple[int, str, int, str]] = [] + for sector in ("central", "adjacent"): + for realization in range(2): + prepare_realization( + 6, + sector, + realization, + root=checkpoint_root, + reduced=True, + force=True, + ) + case = (6, sector, realization, "sparse") + run_panel(*case, root=checkpoint_root, reduced=True, force=True) + write_null_bank( + *case, + checkpoint_root=checkpoint_root, + output_root=bank_root, + draws=8, + force=True, + ) + if delete_outcomes: + # Prediction generation must succeed with no outcome sidecars. + _, _, outcome_path = panel_paths(checkpoint_root, *case) + outcome_path.unlink() + cases.append(case) + return cases + + +def test_prediction_is_sealed_before_any_outcome_is_read(tmp_path: Path) -> None: + cases = _reduced_prediction_fixture(tmp_path) + prediction_json = tmp_path / "prediction.json" + prediction_npz = tmp_path / "prediction.npz" + prediction_seal = tmp_path / "prediction.sha256" + payload = write_n14_prediction( + cases, + checkpoint_root=tmp_path / "checkpoints", + null_bank_root=tmp_path / "banks", + safe_covariates_json=tmp_path / "safe.json", + output_json=prediction_json, + output_npz=prediction_npz, + seal_path=prediction_seal, + null_replicates=24, + seed=71, + ) + assert payload["passed"] + assert prediction_seal.is_file() + serialized = prediction_json.read_text(encoding="utf-8").lower() + assert "r4" not in serialized + assert "four_point" not in serialized + assert "connected" not in serialized + assert { + (item["sector"], item["panel_kind"]) + for item in payload["primary_pair"] + } == {("central", "sparse"), ("adjacent", "sparse")} + with np.load(prediction_npz) as arrays: + assert arrays["N6_central_sparse_collapsed"].shape == (24,) + assert arrays["N6_adjacent_sparse_hodge"].shape == (24,) + + +def test_scoring_fails_closed_when_prediction_seal_is_corrupted( + tmp_path: Path, +) -> None: + cases = _reduced_prediction_fixture(tmp_path) + prediction_json = tmp_path / "prediction.json" + prediction_npz = tmp_path / "prediction.npz" + prediction_seal = tmp_path / "prediction.sha256" + write_n14_prediction( + cases, + checkpoint_root=tmp_path / "checkpoints", + null_bank_root=tmp_path / "banks", + safe_covariates_json=tmp_path / "safe.json", + output_json=prediction_json, + output_npz=prediction_npz, + seal_path=prediction_seal, + null_replicates=12, + seed=73, + ) + unsealed = { + "records": [ + { + "N": N, + "sector": sector, + "realization": realization, + "panel_kind": panel, + "R4": float(0.1 + 0.01 * realization), + } + for N, sector, realization, panel in cases + ], + "passed": True, + } + unsealed_json = tmp_path / "unsealed.json" + unsealed_json.write_text(json.dumps(unsealed), encoding="utf-8") + prediction_seal.write_text("0" * 64 + " prediction.json\n", encoding="utf-8") + with pytest.raises(ValueError, match="seal mismatch"): + score_unsealed_n14( + prediction_json, + prediction_seal, + unsealed_json, + output_json=tmp_path / "inference.json", + bootstrap_replicates=32, + seed=79, + ) + + +def test_frozen_branch_selection_is_exhaustive_and_fail_closed() -> None: + assert select_frozen_branch(True, True, False, True) == ( + "strong_covariance_universality" + ) + assert select_frozen_branch(False, True, False, True) == ( + "hodge_resolved_geometric_eth" + ) + assert select_frozen_branch(False, False, False, True) == ( + "cohomological_non_gaussian_class" + ) + assert select_frozen_branch(False, False, True, True) == ( + "structured_cohomology" + ) + assert select_frozen_branch(True, False, False, True) == ( + "feasibility_failure" + ) + assert select_frozen_branch(True, True, False, False) == ( + "feasibility_failure" + ) + + +def test_scheduler_stops_after_the_prediction_seal() -> None: + script_root = Path(__file__).resolve().parents[1] + submit = ( + script_root / "slurm" / "submit_susy_hodge_N14_v7.sh" + ).read_text(encoding="utf-8") + assert "seal_susy_hodge_N14_v7.sbatch" in submit + assert "run_susy_hodge_N14_null_v7_array.sbatch" in submit + assert 'dependency="afterok:${ARRAY_JOB}"' in submit + assert 'dependency="afterok:${NULL_JOB}"' in submit + assert "analyze_susy_hodge_geometric_eth_v7.py unseal" not in submit + seal_job = ( + script_root / "slurm" / "seal_susy_hodge_N14_v7.sbatch" + ).read_text(encoding="utf-8") + assert " predict " in seal_job + assert " unseal" not in seal_job + response_job = ( + script_root / "slurm" / "run_susy_hodge_N14_v7_array.sbatch" + ).read_text(encoding="utf-8") + assert 'WORKER_COUNT="${N14_RESPONSE_WORKERS:-16}"' in response_job + logical_ids = { + logical_id + for array_id in range(8) + for logical_id in range(array_id, 48, 8) + } + assert logical_ids == set(range(48)) + null_job = ( + script_root / "slurm" / "run_susy_hodge_N14_null_v7_array.sbatch" + ).read_text(encoding="utf-8") + assert 'WORKER_COUNT="${N14_NULL_WORKERS:-48}"' in null_job + null_logical_ids = { + logical_id + for array_id in range(8) + for logical_id in range(array_id, 48, 8) + } + assert null_logical_ids == set(range(48)) + + +def test_pilot_aggregate_resamples_complete_realizations(tmp_path: Path) -> None: + cases = _reduced_prediction_fixture(tmp_path, delete_outcomes=False) + payload = aggregate_pilot_from_banks( + cases, + checkpoint_root=tmp_path / "checkpoints", + null_bank_root=tmp_path / "banks", + safe_covariates_json=tmp_path / "pilot_safe.json", + output_json=tmp_path / "pilot.json", + output_npz=tmp_path / "pilot.npz", + null_replicates=12, + bootstrap_replicates=16, + seed=83, + ) + assert payload["passed"] + assert payload["uncertainty_unit"] == "complete_disorder_realization" + assert len(payload["groups"]) == 2 + with np.load(tmp_path / "pilot.npz") as arrays: + assert arrays["N6_central_sparse_physical"].shape == (2,) + assert arrays["N6_central_sparse_physical_bootstrap"].shape == (16,) + assert arrays["N6_central_sparse_collapsed_null"].shape == (12,) + assert arrays["N6_central_sparse_hodge_null"].shape == (12,) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_controls_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_controls_v7.py new file mode 100644 index 000000000..7bd06bedf --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_controls_v7.py @@ -0,0 +1,30 @@ +"""Machine-readable analytic-control artifact tests for SUSY/Hodge v7.""" + +from __future__ import annotations + +import json +from pathlib import Path + +from generate_susy_hodge_controls_v7 import generate_controls + + +def test_decomposable_atoms_and_one_sided_regression_are_audited( + tmp_path: Path, +) -> None: + output = tmp_path / "controls.json" + payload = generate_controls(output) + assert payload["passed"] + assert payload["decomposable_N6"]["diagonal_multiplicities"] == { + "negative": 1, + "zero": 16, + "positive": 1, + } + assert payload["decomposable_N6"]["off_diagonal_multiplicities"] == { + "negative": 2, + "zero": 14, + "positive": 2, + } + assert payload["decomposable_N8"]["bps_rank"] == 60 + assert payload["one_sided_regression"]["max_absolute_difference"] == 0.0 + reloaded = json.loads(output.read_text(encoding="utf-8")) + assert reloaded["sources"] == payload["sources"] diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_delivery_script_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_delivery_script_v7.py new file mode 100644 index 000000000..254332142 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_delivery_script_v7.py @@ -0,0 +1,34 @@ +"""The delivery command must preserve the explicit held-out unseal boundary.""" + +from __future__ import annotations + +from pathlib import Path + + +def test_delivery_script_orders_assets_and_never_unseals() -> None: + script = ( + Path(__file__).resolve().parents[1] / "run_susy_hodge_delivery_v7.sh" + ).read_text(encoding="utf-8") + merge = script.index("merge_susy_hodge_pilot_v7.py") + figure = script.index("make_susy_hodge_figure_v7.py") + assets = script.index("make_susy_hodge_manuscript_assets_v7.py") + compile_pdf = script.index("latexmk") + archive_pdf = script.index("response_complex_memory_v7.pdf") + supplement = script.index("supplement.tex") + archive_supplement = script.index("response_complex_memory_supplement_v7.pdf") + audit = script.index("verify_susy_hodge_delivery_v7.py") + manuscript = script.index("verify_susy_hodge_manuscript_v7.py") + + assert ( + merge + < figure + < assets + < compile_pdf + < supplement + < archive_pdf + < archive_supplement + < audit + < manuscript + ) + assert " unseal" not in script.lower() + assert "analyze_susy_hodge_geometric_eth_v7.py unseal" not in script diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_delivery_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_delivery_v7.py new file mode 100644 index 000000000..1c5475d08 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_delivery_v7.py @@ -0,0 +1,196 @@ +"""Fail-closed delivery and corruption tests for SUSY/Hodge v7.""" + +from __future__ import annotations + +import hashlib +import json +from datetime import datetime, timedelta, timezone +from pathlib import Path + +import numpy as np + +from verify_susy_hodge_delivery_v7 import verify_delivery + + +def _hash(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def _write_json(path: Path, payload: dict) -> None: + path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8") + + +def _synthetic_delivery(tmp_path: Path) -> dict[str, Path]: + now = datetime.now(timezone.utc) + pilot_groups = [ + { + "N": N, + "sector": sector, + "panel_kind": panel, + "collapsed_covered": False, + "hodge_covered": False, + } + for N in (8, 10, 12) + for sector in ("central", "adjacent") + for panel in ("sparse", "isotropic") + ] + pilot = tmp_path / "pilot.json" + pilot_npz = tmp_path / "pilot.npz" + np.savez_compressed(pilot_npz, values=np.arange(3.0)) + _write_json( + pilot, + { + "version": "v7", + "groups": pilot_groups, + "arrays_sha256": _hash(pilot_npz), + "checks": {"complete": True}, + "passed": True, + }, + ) + safe = tmp_path / "safe.json" + _write_json(safe, {"version": "v7", "records": [], "passed": True}) + prediction_npz = tmp_path / "prediction.npz" + np.savez_compressed(prediction_npz, central=np.arange(4.0)) + primary_prediction = [ + { + "N": 14, + "sector": sector, + "panel_kind": "sparse", + "realizations": 2, + "collapsed_interval": [0.10, 0.11, 0.12], + "hodge_interval": [0.13, 0.14, 0.15], + } + for sector in ("central", "adjacent") + ] + prediction = tmp_path / "prediction.json" + _write_json( + prediction, + { + "version": "v7", + "generated_utc": now.isoformat(), + "prediction_arrays_file": prediction_npz.name, + "prediction_arrays_sha256": _hash(prediction_npz), + "safe_covariates_sha256": _hash(safe), + "primary_pair": primary_prediction, + "checks": {"complete": True, "no_outcome_leakage": True}, + "passed": True, + }, + ) + seal = tmp_path / "prediction.sha256" + seal.write_text(f"{_hash(prediction)} {prediction.name}\n", encoding="utf-8") + unsealed = tmp_path / "unsealed.json" + _write_json( + unsealed, + { + "version": "v7", + "prediction_sha256": _hash(prediction), + "unsealed_utc": (now + timedelta(seconds=1)).isoformat(), + "checks": {"complete": True}, + "passed": True, + }, + ) + primary_inference = [ + { + "N": 14, + "sector": sector, + "panel_kind": "sparse", + "collapsed_covered": False, + "hodge_covered": False, + "robust_outside_both": True, + } + for sector in ("central", "adjacent") + ] + inference = tmp_path / "inference.json" + _write_json( + inference, + { + "version": "v7", + "prediction_sha256": _hash(prediction), + "selected_branch": "cohomological_non_gaussian_class", + "primary_pair": primary_inference, + "structured_indistinguishable": False, + "checks": {"registered_branch_resolved": True}, + "passed": True, + }, + ) + controls = tmp_path / "controls.json" + _write_json( + controls, + { + "version": "v7", + "checks": { + "N6_curvature_atoms": True, + "one_sided_exact_regression": True, + }, + "passed": True, + }, + ) + pdf = tmp_path / "figure.pdf" + png = tmp_path / "figure.png" + report = tmp_path / "report.md" + pdf.write_bytes(b"%PDF-1.4\nsynthetic\n") + png.write_bytes(b"synthetic-png") + report.write_text( + "## Established\ncohomological_non_gaussian_class\n" + "## Not established\n[Source](https://example.org)\n", + encoding="utf-8", + ) + figure = tmp_path / "figure.json" + _write_json( + figure, + { + "version": "v7", + "selected_branch": "cohomological_non_gaussian_class", + "inputs": { + pilot.name: _hash(pilot), + inference.name: _hash(inference), + }, + "outputs": { + pdf.name: _hash(pdf), + png.name: _hash(png), + report.name: _hash(report), + }, + "checks": {"complete": True}, + "passed": True, + }, + ) + return { + "pilot_json": pilot, + "pilot_npz": pilot_npz, + "safe_json": safe, + "prediction_json": prediction, + "prediction_npz": prediction_npz, + "prediction_seal": seal, + "unsealed_json": unsealed, + "inference_json": inference, + "controls_json": controls, + "figure_manifest": figure, + "figure_pdf": pdf, + "figure_png": png, + "report_md": report, + } + + +def test_delivery_passes_then_rejects_seal_and_safe_leakage(tmp_path: Path) -> None: + paths = _synthetic_delivery(tmp_path) + output = tmp_path / "audit.json" + first = verify_delivery(**paths, output_json=output) + assert first["passed"] + paths["prediction_seal"].write_text( + "0" * 64 + f" {paths['prediction_json'].name}\n", + encoding="utf-8", + ) + second = verify_delivery(**paths, output_json=output) + assert not second["passed"] + assert not second["checks"]["valid_prediction_seal"] + paths = _synthetic_delivery(tmp_path) + leaked = json.loads(paths["prediction_json"].read_text(encoding="utf-8")) + leaked["R4"] = 0.3 + _write_json(paths["prediction_json"], leaked) + paths["prediction_seal"].write_text( + f"{_hash(paths['prediction_json'])} {paths['prediction_json'].name}\n", + encoding="utf-8", + ) + third = verify_delivery(**paths, output_json=output) + assert not third["passed"] + assert not third["checks"]["prediction_has_no_outcome_leakage"] diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_figure_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_figure_v7.py new file mode 100644 index 000000000..7e7e5e749 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_figure_v7.py @@ -0,0 +1,98 @@ +"""Publication-figure and source-backed report tests for SUSY/Hodge v7.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import matplotlib.image as mpimg + +from make_susy_hodge_figure_v7 import make_figure + + +def _write_sources(tmp_path: Path) -> tuple[Path, Path]: + groups = [] + for N in (8, 10, 12): + for sector, balance in (("central", 1.0), ("adjacent", 0.1)): + for panel_index, panel in enumerate(("sparse", "isotropic")): + observed = 0.34 - 0.01 * (N - 8) - 0.03 * panel_index + groups.append( + { + "N": N, + "sector": sector, + "panel_kind": panel, + "observed_median": observed, + "physical_bootstrap_interval": [ + observed - 0.01, + observed + 0.01, + ], + "collapsed_prediction_interval": [0.12, 0.13, 0.14], + "hodge_prediction_interval": [0.14, 0.15, 0.16], + "collapsed_covered": False, + "hodge_covered": False, + "median_hodge_balance": balance, + } + ) + pilot = { + "version": "v7", + "uncertainty_unit": "complete_disorder_realization", + "groups": groups, + "checks": {"synthetic_complete_grid": True}, + "passed": True, + } + primary = [] + for sector, observed in (("central", 0.29), ("adjacent", 0.31)): + primary.append( + { + "N": 14, + "sector": sector, + "panel_kind": "sparse", + "observed_median": observed, + "physical_bootstrap_interval": [observed - 0.01, observed + 0.01], + "collapsed_prediction_interval": [0.10, 0.11, 0.12], + "hodge_prediction_interval": [0.13, 0.14, 0.15], + "collapsed_covered": False, + "hodge_covered": False, + "robust_outside_both": True, + } + ) + inference = { + "version": "v7", + "prediction_sha256": "a" * 64, + "selected_branch": "cohomological_non_gaussian_class", + "primary_pair": primary, + "checks": {"valid_prediction_seal": True}, + "passed": True, + } + pilot_path = tmp_path / "pilot.json" + inference_path = tmp_path / "inference.json" + pilot_path.write_text(json.dumps(pilot), encoding="utf-8") + inference_path.write_text(json.dumps(inference), encoding="utf-8") + return pilot_path, inference_path + + +def test_figure_and_report_are_provenance_complete(tmp_path: Path) -> None: + pilot, inference = _write_sources(tmp_path) + pdf = tmp_path / "figure.pdf" + png = tmp_path / "figure.png" + manifest_path = tmp_path / "figure.json" + report_path = tmp_path / "report.md" + manifest = make_figure( + pilot_json=pilot, + inference_json=inference, + output_pdf=pdf, + output_png=png, + manifest_json=manifest_path, + report_md=report_path, + ) + assert all(manifest["checks"].values()) + assert manifest["selected_branch"] == "cohomological_non_gaussian_class" + assert manifest["pilot_group_count"] == 12 + assert pdf.is_file() and png.is_file() and manifest_path.is_file() + image = mpimg.imread(png) + assert image.shape[1] >= 2000 + report = report_path.read_text(encoding="utf-8") + assert "## Established" in report + assert "## Not established" in report + assert "cohomological_non_gaussian_class" in report + assert "](https://" in report diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_manuscript_assets_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_manuscript_assets_v7.py new file mode 100644 index 000000000..a75b1dfe7 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_manuscript_assets_v7.py @@ -0,0 +1,104 @@ +"""Fail-closed manuscript-asset tests for the SUSY/Hodge result.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import pytest + +from make_susy_hodge_manuscript_assets_v7 import build_manuscript_assets +from run_susy_hodge_geometric_eth_v7 import sha256 + + +def _write_json(path: Path, payload: dict) -> None: + path.write_text(json.dumps(payload), encoding="utf-8") + + +def _sources(root: Path, *, branch: str = "hodge_resolved_geometric_eth") -> dict: + groups = [ + { + "N": size, + "sector": sector, + "panel_kind": panel, + "collapsed_covered": False, + "hodge_covered": False, + } + for size in (8, 10, 12) + for sector in ("central", "adjacent") + for panel in ("sparse", "isotropic") + ] + primary = [ + { + "N": 14, + "sector": sector, + "panel_kind": "sparse", + "observed_median": 0.3, + "physical_bootstrap_interval": [0.29, 0.31], + "collapsed_prediction_interval": [0.1, 0.12, 0.14], + "hodge_prediction_interval": [0.28, 0.30, 0.32], + } + for sector in ("central", "adjacent") + ] + pilot = root / "pilot.json" + inference = root / "inference.json" + figure = root / "figure.pdf" + figure_manifest = root / "figure.json" + common = {"version": "v7", "checks": {"passed": True}, "passed": True} + _write_json(pilot, {**common, "groups": groups}) + _write_json( + inference, + { + **common, + "selected_branch": branch, + "prediction_sha256": "a" * 64, + "primary_pair": primary, + }, + ) + figure.write_bytes(b"%PDF-1.4\nsynthetic\n") + _write_json( + figure_manifest, + { + **common, + "selected_branch": branch, + "inputs": { + pilot.name: sha256(pilot), + inference.name: sha256(inference), + }, + "outputs": {figure.name: sha256(figure)}, + }, + ) + return { + "pilot_json": pilot, + "inference_json": inference, + "figure_manifest_json": figure_manifest, + "figure_pdf": figure, + "results_tex": root / "results.tex", + "figure_target": root / "copied.pdf", + "manifest_json": root / "assets.json", + } + + +def test_build_manuscript_assets_enables_results_after_hash_audit( + tmp_path: Path, +) -> None: + paths = _sources(tmp_path) + manifest = build_manuscript_assets(**paths) + + assert manifest["passed"] + text = paths["results_tex"].read_text(encoding="utf-8") + assert r"\heldoutcompletetrue" in text + assert r"\heldoutcompletefalse" not in text + assert r"hodge\_resolved\_geometric\_eth" in text + assert r"\newcommand{\HeldoutAdjacentPhysical}" in text + assert r"\newcommand{\HeldoutCentralHodge}" in text + assert sha256(paths["figure_pdf"]) == sha256(paths["figure_target"]) + + +def test_build_manuscript_assets_rejects_feasibility_failure( + tmp_path: Path, +) -> None: + paths = _sources(tmp_path, branch="feasibility_failure") + + with pytest.raises(ValueError, match="not publishable"): + build_manuscript_assets(**paths) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_manuscript_audit_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_manuscript_audit_v7.py new file mode 100644 index 000000000..616d8c23e --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_manuscript_audit_v7.py @@ -0,0 +1,105 @@ +"""Tests for the compiled response-complex manuscript audit.""" + +from __future__ import annotations + +import json +from pathlib import Path + +from run_susy_hodge_geometric_eth_v7 import sha256 +from verify_susy_hodge_manuscript_v7 import verify_manuscript + + +def test_manuscript_audit_checks_activation_hashes_and_pdf(tmp_path: Path) -> None: + main = tmp_path / "main.tex" + results = tmp_path / "results_v7.tex" + figure = tmp_path / "figure.pdf" + pdf = tmp_path / "main.pdf" + archive = tmp_path / "archive.pdf" + log = tmp_path / "main.log" + supplement = tmp_path / "supplement.tex" + supplement_pdf = tmp_path / "supplement.pdf" + supplement_archive = tmp_path / "supplement-archive.pdf" + supplement_log = tmp_path / "supplement.log" + manifest = tmp_path / "assets.json" + output = tmp_path / "audit.json" + main.write_text(r"\input{generated/results_v7.tex}", encoding="utf-8") + supplement.write_text( + r"\input{generated/results_v7.tex}", encoding="utf-8" + ) + results.write_text( + "\n".join( + ( + r"\newif\ifheldoutcomplete", + r"\heldoutcompletetrue", + r"\newcommand{\HeldoutBranch}{hodge\_resolved\_geometric\_eth}", + ) + ), + encoding="utf-8", + ) + figure.write_bytes(b"%PDF-1.4\n" + b"x" * 2048 + b"\n%%EOF\n") + pdf.write_bytes(b"%PDF-1.4\n" + b"y" * 2048 + b"\n%%EOF\n") + archive.write_bytes(pdf.read_bytes()) + log.write_text("Output written on main.pdf", encoding="utf-8") + supplement_pdf.write_bytes( + b"%PDF-1.4\n" + b"z" * 2048 + b"\n%%EOF\n" + ) + supplement_archive.write_bytes(supplement_pdf.read_bytes()) + supplement_log.write_text( + "Output written on supplement.pdf", encoding="utf-8" + ) + manifest.write_text( + json.dumps( + { + "version": "v7", + "selected_branch": "hodge_resolved_geometric_eth", + "prediction_sha256": "a" * 64, + "outputs": { + results.name: sha256(results), + figure.name: sha256(figure), + }, + "checks": {"assets": True}, + "passed": True, + } + ), + encoding="utf-8", + ) + + payload = verify_manuscript( + asset_manifest_json=manifest, + main_tex=main, + results_tex=results, + figure_pdf=figure, + main_pdf=pdf, + archive_pdf=archive, + main_log=log, + supplement_tex=supplement, + supplement_pdf=supplement_pdf, + supplement_archive_pdf=supplement_archive, + supplement_log=supplement_log, + output_json=output, + ) + + assert payload["passed"] + + results.write_text( + results.read_text(encoding="utf-8") + + "\n" + + r"\heldoutcompletefalse", + encoding="utf-8", + ) + rejected = verify_manuscript( + asset_manifest_json=manifest, + main_tex=main, + results_tex=results, + figure_pdf=figure, + main_pdf=pdf, + archive_pdf=archive, + main_log=log, + supplement_tex=supplement, + supplement_pdf=supplement_pdf, + supplement_archive_pdf=supplement_archive, + supplement_log=supplement_log, + output_json=output, + ) + assert not rejected["passed"] + assert not rejected["checks"]["heldout_result_enabled"] diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_merge_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_merge_v7.py new file mode 100644 index 000000000..675fcfd38 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_merge_v7.py @@ -0,0 +1,88 @@ +"""Tests for the compact sequential-pilot merge.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import numpy as np +import pytest + +from merge_susy_hodge_pilot_v7 import merge_pilot_artifacts +from run_susy_hodge_geometric_eth_v7 import sha256 + + +def _source(root: Path, size: int) -> tuple[Path, Path]: + json_path = root / f"N{size}.json" + npz_path = root / f"N{size}.npz" + arrays = {} + groups = [] + for sector in ("central", "adjacent"): + for panel in ("sparse", "isotropic"): + prefix = f"N{size}_{sector}_{panel}" + arrays[f"{prefix}_physical"] = np.arange(3.0) + size + arrays[f"{prefix}_physical_bootstrap"] = np.arange(5.0) + size + arrays[f"{prefix}_collapsed_null"] = np.arange(4.0) + size + arrays[f"{prefix}_hodge_null"] = np.arange(4.0) + size + 0.5 + groups.append( + { + "N": size, + "sector": sector, + "panel_kind": panel, + "realizations": 3, + } + ) + np.savez_compressed(npz_path, **arrays) + json_path.write_text( + json.dumps( + { + "version": "v7", + "uncertainty_unit": "complete_disorder_realization", + "null_replicates": 4, + "physical_bootstrap_replicates": 5, + "prediction_coverage": 0.975, + "groups": groups, + "safe_covariates_sha256": f"safe-{size}", + "arrays_sha256": sha256(npz_path), + "checks": {"source_passed": True}, + "passed": True, + } + ), + encoding="utf-8", + ) + return json_path, npz_path + + +def test_merge_pilot_artifacts_preserves_complete_grid(tmp_path: Path) -> None: + first_json, first_npz = _source(tmp_path, 8) + second_json, second_npz = _source(tmp_path, 10) + output_json = tmp_path / "combined.json" + output_npz = tmp_path / "combined.npz" + + result = merge_pilot_artifacts( + [first_json, second_json], + [first_npz, second_npz], + output_json=output_json, + output_npz=output_npz, + expected_sizes=(8, 10), + ) + + assert result["passed"] + assert len(result["groups"]) == 8 + assert result["arrays_sha256"] == sha256(output_npz) + with np.load(output_npz) as arrays: + assert len(arrays.files) == 32 + + +def test_merge_pilot_artifacts_rejects_tampered_npz(tmp_path: Path) -> None: + json_path, npz_path = _source(tmp_path, 8) + np.savez_compressed(npz_path, changed=np.arange(2.0)) + + with pytest.raises(ValueError, match="hash mismatch"): + merge_pilot_artifacts( + [json_path], + [npz_path], + output_json=tmp_path / "combined.json", + output_npz=tmp_path / "combined.npz", + expected_sizes=(8,), + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_null_bank_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_null_bank_v7.py new file mode 100644 index 000000000..0e9b9f454 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_null_bank_v7.py @@ -0,0 +1,90 @@ +"""Safe per-realization null banks for parallel SUSY/Hodge production.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import numpy as np + +from run_susy_hodge_geometric_eth_v7 import prepare_realization, run_panel +from run_susy_hodge_null_bank_v7 import null_bank_paths, write_null_bank + + +def test_null_bank_uses_only_safe_panel_files(tmp_path: Path) -> None: + case = (6, "central", 0, "sparse") + prepare_realization(6, "central", 0, root=tmp_path, reduced=True, force=True) + run_panel(*case, root=tmp_path, reduced=True, force=True) + outcome_path = ( + tmp_path / "panels" / "N6_central_seed000_sparse_v7.outcome.json" + ) + outcome_path.unlink() + result = write_null_bank( + *case, + checkpoint_root=tmp_path, + output_root=tmp_path / "banks", + draws=8, + force=True, + ) + assert result["passed"] + metadata_path, arrays_path = null_bank_paths( + tmp_path / "banks", + *case, + ) + text = metadata_path.read_text(encoding="utf-8").lower() + assert "r4" not in text + assert "four_point" not in text + assert "connected" not in text + metadata = json.loads(metadata_path.read_text(encoding="utf-8")) + assert metadata["draws"] == 8 + with np.load(arrays_path) as arrays: + assert arrays["collapsed_null"].shape == (8,) + assert arrays["hodge_null"].shape == (8,) + assert np.all(np.isfinite(arrays["collapsed_null"])) + assert np.all(np.isfinite(arrays["hodge_null"])) + + +def test_null_bank_is_deterministic_and_hash_checked(tmp_path: Path) -> None: + case = (6, "adjacent", 1, "isotropic") + prepare_realization(6, "adjacent", 1, root=tmp_path, reduced=True, force=True) + run_panel(*case, root=tmp_path, reduced=True, force=True) + first_root = tmp_path / "first" + second_root = tmp_path / "second" + first = write_null_bank( + *case, + checkpoint_root=tmp_path, + output_root=first_root, + draws=8, + force=True, + ) + second = write_null_bank( + *case, + checkpoint_root=tmp_path, + output_root=second_root, + draws=8, + force=True, + ) + assert first["collapsed_sha256"] == second["collapsed_sha256"] + assert first["hodge_sha256"] == second["hodge_sha256"] + + +def test_pilot_slurm_array_maps_complete_n10_n12_grid() -> None: + slurm_root = Path(__file__).resolve().parents[1] / "slurm" + array = (slurm_root / "run_susy_hodge_pilot_v7_array.sbatch").read_text( + encoding="utf-8" + ) + submit = (slurm_root / "submit_susy_hodge_pilot_v7.sh").read_text( + encoding="utf-8" + ) + assert 'if [[ "$TASK_ID" -lt 96 ]]' in array + assert "COUNT=48" in array and "COUNT=32" in array + assert "LOCAL_ID=$((TASK_ID - 96))" in array + assert array.count("run_susy_hodge_null_bank_v7.py") == 1 + assert "for PANEL_KIND in sparse isotropic" in array + assert "TASK_ID=ARRAY_ID; TASK_ID<160; TASK_ID+=8" in array + assert "--array=0-7%8" in submit + logical_ids = { + task_id for array_id in range(8) for task_id in range(array_id, 160, 8) + } + assert logical_ids == set(range(160)) + assert "sbatch" in submit diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_pilot_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_pilot_v7.py new file mode 100644 index 000000000..45eca8e8a --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_pilot_v7.py @@ -0,0 +1,71 @@ +"""Reduced sequential-pilot aggregation for the SUSY/Hodge program.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import numpy as np + +from run_susy_hodge_geometric_eth_v7 import ( + aggregate_pilot, + prepare_realization, + run_panel, +) + + +def test_reduced_pilot_uses_complete_realizations_and_is_reproducible( + tmp_path: Path, +) -> None: + cases: list[tuple[int, str, int, str]] = [] + for sector in ("central", "adjacent"): + for realization in range(2): + prepare_realization( + 6, + sector, + realization, + root=tmp_path, + reduced=True, + force=True, + ) + for panel_kind in ("sparse", "isotropic"): + case = (6, sector, realization, panel_kind) + run_panel(*case, root=tmp_path, reduced=True, force=True) + cases.append(case) + + first = aggregate_pilot( + cases, + root=tmp_path, + null_samples=12, + null_draws_per_realization=6, + seed=109, + safe_output_json=tmp_path / "safe_first.json", + output_json=tmp_path / "pilot_first.json", + output_npz=tmp_path / "pilot_first.npz", + ) + second = aggregate_pilot( + cases, + root=tmp_path, + null_samples=12, + null_draws_per_realization=6, + seed=109, + safe_output_json=tmp_path / "safe_second.json", + output_json=tmp_path / "pilot_second.json", + output_npz=tmp_path / "pilot_second.npz", + ) + assert first["passed"] and second["passed"] + assert len(first["cases"]) == 4 + assert all(record["realizations"] == 2 for record in first["cases"]) + with np.load(tmp_path / "pilot_first.npz") as first_arrays: + with np.load(tmp_path / "pilot_second.npz") as second_arrays: + assert set(first_arrays.files) == set(second_arrays.files) + for key in first_arrays.files: + assert np.array_equal(first_arrays[key], second_arrays[key]) + assert first_arrays["N6_central_sparse_physical"].shape == (2,) + assert first_arrays["N6_central_sparse_collapsed_null"].shape == (12,) + assert first_arrays["N6_central_sparse_hodge_null"].shape == (12,) + safe_text = (tmp_path / "safe_first.json").read_text(encoding="utf-8").lower() + assert "r4" not in safe_text + payload = json.loads((tmp_path / "pilot_first.json").read_text(encoding="utf-8")) + assert payload["uncertainty_unit"] == "complete_disorder_realization" + assert payload["null_draws_per_realization"] == 6 diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_runner_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_runner_v7.py new file mode 100644 index 000000000..f7dc69d97 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_susy_hodge_runner_v7.py @@ -0,0 +1,110 @@ +"""Reduced end-to-end tests for the sealed SUSY/Hodge runner.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import pytest + +from run_susy_hodge_geometric_eth_v7 import ( + panel_paths, + prepare_realization, + run_panel, + seal_file_hash, + unseal_outcomes, + write_safe_covariates, +) + + +def test_reduced_runner_splits_safe_hodge_data_from_r4(tmp_path: Path) -> None: + case = (6, "central", 0, "sparse") + kernel = prepare_realization( + 6, + "central", + 0, + root=tmp_path, + reduced=True, + force=True, + ) + assert all(kernel["checks"].values()) + summary = run_panel( + *case, + root=tmp_path, + reduced=True, + force=True, + ) + assert all(summary["safe"]["checks"].values()) + safe_json, safe_npz, outcome_json = panel_paths(tmp_path, *case) + safe_text = safe_json.read_text(encoding="utf-8") + safe_lower = safe_text.lower() + assert "r4" not in safe_lower + assert "four_point" not in safe_lower + assert "connected" not in safe_lower + assert '"R4"' in outcome_json.read_text(encoding="utf-8") + with pytest.raises(KeyError): + with __import__("numpy").load(safe_npz) as arrays: + _ = arrays["minus"] + + covariate_path = tmp_path / "covariates.json" + covariates = write_safe_covariates( + [case], + root=tmp_path, + output_json=covariate_path, + ) + assert covariates["checks"]["no_outcome_leakage"] + assert "r4" not in covariate_path.read_text(encoding="utf-8").lower() + + +def test_unseal_requires_intact_prediction_and_outcome_identity(tmp_path: Path) -> None: + case = (6, "central", 0, "isotropic") + prepare_realization(6, "central", 0, root=tmp_path, reduced=True, force=True) + run_panel(*case, root=tmp_path, reduced=True, force=True) + prediction = tmp_path / "prediction.json" + prediction.write_text(json.dumps({"prediction": "frozen"}), encoding="utf-8") + seal = tmp_path / "prediction.sha256" + with pytest.raises(FileNotFoundError, match="prediction hash seal"): + unseal_outcomes( + [case], + root=tmp_path, + prediction_json=prediction, + prediction_seal=seal, + output_json=tmp_path / "outcomes.json", + output_npz=tmp_path / "outcomes.npz", + ) + seal_file_hash(prediction, seal) + prediction.write_text(json.dumps({"prediction": "changed"}), encoding="utf-8") + with pytest.raises(ValueError, match="prediction hash seal mismatch"): + unseal_outcomes( + [case], + root=tmp_path, + prediction_json=prediction, + prediction_seal=seal, + output_json=tmp_path / "outcomes.json", + output_npz=tmp_path / "outcomes.npz", + ) + prediction.write_text(json.dumps({"prediction": "frozen"}), encoding="utf-8") + seal_file_hash(prediction, seal) + result = unseal_outcomes( + [case], + root=tmp_path, + prediction_json=prediction, + prediction_seal=seal, + output_json=tmp_path / "outcomes.json", + output_npz=tmp_path / "outcomes.npz", + ) + assert result["passed"] + + _, _, outcome_path = panel_paths(tmp_path, *case) + outcome = json.loads(outcome_path.read_text(encoding="utf-8")) + outcome["safe_identity_hash"] = "0" * 64 + outcome_path.write_text(json.dumps(outcome), encoding="utf-8") + with pytest.raises(ValueError, match="outcome identity mismatch"): + unseal_outcomes( + [case], + root=tmp_path, + prediction_json=prediction, + prediction_seal=seal, + output_json=tmp_path / "corrupt.json", + output_npz=tmp_path / "corrupt.npz", + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_topological_holonomy_delivery_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_topological_holonomy_delivery_v3.py new file mode 100644 index 000000000..42aeb46f8 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_topological_holonomy_delivery_v3.py @@ -0,0 +1,69 @@ +"""Publication and fail-closed tests for fixed-Chern holonomy.""" + +from __future__ import annotations + +import copy +import hashlib +import json +from pathlib import Path + +import pytest +from PIL import Image + +from run_topological_holonomy_v3 import OUTPUT_JSON, OUTPUT_NPZ +from verify_topological_holonomy_v3 import ( + AUDIT_JSON, + FIGURE_MANIFEST, + FIGURE_PDF, + FIGURE_PNG, + audit_topology_payload, +) + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def test_figure_7_has_registered_dimensions_and_source_hashes() -> None: + manifest = json.loads(FIGURE_MANIFEST.read_text(encoding="utf-8")) + figure = manifest["figure_7_topological_holonomy_v3"] + assert figure["width_inches"] == 7.0 + assert figure["png_width_pixels"] == 2100 + assert figure["source_json_sha256"] == _sha256(OUTPUT_JSON) + assert figure["source_npz_sha256"] == _sha256(OUTPUT_NPZ) + assert figure["pdf_sha256"] == _sha256(FIGURE_PDF) + assert figure["png_sha256"] == _sha256(FIGURE_PNG) + assert figure["panels"] == [ + "fixed_chern_and_gap", + "determinant_winding", + "wilson_gap_ratio", + "wilson_form_factor", + ] + with Image.open(FIGURE_PNG) as image: + assert image.width == 2100 + assert image.height >= 1450 + + +def test_topology_delivery_audit_passes_all_gates() -> None: + audit = json.loads(AUDIT_JSON.read_text(encoding="utf-8")) + assert audit["passed"] is True + assert all(audit["checks"].values()) + assert audit["result_branch"] == "fixed_chern_deformed_holonomy" + assert audit["registered_sizes"] == [[3, 8, 16], [4, 10, 25]] + assert audit["registered_meshes"] == [16, 20] + + +def test_topology_audit_rejects_changed_chern() -> None: + payload = json.loads(OUTPUT_JSON.read_text(encoding="utf-8")) + corrupted = copy.deepcopy(payload) + corrupted["sizes"][0]["primary_chern_range"][-1] += 1.0 + with pytest.raises(AssertionError): + audit_topology_payload(corrupted) + + +def test_topology_audit_rejects_false_cue_branch() -> None: + payload = json.loads(OUTPUT_JSON.read_text(encoding="utf-8")) + corrupted = copy.deepcopy(payload) + corrupted["result_branch"] = "fixed_chern_chaotic_holonomy" + with pytest.raises(AssertionError): + audit_topology_payload(corrupted) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_topological_holonomy_runner_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_topological_holonomy_runner_v3.py new file mode 100644 index 000000000..aeb6e968c --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_topological_holonomy_runner_v3.py @@ -0,0 +1,82 @@ +"""Runner tests for fixed-Chern Wilson holonomy production.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import pytest + +from run_topological_holonomy_v3 import ( + OUTPUT_JSON, + run, + select_topology_branch, +) + + +EXTERNAL_REDUCED_BUNDLE = ( + Path(__file__).resolve().parents[1] + / "output" + / "topology_v3_checkpoints" + / "N3_mesh6_twist_bundle_v3.json" +) + + +@pytest.mark.skipif( + not EXTERNAL_REDUCED_BUNDLE.exists(), + reason=( + "activates with production arrays listed in release_manifest_v1.json" + ), +) +def test_reduced_runner_contains_topology_and_holonomy_gates( + tmp_path: Path, +) -> None: + payload = run( + output_json=tmp_path / "result.json", + output_npz=tmp_path / "result.npz", + sizes=((3, 8, 16),), + primary_mesh=6, + convergence_mesh=8, + g_values=(0.0, 0.25), + generator_seeds=(20260728400,), + cue_samples=64, + workers=1, + production=False, + ) + assert set(payload["checks"]) >= { + "kernel_count", + "gap_open", + "mesh_chern_integer", + "mesh_chern_agreement", + "determinant_trace_agreement", + "branch_margin", + "random_gauge_invariance", + "isospectral_orbit", + } + assert payload["sizes"][0]["base_chern_integer"] == 6 + assert payload["configuration"]["g_values"] == [0.0, 0.25] + + +@pytest.mark.skipif( + not OUTPUT_JSON.exists(), + reason="production topology artifact has not been generated", +) +def test_chern_and_energy_are_fixed_across_g() -> None: + payload = json.loads(OUTPUT_JSON.read_text(encoding="utf-8")) + for size in payload["sizes"]: + assert ( + max(size["primary_chern_range"]) + - min(size["primary_chern_range"]) + < 1e-8 + ) + assert size["maximum_energy_spectrum_error"] < 1e-13 + assert size["maximum_gap_error"] < 1e-13 + + +@pytest.mark.skipif( + not OUTPUT_JSON.exists(), + reason="production topology artifact has not been generated", +) +def test_result_branch_is_recomputed_from_raw_topology_metrics() -> None: + payload = json.loads(OUTPUT_JSON.read_text(encoding="utf-8")) + assert payload["result_branch"] == select_topology_branch(payload) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_twist_bundle_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_twist_bundle_v3.py new file mode 100644 index 000000000..31a05dd1f --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_twist_bundle_v3.py @@ -0,0 +1,74 @@ +"""Tests for physical closed twist-torus bundle checkpoints.""" + +from __future__ import annotations + +from pathlib import Path + +import numpy as np +import pytest + +from lgeth.twist_bundle import ( + build_twist_bundle, + load_twist_bundle, + save_twist_bundle, +) + + +@pytest.fixture(scope="module") +def reduced_bundle(): + return build_twist_bundle(N=3, n_flux=8, rank=16, mesh=3) + + +def test_reduced_twist_bundle_has_exact_kernel_and_open_gap( + reduced_bundle, +) -> None: + bundle = reduced_bundle + assert bundle.coefficient_frames.shape[:2] == (3, 3) + assert bundle.coefficient_frames.shape[-1] == 16 + assert np.max(bundle.kernel_bandwidth) < 1e-9 + assert np.min(bundle.external_gap) > 0.0 + assert bundle.geometry.minimum_overlap_singular_value > 0.0 + assert bundle.observed_rank_min == bundle.observed_rank_max == 16 + + +def test_checkpoint_round_trip_preserves_frames_and_geometry( + reduced_bundle, + tmp_path: Path, +) -> None: + metadata = tmp_path / "bundle.json" + save_twist_bundle(reduced_bundle, metadata) + loaded = load_twist_bundle( + metadata, + expected_N=3, + expected_n_flux=8, + expected_rank=16, + expected_mesh=3, + ) + np.testing.assert_allclose( + loaded.coefficient_frames, + reduced_bundle.coefficient_frames, + ) + np.testing.assert_allclose( + loaded.orbital_frames, + reduced_bundle.orbital_frames, + ) + assert loaded.geometry.chern_determinant == pytest.approx( + reduced_bundle.geometry.chern_determinant, + abs=1e-12, + ) + + +def test_checkpoint_rejects_mesh_mismatch( + reduced_bundle, + tmp_path: Path, +) -> None: + metadata = tmp_path / "bundle.json" + save_twist_bundle(reduced_bundle, metadata) + with pytest.raises(ValueError, match="checkpoint identity"): + load_twist_bundle( + metadata, + expected_N=3, + expected_n_flux=8, + expected_rank=16, + expected_mesh=4, + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_wick_channels_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_wick_channels_v3.py new file mode 100644 index 000000000..0827d7829 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/tests/test_wick_channels_v3.py @@ -0,0 +1,190 @@ +"""Tests for gauge-invariant four-channel Wick statistics.""" + +from __future__ import annotations + +import numpy as np +import pytest + +from lgeth.wick_channels import ( + channel_covariance, + covariance_matched_wick, + external_covariance_eigenvalues, + fourier_density_panel, + gaussian_r4_reference, + local_density_panels, + sample_matched_gaussian_channels, + whiten_channel_labels, +) + + +def _synthetic_channels( + seed: int, + channels: int = 8, + ambient: int = 20, + rank: int = 5, +) -> np.ndarray: + rng = np.random.default_rng(seed) + return ( + rng.normal(size=(channels, ambient, rank)) + + 1j * rng.normal(size=(channels, ambient, rank)) + ) / np.sqrt(2.0 * ambient) + + +def _seeded_unitary(dimension: int, seed: int) -> np.ndarray: + rng = np.random.default_rng(seed) + matrix = rng.normal(size=(dimension, dimension)) + matrix = matrix + 1j * rng.normal(size=matrix.shape) + unitary, _ = np.linalg.qr(matrix) + return unitary + + +def test_local_panels_are_mean_zero_distinct_site_densities() -> None: + panels = local_density_panels( + length=4, + panel_size=8, + panels=6, + seed=71, + ) + assert panels.shape == (6, 8, 16) + np.testing.assert_allclose(np.sum(panels, axis=-1), 0.0, atol=1e-14) + assert np.all( + np.count_nonzero(np.abs(panels) > 1e-14, axis=-1) == 16 + ) + assert np.array_equal( + panels, + local_density_panels(4, 8, 6, 71), + ) + + +def test_fourier_panel_is_not_a_relabeling_of_local_panel() -> None: + local = local_density_panels(4, 8, 1, 71)[0] + fourier = fourier_density_panel(4, 8) + assert fourier.shape == local.shape + assert np.linalg.matrix_rank( + np.concatenate([local, fourier], axis=0) + ) > 8 + + +def test_channel_label_whitening_sets_covariance_to_identity() -> None: + channels = _synthetic_channels(seed=9) + whitened = whiten_channel_labels(channels, rtol=1e-12) + covariance = channel_covariance(whitened.channels) + np.testing.assert_allclose( + covariance, + np.eye(channels.shape[0]), + atol=1e-10, + ) + + +def test_singular_channel_support_fails_closed() -> None: + channels = _synthetic_channels(seed=9) + channels[1] = channels[0] + with pytest.raises(ValueError, match="channel-label support"): + whiten_channel_labels(channels, rtol=1e-10) + + +def test_isotropic_wick_coefficients_reduce_to_known_limits() -> None: + rng = np.random.default_rng(12) + channels = ( + rng.normal(size=(16, 20, 5)) + + 1j * rng.normal(size=(16, 20, 5)) + ) / np.sqrt(40.0) + result = covariance_matched_wick(channels) + assert result.A_left == pytest.approx(1.0, rel=0.08) + assert result.B_right == pytest.approx(5.0 / 20.0, rel=0.25) + + +def test_gram_reduction_matches_explicit_external_covariance() -> None: + channels = _synthetic_channels(seed=17, channels=4, ambient=9, rank=3) + explicit = np.mean( + np.einsum( + "mai,mbi->mab", + channels, + channels.conj(), + optimize=True, + ), + axis=0, + ) + explicit_values = np.linalg.eigvalsh(explicit) + explicit_values = explicit_values[explicit_values > 1e-12] + reduced = external_covariance_eigenvalues(channels) + np.testing.assert_allclose( + reduced, + explicit_values, + rtol=1e-10, + atol=1e-12, + ) + + +def test_r4_is_invariant_under_target_external_and_label_unitaries() -> None: + channels = _synthetic_channels(seed=21) + reference = covariance_matched_wick(channels).R4 + label = _seeded_unitary(channels.shape[0], seed=22) + external = _seeded_unitary(channels.shape[1], seed=23) + target = _seeded_unitary(channels.shape[2], seed=24) + transformed = np.einsum( + "mn,ab,nbj,jk->mak", + label, + external, + channels, + target, + optimize=True, + ) + observed = covariance_matched_wick(transformed).R4 + assert observed == pytest.approx(reference, abs=2e-10) + + +def test_matched_gaussian_reference_is_seed_reproducible() -> None: + physical = covariance_matched_wick(_synthetic_channels(seed=31)) + first = gaussian_r4_reference( + physical.left_eigenvalues, + physical.right_eigenvalues, + channel_count=8, + samples=64, + seed=32, + ) + second = gaussian_r4_reference( + physical.left_eigenvalues, + physical.right_eigenvalues, + channel_count=8, + samples=64, + seed=32, + ) + np.testing.assert_array_equal(first, second) + assert np.all(np.isfinite(first)) + assert np.quantile(first, 0.025) < np.quantile(first, 0.975) + + +def test_matched_gaussian_sampler_has_requested_shape() -> None: + rng = np.random.default_rng(41) + sample = sample_matched_gaussian_channels( + left_eigenvalues=np.array([0.4, 0.6]), + right_eigenvalues=np.array([0.2, 0.3, 0.5]), + channel_count=5, + rng=rng, + ) + assert sample.shape == (5, 3, 2) + assert np.all(np.isfinite(sample)) + + +def test_fast_gaussian_reference_estimator_matches_full_result() -> None: + channels = _synthetic_channels(seed=51) + physical = covariance_matched_wick(channels) + reference = gaussian_r4_reference( + physical.left_eigenvalues, + physical.right_eigenvalues, + channel_count=8, + samples=1, + seed=52, + ) + rng = np.random.default_rng(52) + sample = sample_matched_gaussian_channels( + physical.left_eigenvalues, + physical.right_eigenvalues, + channel_count=8, + rng=rng, + ) + assert reference[0] == pytest.approx( + covariance_matched_wick(sample).R4, + abs=2e-10, + ) diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/validate_citations_v1.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/validate_citations_v1.py new file mode 100644 index 000000000..ac168dbdb --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/validate_citations_v1.py @@ -0,0 +1,685 @@ +#!/usr/bin/env python3 +"""Validate the large-scale companion bibliography against primary metadata. + +The audit is intentionally explicit: every bibliography key is registered, +assigned to an intended manuscript section, and checked against a primary +identifier. No task_03 files or bibliography are imported. +""" + +from __future__ import annotations + +import argparse +import json +import re +import unicodedata +import urllib.parse +import urllib.request +import xml.etree.ElementTree as ET +from difflib import SequenceMatcher +from pathlib import Path +from typing import Any + + +SCRIPT_DIR = Path(__file__).resolve().parent +REPO_ROOT = SCRIPT_DIR.parents[2] +DEFAULT_BIB = ( + REPO_ROOT + / "overleaf_sync" + / "geometric_eth_large_scale" + / "references.bib" +) +DEFAULT_JSON = SCRIPT_DIR / "output" / "citation_audit_v1.json" +DEFAULT_MARKDOWN = ( + REPO_ROOT + / "docs" + / "literature" + / "2026-07-28-geometric-eth-large-scale-citation-audit.md" +) +USER_AGENT = ( + "Chaos-of-Quantum-Geometry citation audit/1.0 " + "(mailto:thomasjwang@users.noreply.github.com)" +) + + +def _record( + key: str, + title: str, + year: int, + authors: tuple[str, ...], + section: str, + *, + doi: str | None = None, + arxiv: str | None = None, +) -> dict[str, Any]: + return { + "key": key, + "title": title, + "year": year, + "authors": list(authors), + "section": section, + "doi": doi, + "arxiv": arxiv, + } + + +REGISTRY = ( + _record( + "berry1984", + "Quantal phase factors accompanying adiabatic changes", + 1984, + ("Berry",), + "geometric foundations", + doi="10.1098/rspa.1984.0023", + ), + _record( + "wilczekzee1984", + "Appearance of gauge structure in simple dynamical systems", + 1984, + ("Wilczek", "Zee"), + "geometric foundations", + doi="10.1103/PhysRevLett.52.2111", + ), + _record( + "provostvallee1980", + "Riemannian structure on manifolds of quantum states", + 1980, + ("Provost", "Vallee"), + "geometric foundations", + doi="10.1007/BF02193559", + ), + _record( + "kato1950", + "On the adiabatic theorem of quantum mechanics", + 1950, + ("Kato",), + "isolated-projector formalism", + doi="10.1143/JPSJ.5.435", + ), + _record( + "chen2026", + "Chaos of Berry curvature for BPS microstates", + 2026, + ("Chen", "Colin-Ellerin", "Mamroud", "Papadodimas"), + "geometric chaos motivation", + arxiv="2604.23287", + ), + _record( + "laughlin1983", + ( + "Anomalous quantum Hall effect: An incompressible quantum " + "fluid with fractionally charged excitations" + ), + 1983, + ("Laughlin",), + "Laughlin zero modes", + doi="10.1103/PhysRevLett.50.1395", + ), + _record( + "haldane1983", + ( + "Fractional quantization of the Hall effect: A hierarchy of " + "incompressible quantum fluid states" + ), + 1983, + ("Haldane",), + "fractional quantum Hall hierarchy", + doi="10.1103/PhysRevLett.51.605", + ), + _record( + "bernevighaldane2008", + "Model fractional quantum Hall states and Jack polynomials", + 2008, + ("Bernevig", "Haldane"), + "generalized exclusion rules", + doi="10.1103/PhysRevLett.100.246802", + ), + _record( + "chenseidel2015", + ( + "Algebraic approach to the study of zero modes of Haldane " + "pseudopotentials" + ), + 2015, + ("Chen", "Seidel"), + "zero-mode algebra", + doi="10.1103/PhysRevB.91.085103", + ), + _record( + "mooreread1991", + "Nonabelions in the fractional quantum Hall effect", + 1991, + ("Moore", "Read"), + "higher clustering", + doi="10.1016/0550-3213(91)90407-O", + ), + _record( + "readrezayi1999", + ( + "Beyond paired quantum Hall states: Parafermions and " + "incompressible states in the first excited Landau level" + ), + 1999, + ("Read", "Rezayi"), + "higher clustering", + doi="10.1103/PhysRevB.59.8084", + ), + _record( + "zhang2023", + ( + "From frustration-free parent Hamiltonians to off-diagonal " + "long-range order: Moore-Read and related states in second " + "quantization" + ), + 2023, + ("Fanmao Zhang", "Matheus Schossler", "Seidel", "Chen"), + "clustered root spaces", + doi="10.1103/PhysRevB.108.075142", + ), + _record( + "mazaheri2015", + ( + "Zero modes, bosonization, and topological quantum order: " + "The Laughlin state in second quantization" + ), + 2015, + ("Mazaheri", "Ortiz", "Nussinov", "Seidel"), + "zero-mode algebra", + doi="10.1103/PhysRevB.91.085115", + ), + _record( + "kapitmueller2010", + "Exact parent Hamiltonian for the quantum Hall states in a lattice", + 2010, + ("Kapit", "Mueller"), + "lattice validation", + doi="10.1103/PhysRevLett.105.215303", + ), + _record( + "leeqi2014", + ( + "Lattice construction of pseudopotential Hamiltonians for " + "fractional Chern insulators" + ), + 2014, + ("Lee", "Qi"), + "lattice pseudopotentials", + doi="10.1103/PhysRevB.90.085103", + ), + _record( + "neupert2011", + "Fractional quantum Hall states at zero magnetic field", + 2011, + ("Neupert", "Santos", "Chamon", "Mudry"), + "fractional Chern insulators", + doi="10.1103/PhysRevLett.106.236804", + ), + _record( + "bravyi2010", + "Topological quantum order: Stability under local perturbations", + 2010, + ("Bravyi", "Hastings", "Michalakis"), + "gapped-phase stability", + doi="10.1063/1.3490195", + ), + _record( + "bachmann2011", + ( + "Automorphic equivalence within gapped phases of quantum " + "lattice systems" + ), + 2011, + ("Bachmann", "Michalakis", "Nachtergaele", "Sims"), + "gapped-phase transport", + doi="10.1007/s00220-011-1380-0", + ), + _record( + "schuch2011", + ( + "Classifying quantum phases using matrix product states and " + "projected entangled pair states" + ), + 2011, + ("Schuch", "David Perez", "Cirac"), + "phase classification", + doi="10.1103/PhysRevB.84.165139", + ), + _record( + "hastingswen2005", + ( + "Quasiadiabatic continuation of quantum states: The stability " + "of topological ground-state degeneracy and emergent gauge " + "invariance" + ), + 2005, + ("Hastings", "Wen"), + "gapped-projector transport", + doi="10.1103/PhysRevB.72.045141", + ), + _record( + "collins2005", + ( + "Product of random projections, Jacobi ensembles and " + "universality problems arising from free probability" + ), + 2005, + ("Collins",), + "Jacobi null model", + doi="10.1007/s00440-005-0428-5", + ), + _record( + "zyczkowski2000", + "Truncations of random unitary matrices", + 2000, + ("Zyczkowski", "Sommers"), + "Haar compressions", + doi="10.1088/0305-4470/33/10/307", + ), + _record( + "atas2013", + ( + "Distribution of the ratio of consecutive level spacings in " + "random matrix ensembles" + ), + 2013, + ("Atas", "Bogomolny", "Giraud", "Roux"), + "local spectral statistics", + doi="10.1103/PhysRevLett.110.084101", + ), + _record( + "niuthoulesswu1985", + "Quantized Hall conductance as a topological invariant", + 1985, + ("Niu", "Thouless", "Wu"), + "many-body topology", + doi="10.1103/PhysRevB.31.3372", + ), + _record( + "kolodrubetz2017", + "Geometry and non-adiabatic response in quantum and classical systems", + 2017, + ("Kolodrubetz", "Sels", "Mehta", "Polkovnikov"), + "quantum geometric response", + doi="10.1016/j.physrep.2017.07.001", + ), + _record( + "bohigas1984", + ( + "Characterization of chaotic quantum spectra and universality " + "of level fluctuation laws" + ), + 1984, + ("Bohigas", "Giannoni", "Schmit"), + "random-matrix quantum chaos", + doi="10.1103/PhysRevLett.52.1", + ), + _record( + "deutsch1991", + "Quantum statistical mechanics in a closed system", + 1991, + ("Deutsch",), + "eigenstate thermalization", + doi="10.1103/PhysRevA.43.2046", + ), + _record( + "srednicki1994", + "Chaos and quantum thermalization", + 1994, + ("Srednicki",), + "eigenstate thermalization", + doi="10.1103/PhysRevE.50.888", + ), + _record( + "dalessio2016", + ( + "From quantum chaos and eigenstate thermalization to " + "statistical mechanics and thermodynamics" + ), + 2016, + ("D'Alessio", "Kafri", "Polkovnikov", "Rigol"), + "ETH review", + doi="10.1080/00018732.2016.1198134", + ), + _record( + "foinikurchan2019", + ( + "Eigenstate thermalization hypothesis and out of time order " + "correlators" + ), + 2019, + ("Foini", "Kurchan"), + "higher matrix-element correlations", + doi="10.1103/PhysRevE.99.042139", + ), + _record( + "pappalardi2022", + "Eigenstate Thermalization Hypothesis and Free Probability", + 2022, + ("Pappalardi", "Foini", "Kurchan"), + "full ETH and free cumulants", + doi="10.1103/PhysRevLett.129.170603", + ), + _record( + "fukui2005", + ( + "Chern Numbers in Discretized Brillouin Zone: Efficient Method " + "of Computing (Spin) Hall Conductances" + ), + 2005, + ("Fukui", "Hatsugai", "Suzuki"), + "discrete Chern links", + doi="10.1143/JPSJ.74.1674", + ), + _record( + "chenludwig2018", + ( + "Universal spectral correlations in the chaotic wave function, " + "and the development of quantum chaos" + ), + 2018, + ("Chen", "Ludwig"), + "non-energy spectral correlations", + doi="10.1103/PhysRevB.98.064309", + ), + _record( + "pandey2020", + "Adiabatic eigenstate deformations as a sensitive probe for quantum chaos", + 2020, + ("Pandey", "Claeys", "Campbell", "Polkovnikov", "Sels"), + "adiabatic deformation chaos diagnostic", + doi="10.1103/PhysRevX.10.041017", + ), + _record( + "sharipov2024", + "Hilbert space geometry and quantum chaos", + 2024, + ("Sharipov", "Tiutiakina", "Gorsky", "Gritsev", "Polkovnikov"), + "Hilbert-space geometry", + arxiv="2411.11968", + ), +) + + +def normalize(value: str) -> str: + """Return an accent-, punctuation-, and case-insensitive comparison key.""" + decomposed = unicodedata.normalize("NFKD", value) + ascii_text = decomposed.encode("ascii", "ignore").decode("ascii") + return "".join(character for character in ascii_text.lower() if character.isalnum()) + + +def _display_path(path: Path) -> str: + try: + return str(path.resolve().relative_to(REPO_ROOT)) + except ValueError: + return str(path.resolve()) + + +def parse_bibtex(path: Path) -> dict[str, str]: + """Parse entry blocks sufficiently strictly for a controlled local BibTeX.""" + text = path.read_text(encoding="utf-8") + matches = list( + re.finditer( + r"@\w+\s*\{\s*([^,\s]+)\s*,(.*?)(?=^@\w+\s*\{|\Z)", + text, + flags=re.DOTALL | re.MULTILINE, + ) + ) + keys = [match.group(1) for match in matches] + if len(keys) != len(set(keys)): + duplicates = sorted( + key for key in set(keys) if keys.count(key) > 1 + ) + raise ValueError(f"duplicate BibTeX keys: {duplicates}") + return {match.group(1): match.group(0) for match in matches} + + +def _request_json(url: str) -> dict[str, Any]: + request = urllib.request.Request( + url, + headers={"User-Agent": USER_AGENT, "Accept": "application/json"}, + ) + with urllib.request.urlopen(request, timeout=30) as response: + return json.loads(response.read().decode("utf-8")) + + +def fetch_doi_record(doi: str) -> dict[str, Any]: + encoded = urllib.parse.quote(doi, safe="") + data = _request_json( + f"https://api.openalex.org/works/https://doi.org/{encoded}" + ) + return { + "title": data["title"], + "year": int(data["publication_year"]), + "authors": [ + authorship["author"]["display_name"] + for authorship in data["authorships"] + ], + "identifier": data.get("doi", f"https://doi.org/{doi}"), + "metadata_source": "OpenAlex DOI resolution", + } + + +def fetch_arxiv_record(arxiv_id: str) -> dict[str, Any]: + url = ( + "https://export.arxiv.org/api/query?id_list=" + + urllib.parse.quote(arxiv_id) + ) + request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT}) + with urllib.request.urlopen(request, timeout=30) as response: + root = ET.fromstring(response.read()) + namespace = {"atom": "http://www.w3.org/2005/Atom"} + entry = root.find("atom:entry", namespace) + if entry is None: + raise LookupError(f"arXiv did not return {arxiv_id}") + title = " ".join( + (entry.findtext("atom:title", default="", namespaces=namespace)).split() + ) + published = entry.findtext( + "atom:published", + default="", + namespaces=namespace, + ) + authors = [ + author.findtext("atom:name", default="", namespaces=namespace) + for author in entry.findall("atom:author", namespace) + ] + return { + "title": title, + "year": int(published[:4]), + "authors": authors, + "identifier": f"https://arxiv.org/abs/{arxiv_id}", + "metadata_source": "arXiv Atom API", + } + + +def validate_record( + expected: dict[str, Any], + observed: dict[str, Any], +) -> dict[str, Any]: + expected_title = normalize(expected["title"]) + observed_title = normalize(observed["title"]) + title_similarity = SequenceMatcher( + None, + expected_title, + observed_title, + ).ratio() + observed_authors = normalize(" ".join(observed["authors"])) + author_matches = { + author: normalize(author) in observed_authors + for author in expected["authors"] + } + checks = { + "title": title_similarity >= 0.90, + "year": int(expected["year"]) == int(observed["year"]), + "authors": all(author_matches.values()), + } + return { + **expected, + "observed": observed, + "title_similarity": title_similarity, + "author_matches": author_matches, + "checks": checks, + "verified": all(checks.values()), + } + + +def _write_markdown(audit: dict[str, Any], path: Path) -> None: + lines = [ + "# Citation audit: *From Local Repulsion to Global Geometry*", + "", + ( + "Generated on 2026-07-28 by the task-local citation validator. " + "Each bibliography entry is assigned to an intended manuscript " + "section and resolved through a DOI or arXiv identifier." + ), + "", + f"Overall status: **{'PASS' if audit['all_checks_pass'] else 'FAIL'}**.", + "", + "| Key | Intended use | Verified metadata | Result |", + "|---|---|---|---|", + ] + for record in audit["records"]: + if record.get("doi"): + link = f"https://doi.org/{record['doi']}" + label = f"DOI {record['doi']}" + else: + link = f"https://arxiv.org/abs/{record['arxiv']}" + label = f"arXiv:{record['arxiv']}" + status = "PASS" if record["verified"] else "FAIL" + lines.append( + f"| `{record['key']}` | {record['section']} | " + f"[{label}]({link}) | **{status}** |" + ) + lines.extend( + [ + "", + "## Audit contract", + "", + ( + "The validator rejects an unresolved identifier, a title " + "similarity below 0.90, an incorrect publication year, a " + "missing registered author, a duplicate BibTeX key, an " + "unregistered bibliography entry, or a registered source " + "missing from the bibliography." + ), + "", + ( + "The citation map is intentionally article-specific. Passing " + "this audit establishes bibliographic identity; the final " + "delivery audit separately verifies that every key is cited " + "in the compiled manuscript or supplement." + ), + "", + ] + ) + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text("\n".join(lines), encoding="utf-8") + + +def run( + bib_path: Path = DEFAULT_BIB, + output_json: Path = DEFAULT_JSON, + output_markdown: Path = DEFAULT_MARKDOWN, + *, + observed_override: dict[str, dict[str, Any]] | None = None, +) -> dict[str, Any]: + entries = parse_bibtex(bib_path) + registry_by_key = {record["key"]: record for record in REGISTRY} + entry_keys = set(entries) + registry_keys = set(registry_by_key) + missing_bib = sorted(registry_keys - entry_keys) + unregistered_bib = sorted(entry_keys - registry_keys) + + results = [] + errors = [] + for expected in REGISTRY: + key = expected["key"] + try: + if observed_override is not None: + observed = observed_override[key] + elif expected["doi"]: + observed = fetch_doi_record(expected["doi"]) + else: + observed = fetch_arxiv_record(expected["arxiv"]) + result = validate_record(expected, observed) + except Exception as exc: # network/metadata failures are audit failures + result = { + **expected, + "verified": False, + "checks": { + "title": False, + "year": False, + "authors": False, + }, + "error": f"{type(exc).__name__}: {exc}", + } + errors.append({"key": key, "error": result["error"]}) + + entry = entries.get(key, "") + identifier_present = bool( + ( + expected["doi"] + and normalize(expected["doi"]) in normalize(entry) + ) + or ( + expected["arxiv"] + and expected["arxiv"] in entry + ) + ) + result["checks"]["identifier_in_bib"] = identifier_present + result["verified"] = bool(result["verified"] and identifier_present) + results.append(result) + + all_checks_pass = bool( + not missing_bib + and not unregistered_bib + and not errors + and all(result["verified"] for result in results) + ) + audit = { + "schema_version": 1, + "article": ( + "From Local Repulsion to Global Geometry: " + "Large-Scale Tests of Geometric ETH" + ), + "bibliography": _display_path(bib_path), + "registered_records": len(REGISTRY), + "bibliography_records": len(entries), + "missing_bibliography_keys": missing_bib, + "unregistered_bibliography_keys": unregistered_bib, + "errors": errors, + "records": results, + "all_checks_pass": all_checks_pass, + } + output_json.parent.mkdir(parents=True, exist_ok=True) + output_json.write_text( + json.dumps(audit, indent=2, sort_keys=True) + "\n", + encoding="utf-8", + ) + _write_markdown(audit, output_markdown) + if not all_checks_pass: + raise RuntimeError( + "citation audit failed; inspect " + f"{_display_path(output_json)}" + ) + return audit + + +def _parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--bib", type=Path, default=DEFAULT_BIB) + parser.add_argument("--json", type=Path, default=DEFAULT_JSON) + parser.add_argument("--markdown", type=Path, default=DEFAULT_MARKDOWN) + return parser.parse_args() + + +def main() -> None: + arguments = _parse_args() + audit = run(arguments.bib, arguments.json, arguments.markdown) + print( + "citation audit: PASS " + f"({audit['registered_records']} verified records)" + ) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_geometric_eth_topology_article_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_geometric_eth_topology_article_v3.py new file mode 100644 index 000000000..70760c08e --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_geometric_eth_topology_article_v3.py @@ -0,0 +1,282 @@ +#!/usr/bin/env python3 +"""Fail-closed delivery audit for the v3 integrated article.""" + +from __future__ import annotations + +import hashlib +import json +import re +import shutil +import subprocess +import tempfile +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from PIL import Image +from pypdf import PdfReader + + +SCRIPT_ROOT = Path(__file__).resolve().parent +REPO_ROOT = SCRIPT_ROOT.parents[2] +OUTPUT = SCRIPT_ROOT / "output" +ARTICLE = REPO_ROOT / "overleaf_sync" / "geometric_eth_large_scale" +FINAL_PDF = OUTPUT / "spectral_silence_and_geometric_chaos_v3.pdf" +AUDIT_JSON = OUTPUT / "geometric_eth_topology_delivery_audit_v3.json" +ARTICLE_TITLE = ( + "Spectral Silence and Geometric Chaos in an Exactly Degenerate " + "Topological Manifold" +) +MAIN_FIGURES = ( + "figure_1_spectral_silence_v2.pdf", + "figure_2_falsification_triangle_v2.pdf", + "figure_3_independent_channels_v2.pdf", + "figure_4_geometric_hierarchy_v2.pdf", + "figure_5_jacobi_atoms_v2.pdf", + "figure_6_wick_factorization_v3.pdf", + "figure_7_topological_holonomy_v3.pdf", +) + + +def _sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for block in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(block) + return digest.hexdigest() + + +def _load(path: Path) -> dict[str, Any]: + return json.loads(path.read_text(encoding="utf-8")) + + +def _render_records(pdf: Path) -> list[dict[str, Any]]: + with tempfile.TemporaryDirectory( + prefix="task05_v3_article_render_" + ) as directory: + root = Path(directory) + subprocess.run( + [ + "pdftoppm", + "-png", + "-r", + "180", + str(pdf), + str(root / "page"), + ], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + ) + records = [] + for index, path in enumerate(sorted(root.glob("page-*.png")), 1): + with Image.open(path) as image: + records.append( + { + "page": index, + "width": image.width, + "height": image.height, + "sha256": _sha256(path), + } + ) + return records + + +def _latex_checks(path: Path) -> dict[str, bool]: + text = path.read_text(encoding="utf-8", errors="replace").lower() + return { + "latex_control_sequences_resolved": ( + "undefined control sequence" not in text + ), + "latex_references_resolved": ( + "there were undefined references" not in text + and not re.search(r"reference [`'][^\n]+ undefined", text) + ), + "latex_citations_resolved": ( + "undefined citations" not in text + and not re.search(r"citation [`'][^\n]+ undefined", text) + ), + "latex_boxes_within_width": "overfull \\hbox" not in text, + "latex_floats_placed": "float is stuck" not in text, + } + + +def _normalize_pdf_text(text: str) -> str: + """Remove layout-only PDF extraction breaks without changing wording.""" + text = re.sub(r"(?<=\w)-\s+(?=\w)", "", text) + return re.sub(r"\s+", " ", text) + + +def run_audit() -> dict[str, Any]: + matrix = _load(OUTPUT / "matrix_element_geometric_eth_v3.json") + topology = _load(OUTPUT / "topological_holonomy_v3.json") + matrix_audit = _load(OUTPUT / "matrix_element_delivery_audit_v3.json") + topology_audit = _load( + OUTPUT / "topological_holonomy_delivery_audit_v3.json" + ) + theory = _load(OUTPUT / "matrix_element_topology_theory_v3.json") + assets = _load(OUTPUT / "geometric_eth_topology_assets_v3.json") + citations = _load(OUTPUT / "citation_audit_v1.json") + main_pdf = ARTICLE / "main.pdf" + shutil.copyfile(main_pdf, FINAL_PDF) + reader = PdfReader(str(main_pdf)) + metadata = reader.metadata or {} + extracted = _normalize_pdf_text( + "\n".join(page.extract_text() or "" for page in reader.pages) + ) + extracted_lower = extracted.lower() + render_records = _render_records(main_pdf) + figure_records = [] + for name in MAIN_FIGURES: + path = ARTICLE / "figures" / name + record = { + "name": name, + "sha256": _sha256(path), + "exists": path.is_file(), + } + if name.startswith("figure_6"): + record["source_hash_matches"] = ( + _sha256(path) + == _sha256(OUTPUT / "figure_6_wick_factorization_v3.pdf") + ) + elif name.startswith("figure_7"): + record["source_hash_matches"] = ( + _sha256(path) + == _sha256(OUTPUT / "figure_7_topological_holonomy_v3.pdf") + ) + else: + record["source_hash_matches"] = True + figure_records.append(record) + generated_sync = all( + _sha256(OUTPUT / name) + == _sha256(ARTICLE / "generated" / name) + for name in ("generated_numbers_v3.tex", "generated_tables_v3.tex") + ) + checks = { + "matrix_audit_passes": matrix_audit["passed"], + "topology_audit_passes": topology_audit["passed"], + "theory_audit_passes": theory["passed"], + "citation_audit_passes": citations["all_checks_pass"], + "matrix_branch_exact": ( + matrix["result_branch"] == "deformed_geometric_eth" + ), + "topology_branch_exact": ( + topology["result_branch"] + == "fixed_chern_deformed_holonomy" + ), + "asset_branches_exact": ( + assets["matrix_branch"] == matrix["result_branch"] + and assets["topology_branch"] == topology["result_branch"] + ), + "generated_assets_synchronized": generated_sync, + "seven_figures_present_and_synchronized": ( + len(figure_records) == 7 + and all( + item["exists"] and item["source_hash_matches"] + for item in figure_records + ) + ), + "pdf_archive_byte_identical": ( + _sha256(FINAL_PDF) == _sha256(main_pdf) + ), + "pdf_page_count": 15 <= len(reader.pages) <= 20, + "pdf_title_metadata": ( + str(metadata.get("/Title", "")) == ARTICLE_TITLE + ), + "pdf_author_metadata": ( + "Thomas J. Wang" in str(metadata.get("/Author", "")) + and "OKongOYangO" in str(metadata.get("/Author", "")) + ), + "affiliations_visible": ( + "Tsinghua University" in extracted + and "The Pennsylvania State University" in extracted + ), + "matrix_result_visible": ( + "four-channel residual" in extracted + and "progressive Gaussianization" in extracted + and "finite-size operator memory" in extracted + ), + "topology_result_visible": ( + "fixed determinantbundle topology" in extracted_lower + and "structured non-abelian holonomy" in extracted_lower + ), + "condensed_matter_mechanism_visible": ( + "frustration-free" in extracted_lower + and "condensedmatter mechanism" in extracted_lower + ), + "scientific_scope_visible": ( + "precise finite-size scope" in extracted + and "N = 6" in extracted + and "real-time dynamics" in extracted + ), + "code_and_data_availability_visible": ( + "code and data availability" in extracted_lower + and "run quick verify v1.sh" in extracted_lower + and "release manifest v1.json" in extracted_lower + ), + "all_pages_rendered_180dpi": ( + len(render_records) == len(reader.pages) + and all( + record["width"] == 1530 + and record["height"] == 1980 + for record in render_records + ) + ), + **_latex_checks(ARTICLE / "main.log"), + } + existing_timestamp = None + if AUDIT_JSON.is_file(): + existing_timestamp = _load(AUDIT_JSON).get("generated_utc") + result = { + "version": "v3", + "generated_utc": ( + existing_timestamp or datetime.now(timezone.utc).isoformat() + ), + "passed": all(checks.values()), + "checks": checks, + "matrix_branch": matrix["result_branch"], + "topology_branch": topology["result_branch"], + "page_count": len(reader.pages), + "main_pdf_sha256": _sha256(main_pdf), + "archived_pdf_sha256": _sha256(FINAL_PDF), + "figures": figure_records, + "rendered_pages": render_records, + "source_hashes": { + str(path.relative_to(REPO_ROOT)): _sha256(path) + for path in ( + ARTICLE / "main.tex", + ARTICLE / "sections" / "08-matrix-elements-topology.tex", + ARTICLE + / "appendices" + / "matrix-element-topology-v3.tex", + ARTICLE / "references.bib", + ) + }, + } + if not result["passed"]: + raise RuntimeError(f"v3 article audit failed: {checks}") + temporary = AUDIT_JSON.with_suffix(".json.tmp") + temporary.write_text( + json.dumps(result, indent=2, sort_keys=True), + encoding="utf-8", + ) + temporary.replace(AUDIT_JSON) + return result + + +def main() -> None: + result = run_audit() + print(json.dumps( + { + "passed": result["passed"], + "checks": result["checks"], + "page_count": result["page_count"], + "main_pdf_sha256": result["main_pdf_sha256"], + }, + indent=2, + sort_keys=True, + )) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_large_scale_article_v1.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_large_scale_article_v1.py new file mode 100644 index 000000000..323e66481 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_large_scale_article_v1.py @@ -0,0 +1,360 @@ +#!/usr/bin/env python3 +"""Fail-closed delivery audit for the large-scale Geometric-ETH article.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import re +import subprocess +import tempfile +from pathlib import Path +from typing import Any + +from PIL import Image +from pypdf import PdfReader + + +SCRIPT_DIR = Path(__file__).resolve().parent +TASK_DIR = SCRIPT_DIR.parent +REPO_ROOT = TASK_DIR.parents[1] +OUTPUT = SCRIPT_DIR / "output" +ARTICLE = REPO_ROOT / "overleaf_sync" / "geometric_eth_large_scale" +REGISTERED_CASES = ( + (8, 16, 80, 2_000), + (10, 50, 140, 2_000), + (12, 112, 216, 2_000), + (14, 210, 308, 1_000), + (16, 352, 416, 1_000), + (18, 546, 540, 500), + (20, 800, 680, 250), +) +REGISTERED_ARCHIVE_SHA256 = ( + "aae68de7569aae83c7ff500718ab0e3635595f050f5b7afc0d60a0e63db55417" +) + + +def _sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for chunk in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def _load(path: Path) -> dict[str, Any]: + return json.loads(path.read_text(encoding="utf-8")) + + +def _bibtex_keys(path: Path) -> set[str]: + return set( + re.findall( + r"@\w+\s*\{\s*([^,\s]+)", + path.read_text(encoding="utf-8"), + ) + ) + + +def _cited_keys() -> set[str]: + keys: set[str] = set() + sources = [ + ARTICLE / "main.tex", + *sorted((ARTICLE / "sections").glob("*.tex")), + *sorted((ARTICLE / "appendices").glob("*.tex")), + ] + for source in sources: + text = source.read_text(encoding="utf-8") + for content in re.findall(r"\\cite\w*\{([^}]+)\}", text): + keys.update(key.strip() for key in content.split(",")) + return keys + + +def _render_pdf(pdf: Path) -> list[dict[str, Any]]: + with tempfile.TemporaryDirectory(prefix="task05_render_") as directory: + root = Path(directory) + subprocess.run( + [ + "pdftoppm", + "-png", + "-r", + "150", + str(pdf), + str(root / "page"), + ], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + ) + records = [] + for index, path in enumerate(sorted(root.glob("page-*.png")), 1): + with Image.open(path) as image: + records.append( + { + "page": index, + "width": image.width, + "height": image.height, + "sha256": _sha256(path), + } + ) + return records + + +def _latex_log_checks(log_path: Path) -> dict[str, bool]: + text = log_path.read_text(encoding="utf-8", errors="replace") + lowered = text.lower() + return { + "no_undefined_control_sequence": ( + "undefined control sequence" not in lowered + ), + "no_undefined_references": ( + "there were undefined references" not in lowered + and "reference `" not in lowered + ), + "no_undefined_citations": ( + "undefined citations" not in lowered + and not re.search(r"citation [`'][^\\n]+ undefined", lowered) + ), + "no_overfull_boxes": "overfull \\hbox" not in lowered, + "no_stuck_floats": "float is stuck" not in lowered, + } + + +def run(output_json: Path) -> dict[str, Any]: + physical = _load(OUTPUT / "physical_ensemble_v1.json") + covariance = _load(OUTPUT / "covariance_model_v1.json") + scaling = _load(OUTPUT / "rank_scaling_v1.json") + statistics = _load(OUTPUT / "statistical_analysis_v1.json") + manifest = _load(OUTPUT / "figure_manifest_v1.json") + citations = _load(OUTPUT / "citation_audit_v1.json") + + expected_cases = [ + {"n": n, "D": D, "M": M, "samples": samples} + for n, D, M, samples in REGISTERED_CASES + ] + observed_cases = [ + { + "n": case["n"], + "D": case["D"], + "M": case["M"], + "samples": case["samples"], + } + for case in scaling["cases"] + ] + largest = scaling["cases"][-1] + inference_methods = [ + content[metric]["method"] + for content in statistics["ensemble_inference"].values() + for metric in content + ] + + input_hashes_match = True + for raw_path, expected_hash in manifest["inputs"].items(): + path = SCRIPT_DIR / raw_path + input_hashes_match &= path.exists() and _sha256(path) == expected_hash + figure_hashes_match = True + synchronized_figures = True + for figure in manifest["figures"].values(): + pdf = SCRIPT_DIR / figure["pdf"] + png = SCRIPT_DIR / figure["png"] + figure_hashes_match &= ( + pdf.exists() + and png.exists() + and _sha256(pdf) == figure["pdf_sha256"] + and _sha256(png) == figure["png_sha256"] + ) + overleaf_pdf = ARTICLE / "figures" / pdf.name + synchronized_figures &= ( + overleaf_pdf.exists() + and _sha256(overleaf_pdf) == _sha256(pdf) + ) + generated_sync = all( + ( + ARTICLE / "generated" / name + ).exists() + and _sha256(ARTICLE / "generated" / name) + == _sha256(OUTPUT / name) + for name in ("generated_numbers_v1.tex", "generated_tables_v1.tex") + ) + + archived_pdf = ( + OUTPUT / "from_local_repulsion_to_global_geometry_v1.pdf" + ) + # The live Overleaf tree is allowed to advance to v2. Audit the immutable + # v1 archive by its registered delivery hash rather than requiring the + # moving ``main.pdf`` to remain byte-identical to the earlier article. + main_pdf = archived_pdf + reader = PdfReader(str(main_pdf)) + metadata = reader.metadata or {} + title = str(metadata.get("/Title", "")) + author = str(metadata.get("/Author", "")) + extracted = "\n".join( + page.extract_text() or "" for page in reader.pages + ) + render_records = _render_pdf(main_pdf) + bib_keys = _bibtex_keys(ARTICLE / "references.bib") + cited_keys = _cited_keys() + pytest_path = OUTPUT / "pytest_v1.txt" + pytest_text = ( + pytest_path.read_text(encoding="utf-8") + if pytest_path.exists() + else "" + ) + match = re.search(r"(\d+) passed", pytest_text) + pytest_passed = int(match.group(1)) if match else None + + checks = { + "physical_registered_scale": ( + physical["sample_count"] == 20_000 + and physical["split"] + == { + "train": 12_000, + "validation": 4_000, + "test": 4_000, + "split_seed": physical["seed"] + 1, + } + and physical["seed_blocks"] == 8 + and physical["physical_case"]["D"] == 50 + and physical["all_checks_pass"] + ), + "covariance_registered_scale": ( + covariance["diagnostic_training_rows"] >= 1_024 + and covariance["haar_samples"] == 10_000 + and covariance["deformed_samples"] == 10_000 + and covariance["held_out_test"]["result_branch"] + == "leading_covariance_capture" + and covariance["all_checks_pass"] + ), + "rank_cases_and_samples_exact": observed_cases == expected_cases, + "largest_rank_present": largest["D"] == 800, + "exact_atom_counts": ( + scaling["cases"][-2]["plus_atoms_per_matrix"] == 6 + and scaling["cases"][-2]["minus_atoms_per_matrix"] == 6 + and largest["plus_atoms_per_matrix"] == 120 + and largest["minus_atoms_per_matrix"] == 120 + ), + "interior_statistics_strip_atoms": all( + case["interior_dimension"] + == case["D"] + - case["plus_atoms_per_matrix"] + - case["minus_atoms_per_matrix"] + for case in scaling["cases"] + ), + "matrix_level_inference_only": ( + statistics["bootstrap_replicates"] == 10_000 + and all( + method + in { + "hierarchical_seed_block_bootstrap", + "matrix_gaussian_multiplier_bootstrap", + "matrix_bootstrap", + } + for method in inference_methods + ) + and all( + "eigenvalue" not in method for method in inference_methods + ) + ), + "statistics_checks_pass": statistics["all_checks_pass"], + "figure_inputs_hashed": input_hashes_match, + "figure_outputs_hashed": figure_hashes_match, + "figures_synchronized": synchronized_figures, + "generated_inputs_synchronized": generated_sync, + "citation_metadata_verified": ( + citations["all_checks_pass"] + and citations["registered_records"] >= 29 + ), + "all_citation_keys_resolve": cited_keys <= bib_keys, + "chen_seed_is_cited": "chen2026" in cited_keys, + "article_pdf_archived": ( + archived_pdf.exists() + and _sha256(archived_pdf) == REGISTERED_ARCHIVE_SHA256 + ), + "pdf_page_count_in_contract": 10 <= len(reader.pages) <= 14, + "pdf_title_metadata": ( + title + == ( + "From Local Repulsion to Global Geometry: " + "Large-Scale Tests of Geometric ETH" + ) + ), + "pdf_author_metadata": ( + "Thomas J. Wang" in author and "OKongOYangO" in author + ), + "pdf_affiliations_visible": ( + "Tsinghua University" in extracted + and "The Pennsylvania State University" in extracted + ), + "all_pdf_pages_rendered": ( + len(render_records) == len(reader.pages) + and all( + record["width"] > 0 and record["height"] > 0 + for record in render_records + ) + ), + **_latex_log_checks(ARTICLE / "main.log"), + "pytest_complete_if_recorded": ( + pytest_passed is None or pytest_passed >= 1 + ), + } + audit = { + "schema_version": 1, + "article": ( + "From Local Repulsion to Global Geometry: " + "Large-Scale Tests of Geometric ETH" + ), + "checks": checks, + "all_checks_pass": bool(all(checks.values())), + "pdf": { + "path": str(main_pdf.relative_to(REPO_ROOT)), + "sha256": _sha256(main_pdf), + "pages": len(reader.pages), + "title": title, + "author": author, + }, + "rendered_pages": render_records, + "pytest_passed": pytest_passed, + "registered_scale": { + "physical_matrices": physical["sample_count"], + "haar_matrices": covariance["haar_samples"], + "deformed_matrices": covariance["deformed_samples"], + "root_matrices": sum( + case["samples"] for case in scaling["cases"] + ), + "maximum_rank": largest["D"], + }, + } + output_json.parent.mkdir(parents=True, exist_ok=True) + output_json.write_text( + json.dumps(audit, indent=2) + "\n", + encoding="utf-8", + ) + if not audit["all_checks_pass"]: + failed = [key for key, value in checks.items() if not value] + raise RuntimeError(f"large-scale delivery audit failed: {failed}") + return audit + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--output-json", + type=Path, + default=OUTPUT / "large_scale_delivery_audit_v1.json", + ) + args = parser.parse_args() + audit = run(args.output_json) + print( + json.dumps( + { + "all_checks_pass": audit["all_checks_pass"], + "pdf": audit["pdf"], + "pytest_passed": audit["pytest_passed"], + }, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_matrix_element_geometric_eth_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_matrix_element_geometric_eth_v3.py new file mode 100644 index 000000000..0a07cd1e3 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_matrix_element_geometric_eth_v3.py @@ -0,0 +1,203 @@ +#!/usr/bin/env python3 +"""Fail-closed audit for matrix-element Geometric ETH artifacts.""" + +from __future__ import annotations + +import ast +import hashlib +import json +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from run_matrix_element_geometric_eth_v3 import ( + CHECKPOINT_ROOT, + OUTPUT_JSON, + OUTPUT_NPZ, + SCRIPT_ROOT, + select_result_branch, +) + + +OUTPUT_ROOT = SCRIPT_ROOT / "output" +FIGURE_MANIFEST = OUTPUT_ROOT / "figure_manifest_v3.json" +FIGURE_PDF = OUTPUT_ROOT / "figure_6_wick_factorization_v3.pdf" +FIGURE_PNG = OUTPUT_ROOT / "figure_6_wick_factorization_v3.png" +AUDIT_JSON = OUTPUT_ROOT / "matrix_element_delivery_audit_v3.json" +RELEASE_MANIFEST = OUTPUT_ROOT / "release_manifest_v1.json" + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def _isolated_task_sources() -> bool: + for source in SCRIPT_ROOT.rglob("*.py"): + tree = ast.parse(source.read_text(encoding="utf-8")) + for node in ast.walk(tree): + if isinstance(node, ast.Import): + modules = [alias.name for alias in node.names] + elif isinstance(node, ast.ImportFrom): + modules = [node.module or ""] + else: + continue + if any( + "task_03" in module + or "task_04" in module + or "qgeom" in module + or "gaccess" in module + for module in modules + ): + return False + return True + + +def audit_payload(payload: dict[str, Any]) -> dict[str, bool]: + """Recompute every scientific gate from a loaded result payload.""" + + cases = payload["cases"] + expected = [(3, 8, 16), (4, 10, 25), (5, 12, 36)] + observed = [ + (case["N"], case["n_flux"], case["rank"]) + for case in cases + ] + checks = { + "registered_sequence": observed == expected, + "fixed_two_quasiholes": all( + case["n_flux"] == 2 * case["N"] + 2 + for case in cases + ), + "all_runner_checks": all(payload["checks"].values()), + "all_case_checks": all( + all(case["checks"].values()) for case in cases + ), + "reference_counts": ( + payload["configuration"]["gaussian_samples"] == 2_000 + ), + "panel_counts": payload["configuration"]["panels"] == 24, + "panel_size": payload["configuration"]["panel_size"] == 8, + "kernel_residuals": all( + case["kernel_residual_norm"] + < (1e-8 if case["kernel_method"] == "dense" else 5e-7) + for case in cases + ), + "resolvent_residuals": all( + case["maximum_relative_residual"] < 2e-3 + for case in cases + ), + "gauge_invariance": all( + case["gauge_invariance_error"] < 2e-9 + for case in cases + ), + "branch_recomputed": ( + payload["result_branch"] == select_result_branch(payload) + ), + "n2_exclusion": ( + payload["excluded_small_case"]["expected_rank"] == 9 + and payload["excluded_small_case"]["observed_rank"] == 12 + and payload["excluded_small_case"]["accepted"] is False + ), + } + if not all(checks.values()): + raise AssertionError(f"matrix-element payload audit failed: {checks}") + return checks + + +def run_audit() -> dict[str, Any]: + payload = json.loads(OUTPUT_JSON.read_text(encoding="utf-8")) + checks = audit_payload(payload) + manifest = json.loads(FIGURE_MANIFEST.read_text(encoding="utf-8")) + figure = manifest["figure_6_wick_factorization_v3"] + checkpoint_files = sorted(CHECKPOINT_ROOT.glob("N*_site_response_v3.*")) + previous_audit = ( + json.loads(AUDIT_JSON.read_text(encoding="utf-8")) + if AUDIT_JSON.exists() + else {} + ) + if len(checkpoint_files) == 6: + checkpoint_hashes = { + str(path.relative_to(SCRIPT_ROOT)): _sha256(path) + for path in checkpoint_files + } + checkpoint_provenance = True + else: + checkpoint_hashes = previous_audit.get("checkpoint_hashes", {}) + release = json.loads(RELEASE_MANIFEST.read_text(encoding="utf-8")) + external_hashes = { + Path(record["path"]).name: record["sha256"] + for record in release["external_artifacts"] + if "matrix_element_v3_checkpoints" in record["path"] + } + archived_npz_hashes = { + Path(path).name: digest + for path, digest in checkpoint_hashes.items() + if path.endswith(".npz") + } + checkpoint_provenance = ( + len(checkpoint_hashes) == 6 + and external_hashes == archived_npz_hashes + ) + checks.update( + { + "npz_hash": payload["npz_sha256"] == _sha256(OUTPUT_NPZ), + "figure_source_hash": ( + figure["source_sha256"] == _sha256(OUTPUT_JSON) + ), + "figure_pdf_hash": ( + figure["pdf_sha256"] == _sha256(FIGURE_PDF) + ), + "figure_png_hash": ( + figure["png_sha256"] == _sha256(FIGURE_PNG) + ), + "checkpoint_provenance": checkpoint_provenance, + "task_isolation": _isolated_task_sources(), + } + ) + result = { + "version": "v3", + "generated_utc": previous_audit.get( + "generated_utc", datetime.now(timezone.utc).isoformat() + ), + "passed": all(checks.values()), + "checks": checks, + "result_branch": payload["result_branch"], + "registered_cases": [ + [case["N"], case["n_flux"], case["rank"]] + for case in payload["cases"] + ], + "result_sha256": _sha256(OUTPUT_JSON), + "arrays_sha256": _sha256(OUTPUT_NPZ), + "checkpoint_hashes": checkpoint_hashes, + "figure": { + "pdf": str(FIGURE_PDF.relative_to(SCRIPT_ROOT)), + "pdf_sha256": _sha256(FIGURE_PDF), + "png": str(FIGURE_PNG.relative_to(SCRIPT_ROOT)), + "png_sha256": _sha256(FIGURE_PNG), + }, + } + if not result["passed"]: + raise RuntimeError(f"matrix-element delivery audit failed: {checks}") + temporary = AUDIT_JSON.with_suffix(".json.tmp") + temporary.write_text( + json.dumps(result, indent=2, sort_keys=True), + encoding="utf-8", + ) + temporary.replace(AUDIT_JSON) + return result + + +def main() -> None: + result = run_audit() + print(json.dumps( + { + "passed": result["passed"], + "checks": result["checks"], + "result_branch": result["result_branch"], + }, + indent=2, + sort_keys=True, + )) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_matrix_element_topology_theory_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_matrix_element_topology_theory_v3.py new file mode 100644 index 000000000..db5a4ab6f --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_matrix_element_topology_theory_v3.py @@ -0,0 +1,220 @@ +#!/usr/bin/env python3 +"""Executable checks for the v3 Wick and topology derivations.""" + +from __future__ import annotations + +import json +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np +from scipy.linalg import expm + +from lgeth.bundle_geometry import analyze_ambient_frame_mesh +from lgeth.wick_channels import covariance_matched_wick + + +SCRIPT_ROOT = Path(__file__).resolve().parent +OUTPUT = SCRIPT_ROOT / "output" / "matrix_element_topology_theory_v3.json" + + +def _seeded_unitary(dimension: int, rng: np.random.Generator) -> np.ndarray: + matrix = rng.normal(size=(dimension, dimension)) + matrix = matrix + 1j * rng.normal(size=matrix.shape) + q, r = np.linalg.qr(matrix) + phases = np.diag(r) + return q * (phases / np.abs(phases)).conj()[None, :] + + +def wick_identity_check( + D: int = 4, + M: int = 7, + channels: int = 4, + samples: int = 20_000, + seed: int = 20260729500, +) -> dict[str, float]: + """Compare the two analytic Wick contractions with direct sampling.""" + + rng = np.random.default_rng(seed) + left = np.linspace(0.7, 1.6, D) + right = np.linspace(0.5, 1.7, M) + right *= D / (np.sum(left) * np.sum(right)) + A_left = D * np.sum(left**2) / np.sum(left) ** 2 + B_right = D * np.sum(right**2) / np.sum(right) ** 2 + identity = np.eye(channels) + expected = ( + A_left * np.einsum("mn,rs->mnrs", identity, identity) + + B_right * np.einsum("ms,rn->mnrs", identity, identity) + ) + accumulated = np.zeros_like(expected, dtype=complex) + batch = 250 + completed = 0 + while completed < samples: + count = min(batch, samples - completed) + gaussian = ( + rng.normal(size=(count, channels, M, D)) + + 1j * rng.normal(size=(count, channels, M, D)) + ) / np.sqrt(2.0) + values = ( + np.sqrt(right)[None, None, :, None] + * gaussian + * np.sqrt(left)[None, None, None, :] + ) + pair = np.einsum( + "zmai,znaj->zmnij", + values.conj(), + values, + optimize=True, + ) + tensor = np.einsum( + "zmnij,zrsji->zmnrs", + pair, + pair, + optimize=True, + ) / D + accumulated += np.sum(tensor, axis=0) + completed += count + observed = accumulated / samples + return { + "A_left": float(A_left), + "B_right": float(B_right), + "relative_error": float( + np.linalg.norm(observed - expected) / np.linalg.norm(expected) + ), + "maximum_absolute_error": float( + np.max(np.abs(observed - expected)) + ), + } + + +def gauge_and_gram_check( + seed: int = 20260729501, +) -> dict[str, float]: + """Check gauge invariance and the nonzero Gram-spectrum reduction.""" + + rng = np.random.default_rng(seed) + channels = ( + rng.normal(size=(5, 9, 4)) + + 1j * rng.normal(size=(5, 9, 4)) + ) / np.sqrt(18.0) + original = covariance_matched_wick(channels) + external = _seeded_unitary(9, rng) + target = _seeded_unitary(4, rng) + transformed = np.einsum( + "ab,mbi,ij->maj", + external.conj().T, + channels, + target, + optimize=True, + ) + gauged = covariance_matched_wick(transformed) + matrix = channels.transpose(1, 0, 2).reshape(9, -1) + R = matrix @ matrix.conj().T / channels.shape[0] + G = matrix.conj().T @ matrix / channels.shape[0] + eigen_R = np.linalg.eigvalsh(0.5 * (R + R.conj().T)) + eigen_G = np.linalg.eigvalsh(0.5 * (G + G.conj().T)) + nonzero_R = eigen_R[eigen_R > 1e-12 * eigen_R[-1]] + nonzero_G = eigen_G[eigen_G > 1e-12 * eigen_G[-1]] + return { + "R4_error": abs(original.R4 - gauged.R4), + "tensor_error": float( + np.max(np.abs(original.tensor - gauged.tensor)) + ), + "gram_spectrum_error": float( + np.max(np.abs(nonzero_R - nonzero_G)) + ), + } + + +def _qiwuzhang_mesh(mesh: int, mass: float = -1.0) -> np.ndarray: + frames = np.empty((mesh, mesh, 2, 1), dtype=complex) + momenta = 2.0 * np.pi * np.arange(mesh) / mesh + for ix, kx in enumerate(momenta): + for iy, ky in enumerate(momenta): + hamiltonian = np.array( + [ + [ + mass + np.cos(kx) + np.cos(ky), + np.sin(kx) - 1j * np.sin(ky), + ], + [ + np.sin(kx) + 1j * np.sin(ky), + -mass - np.cos(kx) - np.cos(ky), + ], + ], + dtype=complex, + ) + _, vectors = np.linalg.eigh(hamiltonian) + frames[ix, iy, :, 0] = vectors[:, 0] + return frames + + +def periodic_unitary_chern_check(mesh: int = 24) -> dict[str, float]: + """Check Chern invariance under a smooth periodic ambient unitary.""" + + frames = _qiwuzhang_mesh(mesh) + deformed = np.empty_like(frames) + sigma_x = np.array([[0.0, 1.0], [1.0, 0.0]], dtype=complex) + sigma_z = np.diag([1.0, -1.0]).astype(complex) + angles = 2.0 * np.pi * np.arange(mesh) / mesh + for ix, theta_x in enumerate(angles): + for iy, theta_y in enumerate(angles): + unitary = expm(0.7j * np.sin(theta_x) * sigma_x) + unitary = unitary @ expm( + 0.5j * np.sin(theta_y) * sigma_z + ) + deformed[ix, iy] = unitary @ frames[ix, iy] + before = analyze_ambient_frame_mesh(frames) + after = analyze_ambient_frame_mesh(deformed) + return { + "chern_before": before.chern_determinant, + "chern_after": after.chern_determinant, + "chern_error": abs( + before.chern_determinant - after.chern_determinant + ), + "minimum_branch_margin": min( + before.determinant_branch_margin, + after.determinant_branch_margin, + ), + } + + +def run_checks() -> dict[str, Any]: + wick = wick_identity_check() + gauge = gauge_and_gram_check() + topology = periodic_unitary_chern_check() + checks = { + "wick_monte_carlo": wick["relative_error"] < 0.04, + "gauge_tensor": gauge["tensor_error"] < 1e-10, + "gauge_R4": gauge["R4_error"] < 1e-10, + "gram_reduction": gauge["gram_spectrum_error"] < 1e-10, + "chern_isomorphism": topology["chern_error"] < 1e-10, + "chern_branch": topology["minimum_branch_margin"] > 0.0, + } + result = { + "version": "v3", + "generated_utc": datetime.now(timezone.utc).isoformat(), + "passed": all(checks.values()), + "checks": checks, + "wick": wick, + "gauge_and_gram": gauge, + "topology": topology, + } + if not result["passed"]: + raise RuntimeError(f"v3 theory checks failed: {result}") + temporary = OUTPUT.with_suffix(".json.tmp") + temporary.write_text( + json.dumps(result, indent=2, sort_keys=True), + encoding="utf-8", + ) + temporary.replace(OUTPUT) + return result + + +def main() -> None: + print(json.dumps(run_checks(), indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_release_contract_v1.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_release_contract_v1.py new file mode 100644 index 000000000..1b7cf212f --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_release_contract_v1.py @@ -0,0 +1,218 @@ +#!/usr/bin/env python3 +"""Fail-closed verification of the task-05 public release contract.""" + +from __future__ import annotations + +import argparse +import ast +import hashlib +import json +import os +import re +import subprocess +from pathlib import Path +from typing import Any + +import yaml + + +SCRIPT_ROOT = Path(__file__).resolve().parent +DEFAULT_REPO_ROOT = SCRIPT_ROOT.parents[2] +DEFAULT_MANIFEST = SCRIPT_ROOT / "output" / "release_manifest_v1.json" +REGISTERED_BRANCHES = { + "matrix_element": "deformed_geometric_eth", + "topology": "fixed_chern_deformed_holonomy", +} +FORBIDDEN_IMPORTS = {"task_03", "task_04", "qgeom", "gaccess"} +CACHE_PARTS = {"__pycache__", ".pytest_cache", ".DS_Store"} + + +def _sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for block in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(block) + return digest.hexdigest() + + +def _record_matches(record: dict[str, Any], repo_root: Path) -> bool: + path = repo_root / record.get("path", "") + return ( + path.is_file() + and path.stat().st_size == record.get("size_bytes") + and _sha256(path) == record.get("sha256") + ) + + +def _tracked_files(repo_root: Path) -> list[Path]: + result = subprocess.run( + ["git", "ls-files", "-z"], + cwd=repo_root, + check=True, + capture_output=True, + ) + return [ + repo_root / item.decode("utf-8") + for item in result.stdout.split(b"\0") + if item + ] + + +def _task_isolated(repo_root: Path) -> bool: + source = repo_root / "01_task_folder" / "task_05" / "script" + for path in source.rglob("*.py"): + tree = ast.parse(path.read_text(encoding="utf-8")) + for node in ast.walk(tree): + if isinstance(node, ast.Import): + for alias in node.names: + if alias.name.split(".", 1)[0] in FORBIDDEN_IMPORTS: + return False + elif isinstance(node, ast.ImportFrom): + module = node.module or "" + if module.split(".", 1)[0] in FORBIDDEN_IMPORTS: + return False + return True + + +def _local_links_valid(path: Path) -> bool: + text = path.read_text(encoding="utf-8") + for target in re.findall(r"\[[^\]]*\]\(([^)]+)\)", text): + if target.startswith(("http://", "https://", "#")): + continue + local = target.split("#", 1)[0] + if local and not (path.parent / local).resolve().exists(): + return False + return True + + +def _citation_valid(repo_root: Path) -> bool: + path = repo_root / "CITATION.cff" + if not path.is_file(): + return False + data = yaml.safe_load(path.read_text(encoding="utf-8")) + return ( + data.get("cff-version") == "1.2.0" + and data.get("title") + == ( + "Spectral Silence and Geometric Chaos in an Exactly " + "Degenerate Topological Manifold" + ) + and data.get("license") == "GPL-3.0-only" + and len(data.get("authors", [])) == 2 + ) + + +def verify_manifest(path: Path, *, repo_root: Path) -> dict[str, Any]: + repo_root = repo_root.resolve() + manifest = json.loads(path.read_text(encoding="utf-8")) + tracked = _tracked_files(repo_root) + release_tracked = [ + item + for item in tracked + if item.relative_to(repo_root).as_posix().startswith( + ( + "01_task_folder/task_05/", + "overleaf_sync/geometric_eth_large_scale/", + ) + ) + ] + max_bytes = int( + os.environ.get("TASK05_RELEASE_MAX_TRACKED_BYTES", 10 * 1024 * 1024) + ) + figures = manifest.get("figures", []) + compact = manifest.get("compact_artifacts", []) + external = manifest.get("external_artifacts", []) + + checks = { + "schema_version": manifest.get("schema_version") == 1, + "release_id": ( + manifest.get("release_id") == "task05-geometric-chaos-v1" + ), + "registered_result_branches": ( + manifest.get("result_branches") == REGISTERED_BRANCHES + ), + "paper_record": ( + manifest.get("paper", {}).get("page_count") == 17 + and _record_matches(manifest.get("paper", {}), repo_root) + ), + "seven_figures": ( + len(figures) == 7 + and all(_record_matches(item, repo_root) for item in figures) + ), + "compact_artifacts": ( + bool(compact) + and all(_record_matches(item, repo_root) for item in compact) + ), + "external_records": ( + len(external) == 25 + and all( + item.get("storage_class") == "recompute_or_release_asset" + and isinstance(item.get("size_bytes"), int) + and item["size_bytes"] > 0 + and len(item.get("sha256", "")) == 64 + and bool(item.get("producer")) + for item in external + ) + ), + "verification_commands": ( + manifest.get("verification", {}).get("quick") + == "bash run_quick_verify_v1.sh" + and manifest.get("verification", {}).get("full") + == "bash run_full_recompute_v1.sh" + ), + "tracked_blob_limit": all( + not item.is_file() or item.stat().st_size <= max_bytes + for item in release_tracked + ), + "no_tracked_caches": all( + not CACHE_PARTS.intersection(item.parts) for item in tracked + ), + "task_runtime_isolated": _task_isolated(repo_root), + "public_readmes": ( + _local_links_valid(repo_root / "README.md") + and _local_links_valid( + repo_root / "01_task_folder" / "task_05" / "README.md" + ) + ), + "citation_metadata": _citation_valid(repo_root), + "release_notes": ( + repo_root / "docs" / "2026-07-30-task05-release-notes.md" + ).is_file(), + "technical_report": ( + repo_root / "docs" / "2026-07-30-task05-technical-report.md" + ).is_file(), + "pr_handoff": all( + ( + repo_root / "docs" / name + ).is_file() + for name in ( + "2026-07-30-task05-pr-body.md", + "2026-07-30-task05-pr-review-comment.md", + "2026-07-30-task05-public-release-checklist.md", + ) + ), + "challenge_handoff": ( + repo_root + / "docs" + / "2026-07-30-quantum-geometry-harness-challenge-draft.md" + ).is_file(), + } + return {"passed": all(checks.values()), "checks": checks} + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "manifest", type=Path, nargs="?", default=DEFAULT_MANIFEST + ) + parser.add_argument("--repo-root", type=Path, default=DEFAULT_REPO_ROOT) + args = parser.parse_args() + + report = verify_manifest(args.manifest, repo_root=args.repo_root) + print(json.dumps(report, indent=2, sort_keys=True)) + if not report["passed"]: + raise SystemExit(1) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_spectral_silence_article_v2.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_spectral_silence_article_v2.py new file mode 100755 index 000000000..8ad316e0d --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_spectral_silence_article_v2.py @@ -0,0 +1,474 @@ +#!/usr/bin/env python3 +"""Fail-closed audit for the spectral-silence/geometric-chaos article.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import re +import subprocess +import tempfile +from pathlib import Path +from typing import Any + +import numpy as np +from PIL import Image +from pypdf import PdfReader + + +SCRIPT_DIR = Path(__file__).resolve().parent +TASK_DIR = SCRIPT_DIR.parent +REPO_ROOT = TASK_DIR.parents[1] +OUTPUT = SCRIPT_DIR / "output" +ARTICLE = REPO_ROOT / "overleaf_sync" / "geometric_eth_large_scale" +ARTICLE_TITLE = ( + "Spectral Silence and Geometric Chaos in an Exactly Degenerate " + "Topological Manifold" +) +ARCHIVED_PDF = OUTPUT / "spectral_silence_and_geometric_chaos_v2.pdf" +REGISTERED_ARCHIVE_SHA256 = ( + "5d51ad4997a8cc95fa60fdafa02ef5aa13ad86cd31f10764b61a8f8903c2895c" +) +V2_SOURCES = ( + SCRIPT_DIR / "lgeth" / "form_factors.py", + SCRIPT_DIR / "lgeth" / "controls.py", + SCRIPT_DIR / "run_spectral_silence_v2.py", + SCRIPT_DIR / "run_spectral_silence_statistics_v2.py", + SCRIPT_DIR / "make_spectral_silence_figures_v2.py", + Path(__file__).resolve(), +) + + +def _sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for block in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(block) + return digest.hexdigest() + + +def _load(path: Path) -> dict[str, Any]: + return json.loads(path.read_text(encoding="utf-8")) + + +def _bibtex_keys(path: Path) -> set[str]: + return set( + re.findall( + r"@\w+\s*\{\s*([^,\s]+)", + path.read_text(encoding="utf-8"), + ) + ) + + +def _tex_sources() -> list[Path]: + return [ + ARTICLE / "main.tex", + *sorted((ARTICLE / "sections").glob("*.tex")), + *sorted((ARTICLE / "appendices").glob("*.tex")), + ] + + +def _cited_keys() -> set[str]: + keys: set[str] = set() + for source in _tex_sources(): + text = source.read_text(encoding="utf-8") + for content in re.findall(r"\\cite\w*\{([^}]+)\}", text): + keys.update(key.strip() for key in content.split(",")) + return keys + + +def _render_pdf(pdf: Path) -> list[dict[str, Any]]: + with tempfile.TemporaryDirectory( + prefix="task05_spectral_silence_render_" + ) as directory: + root = Path(directory) + subprocess.run( + [ + "pdftoppm", + "-png", + "-r", + "150", + str(pdf), + str(root / "page"), + ], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + ) + records: list[dict[str, Any]] = [] + for index, path in enumerate(sorted(root.glob("page-*.png")), 1): + with Image.open(path) as image: + records.append( + { + "page": index, + "width": image.width, + "height": image.height, + "sha256": _sha256(path), + } + ) + return records + + +def _latex_log_checks(log_path: Path) -> dict[str, bool]: + text = log_path.read_text(encoding="utf-8", errors="replace") + lowered = text.lower() + return { + "no_undefined_control_sequence": ( + "undefined control sequence" not in lowered + ), + "no_undefined_references": ( + "there were undefined references" not in lowered + and not re.search(r"reference [`'][^\n]+ undefined", lowered) + ), + "no_undefined_citations": ( + "undefined citations" not in lowered + and not re.search(r"citation [`'][^\n]+ undefined", lowered) + ), + "no_overfull_boxes": "overfull \\hbox" not in lowered, + "no_stuck_floats": "float is stuck" not in lowered, + } + + +def _manifest_checks( + manifest: dict[str, Any], +) -> tuple[bool, bool, bool]: + input_hashes = all( + Path(raw_path).is_file() + and _sha256(Path(raw_path)) == expected_hash + for raw_path, expected_hash in manifest["inputs"].items() + ) + figure_hashes = True + figure_sync = True + for figure in manifest["figures"].values(): + pdf = Path(figure["pdf"]) + png = Path(figure["png"]) + figure_hashes &= bool( + pdf.is_file() + and png.is_file() + and _sha256(pdf) == figure["pdf_sha256"] + and _sha256(png) == figure["png_sha256"] + ) + target = ARTICLE / "figures" / pdf.name + figure_sync &= bool( + target.is_file() and _sha256(target) == _sha256(pdf) + ) + return input_hashes, figure_hashes, figure_sync + + +def _new_reference_metadata_passes(bib_text: str) -> bool: + required_fragments = ( + "@article{pandey2020", + "10.1103/PhysRevX.10.041017", + "2004.05043", + "@misc{sharipov2024", + "2411.11968", + "@article{chenludwig2018", + "10.1103/PhysRevB.98.064309", + "1710.02686", + "@misc{chen2026", + "2604.23287", + ) + return all(fragment in bib_text for fragment in required_fragments) + + +def run(output_json: Path) -> dict[str, Any]: + source_json = _load(OUTPUT / "spectral_silence_v2.json") + statistics_json = _load( + OUTPUT / "spectral_silence_statistics_v2.json" + ) + manifest = _load(OUTPUT / "figure_manifest_v2.json") + physical_v1 = _load(OUTPUT / "physical_ensemble_v1.json") + covariance_v1 = _load(OUTPUT / "covariance_model_v1.json") + scaling_v1 = _load(OUTPUT / "rank_scaling_v1.json") + with ( + np.load( + OUTPUT / "spectral_silence_v2.npz", + allow_pickle=False, + ) as source, + np.load( + OUTPUT / "spectral_silence_statistics_v2.npz", + allow_pickle=False, + ) as statistics, + ): + energy_exact = bool( + np.array_equal(source["energy_raw"], np.full(121, 50.0)) + and np.array_equal(source["energy_connected"], np.zeros(121)) + ) + structured_control = bool( + source["structured_spectra"].shape == (24, 50) + and np.all(source["structured_active_ranks"] == 50) + and int(np.max(source["structured_unique_counts"])) <= 10 + and np.unique(source["structured_orbit_id"]).size == 12 + ) + geometry_axis = bool( + source["g_spectra"].shape == (7, 4000, 50) + and np.all(source["g_active_ranks"] == 50) + and np.allclose( + source["g_values"], + [0.02, 0.05, 0.10, 0.20, 0.40, 0.70, 1.00], + ) + ) + spectral_axis = bool( + source["energy_spectra_alpha"].shape == (8, 4000, 50) + and np.allclose( + source["alpha_values"], + [0.0, 0.10, 0.20, 0.35, 0.50, 0.70, 0.85, 1.00], + ) + and float(np.max(source["projector_distance_alpha"])) < 1e-12 + and float(np.max(source["curvature_error_alpha"])) < 1e-12 + ) + atom_data = bool( + int(source["rank_D"][-1]) == 800 + and int(source["rank_interior"][-1]) == 560 + and int(source["rank_atom_each"][-1]) == 120 + and abs( + float(source["rank_interior"][-1]) + / float(source["rank_D"][-1]) + - 0.7 + ) + < 1e-12 + ) + statistics_arrays = bool( + statistics["g_form_mean"].shape == (7, 121) + and statistics["energy_gap_ratio_mean"].shape == (8,) + and statistics["rank_physical_connected_full"].shape + == (7, 121) + ) + + input_hashes, figure_hashes, figure_sync = _manifest_checks(manifest) + generated_sync = all( + (ARTICLE / "generated" / name).is_file() + and _sha256(ARTICLE / "generated" / name) + == _sha256(OUTPUT / name) + for name in ( + "generated_numbers_v2.tex", + "generated_tables_v2.tex", + ) + ) + + # v2 is an immutable archived delivery. The live Overleaf tree may advance + # to later article versions without invalidating this historical audit. + main_pdf = ARCHIVED_PDF + reader = PdfReader(str(main_pdf)) + metadata = reader.metadata or {} + title = str(metadata.get("/Title", "")) + author = str(metadata.get("/Author", "")) + extracted = "\n".join( + page.extract_text() or "" for page in reader.pages + ) + render_records = _render_pdf(main_pdf) + source_text = "\n".join( + path.read_text(encoding="utf-8") for path in _tex_sources() + ) + bib_path = ARTICLE / "references.bib" + bib_text = bib_path.read_text(encoding="utf-8") + bib_keys = _bibtex_keys(bib_path) + cited_keys = _cited_keys() + forbidden_task_import = any( + re.search(r"task_0[0-46-9]", path.read_text(encoding="utf-8")) + for path in V2_SOURCES + ) + + outcomes = statistics_json["outcomes"] + physics_hierarchy = bool( + abs(outcomes["physical_tau_compatibility_onset"] - 0.25) < 1e-12 + and abs( + outcomes["first_g_with_haar_gap_ratio_interval"] - 0.20 + ) + < 1e-7 + and abs( + outcomes["first_g_with_registered_jacobi_window"] - 0.40 + ) + < 1e-7 + and abs( + outcomes["number_variance_compatibility_extent"] - 1.0 + ) + < 1e-12 + and outcomes["number_variance_L8_residual"]["lower"] > 0.0 + ) + endpoint_separation = bool( + outcomes["energy_gap_ratio_endpoints"]["poisson_upper"] + < outcomes["energy_gap_ratio_endpoints"]["gue_lower"] + ) + v1_retained = bool( + physical_v1["all_checks_pass"] + and physical_v1["sample_count"] == 20_000 + and covariance_v1["all_checks_pass"] + and covariance_v1["held_out_test"]["result_branch"] + == "leading_covariance_capture" + and scaling_v1["all_checks_pass"] + and scaling_v1["cases"][-1]["D"] == 800 + ) + + pytest_path = OUTPUT / "pytest_v2.txt" + pytest_text = ( + pytest_path.read_text(encoding="utf-8") + if pytest_path.exists() + else "" + ) + match = re.search(r"(\d+) passed", pytest_text) + pytest_passed = int(match.group(1)) if match else None + + checks = { + "source_artifact_passes": bool(source_json["all_checks_pass"]), + "statistical_artifact_passes": bool( + statistics_json["all_checks_pass"] + ), + "figure_manifest_passes": bool(manifest["all_checks_pass"]), + "exact_energy_silence": energy_exact, + "same_rank_structured_control": structured_control, + "registered_geometry_axis": geometry_axis, + "registered_spectral_axis": spectral_axis, + "spectral_endpoint_confidence_separated": endpoint_separation, + "finite_jacobi_numerics_pass": bool( + source_json["finite_jacobi"]["mass_error"] < 1e-10 + and source_json["finite_jacobi"]["orthogonality_error"] < 1e-10 + and source_json["finite_jacobi"]["atom_relation_error"] < 1e-12 + and source_json["finite_jacobi"]["raw_atom_closure_error"] < 1e-10 + ), + "atom_plateau_data_exact": atom_data, + "registered_hierarchy_resolved": physics_hierarchy, + "statistical_arrays_complete": statistics_arrays, + "bootstrap_replicates_exact": ( + statistics_json["bootstrap_replicates"] == 10_000 + ), + "v1_large_scale_evidence_retained": v1_retained, + "figure_inputs_hashed": input_hashes, + "figure_outputs_hashed": figure_hashes, + "figures_synchronized": figure_sync, + "generated_inputs_synchronized": generated_sync, + "all_citation_keys_resolve": cited_keys <= bib_keys, + "new_reference_metadata_registered": ( + _new_reference_metadata_passes(bib_text) + ), + "chen_program_positioned": ( + "chen2026" in cited_keys + and "pandey2020" in cited_keys + and "sharipov2024" in cited_keys + and "chenludwig2018" in cited_keys + ), + "no_cross_task_v2_runtime_dependency": not forbidden_task_import, + "article_pdf_archived": bool( + ARCHIVED_PDF.is_file() + and _sha256(ARCHIVED_PDF) == REGISTERED_ARCHIVE_SHA256 + ), + "pdf_page_count_in_contract": 10 <= len(reader.pages) <= 15, + "pdf_title_metadata": title == ARTICLE_TITLE, + "pdf_author_metadata": ( + "Thomas J. Wang" in author and "OKongOYangO" in author + ), + "pdf_affiliations_visible": ( + "Tsinghua University" in extracted + and "The Pennsylvania State University" in extracted + ), + "headline_claim_visible": ( + "Exact degeneracy makes the energy spectrum silent" + in source_text + and "projector geometry retains" in source_text + ), + "time_caveat_visible": ( + "not physical time" in source_text + and "not an out-of-time-order correlator" in source_text + ), + "non_susy_scope_visible": ( + "no SUSY cohomology" in extracted + and "no gravitational interpretation" in extracted + ), + "all_pdf_pages_rendered": ( + len(render_records) == len(reader.pages) + and all( + record["width"] == 1275 and record["height"] == 1650 + for record in render_records + ) + ), + **_latex_log_checks(ARTICLE / "main.log"), + "pytest_complete_if_recorded": ( + pytest_passed is None or pytest_passed >= 1 + ), + } + audit = { + "schema_version": 2, + "article": ARTICLE_TITLE, + "checks": checks, + "all_checks_pass": bool(all(checks.values())), + "pdf": { + "path": str(main_pdf.relative_to(REPO_ROOT)), + "archived_path": str(ARCHIVED_PDF.relative_to(REPO_ROOT)), + "sha256": _sha256(main_pdf), + "pages": len(reader.pages), + "title": title, + "author": author, + }, + "rendered_pages": render_records, + "pytest_passed": pytest_passed, + "registered_scale": { + "physical_matrices": physical_v1["sample_count"], + "physical_test_matrices": 4_000, + "structured_momenta": 24, + "structured_orbits": 12, + "geometric_interpolation_matrices": 7 * 4_000, + "spectral_interpolation_matrices": 8 * 4_000, + "haar_matrices": covariance_v1["haar_samples"], + "root_matrices": sum( + case["samples"] for case in scaling_v1["cases"] + ), + "maximum_rank": scaling_v1["cases"][-1]["D"], + "bootstrap_replicates": ( + statistics_json["bootstrap_replicates"] + ), + }, + "supported_conclusion": { + "energy_connected_sff": 0.0, + "physical_jacobi_tau_onset": ( + outcomes["physical_tau_compatibility_onset"] + ), + "geometric_local_onset": ( + outcomes["first_g_with_haar_gap_ratio_interval"] + ), + "geometric_ramp_onset": ( + outcomes["first_g_with_registered_jacobi_window"] + ), + "number_variance_compatibility_extent": ( + outcomes["number_variance_compatibility_extent"] + ), + "D800_connected_plateau": 0.7, + }, + } + output_json.parent.mkdir(parents=True, exist_ok=True) + output_json.write_text( + json.dumps(audit, indent=2) + "\n", + encoding="utf-8", + ) + if not audit["all_checks_pass"]: + failed = [key for key, value in checks.items() if not value] + raise RuntimeError( + f"spectral-silence delivery audit failed: {failed}" + ) + return audit + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--output-json", + type=Path, + default=OUTPUT / "spectral_silence_delivery_audit_v2.json", + ) + args = parser.parse_args() + audit = run(args.output_json) + print( + json.dumps( + { + "all_checks_pass": audit["all_checks_pass"], + "pdf": audit["pdf"], + "pytest_passed": audit["pytest_passed"], + "registered_scale": audit["registered_scale"], + }, + indent=2, + ) + ) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_susy_hodge_delivery_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_susy_hodge_delivery_v7.py new file mode 100644 index 000000000..1ab2d1592 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_susy_hodge_delivery_v7.py @@ -0,0 +1,302 @@ +#!/usr/bin/env python3 +"""Fail-closed scientific and provenance audit for SUSY/Hodge v7.""" + +from __future__ import annotations + +import json +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from analyze_susy_hodge_geometric_eth_v7 import ( + N14_INFERENCE_JSON, + N14_PREDICTION_JSON, + N14_PREDICTION_NPZ, + N14_PREDICTION_SEAL, + N14_SAFE_JSON, + N14_UNSEALED_JSON, + select_frozen_branch, +) +from generate_susy_hodge_controls_v7 import OUTPUT_JSON as CONTROLS_JSON +from merge_susy_hodge_pilot_v7 import ( + OUTPUT_JSON as PILOT_BANK_JSON, + OUTPUT_NPZ as PILOT_BANK_NPZ, +) +from make_susy_hodge_figure_v7 import ( + FIGURE_PDF, + FIGURE_PNG, + MANIFEST_JSON as FIGURE_MANIFEST, + REPORT_MD, +) +from run_susy_hodge_geometric_eth_v7 import _atomic_json, sha256 + + +SCRIPT_ROOT = Path(__file__).resolve().parent +OUTPUT_JSON = SCRIPT_ROOT / "output" / "susy_hodge_delivery_audit_v7.json" +FORBIDDEN_SAFE_TOKENS = ("r4", "four_point", "connected") + + +def _load(path: Path) -> dict[str, Any] | None: + try: + payload = json.loads(Path(path).read_text(encoding="utf-8")) + except (FileNotFoundError, json.JSONDecodeError, OSError): + return None + return payload if isinstance(payload, dict) else None + + +def _passed(payload: dict[str, Any] | None) -> bool: + return bool( + payload + and payload.get("version") == "v7" + and payload.get("passed") + and all(payload.get("checks", {}).values()) + ) + + +def _matches_hash(path: Path, expected: object) -> bool: + try: + return isinstance(expected, str) and sha256(path) == expected + except (FileNotFoundError, OSError): + return False + + +def _seal_hash(source: Path, seal: Path) -> str | None: + try: + fields = Path(seal).read_text(encoding="utf-8").strip().split() + except (FileNotFoundError, OSError): + return None + if len(fields) != 2 or fields[1] != Path(source).name: + return None + return fields[0] if _matches_hash(source, fields[0]) else None + + +def _safe_serialization(path: Path) -> bool: + try: + serialized = Path(path).read_text(encoding="utf-8").lower() + except (FileNotFoundError, OSError): + return False + return not any(token in serialized for token in FORBIDDEN_SAFE_TOKENS) + + +def _timestamp_order( + prediction: dict[str, Any] | None, + unsealed: dict[str, Any] | None, +) -> bool: + try: + prediction_time = datetime.fromisoformat(str(prediction["generated_utc"])) + unsealed_time = datetime.fromisoformat(str(unsealed["unsealed_utc"])) + except (KeyError, TypeError, ValueError): + return False + return unsealed_time > prediction_time + + +def _exact_grid(payload: dict[str, Any] | None) -> bool: + if not payload: + return False + expected = { + (N, sector, panel) + for N in (8, 10, 12) + for sector in ("central", "adjacent") + for panel in ("sparse", "isotropic") + } + try: + observed = { + (int(item["N"]), str(item["sector"]), str(item["panel_kind"])) + for item in payload["groups"] + } + except (KeyError, TypeError, ValueError): + return False + return observed == expected + + +def _primary_pair(payload: dict[str, Any] | None, key: str) -> bool: + if not payload: + return False + try: + observed = { + (int(item["N"]), str(item["sector"]), str(item["panel_kind"])) + for item in payload[key] + } + except (KeyError, TypeError, ValueError): + return False + return observed == {(14, "central", "sparse"), (14, "adjacent", "sparse")} + + +def _recomputed_branch(inference: dict[str, Any] | None) -> str | None: + if not inference: + return None + try: + records = inference["primary_pair"] + collapsed = all(bool(item["collapsed_covered"]) for item in records) + hodge = all(bool(item["hodge_covered"]) for item in records) + structured = bool(inference.get("structured_indistinguishable", False)) + resolved = bool( + inference.get("checks", {}).get("registered_branch_resolved", False) + ) + except (KeyError, TypeError): + return None + return select_frozen_branch(collapsed, hodge, structured, resolved) + + +def _figure_hashes( + manifest: dict[str, Any] | None, + *, + pilot_json: Path, + inference_json: Path, + figure_pdf: Path, + figure_png: Path, + report_md: Path, +) -> bool: + if not manifest: + return False + inputs = manifest.get("inputs", {}) + outputs = manifest.get("outputs", {}) + return all( + ( + _matches_hash( + pilot_json, inputs.get(Path(pilot_json).name) + ), + _matches_hash( + inference_json, inputs.get(Path(inference_json).name) + ), + _matches_hash( + figure_pdf, outputs.get(Path(figure_pdf).name) + ), + _matches_hash( + figure_png, outputs.get(Path(figure_png).name) + ), + _matches_hash( + report_md, outputs.get(Path(report_md).name) + ), + ) + ) + + +def verify_delivery( + *, + pilot_json: Path = PILOT_BANK_JSON, + pilot_npz: Path = PILOT_BANK_NPZ, + safe_json: Path = N14_SAFE_JSON, + prediction_json: Path = N14_PREDICTION_JSON, + prediction_npz: Path = N14_PREDICTION_NPZ, + prediction_seal: Path = N14_PREDICTION_SEAL, + unsealed_json: Path = N14_UNSEALED_JSON, + inference_json: Path = N14_INFERENCE_JSON, + controls_json: Path = CONTROLS_JSON, + figure_manifest: Path = FIGURE_MANIFEST, + figure_pdf: Path = FIGURE_PDF, + figure_png: Path = FIGURE_PNG, + report_md: Path = REPORT_MD, + output_json: Path = OUTPUT_JSON, +) -> dict[str, Any]: + """Audit every compact artifact and return checks instead of trusting prose.""" + + paths = { + "pilot_json": Path(pilot_json), + "pilot_npz": Path(pilot_npz), + "safe_json": Path(safe_json), + "prediction_json": Path(prediction_json), + "prediction_npz": Path(prediction_npz), + "prediction_seal": Path(prediction_seal), + "unsealed_json": Path(unsealed_json), + "inference_json": Path(inference_json), + "controls_json": Path(controls_json), + "figure_manifest": Path(figure_manifest), + "figure_pdf": Path(figure_pdf), + "figure_png": Path(figure_png), + "report_md": Path(report_md), + } + pilot = _load(paths["pilot_json"]) + safe = _load(paths["safe_json"]) + prediction = _load(paths["prediction_json"]) + unsealed = _load(paths["unsealed_json"]) + inference = _load(paths["inference_json"]) + controls = _load(paths["controls_json"]) + figure = _load(paths["figure_manifest"]) + seal_hash = _seal_hash(paths["prediction_json"], paths["prediction_seal"]) + recomputed_branch = _recomputed_branch(inference) + try: + report_text = paths["report_md"].read_text(encoding="utf-8") + except (FileNotFoundError, OSError): + report_text = "" + checks = { + "all_required_files_exist": all(path.is_file() for path in paths.values()), + "pilot_passed": _passed(pilot), + "complete_pilot_grid": _exact_grid(pilot), + "pilot_array_hash": bool(pilot) + and _matches_hash(paths["pilot_npz"], pilot.get("arrays_sha256")), + "safe_covariates_passed": bool(safe) and bool(safe.get("passed")), + "safe_covariates_have_no_outcome_leakage": _safe_serialization( + paths["safe_json"] + ), + "prediction_passed": _passed(prediction), + "complete_prediction_primary_pair": _primary_pair(prediction, "primary_pair"), + "prediction_array_hash": bool(prediction) + and _matches_hash( + paths["prediction_npz"], prediction.get("prediction_arrays_sha256") + ), + "prediction_safe_covariate_hash": bool(prediction) + and _matches_hash(paths["safe_json"], prediction.get("safe_covariates_sha256")), + "prediction_has_no_outcome_leakage": _safe_serialization( + paths["prediction_json"] + ), + "valid_prediction_seal": seal_hash is not None, + "unsealed_passed": _passed(unsealed), + "prediction_precedes_unseal": _timestamp_order(prediction, unsealed), + "unsealed_references_prediction": bool(unsealed) + and seal_hash is not None + and unsealed.get("prediction_sha256") == seal_hash, + "inference_passed": _passed(inference), + "complete_inference_primary_pair": _primary_pair(inference, "primary_pair"), + "inference_references_prediction": bool(inference) + and seal_hash is not None + and inference.get("prediction_sha256") == seal_hash, + "selected_branch_recomputed": bool(inference) + and recomputed_branch == inference.get("selected_branch"), + "analytic_controls_passed": _passed(controls), + "curvature_atom_control": bool(controls) + and bool(controls.get("checks", {}).get("N6_curvature_atoms")), + "one_sided_control": bool(controls) + and bool(controls.get("checks", {}).get("one_sided_exact_regression")), + "figure_manifest_passed": _passed(figure), + "figure_and_report_hashes": _figure_hashes( + figure, + pilot_json=paths["pilot_json"], + inference_json=paths["inference_json"], + figure_pdf=paths["figure_pdf"], + figure_png=paths["figure_png"], + report_md=paths["report_md"], + ), + "figure_branch_matches_inference": bool(figure and inference) + and figure.get("selected_branch") == inference.get("selected_branch"), + "report_has_claim_boundary_and_sources": bool(inference) + and "## Established" in report_text + and "## Not established" in report_text + and "](https://" in report_text + and str(inference.get("selected_branch")) in report_text, + } + payload = { + "version": "v7", + "generated_utc": datetime.now(timezone.utc).isoformat(), + "selected_branch": inference.get("selected_branch") if inference else None, + "recomputed_branch": recomputed_branch, + "prediction_sha256": seal_hash, + "artifact_hashes": { + key: sha256(path) for key, path in paths.items() if path.is_file() + }, + "checks": checks, + "passed": all(checks.values()), + } + _atomic_json(output_json, payload) + return payload + + +def main() -> None: + payload = verify_delivery() + print(json.dumps(payload, indent=2, sort_keys=True)) + if not payload["passed"]: + raise SystemExit(1) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_susy_hodge_manuscript_v7.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_susy_hodge_manuscript_v7.py new file mode 100644 index 000000000..66e77d5d7 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_susy_hodge_manuscript_v7.py @@ -0,0 +1,197 @@ +#!/usr/bin/env python3 +"""Verify the result-bearing v7 manuscript after compilation.""" + +from __future__ import annotations + +import json +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from make_susy_hodge_manuscript_assets_v7 import ( + FIGURE_TARGET, + MANIFEST_JSON as ASSET_MANIFEST_JSON, + MANUSCRIPT_ROOT, + RESULTS_TEX, +) +from run_susy_hodge_geometric_eth_v7 import _atomic_json, sha256 + + +SCRIPT_ROOT = Path(__file__).resolve().parent +OUTPUT_JSON = SCRIPT_ROOT / "output" / "susy_hodge_manuscript_audit_v7.json" +ARCHIVE_PDF = SCRIPT_ROOT / "output" / "response_complex_memory_v7.pdf" +SUPPLEMENT_TEX = MANUSCRIPT_ROOT / "supplement.tex" +SUPPLEMENT_PDF = MANUSCRIPT_ROOT / "supplement.pdf" +SUPPLEMENT_LOG = MANUSCRIPT_ROOT / "supplement.log" +SUPPLEMENT_ARCHIVE_PDF = ( + SCRIPT_ROOT / "output" / "response_complex_memory_supplement_v7.pdf" +) +MAIN_TEX = MANUSCRIPT_ROOT / "main.tex" +MAIN_PDF = MANUSCRIPT_ROOT / "main.pdf" +MAIN_LOG = MANUSCRIPT_ROOT / "main.log" + + +def _load(path: Path) -> dict[str, Any] | None: + try: + payload = json.loads(Path(path).read_text(encoding="utf-8")) + except (FileNotFoundError, json.JSONDecodeError, OSError): + return None + return payload if isinstance(payload, dict) else None + + +def _valid_pdf(path: Path) -> bool: + try: + data = Path(path).read_bytes() + except (FileNotFoundError, OSError): + return False + return ( + len(data) > 1024 + and data.startswith(b"%PDF-") + and b"%%EOF" in data[-1024:] + ) + + +def _matches_hash(path: Path, expected: object) -> bool: + try: + return isinstance(expected, str) and sha256(path) == expected + except (FileNotFoundError, OSError): + return False + + +def _same_hash(first: Path, second: Path) -> bool: + try: + return sha256(first) == sha256(second) + except (FileNotFoundError, OSError): + return False + + +def verify_manuscript( + *, + asset_manifest_json: Path = ASSET_MANIFEST_JSON, + main_tex: Path = MAIN_TEX, + results_tex: Path = RESULTS_TEX, + figure_pdf: Path = FIGURE_TARGET, + main_pdf: Path = MAIN_PDF, + archive_pdf: Path = ARCHIVE_PDF, + main_log: Path = MAIN_LOG, + supplement_tex: Path = SUPPLEMENT_TEX, + supplement_pdf: Path = SUPPLEMENT_PDF, + supplement_archive_pdf: Path = SUPPLEMENT_ARCHIVE_PDF, + supplement_log: Path = SUPPLEMENT_LOG, + output_json: Path = OUTPUT_JSON, +) -> dict[str, Any]: + """Audit source activation, copied assets, compilation, and claim branch.""" + + manifest = _load(asset_manifest_json) + try: + main_source = Path(main_tex).read_text(encoding="utf-8") + supplement_source = Path(supplement_tex).read_text(encoding="utf-8") + result_source = Path(results_tex).read_text(encoding="utf-8") + log_text = Path(main_log).read_text(encoding="utf-8").lower() + supplement_log_text = Path(supplement_log).read_text( + encoding="utf-8" + ).lower() + except (FileNotFoundError, OSError): + main_source = "" + supplement_source = "" + result_source = "" + log_text = "" + supplement_log_text = "" + outputs = manifest.get("outputs", {}) if manifest else {} + branch = str(manifest.get("selected_branch", "")) if manifest else "" + checks = { + "asset_manifest_passed": bool( + manifest + and manifest.get("version") == "v7" + and manifest.get("passed") + and all(manifest.get("checks", {}).values()) + ), + "result_source_hash": bool(manifest) + and _matches_hash( + Path(results_tex), outputs.get(Path(results_tex).name) + ), + "figure_source_hash": bool(manifest) + and _matches_hash( + Path(figure_pdf), outputs.get(Path(figure_pdf).name) + ), + "main_uses_generated_results": r"\input{generated/results_v7.tex}" + in main_source, + "supplement_uses_generated_results": r"\input{generated/results_v7.tex}" + in supplement_source, + "heldout_result_enabled": r"\heldoutcompletetrue" in result_source + and r"\heldoutcompletefalse" not in result_source, + "selected_branch_in_source": bool(branch) + and branch.replace("_", r"\_") in result_source, + "compiled_pdf_structure": _valid_pdf(main_pdf), + "archived_pdf_exact": _valid_pdf(archive_pdf) + and _same_hash(Path(archive_pdf), Path(main_pdf)), + "compiled_supplement_structure": _valid_pdf(supplement_pdf), + "archived_supplement_exact": _valid_pdf(supplement_archive_pdf) + and _same_hash(Path(supplement_archive_pdf), Path(supplement_pdf)), + "clean_latex_log": bool(log_text) + and not any( + token in log_text + for token in ( + "undefined citation", + "undefined references", + "overfull \\hbox", + "overfull \\vbox", + "underfull \\hbox", + "emergency stop", + "fatal error", + ) + ), + "clean_supplement_log": bool(supplement_log_text) + and not any( + token in supplement_log_text + for token in ( + "undefined citation", + "undefined references", + "overfull \\hbox", + "overfull \\vbox", + "underfull \\hbox", + "emergency stop", + "fatal error", + ) + ), + } + payload = { + "version": "v7", + "generated_utc": datetime.now(timezone.utc).isoformat(), + "selected_branch": branch or None, + "prediction_sha256": ( + manifest.get("prediction_sha256") if manifest else None + ), + "artifact_hashes": { + path.name: sha256(path) + for path in ( + Path(asset_manifest_json), + Path(main_tex), + Path(results_tex), + Path(figure_pdf), + Path(main_pdf), + Path(archive_pdf), + Path(main_log), + Path(supplement_tex), + Path(supplement_pdf), + Path(supplement_archive_pdf), + Path(supplement_log), + ) + if path.is_file() + }, + "checks": checks, + "passed": all(checks.values()), + } + _atomic_json(output_json, payload) + return payload + + +def main() -> None: + payload = verify_manuscript() + print(json.dumps(payload, indent=2, sort_keys=True)) + if not payload["passed"]: + raise SystemExit(1) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_topological_holonomy_v3.py b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_topological_holonomy_v3.py new file mode 100644 index 000000000..ca665873d --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/script/verify_topological_holonomy_v3.py @@ -0,0 +1,272 @@ +#!/usr/bin/env python3 +"""Fail-closed audit for fixed-Chern Wilson-holonomy artifacts.""" + +from __future__ import annotations + +import hashlib +import json +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import numpy as np + +from run_topological_holonomy_v3 import ( + MESH_ALIAS_AUDIT_JSON, + MESH_ALIAS_AUDIT_NPZ, + OUTPUT_JSON, + OUTPUT_NPZ, + REGISTERED_CONVERGENCE_MESH, + REGISTERED_CUE_SAMPLES, + REGISTERED_G, + REGISTERED_GENERATOR_SEEDS, + REGISTERED_PRIMARY_MESH, + REGISTERED_SIZES, + SCRIPT_ROOT, + select_topology_branch, +) + + +OUTPUT_ROOT = SCRIPT_ROOT / "output" +FIGURE_MANIFEST = OUTPUT_ROOT / "figure_manifest_v3.json" +FIGURE_PDF = OUTPUT_ROOT / "figure_7_topological_holonomy_v3.pdf" +FIGURE_PNG = OUTPUT_ROOT / "figure_7_topological_holonomy_v3.png" +AUDIT_JSON = OUTPUT_ROOT / "topological_holonomy_delivery_audit_v3.json" + + +def _sha256(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def audit_topology_payload( + payload: dict[str, Any], +) -> dict[str, bool]: + """Recompute the registered topology gates from serialized metrics.""" + + configuration = payload["configuration"] + sizes = payload["sizes"] + observed_sizes = [ + (size["N"], size["n_flux"], size["rank"]) for size in sizes + ] + expected_chern = {3: 6, 4: 10} + checks = { + "registered_sizes": observed_sizes == list(REGISTERED_SIZES), + "registered_meshes": ( + configuration["primary_mesh"] == REGISTERED_PRIMARY_MESH + and configuration["convergence_mesh"] + == REGISTERED_CONVERGENCE_MESH + ), + "registered_g_grid": ( + configuration["g_values"] == list(REGISTERED_G) + ), + "registered_generator_seeds": ( + configuration["generator_seeds"] + == list(REGISTERED_GENERATOR_SEEDS) + ), + "cue_reference_count": ( + configuration["cue_samples"] == REGISTERED_CUE_SAMPLES + ), + "runner_checks": all(payload["checks"].values()), + "branch_recomputed": ( + payload["result_branch"] == select_topology_branch(payload) + ), + "supported_branch": ( + payload["result_branch"] == "fixed_chern_deformed_holonomy" + ), + "chern_fixed": all( + abs(size["base_chern_integer"] - expected_chern[size["N"]]) + < 1e-12 + and max(size["primary_chern_range"]) + - min(size["primary_chern_range"]) + < 1e-8 + and max(size["convergence_endpoint_chern_range"]) + - min(size["convergence_endpoint_chern_range"]) + < 1e-8 + for size in sizes + ), + "mesh_agreement": all( + abs( + size["base_chern_primary"] + - size["base_chern_convergence"] + ) + < 1e-8 + for size in sizes + ), + "determinant_trace_agreement": all( + size["maximum_determinant_trace_difference"] < 1e-8 + for size in sizes + ), + "positive_gap_branch_overlap": all( + size["minimum_external_gap"] > 0.0 + and size["minimum_branch_margin"] > 0.0 + and size["minimum_overlap_singular_value"] > 5e-2 + for size in sizes + ), + "exact_isospectral_construction": all( + size["maximum_energy_spectrum_error"] < 1e-13 + and size["maximum_gap_error"] < 1e-13 + and size["isospectrality_mode"] + == ( + "exact_coordinate_identity_under_periodic_ambient_" + "conjugation" + ) + for size in sizes + ), + "gauge_invariance": ( + payload["random_gauge_errors"]["chern_error"] < 1e-9 + and payload["random_gauge_errors"]["wilson_phase_error"] + < 1e-8 + ), + "deformed_but_non_cue": all( + size["holonomy_change_significant"] + and not size["cue_compatible_at_largest_g"] + for size in sizes + ), + } + if not all(checks.values()): + raise AssertionError(f"topology payload audit failed: {checks}") + return checks + + +def _array_checks(payload: dict[str, Any]) -> dict[str, bool]: + configuration = payload["configuration"] + seeds = len(configuration["generator_seeds"]) + g_count = len(configuration["g_values"]) + checks: dict[str, bool] = {} + with np.load(OUTPUT_NPZ, allow_pickle=False) as arrays: + checks["result_npz_hash"] = ( + payload["npz_sha256"] == _sha256(OUTPUT_NPZ) + ) + for index, size in enumerate(payload["sizes"]): + rank = size["rank"] + primary_mesh = size["primary_mesh"] + convergence_mesh = size["convergence_mesh"] + checks[f"size_{index}_seed_shapes"] = ( + arrays[f"size_{index}_gap_mean"].shape + == (seeds, g_count) + and arrays[f"size_{index}_form_mean"].shape + == (seeds, g_count, rank) + ) + checks[f"size_{index}_loop_shapes"] = ( + arrays[f"size_{index}_gap_loops"].shape + == (seeds, g_count, 2 * primary_mesh) + and arrays[f"size_{index}_form_loops"].shape + == (seeds, g_count, 2 * primary_mesh, rank) + and arrays[f"size_{index}_endpoint_gap_loops"].shape + == (seeds, 2 * convergence_mesh) + ) + checks[f"size_{index}_commuting_control"] = ( + arrays[f"size_{index}_commuting_gap"].shape + == (g_count,) + and arrays[f"size_{index}_commuting_form"].shape + == (g_count, rank) + ) + checks[f"size_{index}_cue_count"] = ( + arrays[f"size_{index}_cue_gap"].shape[0] + == REGISTERED_CUE_SAMPLES + and arrays[f"size_{index}_cue_form"].shape + == (REGISTERED_CUE_SAMPLES, rank) + ) + return checks + + +def run_audit() -> dict[str, Any]: + payload = json.loads(OUTPUT_JSON.read_text(encoding="utf-8")) + checks = audit_topology_payload(payload) + checks.update(_array_checks(payload)) + alias = json.loads(MESH_ALIAS_AUDIT_JSON.read_text(encoding="utf-8")) + checks.update( + { + "alias_artifacts_present": ( + MESH_ALIAS_AUDIT_JSON.exists() + and MESH_ALIAS_AUDIT_NPZ.exists() + ), + "alias_failure_retained": ( + alias["result_branch"] == "topology_mesh_unresolved" + and alias["checks"]["mesh_chern_integer"] is False + and alias["checks"]["branch_margin"] is False + and min(alias["sizes"][1]["primary_chern_range"]) < 9.0 + ), + "alias_hashes": ( + payload["mesh_alias_audit"]["json_sha256"] + == _sha256(MESH_ALIAS_AUDIT_JSON) + and payload["mesh_alias_audit"]["npz_sha256"] + == _sha256(MESH_ALIAS_AUDIT_NPZ) + ), + } + ) + for relative, expected_hash in payload["checkpoint_hashes"].items(): + checks[f"checkpoint:{relative}"] = ( + _sha256(SCRIPT_ROOT / relative) == expected_hash + ) + manifest = json.loads(FIGURE_MANIFEST.read_text(encoding="utf-8")) + figure = manifest["figure_7_topological_holonomy_v3"] + checks.update( + { + "figure_source_json_hash": ( + figure["source_json_sha256"] == _sha256(OUTPUT_JSON) + ), + "figure_source_npz_hash": ( + figure["source_npz_sha256"] == _sha256(OUTPUT_NPZ) + ), + "figure_pdf_hash": ( + figure["pdf_sha256"] == _sha256(FIGURE_PDF) + ), + "figure_png_hash": ( + figure["png_sha256"] == _sha256(FIGURE_PNG) + ), + } + ) + result = { + "version": "v3", + "generated_utc": datetime.now(timezone.utc).isoformat(), + "passed": all(checks.values()), + "checks": checks, + "result_branch": payload["result_branch"], + "registered_sizes": [ + [size["N"], size["n_flux"], size["rank"]] + for size in payload["sizes"] + ], + "registered_meshes": [ + configuration_mesh + for configuration_mesh in ( + payload["configuration"]["primary_mesh"], + payload["configuration"]["convergence_mesh"], + ) + ], + "result_sha256": _sha256(OUTPUT_JSON), + "arrays_sha256": _sha256(OUTPUT_NPZ), + "alias_audit_sha256": _sha256(MESH_ALIAS_AUDIT_JSON), + "figure": { + "pdf": str(FIGURE_PDF.relative_to(SCRIPT_ROOT)), + "pdf_sha256": _sha256(FIGURE_PDF), + "png": str(FIGURE_PNG.relative_to(SCRIPT_ROOT)), + "png_sha256": _sha256(FIGURE_PNG), + }, + } + if not result["passed"]: + raise RuntimeError(f"topology delivery audit failed: {checks}") + temporary = AUDIT_JSON.with_suffix(".json.tmp") + temporary.write_text( + json.dumps(result, indent=2, sort_keys=True), + encoding="utf-8", + ) + temporary.replace(AUDIT_JSON) + return result + + +def main() -> None: + result = run_audit() + print(json.dumps( + { + "passed": result["passed"], + "checks": result["checks"], + "result_branch": result["result_branch"], + }, + indent=2, + sort_keys=True, + )) + + +if __name__ == "__main__": + main() diff --git a/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/task_05_dashboard.md b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/task_05_dashboard.md new file mode 100644 index 000000000..a1929430f --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/01_task_folder/task_05/task_05_dashboard.md @@ -0,0 +1,407 @@ +# task_05: Spectral Silence and Geometric Chaos +Status: 🟡 Ongoing +Last Updated: 2026-07-30 (v35) [Codex] + +Provenance: `docs/plans/2026-07-28-large-scale-geometric-eth-companion-design.md` +Primary execution zone: `01_task_folder/task_05/script/` +Article target: `overleaf_sync/geometric_eth_large_scale/` +Main outputs: `script/output/spectral_silence_v2.{json,npz}`, `script/output/matrix_element_geometric_eth_v3.{json,npz}`, `script/output/topological_holonomy_v3.{json,npz}`, `script/output/geometric_eth_topology_delivery_audit_v3.json`, plus the immutable v1/v2 artifacts +Article: `script/output/spectral_silence_and_geometric_chaos_v3.pdf` +Verdict: Exact degeneracy turns projector geometry into the operative chaos signal. The v3 extension resolves a shrinking gauge-invariant connected four-channel component (`deformed_geometric_eth`) and a fixed-Chern, exactly isospectral twist bundle with tunably deformed Wilson holonomy (`fixed_chern_deformed_holonomy`). Both results, their analytic derivations, seven figures, and forward scaling program are integrated into an audited 17-page article and a tiered public release. + +## Objective + +Create an independent large-scale numerical companion, *From Local Repulsion to Global Geometry: Large-Scale Tests of Geometric ETH*. Expand the physical ensemble to 20000 tangent pairs, extend exact root-response calculations through \(D=800\) across the Jacobi boundary-atom transition, replace rough histograms and sparse bars with uncertainty-aware publication graphics, and deliver a separately audited PDF without importing task-04 executables or artifacts. + +**Scope addendum (2026-07-28) [Human/Codex]:** Expand the same article around *Spectral Silence and Geometric Chaos in an Exactly Degenerate Topological Manifold*: contrast the identically trivial energy SFF with the nontrivial curvature SFF, add a same-parent structured tangent control, vary intrafiber spectral and projector-geometric chaos independently, derive the finite-Jacobi/atom form factor analytically, and retain explicit non-SUSY and nondynamical claim boundaries. + +**Scope addendum (2026-07-28) [Human/Codex]:** Extend the delivered article with both approved post-delivery programs: a gauge-invariant four-channel Wick-factorization test on a genuine fixed-two-quasihole particle-number sequence, and a closed twist-torus calculation that separates fixed \(U(1)\) Chern topology from tunable \(SU(D)\) Wilson-loop holonomy. + +## Version Log + +**v1 (2026-07-28) [Codex]:** Created task_05 from the human's request for substantially larger calculations, improved figures, and a separate PDF. Froze the independent-workspace rule, physical \(20000\)-pair train/validation/test design, fixed-eigenvalue-budget rank sequence through \(D=800\), exact atom handling, hierarchical inference, five-figure visual contract, manuscript architecture, and completion gates. + +**v2 (2026-07-28) [Codex]:** Saved the eight-task implementation plan `docs/plans/2026-07-28-large-scale-geometric-eth-companion-implementation-plan.md`. It specifies task-local module interfaces, test-driven physical/covariance/scaling runners, exact atom labels, matrix-level statistical estimators, five figure contracts, a separate REVTeX source tree, and a fail-closed one-command delivery audit. Execution is inline because unrequested subagents are prohibited. + +**v3 (2026-07-28) [Codex]:** Built the independent `lgeth` numerical package. Task 05 now owns its combinatorics, Kapit--Mueller lattice, channel, Jacobi, Grassmannian, root-operator, and statistics algorithms; an AST import audit forbids task-04 dependencies. Four focused tests verify \(D(3,20)=800\), \(M(3,20)=680\), \(120\) exact atoms on each boundary when \(r=800,M=680\), algebraic atom removal, and \(YY^\dagger=I\). + +**v4 (2026-07-28) [Codex]:** Generated the preregistered \(20000\)-pair Kapit--Mueller physical ensemble in eight independently seeded blocks and 104.33 s. The fixed split is \(12000/4000/4000\); every sample has active and curvature rank \(50\), the parent kernel width is \(5.78\times10^{-16}\), the external gap is \(0.106672\), and no exact \(\pm1\) atoms occur. The reduced deterministic runner test passes. + +**v5 (2026-07-28) [Codex]:** Fit the covariance model on \(1024\) training row spaces, selected the eigenvalue floor \(0.05\) from five candidates using validation data only, and generated \(10000\) Haar plus \(10000\) covariance-deformed spectra. On the untouched \(4000\)-matrix test set, the deformed model reduces density \(L^1\) error from \(0.290988\) to \(0.123720\) (\(57.48\%\)) while matching the mean gap ratio within \(6.06\times10^{-4}\). The registered outcome is `leading_covariance_capture`; six focused tests pass. + +**v6 (2026-07-28) [Codex]:** Completed all seven root-response cases with no sample-count reduction: \(2000,2000,2000,1000,1000,500,250\) matrices at \(D=16,50,112,210,352,546,800\). Interior density error falls \(0.43375\to0.05226\), participation rises \(0.77394\to0.97000\), and the exact atom transition produces \(6+6\) atoms at \(D=546\) and \(120+120\) at \(D=800\). All checkpoint files are resumable, all six scaling gates pass, and the nine accumulated focused tests pass. + +**v7 (2026-07-28) [Codex]:** Added \(10000\)-replicate seed-block/matrix-level simultaneous bands for density, \(P(r)\), number variance, rigidity, form factor, and moments through eighth order. Covariance improvement holds at every registered KDE bandwidth; local ratios are stable under bulk-window, unfolding, and binning choices. Finite-size fits favor a free density exponent \(p=0.5929\), \(D^{-1}\) for the gap-ratio difference, and \(D^{-1/2}\) for participation deficit, but are explicitly treated as finite-range evidence rather than a thermodynamic theorem. All six inference gates and three analytic statistics tests pass. + +**v8 (2026-07-28) [Codex]:** Generated and visually audited five \(7.0\)-inch vector figures with \(2100\)-pixel, \(300\)-dpi previews: physical density/residuals/moments; the local-to-global hierarchy; continuous-spectrum/atom crossover; confidence-aware size fits; and the covariance mechanism. Removed two data-label collisions after original-resolution inspection. The figure manifest hashes all seven numerical inputs and every output, and generated LaTeX macros/tables carry the exact registered values. + +**v9 (2026-07-28) [Codex]:** Wrote and compiled the independent REVTeX PRB-style article *From Local Repulsion to Global Geometry: Large-Scale Tests of Geometric ETH*. The 10-page PDF has correct authors and affiliations, five vector figures, an analytic signature-compression/Jacobi derivation, the exact \(r-M\) atom theorem, a covariance-deformed ETH ansatz, held-out physical results, finite-size limitations, and a numerical appendix. The final log has no undefined citations/references, overfull boxes, or stuck floats; PDF SHA-256 is `004a8615aa293e121b3cc20b5b2b9f80b19e10adbcecdafa91913b7feae1781f`. + +**v10 (2026-07-28) [Codex]:** Clarified the random-matrix/ETH claim boundary. The project already contains exact finite-rank Haar--Jacobi theory, independent Wishart--Jacobi and covariance-deformed ensembles, and local-to-long-range spectral tests. Its ETH content is presently an operational covariance-deformed Geometric-ETH ansatz, not the conventional energy-resolved ETH matrix-element law or a thermodynamic theorem. The next priority is a gauge-invariant tangent-channel Wick-factorization test on a genuine many-body sequence, followed by a controlled comparison with intramultiplet spectral chaos and dynamics. + +**v11 (2026-07-28) [Codex]:** Completed the fail-closed delivery workflow. The one-command runner regenerated \(20000\) physical matrices, \(10000\) Haar matrices, \(10000\) covariance-deformed matrices, \(8750\) rank-sequence matrices through \(D=800\), \(10000\)-replicate matrix-level confidence bands, all five vector figures, and the independent article. Twenty-nine bibliography records resolve online, 14 tests and all 27 delivery gates pass, and all 10 final PDF pages were rendered and visually inspected. The synchronized manuscript/archive SHA-256 is `aae68de7569aae83c7ff500718ab0e3635595f050f5b7afc0d60a0e63db55417`. + +**v12 (2026-07-28) [Codex]:** Repositioned the proposed SFF expansion after a literature and falsification audit. The new recommended spine is “spectral silence versus geometric ramp,” but only with a same-rank/same-gap structured curvature control and independent \(PHP\) versus \(P(\partial H)Q\) interventions. Registered an A+B target: causal channel separation plus a finite-\(D\) Jacobi form-factor derivation, including exact boundary-atom terms. Saved the clickable research memo at `docs/2026-07-28-curvature-sff-research-positioning.md`; no implementation is approved yet. + +**v13 (2026-07-28) [Codex]:** The human approved the recommended A+B expansion with “做吧.” Saved the frozen design at `docs/plans/2026-07-28-spectral-silence-geometric-ramp-design.md`. The primary structured control uses momentum-resolved cosine/sine tangent quadratures on the same Kapit--Mueller zero-mode projector; an exploratory audit finds full active rank \(50\) but only \(10\) distinct curvature eigenvalues. The approved analytic target is the unfolded finite-\(D\) Jacobi determinantal-kernel SFF plus the exact \(K_{c}^{\rm full}=(k/D)K_{c}^{\rm cont}\) boundary-atom theorem. + +**v14 (2026-07-28) [Codex]:** Saved the eight-task test-driven implementation plan at `docs/plans/2026-07-28-spectral-silence-geometric-ramp-implementation-plan.md`. It freezes task-local v2 interfaces, registered control grids and sample counts, finite-Jacobi quadrature tests, simultaneous-band crossover rules, five argument-ordered figures, the retitled REVTeX article, and a fail-closed one-command delivery audit. Inline execution begins with the exact form-factor module. + +**v15 (2026-07-28) [Codex]:** Implemented the exact form-factor core. A single \(1/D\)-normalized decomposition now returns raw, disconnected, and connected parts; the exactly degenerate energy band gives \(K_{E,\mathrm{raw}}=D\) and \(K_{E,c}=0\) to machine precision. The finite complex-Jacobi connected SFF is evaluated from the unfolded Gauss--Jacobi determinantal kernel, agrees with an independent rank-\(16\) Monte Carlo curve within the preregistered tolerance, and is stable at rank \(50\) between quadrature orders 384 and 512. The \(D>M\) theorem \(K_{c}^{\rm full}=(k/D)K_{c}^{\rm cont}\) and raw atom decomposition are executable and tested; 15 focused/regression tests pass. + +**v16 (2026-07-28) [Codex]:** Implemented the two causal controls. All 24 nonzero \(5\times5\) Fourier tangent quadratures preserve the physical active rank \(D=50\) but have at most 10 distinct metric-normalized curvature eigenvalues, giving a full-rank structured negative control. The independent fixed-\(P\) interpolation moves the mean energy gap ratio from \(0.392116\) to \(0.598531\), while the numerically reconstructed target projector changes by at most \(1.13\times10^{-14}\) and the repeated curvature spectrum is invariant exactly. Thirteen focused/control regressions pass. + +**v17 (2026-07-28) [Codex]:** Generated the registered `spectral_silence_v2` artifact in 113.03 s: 24 exact Fourier controls in 12 momentum-inversion orbits, \(7\times4000\) positive-\(g\) geometric-scrambling spectra, \(8\times4000\) fixed-projector energy spectra, the \(4000\)-matrix physical test set, \(10000\) independent Haar spectra, and form factors for all seven rank cases. At \(\tau=0.5\), \(K_{F,c}=4.476\) for the structured control, \(0.502\) for the physical ensemble, and \(0.501\) for the finite-\(D\) Jacobi kernel. The fixed-\(P\) energy ratio moves \(0.385645\to0.598677\); all ten production gates pass. + +**v18 (2026-07-28) [Codex]:** Completed \(10000\)-replicate simultaneous-band inference. The physical curvature SFF is compatible with the exact finite-\(D\) Jacobi curve throughout the registered \(\tau\in[0.25,1.5]\) window, whereas the structured control is decisively rejected. Along geometric scrambling, the gap-ratio interval first overlaps Haar at \(g=0.20\), but a registered Jacobi SFF window first appears at \(g=0.40\). Number-variance compatibility ends at \(L=1\); at \(L=8\) the physical excess is \(0.12582\) with simultaneous interval \([0.11428,0.13736]\). All nine inference gates pass. + +**v19 (2026-07-28) [Codex]:** Generated and visually audited the five-figure v2 package: spectral silence versus geometric ramp; the structured/physical/Jacobi falsification triangle; independent \(PHP\) and \(P(\partial H)Q\) channels; the controlled geometric correlation hierarchy; and the exact Jacobi boundary-atom form factor. Every figure is a 7-inch vector PDF with a 2100-pixel/300-dpi preview, synchronized hashes, generated TeX inputs, and exact scientific annotations. Both figure tests pass after replacing a nonmonotonic onset plot by the monotone RMS SFF residual. + +**v20 (2026-07-28) [Codex]:** Rewrote the article as *Spectral Silence and Geometric Chaos in an Exactly Degenerate Topological Manifold*. The 12-page REVTeX manuscript now begins from the exact \(K_{E,\mathrm{raw}}=D,\ K_{E,c}=0\) theorem, derives the metric-normalized signature compression and unfolded finite-Jacobi determinantal-kernel SFF, proves \(K_{J,c}^{\mathrm{full}}=(k/D)K_{J,c}^{(k)}\) with exact boundary atoms, and organizes all five v2 figures as falsification and causal controls. Added verified AGP, Hilbert-space-geometry, and non-energy-SFF references; clean compilation has no undefined citations/references, overfull boxes, or stuck floats, and all 12 pages pass original-render visual inspection. A new fail-closed audit and delivery test pass on the current PDF. + +**v21 (2026-07-28) [Codex]:** Executed the complete v2 one-command delivery at full registered scale: regenerated 24 Fourier controls, \(7\times4000\) geometric-interpolation matrices, \(8\times4000\) fixed-projector spectral matrices, all seven rank form factors, \(10000\)-replicate simultaneous bands, five vector figures, and the 12-page PDF. Both immutable v1 and live v2 delivery tests now coexist; 34/34 tests and 37/37 final gates pass. The final manuscript/archive SHA-256 is `5d51ad4997a8cc95fa60fdafa02ef5aa13ad86cd31f10764b61a8f8903c2895c`, and the newly rendered pages are pixel-identical to the manually inspected audit set. + +**v22 (2026-07-28) [Codex]:** Triaged the post-delivery research program. The recommended next extension is no longer another curvature-spectrum statistic, but a covariance-whitened, gauge-invariant four-channel Wick-factorization test on a genuine many-body sequence. A closed two-cycle topology/holonomy calculation is the second priority, and a lifted-band dynamical comparison is retained only as external validation. This is a discussion-stage recommendation; no new implementation or numerical claim is approved. + +**v23 (2026-07-28) [Codex]:** The human approved both post-delivery programs. Froze the joint design at `docs/plans/2026-07-28-matrix-element-geometric-eth-and-topology-design.md`: the Wick test uses fixed local operators rather than tautological Gaussian tangent combinations, the true many-body sequence is \(N=3,4,5\) at \(n_\phi=2N+2\), and the topology test uses a smooth periodic quasi-local ambient unitary orbit over the twist torus so exact degeneracy, the full energy spectrum, the gap, and \(C_1\) remain fixed while traceless Wilson holonomy can change. Preliminary feasibility checks validate the three registered kernel ranks and open gaps; no production result is yet claimed. + +**v24 (2026-07-28) [Codex]:** Saved three test-driven implementation plans: `docs/plans/2026-07-28-matrix-element-geometric-eth-implementation-plan.md`, `docs/plans/2026-07-28-topological-holonomy-implementation-plan.md`, and `docs/plans/2026-07-28-geometric-eth-topology-article-integration-plan.md`. They define task-local module interfaces, exact sequence and mesh gates, covariance-matched finite-size references, isospectral topology controls, seven-figure manuscript integration, and fail-closed delivery. Execution is inline because unrequested subagents are prohibited. + +**v25 (2026-07-28) [Codex]:** Completed the registered matrix-element production calculation on the genuine fixed-two-quasihole sequence \((N,n_\phi,D)=(3,8,16),(4,10,25),(5,12,36)\). All exact-kernel, open-gap, resolvent, support, gauge, and reference gates pass. The physical median \(R_4\) decreases \(0.37093\to0.24715\to0.20906\), but remains above the covariance-matched Gaussian medians \(0.21708\to0.14638\to0.12723\); the non-Gaussian excess decreases \(0.15385\to0.10078\to0.08183\). The registered branch is `deformed_geometric_eth`, not finite-size Wick compatibility. + +**v26 (2026-07-28) [Codex]:** Generated and visually audited `figure_6_wick_factorization_v3` as a 7-inch vector PDF with a 2100-pixel preview. The four-panel figure exposes the exact many-body/gap sequence, finite-size Gaussian reference bands, physical and Fourier four-channel residuals, shrinking non-Gaussian excess, and covariance effective dimension. The independent matrix-element delivery audit passes all 18 scientific, provenance, isolation, reference-count, checkpoint, and figure-hash gates. + +**v27 (2026-07-29) [Codex]:** Completed the closed-twist-torus Chern/Wilson production calculation for \((N,n_\phi,D)=(3,8,16),(4,10,25)\). A retained \(12\times12\) audit exposed one \(N=4,g=1\) plaquette-phase alias; upgrading the accepted convergence pair to \(16\times16\) and \(20\times20\) restores \(C_1=6,10\) for every one of eight noncommuting seeds, all five \(g\) values, and the commuting control. All ten topology, gap, branch, overlap, determinant/trace, gauge, and isospectral gates pass. Wilson gap ratios change significantly under the periodic ambient conjugation but remain far below CUE, selecting `fixed_chern_deformed_holonomy`. + +**v28 (2026-07-29) [Codex]:** Generated and visually audited `figure_7_topological_holonomy_v3` as a 7-inch vector PDF with a 2100-pixel preview. Its four panels show fixed \(C_1\) and gap, fixed determinant winding with deformed local spectral flow, significant Wilson gap-ratio changes that remain outside CUE, and a structured Wilson SFF. The independent topology delivery audit preserves the coarse-mesh failure and passes every production, per-loop shape, checkpoint-hash, alias, figure, branch-recomputation, and negative-corruption gate; 21 focused tests pass. + +**v29 (2026-07-29) [Codex]:** Integrated the matrix-element and topology results into the REVTeX article, including the gauge-covariant four-channel tensor, separable complex-Gaussian Wick law, Gram-spectrum reduction, periodic bundle-isomorphism proof for fixed \(C_1\), and connection-shift explanation for changing Wilson holonomy. The one-command v3 build now synchronizes Figures 6/7, validates 35 references, compiles and archives a clean 17-page PDF, passes all 24 delivery gates and 89 task-local tests, and survives original-resolution inspection of all pages. A fixed source-date epoch makes Figures 6/7 and the article byte-reproducible across consecutive clean builds; the final PDF SHA-256 is `68f565e7152d910e78ffb9c42e17e753f497fde1849dda5c4be8a08c5e50c985`. + +**v30 (2026-07-30) [Codex]:** Designed the public Task 05 release around the innovation ladder from spectral silence to curvature statistics, gauge-invariant channel memory, and fixed-Chern holonomy. Added the public-release design and implementation plans, a reviewer-first artifact map, and tiered compact/full reproduction paths. + +**v31 (2026-07-30) [Codex]:** Added the machine-readable release contract, quick and full runners, compact-checkout support, external-artifact provenance, citation metadata, and release tests. The manifest registers 14 compact artifacts, seven figures, 25 production records, exact result branches, and executable verification commands. + +**v32 (2026-07-30) [Codex]:** Reframed the repository, Task 05 entry point, article, release notes, and technical report around the condensed-matter advance and the four new algorithms. Added the challenge draft, PR body, reviewer comment with `@OkongOyangO`, and public-release checklist. Figure 6 now presents the measured quantity directly as connected channel memory. + +**v33 (2026-07-30) [Codex]:** Completed the PR-ready delivery audit. The quick path passes 17 release checks and 38 focused tests; the full compact suite reports 86 passing tests plus six manifest-activated production tests; the article audit passes 25/25 gates across 17 pages and seven synchronized figures. The final PDF SHA-256 is `a75377f76acd78eb3354e186a57933abdf11abbbe5e9a8abd43482ca8c4e05ad`. Task 05 remains 🟡 Ongoing for Issue-linked review and PR discussion. + +**v34 (2026-07-30) [Codex]:** Reconciled the public landing page, citation metadata, and PR body with the repository's GNU GPL v3.0 license, then revalidated the quick release path before the final remote push. + +**v35 (2026-07-30) [Codex]:** Linked the release to `QuantumBFS/quantum.harness#276` and sharpened the PR's direct answer: non-Abelian projector geometry over coupling space is the chaos probe that remains operative inside an exactly degenerate eigenspace. Synchronized the PR body, collaborator review comment, and public checklist for draft-PR submission. + +## Canvas + +### Central numerical question + +When the active rank and Monte Carlo resolution grow, do local correlations, smooth density, channel covariance, and higher Grassmannian cumulants approach the Jacobi law at the same scale? + +The new paper tests a hierarchy rather than a single yes/no random-matrix gate: + +$$\text{local repulsion}\ \longrightarrow\ \text{global density}\ \longrightarrow\ \text{higher Grassmannian cumulants}.$$ + +The \(D=546\) and \(D=800\) cases additionally cross the exact \(r=M\) boundary and expose forced \(\pm1\) atoms. This converts a previously rough finite-size extension into a qualitatively new geometric regime. + +### Independent-core checkpoint + +The executable namespace is now fully task-local. The first completion gate passes with `4 passed`: no task-05 Python source imports `task_04` or `gaccess`, the registered largest root space has \((D,M)=(800,680)\), the Jacobi intersection theorem fixes \(120\) eigenvalues at each of \(\lambda=\pm1\), and the normalized-curvature rows satisfy the numerical isometry identity. + +### Physical high-statistics checkpoint + +The physical anchor is now \((N,n,D,M)=(3,10,50,170)\), with one million normalized curvature eigenvalues. All \(20000\) tangent pairs are retained together with the tangent coefficients and eight seed-block labels. The train, validation, and test sets are disjoint, so covariance learning, hyperparameter choice, and the final density comparison cannot leak into one another. + +### Held-out Geometric-ETH checkpoint + +The physical row spaces are manifestly non-Haar: their mean-projector relative anisotropy is \(0.86743\), coordinate participation is \(0.62494\), mean frame overlap is \(12.8384\) versus the exact Haar value \(7.35294\), and the entry fourth ratio is \(3.32657\). Nevertheless, local eigenvalue repulsion is already Jacobi-like: + +$$\langle r\rangle_{\rm phys}=0.599806,\qquad \langle r\rangle_{\rm Haar}=0.599395,\qquad \langle r\rangle_{\rm cov}=0.599200.$$ + +The covariance deformation explains most of the global one-point discrepancy and closely tracks moments through eighth order. The supported statement is therefore a hierarchical Geometric ETH: local correlations forget microscopic tangent structure before the global density and Grassmannian frame statistics do. + +### Rank and boundary-atom checkpoint + +The increasing-rank result separates two effects. Before the capacity crossing, the continuous root-response spectrum approaches the exact Jacobi law: + +| \(D\) | \(M\) | matrices | \(\Delta\langle r\rangle\) | interior density \(L^1\) | participation | +|---:|---:|---:|---:|---:|---:| +| 16 | 80 | 2000 | 0.03023 | 0.43375 | 0.77394 | +| 50 | 140 | 2000 | 0.00767 | 0.22916 | 0.85413 | +| 112 | 216 | 2000 | 0.00403 | 0.14094 | 0.89476 | +| 210 | 308 | 1000 | 0.00173 | 0.09624 | 0.92125 | +| 352 | 416 | 1000 | 0.00290 | 0.06866 | 0.94097 | + +After \(D>M\), the intersection theorem forces \((D-M)\) eigenvalues at each boundary while the algebraically stripped interior remains random-matrix-like: + +| \(D\) | \(M\) | interior dimension | atoms at each boundary | \(\Delta\langle r\rangle_{\rm int}\) | interior density \(L^1\) | +|---:|---:|---:|---:|---:|---:| +| 546 | 540 | 534 | 6 | 0.00024 | 0.05149 | +| 800 | 680 | 560 | 120 | 0.00423 | 0.05226 | + +Thus exact geometric modes at \(\lambda=\pm1\) do not destroy chaos in the complementary continuous sector. This coexistence is the companion paper's new structural result. + +### Matrix-level inference checkpoint + +Every visual confidence band is now based on independent matrices or the eight physical seed blocks. At the longest displayed scale \(L=8\), the number variance retains a measurable physical excess, + +$$\Sigma^2_{\rm phys}(8)=0.696,\qquad \Sigma^2_{\rm Haar}(8)=0.570,\qquad \Sigma^2_{\rm cov}(8)=0.570,$$ + +while the connected form-factor ramp is already close at \(\tau=0.5\), + +$$K_{c,\rm phys}(0.5)=0.502,\qquad K_{c,\rm Haar}(0.5)=0.495,\qquad K_{c,\rm cov}(0.5)=0.502.$$ + +This refines the hierarchy: short-range repulsion and the ramp are nearly universal, the one-point density is largely covariance controlled, and number variance at the largest available windows still resolves physical memory. Across bandwidths \(h=0.015\) to \(0.05\), the covariance model's density error remains \(0.105\)–\(0.119\), compared with \(0.280\)–\(0.290\) for Haar. + +### Principal result figure + +![Spectral silence and geometric ramp](script/output/figure_1_spectral_silence_v2.png) + +The v2 argument-ordered figure package is: + +- [Structured/physical/Jacobi falsification triangle](script/output/figure_2_falsification_triangle_v2.png) +- [Independent spectral and geometric chaos channels](script/output/figure_3_independent_channels_v2.png) +- [Controlled geometric correlation hierarchy](script/output/figure_4_geometric_hierarchy_v2.png) +- [Finite-Jacobi and exact boundary-atom SFF](script/output/figure_5_jacobi_atoms_v2.png) + +The v1 high-statistics density, covariance, rigidity, and finite-size figures remain immutable provenance and will be retained as supporting material rather than discarded. + +### Independent article + +[Spectral Silence and Geometric Chaos in an Exactly Degenerate Topological Manifold](script/output/spectral_silence_and_geometric_chaos_v2.pdf) + +The article is deliberately positioned as a non-supersymmetric condensed-matter extension of Chen \emph{et al.}: exact degeneracy is supplied by a frustration-free fractional topological zero-mode manifold, not SUSY cohomology. The sharpened central result is that exact degeneracy removes the energy ramp while projector geometry retains a finite-Jacobi correlation ramp independent of intrafiber spectral chaos. For \(r>M\), exact \(\pm1\) atoms have multiplicity \(r-M\) per boundary and suppress the full connected plateau to \((2M-r)/r\), while the continuous complement remains Jacobi correlated. + +### Random-matrix and ETH claim boundary + +Random matrices have already been computed at three distinct levels: + +1. The exact null model is the finite-\((D,M)\) complex Jacobi ensemble obtained by Haar compression of the signature matrix \(J\). +2. Independent Wishart--Jacobi samples provide \(10000\) Haar reference matrices at the physical anchor and matched references for every rank from \(D=16\) through \(D=800\). +3. A second \(10000\)-matrix ensemble uses the training-only channel covariance and tests a covariance-deformed random-plane law on an untouched physical test set. + +The present Geometric-ETH statement is correspondingly specific. It decomposes the tangent-channel distribution into a deterministic two-point covariance envelope and a locally Gaussian random residual. The observed hierarchy is + +$$\text{Jacobi local repulsion}\ \prec\ \text{covariance-controlled one-point law}\ \prec\ \text{non-Haar higher cumulants}.$$ + +This is not yet the conventional energy-resolved ETH ansatz, because all states in the target manifold are exactly degenerate and there is no internal frequency variable. It is also not yet a microscopic or thermodynamic Geometric-ETH theorem. + +### Next decisive extension + +The next calculation should test an invariant matrix-element form of Geometric ETH before adding more curvature histograms. For tangent channels + +$$X_\mu=P(\partial_\mu H)Q\,[Q(H-E_0)Q]^{-1},$$ + +the target statement is that, after removing a smooth channel covariance, connected invariant cumulants approach their Gaussian Wick contractions along a many-body sequence: + +$$\mathcal{K}^{(4)}_{\mu\nu\rho\sigma}=\operatorname{Tr}(X_\mu X_\nu^\dagger X_\rho X_\sigma^\dagger)-\operatorname{Wick}_{\mu\nu\rho\sigma}\longrightarrow0.$$ + +The implementation priority is: + +1. Derive the two- and four-channel invariant contractions, their finite-\((D,M)\) Gaussian predictions, and the expected scaling of the connected residual. +2. Replace the fixed-\(N=3\) dilution sequence by a genuine many-body Laughlin/FCI sequence with increasing particle number, a fixed physical scaling prescription, an open external gap, and a growing exact multiplet. +3. Measure covariance-whitened channel cumulants, multi-curvature correlators, quantum-metric statistics, and the joint metric--curvature law rather than only eigenvalue statistics of one curvature matrix. +4. Add an independent intramultiplet perturbation \(PHP\) that crosses Poisson to GUE while leaving the full projector \(P\) fixed. This separates conventional spectral chaos from external geometric scrambling \(P(\partial_\mu H)Q\). +5. Compare the resulting geometric crossover with projected-operator ETH, entanglement, fidelity susceptibility, and, where feasible, an OTOC or dynamical structure factor. Berry curvature is decisive only if it detects chaos in the exactly degenerate limit where the internal spectrum remains silent. + +The immediate paper-level target is therefore not “more RMT.” It is a falsifiable matrix-element Geometric-ETH law: two-point covariance sets the smooth envelope, Wick factorization controls the universal residual, and connected higher cumulants vanish with a script-derived finite-size exponent. + +### SFF expansion: revised positioning + +The curvature SFF is scientifically useful only if it survives the following objection: an arbitrary generic Hermitian matrix can display a ramp after unfolding. The revised design therefore does not treat the existing \(K_{F,c}(\tau)\) curve as a standalone chaos proof. + +For the exactly degenerate target energies \(E_a=E_0\), + +$$K_{E,\mathrm{raw}}(t)=D,\qquad K_{E,c}(t)=0,$$ + +under the task's \(1/D\) normalization. This analytic spectral silence should be placed beside the nontrivial connected curvature ramp, while displaying raw and connected conventions for both objects so that the comparison is statistically fair. + +The decisive control is a three-way comparison at fixed rank, exact target bandwidth, external-gap condition, and topology: + +$$\text{structured tangent geometry}\ \longleftrightarrow\ \text{physical scrambled geometry}\ \longleftrightarrow\ \text{Haar--Jacobi}.$$ + +The paper must then separate two independent mechanisms. An internal \(PHP\) intervention changes intramultiplet Poisson/GUE statistics at fixed projector \(P\), whereas an external \(P(\partial_\mu H)Q\) intervention changes the projector geometry while the target energy spectrum remains exactly degenerate. A \(2\times2\) quadrant figure—neither chaotic, spectral only, geometric only, both chaotic—would make Berry curvature's nonredundant role explicit. + +Three routes were compared: + +1. **A: spectral silence versus geometric ramp.** Best narrative and shortest causal test. +2. **B: exact finite-\(D\) Jacobi SFF and boundary-atom decomposition.** Best immediate analytic upgrade, but insufficient by itself to establish physical meaning. +3. **C: covariance-whitened matrix-element Geometric ETH and Wick factorization on a genuine many-body sequence.** Strongest ultimate theory, but most expensive and not required before repairing the main story. + +The recommended synthesis is A+B now, with the first invariant four-channel cumulant from C as a final or supplemental result. The proposed main figures are: (1) exact energy silence versus geometric ramp; (2) structured/physical/Jacobi falsification triangle; (3) independent spectral and geometric chaos axes; (4) confidence-defined geometric correlation scale; (5) exact full versus atom-stripped Jacobi SFF across \(D=M\); and optionally (6) covariance-whitened Wick-factorization residuals. The current spectral-rigidity panel should move to the supplement. + +The complete literature position, equations, figure contracts, acceptance gates, and overclaim boundaries are recorded in [the curvature-SFF research memo](../../docs/2026-07-28-curvature-sff-research-positioning.md). This remains a discussion-stage design pending human choice between Route A alone and the recommended A+B synthesis. + +The human subsequently approved the A+B synthesis. The implementation ground truth is now [the spectral-silence/geometric-ramp design](../../docs/plans/2026-07-28-spectral-silence-geometric-ramp-design.md). Existing v1 scripts and artifacts remain immutable provenance; all extension code and results will use v2 names. + +The structured control is now concrete rather than schematic. Its momentum quadratures are local site-potential operators evaluated through the same physical channel cache as the random-local ensemble. Because they remain full active rank but organize into only ten curvature eigenvalues, failure of RMT cannot be dismissed as an accessibility-rank artifact. + +The fixed-projector control separately establishes the algebraic mechanism: \(PHP\) can develop GUE energy correlations while the complete fiber projector and its curvature do not move. This control is effective rather than a microscopic local path and will be labeled as such in the manuscript. + +### Spectral-silence production checkpoint + +The primary v2 artifact contains three genuinely different objects rather than three relabelings of one random ensemble: + +1. the structured momentum-resolved curvature spectra, with exact magnetic-translation multiplets; +2. the physical random-local-potential curvature spectra and their continuous \(g\)-interpolation from the structured endpoint; +3. the independent finite-\(D\) Haar--Jacobi reference, including the exact boundary-atom normalization. + +At the headline Fourier scale, + +$$K_{F,c}^{\rm structured}(0.5)=4.476,\qquad K_{F,c}^{\rm physical}(0.5)=0.502,\qquad K_{J,c}^{(50,170)}(0.5)=0.501.$$ + +The structured control therefore fails in the opposite direction from a weak finite-size deviation: its unresolved symmetry multiplets create a large coherent form-factor excess despite full active rank. Along the geometric-scrambling axis, the mean gap ratio is already \(0.577596\) at \(g=0.02\) and approaches \(0.600307\) at \(g=1\). Whether the SFF residual is statistically compatible with Jacobi over a registered non-plateau interval is deferred to the simultaneous-band analysis rather than inferred from these point values. + +The exact-parent checks remain unchanged throughout this axis: + +$$\operatorname{bandwidth}(PHP)=5.78\times10^{-16},\qquad \Delta_{\rm ext}=0.106672.$$ + +The independent spectral axis gives + +$$\langle r\rangle_{\alpha=0}=0.385645,\qquad \langle r\rangle_{\alpha=1}=0.598677,$$ + +with maximum reconstructed-projector distance \(1.15\times10^{-14}\) and zero repeated-curvature-spectrum error. Thus the two axes already realize the four logical quadrants required by the approved design; the next stage assigns confidence bands and registered crossover sets. + +### Registered correlation hierarchy + +The simultaneous-band analysis separates three correlation scales on the geometric-scrambling axis: + +$$g_{\rm local}=0.20 + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/tracks/mps/solutions/Wander-276/research/README.md b/tracks/mps/solutions/Wander-276/research/README.md new file mode 100644 index 000000000..6b546d497 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/README.md @@ -0,0 +1,107 @@ +# Chaos of Quantum Geometry + +> **Exact degeneracy removes spectral diagnostics, not state-space complexity.** + +![Hodge-resolved Geometric ETH evidence](01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.png) + +This project studies quantum chaos as a property of how an exactly degenerate protected manifold moves over coupling space. The response amplitudes + +$$X_a=(1-P)\partial_aP$$ + +generate the non-Abelian quantum geometric tensor (\mathcal Q_{ab}=X_a^\dagger X_b), hence both the quantum metric and Berry curvature. They also retain higher correlations invisible to curvature eigenvalues alone. + +The starting point is Chen, Colin-Ellerin, Mamroud, and Papadodimas, [“Chaos of Berry curvature for BPS microstates”](https://arxiv.org/abs/2604.23287). The present release adds an independently protected many-body mechanism and an outcome-blind higher-moment test. + +## Scientific Architecture + +```mermaid +flowchart LR + A["Exactly degenerate protected fiber P(lambda)"] --> B["Response X=(1-P)dP"] + B --> C["QGT: metric and Berry curvature"] + B --> D["Whitened four-channel tensor"] + E["Laughlin parent B-dagger B"] --> F["One-sided response"] + G["N=2 SYK {Q,Q-dagger}"] --> H["Exact plus coexact response"] + F --> D + H --> D + D --> I["Frozen covariance predictions"] + I --> J["SHA-256-sealed held-out N=14 test"] +``` + +## What Is New + +| Question | Delivered result | +|---|---| +| Is the phenomenon tied to the Kapit–Mueller/Laughlin parent? | No. Generic cubic (\mathcal N=2) SYK supplies a charge-resolved cohomological BPS manifold with a different protection mechanism. | +| What replaces a one-sided parent response? | The exact identity (X=X_-\oplus X_+), with (X_-^\dagger X_+=0), resolves the response into exact and coexact Hodge branches. | +| How is “Geometric ETH” made falsifiable? | Two covariance-only Gaussian predictions are frozen before the held-out four-channel outcome is opened. | +| What is the statistical unit? | The complete disorder realization; no tangent entry or tensor component is treated as an independent sample. | +| What prevents post-outcome tuning? | Safe covariates, numerical predictions, source identities, and the held-out state machine are hash sealed. | + +For an eight-channel tangent panel, the gauge-invariant diagnostic is + +$$\mathcal T_{abcd}=\frac1D\operatorname{Tr}(\widehat X_a^\dagger\widehat X_b\widehat X_c^\dagger\widehat X_d).$$ + +The collapsed null matches registered marginal covariance data without a branch label. The Hodge null samples exact and coexact branches independently and combines their orthogonal direct sum. Both are fixed by safe two-point information. + +## Pilot Evidence + +The sequential (N=8,10,12) pilot contains central/adjacent sectors and sparse/isotropic tangent panels. All 12 size-sector-panel groups reject both registered separable covariance nulls. For the preregistered sparse panel, the physical-to-Hodge-null median ratio evolves as follows: + +| Sector | (N=8) | (N=10) | (N=12) | +|---|---:|---:|---:| +| Central | 1.467 | 2.790 | 3.328 | +| Adjacent | 1.261 | 2.081 | 2.613 | + +These are strong finite-size deviations. They are not an asymptotic scaling theorem. + +## Sealed Held-Out Result + +The independent prediction seal passed before explicit outcome opening. The primary $N=14$ sparse pair gives: + +| Sector | Physical median (95% bootstrap) | Collapsed null (97.5% prediction) | Hodge null (97.5% prediction) | +|---|---:|---:|---:| +| Adjacent | 0.301529 [0.291527, 0.312061] | [0.111789, 0.111852] | [0.112344, 0.112513] | +| Central | 0.374993 [0.368980, 0.380473] | [0.111338, 0.111353] | [0.111333, 0.111348] | + +Both registered nulls miss both primary sectors. The frozen selector returns `cohomological_non_gaussian_class`: two-point Hodge data do not close the observed four-channel response within the registered separable covariance family. The prediction SHA-256 is `fc300dc7e4bdc1be157919e458ac868d3468533cce31108f23c9fba4f7e9f102`; the inference SHA-256 is `177643e07fc6cf210362fc1077070bd1f0ba316b6805042a626de3f96c55a627`. + +## Exact Controls + +- A decomposable three-form reproduces the analytic curvature atoms (0,\pm\alpha^{-2}) with their predicted multiplicities. +- A one-sided synthetic response reproduces the accepted Laughlin Gaussian null. +- The Hodge formula agrees with a direct Hamiltonian resolvent derivative and a centered finite difference of the protected projector. +- Exact scalable covariance diagonalization agrees with the dense reference within (2\times10^{-12}) in the regression regime. + +## Reproduce and Audit + +From `01_task_folder/task_05/script`: + +```bash +PYTHONPATH=. pytest -q $(rg --files tests | rg 'v7\.py$') +bash run_susy_hodge_delivery_v7.sh +python verify_susy_hodge_delivery_v7.py +python verify_susy_hodge_manuscript_v7.py +``` + +The delivery script is fail-closed: it will not activate the paper macros unless the pilot, sealed (N=14) prediction, explicit unseal, frozen inference, controls, figures, and manuscript audits all pass. + +## Start Here + +| Deliverable | Purpose | +|---|---| +| [Letter source](overleaf_sync/cohomological_geometric_eth/main.tex) | Compact scientific argument and primary result | +| [Supplement source](overleaf_sync/cohomological_geometric_eth/supplement.tex) | Derivation, controls, state machine, artifact contract, and limitations | +| [Compiled Letter](01_task_folder/task_05/script/output/response_complex_memory_v7.pdf) | Four-page audited REVTeX paper; SHA-256 `9fe357a5bfce5e6efd60a3c8bf0a1b73a4eac4ee15f9bb8844f51d2f7e1252ee` | +| [Compiled Supplemental Material](01_task_folder/task_05/script/output/response_complex_memory_supplement_v7.pdf) | Four-page audited methods and exact-statistics package; SHA-256 `e43a5a2f62494bb7595f790de5643d6244d782402478f36fdcc7c511176b79c5` | +| [Result report](01_task_folder/task_05/script/output/susy_hodge_geometric_eth_report_v7.md) | Machine-generated verdict and numerical intervals | +| [Figure manifest](01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.json) | Input/output hashes for the main evidence figure | +| [Scientific ceiling memo](docs/2026-08-01-scientific-ceiling-strategy.md) | Novelty boundary, journal ceiling, and next-theorem roadmap | +| [Legacy Laughlin article](01_task_folder/task_05/script/output/spectral_silence_and_geometric_chaos_v3.pdf) | One-sided topological benchmark and fixed-Chern holonomy results | + +## Claim Boundary and Research Horizon + +The independent model/operator-class gate is now crossed: cohomological (\mathcal N=2) SYK is not a repackaged FQH parent Hamiltonian. The asymptotic gate remains open. The current release establishes only the tested finite-size sequence and only relative to the frozen separable covariance nulls. + +The next high-ceiling steps are a controlled large-(N) response-tensor law and a spatially local nilpotent-supercharge model with a stable protected rank, open gap, and nontrivially moving harmonic projector. + +The code is released under the [GNU General Public License v3.0](LICENSE). Citation metadata are provided in [CITATION.cff](CITATION.cff). diff --git a/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-quantum-geometry-harness-challenge-draft.md b/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-quantum-geometry-harness-challenge-draft.md new file mode 100644 index 000000000..6510a4588 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-quantum-geometry-harness-challenge-draft.md @@ -0,0 +1,94 @@ +# Quantum Harness Challenge Draft: Geometry Speaks Under Exact Degeneracy + +## Form Fields + +**Title** + +`[challenge] Can non-Abelian quantum geometry reveal chaos inside an exactly degenerate manifold?` + +**Released by** + +Thomas J. Wang, Tsinghua University + +**Public contact** + +[@JunkaiWang-TheoPhy](https://github.com/JunkaiWang-TheoPhy); the issue form can carry the preferred public email. + +**Method** + +Exact Diagonalization + +## Challenge Issue + +**Difficulty:** ★★★ + +### Background + +An exactly degenerate multiplet has identical internal energies, while its projector can trace a rich path through Hilbert space. Chen, Colin-Ellerin, Mamroud, and Papadodimas proposed non-Abelian Berry curvature as an intrinsic chaos diagnostic for degenerate BPS microstates in [arXiv:2604.23287](https://arxiv.org/abs/2604.23287). The public task-05 baseline turns that idea into a gauge-invariant many-body matrix-element program with exact analytic references and machine-checkable outcomes. + +For a degenerate projector \(P(\lambda)\), \(Q=1-P\), and zero-mode energy \(E_0\), define the resolvent-dressed tangent response + +$$X_\mu=P(\partial_\mu H)Q[Q(H-E_0)Q]^{-1}.$$ + +After whitening by a preregistered two-point channel covariance, evaluate the gauge-invariant tensor + +$$T_{\mu\nu\rho\sigma}=\frac{1}{D}\operatorname{Tr}(\widetilde X_\mu\widetilde X_\nu^\dagger\widetilde X_\rho\widetilde X_\sigma^\dagger)$$ + +against its finite-size covariance-matched complex-Gaussian Wick reference. + +The baseline establishes feasibility for a bosonic Laughlin sequence at \(N=3,4,5\): local curvature correlations follow the finite-Jacobi law, the connected four-channel component decreases monotonically, and fixed-Chern Wilson holonomy occupies a structured tunable regime. The challenge begins at the next scaling frontier. + +### Research Objective + +Complete at least one branch: + +1. extend the fixed-two-quasihole Laughlin sequence through \(N=6\) and issue a preregistered matrix-element verdict; +2. repeat the full gauge-invariant test in a second local exact-degeneracy mechanism; +3. derive and verify the asymptotic scaling of the connected four-channel component from locality or constraint algebra. + +The verifier selects exactly one outcome: + +- `emergent_wick_geometric_eth`; +- `deformed_geometric_eth`; +- `structured_geometry_regime`; +- `scaling_frontier`. + +Every branch carries scientific value and maps a distinct universality structure. + +### Mandatory Gates + +**Gate 0: exact kernel and gap.** Match the target rank to independent counting, resolve internal bandwidth below \(10^{-8}\) times the external gap, publish eigensolver/resolvent residuals, and retain every preregistered size. + +**Gate 1: gauge and mesh invariance.** Curvature spectra, the four-channel residual, Chern number, and Wilson eigenphases must remain stable under independently sampled local \(U(D)\) frame rotations. Two meshes must agree on the integer Chern number with positive determinant-branch margin and stable Wilson statistics. + +**Gate 2: independent chaos axes.** Tune unfolded intramultiplet statistics through \(PHP\) while preserving \(P\) and its geometry; tune \(P(\partial_\mu H)Q\) while preserving the complete energy spectrum. + +**Gate 3: matrix-element verdict.** Freeze sizes, local-operator panels, covariance cutoff, random seeds, reference count, compatibility bands, and solver tolerances before the largest run. Emit the result branch from raw artifacts through a public script. + +**Gate 4: topology.** On a closed two-parameter surface, separate determinant \(U(1)\) topology from relative \(SU(D)\) holonomy and report both the fixed \(C_1\) sector and the Wilson universality class. + +### Deliverables + +- source and environment lock; +- raw spectra, overlaps, seeds, and solver checkpoints or a DOI-backed data archive; +- machine-readable result schema and one-command verifier; +- gauge-randomization and mesh-convergence reports; +- compact figures showing the three-ensemble comparison, four-channel scaling, and fixed-Chern holonomy; +- a research report that explains the selected outcome as a distinct universality statement. + +### Why This Can Produce Research + +Wick compatibility would establish a microscopic matrix-element Geometric-ETH law in an exactly degenerate many-body manifold. A stable connected component would establish a deformed fixed tensor with operator memory. Independent spectral and geometric axes reveal how multiple notions of chaos coexist, while the topology gate connects local universality to the global structure of parameter space. + +The baseline contributes new finite-rank algorithms, a gauge-invariant tensor law, and an isospectral topology control, so every submission begins from an executable research platform rather than a conceptual prompt. + +### References + +1. Y. Chen, S. Colin-Ellerin, O. Mamroud, and K. Papadodimas, [“Chaos of Berry curvature for BPS microstates”](https://arxiv.org/abs/2604.23287). +2. M. Kolodrubetz, D. Sels, P. Mehta, and A. Polkovnikov, [“Geometry and non-adiabatic response in quantum and classical systems”](https://arxiv.org/abs/1602.01062). +3. T. Fukui, Y. Hatsugai, and H. Suzuki, [“Chern Numbers in Discretized Brillouin Zone”](https://doi.org/10.1143/JPSJ.74.1674). +4. Quantum Harness [issue 73](https://github.com/QuantumBFS/quantum.harness/issues/73), an Abelian Berry-phase benchmark complementary to this non-Abelian challenge. + +## Submission Note + +An authorized repository member can paste this draft into the issue form, add the preferred public email, and attach the release DOI when available. diff --git a/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-pr-body.md b/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-pr-body.md new file mode 100644 index 000000000..01d80bbef --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-pr-body.md @@ -0,0 +1,90 @@ +# PR Title + +`Geometric chaos under exact degeneracy: reproducible task-05 release` + +# PR Body + +Related research challenge: [QuantumBFS/quantum.harness#276 — What is the Probe of Quantum Chaos for Degenerate Eigenstate Subspace?](https://github.com/QuantumBFS/quantum.harness/issues/276) + +## Exact degeneracy turns quantum geometry into the signal + +Exact spectral flatness and geometric ramp + +This PR gives an executable answer to Issue #276: the chaos probe for a degenerate eigenspace is the non-Abelian quantum geometry of its projector over coupling space. In an exactly degenerate bosonic Laughlin manifold, the energy sector obeys the exact identities \(K_{E,\mathrm{raw}}=D\) and \(K_{E,c}=0\), while the projector geometry resolves local finite-Jacobi correlations, a gauge-invariant connected response cumulant, and tunable Wilson holonomy at fixed Chern class. + +## Scientific Advance + +| Layer | New capability | Registered result | +|---|---|---| +| Exact spectrum | Clean spectral-flatness reference | \(K_{E,c}=0\) identically | +| Local geometry | Parameter-free finite-\(D\) Jacobi kernel and SFF | Physical curvature tracks the registered Jacobi ramp | +| Matrix elements | Covariance-whitened four-channel tensor | `deformed_geometric_eth` | +| Global topology | Isospectral, fixed-Chern Wilson control | `fixed_chern_deformed_holonomy` | + +## Four Innovations + +1. **Metric-normalized signature compression.** The projector response becomes a compression of a fixed signature matrix, turning a model-specific many-body problem into an exact finite-rank complex-Jacobi process. +2. **Boundary-atom form-factor theorem.** The implementation treats exact \(\lambda=\pm1\) modes algebraically and proves \(K_{J,c}^{\mathrm{full}}=(k/D)K_{J,c}^{(k)}\), including the \(D=800\) plateau. +3. **Matrix-element Geometric ETH.** A gauge-invariant four-channel tensor, evaluated on the genuine \(N=3,4,5\) sequence, promotes the analysis beyond curvature eigenvalues and reveals progressive Gaussianization with a resolved connected component. +4. **Fixed-Chern holonomy engineering.** A periodic ambient unitary preserves every energy, the external gap, and \(C_1\), while continuously tuning relative Wilson transport. + +These advances build directly on the Berry-curvature chaos program of Chen, Colin-Ellerin, Mamroud, and Papadodimas and add a local frustration-free condensed-matter realization, exact finite-rank algorithms, causal spectral/geometric interventions, an operator-level law, and global topology control. + +## Quantitative Highlights + +- 20000 physical tangent pairs with a frozen `12000/4000/4000` train/validation/test split. +- At \(\tau=0.5\), physical \(K_{F,c}=0.502\) and finite-Jacobi \(K_{J,c}=0.501\). +- Four-channel connected excess: \(0.15385\to0.10078\to0.08183\) across \(N=3,4,5\). +- Fixed Chern numbers \(C_1=6,10\) with reproducibly shifted Wilson statistics. +- Exact rank sequence through \(D=800\), including 120 atoms at each boundary and connected plateau \(0.7\). +- Seven synchronized publication figures and an audited 17-page article. + +## Delivery Package + +- innovation-first [project landing page](https://github.com/JunkaiWang-TheoPhy/Chaos-of-Quantum-Geometry/tree/codex/task-05-geometric-chaos-baseline); +- task-level [reproduction guide](https://github.com/JunkaiWang-TheoPhy/Chaos-of-Quantum-Geometry/blob/codex/task-05-geometric-chaos-baseline/01_task_folder/task_05/README.md); +- [Markdown technical report](https://github.com/JunkaiWang-TheoPhy/Chaos-of-Quantum-Geometry/blob/codex/task-05-geometric-chaos-baseline/docs/2026-07-30-task05-technical-report.md); +- [17-page PDF](https://github.com/JunkaiWang-TheoPhy/Chaos-of-Quantum-Geometry/blob/codex/task-05-geometric-chaos-baseline/01_task_folder/task_05/script/output/spectral_silence_and_geometric_chaos_v3.pdf); +- `CITATION.cff`, pinned Python dependencies, and GPL-3.0 licensing; +- quick and full recomputation runners; +- machine-readable release manifest covering 7 figures, 14 compact artifacts, and 25 production arrays; +- issue-ready [Quantum Harness challenge](https://github.com/JunkaiWang-TheoPhy/Chaos-of-Quantum-Geometry/blob/codex/task-05-geometric-chaos-baseline/docs/2026-07-30-quantum-geometry-harness-challenge-draft.md). + +## Verification + +```bash +cd 01_task_folder/task_05/script +python -m pip install -r requirements.txt +bash run_quick_verify_v1.sh +``` + +Verified release state: + +- 38 focused quick-path tests; +- 86 passing compact-checkout tests plus 6 production-data tests that activate with the manifest-listed arrays; +- 25 article-delivery checks across all 17 rendered pages; +- synchronized paper/archive SHA-256 recorded in `release_manifest_v1.json`; +- task-local runtime isolation and a 10 MiB tracked-blob policy. + +## Reviewer Route + +1. Read the [technical report](https://github.com/JunkaiWang-TheoPhy/Chaos-of-Quantum-Geometry/blob/codex/task-05-geometric-chaos-baseline/docs/2026-07-30-task05-technical-report.md). +2. Inspect Figures 1, 6, and 7. +3. Run `bash run_quick_verify_v1.sh`. +4. Check the two registered result branches in the manifest and JSON artifacts. +5. Review the \(N=6\)/second-model growth program in the challenge draft. + +## Growth Horizon + +The public baseline makes three next steps immediately executable: \(N=6\) matrix-element scaling, transfer to a second exact-degeneracy mechanism, and a locality-based derivation of the four-channel law. The associated Quantum Harness issue turns these directions into a community benchmark with machine-verifiable outcomes. + +## Checklist + +- [x] Scientific source and task isolation +- [x] Seven publication figures +- [x] 17-page article and Markdown technical report +- [x] Quick and full reproduction paths +- [x] Compact/external artifact manifest +- [x] Citation metadata and public landing pages +- [x] Issue-ready follow-on challenge +- [x] Clean-checkout verification diff --git a/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-pr-review-comment.md b/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-pr-review-comment.md new file mode 100644 index 000000000..139bb6469 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-pr-review-comment.md @@ -0,0 +1,25 @@ +# PR Review Comment + +Paste this comment after opening the PR: + +--- + +@OkongOyangO This release provides the executable answer to [QuantumBFS/quantum.harness#276](https://github.com/QuantumBFS/quantum.harness/issues/276) and is ready for a focused scientific review. The most valuable review path is: + +1. **Core claim:** exact spectral flatness \(K_{E,c}=0\) together with finite-Jacobi local curvature correlations. +2. **New matrix-element law:** gauge invariance of \(T_{\mu\nu\rho\sigma}\), covariance matching, and the \(N=3,4,5\) decrease of the connected excess. +3. **Topology result:** the bundle-isomorphism proof for fixed \(C_1\) and the independent deformation of relative Wilson holonomy. +4. **Release contract:** `bash run_quick_verify_v1.sh`, the 17-page PDF audit, and the compact/external artifact manifest. + +The quickest entry points are the [technical report](https://github.com/JunkaiWang-TheoPhy/Chaos-of-Quantum-Geometry/blob/codex/task-05-geometric-chaos-baseline/docs/2026-07-30-task05-technical-report.md), Figures 1/6/7, and `01_task_folder/task_05/script/output/release_manifest_v1.json`. + +The central innovation is the combination of exact parent-Hamiltonian kernels, metric-normalized signature compression, a gauge-invariant four-channel Geometric-ETH test, and fixed-Chern holonomy engineering. This creates a calculable bridge from the BPS Berry-curvature program to fractional topological matter and opens a concrete \(N=6\)/second-model scaling program. + +Verification command: + +```bash +cd 01_task_folder/task_05/script +bash run_quick_verify_v1.sh +``` + +--- diff --git a/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-public-release-checklist.md b/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-public-release-checklist.md new file mode 100644 index 000000000..e9c4fd3be --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-public-release-checklist.md @@ -0,0 +1,59 @@ +# Task 05 Public Release Checklist + +## 1. Research Issue Submitted + +- Issue: [QuantumBFS/quantum.harness#276](https://github.com/QuantumBFS/quantum.harness/issues/276). +- Title: `What is the Probe of Quantum Chaos for Degenerate Eigenstate Subspace?` +- The PR body now links the issue and supplies the executable geometric answer. + +## 2. Open the PR + +- Base: `main` +- Head: `codex/task-05-geometric-chaos-baseline` +- Title: `Geometric chaos under exact degeneracy: reproducible task-05 release` +- Body: paste [the prepared PR body](2026-07-30-task05-pr-body.md). +- Suggested mode: Draft during the first scientific review, then Ready for Review after author sign-off. + +## 3. Add the Review Comment + +- Paste [the prepared review comment](2026-07-30-task05-pr-review-comment.md). +- Keep `@OkongOyangO` in the first line so GitHub sends the review notification. +- Request review from the same collaborator in the PR sidebar. + +## 4. Review the Public Landing Page + +- Confirm the hero figure renders on the repository front page. +- Open the Markdown technical report and 17-page PDF. +- Check `CITATION.cff` rendering in GitHub's citation panel. +- Confirm every link in the task release guide resolves. + +## 5. Run the Release Gate + +```bash +cd 01_task_folder/task_05/script +bash run_quick_verify_v1.sh +``` + +Expected compact release state: + +- 38 focused tests; +- 86 passing complete-suite tests; +- 6 production-data tests activated by the manifest-listed arrays; +- 17 rendered article pages; +- 7 synchronized main figures; +- 14 Git-resident compact artifacts; +- 25 production arrays recorded with SHA-256 and byte size. + +## 6. Publish the Data Layer + +- Create a DOI-backed archive for the 25 production arrays when desired. +- Attach the DOI to the GitHub release, technical report, and challenge issue. +- Regenerate `release_manifest_v1.json` with the archived artifacts present and confirm identical hashes. + +## 7. Convert the PR to Ready for Review + +- Confirm author names and public contact details. +- Confirm the issue link. +- Confirm the final article hash. +- Publish the prepared review comment. +- Select **Ready for Review**. diff --git a/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-release-notes.md b/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-release-notes.md new file mode 100644 index 000000000..2e256398c --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-release-notes.md @@ -0,0 +1,39 @@ +# Task 05 Research Release Notes + +**Release ID:** `task05-geometric-chaos-v1` + +## Headline + +**Exact degeneracy turns quantum geometry into the signal.** + +This release transforms the completed task-05 calculation into a public, independently reviewable baseline. It includes the task-local numerical package, compact evidence, seven publication figures, a 17-page REVTeX article, a Markdown technical report, quick and full verification paths, and a machine-readable artifact manifest. + +## Four Research Advances + +1. **An exact geometric-chaos setting.** A local Kapit–Mueller parent supplies a gapped bosonic Laughlin kernel with exact many-body degeneracy. +2. **A finite-rank analytic algorithm.** Metric-normalized curvature reduces to a complex-Jacobi signature compression with an executable determinantal-kernel form factor and boundary-atom theorem. +3. **A matrix-element Geometric-ETH test.** A covariance-whitened, gauge-invariant four-channel tensor exposes progressive Gaussianization plus a resolved connected component across \(N=3,4,5\). +4. **A topology/holonomy separation.** A closed twist-torus family preserves the complete spectrum and \(C_1\) while tuning relative Wilson transport. + +## Evidence Layers + +| Evidence class | Public result | Authoritative artifact | +|---|---|---| +| Exact | \(K_{E,\mathrm{raw}}=D\) and \(K_{E,c}=0\) in the degenerate manifold | Article Eq. (1), Figure 1 | +| Statistical | Metric-normalized curvature follows finite-Jacobi local correlations and a registered ramp | Figures 1–5, `spectral_silence_delivery_audit_v2.json` | +| Matrix element | The four-channel connected excess decreases \(0.15385\to0.10078\to0.08183\) | Figure 6, `matrix_element_geometric_eth_v3.json` | +| Topological | \(C_1=6,10\) stays fixed while Wilson statistics shift reproducibly | Figure 7, `topological_holonomy_v3.json` | + +The registered outcome labels are `deformed_geometric_eth` and `fixed_chern_deformed_holonomy`. Numerical gates generate both labels directly from the frozen artifacts. + +## Reproduction Contract + +- Quick verification: 38 focused tests plus release hashes, result labels, task isolation, analytic identities, documentation links, and citation metadata. +- Complete compact suite: 86 passing tests and 6 production-data tests that activate upon restoration of the manifest-listed arrays. +- Article verification: seven synchronized figures, clean REVTeX compilation, PDF metadata, 17 rendered pages, citation records, and scientific-scope checks. +- Full reproduction: staged v1, v2, and v3 numerical pipelines with resumable checkpoints. +- Data manifest: 14 compact artifacts in Git and 25 production arrays with exact paths, sizes, SHA-256 hashes, and producer commands. + +## Growth Horizon + +The completed \(N=3,4,5\) sequence is the public reference baseline. The Quantum Harness challenge advances to \(N=6\), a second exact-degeneracy mechanism, and a derivation of the four-channel scaling from locality. Each registered outcome contributes a publishable statement about the emergence and structure of Geometric ETH. diff --git a/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-technical-report.md b/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-technical-report.md new file mode 100644 index 000000000..025eb6557 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/docs/2026-07-30-task05-technical-report.md @@ -0,0 +1,148 @@ +# Technical Report: Geometry Speaks Under Exact Degeneracy + +**Release:** `task05-geometric-chaos-v1` +**Article:** *Spectral Silence and Geometric Chaos in an Exactly Degenerate Topological Manifold* +**Authors:** Thomas J. Wang and OKongOYangO +**Date:** 2026-07-30 + +## Executive Signal + +This project establishes a new route to diagnosing quantum chaos when an entire many-body manifold is exactly degenerate. Instead of introducing an artificial energy splitting, it measures how the protected subspace moves over coupling space. The result is a hierarchy of geometric information: finite-Jacobi curvature correlations at local scales, a gauge-invariant connected response cumulant at the operator level, and tunable Wilson holonomy inside a fixed Chern class. + +The central scientific advance is therefore stronger than a new statistic. It is a complete architecture for **geometric chaos under exact spectral flatness**: + +$$\text{exact parent kernel}\longrightarrow\text{projector response}\longrightarrow\text{metric normalization}\longrightarrow\text{finite-rank RMT}\longrightarrow\text{global bundle topology}.$$ + +## Relation to the Starting Point + +Chen, Colin-Ellerin, Mamroud, and Papadodimas introduced non-Abelian Berry curvature as an intrinsic chaos diagnostic for exactly degenerate BPS sectors. Their work supplies the conceptual starting point: energy degeneracy elevates quantum geometry from an auxiliary observable to the primary carrier of chaos information. + +This release adds a complementary condensed-matter realization and four new layers: + +| Starting capability | Innovation in this project | Why it matters | +|---|---|---| +| Curvature as a BPS chaos diagnostic | Exact bosonic Laughlin zero modes of a local Kapit–Mueller parent | Demonstrates the geometric principle in a frustration-free fractional-topological system | +| Random-matrix-like curvature | Exact finite-\(D\) complex-Jacobi kernel and connected form factor | Supplies a parameter-free benchmark at the dimensions used numerically | +| Curvature eigenvalue evidence | Gauge-invariant four-channel response tensor | Promotes Geometric ETH from eigenvalue statistics to a matrix-element statement | +| Moduli-space Chern topology | Fixed-spectrum, fixed-Chern, tunable Wilson holonomy | Separates integrated topology from relative non-Abelian transport | +| Numerical demonstration | Cryptographic release manifest and tiered verification | Makes every public claim traceable to source, figure, compact artifact, or regenerable array | + +## Why the New Algorithms Make This Possible + +### Exact parent-Hamiltonian geometry + +The bosonic contact parent is positive semidefinite, and its Laughlin quasihole manifold is the exact kernel. The Kapit–Mueller lattice supplies an exactly flat Chern band and a clean boundary-twist torus. Together they provide exact degeneracy, an open external gap, a growing multiplet rank, and local response channels in one calculable model. + +### Signature-compression reduction + +Let \(P\) project onto the exact zero-mode manifold and \(Q=1-P\). The resolvent-dressed response map for a deformation \(\lambda^\mu\) is + +$$X_\mu=P(\partial_\mu H)Q\,[Q(H-E_0)Q]^{-1}.$$ + +After whitening by the quantum metric, the curvature becomes a compression of a fixed signature matrix by the row space of the response channel. When that row space is Haar distributed, the curvature eigenvalues form an exact complex-Jacobi process. The algorithm therefore replaces a large, model-specific matrix comparison with a finite-rank analytic law containing the correct rank, support, and boundary atoms. + +### Determinantal-kernel form factor + +The connected curvature form factor is evaluated directly from the unfolded finite-Jacobi determinantal kernel. For \(D>M\), the signature compression produces exact atoms at \(\lambda=\pm1\). Separating their algebraic multiplicities yields + +$$K_{J,c}^{\mathrm{full}}(\tau)=\frac{k}{D}K_{J,c}^{(k)}(\tau),\qquad k=2M-D.$$ + +At \(D=800\), the calculation resolves 120 atoms on each boundary and a connected plateau of \(0.7\). This finite-rank correction is available analytically and is implemented as an executable theorem. + +### Gauge-invariant four-channel law + +The whitened response tensor + +$$T_{\mu\nu\rho\sigma}=\frac{1}{D}\operatorname{Tr}(\widetilde X_\mu\widetilde X_\nu^\dagger\widetilde X_\rho\widetilde X_\sigma^\dagger)$$ + +is invariant under independent changes of basis in the zero-mode and complementary subspaces. Its complex-Gaussian reference is generated from measured two-point covariances and independent samples, so the normalized residual \(R_4\) measures a genuine connected four-channel component. + +### Bundle-isomorphism control of holonomy + +For a smooth periodic ambient unitary \(\mathcal U_g(\theta)\), + +$$H_g(\theta)=\mathcal U_g(\theta)H_0(\theta)\mathcal U_g^\dagger(\theta)$$ + +preserves every energy, the external gap, and the vector-bundle isomorphism class. The Berry connection gains the projected one-form + +$$A_g=A_0+i\Phi_0^\dagger\mathcal U_g^\dagger d\mathcal U_g\Phi_0,$$ + +which tunes relative Wilson transport while \(C_1\) stays fixed. This provides a clean causal separation of determinant topology and non-Abelian holonomy. + +## Quantitative Results + +### Exact spectral-flatness identity + +For a \(D\)-fold degenerate zero-mode manifold, + +$$K_{E,\mathrm{raw}}=D,\qquad K_{E,c}=0.$$ + +This exact identity fixes the baseline and motivates the geometric channel. + +### Local curvature universality + +The physical ensemble contains 20000 independent Kapit–Mueller tangent pairs. At \(\tau=0.5\), the connected curvature form factor is \(0.502\), compared with \(0.501\) from the exact finite-\(D\) Jacobi kernel. A full-rank Fourier tangent family produces \(4.476\), cleanly resolving microscopic structure at the same active rank. + +### Matrix-element Geometric ETH + +| \(N\) | \(D\) | Physical median \(R_4\) | Matched Gaussian median | Connected excess | +|---:|---:|---:|---:|---:| +| 3 | 16 | 0.37093 | 0.21708 | 0.15385 | +| 4 | 25 | 0.24715 | 0.14638 | 0.10078 | +| 5 | 36 | 0.20906 | 0.12723 | 0.08183 | + +The monotone decrease reveals progressive Gaussianization, while the resolved connected component defines the registered `deformed_geometric_eth` branch. + +### Fixed-Chern holonomy + +| \(N\) | \(D\) | \(C_1\) | Minimum external gap | Base Wilson \(\langle r\rangle\) | Deformed seed interval | +|---:|---:|---:|---:|---:|---:| +| 3 | 16 | 6 | 0.051741 | 0.28849 | [0.30837, 0.35754] | +| 4 | 25 | 10 | 0.094695 | 0.30998 | [0.32379, 0.34411] | + +The complete spectrum and \(C_1\) stay fixed across the family. The Wilson shift is reproducible across seeds and occupies a structured regime distinct from CUE, establishing `fixed_chern_deformed_holonomy`. + +## Innovation-to-Evidence Matrix + +| Innovation | Primary evidence | Independent verification | +|---|---|---| +| Exact spectral-flatness baseline | Figure 1 and Eq. (1) | Analytic form-factor tests | +| Finite-Jacobi curvature algorithm | Figures 1, 2, and 5 | Quadrature stability and Monte Carlo cross-checks | +| Independent spectral/geometric interventions | Figure 3 | Fixed-projector and tangent-channel invariance tests | +| Correlation hierarchy | Figure 4 | Matrix-level simultaneous confidence bands | +| Four-channel Geometric ETH | Figure 6 | Gauge randomization and covariance-matched references | +| Fixed-Chern Wilson engineering | Figure 7 | Mesh convergence, branch margins, and isospectral checks | +| Reproducible public release | Release manifest | Hash, link, blob-size, isolation, PDF, and test audits | + +## Delivery Package + +- [17-page article PDF](../01_task_folder/task_05/script/output/spectral_silence_and_geometric_chaos_v3.pdf) +- [Task release guide](../01_task_folder/task_05/README.md) +- [Machine-readable release manifest](../01_task_folder/task_05/script/output/release_manifest_v1.json) +- [Combined PDF/article audit](../01_task_folder/task_05/script/output/geometric_eth_topology_delivery_audit_v3.json) +- [Matrix-element artifact](../01_task_folder/task_05/script/output/matrix_element_geometric_eth_v3.json) +- [Topology artifact](../01_task_folder/task_05/script/output/topological_holonomy_v3.json) +- [Seven-figure package](../01_task_folder/task_05/script/output/figure_1_spectral_silence_v2.png) +- [Public challenge handoff](2026-07-30-quantum-geometry-harness-challenge-draft.md) + +## Verification + +The compact review path is: + +```bash +cd 01_task_folder/task_05/script +python -m pip install -r requirements.txt +bash run_quick_verify_v1.sh +``` + +It checks 17 release-contract classes and 38 focused tests. The complete compact-checkout suite reports 86 passing tests plus 6 production-data tests that activate when their manifest-listed arrays are restored. The article build independently compiles and audits all 17 pages, seven figures, references, metadata, and source synchronization. + +## Forward Program + +The release opens three high-value directions: + +1. extend the genuine fixed-two-quasihole sequence through \(N=6\) and resolve the asymptotic four-channel law; +2. transfer the invariant response-tensor protocol to a second exact-degeneracy mechanism; +3. connect local curvature, operator cumulants, and Wilson transport to dynamical observables. + +The combined analytic reduction and reproducible numerical architecture make each direction immediately testable. The public challenge packages these goals into machine-verifiable outcomes and welcomes independent implementations. diff --git a/tracks/mps/solutions/Wander-276/research/docs/2026-08-01-scientific-ceiling-strategy.md b/tracks/mps/solutions/Wander-276/research/docs/2026-08-01-scientific-ceiling-strategy.md new file mode 100644 index 000000000..19eb3bb24 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/docs/2026-08-01-scientific-ceiling-strategy.md @@ -0,0 +1,247 @@ +# 如何抬高 *Chaos of Quantum Geometry* 的科学上限 + +Date: 2026-08-01 + +Authoring agent: [Codex] + +## 2026-08-04 封存结果 closeout + +封存的 $N=14$ 主检验已经完成独立 hash/source 审计并显式解盲。Adjacent sparse 的物理中位数为 $0.301529$，complete-realization 95% 区间为 $[0.291527,0.312061]$；collapsed 与 Hodge 97.5% prediction intervals 分别为 $[0.111789,0.111852]$ 和 $[0.112344,0.112513]$。Central sparse 的对应结果为 $0.374993$、$[0.368980,0.380473]$，而两个 null 区间分别为 $[0.111338,0.111353]$ 和 $[0.111333,0.111348]$。两个主 sector 都拒绝两个冻结的 separable covariance null，选择 `cohomological_non_gaussian_class`。 + +因此 `Independent model/operator class` 门槛已经从设计层面升级为封存验证后的有限尺寸结果：generic fixed-charge cubic $\mathcal N=2$ SYK 通过 exact/coexact cohomological response 实现了独立于 Kapit--Mueller/Laughlin 的保护机制，并在同一个 four-channel protocol 下保留结构记忆。`Asymptotic Geometric ETH` 仍未建立；完整 nonseparable entrywise covariance matching 也仍未完成。当前组合使 PRL 成为有逻辑依据的首投尝试，但 PRX Quantum 仍需要更强的 QIS consequence/capability，Nature Physics 仍需要受控大 $N$ 定律、BPS 新预测或同等级的广泛概念后果。 + +## 2026-08-02 状态更新：两个上限门槛已经分化 + +这份路线图中的一个关键前提已经改变。`Independent model/operator class` 不再是“没有”：当前 v7 工作使用 generic fixed-charge cubic $\mathcal N=2$ SYK 的 harmonic cohomology，实现了与 Kapit--Mueller/Laughlin $B^\dagger B$ parent 不同的 $H=\{Q,Q^\dagger\}$ 保护机制。其响应严格分成正交 exact/coexact 分支；$N=8,10,12$ 的 12 个 size/sector/panel 组都拒绝冻结的 collapsed 与 Hodge-separable Gaussian null。这里的新贡献不是再次发现 SYK Berry-curvature chaos，而是用同一个 gauge-invariant four-channel 统计量对不同保护复形进行 pre-outcome prediction test。 + +`Asymptotic Geometric ETH` 仍然没有建立。即使封存的 $N=14$ 验证重复 pilot 分支，它也只把结论升级成受预注册保护的有限尺寸 cross-mechanism response class；它不能给出大 $N$ 集中定理、受控指数或 thermodynamic limit。两个主题因此都重要，但不是“做完两个 checkbox 就自动中好杂志”：独立机制回答“不是单个 parent 的巧合”，渐近理论回答“这是不是一个真正的普适律”。 + +### 按期刊官方标准重新判断 + +- [Physical Review Letters 的官方标准](https://journals.aps.org/prl/authors/publish/policies-and-practices-physical-review-letters-july-2013)要求工作构成一个领域中的重大进展或具有跨子领域影响，并且以广泛物理读者能理解的方式说明问题与主要成就。若 $N=14$ 封存检验通过全部门禁，当前组合——能谱沉默、量子几何替代诊断、独立拓扑与 SUSY 保护机制、精确 response-complex identity、无事后拟合的验证——已经形成一个可信的 PRL 尝试，而不是只有“多算了一个尺寸”。这仍是投稿判断，不是录用保证。 +- [PRX Quantum 的官方 acceptance criteria](https://journals.aps.org/prxquantum/about)要求至少体现 exceptional advance、exceptional connection、exceptional capability 或 exceptional insight；其[官方 scope](https://journals.aps.org/prxquantum/scope)明确包含 many-body quantum information、fundamental physics、verification/validation 与 benchmarking。当前工作的最佳匹配是 exceptional connection：把 BPS/SUSY cohomology、FQH parent geometry、随机矩阵高阶响应和 fail-closed computational validation 连接起来。要让它成为强 PRX Quantum 稿，而不是可尝试稿，需要把诊断明确连接到 quantum information observable、verification protocol 或参数空间信息传输后果。 +- [Nature Physics 的官方 scope](https://www.nature.com/nphys/submission-guidelines/about/aims)要求最高质量和显著性的广泛物理结果；其[审稿流程说明](https://www.nature.com/nphys/editorial-policies/peer-review)也明确只有最可能满足一般兴趣标准的稿件才会送外审。当前有限尺寸结果即使封存成功，也不足以把 Nature Physics 当作现实首投目标。合理的抬档条件是：受控大 $N$ 定律、一个参数无关的 geometric echo/holonomy/OTOC 后果，或对 BPS black-hole microstates 给出 seed paper 之外的新定理或预测；三者至少完成一个，最好完成两个。 + +### 当前最诚实的期刊上限 + +| 完成状态 | 科学含义 | 投稿判断 | +|---|---|---| +| 已完成 $N=8,10,12$ pilot 与封存 $N=14$ 主检验 | 独立 cohomological 机制 + outcome-blind finite-size falsification；两个主 sector 均拒绝两个冻结 null | PRL 是合理首投；PRX Quantum 可尝试但需强化 QIS consequence | +| 再完成 full nonseparable covariance control 或可推导尺度律 | 排除“只是遗漏两点协方差”的主要替代解释，进入机制性 universality | 强 PRL / 实质性 PRX Quantum | +| 再加局域 SUSY parent 或参数无关动力学/拓扑后果 | 跨保护、局域性与独立物理后果形成统一原则 | 强 PRX；Nature Physics 成为高风险但有逻辑依据的目标 | +| 建立大 $N$ concentration theorem 并产生 BPS/black-hole 新预测 | Asymptotic Geometric ETH 与原始物理动机闭环 | Nature Physics/PRX 级真正高上限，仍无录用保证 | + +判断方法不是数关键词，而是问审稿人最难提出的替代解释还剩什么。现在最主要的替代解释已经从“只属于 Kapit--Mueller”变成“当前 null 没有匹配完整 nonseparable entrywise covariance”；最主要的量词缺口则仍是“$N\le14$ 不能决定 $N\to\infty$”。因此下一轮最值钱的工作不是立即堆 $N=16,18$，而是先导出或构造更强的 covariance-complete null，再用新增尺寸区分一个冻结的大 $N$ 预测。 + +## 结论先行 + +这篇工作的科学上限，不由还能多算几个粒子决定，而由论文标题中最强的量词决定。当前最稳妥的主张是：在一个 Kapit--Mueller bosonic Laughlin 精确零模家族中，能谱完全沉默时，非阿贝尔量子几何仍表现出局域 Jacobi 型相关和朝协方差匹配 Wick 零假设收敛的有限尺寸流，同时保留可分辨的非高斯结构记忆。要提高上限，需要把“一个构造中的有限尺寸观察”至少升级为以下三者之一：一个可推导的机制、一个跨模型的普适类、一个可检验的新后果。单纯扩大同一模型的 Monte Carlo 样本、增加曲率统计量或把随机矩阵维数推得更高，只会提高精度，不会改变主张的逻辑等级。 + +最优研究组合是：现有 PRL 包不继续等待，保持其聚焦并进入投稿；随后以“机制优先、独立模型复现、可观测后果”为三个升级阶段发展一篇更高上限的后续工作。若只能选择一个下一步，应先做同一精确保护框架中的第二局域算符类，并同时推导以有效通道数为尺度的四点连通量衰减律。它最便宜，也最直接判断当前结果究竟是 Geometric ETH 普适性，还是仅属于密度型变形的特殊性质。 + +## 一、先学会区分“算得更多”和“知道得更多” + +当前摘要中最弱的一句话可以抽象成： + +> 在一个工程化的精确简并拓扑 parent family 上，我们观察到五个粒子数的有限尺寸流。 + +提高科学上限，本质上是改写这句话中的四个语法部件： + +| 维度 | 当前状态 | 真正的升级 | +|---|---|---| +| 名词 | 一个 Kapit--Mueller 家族 | 一类精确简并流形、两种不同保护机制、或 SUSY/BPS 扇区 | +| 动词 | 数值观察 | 推导、证明、预测、分类 | +| 量词 | \(N=3,\ldots,7\) 的有限尺寸趋势 | 受控渐近律、跨模型数据塌缩、或有假设的定理 | +| 后果 | 一个新的诊断量 | 对慢驱动、参数回波、Wilson 传输、OTOC 或简并解除交叉的参数无关预测 | + +一个新计算如果不改变这四项中的任何一项，它通常只是精度工作。精度工作可能是投稿审计所必需的，却很少提高期刊上限。 + +可以把科学主张分成五级： + +1. **存在性：** 能谱沉默时，几何仍然非平凡。 +2. **非冗余性：** 几何混沌与能谱混沌、Chern 数和秩可以独立变化。 +3. **机制性：** 局域响应通道为何产生 Jacobi 相关和特定的非高斯修正。 +4. **普适性：** 同一律跨算符类、模型或精确简并机制成立。 +5. **后果性：** 该几何律决定一个独立可计算的动力学、输运或信息论效应。 + +现有论文已经可靠达到第二级，并且凭借精确 transported-kernel identity 进入了第三级的一部分。PRX 级别的自然目标是完整的第三级加第四级，或第三级加第五级。更宽领域的顶级期刊通常需要第四级和第五级至少有一个非常强，并且故事重新回到 BPS/黑洞问题或一个足够普遍的多体原则。实验不是硬门槛；没有机制、普适性和后果才是门槛。 + +## 二、六种真正能提高上限的杠杆 + +### 1. 从有限尺寸拟合升级为可推导的尺度律 + +当前 \(\delta_4\) 随 \(D\) 单调下降，并且有限尺寸信息偏好零截距的 \(1/D\) 形式，但五个尺寸不能区分严格趋零和很小的平台。下一步不应只是把 \(N=8\) 接在曲线上，而应先问：为什么尺度变量应当是 \(D\)，而不是外部空间维数、可达响应秩、通道参与率或某个相关长度？ + +理论目标是把响应写成受局域性和算符代数约束的协方差变形随机通道， + +$$X_a\simeq\sum_b(C_{\mathrm{op}}^{1/2})_{ab}G_bC_R^{1/2}+\delta X_a,$$ + +然后在清楚写明的混合假设下，证明或推导连通四点量随有效独立通道数 \(M_{\mathrm{eff}}\) 抑制，例如给出 \(\delta_4\) 的上界、主导阶或可检验系数。这样，\(N=8\) 的作用才是区分理论预言，而不是帮助选择一个好看的拟合函数。 + +成功后的摘要动词会从“观察到下降”变为“推导并验证一个有限尺寸律”。即使最后得到非零平台，只要平台由局域可达代数决定并能跨算符类预测，它仍然是一种 deformed Geometric ETH 普适类，而不是失败。 + +### 2. 从单一密度变形升级为算符类普适性或分类 + +这是性价比最高的下一步。保持同一个精确零模 projector、相同粒子数序列和相同统计流程，只更换保护家族的生成元：从当前类型扩展到键、流或更长程但仍准局域的一体生成元。精确 transported-kernel 定理使这些方向无需重新解决完整 resolvent 问题，因此计算资源主要用于零模 frame 和相同的 panel aggregation。 + +关键结果不是“第二条曲线也下降”，而是下面两个互斥且都科学上有价值的分支： + +- 不同算符类在以 \(M_{\mathrm{eff}}\) 或可达秩重标度后塌缩到同一曲线：支持一个受局域协方差变形的普适 Geometric ETH。 +- 密度、键和流变形趋向不同的极限，但差异由可达算符代数或守恒律预测：得到 operator-class geometric phases 的分类。 + +第二个分支不比第一个差。真正糟糕的是只看到不同曲线，却没有能解释差异的结构变量。 + +### 3. 从一个工程化 parent family 升级为独立精确简并机制 + +这是抬高 PRX 上限最直接的方式。第二个模型必须消除第一模型最可能的替代解释，而不是仅仅改一个晶格参数。候选按目标分成三类： + +- **近期最稳健：continuum LLL pseudopotential Laughlin 零模。** 它可以回答现象是否依赖 Kapit--Mueller 长程跳跃和晶格构造。若相同的白化四点律出现在 continuum torus 上，主张从“某个晶格 parent”升级为“Laughlin 零模流形”。 +- **拓扑上限最高：Moore--Read 或 Read--Rezayi quasihole parent。** 这些流形本身具有非阿贝尔编织结构。可以研究确定的拓扑 braid representation 与局域随机曲率能否共存，并把“固定 Chern”升级为“固定非阿贝尔拓扑数据与混沌几何分离”。已有 lattice Moore--Read parent Hamiltonian 可以通过耦合变化移动和编织 quasiholes，这给出了自然参数空间。[Manna et al.](https://arxiv.org/abs/1807.11222) +- **与 seed paper 联系最强：SUSY/cohomological zero modes。** 构造 \(Q(\lambda)^2=0\)、\(H(\lambda)=\{Q,Q^\dagger\}\) 的精确零模流形，比较结构化和混沌超荷下的 Berry curvature。二维 supersymmetric lattice fermion 的零模可由 cohomology 精确描述，为此提供现成理论语言。[Huijse and Schoutens](https://arxiv.org/abs/0903.0784) + +选择原则很简单：如果目标是尽快增强当前 PRL 的自然性，先做 continuum LLL 或第二个 FQH parent；如果目标是发展一篇真正回到黑洞/BPS 动机的后续论文，应优先 SUSY/cohomological 模型。不要同时搭建三个新平台，因为那会把理论问题稀释成软件工程。 + +### 4. 从“诊断”升级为“产生后果的定律” + +Geometric ETH 最容易被质疑为“又一个看起来像随机矩阵的统计量”。最强回应不是更多随机矩阵图，而是证明它控制一个独立响应。 + +最自然的对象是小参数回路。沿 \((\lambda^a,\lambda^b)\) 平面走一个面积为 \(\mathcal A\) 的小矩形，简并子空间中的 holonomy 满足 + +$$U_{\square}=\exp\!\left(iF_{ab}\mathcal A+O(\mathcal A^{3/2})\right).$$ + +因此返回概率、\(\operatorname{Tr}U_{\square}\) 的矩、连续随机小回路的非阿贝尔扩散，以及非高斯修正，都可以由曲率二点和四点 cumulant 预测。若能从现有 \(X_a\) 的 Wick/connected decomposition 推出一个无额外拟合参数的 geometric echo 或 Wilson-loop 统计，并在独立数值演化中验证，论文就从“定义一个 chaos diagnostic”升级成“发现一个控制参数空间动力学的统计定律”。 + +第二条桥梁是绝热规范势。\(X_a\) 正是 AGP 的 fiber-to-complement block；AGP 已被证明对可积性破缺和量子混沌敏感。[Pandey et al.](https://arxiv.org/abs/2004.05043) 可以尝试推导简并 projector 版本的 Kubo/AGP identity，并比较轻微解除简并后的谱统计交叉。重点必须是一个推导出来的 crossover relation，而不是两张相关性图。 + +第三条桥梁是 generalized/full ETH。标准 ETH 的二点信息不足以决定 OTOC，高阶矩阵元相关和 free cumulants 才是关键。[Foini and Kurchan](https://arxiv.org/abs/1803.10658)；[Pappalardi, Foini, and Kurchan](https://arxiv.org/abs/2204.11679)；[Pappalardi, Fritzsch, and Prosen](https://arxiv.org/abs/2303.00713) 当前四通道残差可以被明确解释为简并几何版本的 connected free cumulant；若能证明它决定一个参数空间 OTOC 或 echo correction，就把 “Geometric ETH” 从命名提升为真正与 full ETH 同构的框架。 + +### 5. 从固定 Chern 反例升级为 topology-constrained random process + +现有受控结果证明了完整能谱和 \(C_1\) 固定并不决定非阿贝尔 Wilson holonomy，但 ambient conjugation 是人为设计的，并且 holonomy 仍非 CUE。更高上限的版本应在自然物理 moduli 上研究 \(U(D)\) holonomy 的分解：拓扑约束控制 determinant/\(U(1)\) 扇区，而 traceless \(SU(D)\) 扇区是否趋向一个 Brownian、free-unitary 或 covariance-deformed 过程。 + +一个值得追求的定理结构是：固定 Chern 数约束 \(\det U_\gamma\)，但在满足局域混合条件时，\(SU(D)\) holonomy 的低阶 cumulants 按独立规律衰减。数值上应使用 twist、interaction metric、quasihole position 或超对称 coupling 等自然参数，而不是仅使用 ambient orbit。若在 Moore--Read 或 \(\mathcal N=2\) SYK/SUSY 零模中实现，这条路线可直接承接 seed paper 关于 moduli-space topology 和大 Chern 数的主线。[Chen et al.](https://arxiv.org/abs/2604.23287) + +### 6. 从正面现象升级为必要性、充分性和 no-go 边界 + +高水平理论论文不一定需要所有结果都“更随机”。一个严格的失败边界同样能提高上限，例如：证明有限范围、守恒律或低可达秩必然保留某个非高斯 cumulant；证明某类 frustration-free deformation 永远不可能达到完整 CUE；或者证明拓扑只约束 central sector 而不能约束 traceless curvature。这样的 no-go theorem 会把当前的“deformed”从有限尺寸不完美变成一个新 universality class 的定义特征。 + +设计计算时要包含干预而不只是对照：固定 \(P\) 改变 \(PHP\)、固定能谱改变 \(P(\partial H)Q\)、固定拓扑改变局域连接、固定 covariance 改变高阶 cumulant。只有这种“保持其他量不变”的实验，才能回答必要性和充分性。 + +## 三、三条完整路线及其取舍 + +### 路线 A：机制优先——第二算符类加尺度理论 + +这是推荐的下一步，也是单位计算资源信息增益最高的路线。 + +**核心问题：** \(\delta_4\) 的下降是简单局域算符经过巨大外部通道混合后的中央极限定律，还是当前密度型变形的特殊性质？ + +**理论工作：** 推导可达支持、左右协方差和 connected four-point tensor 的有限 \((D,M,m)\) 结构；定义从协方差谱得到的 \(M_{\mathrm{eff}}\)；给出 \(\delta_4(M_{\mathrm{eff}})\) 的主导预测或上界。 + +**数值工作：** 在完全相同的 \(N=3,\ldots,7\) kernel 上运行固定的 bond/current panels；保持 whitening、Gaussian null、bootstrap 和阈值不变；比较按 \(D\) 和按 \(M_{\mathrm{eff}}\) 的 collapse；只有在两个候选渐近行为在 \(N=8\) 上给出可分辨差异时才启动 \(N=8\)。 + +**成功主张：** “一类精确保护多体流形遵循由可达通道数控制的 covariance-deformed Geometric ETH。” + +**失败后的可发表主张：** “局域算符代数定义不同的 geometric universality classes。” + +**上限判断：** 足以明显稳固 PRL；若理论结果具有一般性并且跨算符类 collapse 成功，可成为 PRX 结构的核心，但单靠它通常还不足以支撑 Nature Physics 级别的广泛物理影响。 + +### 路线 B：普适性优先——第二种精确简并机制 + +**核心问题：** Geometric ETH 是 Laughlin/Kapit--Mueller 构造的性质，还是精确简并多体流形的一般现象？ + +**近期版本：** continuum LLL Laughlin 或独立 CFT lattice parent，复用同一 gauge-invariant cumulant pipeline。 + +**高风险高回报版本：** Moore--Read/Read--Rezayi 非阿贝尔 quasiholes，或 SUSY/cohomological zero modes。前者把拓扑编织与几何混沌放在同一框架中，后者把工作直接送回 BPS 黑洞动机。 + +**成功主张：** “不同物理保护机制在 whitened response space 中共享同一几何统计律，而 central/topological data 保持模型特异。” + +**失败后的价值：** 若 FQH 成功而 SUSY 失败，或反之，结果会定位 Geometric ETH 的适用条件；这比盲目声称普适更有理论价值。 + +**上限判断：** 独立模型复现加共同尺度变量是最清楚的 PRX 升级；若同时产生 BPS/黑洞新结论，则有资格把 Nature Physics 作为高风险目标，而不依赖实验。 + +### 路线 C：后果优先——geometric echo、AGP 或 topology-constrained holonomy + +**核心问题：** 几何 cumulant 除了诊断混沌，还决定什么？ + +**理论工作：** 从小回路展开或慢驱动 Kubo 公式导出可观测量，明确二点项、Wick 项和 connected four-point correction；给出不从验证数据重新拟合的预测。 + +**数值工作：** 用独立的有限回路或时变 coupling 演化验证预测；构造结构化和混沌 family，在相同能谱/拓扑约束下比较回波扩散；必要时加入受控简并解除来连接普通 level statistics 和 OTOC。 + +**成功主张：** “Geometric ETH 决定简并多体流形中的参数空间信息扩散/非阿贝尔回波。” + +**风险：** 如果最终只有 AGP、OTOC 和 \(R_4\) 的经验相关，这条路线不会抬高上限；必须有 identity、sum rule 或参数无关预测。 + +**上限判断：** 一个清楚的新后果能显著扩大受众，并给 PRX 级故事提供第二条腿；若再与 BPS moduli 或非阿贝尔任意子结合，可能成为最有辨识度的长线方向。 + +## 四、超算应该如何使用 + +超算的价值不是“把所有尺寸都算一遍”，而是让互相竞争的理论预言变得可分辨。每个大任务提交前，必须能回答三句话： + +1. 如果成功，摘要中哪一个名词、动词或量词会变强？ +2. 它消灭哪一个具体替代解释？ +3. 如果失败，是否会自动落入另一个事先定义的科学分支？ + +推荐的计算顺序是： + +1. 复用 \(N=3,\ldots,7\) kernels，完成第二 bond/current 算符类。它检验 universality，成本远低于新模型。 +2. 同时完成 \(M_{\mathrm{eff}}\) 理论和无需高阶数据拟合的曲率/四点预测。只有理论能区分候选趋势后，才决定是否需要 \(N=8\)。 +3. 若算符类 collapse 成功，选择一个独立自然机制。以近期论文为目标选 continuum LLL；以长线高上限为目标选 SUSY/cohomological 或 Moore--Read。 +4. 在普适结构明确后，推导并验证小回路 geometric echo。这样后果建立在一个稳定定律上，而不是建立在单个模型的漂亮图上。 + +明确的止损条件： + +- 第二算符类不 collapse 时，不继续用更多尺寸强迫单一 \(1/D\) 拟合；转向 operator-class classification。 +- \(N=8\) 只有在零极限与平台模型对该点作出可分辨预测时才值得做；否则它只是更昂贵的第六个点。 +- 独立模型若无法维持精确简并、固定 nullity 和开隙，就不能承担“exact-degeneracy universality”的主张；应保留为解除保护的 crossover 对照。 +- 动力学路线若不能得到参数无关关系，就暂不进入主论文。 + +## 五、如何预判审稿人的真正 objections + +把审稿人想象成依次提出五个问题： + +1. **这是数值或 gauge artifact 吗？** 现有 frame invariance、solver residual、结构化 control 和 fail-closed audit 已经较好解决。 +2. **这只是有限尺寸拟合吗？** 需要理论尺度变量、额外判别尺寸或严格界。 +3. **这只属于 Kapit--Mueller/这个生成元吗？** 需要第二算符类和独立模型。 +4. **为什么会出现这个统计律？** 需要 locality/accessibility/mixing 的机制。 +5. **除了新统计量，它改变了什么物理？** 需要 geometric echo、topology-constrained process、AGP/OTOC bridge 或 BPS 新预测。 + +当前最值得花资源的是第二到第四个问题，而不是继续加固已经很强的第一个问题。 + +## 六、期刊上限与项目组织 + +现有 v5 Letter 已经是一个聚焦、可审计、适合立即尝试 PRL 的包。继续把所有长线路线塞进当前 Letter 会损害它的中心悖论，也会延迟一个已经形成闭环的结果。因此建议采用“双轨制”： + +- **当前论文：** 冻结 v5，完成作者元数据和公开归档后投稿 PRL。它的主张保持为 exact spectral silence 加 protected deformed Geometric ETH，并明确有限尺寸与单模型边界。 +- **上限论文：** 以路线 A 为起点；若跨算符类成立，进入路线 B；若得到共同定律，再做路线 C。这样每一步都能单独形成科学分支，失败不会摧毁整个项目。 + +大致的上限映射不是录用保证，而是主张结构判断： + +| 新增内容 | 主张升级 | 合理上限 | +|---|---|---| +| 仅增加 \(N=8\)、样本数或曲率图 | 更精确的同一观察 | 不改变期刊层级 | +| 第二算符类加理论尺度律 | 机制或 operator-class classification | 强化 PRL；广义定理可触及 PRX | +| 独立精确简并模型加共同 collapse | 跨机制普适性 | PRX 成为实质性目标 | +| 普适律加参数无关动力学/拓扑后果 | 新原则和新预测 | 强 PRX；更广期刊的必要条件之一 | +| 回到 SUSY/BPS 并产生 seed paper 之外的新定理或预测 | 统一 condensed matter 与 black-hole microstates | Nature Physics 级高风险上限，不要求实验但要求广泛概念影响 | + +## 七、以后独立判断研究方向的方法 + +每当出现一个新想法，先做“摘要句测试”，不要先写代码。把成功结果写成一句话，并检查它改变的是哪一个部件： + +> 我们在【什么对象】上【观察/推导/证明】了【多大范围成立的规律】，它【排除了什么替代解释】并【预测了什么新后果】。 + +如果新想法只能填入“多算了一个尺寸”或“又画了一种分布”，它的科学信息增益通常低。若它能把“一个模型”改成“一类模型”，把“观察”改成“推导”，把“有限尺寸”改成“共同尺度律”，或者增加一个不能由原数据自动保证的新后果，它才真正提高上限。 + +最后再做“反事实测试”：假如结果与预期相反，是否仍能形成清楚结论？好的研究设计至少有两个可发表分支；坏的设计只有在曲线朝想要的方向走时才有故事。当前项目的最好反事实正是：统一 collapse 对应 Geometric ETH，稳定分裂对应 operator-class geometric phases，非零平台对应 locality-protected deformed ETH。这样超算不是用来赌博，而是用来在有限个理论分支之间做决定。 + +## 参考文献与原始来源 + +- [Y. Chen et al., *Chaos of Berry curvature for BPS microstates*](https://arxiv.org/abs/2604.23287) +- [E. Kapit and E. Mueller, *Exact Parent Hamiltonian for Quantum Hall States in a Lattice*](https://arxiv.org/abs/1005.3282) +- [P. Pandey et al., *Adiabatic Eigenstate Deformations as a Sensitive Probe for Quantum Chaos*](https://arxiv.org/abs/2004.05043) +- [L. Foini and J. Kurchan, *Eigenstate thermalization hypothesis and out of time order correlators*](https://arxiv.org/abs/1803.10658) +- [S. Pappalardi, L. Foini, and J. Kurchan, *Eigenstate thermalization hypothesis and free probability*](https://arxiv.org/abs/2204.11679) +- [S. Pappalardi, C. Fritzsch, and T. Prosen, *General Eigenstate Thermalization via Free Cumulants in Quantum Lattice Systems*](https://arxiv.org/abs/2303.00713) +- [M. B. Hastings and X.-G. Wen, *Quasi-adiabatic continuation of quantum states*](https://arxiv.org/abs/cond-mat/0503554) +- [S. Manna et al., *Non-Abelian quasiholes in lattice Moore--Read states and parent Hamiltonians*](https://arxiv.org/abs/1807.11222) +- [L. Huijse and K. Schoutens, *Supersymmetry, lattice fermions, independence complexes and cohomology theory*](https://arxiv.org/abs/0903.0784) diff --git a/tracks/mps/solutions/Wander-276/research/docs/literature/2026-08-01-susy-cohomological-third-model.md b/tracks/mps/solutions/Wander-276/research/docs/literature/2026-08-01-susy-cohomological-third-model.md new file mode 100644 index 000000000..0f1b1d507 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/docs/literature/2026-08-01-susy-cohomological-third-model.md @@ -0,0 +1,51 @@ +# SUSY/cohomological third-model source audit + +Date: 2026-08-01 +Status: discussion-stage literature and novelty audit; no numerical outcome has been inspected or generated. + +## Scientific question + +Can the covariance-whitened, gauge-invariant response statistic already used for the Kapit--Mueller and continuum-LLL Laughlin parents distinguish a one-sided frustration-free constraint kernel from a genuinely two-sided supersymmetric cohomology, without fitting the third model's four-point result? + +The intended third-model benchmark is the generic cubic $\mathcal N=2$ SYK complex, + +$$Q(C)=\sum_{i **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Build, preregister, execute, and audit a charge-resolved $\mathcal N=2$ SYK benchmark that predicts a sealed four-channel response statistic from exact/coexact two-point Hodge data and compares it with the existing one-sided Laughlin response law. + +**Architecture:** New task-local v7 modules construct cubic fermionic cochain complexes, solve their harmonic BPS fibers, decompose projector responses into orthogonal exact/coexact branches, and generate both collapsed and Hodge-resolved covariance-matched Gaussian nulls. A split-checkpoint runner keeps physical $R_4$ in outcome sidecars, a sequential analyzer seals the complete $N=14$ prediction before unsealing, and independent figure/report/delivery scripts consume only accepted hashed artifacts. Existing v1--v6 source and outcome files remain immutable. + +**Tech Stack:** Python 3, NumPy, SciPy sparse/dense linear algebra, pytest, Matplotlib, JSON/NPZ/SHA-256 checkpointing, Bash/Slurm for $N=14$, and the existing task-local `lgeth.wick_channels` finite-size statistic. + +## Global Constraints + +- Work only inside `01_task_folder/task_05/` for executable code and task outputs; task scripts may not import another task folder. +- Create new v7 files; do not modify accepted v1--v6 numerical artifacts or hash-anchored implementation modules. +- Write tests before implementation and commit each independently reviewable task. +- Generate every numerical result, table, and figure by script; do not enter measured values by hand. +- Treat a complete disorder realization as the uncertainty unit; never resample tangent entries as independent observations. +- Keep safe Hodge covariates and physical four-point outcomes in different files; safe serialization must reject `R4`, `four_point`, and `connected` keys. +- Use $m=8$ channels, primary sparse and secondary isotropic coupling panels, $N=8,10,12$ sequential development, $N=14$ sealed validation, and $N=16$ only after an explicit separation gate. +- Preserve the registered result branches and claim boundaries from `docs/plans/2026-08-01-susy-cohomological-geometric-eth-design.md`. +- Keep task_05 and main-dashboard statuses synchronized at `🟡 Ongoing` until the human explicitly closes the task. + +## File map + +- Create `01_task_folder/task_05/script/lgeth/susy_cohomology.py`: charge bases, fermionic signs, cubic supercharge matrices, charge-sector Hamiltonians, BPS frames, and expected generic ranks. +- Create `01_task_folder/task_05/script/lgeth/hodge_response.py`: coupling-tangent projection, sparse/isotropic panels, exact/coexact response branches, covariance summaries, and Hodge signatures. +- Create `01_task_folder/task_05/script/lgeth/hodge_wick.py`: collapsed-versus-Hodge Gaussian samplers and complete-realization reference aggregation. +- Create `01_task_folder/task_05/script/run_susy_hodge_geometric_eth_v7.py`: source-hashed kernel/response checkpoints, split safe/outcome files, pilot aggregation, prediction seals, and CLI. +- Create `01_task_folder/task_05/script/analyze_susy_hodge_geometric_eth_v7.py`: sequential pilot summaries, sealed $N=14$ predictions, unseal scoring, and frozen branch selection. +- Create `01_task_folder/task_05/script/make_susy_hodge_figure_v7.py`: one publication figure and machine-readable manifest. +- Create `01_task_folder/task_05/script/verify_susy_hodge_delivery_v7.py`: full scientific, provenance, corruption, figure, and report audit. +- Create `01_task_folder/task_05/script/slurm/run_susy_hodge_N14_v7_array.sbatch` and `submit_susy_hodge_N14_v7.sh`: safe production and prediction-only dependency chain; no automatic unseal. +- Create focused tests named `test_susy_cohomology_v7.py`, `test_hodge_response_v7.py`, `test_hodge_wick_v7.py`, `test_susy_hodge_runner_v7.py`, `test_susy_hodge_analysis_v7.py`, and `test_susy_hodge_delivery_v7.py`. +- Generate outputs under `01_task_folder/task_05/script/output/susy_hodge_v7_*` and `susy_hodge_v7_checkpoints/`; do not commit bulk frames or response arrays. + +--- + +### Task 1: Cubic charge-resolved cochain complex + +**Files:** +- Create: `01_task_folder/task_05/script/lgeth/susy_cohomology.py` +- Test: `01_task_folder/task_05/script/tests/test_susy_cohomology_v7.py` + +**Interfaces:** +- Produces: `charge_basis(N: int, charge: int) -> tuple[int, ...]`, `cubic_triples(N: int) -> tuple[tuple[int,int,int], ...]`, `cubic_supercharge(N: int, charge: int, couplings: np.ndarray) -> scipy.sparse.csr_matrix`, `charge_hamiltonian(...) -> csr_matrix`, `expected_generic_bps_rank(N: int, charge: int) -> int`, and `solve_bps_frame(...) -> BPSFrame`. +- `BPSFrame` fields: `basis`, `projector_frame`, `complement_frame`, `positive_energies`, `gap`, `kernel_residual`, `orthogonality_error`, `expected_rank`, `q_in`, and `q_out`. + +- [ ] **Step 1: Write the failing algebra tests** + +```python +def test_cubic_supercharge_is_nilpotent_and_has_registered_bps_rank(): + rng = np.random.default_rng(7) + couplings = rng.normal(size=20) + 1j * rng.normal(size=20) + q1 = cubic_supercharge(6, 1, couplings) + q4 = cubic_supercharge(6, 4, couplings) + assert np.linalg.norm((q4 @ q1).toarray()) < 1e-12 + frame = solve_bps_frame(6, 3, couplings, dense_cutoff=64) + assert frame.projector_frame.shape == (20, 18) + assert frame.gap > 0.0 + assert frame.kernel_residual < 1e-10 +``` + +- [ ] **Step 2: Run the focused test and verify the missing-module failure** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_susy_cohomology_v7.py` + +Expected: collection fails because `lgeth.susy_cohomology` does not exist. + +- [ ] **Step 3: Implement fermionic creation signs and sparse supercharges** + +Use sorted bit-string bases and apply the ordered operator product from right to left: + +```python +def _create(state: int, mode: int) -> tuple[int, int] | None: + bit = 1 << mode + if state & bit: + return None + sign = -1 if (state & (bit - 1)).bit_count() % 2 else 1 + return state | bit, sign +``` + +Build `Q_r: H_r -> H_{r+3}` in COO form, convert to CSR, and define + +```python +h_r = q_in @ q_in.getH() + q_out.getH() @ q_out +``` + +Solve the reduced dense cases with `scipy.linalg.eigh`; classify eigenvalues relative to `max(1.0, max_eigenvalue) * 1e-11`; verify the expected rank rather than inferring the scientific rank from a tolerance. + +- [ ] **Step 4: Run the algebra tests** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_susy_cohomology_v7.py` + +Expected: all tests pass for basis counts, Hermiticity, positivity, nilpotency, central/adjacent rank formulas, and deterministic frames. + +- [ ] **Step 5: Commit the cochain backend** + +```bash +git add 01_task_folder/task_05/script/lgeth/susy_cohomology.py 01_task_folder/task_05/script/tests/test_susy_cohomology_v7.py +git commit -m "feat: add charge-resolved SUSY cochain backend" +``` + +### Task 2: Exact/coexact Hodge response theorem + +**Files:** +- Create: `01_task_folder/task_05/script/lgeth/hodge_response.py` +- Test: `01_task_folder/task_05/script/tests/test_hodge_response_v7.py` + +**Interfaces:** +- Consumes: `BPSFrame`, `cubic_supercharge`, and an $m\times\binom N3$ tangent array. +- Produces: `HodgeResponse(minus: np.ndarray, plus: np.ndarray, total: np.ndarray, direct: np.ndarray, checks: dict[str,bool])` and `hodge_response(frame, couplings, tangents) -> HodgeResponse` with arrays shaped `(m, dim(H_r), D)`. + +- [ ] **Step 1: Write failing response-identity tests** + +```python +def test_hodge_branches_are_orthogonal_and_equal_direct_resolvent(): + frame, couplings, tangent = reduced_generic_case(N=6, charge=3, seed=11) + result = hodge_response(frame, couplings, tangent[None, :]) + assert np.linalg.norm(result.minus[0].conj().T @ result.plus[0]) < 1e-10 + assert np.allclose(result.total, result.minus + result.plus, atol=1e-10) + assert np.allclose(result.total, result.direct, atol=1e-10) +``` + +Add a centered finite-difference test for the projector derivative `dP = X P^† + P X^†` at step sizes `2e-5` and `1e-5`; require the error ratio to be compatible with second-order convergence and the smaller-step relative error below `2e-5`. + +- [ ] **Step 2: Run the test to confirm failure** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_hodge_response_v7.py` + +Expected: collection fails because `hodge_response` is undefined. + +- [ ] **Step 3: Implement branch right-hand sides and pseudoinverse action** + +For tangent supercharges `dq_in` and `dq_out`, compute + +```python +rhs_minus = q_in @ dq_in.getH() @ P +rhs_plus = q_out.getH() @ dq_out @ P +solve = U @ ((U.conj().T @ rhs) / energies[:, None]) +x_minus = -solve(rhs_minus) +x_plus = -solve(rhs_plus) +``` + +Compute the direct derivative from `dH = dq_in @ q_in.H + q_in @ dq_in.H + dq_out.H @ q_out + q_out.H @ dq_out` and require branch sum agreement. Do not project away a failed residual. + +- [ ] **Step 4: Run response and cochain regressions** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_susy_cohomology_v7.py 01_task_folder/task_05/script/tests/test_hodge_response_v7.py` + +Expected: all tests pass. + +- [ ] **Step 5: Commit the response theorem** + +```bash +git add 01_task_folder/task_05/script/lgeth/hodge_response.py 01_task_folder/task_05/script/tests/test_hodge_response_v7.py +git commit -m "feat: implement exact SUSY Hodge response" +``` + +### Task 3: Physical tangent panels and safe Hodge signature + +**Files:** +- Modify: `01_task_folder/task_05/script/lgeth/hodge_response.py` +- Modify: `01_task_folder/task_05/script/tests/test_hodge_response_v7.py` + +**Interfaces:** +- Produces: `project_moduli_tangents(couplings, candidates)`, `coupling_panels(couplings, panel_size, seed) -> dict[str,np.ndarray]`, `HodgeSignature`, and `hodge_signature(response) -> HodgeSignature`. +- `HodgeSignature` records full nonnegative branch target spectra, positive complement spectra, branch weights, Hodge balance, effective ranks, spectral entropies, and orthogonality residual. + +- [ ] **Step 1: Add failing tangent and signature tests** + +```python +def test_registered_panels_remove_radial_phase_and_have_full_support(): + couplings = normalized_couplings(8, seed=13) + panels = coupling_panels(couplings, panel_size=8, seed=17) + assert set(panels) == {"sparse", "isotropic"} + for values in panels.values(): + assert values.shape == (8, 56) + assert np.max(np.abs(values @ couplings.conj())) < 1e-12 + assert np.allclose(values @ values.conj().T, np.eye(8), atol=1e-12) +``` + +Test `eta_H=0` for a one-sided synthetic response, `eta_H=1` for equal branch weights, invariance under independent ambient and target unitary rotations, and rejection of a singular eight-channel panel. + +- [ ] **Step 2: Run tests and observe the missing-interface failure** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_hodge_response_v7.py` + +- [ ] **Step 3: Implement complex moduli projection and deterministic QR** + +Use the complex projection + +```python +projected = candidates - np.outer(candidates @ couplings.conj(), couplings) +q, r = np.linalg.qr(projected.T, mode="reduced") +phases = np.exp(-1j * np.angle(np.diag(r))) +tangents = (q * phases[None, :]).T +``` + +The one complex direction removed spans both real radial and phase directions. Select sparse coordinates from a deterministic permutation and generate isotropic candidates from an independent RNG stream. + +- [ ] **Step 4: Run the focused response suite** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_hodge_response_v7.py` + +- [ ] **Step 5: Commit the safe signature layer** + +```bash +git add 01_task_folder/task_05/script/lgeth/hodge_response.py 01_task_folder/task_05/script/tests/test_hodge_response_v7.py +git commit -m "feat: add SUSY tangent panels and Hodge signatures" +``` + +### Task 4: Hodge-resolved covariance-matched Gaussian null + +**Files:** +- Create: `01_task_folder/task_05/script/lgeth/hodge_wick.py` +- Test: `01_task_folder/task_05/script/tests/test_hodge_wick_v7.py` + +**Interfaces:** +- Consumes: branch spectra/weights from `HodgeSignature` and `covariance_matched_wick` from the immutable `lgeth.wick_channels` module. +- Produces: `sample_hodge_gaussian_channels(signature, channel_count, rng) -> np.ndarray`, `hodge_gaussian_r4_reference(signature, channel_count, samples, seed) -> np.ndarray`, and `complete_realization_null(signatures, samples, seed) -> np.ndarray`. + +- [ ] **Step 1: Write failing Gaussian-null tests** + +```python +def test_one_sided_hodge_sampler_matches_existing_distribution(): + signature = synthetic_signature(minus_weight=1.0, plus_weight=0.0) + first = hodge_gaussian_r4_reference(signature, 8, 512, 23) + second = gaussian_r4_reference( + signature.minus_target_positive, + signature.minus_external_positive, + 8, + 512, + 23, + ) + assert abs(np.median(first) - np.median(second)) < 0.015 +``` + +Also test deterministic seeds, nonnegative spectra, branch-weight rescaling invariance after channel whitening, and direct-sum output shape. + +- [ ] **Step 2: Run tests and confirm failure** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_hodge_wick_v7.py` + +- [ ] **Step 3: Implement the signed two-branch sampler** + +For each nonzero branch, normalize its target/external spectra, generate complex standard Gaussian entries, apply square-root spectra, rotate the target by a deterministic Haar unitary drawn from the null RNG, scale by the square root of the branch weight fraction, concatenate branches along the external axis, and call the unchanged `covariance_matched_wick` implementation. If exactly one branch has positive weight, dispatch directly to the existing one-sided sampler. + +- [ ] **Step 4: Run null and immutable Wick regressions** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_hodge_wick_v7.py 01_task_folder/task_05/script/tests/test_wick_channels_v3.py` + +- [ ] **Step 5: Commit the Hodge null** + +```bash +git add 01_task_folder/task_05/script/lgeth/hodge_wick.py 01_task_folder/task_05/script/tests/test_hodge_wick_v7.py +git commit -m "feat: add Hodge-resolved Gaussian response null" +``` + +### Task 5: Split-checkpoint runner and information barrier + +**Files:** +- Create: `01_task_folder/task_05/script/run_susy_hodge_geometric_eth_v7.py` +- Test: `01_task_folder/task_05/script/tests/test_susy_hodge_runner_v7.py` + +**Interfaces:** +- Produces: `prepare_realization(N, sector, realization, ...)`, `run_panel(...)`, `write_safe_covariates(...)`, `seal_file_hash(...)`, `write_prediction(...)`, and `unseal_outcomes(...)`. +- Registered constants: `SIZES=(8,10,12,14)`, `SECTORS=("central","adjacent")`, `PANEL_KINDS=("sparse","isotropic")`, `PANEL_SIZE=8`, realization counts `{8:64,10:48,12:32,14:24}`, and `NULL_REPLICATES=2000`. + +- [ ] **Step 1: Write the reduced split/seal test** + +```python +def test_reduced_susy_runner_keeps_r4_out_of_safe_artifacts(tmp_path): + prepare_realization(6, "central", 0, root=tmp_path, reduced=True, force=True) + run_panel(6, "central", 0, "sparse", root=tmp_path, reduced=True, force=True) + safe = (tmp_path / "N6_central_seed000_sparse_v7.json").read_text() + outcome = (tmp_path / "N6_central_seed000_sparse_v7.outcome.json").read_text() + assert "R4" not in safe and "four_point" not in safe and "connected" not in safe + assert '"R4"' in outcome +``` + +Require `unseal_outcomes` to fail before a seal exists, after a one-byte prediction mutation, and after an outcome identity mutation. + +- [ ] **Step 2: Run the runner test and verify failure** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_susy_hodge_runner_v7.py` + +- [ ] **Step 3: Implement atomic, source-hashed checkpoints** + +Follow the v6 continuum runner's `_atomic_json`, `_atomic_npz`, identity hash, array hash, and seal validation patterns in a new file. Serialize branch matrices only in NPZ; serialize derived safe scalars/spectra in JSON. Write the outcome sidecar only after all response identities pass, and never load it from a safe aggregation function. + +- [ ] **Step 4: Run reduced runner plus Hodge suites** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_susy_hodge_runner_v7.py 01_task_folder/task_05/script/tests/test_susy_cohomology_v7.py 01_task_folder/task_05/script/tests/test_hodge_response_v7.py 01_task_folder/task_05/script/tests/test_hodge_wick_v7.py` + +- [ ] **Step 5: Commit the information barrier** + +```bash +git add 01_task_folder/task_05/script/run_susy_hodge_geometric_eth_v7.py 01_task_folder/task_05/script/tests/test_susy_hodge_runner_v7.py +git commit -m "feat: enforce sealed SUSY Hodge response outcomes" +``` + +### Task 6: Analytic decomposable-three-form control + +**Files:** +- Modify: `01_task_folder/task_05/script/lgeth/susy_cohomology.py` +- Modify: `01_task_folder/task_05/script/lgeth/hodge_response.py` +- Modify: `01_task_folder/task_05/script/tests/test_susy_cohomology_v7.py` +- Modify: `01_task_folder/task_05/script/tests/test_hodge_response_v7.py` + +**Interfaces:** +- Produces: `decomposable_couplings(N, alpha)`, `decomposable_tangent(N, family, site)`, and `analytic_decomposable_curvature_multiplicities(N, charge, kind)`. + +- [ ] **Step 1: Add failing atomic-spectrum tests** + +At $C_{123}=\alpha$ and all other couplings zero, compute diagonal tangent $(12k)$ and off-diagonal Hermitian combination $(12k),(13l)$. Assert every numerical curvature eigenvalue lies within `1e-10` of `{-1/alpha**2, 0, 1/alpha**2}` and the nonzero multiplicities match Appendix D.2 of the seed paper. + +- [ ] **Step 2: Run the control tests and verify failure** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_susy_cohomology_v7.py 01_task_folder/task_05/script/tests/test_hodge_response_v7.py` + +- [ ] **Step 3: Implement the exact control and multiplicity formulas** + +Generate the decomposable coupling vector by the canonical triple lookup. Construct curvature from the response branches as the antisymmetrized Gram combination and compare it with the analytic $0,\pm1/\alpha^2$ support. Preserve zero eigenvalues rather than removing them in this structural test. + +- [ ] **Step 4: Run all v7 unit tests** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q $(rg --files 01_task_folder/task_05/script/tests | rg 'v7\.py$')` + +- [ ] **Step 5: Commit the analytic negative control** + +```bash +git add 01_task_folder/task_05/script/lgeth/susy_cohomology.py 01_task_folder/task_05/script/lgeth/hodge_response.py 01_task_folder/task_05/script/tests/test_susy_cohomology_v7.py 01_task_folder/task_05/script/tests/test_hodge_response_v7.py +git commit -m "test: certify decomposable SUSY curvature atoms" +``` + +### Task 7: Sequential $N=8,10,12$ pilot production + +**Files:** +- Modify: `01_task_folder/task_05/script/run_susy_hodge_geometric_eth_v7.py` +- Create: `01_task_folder/task_05/script/tests/test_susy_hodge_pilot_v7.py` + +**Interfaces:** +- Produces: `script/output/susy_hodge_v7_covariates_pilot.json`, `susy_hodge_v7_outcomes_pilot.{json,npz}`, and per-realization checkpoints. + +- [ ] **Step 1: Add a reduced aggregation test** + +Generate two reduced realizations in each sector and panel kind. Require complete case grids, finite physical and both-null $R_4$ arrays, full source identity, complete-realization grouping, and deterministic regeneration. + +- [ ] **Step 2: Run the reduced pilot test** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_susy_hodge_pilot_v7.py` + +- [ ] **Step 3: Implement resumable pilot aggregation** + +Use independent seeds derived from `(VERSION, N, sector, realization, purpose)`. The safe aggregate must be written before any pilot outcome aggregate. Opening pilot outcomes is allowed only after every kernel, gap, Hodge, panel-support, gauge, and source-hash gate passes. + +- [ ] **Step 4: Run the registered local sizes sequentially** + +Run: + +```bash +PYTHONPATH=01_task_folder/task_05/script python 01_task_folder/task_05/script/run_susy_hodge_geometric_eth_v7.py pilot --sizes 8 10 12 +``` + +Expected: 64/48/32 complete disorder realizations per sector and both panel kinds, with safe artifacts written before the pilot outcome aggregate. + +- [ ] **Step 5: Run v7 regressions and commit compact pilot code/metadata** + +```bash +PYTHONPATH=01_task_folder/task_05/script pytest -q $(rg --files 01_task_folder/task_05/script/tests | rg 'v7\.py$') +git add 01_task_folder/task_05/script/run_susy_hodge_geometric_eth_v7.py 01_task_folder/task_05/script/tests/test_susy_hodge_pilot_v7.py +git commit -m "data: complete SUSY Hodge pilot sequence" +``` + +Do not stage bulk checkpoint NPZ files. + +### Task 8: Sealed $N=14$ prediction and Slurm workflow + +**Files:** +- Create: `01_task_folder/task_05/script/analyze_susy_hodge_geometric_eth_v7.py` +- Create: `01_task_folder/task_05/script/slurm/run_susy_hodge_N14_v7_array.sbatch` +- Create: `01_task_folder/task_05/script/slurm/submit_susy_hodge_N14_v7.sh` +- Test: `01_task_folder/task_05/script/tests/test_susy_hodge_analysis_v7.py` + +**Interfaces:** +- Produces: `write_n14_prediction(covariates, ...)`, `score_unsealed_n14(...)`, `susy_hodge_v7_N14_prediction.json`, and `susy_hodge_v7_N14_prediction.sha256`. + +- [ ] **Step 1: Write failing prediction-before-outcome tests** + +Use synthetic safe covariates and hidden sidecars. Assert prediction creation succeeds when sidecars are unreadable, the serialized prediction contains no physical $R_4$, scoring fails without a valid SHA-256 seal, and the primary simultaneous pair is central/adjacent sparse panels only. + +- [ ] **Step 2: Run analysis tests and verify failure** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_susy_hodge_analysis_v7.py` + +- [ ] **Step 3: Implement complete-realization prediction intervals and frozen branch logic** + +For each of 2000 reference replicates, draw one covariance-conditioned Gaussian tensor per disorder realization and take the realization median. Use per-case 97.5% intervals for the two-case primary pair. Score `strong_covariance_universality`, `hodge_resolved_geometric_eth`, `cohomological_non_gaussian_class`, `structured_cohomology`, or `feasibility_failure` exactly as frozen in the design. + +- [ ] **Step 4: Implement the scheduler stop point** + +The array maps 24 realizations × two sectors × two panel kinds. The dependent aggregate writes safe covariates and the two numerical null predictions, seals the JSON, prints the seal, and exits. The submission script must not invoke the unseal subcommand. + +- [ ] **Step 5: Run tests, shell syntax checks, and submit when the remote allocation is live** + +```bash +PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_susy_hodge_analysis_v7.py 01_task_folder/task_05/script/tests/test_susy_hodge_runner_v7.py +bash -n 01_task_folder/task_05/script/slurm/submit_susy_hodge_N14_v7.sh +``` + +After the prediction seal is independently visible, run the separate unseal command and commit only code, compact JSON summaries, and seals: + +```bash +git add 01_task_folder/task_05/script/analyze_susy_hodge_geometric_eth_v7.py 01_task_folder/task_05/script/slurm/run_susy_hodge_N14_v7_array.sbatch 01_task_folder/task_05/script/slurm/submit_susy_hodge_N14_v7.sh 01_task_folder/task_05/script/tests/test_susy_hodge_analysis_v7.py +git commit -m "analysis: seal SUSY Hodge held-out prediction" +``` + +### Task 9: Inference figure and source-backed result report + +**Files:** +- Create: `01_task_folder/task_05/script/make_susy_hodge_figure_v7.py` +- Create: `01_task_folder/task_05/script/tests/test_susy_hodge_figure_v7.py` +- Generate: `01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.{pdf,png,json}` +- Generate: `01_task_folder/task_05/script/output/susy_hodge_geometric_eth_report_v7.md` + +**Interfaces:** +- Consumes only accepted pilot inference, sealed $N=14$ inference, decomposable-control audit, and immutable v6 cross-parent report. +- Produces a four-panel figure: response-complex schematic; Hodge balance/effective-rank flow; physical versus collapsed/Hodge null; and held-out branch/structured-control verdict. + +- [ ] **Step 1: Write failing figure/report provenance tests** + +Require every plotted scalar to be recoverable from hashed JSON/NPZ input, the selected branch to appear verbatim in figure JSON and report, the literature links to be clickable Markdown, and the report to contain established/not-established sections. + +- [ ] **Step 2: Run figure tests and confirm missing outputs** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_susy_hodge_figure_v7.py` + +- [ ] **Step 3: Implement generated assets** + +Use uncertainty bands from complete realizations, distinguish pilot from held-out points visually, mark the prediction-seal boundary, and place the analytic decomposable control in a separate style. Do not draw an asymptotic fit unless the registered $N=16$ separation gate later passes. + +- [ ] **Step 4: Generate and visually inspect both PDF and PNG** + +```bash +PYTHONPATH=01_task_folder/task_05/script python 01_task_folder/task_05/script/make_susy_hodge_figure_v7.py +pdftoppm -png -r 180 -f 1 -singlefile 01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.pdf tmp/susy_hodge_v7_figure +``` + +Inspect `tmp/susy_hodge_v7_figure.png` at original resolution and correct clipping, overlaps, unreadable labels, or misleading axes before acceptance. + +- [ ] **Step 5: Commit code and compact publication artifacts** + +```bash +git add 01_task_folder/task_05/script/make_susy_hodge_figure_v7.py 01_task_folder/task_05/script/tests/test_susy_hodge_figure_v7.py 01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.pdf 01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.png 01_task_folder/task_05/script/output/figure_susy_hodge_geometric_eth_v7.json 01_task_folder/task_05/script/output/susy_hodge_geometric_eth_report_v7.md +git commit -m "docs: report Hodge-resolved geometric ETH verdict" +``` + +### Task 10: Fail-closed delivery audit and dashboard synchronization + +**Files:** +- Create: `01_task_folder/task_05/script/verify_susy_hodge_delivery_v7.py` +- Create: `01_task_folder/task_05/script/tests/test_susy_hodge_delivery_v7.py` +- Modify: `01_task_folder/task_05/task_05_dashboard.md` +- Modify: `00_main/main_dashboard.md` + +**Interfaces:** +- Produces: `script/output/susy_hodge_delivery_audit_v7.json` with individual checks and one top-level `passed` boolean. + +- [ ] **Step 1: Write the failing delivery and corruption tests** + +Require exact registered case grids, all source/array/seal hashes, no safe-outcome leakage, prediction timestamp before unseal timestamp, analytic curvature atoms, one-sided regression, selected branch consistency, figure/report provenance, and the complete v7 pytest command. Copy accepted metadata to a temporary directory, corrupt one seal and one safe JSON key, and require both audits to fail. + +- [ ] **Step 2: Run the delivery test and confirm failure** + +Run: `PYTHONPATH=01_task_folder/task_05/script pytest -q 01_task_folder/task_05/script/tests/test_susy_hodge_delivery_v7.py` + +- [ ] **Step 3: Implement the audit and one-command verifier** + +The verifier must recompute branch selection from arrays rather than trust the report, scan safe serialized data for forbidden keys, compare every referenced SHA-256, and include exact test counts and result provenance in its JSON. + +- [ ] **Step 4: Run the complete v7 and immutable v6 regressions** + +```bash +PYTHONPATH=01_task_folder/task_05/script pytest -q $(rg --files 01_task_folder/task_05/script/tests | rg '(v6|v7)\.py$') +PYTHONPATH=01_task_folder/task_05/script python 01_task_folder/task_05/script/verify_susy_hodge_delivery_v7.py +``` + +- [ ] **Step 5: Synchronize dashboards and commit the delivery** + +Append a `[Codex]` version-log entry with the selected branch, main numerical intervals, source hashes, prediction seal, test count, report, and figure. Embed `![Hodge-resolved Geometric ETH](script/output/figure_susy_hodge_geometric_eth_v7.png)` in the task canvas and add the same status/result to the main session log. Keep both statuses `🟡 Ongoing` unless the human explicitly closes the task. + +```bash +git add 01_task_folder/task_05/script/verify_susy_hodge_delivery_v7.py 01_task_folder/task_05/script/tests/test_susy_hodge_delivery_v7.py 01_task_folder/task_05/script/output/susy_hodge_delivery_audit_v7.json +git commit -m "science: deliver Hodge-resolved SUSY benchmark" +``` + +## Self-review result + +- **Spec coverage:** The ten tasks cover the cubic cochain, expected BPS ranks, exact/coexact theorem, tangent panels, pre-outcome Hodge signature, two competing nulls, information barrier, decomposable control, sequential pilot, sealed $N=14$, branch inference, figure/report, corruption tests, and dashboard delivery. The conditional $N=16$ extension remains gated exactly as specified rather than being silently omitted. +- **Placeholder scan:** No red-flag placeholder or unspecified error-handling step remains. Every code task has a named failing test, exact command, implementation rule, passing command, and commit boundary. +- **Type consistency:** `BPSFrame` flows from `susy_cohomology` into `hodge_response`; `HodgeSignature` flows into `hodge_wick` and the safe runner; only the analyzer may validate a seal and open outcome sidecars; figure and delivery scripts consume the analyzer's accepted artifacts. + +## Execution handoff + +Plan saved at `docs/plans/2026-08-01-susy-cohomological-geometric-eth-implementation-plan.md`. Execution mode is **inline**: the human already authorized execution with “做吧,” and the active repository instructions prohibit unrequested subagent delegation. Work proceeds task by task with the commit and regression checkpoints above. diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/figures/figure_susy_hodge_geometric_eth_v7.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/figures/figure_susy_hodge_geometric_eth_v7.pdf new file mode 100644 index 000000000..86717f6c4 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/figures/figure_susy_hodge_geometric_eth_v7.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/generated/results_v7.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/generated/results_v7.tex new file mode 100644 index 000000000..f3b90bfc7 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/generated/results_v7.tex @@ -0,0 +1,16 @@ +% Generated from audited v7 inference; do not edit. +\newif\ifheldoutcomplete +\heldoutcompletetrue +\newcommand{\HeldoutAbstract}{Exactly degenerate quantum manifolds have no internal level statistics, but their projectors move over coupling space. We formulate this motion as a response complex and compare one-sided frustration-free constraints with the orthogonal exact/coexact response of charge-resolved cubic $\mathcal N=2$ Sachdev--Ye--Kitaev cohomology. In the sequential $N=8,10,12$ pilot, 12 of 12 size/sector/panel groups reject both registered separable covariance nulls. A prediction sealed before the held-out $N=14$ opening is rejected by both nulls for the central/adjacent sparse pair, establishing structured four-point memory beyond the frozen separable Hodge-covariance law, without claiming complete entrywise covariance matching.} +\newcommand{\HeldoutBranch}{cohomological\_non\_gaussian\_class} +\newcommand{\HeldoutResultSentence}{The held-out adjacent and central medians are 0.301529 and 0.374993; their complete-realization confidence intervals do not overlap either sealed covariance prediction.} +\newcommand{\PilotResultSentence}{Across the complete $N=8,10,12$ pilot, 12 of 12 groups reject both registered separable covariance nulls under complete-realization resampling.} +\newcommand{\HeldoutSeal}{fc300dc7e4bd} +\newcommand{\HeldoutAdjacentObserved}{0.301529} +\newcommand{\HeldoutAdjacentPhysical}{$[0.291527,\,0.312061]$} +\newcommand{\HeldoutAdjacentCollapsed}{$[0.111789,\,0.111852]$} +\newcommand{\HeldoutAdjacentHodge}{$[0.112344,\,0.112513]$} +\newcommand{\HeldoutCentralObserved}{0.374993} +\newcommand{\HeldoutCentralPhysical}{$[0.368980,\,0.380473]$} +\newcommand{\HeldoutCentralCollapsed}{$[0.111338,\,0.111353]$} +\newcommand{\HeldoutCentralHodge}{$[0.111333,\,0.111348]$} diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/main.log b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/main.log new file mode 100644 index 000000000..82dd1ad43 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/main.log @@ -0,0 +1,586 @@ +This is pdfTeX, Version 3.141592653-2.6-1.40.27 (TeX Live 2025) (preloaded format=pdflatex 2025.3.8) 4 AUG 2026 09:30 +entering extended mode + restricted \write18 enabled. + %&-line parsing enabled. +**main.tex +(./main.tex +LaTeX2e <2024-11-01> patch level 2 +L3 programming layer <2025-01-18> +(/usr/local/texlive/2025/texmf-dist/tex/latex/revtex/revtex4-2.cls +Document Class: revtex4-2 2022/06/05 4.2f (https://journals.aps.org/revtex/ for + documentation) + Copyright (c) 2019 American Physical Society. + mailto:revtex@aps.org + Licensed under the LPPL: +http://www.ctan.org/tex-archive/macros/latex/base/lppl.txt + Arthur Ogawa + Based on work by David Carlisle + Version (4.2d--4.2f): Modified by Mark Doyle and Phelype Oleinik + . +ltxutil[2022/06/05 4.2f utilities package (portions licensed from W. E. Baxter +web at superscript.com)] +LaTeX Info: Redefining \@centercr on input line 356. +Class revtex4-2 Info: Repairing broken LaTeX eqnarray on input line 417. +\eqncolsep=\skip49 +Class revtex4-2 Info: Repairing hyperref-unfriendly LaTeX definition of \mpfoot +note on input line 492. +Class revtex4-2 Info: Repairing broken LateX \@sect on input line 814. +\intertabularlinepenalty=\count196 +\@tbpen=\count197 +\@arstrutbox@hline=\box52 +Class revtex4-2 Info: Repairing broken LaTeX \@xbitor on input line 1845. +Class revtex4-2 Info: Making \typeout \long on input line 2110. +ltxfront[2022/06/05 4.2f frontmatter package (AO,DPC,MD)] +\c@affil=\count198 +\c@collab=\count199 +\absbox=\box53 +ltxgrid[2022/06/05 4.2f page grid package (portions licensed from W. E. Baxter +web at superscript.com)] +\c@linecount=\count266 +\output@latex=\toks17 +\box@size@1=\box54 +\box@size@2=\box55 +\@protection@box=\box56 +\@topmark@saved=\toks18 +\footins@saved=\box57 +\footins@recovered=\box58 +\column@recovered=\box59 +\pagesofar=\box60 +\footsofar=\box61 +\pagegrid@col=\count267 +Class revtex4-2 Info: Overriding \@vspace, \@vspacer, \@no@pgbk, \@newline, and + \\ on input line 5676. +\c@part=\count268 +\c@section=\count269 +\c@subsection=\count270 +\c@subsubsection=\count271 +\c@paragraph=\count272 +\c@subparagraph=\count273 +\abovecaptionskip=\skip50 +\belowcaptionskip=\skip51 +\c@figure=\count274 +\fbox@1=\box62 +\c@table=\count275 +\fbox@2=\box63 +\c@video=\count276 +\fbox@4=\box64 +\@bibdataout=\write3 +\widetext@top=\box65 +\widetext@bot=\box66 +Class revtex4-2 Info: Selecting society aps on input line 7669. +(/usr/local/texlive/2025/texmf-dist/tex/latex/revtex/aps4-2.rtx +File: aps4-2 2022/06/05 4.2f (https://journals.aps.org/revtex/ for documentatio +n) +Class revtex4-2 Info: RevTeX society APS selected on input line 40. +) +Class revtex4-2 Info: Selecting journal prl on input line 7671. +Class revtex4-2 Info: APS journal PRL selected on input line 7672. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/revtex/aps10pt4-2.rtx +File: aps10pt4-2 2022/06/05 4.2f (https://journals.aps.org/revtex/ for document +ation) +Class revtex4-2 Info: RevTeX pointsize 10pt selected on input line 39. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/textcase/textcase.sty +Package: textcase 2025/02/16 v1.05 Text only upper/lower case changing (DPC) +Package textcase Info: Defining Legacy names on input line 20. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/url/url.sty +\Urlmuskip=\muskip17 +Package: url 2013/09/16 ver 3.4 Verb mode for urls, etc. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/natbib/natbib.sty +Package: natbib 2010/09/13 8.31b (PWD, AO) +\bibhang=\skip52 +\bibsep=\skip53 +LaTeX Info: Redefining \cite on input line 694. +\c@NAT@ctr=\count277 +) +Class revtex4-2 Info: Repairing natbib's \BibitemShut on input line 7676. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/revtex/revsymb4-2.sty +Package: revsymb4-2 2022/06/05 4.2f (https://journals.aps.org/revtex/ for docum +entation) +LaTeX Info: Redefining \REV@mathfrak on input line 128. +)) +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsmath/amsmath.sty +Package: amsmath 2024/11/05 v2.17t AMS math features +\@mathmargin=\skip54 + +For additional information on amsmath, use the `?' option. +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsmath/amstext.sty +Package: amstext 2021/08/26 v2.01 AMS text + +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsmath/amsgen.sty +File: amsgen.sty 1999/11/30 v2.0 generic functions +\@emptytoks=\toks19 +\ex@=\dimen141 +) +LaTeX Info: Redefining \text on input line 28. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsmath/amsbsy.sty +Package: amsbsy 1999/11/29 v1.2d Bold Symbols +\pmbraise@=\dimen142 +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsmath/amsopn.sty +Package: amsopn 2022/04/08 v2.04 operator names +) +\inf@bad=\count278 +LaTeX Info: Redefining \frac on input line 233. +\uproot@=\count279 +\leftroot@=\count280 +LaTeX Info: Redefining \overline on input line 398. +LaTeX Info: Redefining \colon on input line 409. +\classnum@=\count281 +\DOTSCASE@=\count282 +LaTeX Info: Redefining \ldots on input line 495. +LaTeX Info: Redefining \dots on input line 498. +LaTeX Info: Redefining \cdots on input line 619. +\Mathstrutbox@=\box67 +\strutbox@=\box68 +LaTeX Info: Redefining \big on input line 721. +LaTeX Info: Redefining \Big on input line 722. +LaTeX Info: Redefining \bigg on input line 723. +LaTeX Info: Redefining \Bigg on input line 724. +\big@size=\dimen143 +LaTeX Font Info: Redeclaring font encoding OML on input line 742. +LaTeX Font Info: Redeclaring font encoding OMS on input line 743. +\macc@depth=\count283 +LaTeX Info: Redefining \bmod on input line 904. +LaTeX Info: Redefining \pmod on input line 909. +LaTeX Info: Redefining \smash on input line 939. +LaTeX Info: Redefining \relbar on input line 969. +LaTeX Info: Redefining \Relbar on input line 970. +\c@MaxMatrixCols=\count284 +\dotsspace@=\muskip18 +\c@parentequation=\count285 +\dspbrk@lvl=\count286 +\tag@help=\toks20 +\row@=\count287 +\column@=\count288 +\maxfields@=\count289 +\andhelp@=\toks21 +\eqnshift@=\dimen144 +\alignsep@=\dimen145 +\tagshift@=\dimen146 +\tagwidth@=\dimen147 +\totwidth@=\dimen148 +\lineht@=\dimen149 +\@envbody=\toks22 +\multlinegap=\skip55 +\multlinetaggap=\skip56 +\mathdisplay@stack=\toks23 +LaTeX Info: Redefining \[ on input line 2953. +LaTeX Info: Redefining \] on input line 2954. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsfonts/amssymb.sty +Package: amssymb 2013/01/14 v3.01 AMS font symbols + +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsfonts/amsfonts.sty +Package: amsfonts 2013/01/14 v3.01 Basic AMSFonts support +\symAMSa=\mathgroup4 +\symAMSb=\mathgroup5 +LaTeX Font Info: Redeclaring math symbol \hbar on input line 98. +LaTeX Font Info: Overwriting math alphabet `\mathfrak' in version `bold' +(Font) U/euf/m/n --> U/euf/b/n on input line 106. +LaTeX Info: Redefining \frak on input line 111. +LaTeX Info: Redefining \Bbb on input line 113. +)) +(/usr/local/texlive/2025/texmf-dist/tex/latex/tools/bm.sty +Package: bm 2023/12/19 v1.2f Bold Symbol Support (DPC/FMi) +\symboldoperators=\mathgroup6 +\symboldletters=\mathgroup7 +\symboldsymbols=\mathgroup8 +Package bm Info: No bold for \OMX/cmex/m/n, using \pmb. +Package bm Info: No bold for \U/msa/m/n, using \pmb. +Package bm Info: No bold for \U/msb/m/n, using \pmb. +LaTeX Font Info: Redeclaring math alphabet \mathbf on input line 149. +LaTeX Info: Redefining \bm on input line 219. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/booktabs/booktabs.sty +Package: booktabs 2020/01/12 v1.61803398 Publication quality tables +\heavyrulewidth=\dimen150 +\lightrulewidth=\dimen151 +\cmidrulewidth=\dimen152 +\belowrulesep=\dimen153 +\belowbottomsep=\dimen154 +\aboverulesep=\dimen155 +\abovetopsep=\dimen156 +\cmidrulesep=\dimen157 +\cmidrulekern=\dimen158 +\defaultaddspace=\dimen159 +\@cmidla=\count290 +\@cmidlb=\count291 +\@aboverulesep=\dimen160 +\@belowrulesep=\dimen161 +\@thisruleclass=\count292 +\@lastruleclass=\count293 +\@thisrulewidth=\dimen162 +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/graphics/graphicx.sty +Package: graphicx 2021/09/16 v1.2d Enhanced LaTeX Graphics (DPC,SPQR) + +(/usr/local/texlive/2025/texmf-dist/tex/latex/graphics/keyval.sty +Package: keyval 2022/05/29 v1.15 key=value parser (DPC) +\KV@toks@=\toks24 +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/graphics/graphics.sty +Package: graphics 2024/08/06 v1.4g Standard LaTeX Graphics (DPC,SPQR) + +(/usr/local/texlive/2025/texmf-dist/tex/latex/graphics/trig.sty +Package: trig 2023/12/02 v1.11 sin cos tan (DPC) +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/graphics-cfg/graphics.cfg +File: graphics.cfg 2016/06/04 v1.11 sample graphics configuration +) +Package graphics Info: Driver file: pdftex.def on input line 106. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/graphics-def/pdftex.def +File: pdftex.def 2024/04/13 v1.2c Graphics/color driver for pdftex +)) +\Gin@req@height=\dimen163 +\Gin@req@width=\dimen164 +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/microtype/microtype.sty +Package: microtype 2025/02/11 v3.2a Micro-typographical refinements (RS) + +(/usr/local/texlive/2025/texmf-dist/tex/latex/etoolbox/etoolbox.sty +Package: etoolbox 2025/02/11 v2.5l e-TeX tools for LaTeX (JAW) +\etb@tempcnta=\count294 +) +\MT@toks=\toks25 +\MT@tempbox=\box69 +\MT@count=\count295 +LaTeX Info: Redefining \noprotrusionifhmode on input line 1087. +LaTeX Info: Redefining \leftprotrusion on input line 1088. +\MT@prot@toks=\toks26 +LaTeX Info: Redefining \rightprotrusion on input line 1107. +LaTeX Info: Redefining \textls on input line 1449. +\MT@outer@kern=\dimen165 +LaTeX Info: Redefining \microtypecontext on input line 2053. +LaTeX Info: Redefining \textmicrotypecontext on input line 2070. +\MT@listname@count=\count296 + +(/usr/local/texlive/2025/texmf-dist/tex/latex/microtype/microtype-pdftex.def +File: microtype-pdftex.def 2025/02/11 v3.2a Definitions specific to pdftex (RS) + +LaTeX Info: Redefining \lsstyle on input line 944. +LaTeX Info: Redefining \lslig on input line 944. +\MT@outer@space=\skip57 +) +Package microtype Info: Loading configuration file microtype.cfg. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/microtype/microtype.cfg +File: microtype.cfg 2025/02/11 v3.2a microtype main configuration file (RS) +) +LaTeX Info: Redefining \microtypesetup on input line 3065. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/xcolor/xcolor.sty +Package: xcolor 2024/09/29 v3.02 LaTeX color extensions (UK) + +(/usr/local/texlive/2025/texmf-dist/tex/latex/graphics-cfg/color.cfg +File: color.cfg 2016/01/02 v1.6 sample color configuration +) +Package xcolor Info: Driver file: pdftex.def on input line 274. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/graphics/mathcolor.ltx) +Package xcolor Info: Model `cmy' substituted by `cmy0' on input line 1349. +Package xcolor Info: Model `hsb' substituted by `rgb' on input line 1353. +Package xcolor Info: Model `RGB' extended on input line 1365. +Package xcolor Info: Model `HTML' substituted by `rgb' on input line 1367. +Package xcolor Info: Model `Hsb' substituted by `hsb' on input line 1368. +Package xcolor Info: Model `tHsb' substituted by `hsb' on input line 1369. +Package xcolor Info: Model `HSB' substituted by `hsb' on input line 1370. +Package xcolor Info: Model `Gray' substituted by `gray' on input line 1371. +Package xcolor Info: Model `wave' substituted by `hsb' on input line 1372. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/hyperref/hyperref.sty +Package: hyperref 2024-11-05 v7.01l Hypertext links for LaTeX + +(/usr/local/texlive/2025/texmf-dist/tex/generic/iftex/iftex.sty +Package: iftex 2024/12/12 v1.0g TeX engine tests +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/kvsetkeys/kvsetkeys.sty +Package: kvsetkeys 2022-10-05 v1.19 Key value parser (HO) +) +(/usr/local/texlive/2025/texmf-dist/tex/generic/kvdefinekeys/kvdefinekeys.sty +Package: kvdefinekeys 2019-12-19 v1.6 Define keys (HO) +) +(/usr/local/texlive/2025/texmf-dist/tex/generic/pdfescape/pdfescape.sty +Package: pdfescape 2019/12/09 v1.15 Implements pdfTeX's escape features (HO) + +(/usr/local/texlive/2025/texmf-dist/tex/generic/ltxcmds/ltxcmds.sty +Package: ltxcmds 2023-12-04 v1.26 LaTeX kernel commands for general use (HO) +) +(/usr/local/texlive/2025/texmf-dist/tex/generic/pdftexcmds/pdftexcmds.sty +Package: pdftexcmds 2020-06-27 v0.33 Utility functions of pdfTeX for LuaTeX (HO +) + +(/usr/local/texlive/2025/texmf-dist/tex/generic/infwarerr/infwarerr.sty +Package: infwarerr 2019/12/03 v1.5 Providing info/warning/error messages (HO) +) +Package pdftexcmds Info: \pdf@primitive is available. +Package pdftexcmds Info: \pdf@ifprimitive is available. +Package pdftexcmds Info: \pdfdraftmode found. +)) +(/usr/local/texlive/2025/texmf-dist/tex/latex/hycolor/hycolor.sty +Package: hycolor 2020-01-27 v1.10 Color options for hyperref/bookmark (HO) +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/hyperref/nameref.sty +Package: nameref 2023-11-26 v2.56 Cross-referencing by name of section + +(/usr/local/texlive/2025/texmf-dist/tex/latex/refcount/refcount.sty +Package: refcount 2019/12/15 v3.6 Data extraction from label references (HO) +) +(/usr/local/texlive/2025/texmf-dist/tex/generic/gettitlestring/gettitlestring.s +ty +Package: gettitlestring 2019/12/15 v1.6 Cleanup title references (HO) + (/usr/local/texlive/2025/texmf-dist/tex/latex/kvoptions/kvoptions.sty +Package: kvoptions 2022-06-15 v3.15 Key value format for package options (HO) +)) + +Package nameref Warning: The definition of \label has changed! +(nameref) Check your packages! +(nameref) Replacing it with the kernel definition on input line +149. + +\c@section@level=\count297 +) (/usr/local/texlive/2025/texmf-dist/tex/generic/stringenc/stringenc.sty +Package: stringenc 2019/11/29 v1.12 Convert strings between diff. encodings (HO +) +) +\@linkdim=\dimen166 +\Hy@linkcounter=\count298 +\Hy@pagecounter=\count299 + +(/usr/local/texlive/2025/texmf-dist/tex/latex/hyperref/pd1enc.def +File: pd1enc.def 2024-11-05 v7.01l Hyperref: PDFDocEncoding definition (HO) +Now handling font encoding PD1 ... +... no UTF-8 mapping file for font encoding PD1 +) +(/usr/local/texlive/2025/texmf-dist/tex/generic/intcalc/intcalc.sty +Package: intcalc 2019/12/15 v1.3 Expandable calculations with integers (HO) +) +\Hy@SavedSpaceFactor=\count300 + +(/usr/local/texlive/2025/texmf-dist/tex/latex/hyperref/puenc.def +File: puenc.def 2024-11-05 v7.01l Hyperref: PDF Unicode definition (HO) +Now handling font encoding PU ... +... no UTF-8 mapping file for font encoding PU +) +Package hyperref Info: Option `colorlinks' set `true' on input line 4040. +Package hyperref Info: Hyper figures OFF on input line 4157. +Package hyperref Info: Link nesting OFF on input line 4162. +Package hyperref Info: Hyper index ON on input line 4165. +Package hyperref Info: Plain pages OFF on input line 4172. +Package hyperref Info: Backreferencing OFF on input line 4177. +Package hyperref Info: Implicit mode ON; LaTeX internals redefined. +Package hyperref Info: Bookmarks ON on input line 4424. +LaTeX Info: Redefining \href on input line 4674. +\c@Hy@tempcnt=\count301 +LaTeX Info: Redefining \url on input line 4763. +\XeTeXLinkMargin=\dimen167 + +(/usr/local/texlive/2025/texmf-dist/tex/generic/bitset/bitset.sty +Package: bitset 2019/12/09 v1.3 Handle bit-vector datatype (HO) + +(/usr/local/texlive/2025/texmf-dist/tex/generic/bigintcalc/bigintcalc.sty +Package: bigintcalc 2019/12/15 v1.5 Expandable calculations on big integers (HO +) +)) +\Fld@menulength=\count302 +\Field@Width=\dimen168 +\Fld@charsize=\dimen169 +Package hyperref Info: Hyper figures OFF on input line 6042. +Package hyperref Info: Link nesting OFF on input line 6047. +Package hyperref Info: Hyper index ON on input line 6050. +Package hyperref Info: backreferencing OFF on input line 6057. +Package hyperref Info: Link coloring ON on input line 6060. +Package hyperref Info: Link coloring with OCG OFF on input line 6067. +Package hyperref Info: PDF/A mode OFF on input line 6072. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/base/atbegshi-ltx.sty +Package: atbegshi-ltx 2021/01/10 v1.0c Emulation of the original atbegshi +package with kernel methods +) +\Hy@abspage=\count303 +\c@Item=\count304 +\c@Hfootnote=\count305 +) +Package hyperref Info: Driver (autodetected): hpdftex. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/hyperref/hpdftex.def +File: hpdftex.def 2024-11-05 v7.01l Hyperref driver for pdfTeX + +(/usr/local/texlive/2025/texmf-dist/tex/latex/base/atveryend-ltx.sty +Package: atveryend-ltx 2020/08/19 v1.0a Emulation of the original atveryend pac +kage +with kernel methods +) +\Fld@listcount=\count306 +\c@bookmark@seq@number=\count307 + +(/usr/local/texlive/2025/texmf-dist/tex/latex/rerunfilecheck/rerunfilecheck.sty +Package: rerunfilecheck 2022-07-10 v1.10 Rerun checks for auxiliary files (HO) + +(/usr/local/texlive/2025/texmf-dist/tex/generic/uniquecounter/uniquecounter.sty +Package: uniquecounter 2019/12/15 v1.4 Provide unlimited unique counter (HO) +) +Package uniquecounter Info: New unique counter `rerunfilecheck' on input line 2 +85. +) +\Hy@SectionHShift=\skip58 +) (./generated/results_v7.tex) +Class revtex4-2 Info: Unrecognized LaTeX tabular. Please update this document c +lass! (Proceeding with fingers crossed.) on input line 18. +Class revtex4-2 Info: cite was not loaded (OK!) on input line 18. +Class revtex4-2 Info: mcite was not loaded (OK!) on input line 18. +Class revtex4-2 Info: multicol was not loaded (OK!) on input line 18. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/l3backend/l3backend-pdftex.def +File: l3backend-pdftex.def 2024-05-08 L3 backend support: PDF output (pdfTeX) +\l__color_backend_stack_int=\count308 +\l__pdf_internal_box=\box70 +) +(./main.aux) +\openout1 = `main.aux'. + +LaTeX Font Info: Checking defaults for OML/cmm/m/it on input line 18. +LaTeX Font Info: ... okay on input line 18. +LaTeX Font Info: Checking defaults for OMS/cmsy/m/n on input line 18. +LaTeX Font Info: ... okay on input line 18. +LaTeX Font Info: Checking defaults for OT1/cmr/m/n on input line 18. +LaTeX Font Info: ... okay on input line 18. +LaTeX Font Info: Checking defaults for T1/cmr/m/n on input line 18. +LaTeX Font Info: ... okay on input line 18. +LaTeX Font Info: Checking defaults for TS1/cmr/m/n on input line 18. +LaTeX Font Info: ... okay on input line 18. +LaTeX Font Info: Checking defaults for OMX/cmex/m/n on input line 18. +LaTeX Font Info: ... okay on input line 18. +LaTeX Font Info: Checking defaults for U/cmr/m/n on input line 18. +LaTeX Font Info: ... okay on input line 18. +LaTeX Font Info: Checking defaults for PD1/pdf/m/n on input line 18. +LaTeX Font Info: ... okay on input line 18. +LaTeX Font Info: Checking defaults for PU/pdf/m/n on input line 18. +LaTeX Font Info: ... okay on input line 18. + +(/usr/local/texlive/2025/texmf-dist/tex/context/base/mkii/supp-pdf.mkii +[Loading MPS to PDF converter (version 2006.09.02).] +\scratchcounter=\count309 +\scratchdimen=\dimen170 +\scratchbox=\box71 +\nofMPsegments=\count310 +\nofMParguments=\count311 +\everyMPshowfont=\toks27 +\MPscratchCnt=\count312 +\MPscratchDim=\dimen171 +\MPnumerator=\count313 +\makeMPintoPDFobject=\count314 +\everyMPtoPDFconversion=\toks28 +) (/usr/local/texlive/2025/texmf-dist/tex/latex/epstopdf-pkg/epstopdf-base.sty +Package: epstopdf-base 2020-01-24 v2.11 Base part for package epstopdf +Package epstopdf-base Info: Redefining graphics rule for `.eps' on input line 4 +85. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/latexconfig/epstopdf-sys.cfg +File: epstopdf-sys.cfg 2010/07/13 v1.3 Configuration of (r)epstopdf for TeX Liv +e +)) +LaTeX Info: Redefining \microtypecontext on input line 18. +Package microtype Info: Applying patch `item' on input line 18. +Package microtype Info: Applying patch `toc' on input line 18. +Package microtype Info: Applying patch `eqnum' on input line 18. +Package microtype Info: Applying patch `footnote' on input line 18. +Package microtype Info: Applying patch `verbatim' on input line 18. +LaTeX Info: Redefining \microtypesetup on input line 18. +Package microtype Info: Generating PDF output. +Package microtype Info: Character protrusion enabled (level 2). +Package microtype Info: Using default protrusion set `alltext'. +Package microtype Info: Automatic font expansion enabled (level 2), +(microtype) stretch: 20, shrink: 20, step: 1, non-selected. +Package microtype Info: Using default expansion set `alltext-nott'. +LaTeX Info: Redefining \showhyphens on input line 18. +Package microtype Info: No adjustment of tracking. +Package microtype Info: No adjustment of interword spacing. +Package microtype Info: No adjustment of character kerning. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/microtype/mt-cmr.cfg +File: mt-cmr.cfg 2013/05/19 v2.2 microtype config. file: Computer Modern Roman +(RS) +) +Package hyperref Info: Link coloring ON on input line 18. + (./main.out) (./main.out) +\@outlinefile=\write4 +\openout4 = `main.out'. + +Class revtex4-2 Info: Taking \maketitle back from hyperref on input line 18. +\openout3 = `mainNotes.bib'. + +LaTeX Font Info: Trying to load font information for U+msa on input line 33. + + (/usr/local/texlive/2025/texmf-dist/tex/latex/amsfonts/umsa.fd +File: umsa.fd 2013/01/14 v3.01 AMS symbols A +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/microtype/mt-msa.cfg +File: mt-msa.cfg 2006/02/04 v1.1 microtype config. file: AMS symbols (a) (RS) +) +LaTeX Font Info: Trying to load font information for U+msb on input line 33. + + +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsfonts/umsb.fd +File: umsb.fd 2013/01/14 v3.01 AMS symbols B +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/microtype/mt-msb.cfg +File: mt-msb.cfg 2005/06/01 v1.0 microtype config. file: AMS symbols (b) (RS) +) +(./sections/01-introduction.tex) (./sections/02-response-complex.tex [1{/usr/lo +cal/texlive/2025/texmf-var/fonts/map/pdftex/updmap/pdftex.map}]) +(./sections/03-sealed-protocol.tex) (./sections/04-results.tex + +File: figures/figure_susy_hodge_geometric_eth_v7.pdf Graphic file (type pdf) + +Package pdftex.def Info: figures/figure_susy_hodge_geometric_eth_v7.pdf used o +n input line 8. +(pdftex.def) Requested size: 510.0pt x 384.584pt. +) +(./sections/05-discussion.tex [2]) (./main.bbl [3 <./figures/figure_susy_hodge_ +geometric_eth_v7.pdf>]) [4] (./main.aux) + *********** +LaTeX2e <2024-11-01> patch level 2 +L3 programming layer <2025-01-18> + *********** +Package rerunfilecheck Info: File `main.out' has not changed. +(rerunfilecheck) Checksum: F59169EAC1252F4D9B561A1F9A1E1000;1684. + ) +Here is how much of TeX's memory you used: + 14485 strings out of 473190 + 220025 string characters out of 5715801 + 700084 words of memory out of 5000000 + 37383 multiletter control sequences out of 15000+600000 + 573312 words of font info for 142 fonts, out of 8000000 for 9000 + 1141 hyphenation exceptions out of 8191 + 75i,15n,79p,1001b,648s stack positions out of 10000i,1000n,20000p,200000b,200000s +< +/usr/local/texlive/2025/texmf-dist/fonts/type1/public/amsfonts/cm/cmex10.pfb> +Output written on main.pdf (4 pages, 246733 bytes). +PDF statistics: + 232 PDF objects out of 1000 (max. 8388607) + 175 compressed objects within 2 object streams + 31 named destinations out of 1000 (max. 500000) + 28750 words of extra memory for PDF output out of 29859 (max. 10000000) diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/main.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/main.pdf new file mode 100644 index 000000000..35906be92 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/main.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/main.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/main.tex new file mode 100644 index 000000000..99f334113 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/main.tex @@ -0,0 +1,53 @@ +\documentclass[aps,prl,reprint,superscriptaddress,longbibliography,floatfix]{revtex4-2} + +\usepackage{amsmath,amssymb,bm} +\usepackage{booktabs} +\usepackage{graphicx} +\usepackage{microtype} +\usepackage{xcolor} +\usepackage[colorlinks=true,citecolor=blue!55!black,linkcolor=blue!55!black,urlcolor=blue!55!black]{hyperref} +\hypersetup{pdftitle={Response-Complex Memory in Exactly Degenerate Quantum Matter},pdfauthor={Thomas J. Wang; OKongOYangO},pdfsubject={Hodge-resolved quantum geometry and chaos under exact degeneracy}} + +\graphicspath{{figures/}} +\input{generated/results_v7.tex} +\newcommand{\Tr}{\operatorname{Tr}} +\newcommand{\dd}{\mathrm d} +\newcommand{\cH}{\mathcal H} +\newcommand{\cM}{\mathcal M} + +\begin{document} + +\title{Response-Complex Memory in Exactly Degenerate Quantum Matter} + +\author{Thomas J. Wang} +\email{WangTheoPhys@outlook.com} +\affiliation{Tsinghua University, Beijing 100084, China} + +\author{OKongOYangO} +\affiliation{The Pennsylvania State University, University Park, Pennsylvania 16802, USA} + +\date{\today} + +\begin{abstract} +\ifheldoutcomplete +\HeldoutAbstract +\else +This source tree freezes the response-complex formalism and the prediction protocol before the held-out calculation is opened. The result-bearing abstract is generated only after a valid prediction seal, explicit unseal, and fail-closed inference audit exist. No held-out scientific branch is claimed in this draft state. +\fi +\end{abstract} + +\maketitle + +\input{sections/01-introduction.tex} +\input{sections/02-response-complex.tex} +\input{sections/03-sealed-protocol.tex} +\input{sections/04-results.tex} +\input{sections/05-discussion.tex} + +\begin{acknowledgments} +The numerical artifacts, complete-realization resampling records, source hashes, and prediction seals are retained with the reproducibility package. We thank the Quantum Harness community for discussions motivating fail-closed computational tests. +\end{acknowledgments} + +\bibliography{references} + +\end{document} diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/references.bib b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/references.bib new file mode 100644 index 000000000..143301513 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/references.bib @@ -0,0 +1,94 @@ +@article{berry1984, + author = {Berry, Michael V.}, + title = {Quantal phase factors accompanying adiabatic changes}, + journal = {Proceedings of the Royal Society of London A}, + volume = {392}, + pages = {45--57}, + year = {1984}, + doi = {10.1098/rspa.1984.0023} +} + +@article{wilczekzee1984, + author = {Wilczek, Frank and Zee, A.}, + title = {Appearance of gauge structure in simple dynamical systems}, + journal = {Physical Review Letters}, + volume = {52}, + pages = {2111--2114}, + year = {1984}, + doi = {10.1103/PhysRevLett.52.2111} +} + +@article{provostvallee1980, + author = {Provost, J. P. and Vall{\'e}e, G.}, + title = {Riemannian structure on manifolds of quantum states}, + journal = {Communications in Mathematical Physics}, + volume = {76}, + pages = {289--301}, + year = {1980}, + doi = {10.1007/BF02193559} +} + +@article{kato1950, + author = {Kato, Tosio}, + title = {On the adiabatic theorem of quantum mechanics}, + journal = {Journal of the Physical Society of Japan}, + volume = {5}, + pages = {435--439}, + year = {1950}, + doi = {10.1143/JPSJ.5.435} +} + +@article{fu2017susy, + author = {Fu, Wenbo and Gaiotto, Davide and Maldacena, Juan and Sachdev, Subir}, + title = {Supersymmetric Sachdev--Ye--Kitaev models}, + journal = {Physical Review D}, + volume = {95}, + pages = {026009}, + year = {2017}, + doi = {10.1103/PhysRevD.95.026009}, + eprint = {1610.08917}, + archivePrefix = {arXiv} +} + +@misc{chang2024fortuity, + author = {Chang, Chi-Ming and Chen, Ying-Hsuan and Sia, Gregory and Yang, Zhenbin}, + title = {Fortuity in {SYK} models}, + year = {2024}, + eprint = {2412.06902}, + archivePrefix = {arXiv} +} + +@misc{chen2024bps, + author = {Chen, Yiming and Lin, Henry W. and Shenker, Stephen H.}, + title = {{BPS} chaos}, + year = {2024}, + eprint = {2407.19387}, + archivePrefix = {arXiv} +} + +@misc{chen2026berry, + author = {Chen, Yiming and Colin-Ellerin, Sean and Mamroud, Ohad and Papadodimas, Kyriakos}, + title = {Chaos of Berry curvature for {BPS} microstates}, + year = {2026}, + eprint = {2604.23287}, + archivePrefix = {arXiv} +} + +@article{huijse2009cohomology, + author = {Huijse, Liza and Schoutens, Kareljan}, + title = {Supersymmetry, lattice fermions, independence complexes and cohomology theory}, + journal = {Advances in Theoretical and Mathematical Physics}, + volume = {14}, + pages = {643--694}, + year = {2010}, + eprint = {0903.0784}, + archivePrefix = {arXiv} +} + +@misc{zhang2024local, + author = {Zhang, Zhiyuan and Sukeno, Hikaru and Ikeda, Tatsuhiko N. and Wei, Tzu-Chieh}, + title = {Local symmetries and extensive ground-state degeneracy of a one-dimensional supersymmetric fermionic chain}, + year = {2024}, + eprint = {2412.17208}, + archivePrefix = {arXiv} +} diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/sections/01-introduction.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/sections/01-introduction.tex new file mode 100644 index 000000000..4774045ab --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/sections/01-introduction.tex @@ -0,0 +1,8 @@ +\section{Spectral silence and response complexity} +\label{sec:introduction} + +Exact degeneracy removes the level spacings on which conventional quantum-chaos diagnostics are built. If a protected multiplet contains \(D\) states at the same energy, its raw energy spectral form factor is constant and its connected form factor vanishes. This is a structural blind spot in supersymmetric sectors, frustration-free zero-mode manifolds, and other problems where lifting the degeneracy would destroy the object of interest. The missing information is carried by the motion of the protected projector \(P(\bm\lambda)\) over a coupling or moduli space, through its non-Abelian Berry curvature and quantum metric \cite{berry1984,wilczekzee1984,provostvallee1980,kato1950}. + +Random-matrix-like Berry curvature in supersymmetric black-hole microstates and in generic \(\mathcal N=2\) Sachdev--Ye--Kitaev (SYK) models is already established \cite{chen2026berry,chen2024bps}. The question addressed here is different. Does random-matrix-like local curvature exhaust the information in the protected response, or do higher gauge-invariant correlations retain the mechanism by which the degeneracy is protected? Equivalently, can a two-point law predict a four-point response observable across distinct protection mechanisms? We compare one-sided positive-constraint Laughlin parents with a two-sided supersymmetric cohomology. The comparison uses the same covariance-whitened four-channel statistic, the same complete-realization uncertainty unit, and a prediction constructed before the held-out four-point outcome is opened. + +The organizing object is a \emph{response complex}. For a frustration-free parent \(H=B^\dagger B\), the zero-mode response is one-sided. For \(H=\{Q,Q^\dagger\}\) with \(Q^2=0\), it decomposes into orthogonal exact and coexact branches. Their weights, covariance spectra, and effective ranks form a safe Hodge signature that is available without reading the four-channel outcome. We ask whether this signature selects a finite-size Gaussian response law. Coverage would support a two-point-controlled form of Geometric ETH; reproducible rejection would instead identify response-complex memory beyond that law. The protocol retains either outcome rather than fitting the held-out statistic after the fact. diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/sections/02-response-complex.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/sections/02-response-complex.tex new file mode 100644 index 000000000..0620e3b86 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/sections/02-response-complex.tex @@ -0,0 +1,59 @@ +\section{Hodge-resolved protected response} +\label{sec:response-complex} + +The generic cubic \(\mathcal N=2\) SYK supercharge is +\begin{equation} + \begin{split} + Q(C)&=\sum_{i patch level 2 +L3 programming layer <2025-01-18> +(/usr/local/texlive/2025/texmf-dist/tex/latex/revtex/revtex4-2.cls +Document Class: revtex4-2 2022/06/05 4.2f (https://journals.aps.org/revtex/ for + documentation) + Copyright (c) 2019 American Physical Society. + mailto:revtex@aps.org + Licensed under the LPPL: +http://www.ctan.org/tex-archive/macros/latex/base/lppl.txt + Arthur Ogawa + Based on work by David Carlisle + Version (4.2d--4.2f): Modified by Mark Doyle and Phelype Oleinik + . +ltxutil[2022/06/05 4.2f utilities package (portions licensed from W. E. Baxter +web at superscript.com)] +LaTeX Info: Redefining \@centercr on input line 356. +Class revtex4-2 Info: Repairing broken LaTeX eqnarray on input line 417. +\eqncolsep=\skip49 +Class revtex4-2 Info: Repairing hyperref-unfriendly LaTeX definition of \mpfoot +note on input line 492. +Class revtex4-2 Info: Repairing broken LateX \@sect on input line 814. +\intertabularlinepenalty=\count196 +\@tbpen=\count197 +\@arstrutbox@hline=\box52 +Class revtex4-2 Info: Repairing broken LaTeX \@xbitor on input line 1845. +Class revtex4-2 Info: Making \typeout \long on input line 2110. +ltxfront[2022/06/05 4.2f frontmatter package (AO,DPC,MD)] +\c@affil=\count198 +\c@collab=\count199 +\absbox=\box53 +ltxgrid[2022/06/05 4.2f page grid package (portions licensed from W. E. Baxter +web at superscript.com)] +\c@linecount=\count266 +\output@latex=\toks17 +\box@size@1=\box54 +\box@size@2=\box55 +\@protection@box=\box56 +\@topmark@saved=\toks18 +\footins@saved=\box57 +\footins@recovered=\box58 +\column@recovered=\box59 +\pagesofar=\box60 +\footsofar=\box61 +\pagegrid@col=\count267 +Class revtex4-2 Info: Overriding \@vspace, \@vspacer, \@no@pgbk, \@newline, and + \\ on input line 5676. +\c@part=\count268 +\c@section=\count269 +\c@subsection=\count270 +\c@subsubsection=\count271 +\c@paragraph=\count272 +\c@subparagraph=\count273 +\abovecaptionskip=\skip50 +\belowcaptionskip=\skip51 +\c@figure=\count274 +\fbox@1=\box62 +\c@table=\count275 +\fbox@2=\box63 +\c@video=\count276 +\fbox@4=\box64 +\@bibdataout=\write3 +\widetext@top=\box65 +\widetext@bot=\box66 +Class revtex4-2 Info: Selecting society aps on input line 7669. +(/usr/local/texlive/2025/texmf-dist/tex/latex/revtex/aps4-2.rtx +File: aps4-2 2022/06/05 4.2f (https://journals.aps.org/revtex/ for documentatio +n) +Class revtex4-2 Info: RevTeX society APS selected on input line 40. +) +Class revtex4-2 Info: Selecting journal prl on input line 7671. +Class revtex4-2 Info: APS journal PRL selected on input line 7672. + + +Class revtex4-2 Warning: No type size specified, using default 10. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/revtex/aps10pt4-2.rtx +File: aps10pt4-2 2022/06/05 4.2f (https://journals.aps.org/revtex/ for document +ation) +Class revtex4-2 Info: RevTeX pointsize 10pt selected on input line 39. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/textcase/textcase.sty +Package: textcase 2025/02/16 v1.05 Text only upper/lower case changing (DPC) +Package textcase Info: Defining Legacy names on input line 20. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/url/url.sty +\Urlmuskip=\muskip17 +Package: url 2013/09/16 ver 3.4 Verb mode for urls, etc. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/natbib/natbib.sty +Package: natbib 2010/09/13 8.31b (PWD, AO) +\bibhang=\skip52 +\bibsep=\skip53 +LaTeX Info: Redefining \cite on input line 694. +\c@NAT@ctr=\count277 +) +Class revtex4-2 Info: Repairing natbib's \BibitemShut on input line 7676. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/revtex/revsymb4-2.sty +Package: revsymb4-2 2022/06/05 4.2f (https://journals.aps.org/revtex/ for docum +entation) +LaTeX Info: Redefining \REV@mathfrak on input line 128. +)) +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsmath/amsmath.sty +Package: amsmath 2024/11/05 v2.17t AMS math features +\@mathmargin=\skip54 + +For additional information on amsmath, use the `?' option. +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsmath/amstext.sty +Package: amstext 2021/08/26 v2.01 AMS text + +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsmath/amsgen.sty +File: amsgen.sty 1999/11/30 v2.0 generic functions +\@emptytoks=\toks19 +\ex@=\dimen141 +) +LaTeX Info: Redefining \text on input line 28. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsmath/amsbsy.sty +Package: amsbsy 1999/11/29 v1.2d Bold Symbols +\pmbraise@=\dimen142 +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsmath/amsopn.sty +Package: amsopn 2022/04/08 v2.04 operator names +) +\inf@bad=\count278 +LaTeX Info: Redefining \frac on input line 233. +\uproot@=\count279 +\leftroot@=\count280 +LaTeX Info: Redefining \overline on input line 398. +LaTeX Info: Redefining \colon on input line 409. +\classnum@=\count281 +\DOTSCASE@=\count282 +LaTeX Info: Redefining \ldots on input line 495. +LaTeX Info: Redefining \dots on input line 498. +LaTeX Info: Redefining \cdots on input line 619. +\Mathstrutbox@=\box67 +\strutbox@=\box68 +LaTeX Info: Redefining \big on input line 721. +LaTeX Info: Redefining \Big on input line 722. +LaTeX Info: Redefining \bigg on input line 723. +LaTeX Info: Redefining \Bigg on input line 724. +\big@size=\dimen143 +LaTeX Font Info: Redeclaring font encoding OML on input line 742. +LaTeX Font Info: Redeclaring font encoding OMS on input line 743. +\macc@depth=\count283 +LaTeX Info: Redefining \bmod on input line 904. +LaTeX Info: Redefining \pmod on input line 909. +LaTeX Info: Redefining \smash on input line 939. +LaTeX Info: Redefining \relbar on input line 969. +LaTeX Info: Redefining \Relbar on input line 970. +\c@MaxMatrixCols=\count284 +\dotsspace@=\muskip18 +\c@parentequation=\count285 +\dspbrk@lvl=\count286 +\tag@help=\toks20 +\row@=\count287 +\column@=\count288 +\maxfields@=\count289 +\andhelp@=\toks21 +\eqnshift@=\dimen144 +\alignsep@=\dimen145 +\tagshift@=\dimen146 +\tagwidth@=\dimen147 +\totwidth@=\dimen148 +\lineht@=\dimen149 +\@envbody=\toks22 +\multlinegap=\skip55 +\multlinetaggap=\skip56 +\mathdisplay@stack=\toks23 +LaTeX Info: Redefining \[ on input line 2953. +LaTeX Info: Redefining \] on input line 2954. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsfonts/amssymb.sty +Package: amssymb 2013/01/14 v3.01 AMS font symbols + +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsfonts/amsfonts.sty +Package: amsfonts 2013/01/14 v3.01 Basic AMSFonts support +\symAMSa=\mathgroup4 +\symAMSb=\mathgroup5 +LaTeX Font Info: Redeclaring math symbol \hbar on input line 98. +LaTeX Font Info: Overwriting math alphabet `\mathfrak' in version `bold' +(Font) U/euf/m/n --> U/euf/b/n on input line 106. +LaTeX Info: Redefining \frak on input line 111. +LaTeX Info: Redefining \Bbb on input line 113. +)) +(/usr/local/texlive/2025/texmf-dist/tex/latex/tools/bm.sty +Package: bm 2023/12/19 v1.2f Bold Symbol Support (DPC/FMi) +\symboldoperators=\mathgroup6 +\symboldletters=\mathgroup7 +\symboldsymbols=\mathgroup8 +Package bm Info: No bold for \OMX/cmex/m/n, using \pmb. +Package bm Info: No bold for \U/msa/m/n, using \pmb. +Package bm Info: No bold for \U/msb/m/n, using \pmb. +LaTeX Font Info: Redeclaring math alphabet \mathbf on input line 149. +LaTeX Info: Redefining \bm on input line 219. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/booktabs/booktabs.sty +Package: booktabs 2020/01/12 v1.61803398 Publication quality tables +\heavyrulewidth=\dimen150 +\lightrulewidth=\dimen151 +\cmidrulewidth=\dimen152 +\belowrulesep=\dimen153 +\belowbottomsep=\dimen154 +\aboverulesep=\dimen155 +\abovetopsep=\dimen156 +\cmidrulesep=\dimen157 +\cmidrulekern=\dimen158 +\defaultaddspace=\dimen159 +\@cmidla=\count290 +\@cmidlb=\count291 +\@aboverulesep=\dimen160 +\@belowrulesep=\dimen161 +\@thisruleclass=\count292 +\@lastruleclass=\count293 +\@thisrulewidth=\dimen162 +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/microtype/microtype.sty +Package: microtype 2025/02/11 v3.2a Micro-typographical refinements (RS) + +(/usr/local/texlive/2025/texmf-dist/tex/latex/graphics/keyval.sty +Package: keyval 2022/05/29 v1.15 key=value parser (DPC) +\KV@toks@=\toks24 +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/etoolbox/etoolbox.sty +Package: etoolbox 2025/02/11 v2.5l e-TeX tools for LaTeX (JAW) +\etb@tempcnta=\count294 +) +\MT@toks=\toks25 +\MT@tempbox=\box69 +\MT@count=\count295 +LaTeX Info: Redefining \noprotrusionifhmode on input line 1087. +LaTeX Info: Redefining \leftprotrusion on input line 1088. +\MT@prot@toks=\toks26 +LaTeX Info: Redefining \rightprotrusion on input line 1107. +LaTeX Info: Redefining \textls on input line 1449. +\MT@outer@kern=\dimen163 +LaTeX Info: Redefining \microtypecontext on input line 2053. +LaTeX Info: Redefining \textmicrotypecontext on input line 2070. +\MT@listname@count=\count296 + +(/usr/local/texlive/2025/texmf-dist/tex/latex/microtype/microtype-pdftex.def +File: microtype-pdftex.def 2025/02/11 v3.2a Definitions specific to pdftex (RS) + +LaTeX Info: Redefining \lsstyle on input line 944. +LaTeX Info: Redefining \lslig on input line 944. +\MT@outer@space=\skip57 +) +Package microtype Info: Loading configuration file microtype.cfg. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/microtype/microtype.cfg +File: microtype.cfg 2025/02/11 v3.2a microtype main configuration file (RS) +) +LaTeX Info: Redefining \microtypesetup on input line 3065. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/xcolor/xcolor.sty +Package: xcolor 2024/09/29 v3.02 LaTeX color extensions (UK) + +(/usr/local/texlive/2025/texmf-dist/tex/latex/graphics-cfg/color.cfg +File: color.cfg 2016/01/02 v1.6 sample color configuration +) +Package xcolor Info: Driver file: pdftex.def on input line 274. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/graphics-def/pdftex.def +File: pdftex.def 2024/04/13 v1.2c Graphics/color driver for pdftex +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/graphics/mathcolor.ltx) +Package xcolor Info: Model `cmy' substituted by `cmy0' on input line 1349. +Package xcolor Info: Model `hsb' substituted by `rgb' on input line 1353. +Package xcolor Info: Model `RGB' extended on input line 1365. +Package xcolor Info: Model `HTML' substituted by `rgb' on input line 1367. +Package xcolor Info: Model `Hsb' substituted by `hsb' on input line 1368. +Package xcolor Info: Model `tHsb' substituted by `hsb' on input line 1369. +Package xcolor Info: Model `HSB' substituted by `hsb' on input line 1370. +Package xcolor Info: Model `Gray' substituted by `gray' on input line 1371. +Package xcolor Info: Model `wave' substituted by `hsb' on input line 1372. +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/hyperref/hyperref.sty +Package: hyperref 2024-11-05 v7.01l Hypertext links for LaTeX + +(/usr/local/texlive/2025/texmf-dist/tex/generic/iftex/iftex.sty +Package: iftex 2024/12/12 v1.0g TeX engine tests +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/kvsetkeys/kvsetkeys.sty +Package: kvsetkeys 2022-10-05 v1.19 Key value parser (HO) +) +(/usr/local/texlive/2025/texmf-dist/tex/generic/kvdefinekeys/kvdefinekeys.sty +Package: kvdefinekeys 2019-12-19 v1.6 Define keys (HO) +) +(/usr/local/texlive/2025/texmf-dist/tex/generic/pdfescape/pdfescape.sty +Package: pdfescape 2019/12/09 v1.15 Implements pdfTeX's escape features (HO) + +(/usr/local/texlive/2025/texmf-dist/tex/generic/ltxcmds/ltxcmds.sty +Package: ltxcmds 2023-12-04 v1.26 LaTeX kernel commands for general use (HO) +) +(/usr/local/texlive/2025/texmf-dist/tex/generic/pdftexcmds/pdftexcmds.sty +Package: pdftexcmds 2020-06-27 v0.33 Utility functions of pdfTeX for LuaTeX (HO +) + +(/usr/local/texlive/2025/texmf-dist/tex/generic/infwarerr/infwarerr.sty +Package: infwarerr 2019/12/03 v1.5 Providing info/warning/error messages (HO) +) +Package pdftexcmds Info: \pdf@primitive is available. +Package pdftexcmds Info: \pdf@ifprimitive is available. +Package pdftexcmds Info: \pdfdraftmode found. +)) +(/usr/local/texlive/2025/texmf-dist/tex/latex/hycolor/hycolor.sty +Package: hycolor 2020-01-27 v1.10 Color options for hyperref/bookmark (HO) +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/hyperref/nameref.sty +Package: nameref 2023-11-26 v2.56 Cross-referencing by name of section + +(/usr/local/texlive/2025/texmf-dist/tex/latex/refcount/refcount.sty +Package: refcount 2019/12/15 v3.6 Data extraction from label references (HO) +) +(/usr/local/texlive/2025/texmf-dist/tex/generic/gettitlestring/gettitlestring.s +ty +Package: gettitlestring 2019/12/15 v1.6 Cleanup title references (HO) + (/usr/local/texlive/2025/texmf-dist/tex/latex/kvoptions/kvoptions.sty +Package: kvoptions 2022-06-15 v3.15 Key value format for package options (HO) +)) + +Package nameref Warning: The definition of \label has changed! +(nameref) Check your packages! +(nameref) Replacing it with the kernel definition on input line +149. + +\c@section@level=\count297 +) (/usr/local/texlive/2025/texmf-dist/tex/generic/stringenc/stringenc.sty +Package: stringenc 2019/11/29 v1.12 Convert strings between diff. encodings (HO +) +) +\@linkdim=\dimen164 +\Hy@linkcounter=\count298 +\Hy@pagecounter=\count299 + +(/usr/local/texlive/2025/texmf-dist/tex/latex/hyperref/pd1enc.def +File: pd1enc.def 2024-11-05 v7.01l Hyperref: PDFDocEncoding definition (HO) +Now handling font encoding PD1 ... +... no UTF-8 mapping file for font encoding PD1 +) +(/usr/local/texlive/2025/texmf-dist/tex/generic/intcalc/intcalc.sty +Package: intcalc 2019/12/15 v1.3 Expandable calculations with integers (HO) +) +\Hy@SavedSpaceFactor=\count300 + +(/usr/local/texlive/2025/texmf-dist/tex/latex/hyperref/puenc.def +File: puenc.def 2024-11-05 v7.01l Hyperref: PDF Unicode definition (HO) +Now handling font encoding PU ... +... no UTF-8 mapping file for font encoding PU +) +Package hyperref Info: Option `colorlinks' set `true' on input line 4040. +Package hyperref Info: Hyper figures OFF on input line 4157. +Package hyperref Info: Link nesting OFF on input line 4162. +Package hyperref Info: Hyper index ON on input line 4165. +Package hyperref Info: Plain pages OFF on input line 4172. +Package hyperref Info: Backreferencing OFF on input line 4177. +Package hyperref Info: Implicit mode ON; LaTeX internals redefined. +Package hyperref Info: Bookmarks ON on input line 4424. +LaTeX Info: Redefining \href on input line 4674. +\c@Hy@tempcnt=\count301 +LaTeX Info: Redefining \url on input line 4763. +\XeTeXLinkMargin=\dimen165 + +(/usr/local/texlive/2025/texmf-dist/tex/generic/bitset/bitset.sty +Package: bitset 2019/12/09 v1.3 Handle bit-vector datatype (HO) + +(/usr/local/texlive/2025/texmf-dist/tex/generic/bigintcalc/bigintcalc.sty +Package: bigintcalc 2019/12/15 v1.5 Expandable calculations on big integers (HO +) +)) +\Fld@menulength=\count302 +\Field@Width=\dimen166 +\Fld@charsize=\dimen167 +Package hyperref Info: Hyper figures OFF on input line 6042. +Package hyperref Info: Link nesting OFF on input line 6047. +Package hyperref Info: Hyper index ON on input line 6050. +Package hyperref Info: backreferencing OFF on input line 6057. +Package hyperref Info: Link coloring ON on input line 6060. +Package hyperref Info: Link coloring with OCG OFF on input line 6067. +Package hyperref Info: PDF/A mode OFF on input line 6072. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/base/atbegshi-ltx.sty +Package: atbegshi-ltx 2021/01/10 v1.0c Emulation of the original atbegshi +package with kernel methods +) +\Hy@abspage=\count303 +\c@Item=\count304 +\c@Hfootnote=\count305 +) +Package hyperref Info: Driver (autodetected): hpdftex. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/hyperref/hpdftex.def +File: hpdftex.def 2024-11-05 v7.01l Hyperref driver for pdfTeX + +(/usr/local/texlive/2025/texmf-dist/tex/latex/base/atveryend-ltx.sty +Package: atveryend-ltx 2020/08/19 v1.0a Emulation of the original atveryend pac +kage +with kernel methods +) +\Fld@listcount=\count306 +\c@bookmark@seq@number=\count307 + +(/usr/local/texlive/2025/texmf-dist/tex/latex/rerunfilecheck/rerunfilecheck.sty +Package: rerunfilecheck 2022-07-10 v1.10 Rerun checks for auxiliary files (HO) + +(/usr/local/texlive/2025/texmf-dist/tex/generic/uniquecounter/uniquecounter.sty +Package: uniquecounter 2019/12/15 v1.4 Provide unlimited unique counter (HO) +) +Package uniquecounter Info: New unique counter `rerunfilecheck' on input line 2 +85. +) +\Hy@SectionHShift=\skip58 +) (./generated/results_v7.tex) +Class revtex4-2 Info: Unrecognized LaTeX tabular. Please update this document c +lass! (Proceeding with fingers crossed.) on input line 14. +Class revtex4-2 Info: cite was not loaded (OK!) on input line 14. +Class revtex4-2 Info: mcite was not loaded (OK!) on input line 14. +Class revtex4-2 Info: multicol was not loaded (OK!) on input line 14. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/l3backend/l3backend-pdftex.def +File: l3backend-pdftex.def 2024-05-08 L3 backend support: PDF output (pdfTeX) +\l__color_backend_stack_int=\count308 +\l__pdf_internal_box=\box70 +) +(./supplement.aux) +\openout1 = `supplement.aux'. + +LaTeX Font Info: Checking defaults for OML/cmm/m/it on input line 14. +LaTeX Font Info: ... okay on input line 14. +LaTeX Font Info: Checking defaults for OMS/cmsy/m/n on input line 14. +LaTeX Font Info: ... okay on input line 14. +LaTeX Font Info: Checking defaults for OT1/cmr/m/n on input line 14. +LaTeX Font Info: ... okay on input line 14. +LaTeX Font Info: Checking defaults for T1/cmr/m/n on input line 14. +LaTeX Font Info: ... okay on input line 14. +LaTeX Font Info: Checking defaults for TS1/cmr/m/n on input line 14. +LaTeX Font Info: ... okay on input line 14. +LaTeX Font Info: Checking defaults for OMX/cmex/m/n on input line 14. +LaTeX Font Info: ... okay on input line 14. +LaTeX Font Info: Checking defaults for U/cmr/m/n on input line 14. +LaTeX Font Info: ... okay on input line 14. +LaTeX Font Info: Checking defaults for PD1/pdf/m/n on input line 14. +LaTeX Font Info: ... okay on input line 14. +LaTeX Font Info: Checking defaults for PU/pdf/m/n on input line 14. +LaTeX Font Info: ... okay on input line 14. +LaTeX Info: Redefining \microtypecontext on input line 14. +Package microtype Info: Applying patch `item' on input line 14. +Package microtype Info: Applying patch `toc' on input line 14. +Package microtype Info: Applying patch `eqnum' on input line 14. +Package microtype Info: Applying patch `footnote' on input line 14. +Package microtype Info: Applying patch `verbatim' on input line 14. +LaTeX Info: Redefining \microtypesetup on input line 14. +Package microtype Info: Generating PDF output. +Package microtype Info: Character protrusion enabled (level 2). +Package microtype Info: Using default protrusion set `alltext'. +Package microtype Info: Automatic font expansion enabled (level 2), +(microtype) stretch: 20, shrink: 20, step: 1, non-selected. +Package microtype Info: Using default expansion set `alltext-nott'. +LaTeX Info: Redefining \showhyphens on input line 14. +Package microtype Info: No adjustment of tracking. +Package microtype Info: No adjustment of interword spacing. +Package microtype Info: No adjustment of character kerning. + +(/usr/local/texlive/2025/texmf-dist/tex/latex/microtype/mt-cmr.cfg +File: mt-cmr.cfg 2013/05/19 v2.2 microtype config. file: Computer Modern Roman +(RS) +) +(/usr/local/texlive/2025/texmf-dist/tex/context/base/mkii/supp-pdf.mkii +[Loading MPS to PDF converter (version 2006.09.02).] +\scratchcounter=\count309 +\scratchdimen=\dimen168 +\scratchbox=\box71 +\nofMPsegments=\count310 +\nofMParguments=\count311 +\everyMPshowfont=\toks27 +\MPscratchCnt=\count312 +\MPscratchDim=\dimen169 +\MPnumerator=\count313 +\makeMPintoPDFobject=\count314 +\everyMPtoPDFconversion=\toks28 +) +Package hyperref Info: Link coloring ON on input line 14. + (./supplement.out) (./supplement.out) +\@outlinefile=\write4 +\openout4 = `supplement.out'. + +Class revtex4-2 Info: Taking \maketitle back from hyperref on input line 14. +\openout3 = `supplementNotes.bib'. + +LaTeX Font Info: Trying to load font information for U+msa on input line 25. + + +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsfonts/umsa.fd +File: umsa.fd 2013/01/14 v3.01 AMS symbols A +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/microtype/mt-msa.cfg +File: mt-msa.cfg 2006/02/04 v1.1 microtype config. file: AMS symbols (a) (RS) +) +LaTeX Font Info: Trying to load font information for U+msb on input line 25. + + +(/usr/local/texlive/2025/texmf-dist/tex/latex/amsfonts/umsb.fd +File: umsb.fd 2013/01/14 v3.01 AMS symbols B +) +(/usr/local/texlive/2025/texmf-dist/tex/latex/microtype/mt-msb.cfg +File: mt-msb.cfg 2005/06/01 v1.0 microtype config. file: AMS symbols (b) (RS) +) [1{/usr/local/texlive/2025/texmf-var/fonts/map/pdftex/updmap/pdftex.map}] +Package microtype Info: Loading generic protrusion settings for font family +(microtype) `cmtt' (encoding: OT1). +(microtype) For optimal results, create family-specific settings. +(microtype) See the microtype manual for details. + [2] +(./supplement.bbl [3]) [4] (./supplement.aux) + *********** +LaTeX2e <2024-11-01> patch level 2 +L3 programming layer <2025-01-18> + *********** +Package rerunfilecheck Info: File `supplement.out' has not changed. +(rerunfilecheck) Checksum: D58BDF49B7931C7093DE876D362A728B;2467. + ) +Here is how much of TeX's memory you used: + 14002 strings out of 473190 + 211681 string characters out of 5715801 + 681276 words of memory out of 5000000 + 36991 multiletter control sequences out of 15000+600000 + 571531 words of font info for 113 fonts, out of 8000000 for 9000 + 1141 hyphenation exceptions out of 8191 + 75i,9n,79p,1007b,646s stack positions out of 10000i,1000n,20000p,200000b,200000s +< +/usr/local/texlive/2025/texmf-dist/fonts/type1/public/amsfonts/cm/cmex10.pfb> +Output written on supplement.pdf (4 pages, 203864 bytes). +PDF statistics: + 181 PDF objects out of 1000 (max. 8388607) + 140 compressed objects within 2 object streams + 33 named destinations out of 1000 (max. 500000) + 27209 words of extra memory for PDF output out of 29859 (max. 10000000) diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/supplement.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/supplement.pdf new file mode 100644 index 000000000..dd5186db4 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/supplement.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/supplement.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/supplement.tex new file mode 100644 index 000000000..93f7ec4a9 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/cohomological_geometric_eth/supplement.tex @@ -0,0 +1,172 @@ +\documentclass[aps,prl,onecolumn,superscriptaddress,longbibliography,floatfix]{revtex4-2} + +\usepackage{amsmath,amssymb,bm} +\usepackage{booktabs} +\usepackage{microtype} +\usepackage{xcolor} +\usepackage[colorlinks=true,citecolor=blue!55!black,linkcolor=blue!55!black,urlcolor=blue!55!black]{hyperref} +\hypersetup{pdftitle={Supplemental Material for Response-Complex Memory in Exactly Degenerate Quantum Matter},pdfauthor={Thomas J. Wang; OKongOYangO}} + +\input{generated/results_v7.tex} +\newcommand{\Tr}{\operatorname{Tr}} +\newcommand{\cH}{\mathcal H} + +\begin{document} + +\title{Supplemental Material for ``Response-Complex Memory in Exactly Degenerate Quantum Matter''} + +\author{Thomas J. Wang} +\email{WangTheoPhys@outlook.com} +\affiliation{Tsinghua University, Beijing 100084, China} + +\author{OKongOYangO} +\affiliation{The Pennsylvania State University, University Park, Pennsylvania 16802, USA} + +\maketitle + +\section{Finite cochain complex and harmonic fiber} +\label{sec:supp-cochain} + +Let \(V_r=\bigwedge^r\mathbb C^N\) be the fixed-charge sector with the occupation basis ordered lexicographically. A complex antisymmetric three-form \(C\) defines the degree-lowering maps +\begin{equation} + Q_r(C):V_r\longrightarrow V_{r-3},\qquad Q_r(C)=\sum_{iM\), exact \(\pm1\) atoms are appended algebraically. +The identity in Eq.~\eqref{eq:atom-plateau} is satisfied to floating-point +zero, and the raw decomposition +Eq.~\eqref{eq:atom-raw-decomposition} closes within +\(1.14\times10^{-13}\). + +\subsection{Interpolation ensembles} + +The geometric interpolation uses +\[ + g=0,\ 0.02,\ 0.05,\ 0.10,\ 0.20,\ 0.40,\ 0.70,\ 1.00 . +\] +At every positive \(g\), \(\GeometricSamplesPerPoint\) independent random +local residual pairs are mixed with a registered Fourier pair through +Eq.~\eqref{eq:geometric-interpolation}. +All \(28000\) positive-\(g\) curvature matrices have active rank \(50\). +The complete script-generated scalar adjacent-gap intervals are retained with +the numerical artifacts; the Haar--Jacobi simultaneous interval is +\(0.598440\)--\(0.600349\). + +The spectral interpolation uses +\[ + \alpha=0,\ 0.10,\ 0.20,\ 0.35,\ 0.50,\ 0.70,\ 0.85,\ 1.00 +\] +and \(\SpectralSamplesPerPoint\) matrices per value. +For every sample, the same Poisson and GUE endpoints are used across +\(\alpha\), which reduces interpolation noise while different samples remain +independent. +The target projector is recomputed numerically from the embedded full +Hamiltonian rather than assumed fixed. +The maximum measured distance in +Eq.~\eqref{eq:projector-invariance} and the zero curvature-spectrum error are +hard delivery gates. + +\subsection{Connected estimators and simultaneous inference} + +Raw, disconnected, and connected form factors are retained separately for +every ensemble: +\begin{equation} + \widehat K_{\rm raw} + =\frac{1}{D N_s}\sum_{s=1}^{N_s}|Z_s|^2,\qquad + \widehat K_{\rm disc} + =\frac{1}{D}\left|\frac{1}{N_s}\sum_{s=1}^{N_s}Z_s\right|^2 . + \label{eq:empirical-sff} +\end{equation} +Their difference is the displayed connected estimator. +This common convention is used for the exact-degenerate energy baseline, +physical curvature, Fourier control, interpolation ensembles, and Monte Carlo +Jacobi reference. +At \(\tau=0\), connected values below \(5\times10^{-15}\) are set to zero +only after raw-minus-disconnected subtraction. + +Complete matrices are the independent statistical units. Physical curves are +first averaged within eight independent seed blocks; +Fourier curves are averaged within the twelve momentum orbits; the Haar +reference uses complete matrices. +We construct \(\BootstrapReplicatesVTwo\)-replicate Gaussian-multiplier or +hierarchical-block processes and take the 95th percentile of the maximum +studentized deviation over each registered grid. +Thus every shaded region used for an onset or compatibility statement is a +simultaneous confidence band across the complete registered grid. + +For an SFF residual band \([\ell(\tau),u(\tau)]\), the registered compatibility +onset is the first grid point \(\tau_*\in[0.25,1.5]\) such that +\(0\in[\ell(\tau),u(\tau)]\) for every subsequent registered point. +An interpolation value \(g\) is said to possess a nontrivial compatibility +window only if at least eight grid points remain. +The number-variance compatibility extent is the largest \(L\) in the +contiguous initial interval beginning at \(L=0.25\) whose residual band +contains zero. +These definitions were fixed before reading the reported onsets. + +\subsection{One-point covariance and finite-rank sequence} + +The v1 analysis retained in the present expanded article tests a distinct +observable: the ensemble-mean ambient row-space projector +\begin{equation} + \overline\Pi=\mathbb E[Y^\dagger Y]. + \label{eq:mean-row-projector} +\end{equation} +A covariance-deformed Gaussian row-space ensemble learned from +\(\TrainingRows\) training matrices and selected on validation data reduces +the held-out density \(L^1\) error from \(\DensityHaarLone\) to +\(\DensityCovLone\), while preserving the local gap ratio. +The exact Jacobi SFF in v2 remains parameter free; this result explains why +one-point and long-range observables can retain structure alongside local +two-level agreement. + +For the rank sequence, cyclic \((1,2)\)-admissible root configurations and +their one-body descendants are generated independently of the lattice cache. +The seven registered sample counts are +\[ + 2000,\ 2000,\ 2000,\ 1000,\ 1000,\ 500,\ 250 . +\] +Atoms are labeled by Eq.~\eqref{eq:atom-count} before their numerical +eigenvalues are inspected. +The final \(D=800\) case therefore contains \(120+120\) exact atoms and +\(560\) interior levels in every matrix. +Because \(N=3\) remains fixed, changes along this sequence are described as +finite-rank evidence only. + +\subsection{Many-body Wick sequence} + +The fixed-two-quasihole sequence uses \(n_\phi=2N+2\) and the exact cyclic +zero-mode ranks \(D=16,25,36\). +The \(N=3,4\) parents are diagonalized densely. +For \(N=5\), the complete 36-column kernel frame is obtained by a block sparse +eigensolver; its residual norm is \(3.59\times10^{-9}\). +Complement resolvents are evaluated at two positive shifts and extrapolated +linearly to zero shift. +The maximum \(N=5\) relative equation residual is +\(2.75\times10^{-7}\), and the maximum two-shift difference is +\(3.94\times10^{-4}\). +The physical sequence begins at \(N=3\), since the \(N=2,n_\phi=6\) +Kapit--Mueller parent has 12 numerical zero modes compared with the cyclic +target rank nine. + +\begin{table*}[t] + \caption{Registered matrix-element sequence. The Gaussian column is the + covariance-matched finite-size median; ``excess'' is the physical median + minus that value.} + \label{tab:matrix-element-v3} + \begin{ruledtabular} + \begin{tabular}{cccccccc} + \(N\) & \(n_\phi\) & \(D\) & \(\dim\mathcal H\) & \(\Delta\) & + \(R_4\) & \(R_4^{\rm G}\) & excess\\ + \MatrixElementResultRows + \end{tabular} + \end{ruledtabular} +\end{table*} + +For each size, 24 deterministic balanced local-density panels supply the +physical resampling units. +Each panel has eight operators. +The finite-size null uses 2000 complete covariance-matched Gaussian response +tensors per size. +All target and external gauge checks are applied before the four-channel +tensor is evaluated. + +\subsection{Closed twist bundle and Wilson statistics} + +The base twist bundles are diagonalized at every point of the periodic mesh. +Physical many-body overlaps include the exact symmetric bosonic lift of the +single-particle orbital overlap. +The undeformed \(6\times6\) and \(8\times8\) meshes establish the base +integer. A \(12\times12\) preflight identifies a determinant-branch alias +and a shifted \(C_1=8\) for one \(N=4,g=1\) seed. The accepted production +pair \(16\times16\) and \(20\times20\) resolves the full \(g\leq1\) orbit, +with the coarse alias artifact retained for provenance. + +\begin{table*}[t] + \caption{Accepted closed-surface topology and Wilson statistics. The final + and CUE columns are median circular adjacent-gap ratios.} + \label{tab:topology-v3} + \begin{ruledtabular} + \begin{tabular}{cccccccc} + \(N\) & \(D\) & \(C_1\) & \(\Delta_{\min}\) & + branch margin & overlap minimum & \(\langle r_W\rangle_{g=1}\) & + \(\langle r_W\rangle_{\rm CUE}\)\\ + \TopologyResultRows + \end{tabular} + \end{ruledtabular} +\end{table*} + +Eight independently seeded noncommuting generator pairs and one commuting +control are evaluated at \(g=0,0.25,0.5,0.75,1\). +Generator seeds are the cluster units in the bootstrap. +The CUE reference contains 10000 independent matrices per rank. +Per-loop arrays are retained within their generator-seed clusters for +bootstrap inference. + +\subsection{Reproducibility gates} + +The task-local delivery requires regenerated hashes for every source artifact; +exact registered sample counts, ranks, and interpolation points; disjoint +training, validation, and test indices; matrix-level confidence calculations; +finite-Jacobi mass, orthogonality, Monte Carlo, atom, and raw-closure checks; +fixed-projector error below \(10^{-12}\); synchronized figure hashes; resolved +LaTeX references; and a render record for every compiled page. Task isolation +keeps the v3 implementation fully self-contained. Additional gates require +both independent v3 audits, the registered \(16/20\) topology pair, the +retained coarse-mesh alias preflight, exact result branches, executable Wick +and Chern identities, and source hashes for +Figs.~\ref{fig:wick-factorization} and~\ref{fig:topological-holonomy}. diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_1_physical_law_v1.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_1_physical_law_v1.pdf new file mode 100644 index 000000000..d898137fb Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_1_physical_law_v1.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_1_spectral_silence_v2.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_1_spectral_silence_v2.pdf new file mode 100644 index 000000000..4c8d2d395 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_1_spectral_silence_v2.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_2_falsification_triangle_v2.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_2_falsification_triangle_v2.pdf new file mode 100644 index 000000000..80c19edb0 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_2_falsification_triangle_v2.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_2_scale_hierarchy_v1.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_2_scale_hierarchy_v1.pdf new file mode 100644 index 000000000..e8a1ea81a Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_2_scale_hierarchy_v1.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_3_atom_crossover_v1.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_3_atom_crossover_v1.pdf new file mode 100644 index 000000000..173e56f14 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_3_atom_crossover_v1.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_3_independent_channels_v2.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_3_independent_channels_v2.pdf new file mode 100644 index 000000000..5287ee30e Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_3_independent_channels_v2.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_4_finite_size_v1.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_4_finite_size_v1.pdf new file mode 100644 index 000000000..5436e997d Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_4_finite_size_v1.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_4_geometric_hierarchy_v2.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_4_geometric_hierarchy_v2.pdf new file mode 100644 index 000000000..5ed7caa28 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_4_geometric_hierarchy_v2.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_5_covariance_mechanism_v1.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_5_covariance_mechanism_v1.pdf new file mode 100644 index 000000000..0089e74e4 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_5_covariance_mechanism_v1.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_5_jacobi_atoms_v2.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_5_jacobi_atoms_v2.pdf new file mode 100644 index 000000000..348c1b853 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_5_jacobi_atoms_v2.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_6_wick_factorization_v3.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_6_wick_factorization_v3.pdf new file mode 100644 index 000000000..1bc7ae8c2 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_6_wick_factorization_v3.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_7_topological_holonomy_v3.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_7_topological_holonomy_v3.pdf new file mode 100644 index 000000000..7915b1e9a Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/figures/figure_7_topological_holonomy_v3.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_numbers_v1.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_numbers_v1.tex new file mode 100644 index 000000000..7edcf9088 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_numbers_v1.tex @@ -0,0 +1,30 @@ +\newcommand{\PhysicalMatrices}{20000} +\newcommand{\PhysicalTestMatrices}{4000} +\newcommand{\PhysicalRank}{50} +\newcommand{\PhysicalChannels}{170} +\newcommand{\TrainingRows}{1024} +\newcommand{\HaarMatrices}{10000} +\newcommand{\DeformedMatrices}{10000} +\newcommand{\SelectedCovFloor}{0.050} +\newcommand{\DensityHaarLone}{0.2910} +\newcommand{\DensityCovLone}{0.1237} +\newcommand{\DensityImprovementPercent}{57.5\%} +\newcommand{\PhysicalGapRatio}{0.599806} +\newcommand{\HaarGapRatio}{0.599395} +\newcommand{\DeformedGapRatio}{0.599200} +\newcommand{\LargestRank}{800} +\newcommand{\LargestChannels}{680} +\newcommand{\LargestAtomMultiplicity}{120} +\newcommand{\LargestAtomWeightPercent}{30.0\%} +\newcommand{\LargestInteriorDensityLone}{0.0523} +\newcommand{\DensityFitExponent}{0.593} +\newcommand{\BootstrapReplicates}{10000} +\newcommand{\RootMatricesTotal}{8750} +\newcommand{\CovarianceAnisotropy}{0.867} +\newcommand{\PhysicalParticipation}{0.625} +\newcommand{\NumberVariancePhysEight}{0.696} +\newcommand{\NumberVarianceHaarEight}{0.570} +\newcommand{\NumberVarianceCovEight}{0.570} +\newcommand{\FormFactorPhysHalf}{0.502} +\newcommand{\FormFactorHaarHalf}{0.495} +\newcommand{\FormFactorCovHalf}{0.502} diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_numbers_v2.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_numbers_v2.tex new file mode 100644 index 000000000..5f3b57ce1 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_numbers_v2.tex @@ -0,0 +1,22 @@ +\newcommand{\EnergyRawSFF}{50} +\newcommand{\EnergyConnectedSFF}{0} +\newcommand{\StructuredFormHalf}{4.476} +\newcommand{\PhysicalFormHalf}{0.502} +\newcommand{\JacobiFormHalf}{0.501} +\newcommand{\GeometricTauOnset}{0.25} +\newcommand{\GeometricLocalOnset}{0.20} +\newcommand{\GeometricRampOnset}{0.40} +\newcommand{\NumberVarianceExtent}{1.0} +\newcommand{\NumberResidualEight}{0.12582} +\newcommand{\NumberResidualEightLower}{0.11428} +\newcommand{\NumberResidualEightUpper}{0.13736} +\newcommand{\PoissonEndpointRatio}{0.385645} +\newcommand{\GUEEndpointRatio}{0.598677} +\newcommand{\StructuredMomenta}{24} +\newcommand{\StructuredOrbits}{12} +\newcommand{\GeometricSamplesPerPoint}{4000} +\newcommand{\SpectralSamplesPerPoint}{4000} +\newcommand{\BootstrapReplicatesVTwo}{10000} +\newcommand{\LargestRankVTwo}{800} +\newcommand{\LargestAtomEachVTwo}{120} +\newcommand{\LargestConnectedPlateau}{0.7} diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_numbers_v3.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_numbers_v3.tex new file mode 100644 index 000000000..b3c34e8c3 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_numbers_v3.tex @@ -0,0 +1,30 @@ +% Generated from audited v3 artifacts by the release pipeline. +\newcommand{\MatrixElementBranch}{deformed\_geometric\_eth} +\newcommand{\MatrixElementBranchText}{The four-channel residual decreases along the genuine many-body sequence and retains a resolved connected component at the largest size.} +\newcommand{\LargestManyBodyN}{5} +\newcommand{\LargestManyBodyRank}{36} +\newcommand{\LargestManyBodyDimension}{4368} +\newcommand{\LargestNRFour}{0.20906} +\newcommand{\LargestGaussianRFour}{0.12723} +\newcommand{\LargestGaussianRFourLow}{0.12657} +\newcommand{\LargestGaussianRFourHigh}{0.12797} +\newcommand{\LargestRFourExcess}{0.08183} +\newcommand{\TopologyBranch}{fixed\_chern\_deformed\_holonomy} +\newcommand{\TopologyBranchText}{The Chern class and complete spectrum remain fixed while Wilson statistics change significantly and occupy a structured class distinct from the circular-unitary reference.} +\newcommand{\TopologyPrimaryMesh}{16} +\newcommand{\TopologyConvergenceMesh}{20} +\newcommand{\TopologyNThreeChern}{6} +\newcommand{\TopologyNFourChern}{10} +\newcommand{\TopologyNThreeGap}{0.051741} +\newcommand{\TopologyNFourGap}{0.094695} +\newcommand{\TopologyNThreeGapChangeLow}{0.02777} +\newcommand{\TopologyNThreeGapChangeHigh}{0.05068} +\newcommand{\TopologyNFourGapChangeLow}{0.01805} +\newcommand{\TopologyNFourGapChangeHigh}{0.02835} +\newcommand{\TopologyNThreeFinalGapRatio}{0.32115} +\newcommand{\TopologyNFourFinalGapRatio}{0.33175} +\newcommand{\TopologyNThreeCUERatio}{0.60153} +\newcommand{\TopologyNFourCUERatio}{0.60079} +\newcommand{\TopologyMinimumBranchMargin}{1.17980} +\newcommand{\TopologyMinimumOverlap}{0.83693} +\newcommand{\TopologyGaugeError}{6.85e-15} diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_tables_v1.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_tables_v1.tex new file mode 100644 index 000000000..0c6cc0d80 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_tables_v1.tex @@ -0,0 +1,13 @@ +\begin{tabular}{rrrrrr} +\hline\hline +$D$ & $M$ & samples & atoms/edge & $\Delta\langle r\rangle$ & $L^1_{\rm int}$ \\ +\hline +16 & 80 & 2000 & 0 & 0.03023 & 0.43375 \\ +50 & 140 & 2000 & 0 & 0.00767 & 0.22916 \\ +112 & 216 & 2000 & 0 & 0.00403 & 0.14094 \\ +210 & 308 & 1000 & 0 & 0.00173 & 0.09624 \\ +352 & 416 & 1000 & 0 & 0.00290 & 0.06866 \\ +546 & 540 & 500 & 6 & 0.00024 & 0.05149 \\ +800 & 680 & 250 & 120 & 0.00423 & 0.05226 \\ +\hline\hline +\end{tabular} diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_tables_v2.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_tables_v2.tex new file mode 100644 index 000000000..9e38a3fb2 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_tables_v2.tex @@ -0,0 +1,13 @@ +\begin{tabular}{rrrr} +\hline\hline +$g$ & $\langle r_F\rangle$ & lower & upper \\ +\hline +0.02 & 0.577596 & 0.575437 & 0.579755 \\ +0.05 & 0.590540 & 0.589162 & 0.591919 \\ +0.10 & 0.594497 & 0.592683 & 0.596310 \\ +0.20 & 0.598927 & 0.597464 & 0.600390 \\ +0.40 & 0.599034 & 0.597900 & 0.600167 \\ +0.70 & 0.599670 & 0.597824 & 0.601517 \\ +1.00 & 0.600307 & 0.598866 & 0.601749 \\ +\hline\hline +\end{tabular} diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_tables_v3.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_tables_v3.tex new file mode 100644 index 000000000..aad5da441 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/generated/generated_tables_v3.tex @@ -0,0 +1,10 @@ +% Generated from audited v3 artifacts by the release pipeline. +\newcommand{\MatrixElementResultRows}{% +3 & 8 & 16 & 120 & 0.055872 & 0.37093 & 0.21708 & 0.15385 \\ +4 & 10 & 25 & 715 & 0.103502 & 0.24715 & 0.14638 & 0.10078 \\ +5 & 12 & 36 & 4368 & 0.093593 & 0.20906 & 0.12723 & 0.08183 \\ +} +\newcommand{\TopologyResultRows}{% +3 & 16 & 6 & 0.051741 & 2.06643 & 0.85325 & 0.32115 & 0.60153 \\ +4 & 25 & 10 & 0.094695 & 1.17980 & 0.83693 & 0.33175 & 0.60079 \\ +} diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/main.pdf b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/main.pdf new file mode 100644 index 000000000..8e41beb23 Binary files /dev/null and b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/main.pdf differ diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/main.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/main.tex new file mode 100644 index 000000000..e608d0547 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/main.tex @@ -0,0 +1,68 @@ +\documentclass[aps,prb,reprint,superscriptaddress,longbibliography,floatfix]{revtex4-2} + +\usepackage{amsmath,amssymb,bm} +\usepackage{booktabs} +\usepackage{graphicx} +\usepackage{microtype} +\usepackage{xcolor} +\usepackage[colorlinks=true,citecolor=blue!55!black,linkcolor=blue!55!black,urlcolor=blue!55!black]{hyperref} +\hypersetup{ + pdftitle={Spectral Silence and Geometric Chaos in an Exactly Degenerate Topological Manifold}, + pdfauthor={Thomas J. Wang; OKongOYangO}, + pdfsubject={Exact degeneracy, non-Abelian Berry curvature, geometric chaos, and finite Jacobi form factors} +} + +\graphicspath{{figures/}} +\input{generated/generated_numbers_v1.tex} +\input{generated/generated_numbers_v2.tex} +\input{generated/generated_numbers_v3.tex} +\input{generated/generated_tables_v3.tex} + +\newcommand{\Tr}{\operatorname{Tr}} +\newcommand{\rank}{\operatorname{rank}} +\newcommand{\cH}{\mathcal{H}} +\newcommand{\cS}{\mathcal{S}} +\newcommand{\dd}{\mathrm{d}} + +\begin{document} + +\title{Spectral Silence and Geometric Chaos in an\texorpdfstring{\\}{ } +Exactly Degenerate Topological Manifold} + +\author{Thomas J. Wang} +\affiliation{Tsinghua University, Beijing 100084, China} + +\author{OKongOYangO} +\affiliation{The Pennsylvania State University, University Park, Pennsylvania 16802, USA} + +\date{\today} + +\begin{abstract} +Exact degeneracy silences every internal level-spacing diagnostic and elevates quantum geometry into the primary signal. We establish an independently testable hierarchy of projector correlations in a bosonic fractional-quantum-Hall zero-mode manifold. The energy spectral form factor obeys the exact identities \(K_{E,\mathrm{raw}}=D\) and \(K_{E,c}=0\), while the quantum-metric-normalized non-Abelian Berry curvature follows the finite-\(D\) complex-Jacobi ramp over a registered window. Structured-tangent and fixed-projector interventions resolve geometric chaos independently from active rank and intramultiplet spectral statistics; exact boundary atoms at \(D>M\) yield the analytic connected plateau \(k/D\). We then introduce a matrix-element Geometric-ETH test. On the genuine fixed-two-quasihole sequence \(N=3,4,5\), a covariance-whitened, gauge-invariant four-channel residual decreases to \(R_4=\LargestNRFour\) and retains a resolved connected component relative to its matched Gaussian interval, selecting deformed Geometric ETH. On the closed twist torus, a smooth periodic ambient conjugation preserves the complete spectrum, gap, and Chern numbers \(C_1=6,10\) for \(N=3,4\), while Wilson gap ratios change significantly and occupy a structured universality class distinct from circular-unitary transport. Exact degeneracy therefore reveals three complementary geometric layers: finite-Jacobi local correlations, operator-channel memory, and tunable non-Abelian holonomy inside one fixed topological class. +\end{abstract} + +\maketitle + +\input{sections/01-introduction.tex} +\input{sections/02-ensembles.tex} +\input{sections/03-physical-law.tex} +\input{sections/04-covariance-eth.tex} +\input{sections/05-rank-crossover.tex} +\input{sections/06-thouless-hierarchy.tex} +\input{sections/08-matrix-elements-topology.tex} +\input{sections/07-conclusion.tex} + +\appendix +\input{appendices/numerical-methods.tex} +\input{appendices/matrix-element-topology-v3.tex} + +\section*{Code and data availability} +The public repository \url{https://github.com/JunkaiWang-TheoPhy/Chaos-of-Quantum-Geometry} contains the complete source, tests, seven figures, generated tables, compact numerical artifacts, and the audited article. From \texttt{01\_task\_folder/task\_05/script}, \texttt{bash run\_quick\_verify\_v1.sh} verifies the release contract and focused analytic tests, while \texttt{bash run\_full\_recompute\_v1.sh} executes the complete production pipeline. The machine-readable \texttt{output/release\_manifest\_v1.json} records every Git-resident artifact and every production array with its path, byte size, SHA-256 hash, storage class, and producing command. + +\begin{acknowledgments} +The numerical artifacts, fixed train--validation--test split, matrix-level uncertainty estimates, and figure-generation scripts are retained with the source of this manuscript. +\end{acknowledgments} + +\bibliography{references} + +\end{document} diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/references.bib b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/references.bib new file mode 100644 index 000000000..903552d16 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/references.bib @@ -0,0 +1,355 @@ +@article{berry1984, + author = {Berry, Michael V.}, + title = {Quantal phase factors accompanying adiabatic changes}, + journal = {Proceedings of the Royal Society of London. A. Mathematical and Physical Sciences}, + volume = {392}, + pages = {45--57}, + year = {1984}, + doi = {10.1098/rspa.1984.0023} +} + +@article{wilczekzee1984, + author = {Wilczek, Frank and Zee, A.}, + title = {Appearance of gauge structure in simple dynamical systems}, + journal = {Physical Review Letters}, + volume = {52}, + pages = {2111--2114}, + year = {1984}, + doi = {10.1103/PhysRevLett.52.2111} +} + +@article{provostvallee1980, + author = {Provost, J. P. and Vall{\'e}e, G.}, + title = {Riemannian structure on manifolds of quantum states}, + journal = {Communications in Mathematical Physics}, + volume = {76}, + pages = {289--301}, + year = {1980}, + doi = {10.1007/BF02193559} +} + +@article{kato1950, + author = {Kato, Tosio}, + title = {On the adiabatic theorem of quantum mechanics}, + journal = {Journal of the Physical Society of Japan}, + volume = {5}, + pages = {435--439}, + year = {1950}, + doi = {10.1143/JPSJ.5.435} +} + +@misc{chen2026, + author = {Chen, Yiming and Colin-Ellerin, Sean and Mamroud, Ohad and Papadodimas, Kyriakos}, + title = {Chaos of Berry curvature for BPS microstates}, + year = {2026}, + eprint = {2604.23287}, + archivePrefix = {arXiv}, + primaryClass = {hep-th}, + url = {https://arxiv.org/abs/2604.23287} +} + +@article{pandey2020, + author = {Pandey, Mohit and Claeys, Pieter W. and Campbell, David K. and Polkovnikov, Anatoli and Sels, Dries}, + title = {Adiabatic eigenstate deformations as a sensitive probe for quantum chaos}, + journal = {Physical Review X}, + volume = {10}, + pages = {041017}, + year = {2020}, + doi = {10.1103/PhysRevX.10.041017}, + eprint = {2004.05043}, + archivePrefix = {arXiv}, + primaryClass = {cond-mat.stat-mech} +} + +@misc{sharipov2024, + author = {Sharipov, Rustem and Tiutiakina, Anastasiia and Gorsky, Alexander and Gritsev, Vladimir and Polkovnikov, Anatoli}, + title = {Hilbert space geometry and quantum chaos}, + year = {2024}, + eprint = {2411.11968}, + archivePrefix = {arXiv}, + primaryClass = {quant-ph}, + url = {https://arxiv.org/abs/2411.11968} +} + +@article{chenludwig2018, + author = {Chen, Xiao and Ludwig, Andreas W. W.}, + title = {Universal spectral correlations in the chaotic wave function, and the development of quantum chaos}, + journal = {Physical Review B}, + volume = {98}, + pages = {064309}, + year = {2018}, + doi = {10.1103/PhysRevB.98.064309}, + eprint = {1710.02686}, + archivePrefix = {arXiv}, + primaryClass = {cond-mat.str-el} +} + +@article{laughlin1983, + author = {Laughlin, Robert B.}, + title = {Anomalous quantum Hall effect: An incompressible quantum fluid with fractionally charged excitations}, + journal = {Physical Review Letters}, + volume = {50}, + pages = {1395--1398}, + year = {1983}, + doi = {10.1103/PhysRevLett.50.1395} +} + +@article{haldane1983, + author = {Haldane, F. D. M.}, + title = {Fractional quantization of the Hall effect: A hierarchy of incompressible quantum fluid states}, + journal = {Physical Review Letters}, + volume = {51}, + pages = {605--608}, + year = {1983}, + doi = {10.1103/PhysRevLett.51.605} +} + +@article{bernevighaldane2008, + author = {Bernevig, B. Andrei and Haldane, F. D. M.}, + title = {Model fractional quantum Hall states and Jack polynomials}, + journal = {Physical Review Letters}, + volume = {100}, + pages = {246802}, + year = {2008}, + doi = {10.1103/PhysRevLett.100.246802} +} + +@article{chenseidel2015, + author = {Chen, Li and Seidel, Alexander}, + title = {Algebraic approach to the study of zero modes of Haldane pseudopotentials}, + journal = {Physical Review B}, + volume = {91}, + pages = {085103}, + year = {2015}, + doi = {10.1103/PhysRevB.91.085103} +} + +@article{mooreread1991, + author = {Moore, Gregory and Read, Nicholas}, + title = {Nonabelions in the fractional quantum Hall effect}, + journal = {Nuclear Physics B}, + volume = {360}, + pages = {362--396}, + year = {1991}, + doi = {10.1016/0550-3213(91)90407-O} +} + +@article{readrezayi1999, + author = {Read, N. and Rezayi, E.}, + title = {Beyond paired quantum Hall states: Parafermions and incompressible states in the first excited Landau level}, + journal = {Physical Review B}, + volume = {59}, + pages = {8084--8092}, + year = {1999}, + doi = {10.1103/PhysRevB.59.8084} +} + +@article{zhang2023, + author = {Zhang, Fanmao and Schossler, Matheus and Seidel, Alexander and Chen, Li}, + title = {From frustration-free parent Hamiltonians to off-diagonal long-range order: Moore--Read and related states in second quantization}, + journal = {Physical Review B}, + volume = {108}, + pages = {075142}, + year = {2023}, + doi = {10.1103/PhysRevB.108.075142} +} + +@article{mazaheri2015, + author = {Mazaheri, Tahereh and Ortiz, Gerardo and Nussinov, Zohar and Seidel, Alexander}, + title = {Zero modes, bosonization, and topological quantum order: The Laughlin state in second quantization}, + journal = {Physical Review B}, + volume = {91}, + pages = {085115}, + year = {2015}, + doi = {10.1103/PhysRevB.91.085115} +} + +@article{kapitmueller2010, + author = {Kapit, Eliot and Mueller, Erich}, + title = {Exact parent Hamiltonian for the quantum Hall states in a lattice}, + journal = {Physical Review Letters}, + volume = {105}, + pages = {215303}, + year = {2010}, + doi = {10.1103/PhysRevLett.105.215303} +} + +@article{leeqi2014, + author = {Lee, Ching Hua and Qi, Xiao-Liang}, + title = {Lattice construction of pseudopotential Hamiltonians for fractional Chern insulators}, + journal = {Physical Review B}, + volume = {90}, + pages = {085103}, + year = {2014}, + doi = {10.1103/PhysRevB.90.085103} +} + +@article{neupert2011, + author = {Neupert, Titus and Santos, Luiz and Chamon, Claudio and Mudry, Christopher}, + title = {Fractional quantum Hall states at zero magnetic field}, + journal = {Physical Review Letters}, + volume = {106}, + pages = {236804}, + year = {2011}, + doi = {10.1103/PhysRevLett.106.236804} +} + +@article{bravyi2010, + author = {Bravyi, Sergey and Hastings, Matthew B. and Michalakis, Spyridon}, + title = {Topological quantum order: Stability under local perturbations}, + journal = {Journal of Mathematical Physics}, + volume = {51}, + pages = {093512}, + year = {2010}, + doi = {10.1063/1.3490195} +} + +@article{bachmann2011, + author = {Bachmann, Sven and Michalakis, Spyridon and Nachtergaele, Bruno and Sims, Robert}, + title = {Automorphic equivalence within gapped phases of quantum lattice systems}, + journal = {Communications in Mathematical Physics}, + volume = {309}, + pages = {835--871}, + year = {2011}, + doi = {10.1007/s00220-011-1380-0} +} + +@article{schuch2011, + author = {Schuch, Norbert and P{\'e}rez-Garc{\'i}a, David and Cirac, Ignacio}, + title = {Classifying quantum phases using matrix product states and projected entangled pair states}, + journal = {Physical Review B}, + volume = {84}, + pages = {165139}, + year = {2011}, + doi = {10.1103/PhysRevB.84.165139} +} + +@article{hastingswen2005, + author = {Hastings, M. B. and Wen, Xiao-Gang}, + title = {Quasiadiabatic continuation of quantum states: The stability of topological ground-state degeneracy and emergent gauge invariance}, + journal = {Physical Review B}, + volume = {72}, + pages = {045141}, + year = {2005}, + doi = {10.1103/PhysRevB.72.045141} +} + +@article{collins2005, + author = {Collins, Beno{\^i}t}, + title = {Product of random projections, Jacobi ensembles and universality problems arising from free probability}, + journal = {Probability Theory and Related Fields}, + volume = {133}, + pages = {315--344}, + year = {2005}, + doi = {10.1007/s00440-005-0428-5} +} + +@article{zyczkowski2000, + author = {{\.Z}yczkowski, Karol and Sommers, Hans-J{\"u}rgen}, + title = {Truncations of random unitary matrices}, + journal = {Journal of Physics A: Mathematical and General}, + volume = {33}, + pages = {2045--2057}, + year = {2000}, + doi = {10.1088/0305-4470/33/10/307} +} + +@article{atas2013, + author = {Atas, Y. Y. and Bogomolny, E. and Giraud, O. and Roux, G.}, + title = {Distribution of the ratio of consecutive level spacings in random matrix ensembles}, + journal = {Physical Review Letters}, + volume = {110}, + pages = {084101}, + year = {2013}, + doi = {10.1103/PhysRevLett.110.084101} +} + +@article{niuthoulesswu1985, + author = {Niu, Qian and Thouless, D. J. and Wu, Yong-Shi}, + title = {Quantized Hall conductance as a topological invariant}, + journal = {Physical Review B}, + volume = {31}, + pages = {3372--3377}, + year = {1985}, + doi = {10.1103/PhysRevB.31.3372} +} + +@article{kolodrubetz2017, + author = {Kolodrubetz, Michael and Sels, Dries and Mehta, Pankaj and Polkovnikov, Anatoli}, + title = {Geometry and non-adiabatic response in quantum and classical systems}, + journal = {Physics Reports}, + volume = {697}, + pages = {1--87}, + year = {2017}, + doi = {10.1016/j.physrep.2017.07.001} +} + +@article{bohigas1984, + author = {Bohigas, Oriol and Giannoni, Marie-Joya and Schmit, Charles}, + title = {Characterization of chaotic quantum spectra and universality of level fluctuation laws}, + journal = {Physical Review Letters}, + volume = {52}, + pages = {1--4}, + year = {1984}, + doi = {10.1103/PhysRevLett.52.1} +} + +@article{deutsch1991, + author = {Deutsch, J. M.}, + title = {Quantum statistical mechanics in a closed system}, + journal = {Physical Review A}, + volume = {43}, + pages = {2046--2049}, + year = {1991}, + doi = {10.1103/PhysRevA.43.2046} +} + +@article{srednicki1994, + author = {Srednicki, Mark}, + title = {Chaos and quantum thermalization}, + journal = {Physical Review E}, + volume = {50}, + pages = {888--901}, + year = {1994}, + doi = {10.1103/PhysRevE.50.888} +} + +@article{dalessio2016, + author = {D'Alessio, Luca and Kafri, Yariv and Polkovnikov, Anatoli and Rigol, Marcos}, + title = {From quantum chaos and eigenstate thermalization to statistical mechanics and thermodynamics}, + journal = {Advances in Physics}, + volume = {65}, + pages = {239--362}, + year = {2016}, + doi = {10.1080/00018732.2016.1198134} +} + +@article{foinikurchan2019, + author = {Foini, Laura and Kurchan, Jorge}, + title = {Eigenstate thermalization hypothesis and out of time order correlators}, + journal = {Physical Review E}, + volume = {99}, + pages = {042139}, + year = {2019}, + doi = {10.1103/PhysRevE.99.042139} +} + +@article{pappalardi2022, + author = {Pappalardi, Silvia and Foini, Laura and Kurchan, Jorge}, + title = {Eigenstate Thermalization Hypothesis and Free Probability}, + journal = {Physical Review Letters}, + volume = {129}, + pages = {170603}, + year = {2022}, + doi = {10.1103/PhysRevLett.129.170603} +} + +@article{fukui2005, + author = {Fukui, Takahiro and Hatsugai, Yasuhiro and Suzuki, Hiroshi}, + title = {Chern Numbers in Discretized Brillouin Zone: Efficient Method of Computing (Spin) Hall Conductances}, + journal = {Journal of the Physical Society of Japan}, + volume = {74}, + pages = {1674--1677}, + year = {2005}, + doi = {10.1143/JPSJ.74.1674} +} diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/01-introduction.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/01-introduction.tex new file mode 100644 index 000000000..abb66527a --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/01-introduction.tex @@ -0,0 +1,139 @@ +\section{Introduction} +\label{sec:introduction} + +Quantum chaos is conventionally diagnosed in the spectrum of a Hamiltonian. +After resolving symmetries and unfolding the density of states, chaotic levels +repel and their long-range correlations approach a Wigner--Dyson random-matrix +ensemble \cite{bohigas1984,atas2013}. +The connected spectral form factor packages the same two-level correlations +into a ramp and plateau. +The eigenstate thermalization hypothesis (ETH) complements this spectral +picture by describing matrix elements of observables in the energy basis +\cite{deutsch1991,srednicki1994,dalessio2016}. +All three constructions use nonzero energy differences, so exact degeneracy +opens a complementary regime in which state-space geometry carries the +resolving information. For \(D\) states sharing the energy \(E_0\), +\begin{equation} + \begin{aligned} + Z_E(t)&=\sum_{a=1}^{D}e^{-itE_a}=D e^{-itE_0},\\ + K_{E,\mathrm{raw}}(t)&=\frac{|Z_E(t)|^2}{D}=D , + \end{aligned} + \label{eq:energy-silence} +\end{equation} +and the ensemble-connected form factor is identically zero. These identities +exhaust the internal energy statistic while preserving the full projector and +its response over parameter space. + +The alternative studied here is geometric. +An isolated degenerate eigenspace defines a vector bundle over Hamiltonian +parameter space. +Its adiabatic transport is governed by the Wilczek--Zee connection and the +matrix-valued Berry curvature \cite{kato1950,berry1984,wilczekzee1984}; +the symmetric partner is the quantum metric +\cite{provostvallee1980,kolodrubetz2017}. +Adiabatic eigenstate deformations are already known to be sensitive probes of +integrability breaking \cite{pandey2020}, and the geometry of parameter space +can distinguish ergodic from integrable random-matrix regimes +\cite{sharipov2024}. +Most directly, Chen, Colin-Ellerin, Mamroud, and Papadodimas proposed +non-Abelian Berry curvature as an intrinsic chaos diagnostic for exactly +degenerate BPS microstates \cite{chen2026}. +Their contrast is between structured, often vanishing curvature for smooth +horizonless sectors and random-matrix-like curvature for supersymmetric black +hole microstates. + +We test that organizing principle in a purely condensed-matter fractional +topological manifold generated by a local frustration-free parent. +The manifold is the kernel of a positive semidefinite bosonic +fractional-quantum-Hall parent Hamiltonian. +Its degeneracy is exact and algebraic, and its projector is separated from the +complement by a gap. +This setting isolates the proposed geometric diagnostic from the special BPS +mechanism and makes five questions answerable: + +\begin{enumerate} + \item Does a curvature ramp survive when the energy form factor is exactly + silent? + \item Does that ramp distinguish random local tangents from structured + tangents at the same active rank? + \item Can energy chaos and projector-geometric chaos be varied independently? + \item Do gauge-invariant response-channel matrix elements approach a + covariance-matched Wick law along a genuine many-body sequence? + \item Can non-Abelian holonomy change inside a closed bundle while its + complete spectrum and Chern class remain fixed? +\end{enumerate} + +Our answers establish five complementary advances across spectrum, local +geometry, response tensors, topology, and finite-rank structure. +The metric-normalized curvature is a compression of a fixed signature matrix +by the row space of projector-to-complement response channels. +A Haar row space gives an exact finite-dimensional complex Jacobi point +process, allowing us to derive its connected form factor directly at the +finite rank used in the calculation. +The physical random-local-tangent ensemble follows this prediction over the +registered two-level window. +A complete momentum-resolved tangent family supplies a same-rank structured +reference with only a small number of distinct curvature eigenvalues. The +adjacent-gap ratio, connected form factor, and number variance place this +reference in a clearly resolved structured regime. + +The central evidence is causal rather than correlational. +We vary the Hamiltonian restricted to the degenerate fiber, +\(PHP\), from Poisson to GUE statistics while holding \(P\) and the +projector-to-complement channels fixed; the energy spectrum changes, whereas +the Berry curvature remains exactly invariant. +Separately, we interpolate the tangent channels from Fourier structured to +random local directions at fixed parent Hamiltonian. +Local Jacobi repulsion appears at a smaller interpolation strength than the +full registered form-factor window, while long-range number variance retains +microscopic memory. +The resulting order +\begin{equation} + \begin{aligned} + \text{local repulsion} + &\ \longrightarrow\ \text{two-level ramp}\\ + &\ \longrightarrow\ \text{long-range rigidity} + \end{aligned} + \label{eq:headline-hierarchy} +\end{equation} +is a measured hierarchy of geometric correlations. +The form-factor variable is a dimensionless Fourier scale of unfolded +curvature eigenvalues. Its connection to real-time dynamics defines a +separate and promising extension. + +Beyond eigenvalue correlations, fixed local operators expose a resolved +four-channel response cumulant. Its normalized residual decreases from +\(N=3\) to \(N=5\), demonstrating progressive Gaussianization together with +finite-size operator memory relative to the covariance-matched reference. +On the closed twist torus, a globally periodic ambient conjugation leaves +every energy and the first Chern class invariant while changing Wilson-loop +statistics reproducibly. +The resulting Wilson statistics occupy a structured regime distinct from CUE. +Together, the response tensor and Wilson sector map how local Jacobi behavior +coexists with higher and global microscopic structure. + +Finally, an independent rank sequence through \(D=\LargestRankVTwo\) resolves +a finite-dimensional effect unique to signature-compressed ensembles. +When the active rank exceeds the dimension \(M\) of either signature +polarization, exact atoms appear at \(\lambda=\pm1\). +We prove that these deterministic modes reduce the connected plateau from +one to \(k/D\), where \(k=2M-D\) is the continuous-sector dimension, while the +continuous complement retains the Jacobi ramp. +This resolves exact geometric modes and correlated continuous modes within +one curvature matrix. + +The paper is organized as follows. +Section~\ref{sec:ensembles} derives the projector response, signature +compression, finite-Jacobi kernel, and atom theorem. +Section~\ref{sec:physical} introduces the fractional topological manifold and +the structured same-rank comparison. +Section~\ref{sec:covariance} performs the independent spectral and geometric +interventions. +Section~\ref{sec:rank} gives the finite-rank atom form factors. +Section~\ref{sec:hierarchy} resolves the correlation hierarchy and its +statistical meaning. +Section~\ref{sec:matrix-topology} tests response-channel Wick factorization +and fixed-Chern Wilson holonomy. +Appendix~\ref{app:numerics} records the numerical and inference protocols. +Appendix~\ref{app:matrix-topology} gives the gauge-covariance, Wick, +Gram-reduction, and bundle-isomorphism derivations. diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/02-ensembles.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/02-ensembles.tex new file mode 100644 index 000000000..ef1463a4b --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/02-ensembles.tex @@ -0,0 +1,181 @@ +\section{Projector geometry and finite Jacobi theory} +\label{sec:ensembles} + +\subsection{Gauge-invariant response of a degenerate projector} + +Let \(H(\lambda)\) have an isolated \(D\)-dimensional eigenspace at energy +\(E_0\), with spectral projector \(P\), complement \(Q=1-P\), and reduced +resolvent +\begin{equation} + R=Q\bigl[Q(H-E_0)Q\bigr]^{-1}Q . + \label{eq:reduced-resolvent} +\end{equation} +For the tangent \(V_\mu=\partial_\mu H\), define the +projector-to-complement response channel +\begin{equation} + X_\mu=P V_\mu R . + \label{eq:channel} +\end{equation} +In bases of the degenerate fiber and its coupled complement, \(X_\mu\) is a +\(D\times M\) matrix. +Kato perturbation theory gives, for two real directions \(v,w\), +\begin{equation} + F_{vw}=i\left(X_vX_w^\dagger-X_wX_v^\dagger\right),\qquad + \Gamma=X_vX_v^\dagger+X_wX_w^\dagger . + \label{eq:curvature-metric} +\end{equation} +Here \(F_{vw}\) is Hermitian under our convention, and \(\Gamma\) is the +positive two-direction quantum metric. +Both transform by conjugation under a basis change within \(P\), so the +generalized eigenvalues of \((F_{vw},\Gamma)\) are gauge invariant. + +The raw curvature scale depends on tangent normalization and energy +denominators. +We remove it by restricting to the \(r=\rank\Gamma\) support and defining +\begin{equation} + \Omega=\Gamma^{-1/2}F_{vw}\Gamma^{-1/2}. + \label{eq:normalized-curvature-intro} +\end{equation} +This normalization is algebraic and model agnostic. +It converts the diagnostic into the relative orientation of the two response +channels. +With +\begin{equation} + B=\begin{pmatrix}X_v&X_w\end{pmatrix},\qquad + J=\begin{pmatrix}0&iI_M\\-iI_M&0\end{pmatrix}, + \label{eq:BJ} +\end{equation} +whitening gives +\begin{equation} + Y=\Gamma^{-1/2}B,\qquad + YY^\dagger=I_r,\qquad + \Omega=YJY^\dagger . + \label{eq:isometry-compression} +\end{equation} +Thus \(\Omega\) is a compression of a fixed matrix with \(M\) positive and +\(M\) negative eigenvalues. +Its statistics depend only on an \(r\)-plane in +\(\mathbb C^{2M}\), i.e., a point on a complex Grassmannian. +This observation makes the random-matrix reference precise: randomness is +assigned exclusively to the orientation of the whitened response row space. + +\subsection{Finite complex-Jacobi point process} + +If the row space of \(Y\) is Haar distributed, the continuously distributed +eigenvalues of Eq.~\eqref{eq:isometry-compression} form a complex Jacobi +ensemble \cite{zyczkowski2000,collins2005}. +For \(r\leq M\), all \(k=r\) levels lie in \((-1,1)\) and +\begin{equation} + p(\lambda_1,\ldots,\lambda_k)\propto + \prod_{aM\), the row space \(\cS\subset\mathbb C^{2M}\) must intersect both +\(M\)-dimensional eigenspaces \(\cH_\pm\) of \(J\): +\begin{equation} + \dim(\cS\cap\cH_\pm)\geq r+M-2M=r-M . + \label{eq:intersection-bound} +\end{equation} +Every vector in these intersections is an exact eigenvector of the +compression with eigenvalue \(\pm1\). +For a generic \(r\)-plane the bound is saturated, giving +\begin{equation} + m_+=m_-=r-M,\qquad k=2M-r. + \label{eq:atom-count} +\end{equation} +The atoms are deterministic under the Jacobi ensemble, so their connected +covariance is exactly zero. +If the full spectrum is normalized by its total rank \(r\), the exact +connected form factor is consequently +\begin{equation} + K_{J,c}^{\mathrm{full}}(\tau) + =\frac{k}{r}K_{J,c}^{(k)}(\tau),\qquad + K_{J,c}^{\mathrm{full}}(\infty)=\frac{k}{r}. + \label{eq:atom-plateau} +\end{equation} +This is an exact finite-dimensional plateau theorem. + +For completeness, the raw, non-unfolded form factor retains deterministic +interference with the atoms. +Writing +\begin{equation} + \begin{aligned} + Z_{\rm full}(s)&=Z_{\rm at}(s)+Z_{\rm int}(s),\\ + Z_{\rm at}(s)&=m_-e^{2\pi i s}+m_+e^{-2\pi i s}, + \end{aligned} + \label{eq:atom-partition} +\end{equation} +gives the exact decomposition +\begin{equation} + K_{\rm raw}^{\rm full} + =\frac{|Z_{\rm at}|^2}{r} + +\frac{2\,\mathrm{Re}\!\left[ + Z_{\rm at}^{*}\langle Z_{\rm int}\rangle\right]}{r} + +\frac{\langle|Z_{\rm int}|^2\rangle}{r}. + \label{eq:atom-raw-decomposition} +\end{equation} +Equations~\eqref{eq:atom-plateau} and +\eqref{eq:atom-raw-decomposition} distinguish deterministic geometry from +correlated fluctuations and provide two independent numerical closure tests. diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/03-physical-law.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/03-physical-law.tex new file mode 100644 index 000000000..b76171ce8 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/03-physical-law.tex @@ -0,0 +1,157 @@ +\section{Energy-silent fractional topological manifold} +\label{sec:physical} + +\subsection{Exact zero modes and tangent families} + +Our physical anchor is a bosonic Kapit--Mueller lattice parent projected to its +exactly flat lowest band \cite{kapitmueller2010}. +At particle number \(N=3\) and flux number \(n=10\), the projected contact +interaction is positive semidefinite and has an isolated zero-mode manifold +of dimension \(D=\PhysicalRank\). +The complement reached by local potentials has dimension +\(M=\PhysicalChannels\) per tangent direction. +The zero modes are lattice Laughlin quasihole states obeying the cyclic +\((1,2)\) exclusion rule \cite{laughlin1983,bernevighaldane2008,chenseidel2015}. +The numerical kernel width is \(5.78\times10^{-16}\), whereas the external +gap is \(0.106672\). + +This is an exact flat band generated by a purely condensed-matter, +frustration-free parent construction. Its kernel is algebraic and provides a +mechanism complementary to supercharge, index, and BPS-shortening mechanisms. +The open external gap makes \(P\), \(R\), and \(F_{vw}\) well defined, while +the exact internal degeneracy enforces Eq.~\eqref{eq:energy-silence}. + +We compare two local-potential tangent families at this same parent: +\begin{equation} + V[v]=\sum_{\bm x}v_{\bm x}\hat n_{\bm x},\qquad + \sum_{\bm x}v_{\bm x}=0. + \label{eq:local-potentials} +\end{equation} +The physical ensemble contains \(\PhysicalMatrices\) independent random +tangent pairs, divided before analysis into +\(12000/4000/4000\) training, validation, and test matrices. +Every result below uses the untouched \(\PhysicalTestMatrices\)-matrix test +set. + +The structured reference is the complete nonzero Fourier family on the +\(5\times5\) lattice. +For momentum \(\bm q\neq0\), take +\begin{equation} + v_{\bm x}^{(\bm q)}\propto\cos(\bm q\cdot\bm x),\qquad + w_{\bm x}^{(\bm q)}\propto\sin(\bm q\cdot\bm x), + \label{eq:fourier-control} +\end{equation} +normalized in the same many-body tangent metric as the random potentials. +All \(\StructuredMomenta\) nonzero momenta are enumerated, but +\(\bm q\) and \(-\bm q\) combine into \(\StructuredOrbits\) independent +orbit-level statistical units. +Each Fourier pair has the same active rank \(r=50\) as a random pair, yet its +curvature has at most ten distinct eigenvalues. +It therefore separates tangent structure from rank, gap, parent Hamiltonian, +and normalization. + +\subsection{Spectral silence and a geometric ramp} + +Figure~\ref{fig:spectral-silence} states the main contrast. +The exact energy form factor follows Eq.~\eqref{eq:energy-silence}: the raw +curve is \(D=\EnergyRawSFF\), and the connected curve is +\(\EnergyConnectedSFF\) for every \(t\). +The curvature spectrum, however, distinguishes structured Fourier tangents +from random local tangents at the same rank. + +\begin{figure*}[t] + \includegraphics[width=\textwidth]{figure_1_spectral_silence_v2.pdf} + \caption{ + \textbf{Exact degeneracy silences the energy spectrum, while projector + geometry retains correlated fluctuations.} + (a) For \(D=50\) exactly degenerate zero modes, the raw energy SFF is the + featureless constant \(D\), and the connected SFF vanishes identically. + The marks display the coincident energies of the exact manifold. + (b) Representative spectra of the metric-normalized curvature + \(\Omega\): structured Fourier tangents retain multiplets, whereas random + local tangents produce a resolved spectrum comparable to the Haar--Jacobi + reference. + (c) Connected curvature SFF of the \(\PhysicalTestMatrices\)-matrix physical + test ensemble and the exact finite-\(D\) Jacobi prediction from + Eq.~\eqref{eq:finite-jacobi-sff}. + The Fourier control is plotted against a separate right axis because it is + parametrically larger. + (d) The physical-minus-Jacobi residual has a simultaneous confidence band + compatible with zero over the registered interval + \(0.25\leq\tau\leq1.5\), while the inset shows that physical-minus-Haar number + variance becomes positive beyond \(L\simeq1\). + Here \(t\) in (a) is conjugate to energy, whereas \(\tau\) in (c,d) is only a + dimensionless Fourier variable for unfolded curvature eigenvalues. + } + \label{fig:spectral-silence} +\end{figure*} + +At \(\tau=0.5\), the connected curvature form factors are +\begin{equation} + \begin{aligned} + K_{F,c}^{\rm structured}&=\StructuredFormHalf,\\ + K_{F,c}^{\rm physical}&=\PhysicalFormHalf,\qquad + K_{J,c}^{(50)}=\JacobiFormHalf . + \end{aligned} + \label{eq:form-half} +\end{equation} +The physical value is thus close to the parameter-free finite-rank prediction, +whereas the structured value is almost an order of magnitude larger. +The agreement is assessed on the whole registered interval with simultaneous +bands; Eq.~\eqref{eq:form-half} provides one representative value. + +\subsection{Three-scale comparison} + +A robust geometric-chaos diagnostic combines three resolutions of the same +point process: +\begin{equation} + P(r)\quad\longleftrightarrow\quad + K_{F,c}(\tau)\quad\longleftrightarrow\quad + \Sigma^2(L), + \label{eq:falsification-triangle} +\end{equation} +testing nearest-neighbor repulsion, two-level correlations across Fourier +scales, and long-range counting fluctuations, respectively. +Related uses of non-energy spectra emphasize that a ramp probes eigenvalue +correlations rather than the physical identity of the operator +\cite{chenludwig2018}. + +\begin{figure*}[t] + \includegraphics[width=\textwidth]{figure_2_falsification_triangle_v2.pdf} + \caption{ + \textbf{Three-scale comparison for geometric chaos.} + (a) Adjacent-gap-ratio distribution of structured Fourier, physical + random-local, and independently sampled Haar--Jacobi curvatures. + Exact multiplets make the structured distribution singular near zero; the + physical and Jacobi bands overlap. + (b) Connected curvature SFF. + The empirical Haar curve and the analytic determinantal-kernel result are + independent references. + (c) Number variance after ensemble-CDF unfolding. + Random local tangents have Jacobi rigidity at short windows but a resolved + excess at long windows, whereas the structured control is nonuniversal + throughout. + Bands are simultaneous 95\% regions obtained from complete momentum orbits, + physical seed blocks, or complete random matrices, with each matrix retained + as one statistical unit. + } + \label{fig:falsification} +\end{figure*} + +Figure~\ref{fig:falsification} resolves two distinct geometric regimes. +First, the rank-\(50\) Fourier reference occupies the structured branch across +all three tests. Second, the physical curvature combines Jacobi local +statistics with covariance-deformed structure at broader scales. +Its one-point density has held-out \(L^1\) distance \(\DensityHaarLone\) from +Haar; a covariance-deformed row-space model reduces this to +\(\DensityCovLone\), a \(\DensityImprovementPercent\) improvement. +At long range, +\begin{equation} + \Sigma_{\rm phys}^2(8)-\Sigma_{\rm Haar}^2(8) + =\NumberResidualEight + \in[\NumberResidualEightLower,\NumberResidualEightUpper]. + \label{eq:number-residual} +\end{equation} +The resulting statement is correlation-scale resolved: Jacobi local +repulsion and a finite-\(D\) ramp coexist with covariance-deformed one-point +structure and long-range memory. diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/04-covariance-eth.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/04-covariance-eth.tex new file mode 100644 index 000000000..0b5d56560 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/04-covariance-eth.tex @@ -0,0 +1,117 @@ +\section{Independent spectral and geometric interventions} +\label{sec:covariance} + +The preceding comparison could still admit a weak interpretation: perhaps the +energy and curvature statistics are merely two correlated consequences of a +single hidden randomness. +We now intervene on the two blocks of a parameter-dependent Hamiltonian +separately. +The decomposition +\begin{equation} + H=PHP+PHQ+QHP+QHQ + \label{eq:block-decomposition} +\end{equation} +shows why this is possible. +Internal energy spacings are controlled by \(PHP\), whereas the projector +response in Eq.~\eqref{eq:channel} is controlled by +\(P(\partial_\mu H)Q\), the complement resolvent, and their adjoints. +These are logically distinct data. + +\subsection{Changing energy statistics at fixed projector} + +For the spectral intervention we use an effective \(D\times D\) fiber +Hamiltonian +\begin{equation} + h_\alpha=\sqrt{1-\alpha^2}\,h_{\rm P}+\alpha h_{\rm GUE}, + \qquad 0\leq\alpha\leq1 , + \label{eq:spectral-interpolation} +\end{equation} +where \(h_{\rm P}\) has independent exponential spacings and +\(h_{\rm GUE}\) is an independent complex Gaussian Hermitian matrix. +Both are centered and matched in Hilbert--Schmidt norm before interpolation. +We embed \(0.1h_\alpha\) in a fixed target block and place a diagonal +complement between energies \(2\) and \(3\). +The external gap stays open throughout, and diagonalization verifies +\begin{equation} + \max_\alpha\|P_\alpha-P_0\|_F=1.15\times10^{-14}. + \label{eq:projector-invariance} +\end{equation} +The tangent channels and a reference curvature spectrum are held fixed. +This effective causal control supplies a clean spectral axis; a local +microscopic realization defines a complementary future program. + +Across \(\SpectralSamplesPerPoint\) matrices per value of \(\alpha\), the +energy adjacent-gap ratio changes from +\begin{equation} + \langle r_E\rangle_{\alpha=0}=\PoissonEndpointRatio,\qquad + \langle r_E\rangle_{\alpha=1}=\GUEEndpointRatio , + \label{eq:energy-axis} +\end{equation} +while the stored curvature spectrum is unchanged to machine precision. +Thus conventional spectral chaos evolves at exactly fixed target-projector +geometry. + +\subsection{Changing geometry at fixed exactly degenerate parent} + +The complementary intervention leaves the Kapit--Mueller parent, its exact +zero energy, its projector, and its external gap fixed. +For each structured Fourier direction \(v_{\bm q}\) and an independent random +local direction \(\eta_v\), define +\begin{equation} + \begin{aligned} + \widetilde v_g&={\cal N}_G\!\left[ + \sqrt{1-g}\,v_{\bm q}+\sqrt g\,\eta_v\right],\\ + \widetilde w_g&={\cal N}_G\!\left[ + \sqrt{1-g}\,w_{\bm q}+\sqrt g\,\eta_w\right], + \end{aligned} + \label{eq:geometric-interpolation} +\end{equation} +where \({\cal N}_G\) mean-centers and normalizes in the physical tangent +Gram matrix. +The square-root weights make \(g\) a variance fraction before the final +normalization. +We sample \(\GeometricSamplesPerPoint\) independent tangent pairs at each +positive registered \(g\), maintaining active rank \(50\) throughout. + +\begin{figure*}[t] + \includegraphics[width=\textwidth]{figure_3_independent_channels_v2.pdf} + \caption{ + \textbf{Energy chaos and projector-geometric chaos are independent + channels.} + (a) Mean energy adjacent-gap ratio under the effective fixed-projector + interpolation in Eq.~\eqref{eq:spectral-interpolation}; it crosses from + Poisson to the GUE/Haar interval. + (b) The target-projector distance remains at diagonalization roundoff and + the supplied curvature spectrum is exactly invariant. + (c) At fixed exactly degenerate parent, scrambling only the tangent channels + in Eq.~\eqref{eq:geometric-interpolation} changes the curvature gap ratio. + Its simultaneous interval first overlaps the Haar--Jacobi interval at + \(g=\GeometricLocalOnset\); the first registered nontrivial SFF window occurs + at \(g=\GeometricRampOnset\). + (d) Logical \(2\times2\) classification. + Spectral and geometric chaos can occur separately or together; the original + topological flat band occupies the energy-silent/geometrically chaotic + quadrant. + Bands are 95\% simultaneous intervals over the registered interpolation + grids. + } + \label{fig:independent-channels} +\end{figure*} + +Figure~\ref{fig:independent-channels} gives the operational separation. +Changing \(PHP\) moves horizontally in panel (d) at fixed +\(P(\partial H)Q\). Changing local tangent structure moves vertically at +fixed exactly degenerate parent. Consequently, a Jacobi-like curvature +spectrum directly diagnoses the embedding and response of the degenerate +subspace. +It diagnoses how the degenerate subspace is embedded in and responds to its +surrounding Hilbert space. + +The intervention also supplies an ordering test. +The mean curvature gap-ratio interval first overlaps the Haar reference at +\(g=\GeometricLocalOnset\), whereas compatibility with the exact finite-\(D\) +SFF over a registered nonzero \(\tau\) interval first occurs at +\(g=\GeometricRampOnset\). +These onsets are confidence-set definitions on a discrete grid. They +demonstrate that local repulsion is established before the broader two-level +ramp under controlled tangent interpolation. diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/05-rank-crossover.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/05-rank-crossover.tex new file mode 100644 index 000000000..e0bd644a6 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/05-rank-crossover.tex @@ -0,0 +1,79 @@ +\section{Exact geometric modes and the Jacobi plateau} +\label{sec:rank} + +The \(D=50\) lattice calculation lies in the atom-free regime \(DM\) contains a finite mass fixed at +\(\pm1\), while the atom-stripped sector displays Jacobi repulsion and its +finite-rank ramp. +The exact modes record a dimension-theorem intersection of the accessible row +space with the two polarizations of \(J\); the ramp probes correlations in the +remaining orientation. +Exact geometry and chaotic geometry are therefore compatible within +orthogonal sectors of the same degenerate manifold. + +The algebraic atom count also strengthens the analysis. Counts are fixed from +\((D,M)\) before eigenvalues are examined, their numerical positions are +audited afterward, and both full and continuous-sector normalizations are +reported. diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/06-thouless-hierarchy.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/06-thouless-hierarchy.tex new file mode 100644 index 000000000..9679ebf02 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/06-thouless-hierarchy.tex @@ -0,0 +1,87 @@ +\section{A hierarchy of geometric correlation scales} +\label{sec:hierarchy} + +The intervention data allow a scale-resolved statement stronger than a +single endpoint comparison. +For each \(g\), we subtract the exact finite-\(D\) Jacobi curve and test the +entire residual process with a simultaneous band. +For the physical ensemble we repeat the same procedure using eight +independently seeded blocks. +Long-range rigidity is tested independently through the number variance +\begin{equation} + \Sigma^2(L)= + \left\langle\bigl[N_\xi(x,L)-L\bigr]^2\right\rangle , + \label{eq:number-variance} +\end{equation} +where \(N_\xi(x,L)\) counts unfolded curvature levels in a sliding interval of +length \(L\). + +\begin{figure*}[t] + \includegraphics[width=\textwidth]{figure_4_geometric_hierarchy_v2.pdf} + \caption{ + \textbf{Controlled hierarchy from structured to random projector geometry.} + (a) Residual connected SFF + \(K_{F,c}(\tau;g)-K_{J,c}^{(50)}(\tau)\) along the tangent-scrambling + interpolation. + (b) Root-mean-square residual over the preregistered range + \(0.25\leq\tau\leq1.5\). + The local adjacent-gap statistic reaches the Haar interval at + \(g=\GeometricLocalOnset\), while the first nontrivial registered SFF + compatibility window occurs at \(g=\GeometricRampOnset\). + (c) Physical random-local-tangent residual with a simultaneous 95\% band; + it is compatible with the exact finite-\(D\) curve throughout the registered + range. + (d) Physical-minus-Haar number variance. + Short windows are compatible through \(L=\NumberVarianceExtent\), but the + positive long-range residual is resolved thereafter. + Onset lines summarize confidence sets on the sampled grids. + } + \label{fig:geometric-hierarchy} +\end{figure*} + +Three conclusions follow from Fig.~\ref{fig:geometric-hierarchy}. +First, a small interpolation away from Fourier structure generates local +level repulsion, while the two-level correlation curve becomes active at a +larger interpolation strength. +The registered local and ramp onsets are +\begin{equation} + g_{\rm local}=\GeometricLocalOnset,\qquad + g_{\rm ramp}=\GeometricRampOnset . + \label{eq:g-onsets} +\end{equation} +Second, at the physical random-local endpoint the residual band contains zero +for every registered \(\tau\in[0.25,1.5]\). +This is a curve-level finite-\(D\) test; it is more restrictive than matching +the value or slope at one point. + +Third, long-range rigidity defines an additional scale. The physical number +variance follows the Haar reference through \(L=\NumberVarianceExtent\), and +at \(L=8\) Eq.~\eqref{eq:number-residual} resolves a positive simultaneous +interval. +The curvature point process therefore loses information in the ordered +sequence +\begin{equation} + \begin{aligned} + \text{local }P(r) + &\ \prec\ \text{finite-\(D\) SFF ramp}\\ + &\ \prec\ \text{long-range }\Sigma^2(L) + \end{aligned} + \label{eq:geometric-correlation-hierarchy} +\end{equation} +where \(A\prec B\) means that \(A\) becomes compatible with the invariant +reference at a weaker scrambling or shorter correlation scale. + +Equation~\eqref{eq:geometric-correlation-hierarchy} defines a geometric +Thouless hierarchy in the precise sense of confidence-resolved correlation +lengths in an unfolded curvature spectrum. Mapping these geometric scales to +transport, scrambling, and real-time diffusion is a promising dynamical +extension. + +Our geometric-ETH statement is operational and complementary to +energy-resolved ETH: after removal of a deterministic +metric envelope, local and intermediate-range correlations of the +projector-response spectrum approach those of a finite invariant point +process. +The held-out one-point covariance improvement and the surviving number +variance show that higher Grassmannian information remains measurable. The +result is covariance-deformed geometric ergodicity. diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/07-conclusion.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/07-conclusion.tex new file mode 100644 index 000000000..dfe6569e3 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/07-conclusion.tex @@ -0,0 +1,75 @@ +\section{Discussion} +\label{sec:conclusion} + +The central result can be stated directly: +\begin{quote} +\emph{Exact degeneracy makes the energy spectrum silent, while non-Abelian +projector geometry reveals a random-matrix correlation ramp, a measurable +matrix-element cumulant, and deformable global holonomy inside one fixed +Chern class.} +\end{quote} +Each clause has a dedicated test. Equation~\eqref{eq:energy-silence} proves +spectral flatness. The finite-Jacobi kernel supplies the geometric reference +curve. The full-rank Fourier family resolves structured and random local +tangents at equal active rank. The two blockwise interventions establish +independent spectral and geometric axes. The four-channel residual promotes +the analysis from curvature eigenvalues to invariant response maps. The +closed twist torus separates determinant topology from relative Wilson +transport while preserving every energy. + +The resulting picture is sharper than the statement that Berry curvature is +a random matrix. The physical one-point density is covariance deformed, +long-range counting fluctuations retain microscopic information, and exact +boundary atoms can occupy a macroscopic fraction of the spectrum. Local +finite-Jacobi universality, progressive response-channel Gaussianization, and +structured global holonomy therefore form three ordered geometric scales. +The analytic atom theorem adds a fourth scale by separating deterministic +geometric modes from the correlated continuous sector. + +The relation to Chen \emph{et al.}~\cite{chen2026} is direct at the level of +the diagnostic and complementary at the level of mechanism. Their proposal +addresses exactly degenerate BPS sectors, supersymmetric black-hole +microstates, smooth horizonless geometries, and Chern topology over the +\(\mathcal N=2\) SYK moduli space. Our frustration-free condensed-matter +mechanism adds the following capabilities: +\begin{enumerate} + \item a parameter-free finite-\(D\) Jacobi prediction for metric-normalized + curvature; + \item a same-parent, same-rank structured tangent reference; + \item causal separation of \(PHP\) from \(P(\partial H)Q\); + \item an exact boundary-atom correction to the connected plateau; + \item a gauge-invariant four-channel test on a genuine \(N=3,4,5\) sequence; + and + \item a closed-surface separation of fixed Chern topology and deformable + Wilson holonomy. +\end{enumerate} +The common principle is that chaos can be encoded in how a degenerate state +bundle moves over coupling space even when every state shares one energy. + +The current calculation establishes a precise finite-size scope. The +fixed-rank sequence quantifies curvature scaling through \(D=800\). The +fixed-projector Poisson-to-GUE path is a controlled block intervention. The +curvature form factor is treated as a geometric Fourier scale. The +many-body response sequence reaches \(N=5\), where the connected four-channel +component remains resolved. The Wilson family is an exact isospectral bundle +construction whose final statistics define a structured class distinct from +CUE. These statements provide clean starting points for larger systems, +local microscopic deformations, and dynamical comparisons. + +The next analytic target is the observed decrease of \(R_4\). An extension +through \(N=6\), combined with a locality-based derivation, can distinguish an +emergent Wick law from a deformed fixed tensor. A second exact-degeneracy +mechanism can establish cross-model universality. On the topological side, +microscopic local deformations that preserve an exact kernel can test the +fixed-\(C_1\), structured-Wilson branch beyond the controlled ambient orbit. +A weak lifted-band or driven calculation can then connect the geometric +hierarchy to real-time dynamics. + +For exactly degenerate quantum matter, the practical prescription is clear. +Compute the isolated projector response, whiten curvature by its quantum +metric, compare the continuous spectrum with the exact finite-rank Jacobi +process, test invariant higher response cumulants, integrate determinant +curvature on a closed surface, retain the relative Wilson spectrum, and map +the scale at which each reference becomes active. Under this protocol, +degeneracy becomes a resource: it isolates a geometric channel of quantum +chaos with local, operator-level, and topological resolution. diff --git a/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/08-matrix-elements-topology.tex b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/08-matrix-elements-topology.tex new file mode 100644 index 000000000..2d1a7600c --- /dev/null +++ b/tracks/mps/solutions/Wander-276/research/overleaf_sync/geometric_eth_large_scale/sections/08-matrix-elements-topology.tex @@ -0,0 +1,53 @@ +\section{Matrix-element geometry and fixed-Chern holonomy} +\label{sec:matrix-topology} + +The curvature spectrum establishes a geometric correlation hierarchy. We now resolve its matrix-element mechanism and its relation to the topology of the full bundle while preserving the exact zero modes. + +\subsection{A gauge-invariant matrix-element test} + +Fixed local operators supply an independent test of Gaussian response statistics, because Gaussian tangent coefficients would make \(X[V]\) Gaussian by linearity. We use eight simple mean-zero local density operators in each panel and form the resolvent-dressed maps \(X_\mu=R_QQV_\mu P\). After whitening their measured label covariance, the primary observable is the invariant tensor in Eq.~\eqref{eq:invariant-four-channel-tensor}. Its two covariance-matched Gaussian contractions are derived in Appendix~\ref{app:matrix-topology}; generalized ETH likewise elevates higher matrix-element correlations beyond entrywise statistics \cite{foinikurchan2019,pappalardi2022}. + +The finite-size reference is a distribution of \(R_4\) at matched \((D,M,m)\). For every physical panel we generate Gaussian response tensors with the measured target and external covariance spectra, whiten them by the same algorithm, and compare the normalized residual in Eq.~\eqref{eq:wick-residual-appendix}. Complete panels are the resampling units. Independent target- and complement-frame rotations change the raw entries while \(T\), \(T^{\rm Wick}\), and \(R_4\) remain invariant. + +\begin{figure*}[t] + \includegraphics[width=\textwidth]{figure_6_wick_factorization_v3.pdf} + \caption{\textbf{Gauge-invariant four-channel Wick test on a genuine many-body sequence.} (a) Fixed-two-quasihole manifolds \((N,n_\phi,D)=(3,8,16),(4,10,25),(5,12,36)\), including the external gap and full Hilbert-space dimension. (b) Physical local-density and structured Fourier residuals against covariance-matched finite-\((D,M,m)\) Gaussian intervals. (c) The physical excess over the Gaussian median decreases with \(N\) and remains resolved at \(N=5\). (d) Measured target anisotropy and effective external dimension entering the two Wick coefficients. Intervals resample 24 complete operator panels or 2000 complete Gaussian tensors, with every matrix retained as one observation.} + \label{fig:wick-factorization} +\end{figure*} + +Figure~\ref{fig:wick-factorization} uses the true sequence \(n_\phi=2N+2\). The Hilbert space reaches \(\LargestManyBodyDimension\) states and the zero-mode rank reaches \(D=\LargestManyBodyRank\). The median physical residual decreases from \(0.37093\) to \(0.24715\) to \(\LargestNRFour\), while the matched Gaussian median decreases from \(0.21708\) to \(0.14638\) to \(\LargestGaussianRFour\). At the largest size the physical excess is \(\LargestRFourExcess\), resolved relative to the Gaussian interval \([\LargestGaussianRFourLow,\LargestGaussianRFourHigh]\). + +\MatrixElementBranchText\ This selects the registered branch \texttt{\MatrixElementBranch}: progressive Gaussianization with a resolved connected operator-channel component. The \(N=3,4,5\) sequence supplies the finite-size baseline for an \(N=6\) scaling test. + +\subsection{A closed surface at fixed spectrum and Chern class} + +For the topology test, the parameter space is the complete twist torus \(T^2_{\theta_x,\theta_y}\). Starting from the physical projected-contact parent, define +\begin{equation} + \begin{aligned} + \mathcal U_g(\theta) + &=e^{ig\sin\theta_xG_x}e^{ig\sin\theta_yG_y},\\ + H_g(\theta) + &=\mathcal U_g(\theta)H_0(\theta)\mathcal U_g^\dagger(\theta), + \end{aligned} + \label{eq:main-isospectral-orbit} +\end{equation} +where \(G_x,G_y\) are deterministic nearest-neighbor Hermitian one-body generators. The bosonic lift is globally periodic. Hence the complete spectrum and gap are identical for every \(g\), and \(\mathcal U_g\) is a bundle isomorphism that preserves \(C_1\). Nevertheless the connection acquires the projected one-form in Eq.~\eqref{eq:connection-shift}, so non-Abelian Wilson holonomy may change. + +Polar-unitary links and plaquette products implement the lattice connection \cite{fukui2005}. We retain determinant topology separately from relative Wilson eigenphases. The circular adjacent-gap ratio is branch free, and the Wilson form factor +\begin{equation} + K_W(k)=\frac{1}{D}\left|\Tr W^k\right|^2 + \label{eq:wilson-form-factor} +\end{equation} +is invariant under a common phase. Both are compared with 10000 independently sampled CUE matrices at the same \(D\). Random local \(U(D)\) frame gauges provide dedicated invariance tests and remain separate from physical scrambling. + +\begin{figure*}[t] + \includegraphics[width=\textwidth]{figure_7_topological_holonomy_v3.pdf} + \caption{\textbf{Fixed Chern topology with deformed non-Abelian Wilson holonomy.} (a) The periodic ambient orbit leaves \(C_1=6,10\) and the external gaps fixed for \(N=3,4\). (b) For \(N=4\), accumulated branch-resolved determinant flux has winding ten at both endpoints, while its local distribution over the transverse twist changes. (c) Seed-cluster intervals of the Wilson circular gap ratio move significantly with \(g\) and occupy a structured range distinct from CUE; a commuting-generator path supplies the reference. (d) The \(N=4\) Wilson SFF at \(g=0\), \(g=1\), and the commuting endpoint compared with the independently sampled CUE mean and simultaneous band. Eight complete noncommuting generator seeds are resampled as clusters.} + \label{fig:topological-holonomy} +\end{figure*} + +The accepted \(\TopologyPrimaryMesh\times\TopologyPrimaryMesh\) and \(\TopologyConvergenceMesh\times\TopologyConvergenceMesh\) meshes give \(C_1=\TopologyNThreeChern\) for \(N=3\) and \(C_1=\TopologyNFourChern\) for \(N=4\), with external gaps \(\TopologyNThreeGap\) and \(\TopologyNFourGap\). The minimum accepted determinant-branch margin is \(\TopologyMinimumBranchMargin\), the minimum neighboring-overlap singular value is \(\TopologyMinimumOverlap\), and the maximum random-gauge Wilson-phase error is \(\TopologyGaugeError\). A retained \(12\times12\) preflight identifies a branch alias for one \(N=4,g=1\) seed and motivates the converged \(16/20\) mesh pair. + +Under noncommuting generators, the seed-cluster confidence interval for the change in \(\langle r_W\rangle\) is \([\TopologyNThreeGapChangeLow,\TopologyNThreeGapChangeHigh]\) at \(N=3\) and \([\TopologyNFourGapChangeLow,\TopologyNFourGapChangeHigh]\) at \(N=4\). Both intervals are strictly positive. At \(g=1\), the medians \(\TopologyNThreeFinalGapRatio\) and \(\TopologyNFourFinalGapRatio\) occupy a structured range below the CUE medians \(\TopologyNThreeCUERatio\) and \(\TopologyNFourCUERatio\), accompanied by a distinct Wilson SFF. + +\TopologyBranchText\ The selected branch is therefore \texttt{\TopologyBranch}: fixed determinant-bundle topology coexists with tunably deformed, structured non-Abelian holonomy. Together with Fig.~\ref{fig:wick-factorization}, it identifies two complementary memories beyond curvature eigenvalue repulsion: a resolved four-channel cumulant and a structured Wilson sector distinct from CUE. diff --git a/tracks/mps/solutions/Wander-276/verify.sh b/tracks/mps/solutions/Wander-276/verify.sh new file mode 100755 index 000000000..e90521c86 --- /dev/null +++ b/tracks/mps/solutions/Wander-276/verify.sh @@ -0,0 +1,16 @@ +#!/usr/bin/env bash +set -euo pipefail + +SOLUTION_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "${SOLUTION_DIR}/research/01_task_folder/task_05/script" +PYTHONDONTWRITEBYTECODE=1 bash run_quick_verify_v1.sh + +V7_TESTS="$(find tests -type f -name '*v7.py' -print | sort)" +if [[ -z "${V7_TESTS}" ]]; then + echo "No v7 tests found" >&2 + exit 1 +fi +# Test paths are repository-controlled and contain no whitespace. +PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=. pytest -q ${V7_TESTS} +PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=. python verify_susy_hodge_delivery_v7.py +PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=. python verify_susy_hodge_manuscript_v7.py