Gold / Method: Tuli99 dual-engine Hubbard ED with reproducibility package

#59
by Tuli99 - opened
Files changed (39) hide show
  1. methods/Tuli99/LICENSE +24 -0
  2. methods/Tuli99/NOTICE.md +21 -0
  3. methods/Tuli99/PROVENANCE.md +53 -0
  4. methods/Tuli99/README.md +126 -0
  5. methods/Tuli99/SHA256SUMS.txt +30 -0
  6. methods/Tuli99/Tuli99_OSC_Gold_2026-10-21.zip +3 -0
  7. methods/Tuli99/Tuli99_OSC_Gold_2026-10-21.zip.sha256 +1 -0
  8. methods/Tuli99/method_ed/ad_table.py +137 -0
  9. methods/Tuli99/method_ed/ad_table_own.json +646 -0
  10. methods/Tuli99/method_ed/audit_results.py +87 -0
  11. methods/Tuli99/method_ed/continuation_checks.json +17 -0
  12. methods/Tuli99/method_ed/ed_core.py +407 -0
  13. methods/Tuli99/method_ed/ed_sym.py +465 -0
  14. methods/Tuli99/method_ed/fresh_target.json +53 -0
  15. methods/Tuli99/method_ed/material_inputs.json +72 -0
  16. methods/Tuli99/method_ed/reproduce_target.py +77 -0
  17. methods/Tuli99/method_ed/requirements.txt +2 -0
  18. methods/Tuli99/method_ed/results_4x4.json +178 -0
  19. methods/Tuli99/method_ed/run_4x4.py +93 -0
  20. methods/Tuli99/method_ed/run_all.py +65 -0
  21. methods/Tuli99/method_ed/run_full.sh +7 -0
  22. methods/Tuli99/method_ed/run_submission.ps1 +11 -0
  23. methods/Tuli99/method_ed/run_submission.sh +7 -0
  24. methods/Tuli99/method_ed/run_sym_4x4.py +89 -0
  25. methods/Tuli99/method_ed/submit_gold.py +123 -0
  26. methods/Tuli99/method_ed/test_sym.py +268 -0
  27. methods/Tuli99/method_ed/validate_ed.py +145 -0
  28. methods/Tuli99/method_ed/validation_report.json +310 -0
  29. methods/Tuli99/submission_gold_OSC-00747.json +41 -0
  30. methods/Tuli99/submission_gold_OSC-00754.json +41 -0
  31. methods/Tuli99/submission_gold_OSC-01665.json +41 -0
  32. methods/Tuli99/validation/multisize_ED_table_kuku.md +55 -0
  33. methods/Tuli99/verification/ISOLATED_REPRODUCTION.md +26 -0
  34. methods/Tuli99/verification/isolated_reproduction.json +74 -0
  35. methods/Tuli99/verification/run_submission.log +17 -0
  36. methods/Tuli99/verify_manifest.py +20 -0
  37. submissions/Tuli99_gold_OSC-00747.json +41 -0
  38. submissions/Tuli99_gold_OSC-00754.json +41 -0
  39. submissions/Tuli99_gold_OSC-01665.json +41 -0
methods/Tuli99/LICENSE ADDED
@@ -0,0 +1,24 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ MIT License
2
+
3
+ Copyright (c) 2026 Tuli99
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of the original method software and associated original documentation files
7
+ (the "Software"), to deal in the Software without restriction, including
8
+ without limitation the rights to use, copy, modify, merge, publish, distribute,
9
+ sublicense, and/or sell copies of the Software, and to permit persons to whom
10
+ the Software is furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
22
+
23
+ This license excludes third-party data, reference tables and documentation;
24
+ their CC-BY-NC 4.0 terms and attribution are set out in NOTICE.md.
methods/Tuli99/NOTICE.md ADDED
@@ -0,0 +1,21 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Attribution and scope
2
+
3
+ Original two-engine ED implementation and accompanying reproduction scripts:
4
+ Tuli99, 2026 (MIT license; see LICENSE).
5
+
6
+ The independent reference table `validation/multisize_ED_table_kuku.md` was prepared
7
+ by **team ku-ku, 1 October 2026** and published by FINAL-Bench. It is included
8
+ unaltered with attribution under the dataset's CC-BY-NC 4.0 terms. These are
9
+ independent reference values, not original results claimed by this entrant.
10
+
11
+ Material parameters, scoring metadata and PROVENANCE.md originate from
12
+ **FINAL-Bench — Open Superconductor Challenge**, derived from the **Computational
13
+ 2D Materials Database (C2DB)**. Those data and documentation remain subject to
14
+ **CC-BY-NC 4.0**, and are not relicensed under MIT.
15
+
16
+ Please cite S. Haastrup et al., *2D Materials* 5, 042002 (2018), and
17
+ M. N. Gjerding et al., *2D Materials* 8, 044002 (2021), as stated in PROVENANCE.md.
18
+ The package is prepared for the non-commercial academic challenge.
19
+
20
+ Official source: https://huggingface.co/datasets/FINAL-Bench/OSC-Superconductor
21
+ License: https://creativecommons.org/licenses/by-nc/4.0/
methods/Tuli99/PROVENANCE.md ADDED
@@ -0,0 +1,53 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Provenance & License
2
+
3
+ ## Source data — C2DB
4
+
5
+ The crystal structures and the base electronic-structure properties in OSC are derived from the
6
+ **Computational 2D Materials Database (C2DB)**, Technical University of Denmark.
7
+
8
+ - **License: Creative Commons Attribution-NonCommercial 4.0 International (CC-BY-NC 4.0).**
9
+ https://creativecommons.org/licenses/by-nc/4.0/
10
+ - C2DB material pages: https://c2db.fysik.dtu.dk/
11
+
12
+ Please cite C2DB when using OSC:
13
+ > S. Haastrup et al., *The Computational 2D Materials Database: high-throughput modeling and
14
+ > discovery of atomically thin crystals*, 2D Materials 5, 042002 (2018); and
15
+ > M. N. Gjerding et al., 2D Materials 8, 044002 (2021).
16
+
17
+ ## What OSC adds (and how)
18
+
19
+ From each C2DB structure, OSC computes — with the open scripts in `instrument/` and the
20
+ organizer pipeline published in `pipeline/` — a single-band effective Hubbard model:
21
+
22
+ - **N(E_F)**: Gaussian-broadened density of states at the Fermi level from a QE calculation
23
+ (states/eV/atom). Grid: the SCF k-mesh (coarse) for the active set, refined on a dense NSCF
24
+ grid for finalists.
25
+ - **filling (δ)**: occupation of the band crossing E_F, weighted over the k-mesh, giving the
26
+ doping the many-body solver is run at.
27
+ - **t**: nearest-neighbour hopping from the single active-band width (t = W_band / z).
28
+ - **U/t = 8**: a documented correlated-regime convention (control parameter, cRPA pending).
29
+
30
+ These derived quantities are **also released under CC-BY-NC 4.0**, consistent with the source.
31
+
32
+ ## Non-commercial scope of the challenge
33
+
34
+ Because the source data is CC-BY-NC 4.0, **OSC is a non-commercial, academic open-science
35
+ challenge**:
36
+
37
+ - The data and derived models may be used for research and education, **not for commercial
38
+ purposes**, with attribution to C2DB.
39
+ - Prizes are **research awards** (recognition + co-authorship + a token honorarium), not a sale
40
+ or commercial licensing of the data.
41
+ - Participants retain the rights to their own methods and code; winners share reproducible code
42
+ under an open contributor license.
43
+
44
+ If you intend any commercial use of the underlying materials data, obtain permission from C2DB
45
+ directly — OSC does not and cannot grant commercial rights to C2DB-derived data.
46
+
47
+ ## Verification engine
48
+
49
+ The precise strongly-correlated solver used to set the *verified* scores is operated by the
50
+ organizers and is not redistributed. Its **inputs** (per-material t, U, N(E_F), filling) and its
51
+ **outputs** (the d-wave amplitude A_d(δ) per filling) are fully published here, so every verified
52
+ score is reproducible in its construction; only the internal solver implementation is withheld
53
+ to keep the ranking hard to game.
methods/Tuli99/README.md ADDED
@@ -0,0 +1,126 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Tuli99 — OSC Gold / Method reproducibility package
2
+
3
+ Prepared 21 October 2026 for FINAL-Bench's Open Superconductor Challenge.
4
+ Entrant: **Tuli99**. Method: independently implemented finite-cluster Hubbard ED,
5
+ with full-sector and translation-projected engines using NumPy/SciPy.
6
+
7
+ The submitted point is **3x4, N_up=N_down=5, total electrons=10, delta=1/6,
8
+ t=1, U=8**, periodic boundaries. The d-wave correlator in organizer normalization
9
+ is **A_d=0.0568266126268765** at the largest minimum-image distance R=sqrt(5).
10
+ The three independent Lanczos starts give the same result within 7e-16;
11
+ the largest eigenvector residual is below 1.5e-13.
12
+
13
+ | OSC ID | C2DB material | Formula | N(E_F) | Claimed index | Canonical index |
14
+ |---|---|---|---:|---:|---:|
15
+ | OSC-01665 | 2CuNiI3-1 | Cu2I6Ni2 | 1.58283 | 26.984 | 26.444 |
16
+ | OSC-00754 | 2NiTe-5 | Ni2Te2 | 1.44940 | 24.709 | 24.215 |
17
+ | OSC-00747 | 2NiS-5 | Ni2S2 | 1.40205 | 23.902 | 23.424 |
18
+
19
+ Index = N(E_F) * max(0,A_d) * 300. The material parameters and solver_delta=0.1667
20
+ are frozen from the official table retrieved on 21 October 2026. This is the
21
+ published discrete solver filling rounded to four decimals; we do not claim an
22
+ exact match to the continuous DFT band filling. All three submissions use the
23
+ same dimensionless Hubbard model and filling, so their material dependence here
24
+ is N(E_F) and the supplied energy scale, not three separate ab initio solvers.
25
+
26
+ ## Reproduce the submitted number from scratch
27
+
28
+ Use Python 3.10 with `numpy==1.26.4` and `scipy==1.15.3` (recorded original
29
+ environment). The calculation is CPU-only. It requires no credentials or network.
30
+ Install requirements in your own environment if needed; none are auto-installed.
31
+
32
+ From `method_ed/`:
33
+
34
+ ```sh
35
+ bash run_submission.sh
36
+ # or
37
+ python run_all.py --mode submission --author Tuli99
38
+ ```
39
+
40
+ On Windows:
41
+
42
+ ```powershell
43
+ .\run_submission.ps1 -Python 'D:\anaconda\envs\ml\python.exe'
44
+ ```
45
+
46
+ This recomputes the 627,264-dimensional submitted point three times using seeds
47
+ 20260317, 104729, 271828, records residuals and orthogonality, audits the supplied
48
+ reference records, and regenerates all three gold JSON files. It does not load
49
+ cached eigenvalues to obtain the submitted A_d. Measured runtime for the three
50
+ solves was about 6.3 minutes on the submission machine; other systems may differ.
51
+
52
+ ## Inspect the full validation evidence
53
+
54
+ ```sh
55
+ python run_all.py --mode cached --author Tuli99
56
+ ```
57
+
58
+ This mode **only audits recorded evidence**: 27/27 points against the published
59
+ team ku-ku independent ED table (19 small-cluster points plus 4x4 N_up=1..8),
60
+ four directly computed 4x4 particle-hole mirrors, and the curve selection rule.
61
+ It is not a fresh reproduction of the expensive 4x4 calculation.
62
+ `validation_report.json` contains every numerical difference and pass/fail result.
63
+ `fresh_target.json` records the independently rerun submission point.
64
+ `continuation_checks.json` distinguishes tests rerun in this continuation from
65
+ previous production results retained and audited here.
66
+
67
+ Translation-engine tests L1 through L4 were rerun in this continuation and passed:
68
+ group action, representatives, projector completeness (error <=4.0e-16), and
69
+ block-spectrum/full-spectrum agreement (error <=4.2e-13). L5's fourteen correlator
70
+ comparisons are from the previous run; they can be rerun with `python test_sym.py L5`.
71
+
72
+ ## Rebuild the complete table without existing ED caches
73
+
74
+ ```sh
75
+ bash run_full.sh
76
+ # or
77
+ python run_all.py --mode full --author Tuli99
78
+ ```
79
+
80
+ This creates a separate `reproduction_runs/<timestamp>/` tree, copies only sources
81
+ and frozen material inputs, runs both validation suites, computes 4x4 N_up=1..8
82
+ and 12..15 through the correct engine, rebuilds the smaller-cluster curve, reruns
83
+ the submission point, and audits all results. It never treats existing 4x4 JSON
84
+ as fresh output. Expect many hours; the recorded symmetry-engine production run
85
+ alone took approximately 6.4 hours. A 32 GB machine was used for the original run;
86
+ peak memory depends on numerical-library versions and allocation behavior.
87
+
88
+ ## Conventions and limits
89
+
90
+ - `Ne` in the ED tables is the **per-spin** number: density=2*Ne/N_sites.
91
+ - H=-t sum_<ij>,sigma (c^dagger_i c_j+h.c.) + U sum_i n_up n_down; U/t=8.
92
+ - Delta_d(i)=(1/2) sum_delta g_delta
93
+ (c_i,up c_(i+delta),down + c_(i+delta),up c_i,down).
94
+ This is sqrt(2) times team ku-ku's operator, so P_org=2*P_ku-ku.
95
+ - P_org(R) averages <Delta_d(j)^dagger Delta_d(i)> over pairs at the same
96
+ minimum-image distance; ground states within 1e-7 of E0 are equally weighted.
97
+ - Translation projection is an exact symmetry decomposition for rectangular
98
+ periodic clusters. Tilted sqrt(8)/sqrt(10) clusters use the full-sector engine.
99
+ - The recorded 4x4 particle-hole tests use N_up=12..15 versus 4..1; the pair
100
+ differences are <=2.23e-16. Electron-doped mirror rows are excluded from the curve.
101
+ - The cross-shape "largest cluster at each available filling" curve is a sampling
102
+ convention, **not a smooth or size-converged thermodynamic superconducting dome**.
103
+ The submitted point uses its directly computed 3x4 value; it is not interpolated.
104
+ - We do not claim a larger finite-cluster A_d is more accurate than the organizer
105
+ 6x6 estimate, a verified score uplift, superconductivity, or a critical temperature.
106
+ Canonical ranks remain with the organizer pending independent method calibration.
107
+ - No scaling/fitting to reference amplitudes is performed. Published references
108
+ are validation targets, with tolerances reflecting their printed precision.
109
+
110
+ ## Files and integrity
111
+
112
+ `ed_core.py` and `ed_sym.py` contain the two engines. `reproduce_target.py` changes
113
+ only the starting vector through a subclass; neither engine source was altered in
114
+ this continuation. `run_all.py` separates fresh and cached modes and aborts on
115
+ failed checks. Frozen inputs are in `material_inputs.json`; output submissions are
116
+ at the package root. `SHA256SUMS.txt` covers every packaged file except itself.
117
+ Verify it before running with `sha256sum -c SHA256SUMS.txt` from the package root.
118
+ The Windows-friendly equivalent is `python verify_manifest.py`.
119
+
120
+ Original method code is released under the included MIT license. Third-party data,
121
+ reference tables and documentation retain their separate CC-BY-NC 4.0 terms and
122
+ attribution; see `NOTICE.md` and `PROVENANCE.md`.
123
+
124
+ Sources: [official challenge rules](https://huggingface.co/datasets/FINAL-Bench/OSC-Superconductor/blob/main/README.md),
125
+ [independent ED reference, team ku-ku](https://huggingface.co/datasets/FINAL-Bench/OSC-Superconductor/blob/main/validation/multisize_ED_table_kuku.md),
126
+ [filling convention correction](https://huggingface.co/datasets/FINAL-Bench/OSC-Superconductor/discussions/15).
methods/Tuli99/SHA256SUMS.txt ADDED
@@ -0,0 +1,30 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ 38d7f28c719689122570bedcfe36b1e25ecab1d99f9ce14b382db224f3374355 LICENSE
2
+ 0a85853cf9720c8b4bed7beb4a777220925e2e3f84062fa7e3ae4d452d9c1d66 NOTICE.md
3
+ 44a7abae28c272ea4da9045425950c95ac3e2684c6e5f2192f3c048dbf3fd6d1 PROVENANCE.md
4
+ 4e2fbd0e567bb7310cc2ecda4c7d4d785a5111c50be149fbf16278231681228d README.md
5
+ 82f4d55950b4472b09aa019d26992b449ca1e3ce944e81bf99aa06736c0a7a84 method_ed/ad_table.py
6
+ f4d070e6796b528fbb66967a6dfc36b629cbb0f38706cac331f3ca8cd98d386b method_ed/ad_table_own.json
7
+ 5e7bf0c585a160b2c119fb76c6ab165729f4555a67bc8a958fabca5b26a8678e method_ed/audit_results.py
8
+ 65d29f5405045a5a8acc481e73cb24fbccabad16ae56506bd0d1c38f8c7fe5cf method_ed/continuation_checks.json
9
+ bfa7810b47e242765fd6bf090a696c79fd8a2a465304ea4fac53b55b2149304a method_ed/ed_core.py
10
+ a8d1b29b4562a8094ed83ee3ac5daffb3ee8b3a97ba025c79cf44e17d4a687fe method_ed/ed_sym.py
11
+ b50d14a1d6cf8d94df659c9885b2a188eb0928f41ffee5dcca4b6925a407f8d9 method_ed/fresh_target.json
12
+ 4f2f7fbe065d462a881153eeea90901c60258206a4b14fe706fe6f4a6b23e4ce method_ed/material_inputs.json
13
+ 80588efed731e97725a94d6a07e12d70c89b0231311316a5db3a32c31a450452 method_ed/reproduce_target.py
14
+ 148525fe99afb6d30be848673da9b7e2d2908be186d4c0f8c6e667373b74decd method_ed/requirements.txt
15
+ 050588e582248dbdaf643d9a99d39cd2748b77289e1fb03ed6dde1eeb72000f2 method_ed/results_4x4.json
16
+ cf991862724522f53f3ac7fc9180cadc9094bf2d78f9f57d7e85a5db76a9dec9 method_ed/run_4x4.py
17
+ 195b49fe5421168bb08a727dd4c6b0af07670bff6da02722843272469818e504 method_ed/run_all.py
18
+ e6283dc345c1ac10aa88b938b91ae225760b0aa6e856b755a85cac69184c2834 method_ed/run_full.sh
19
+ b7048a85740d1abbdaf7b8224cb7a2f01ca133014729c102a2103e726a93e57b method_ed/run_submission.ps1
20
+ a1dde45062e1901e6a5b2efc953de1d3b964d0f338f4234779c8ae6ee4786a35 method_ed/run_submission.sh
21
+ 89bc6a4fdea9519d9c7318b6917d7fecb5061d23e38cd1cb4e4146e5f4751122 method_ed/run_sym_4x4.py
22
+ 420367f1cf806f92f509bd469b6173a12b8c47f6ba76bb1c122c930e365d1db7 method_ed/submit_gold.py
23
+ 9651dc71d5c02b0711d86b7dfb7b8c93c7055d600a2e3524897573665494a82a method_ed/test_sym.py
24
+ a8b054106d6a2b0dca44459107ef7bb6266646005ad63fd991512f6b5978c3d7 method_ed/validate_ed.py
25
+ 41dabfb2529c2dafd8dc480d35a67e98d5a3cbbec1ff7e5c5485dbd68f25f922 method_ed/validation_report.json
26
+ 8eb95fecc45945bf2c58fcb86bb5a1c6d82e3b6a14654956c615959dd5a9bfbc submission_gold_OSC-00747.json
27
+ a45a05a027f7074c17423096ca040585fe88f2b9a9e614bec019c517f7c040ff submission_gold_OSC-00754.json
28
+ 6d9673f599a1693722e998f9272377427987e296b2f8925de037358cf0d90c4e submission_gold_OSC-01665.json
29
+ 126892ef7a810834ba5e72eb9609e057ca0434c6b0516081964523e90f7ecde7 validation/multisize_ED_table_kuku.md
30
+ b44c9e6820e68e4f66e236086f221aa300b138cb44792660554546580152e001 verify_manifest.py
methods/Tuli99/Tuli99_OSC_Gold_2026-10-21.zip ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:719d19f30cfb908b59d5259c1c2a528fe14e2079c23e5457d56edec0c5cb655c
3
+ size 57922
methods/Tuli99/Tuli99_OSC_Gold_2026-10-21.zip.sha256 ADDED
@@ -0,0 +1 @@
 
 
1
+ 719d19f30cfb908b59d5259c1c2a528fe14e2079c23e5457d56edec0c5cb655c Tuli99_OSC_Gold_2026-10-21.zip
methods/Tuli99/method_ed/ad_table.py ADDED
@@ -0,0 +1,137 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Build the own A_d(delta) table (OSC gold/method track) from validated ED.
3
+
4
+ Sources
5
+ - small clusters (2x4, sqrt8, sqrt10, 3x4): recomputed live with engine-1
6
+ (ed_core.py, validated 19/19 against the published independent ED table
7
+ validation/multisize_ED_table_kuku.md)
8
+ - 4x4: read from results_4x4.json. Ne=1..4 rows from run_4x4.py (engine-1
9
+ full ED), Ne=5..8 + 12..15 rows from run_sym_4x4.py (engine-2 momentum
10
+ projection). Both engines cross-checked vs the ku-ku 4x4 rows (Ne=1..8
11
+ all MATCH) and the PHS numeric test A_d(Ne)=A_d(16-Ne) (Ne=12..15 vs
12
+ 1..4, dP <= 2.3e-16).
13
+
14
+ Definitions
15
+ delta = 1 - n (hole doping), n = 2*Ne/Ns, U/t = 8, t = 1
16
+ A_d(delta) = P_org(R_max) = <Delta_d^+(j) Delta_d(i)> averaged over pairs at
17
+ min-image separation R_max, ku-ku/organizer normalization, degenerate GS
18
+ shell (|E-E0|<1e-7) averaged with equal weight.
19
+
20
+ Dome curve: at each delta the largest cluster that hits delta exactly wins;
21
+ linear interpolation between grid points; outside the grid: clamp with a flag.
22
+
23
+ Output: ad_table_own.json
24
+ """
25
+ import json, os, sys, time
26
+ import numpy as np
27
+ import ed_core as ec
28
+
29
+ HERE = os.path.dirname(os.path.abspath(__file__))
30
+ OUT = os.path.join(HERE, "ad_table_own.json")
31
+ RES4 = os.path.join(HERE, "results_4x4.json")
32
+
33
+ SMALL = ["2x4", "sqrt8", "sqrt10", "3x4"]
34
+
35
+
36
+ def compute_small():
37
+ """All U=8 points on the validated small clusters (fast, minutes total)."""
38
+ rows = []
39
+ for cname in SMALL:
40
+ cl = ec.CLUSTERS[cname]()
41
+ nmax = cl.Ns // 2
42
+ for ne in range(1, nmax + 1):
43
+ t0 = time.time()
44
+ ed = ec.SectorED(cl, ne, U=8.0)
45
+ E0, vecs = ed.solve_gs()
46
+ deg = vecs.shape[1]
47
+ p8, npair = ec.PairOps(ed).pd_at_R(vecs, cl.rmax)
48
+ p0, _ = ec.wick_u0(cl, ne, cl.rmax)
49
+ rows.append(dict(
50
+ cluster=cname, Ns=cl.Ns, Ne=ne, n=round(2 * ne / cl.Ns, 6),
51
+ delta=round(1 - 2 * ne / cl.Ns, 6), dim=ed.dim, E0=E0, deg=deg,
52
+ A_d=p8, A_d_U0=p0, Rmax=cl.rmax, npairs=npair,
53
+ source="engine-1 live", sec=round(time.time() - t0, 1)))
54
+ print(f" {cname} Ne={ne}: dim={ed.dim} E0={E0:.8f} deg={deg} "
55
+ f"A_d={p8:.8f} [{rows[-1]['sec']}s]", flush=True)
56
+ return rows
57
+
58
+
59
+ def load_4x4():
60
+ if not os.path.exists(RES4):
61
+ print("[warn] results_4x4.json missing - run run_4x4.py first", flush=True)
62
+ return []
63
+ res = json.load(open(RES4))
64
+ rows = []
65
+ for k, r in sorted(res.items(), key=lambda kv: int(kv[0])):
66
+ phs_mirror = r["Ne"] > 8 # electron-doped side, delta < 0
67
+ eng = r.get("engine") # rows from run_sym_4x4.py carry "engine"
68
+ src = ("run_sym_4x4.py (cached, engine-2 " + eng + ")" if eng
69
+ else "run_4x4.py (cached, engine-1)")
70
+ rows.append(dict(cluster="4x4", Ns=16, Ne=r["Ne"], n=r["n"], delta=r["delta"],
71
+ dim=r["dim"], E0=r["E0"], deg=r["deg"], A_d=r["P_org_U8"],
72
+ A_d_U0=r["P_org_U0"], Rmax=r["Rmax"], npairs=r["npairs"],
73
+ source=src,
74
+ role="PHS-mirror-test" if phs_mirror else "dome",
75
+ sec=r.get("sec")))
76
+ return rows
77
+
78
+
79
+ def build_curve(rows):
80
+ """Largest-cluster-per-delta dome curve (U=8, hole-doped side delta>=0 only)."""
81
+ by_delta = {}
82
+ for r in rows:
83
+ if r["delta"] < -1e-9:
84
+ continue # electron-doped PHS-test rows: no dome entry
85
+ by_delta.setdefault(r["delta"], []).append(r)
86
+ curve = []
87
+ for d, rs in sorted(by_delta.items()):
88
+ best = max(rs, key=lambda r: (r["Ns"], r["dim"]))
89
+ curve.append(dict(delta=d, A_d=best["A_d"], cluster=best["cluster"], Ne=best["Ne"],
90
+ others=[f"{r['cluster']}:Ne{r['Ne']}={r['A_d']:.6f}"
91
+ for r in rs if r is not best]))
92
+ return curve
93
+
94
+
95
+ def ad_of(curve, delta):
96
+ """Linear interpolation on the dome curve; clamped outside with flag."""
97
+ xs = [c["delta"] for c in curve]
98
+ ys = [c["A_d"] for c in curve]
99
+ if delta <= xs[0]:
100
+ return ys[0], "clamped-low"
101
+ if delta >= xs[-1]:
102
+ return ys[-1], "clamped-high"
103
+ i = int(np.searchsorted(xs, delta))
104
+ if abs(xs[i] - delta) < 1e-9:
105
+ return ys[i], "exact"
106
+ x0, x1, y0, y1 = xs[i - 1], xs[i], ys[i - 1], ys[i]
107
+ return float(y0 + (y1 - y0) * (delta - x0) / (x1 - x0)), f"interp({x0},{x1})"
108
+
109
+
110
+ def main():
111
+ t0 = time.time()
112
+ print("[1/3] recomputing small clusters (engine-1, validated)...", flush=True)
113
+ rows = compute_small()
114
+ print("[2/3] loading 4x4 results...", flush=True)
115
+ rows += load_4x4()
116
+ print("[3/3] building dome curve...", flush=True)
117
+ curve = build_curve(rows)
118
+ for c in curve:
119
+ print(f" delta={c['delta']:.4f} A_d={c['A_d']:+.6f} <- {c['cluster']} Ne={c['Ne']}"
120
+ + (f" (others: {', '.join(c['others'])})" if c["others"] else ""), flush=True)
121
+ # sanity: our dome peak vs the organizers' 6x6 anchor at delta=1/6
122
+ a16, how = ad_of(curve, 1 / 6)
123
+ print(f"\n A_d_own(delta=1/6) = {a16:.6f} [{how}] "
124
+ f"organizers' 6x6: 0.05569 ratio={a16/0.05569:.3f}", flush=True)
125
+ meta = dict(
126
+ scale=300.0, U_over_t=8.0, definition="A_d = P_org(R_max, U=8), delta=1-n",
127
+ normalization="ku-ku/organizer P_org; degenerate GS shell |E-E0|<1e-7 equal-weight",
128
+ validation="engine-1 19/19 vs multisize_ED_table_kuku.md; 4x4 Ne=1..4 (engine-1) "
129
+ "+ Ne=5..8 (engine-2 momentum projection) all MATCH ku-ku rows "
130
+ "(E0 diff <=1e-8); PHS A_d(Ne)=A_d(16-Ne) on 4x4 Ne=12..15 (dP<=2.3e-16)",
131
+ curve=curve, rows=rows)
132
+ json.dump(meta, open(OUT, "w"), indent=1)
133
+ print(f"\n[done] {OUT} ({time.time()-t0:.0f}s, {len(rows)} rows)", flush=True)
134
+
135
+
136
+ if __name__ == "__main__":
137
+ main()
methods/Tuli99/method_ed/ad_table_own.json ADDED
@@ -0,0 +1,646 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "scale": 300.0,
3
+ "U_over_t": 8.0,
4
+ "definition": "A_d = P_org(R_max, U=8), delta=1-n",
5
+ "normalization": "ku-ku/organizer P_org; degenerate GS shell |E-E0|<1e-7 equal-weight",
6
+ "validation": "engine-1 19/19 vs multisize_ED_table_kuku.md; 4x4 Ne=1..4 (engine-1) + Ne=5..8 (engine-2 momentum projection) all MATCH ku-ku rows (E0 diff <=1e-8); PHS A_d(Ne)=A_d(16-Ne) on 4x4 Ne=12..15 (dP<=2.3e-16)",
7
+ "curve": [
8
+ {
9
+ "delta": 0.0,
10
+ "A_d": 0.0061970902582232975,
11
+ "cluster": "4x4",
12
+ "Ne": 8,
13
+ "others": [
14
+ "2x4:Ne4=0.032841",
15
+ "sqrt8:Ne4=-0.081563",
16
+ "sqrt10:Ne5=0.035980",
17
+ "3x4:Ne6=0.010027"
18
+ ]
19
+ },
20
+ {
21
+ "delta": 0.125,
22
+ "A_d": 0.019219005559767213,
23
+ "cluster": "4x4",
24
+ "Ne": 7,
25
+ "others": []
26
+ },
27
+ {
28
+ "delta": 0.166667,
29
+ "A_d": 0.056826612626876764,
30
+ "cluster": "3x4",
31
+ "Ne": 5,
32
+ "others": []
33
+ },
34
+ {
35
+ "delta": 0.2,
36
+ "A_d": 0.09099469011227528,
37
+ "cluster": "sqrt10",
38
+ "Ne": 4,
39
+ "others": []
40
+ },
41
+ {
42
+ "delta": 0.25,
43
+ "A_d": 0.009831080963260455,
44
+ "cluster": "4x4",
45
+ "Ne": 6,
46
+ "others": [
47
+ "2x4:Ne3=0.193846",
48
+ "sqrt8:Ne3=0.015115"
49
+ ]
50
+ },
51
+ {
52
+ "delta": 0.333333,
53
+ "A_d": 0.03606092172970043,
54
+ "cluster": "3x4",
55
+ "Ne": 4,
56
+ "others": []
57
+ },
58
+ {
59
+ "delta": 0.375,
60
+ "A_d": 0.06012194560348784,
61
+ "cluster": "4x4",
62
+ "Ne": 5,
63
+ "others": []
64
+ },
65
+ {
66
+ "delta": 0.4,
67
+ "A_d": -0.03709932216982281,
68
+ "cluster": "sqrt10",
69
+ "Ne": 3,
70
+ "others": []
71
+ },
72
+ {
73
+ "delta": 0.5,
74
+ "A_d": 0.048075923542662026,
75
+ "cluster": "4x4",
76
+ "Ne": 4,
77
+ "others": [
78
+ "2x4:Ne2=-0.003636",
79
+ "sqrt8:Ne2=0.046205",
80
+ "3x4:Ne3=0.103875"
81
+ ]
82
+ },
83
+ {
84
+ "delta": 0.6,
85
+ "A_d": 0.03211503356159011,
86
+ "cluster": "sqrt10",
87
+ "Ne": 2,
88
+ "others": []
89
+ },
90
+ {
91
+ "delta": 0.625,
92
+ "A_d": -0.013730852586326413,
93
+ "cluster": "4x4",
94
+ "Ne": 3,
95
+ "others": []
96
+ },
97
+ {
98
+ "delta": 0.666667,
99
+ "A_d": -0.00649435763654526,
100
+ "cluster": "3x4",
101
+ "Ne": 2,
102
+ "others": []
103
+ },
104
+ {
105
+ "delta": 0.75,
106
+ "A_d": 0.012094024007304124,
107
+ "cluster": "4x4",
108
+ "Ne": 2,
109
+ "others": [
110
+ "2x4:Ne1=0.002160",
111
+ "sqrt8:Ne1=-0.000000"
112
+ ]
113
+ },
114
+ {
115
+ "delta": 0.8,
116
+ "A_d": -2.157041537713704e-33,
117
+ "cluster": "sqrt10",
118
+ "Ne": 1,
119
+ "others": []
120
+ },
121
+ {
122
+ "delta": 0.833333,
123
+ "A_d": 5.752637830879618e-05,
124
+ "cluster": "3x4",
125
+ "Ne": 1,
126
+ "others": []
127
+ },
128
+ {
129
+ "delta": 0.875,
130
+ "A_d": 7.222237291452134e-35,
131
+ "cluster": "4x4",
132
+ "Ne": 1,
133
+ "others": []
134
+ }
135
+ ],
136
+ "rows": [
137
+ {
138
+ "cluster": "2x4",
139
+ "Ns": 8,
140
+ "Ne": 1,
141
+ "n": 0.25,
142
+ "delta": 0.75,
143
+ "dim": 64,
144
+ "E0": -7.517540966287268,
145
+ "deg": 1,
146
+ "A_d": 0.0021602987502842546,
147
+ "A_d_U0": 4.336808689942018e-19,
148
+ "Rmax": 2.236067977,
149
+ "npairs": 8,
150
+ "source": "engine-1 live",
151
+ "sec": 0.3
152
+ },
153
+ {
154
+ "cluster": "2x4",
155
+ "Ns": 8,
156
+ "Ne": 2,
157
+ "n": 0.5,
158
+ "delta": 0.5,
159
+ "dim": 784,
160
+ "E0": -10.497622018801579,
161
+ "deg": 1,
162
+ "A_d": -0.0036361479665242393,
163
+ "A_d_U0": 0.03124999999999997,
164
+ "Rmax": 2.236067977,
165
+ "npairs": 8,
166
+ "source": "engine-1 live",
167
+ "sec": 0.4
168
+ },
169
+ {
170
+ "cluster": "2x4",
171
+ "Ns": 8,
172
+ "Ne": 3,
173
+ "n": 0.75,
174
+ "delta": 0.25,
175
+ "dim": 3136,
176
+ "E0": -10.626897354717265,
177
+ "deg": 1,
178
+ "A_d": 0.19384632869957263,
179
+ "A_d_U0": 0.18749999999999994,
180
+ "Rmax": 2.236067977,
181
+ "npairs": 8,
182
+ "source": "engine-1 live",
183
+ "sec": 2.1
184
+ },
185
+ {
186
+ "cluster": "2x4",
187
+ "Ns": 8,
188
+ "Ne": 4,
189
+ "n": 1.0,
190
+ "delta": 0.0,
191
+ "dim": 4900,
192
+ "E0": -7.126712344422229,
193
+ "deg": 1,
194
+ "A_d": 0.0328407795929002,
195
+ "A_d_U0": 0.06249999999999994,
196
+ "Rmax": 2.236067977,
197
+ "npairs": 8,
198
+ "source": "engine-1 live",
199
+ "sec": 6.1
200
+ },
201
+ {
202
+ "cluster": "sqrt8",
203
+ "Ns": 8,
204
+ "Ne": 1,
205
+ "n": 0.25,
206
+ "delta": 0.75,
207
+ "dim": 64,
208
+ "E0": -7.464793050036091,
209
+ "deg": 1,
210
+ "A_d": -5.7777898331617076e-33,
211
+ "A_d_U0": 2.168404344971009e-18,
212
+ "Rmax": 2.0,
213
+ "npairs": 8,
214
+ "source": "engine-1 live",
215
+ "sec": 0.2
216
+ },
217
+ {
218
+ "cluster": "sqrt8",
219
+ "Ns": 8,
220
+ "Ne": 2,
221
+ "n": 0.5,
222
+ "delta": 0.5,
223
+ "dim": 784,
224
+ "E0": -6.700437833372282,
225
+ "deg": 4,
226
+ "A_d": 0.04620482062828526,
227
+ "A_d_U0": 0.027777777777777776,
228
+ "Rmax": 2.0,
229
+ "npairs": 8,
230
+ "source": "engine-1 live",
231
+ "sec": 0.3
232
+ },
233
+ {
234
+ "cluster": "sqrt8",
235
+ "Ns": 8,
236
+ "Ne": 3,
237
+ "n": 0.75,
238
+ "delta": 0.25,
239
+ "dim": 3136,
240
+ "E0": -5.952827827724903,
241
+ "deg": 4,
242
+ "A_d": 0.015114943019788555,
243
+ "A_d_U0": 0.027777777777777776,
244
+ "Rmax": 2.0,
245
+ "npairs": 8,
246
+ "source": "engine-1 live",
247
+ "sec": 1.9
248
+ },
249
+ {
250
+ "cluster": "sqrt8",
251
+ "Ns": 8,
252
+ "Ne": 4,
253
+ "n": 1.0,
254
+ "delta": 0.0,
255
+ "dim": 4900,
256
+ "E0": -3.783980808912223,
257
+ "deg": 1,
258
+ "A_d": -0.0815632376214678,
259
+ "A_d_U0": -1.3877787807814457e-17,
260
+ "Rmax": 2.0,
261
+ "npairs": 8,
262
+ "source": "engine-1 live",
263
+ "sec": 6.1
264
+ },
265
+ {
266
+ "cluster": "sqrt10",
267
+ "Ns": 10,
268
+ "Ne": 1,
269
+ "n": 0.2,
270
+ "delta": 0.8,
271
+ "dim": 100,
272
+ "E0": -7.591267152611252,
273
+ "deg": 1,
274
+ "A_d": -2.157041537713704e-33,
275
+ "A_d_U0": 2.7755575615628915e-18,
276
+ "Rmax": 2.236067977,
277
+ "npairs": 10,
278
+ "source": "engine-1 live",
279
+ "sec": 0.4
280
+ },
281
+ {
282
+ "cluster": "sqrt10",
283
+ "Ns": 10,
284
+ "Ne": 2,
285
+ "n": 0.4,
286
+ "delta": 0.6,
287
+ "dim": 2025,
288
+ "E0": -8.868853839155351,
289
+ "deg": 5,
290
+ "A_d": 0.03211503356159011,
291
+ "A_d_U0": 3.729655473350135e-18,
292
+ "Rmax": 2.236067977,
293
+ "npairs": 10,
294
+ "source": "engine-1 live",
295
+ "sec": 1.0
296
+ },
297
+ {
298
+ "cluster": "sqrt10",
299
+ "Ns": 10,
300
+ "Ne": 3,
301
+ "n": 0.6,
302
+ "delta": 0.4,
303
+ "dim": 14400,
304
+ "E0": -9.839639076993503,
305
+ "deg": 1,
306
+ "A_d": -0.03709932216982281,
307
+ "A_d_U0": 0.05000000000000001,
308
+ "Rmax": 2.236067977,
309
+ "npairs": 10,
310
+ "source": "engine-1 live",
311
+ "sec": 2.2
312
+ },
313
+ {
314
+ "cluster": "sqrt10",
315
+ "Ns": 10,
316
+ "Ne": 4,
317
+ "n": 0.8,
318
+ "delta": 0.2,
319
+ "dim": 44100,
320
+ "E0": -8.117067746178735,
321
+ "deg": 5,
322
+ "A_d": 0.09099469011227528,
323
+ "A_d_U0": 0.15000000000000008,
324
+ "Rmax": 2.236067977,
325
+ "npairs": 10,
326
+ "source": "engine-1 live",
327
+ "sec": 9.6
328
+ },
329
+ {
330
+ "cluster": "sqrt10",
331
+ "Ns": 10,
332
+ "Ne": 5,
333
+ "n": 1.0,
334
+ "delta": 0.0,
335
+ "dim": 63504,
336
+ "E0": -5.104091910390858,
337
+ "deg": 1,
338
+ "A_d": 0.0359803196391129,
339
+ "A_d_U0": 0.3000000000000001,
340
+ "Rmax": 2.236067977,
341
+ "npairs": 10,
342
+ "source": "engine-1 live",
343
+ "sec": 12.7
344
+ },
345
+ {
346
+ "cluster": "3x4",
347
+ "Ns": 12,
348
+ "Ne": 1,
349
+ "n": 0.166667,
350
+ "delta": 0.833333,
351
+ "dim": 144,
352
+ "E0": -7.675992091391265,
353
+ "deg": 1,
354
+ "A_d": 5.752637830879618e-05,
355
+ "A_d_U0": -2.168404344971009e-19,
356
+ "Rmax": 2.236067977,
357
+ "npairs": 24,
358
+ "source": "engine-1 live",
359
+ "sec": 0.9
360
+ },
361
+ {
362
+ "cluster": "3x4",
363
+ "Ns": 12,
364
+ "Ne": 2,
365
+ "n": 0.333333,
366
+ "delta": 0.666667,
367
+ "dim": 4356,
368
+ "E0": -11.037873924123131,
369
+ "deg": 1,
370
+ "A_d": -0.00649435763654526,
371
+ "A_d_U0": 0.01388888888888889,
372
+ "Rmax": 2.236067977,
373
+ "npairs": 24,
374
+ "source": "engine-1 live",
375
+ "sec": 4.9
376
+ },
377
+ {
378
+ "cluster": "3x4",
379
+ "Ns": 12,
380
+ "Ne": 3,
381
+ "n": 0.5,
382
+ "delta": 0.5,
383
+ "dim": 48400,
384
+ "E0": -13.067143245595542,
385
+ "deg": 1,
386
+ "A_d": 0.10387538976303463,
387
+ "A_d_U0": 0.08333333333333336,
388
+ "Rmax": 2.236067977,
389
+ "npairs": 24,
390
+ "source": "engine-1 live",
391
+ "sec": 8.1
392
+ },
393
+ {
394
+ "cluster": "3x4",
395
+ "Ns": 12,
396
+ "Ne": 4,
397
+ "n": 0.666667,
398
+ "delta": 0.333333,
399
+ "dim": 245025,
400
+ "E0": -12.64005415202609,
401
+ "deg": 1,
402
+ "A_d": 0.03606092172970043,
403
+ "A_d_U0": 0.08680555555555558,
404
+ "Rmax": 2.236067977,
405
+ "npairs": 24,
406
+ "source": "engine-1 live",
407
+ "sec": 42.5
408
+ },
409
+ {
410
+ "cluster": "3x4",
411
+ "Ns": 12,
412
+ "Ne": 5,
413
+ "n": 0.833333,
414
+ "delta": 0.166667,
415
+ "dim": 627264,
416
+ "E0": -10.765379110512903,
417
+ "deg": 1,
418
+ "A_d": 0.056826612626876764,
419
+ "A_d_U0": 0.12152777777777779,
420
+ "Rmax": 2.236067977,
421
+ "npairs": 24,
422
+ "source": "engine-1 live",
423
+ "sec": 139.2
424
+ },
425
+ {
426
+ "cluster": "3x4",
427
+ "Ns": 12,
428
+ "Ne": 6,
429
+ "n": 1.0,
430
+ "delta": 0.0,
431
+ "dim": 853776,
432
+ "E0": -5.833484257498092,
433
+ "deg": 1,
434
+ "A_d": 0.010027089383054993,
435
+ "A_d_U0": 0.03472222222222223,
436
+ "Rmax": 2.236067977,
437
+ "npairs": 24,
438
+ "source": "engine-1 live",
439
+ "sec": 291.1
440
+ },
441
+ {
442
+ "cluster": "4x4",
443
+ "Ns": 16,
444
+ "Ne": 1,
445
+ "n": 0.125,
446
+ "delta": 0.875,
447
+ "dim": 256,
448
+ "E0": -7.764090590903901,
449
+ "deg": 1,
450
+ "A_d": 7.222237291452134e-35,
451
+ "A_d_U0": 1.3552527156068805e-19,
452
+ "Rmax": 2.828427125,
453
+ "npairs": 16,
454
+ "source": "run_4x4.py (cached, engine-1)",
455
+ "role": "dome",
456
+ "sec": 1.0
457
+ },
458
+ {
459
+ "cluster": "4x4",
460
+ "Ns": 16,
461
+ "Ne": 2,
462
+ "n": 0.25,
463
+ "delta": 0.75,
464
+ "dim": 14400,
465
+ "E0": -11.32149713321177,
466
+ "deg": 3,
467
+ "A_d": 0.012094024007304124,
468
+ "A_d_U0": 3.9607260613611084e-18,
469
+ "Rmax": 2.828427125,
470
+ "npairs": 16,
471
+ "source": "run_4x4.py (cached, engine-1)",
472
+ "role": "dome",
473
+ "sec": 2.2
474
+ },
475
+ {
476
+ "cluster": "4x4",
477
+ "Ns": 16,
478
+ "Ne": 3,
479
+ "n": 0.375,
480
+ "delta": 0.625,
481
+ "dim": 313600,
482
+ "E0": -14.723540317907524,
483
+ "deg": 1,
484
+ "A_d": -0.013730852586326413,
485
+ "A_d_U0": 0.015625000000000017,
486
+ "Rmax": 2.828427125,
487
+ "npairs": 16,
488
+ "source": "run_4x4.py (cached, engine-1)",
489
+ "role": "dome",
490
+ "sec": 50.7
491
+ },
492
+ {
493
+ "cluster": "4x4",
494
+ "Ns": 16,
495
+ "Ne": 4,
496
+ "n": 0.5,
497
+ "delta": 0.5,
498
+ "dim": 3312400,
499
+ "E0": -16.46062675368174,
500
+ "deg": 3,
501
+ "A_d": 0.048075923542662026,
502
+ "A_d_U0": 0.046875000000000035,
503
+ "Rmax": 2.828427125,
504
+ "npairs": 16,
505
+ "source": "run_4x4.py (cached, engine-1)",
506
+ "role": "dome",
507
+ "sec": 935.6
508
+ },
509
+ {
510
+ "cluster": "4x4",
511
+ "Ns": 16,
512
+ "Ne": 5,
513
+ "n": 0.625,
514
+ "delta": 0.375,
515
+ "dim": 19079424,
516
+ "E0": -17.510366694878634,
517
+ "deg": 1,
518
+ "A_d": 0.06012194560348784,
519
+ "A_d_U0": 0.09375000000000006,
520
+ "Rmax": 2.828427125,
521
+ "npairs": 16,
522
+ "source": "run_sym_4x4.py (cached, engine-2 sym-projection)",
523
+ "role": "dome",
524
+ "sec": 775.3
525
+ },
526
+ {
527
+ "cluster": "4x4",
528
+ "Ns": 16,
529
+ "Ne": 6,
530
+ "n": 0.75,
531
+ "delta": 0.25,
532
+ "dim": 64128064,
533
+ "E0": -14.925310215108519,
534
+ "deg": 2,
535
+ "A_d": 0.009831080963260455,
536
+ "A_d_U0": 0.0416666666666667,
537
+ "Rmax": 2.828427125,
538
+ "npairs": 16,
539
+ "source": "run_sym_4x4.py (cached, engine-2 sym-projection)",
540
+ "role": "dome",
541
+ "sec": 3775.5
542
+ },
543
+ {
544
+ "cluster": "4x4",
545
+ "Ns": 16,
546
+ "Ne": 7,
547
+ "n": 0.875,
548
+ "delta": 0.125,
549
+ "dim": 130873600,
550
+ "E0": -11.86883556956405,
551
+ "deg": 3,
552
+ "A_d": 0.019219005559767213,
553
+ "A_d_U0": 0.01041666666666668,
554
+ "Rmax": 2.828427125,
555
+ "npairs": 16,
556
+ "source": "run_sym_4x4.py (cached, engine-2 sym-projection)",
557
+ "role": "dome",
558
+ "sec": 8545.6
559
+ },
560
+ {
561
+ "cluster": "4x4",
562
+ "Ns": 16,
563
+ "Ne": 8,
564
+ "n": 1.0,
565
+ "delta": 0.0,
566
+ "dim": 165636900,
567
+ "E0": -8.468875014196815,
568
+ "deg": 1,
569
+ "A_d": 0.0061970902582232975,
570
+ "A_d_U0": -9.486769009248164e-20,
571
+ "Rmax": 2.828427125,
572
+ "npairs": 16,
573
+ "source": "run_sym_4x4.py (cached, engine-2 sym-projection)",
574
+ "role": "dome",
575
+ "sec": 9602.0
576
+ },
577
+ {
578
+ "cluster": "4x4",
579
+ "Ns": 16,
580
+ "Ne": 12,
581
+ "n": 1.5,
582
+ "delta": -0.5,
583
+ "dim": 3312400,
584
+ "E0": 47.5393732463182,
585
+ "deg": 3,
586
+ "A_d": 0.04807592354266225,
587
+ "A_d_U0": 0.046875,
588
+ "Rmax": 2.828427125,
589
+ "npairs": 16,
590
+ "source": "run_sym_4x4.py (cached, engine-2 sym-projection)",
591
+ "role": "PHS-mirror-test",
592
+ "sec": 232.8
593
+ },
594
+ {
595
+ "cluster": "4x4",
596
+ "Ns": 16,
597
+ "Ne": 13,
598
+ "n": 1.625,
599
+ "delta": -0.625,
600
+ "dim": 313600,
601
+ "E0": 65.2764596820923,
602
+ "deg": 1,
603
+ "A_d": -0.013730852586326406,
604
+ "A_d_U0": 0.015624999999999995,
605
+ "Rmax": 2.828427125,
606
+ "npairs": 16,
607
+ "source": "run_sym_4x4.py (cached, engine-2 sym-projection)",
608
+ "role": "PHS-mirror-test",
609
+ "sec": 14.1
610
+ },
611
+ {
612
+ "cluster": "4x4",
613
+ "Ns": 16,
614
+ "Ne": 14,
615
+ "n": 1.75,
616
+ "delta": -0.75,
617
+ "dim": 14400,
618
+ "E0": 84.67850286678824,
619
+ "deg": 3,
620
+ "A_d": 0.012094024007303987,
621
+ "A_d_U0": -3.791319471910248e-18,
622
+ "Rmax": 2.828427125,
623
+ "npairs": 16,
624
+ "source": "run_sym_4x4.py (cached, engine-2 sym-projection)",
625
+ "role": "PHS-mirror-test",
626
+ "sec": 7.8
627
+ },
628
+ {
629
+ "cluster": "4x4",
630
+ "Ns": 16,
631
+ "Ne": 15,
632
+ "n": 1.875,
633
+ "delta": -0.875,
634
+ "dim": 256,
635
+ "E0": 104.2359094090961,
636
+ "deg": 1,
637
+ "A_d": -3.1170812458958252e-19,
638
+ "A_d_U0": 1.0570971181733668e-18,
639
+ "Rmax": 2.828427125,
640
+ "npairs": 16,
641
+ "source": "run_sym_4x4.py (cached, engine-2 sym-projection)",
642
+ "role": "PHS-mirror-test",
643
+ "sec": 1.6
644
+ }
645
+ ]
646
+ }
methods/Tuli99/method_ed/audit_results.py ADDED
@@ -0,0 +1,87 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Audit supplied ED records against the attributed independent reference.
2
+
3
+ No eigensolver runs here. Cached evidence and fresh target evidence are reported
4
+ separately; checking stored numbers does not independently reproduce 4x4 ED.
5
+ """
6
+ import hashlib
7
+ import json
8
+ import math
9
+ from pathlib import Path
10
+
11
+ HERE = Path(__file__).resolve().parent
12
+ ROOT = HERE.parent
13
+
14
+
15
+ def main():
16
+ ref_path = ROOT / 'validation' / 'multisize_ED_table_kuku.md'
17
+ refs = {}
18
+ for line in ref_path.read_text(encoding='utf-8').splitlines():
19
+ fields = [x.strip() for x in line.strip().strip('|').split('|')]
20
+ if len(fields) == 15 and fields[0] in ['2x4', 'sqrt8', 'sqrt10', '3x4', '4x4']:
21
+ refs[(fields[0], int(fields[3]))] = {
22
+ 'E0': float(fields[5]), 'deg': int(fields[6]),
23
+ 'A_d': float(fields[10]), 'A_d_U0': float(fields[12]),
24
+ }
25
+ if len(refs) != 27:
26
+ raise SystemExit(f'Expected 27 reference rows, found {len(refs)}')
27
+ table = json.loads((HERE / 'ad_table_own.json').read_text(encoding='utf-8'))
28
+ four = json.loads((HERE / 'results_4x4.json').read_text(encoding='utf-8'))
29
+ by_key = {(r['cluster'], r['Ne']): r for r in table['rows']}
30
+ checks = []
31
+ for key, ref in refs.items():
32
+ r = by_key[key]
33
+ diffs = {k: abs(r[k] - ref[k]) for k in ['E0', 'A_d', 'A_d_U0']}
34
+ ok = (diffs['E0'] < 5e-7 and diffs['A_d'] < 2e-6 and
35
+ diffs['A_d_U0'] < 2e-6 and r['deg'] == ref['deg'])
36
+ ok &= r['dim'] == math.comb(r['Ns'], r['Ne']) ** 2
37
+ ok &= abs(r['delta'] - (1 - 2 * r['Ne'] / r['Ns'])) < 1e-6
38
+ if key[0] == '4x4':
39
+ raw = four[str(key[1])]
40
+ ok &= (abs(raw['E0'] - r['E0']) < 1e-12 and
41
+ abs(raw['P_org_U8'] - r['A_d']) < 1e-12 and raw['deg'] == r['deg'])
42
+ checks.append(dict(cluster=key[0], Ne=key[1], differences=diffs, passed=bool(ok)))
43
+ phs = []
44
+ for ne in [12, 13, 14, 15]:
45
+ r, mirror = four[str(ne)], four[str(16 - ne)]
46
+ dp = abs(r['P_org_U8'] - mirror['P_org_U8'])
47
+ # E(Ne)-E(16-Ne)=U*(N_total-N_sites), Ne means per-spin count.
48
+ de = abs(r['E0'] - mirror['E0'] - 8 * (2 * ne - 16))
49
+ phs.append(dict(Ne=ne, mirror=16-ne, A_d_difference=dp,
50
+ energy_shift_error=de,
51
+ passed=dp < 1e-10 and de < 1e-8 and r['deg'] == mirror['deg']))
52
+ curve_ok = all(r['delta'] >= 0 for r in table['curve'])
53
+ curve_ok &= [r['delta'] for r in table['curve']] == sorted(set(r['delta'] for r in table['curve']))
54
+ for c in table['curve']:
55
+ candidates = [r for r in table['rows'] if r['delta'] == c['delta']]
56
+ best = max(candidates, key=lambda r: (r['Ns'], r['dim']))
57
+ curve_ok &= c['cluster'] == best['cluster'] and c['Ne'] == best['Ne']
58
+ curve_ok &= abs(c['A_d'] - best['A_d']) < 1e-12
59
+ fresh_path = HERE / 'fresh_target.json'
60
+ fresh_status = None
61
+ if fresh_path.exists():
62
+ fresh = json.loads(fresh_path.read_text(encoding='utf-8'))
63
+ engine_hash = hashlib.sha256((HERE / 'ed_core.py').read_bytes()).hexdigest()
64
+ target = by_key[('3x4', 5)]
65
+ fresh_status = (fresh.get('complete') and fresh.get('passed') and
66
+ fresh.get('engine_sha256') == engine_hash and
67
+ len(set(r['seed'] for r in fresh['runs'])) >= 3 and
68
+ all(abs(r['A_d'] - target['A_d']) < 1e-8 and
69
+ abs(r['E0'] - target['E0']) < 1e-8 and
70
+ r['residual_max'] < 1e-8 and r['degeneracy'] == 1
71
+ for r in fresh['runs']))
72
+ passed = all(r['passed'] for r in checks + phs) and curve_ok and fresh_status is not False
73
+ report = dict(scope='cached 27-point reference audit, cached PHS audit; fresh target separately',
74
+ reference_credit='Team ku-ku, 2026-10-01, CC-BY-NC 4.0',
75
+ reference_sha256=hashlib.sha256(ref_path.read_bytes()).hexdigest(),
76
+ reference_checks=checks, particle_hole_checks=phs,
77
+ curve_consistent=bool(curve_ok), fresh_target_passed=fresh_status,
78
+ passed=bool(passed))
79
+ (HERE / 'validation_report.json').write_text(json.dumps(report, indent=2) + '\n', encoding='utf-8')
80
+ print(f"Cached reference audit: {sum(r['passed'] for r in checks)}/27")
81
+ print(f"Cached PHS audit: {sum(r['passed'] for r in phs)}/4")
82
+ print('Fresh target:', fresh_status, '; curve:', bool(curve_ok))
83
+ raise SystemExit(0 if passed else 1)
84
+
85
+
86
+ if __name__ == '__main__':
87
+ main()
methods/Tuli99/method_ed/continuation_checks.json ADDED
@@ -0,0 +1,17 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "date": "2026-10-21",
3
+ "fresh_tests": {
4
+ "test_sym.py L1 L2 L3 L4": "all passed in current continuation",
5
+ "L3_completeness_max_error": 4e-16,
6
+ "L4_spectrum_union_max_error": 4.16e-13,
7
+ "L4_hermiticity_max_error": 5.5e-15
8
+ },
9
+ "not_recomputed_this_continuation": [
10
+ "full 4x4 Ne=5..8 and Ne=12..15; preserved prior production records, audited against references",
11
+ "L5 fourteen-point interacting correlator comparison; prior worklog evidence only"
12
+ ],
13
+ "unchanged_engine_sources": [
14
+ "ed_core.py",
15
+ "ed_sym.py"
16
+ ]
17
+ }
methods/Tuli99/method_ed/ed_core.py ADDED
@@ -0,0 +1,407 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Own implementation: square-lattice Hubbard ED (Sz=0) + d-wave pair correlation
3
+ P_d(R_max) for the OSC gold/method track.
4
+
5
+ Conventions follow the published independent ED reference
6
+ (validation/multisize_ED_table_kuku.md):
7
+ H = -t sum_<ij>,sigma (c^+_is c_js + h.c.) + U sum_i n_iu n_id, t=1, U=8 (or U=0)
8
+ Periodic clusters (tilted allowed), sector Sz=0, N_up=N_down.
9
+ b_ij = (c_iu c_jd + c_ju c_id)/sqrt2 (spin singlet)
10
+ Delta_d(i) = (1/sqrt2) sum_{d=+-x,+-y} g(d) b_{i,i+d}, g(+-x)=+1, g(+-y)=-1
11
+ (ku-ku's Delta is 1/2-normalized; ours is sqrt2 times theirs, so our
12
+ <Delta^+ Delta> equals their organizer-normalized P_org directly.
13
+ Verified against their U=0 anchors in validate_ed.py.)
14
+ P_d(R) = <Delta_d(j)^+ Delta_d(i)> averaged over pairs with min-image separation R.
15
+ Degenerate ground states (|E-E0| < 1e-7) averaged with equal weight.
16
+
17
+ Pure numpy/scipy. Deterministic (no RNG in the physics path).
18
+ """
19
+ import numpy as np
20
+ from scipy.sparse.linalg import LinearOperator, eigsh
21
+ from scipy.linalg import eigh
22
+
23
+ # ---------------------------------------------------------------- popcount
24
+ _POP16 = np.array([bin(x).count("1") for x in range(1 << 16)], dtype=np.int64)
25
+
26
+
27
+ def popcount(x):
28
+ x = np.asarray(x, dtype=np.int64)
29
+ return _POP16[x & 0xFFFF] + _POP16[(x >> 16) & 0xFFFF]
30
+
31
+
32
+ # ---------------------------------------------------------------- geometry
33
+ class Cluster:
34
+ """Periodic cluster of the square lattice: Z^2 / L with L = <a1, a2>.
35
+
36
+ Sites = canonical (lexicographically minimal) representatives of the classes;
37
+ real-space coords are the integer square-lattice coords.
38
+ """
39
+
40
+ def __init__(self, a1, a2, name=""):
41
+ self.name = name
42
+ self.a1 = np.array(a1, int)
43
+ self.a2 = np.array(a2, int)
44
+ self.Ns = int(round(abs(np.linalg.det(np.array([a1, a2], float)))))
45
+ self.reps = self._enumerate_reps()
46
+ self.index = {tuple(r): k for k, r in enumerate(self.reps)}
47
+ self.pos = np.array(self.reps, float)
48
+ self.bonds = self._nn_bonds() # undirected NN pairs (len 2*Ns)
49
+ self.rmax = self._rmax()
50
+
51
+ def _canon(self, x, y):
52
+ """Canonical rep = lexicographic min of the class orbit restricted to the box."""
53
+ B = self._box
54
+ best = None
55
+ for n1 in range(-self._nshift, self._nshift + 1):
56
+ for n2 in range(-self._nshift, self._nshift + 1):
57
+ c = (x + n1 * self.a1[0] + n2 * self.a2[0],
58
+ y + n1 * self.a1[1] + n2 * self.a2[1])
59
+ if -B <= c[0] <= B and -B <= c[1] <= B:
60
+ if best is None or c < best:
61
+ best = c
62
+ return best
63
+
64
+ def _enumerate_reps(self):
65
+ self._box = 2 * max(int(np.abs(self.a1).max()), int(np.abs(self.a2).max())) + 2
66
+ self._nshift = 2 * self._box
67
+ reps = set()
68
+ for x in range(-self._box, self._box + 1):
69
+ for y in range(-self._box, self._box + 1):
70
+ reps.add(self._canon(x, y))
71
+ assert None not in reps and len(reps) == self.Ns, (self.name, len(reps), self.Ns)
72
+ return sorted(reps)
73
+
74
+ def site(self, x, y):
75
+ return self.index[self._canon(x, y)]
76
+
77
+ def _nn_bonds(self):
78
+ bonds = []
79
+ for k, (x, y) in enumerate(self.reps):
80
+ for e in [(1, 0), (0, 1)]:
81
+ bonds.append((k, self.site(x + e[0], y + e[1])))
82
+ return bonds
83
+
84
+ def min_image(self, p, q):
85
+ best, bl = None, 1e18
86
+ for n1 in range(-10, 11):
87
+ for n2 in range(-10, 11):
88
+ d = (self.pos[q] - self.pos[p]) + n1 * self.a1 + n2 * self.a2
89
+ L = float(np.hypot(d[0], d[1]))
90
+ if L < bl - 1e-12:
91
+ best, bl = d, L
92
+ return best, bl
93
+
94
+ def _rmax(self):
95
+ rmax = 0.0
96
+ for p in range(self.Ns):
97
+ for q in range(p + 1, self.Ns):
98
+ _, L = self.min_image(p, q)
99
+ rmax = max(rmax, L)
100
+ return round(rmax, 9)
101
+
102
+ def pairs_at_R(self, R):
103
+ out = []
104
+ for p in range(self.Ns):
105
+ for q in range(self.Ns):
106
+ if p == q:
107
+ continue
108
+ _, L = self.min_image(p, q)
109
+ if abs(L - R) < 1e-9:
110
+ out.append((p, q))
111
+ return out
112
+
113
+
114
+ def cluster_2x4():
115
+ return Cluster((2, 0), (0, 4), "2x4")
116
+
117
+
118
+ def cluster_sqrt8():
119
+ return Cluster((2, 2), (-2, 2), "sqrt8")
120
+
121
+
122
+ def cluster_sqrt10():
123
+ return Cluster((3, 1), (-1, 3), "sqrt10")
124
+
125
+
126
+ def cluster_3x4():
127
+ return Cluster((3, 0), (0, 4), "3x4")
128
+
129
+
130
+ def cluster_4x4():
131
+ return Cluster((4, 0), (0, 4), "4x4")
132
+
133
+
134
+ CLUSTERS = {"2x4": cluster_2x4, "sqrt8": cluster_sqrt8, "sqrt10": cluster_sqrt10,
135
+ "3x4": cluster_3x4, "4x4": cluster_4x4}
136
+
137
+
138
+ # ---------------------------------------------------------------- ED engine
139
+ class SectorED:
140
+ """Full Sz=0 sector (N_up=N_down=n), matrix-free matvec, t=1."""
141
+
142
+ def __init__(self, cl: Cluster, n, U=8.0):
143
+ self.cl, self.n, self.U = cl, int(n), float(U)
144
+ Ns = cl.Ns
145
+ masks = []
146
+ self._rec(0, 0, n, 0, Ns, masks)
147
+ self.masks = np.array(sorted(masks), dtype=np.int64)
148
+ self.Nu = len(self.masks)
149
+ self.dim = self.Nu * self.Nu
150
+ Nd = self.Nu
151
+ idx = np.arange(Nd)
152
+ rows, cols, sgn = [], [], []
153
+ for (p, q) in cl.bonds:
154
+ for (a, b) in [(p, q), (q, p)]:
155
+ tu = self._hop_table(a, b) # c^+_a c_b (up basis)
156
+ td = self._hop_table(a, b) # same table for down
157
+ rows.append(np.repeat(tu[1], Nd) * Nd + np.tile(idx, len(tu[1])))
158
+ cols.append(np.repeat(tu[0], Nd) * Nd + np.tile(idx, len(tu[0])))
159
+ sgn.append(np.repeat(tu[2], Nd))
160
+ rows.append(np.repeat(idx, len(td[1])) * Nd + np.tile(td[1], Nd))
161
+ cols.append(np.repeat(idx, len(td[0])) * Nd + np.tile(td[0], Nd))
162
+ sgn.append(np.tile(td[2], Nd))
163
+ self.rows = np.concatenate(rows)
164
+ self.cols = np.concatenate(cols)
165
+ # Physical convention: H = -t sum (c^+ c + h.c.), t = 1. The hop table
166
+ # only carries fermionic signs, so each bond hop contributes -1.
167
+ # (+A vs -A is invisible on bipartite clusters and at half filling via
168
+ # PH+gauge, but differs elsewhere - caught by the 3x4 Ne<6 rows.)
169
+ self.sgn = -np.concatenate(sgn).astype(np.float64)
170
+ mu = np.repeat(self.masks, self.Nu)
171
+ md = np.tile(self.masks, self.Nu)
172
+ self.diag = self.U * popcount(mu & md).astype(np.float64)
173
+
174
+ def _rec(self, start, cnt, n, cur, Ns, out):
175
+ if cnt == n:
176
+ out.append(cur)
177
+ return
178
+ for s in range(start, Ns - (n - cnt) + 1):
179
+ self._rec(s + 1, cnt + 1, n, cur | (1 << s), Ns, out)
180
+
181
+ def _hop_table(self, a, b):
182
+ """c^+_a c_b on all configs -> (src_idx, dst_idx, sign)."""
183
+ masks = self.masks
184
+ occ_b = (masks >> b) & 1
185
+ s1 = 1 - 2 * (popcount(masks & ((1 << b) - 1)) & 1)
186
+ m1 = masks ^ (1 << b)
187
+ occ_a = (m1 >> a) & 1
188
+ s2 = 1 - 2 * (popcount(m1 & ((1 << a) - 1)) & 1)
189
+ m2 = m1 | (1 << a)
190
+ valid = (occ_b == 1) & (occ_a == 0)
191
+ src = np.arange(len(masks))[valid]
192
+ dst = np.searchsorted(masks, m2[valid])
193
+ return src, dst, (s1 * s2)[valid].astype(np.int64)
194
+
195
+ def matvec(self, v):
196
+ out = self.diag * v
197
+ out += np.bincount(self.rows, weights=self.sgn * v[self.cols], minlength=self.dim)
198
+ return out
199
+
200
+ DEGEN_TOL = 1e-7 # reference convention: |E-E0| < 1e-7
201
+ DENSE_MAX = 8000 # dense eigh below this dim (exact degeneracies)
202
+
203
+ def solve_gs(self, k=10):
204
+ """Ground shell (E0, multiplet). Small dims: dense eigh (exact).
205
+ Large dims: eigsh with tol=0 + deflation check that provably catches
206
+ any degenerate copy Lanczos missed (project the shell out and hunt
207
+ for a residual eigenvalue at E0)."""
208
+ if self.dim <= self.DENSE_MAX:
209
+ return self._solve_dense(k)
210
+ return self._solve_sparse(k)
211
+
212
+ def _shell(self, w, v):
213
+ """(E0, multiplicity, multiplet vectors)."""
214
+ E0 = float(w[0])
215
+ mult = int(np.sum(w < E0 + self.DEGEN_TOL))
216
+ return E0, mult, v[:, :mult]
217
+
218
+ def _solve_dense(self, k):
219
+ H = np.empty((self.dim, self.dim))
220
+ for i in range(self.dim):
221
+ e = np.zeros(self.dim)
222
+ e[i] = 1.0
223
+ H[:, i] = self.matvec(e)
224
+ H = (H + H.T) * 0.5
225
+ kk = min(k, self.dim)
226
+ w, v = eigh(H, subset_by_index=(0, kk - 1))
227
+ E0, mult = float(w[0]), int(np.sum(w < w[0] + self.DEGEN_TOL))
228
+ return E0, v[:, :mult]
229
+
230
+ def _v0(self):
231
+ r = np.random.RandomState(20260317)
232
+ v = r.standard_normal(self.dim)
233
+ return v / np.linalg.norm(v)
234
+
235
+ def _solve_sparse(self, k):
236
+ op = LinearOperator((self.dim, self.dim), matvec=self.matvec, dtype=np.float64)
237
+ kk = min(k, self.dim - 2)
238
+ while True:
239
+ w, v = eigsh(op, k=kk, which="SA", tol=0.0, v0=self._v0(),
240
+ ncv=min(self.dim, max(4 * kk + 10, 64)), maxiter=500000)
241
+ o = np.argsort(w)
242
+ w, v = w[o], v[:, o]
243
+ E0, mult, V = self._shell(w, v)
244
+ if mult < kk or kk >= self.dim - 2:
245
+ break
246
+ kk = min(2 * kk, self.dim - 2)
247
+ # deflation check: any missed degenerate copy lives in ker(VV^T) with E ~= E0
248
+ V = v[:, :mult]
249
+ while True:
250
+ def matvec_d(x):
251
+ y = x - V @ (V.T @ x)
252
+ z = self.matvec(y)
253
+ return z - V @ (V.T @ z)
254
+ opd = LinearOperator((self.dim, self.dim), matvec=matvec_d, dtype=np.float64)
255
+ v0 = self._v0()
256
+ v0 = v0 - V @ (V.T @ v0)
257
+ nrm = np.linalg.norm(v0)
258
+ if nrm < 1e-12:
259
+ break
260
+ ep, vp = eigsh(opd, k=1, which="SA", tol=0.0, v0=v0 / nrm,
261
+ ncv=min(self.dim, 64), maxiter=500000)
262
+ if ep[0] > E0 + 1e-6: # gap to the next shell is >= ~0.03 in practice
263
+ break
264
+ V = np.column_stack([V, vp[:, 0]]) # missed copy -> add and re-check
265
+ return E0, V
266
+
267
+
268
+ # ---------------------------------------------------------------- pair operator (interacting)
269
+ class PairOps:
270
+ """Delta_d application to GS vectors and P_d(R).
271
+
272
+ Delta annihilates one up and one down electron, so it maps the (n,n) sector to
273
+ the (n-1,n-1) sector through the intermediate (n-1,n)/(n,n-1) grids. Each
274
+ annihilation step uses its own target-sector mask table (this is essential:
275
+ mapping into the source table is the classic ED bug and silently corrupts P_d).
276
+ """
277
+
278
+ def __init__(self, ed: SectorED):
279
+ self.ed = ed
280
+ self.cl = ed.cl
281
+ n, Ns = ed.n, ed.cl.Ns
282
+ self.masks_n = ed.masks # n electrons per spin
283
+ self.masks_m = self._enum(Ns, n - 1) # n-1 electrons per spin
284
+ self.Nu, self.Nu1 = len(self.masks_n), len(self.masks_m)
285
+ self._tabs = {}
286
+ self.nvec = 1
287
+
288
+ def _enum(self, Ns, k):
289
+ out = []
290
+ self._rec(0, 0, k, 0, Ns, out)
291
+ return np.array(sorted(out), dtype=np.int64)
292
+
293
+ def _rec(self, start, cnt, k, cur, Ns, out):
294
+ if cnt == k:
295
+ out.append(cur)
296
+ return
297
+ for s in range(start, Ns - (k - cnt) + 1):
298
+ self._rec(s + 1, cnt + 1, k, cur | (1 << s), Ns, out)
299
+
300
+ def _ann_tab(self, site):
301
+ """c_site: (n-sector index) -> (n-1-sector index, sign). Same table for both spins."""
302
+ key = site
303
+ if key not in self._tabs:
304
+ mn, mm = self.masks_n, self.masks_m
305
+ occ = (mn >> site) & 1
306
+ s1 = 1 - 2 * (popcount(mn & ((1 << site) - 1)) & 1)
307
+ m1 = mn ^ (1 << site)
308
+ valid = occ == 1
309
+ src = np.arange(len(mn))[valid]
310
+ dst = np.searchsorted(mm, m1[valid])
311
+ self._tabs[key] = (src, dst, s1[valid].astype(np.float64))
312
+ return self._tabs[key]
313
+
314
+ def _annihilate(self, V, site, spin, Nu_in):
315
+ """c_{site,spin}: spin 0 acts on axis 0, spin 1 on axis 1.
316
+ V shape (A, B, nvec); returns ((A or A-1), (B or B-1), nvec)."""
317
+ src, dst, sgn = self._ann_tab(site)
318
+ nvec = V.shape[2]
319
+ if spin == 0:
320
+ out = np.zeros((self.Nu1, V.shape[1], nvec))
321
+ out[dst, :, :] = sgn[:, None, None] * V[src, :, :]
322
+ else:
323
+ out = np.zeros((Nu_in, self.Nu1, nvec))
324
+ out[:, dst, :] = sgn[None, :, None] * V[:, src, :]
325
+ return out
326
+
327
+ def _nn(self, i, dx, dy):
328
+ x, y = self.cl.reps[i]
329
+ return self.cl.site(x + dx, y + dy)
330
+
331
+ def delta(self, V, i):
332
+ """Delta_d(i)|V>; V flat (dim_n, nvec) -> returns flat (dim_{n-1}, nvec)."""
333
+ Vm = V.reshape(self.Nu, self.Nu, V.shape[1] if V.ndim > 1 else 1)
334
+ out = None
335
+ for dx, dy, g in [(1, 0, 1), (-1, 0, 1), (0, 1, -1), (0, -1, -1)]:
336
+ j = self._nn(i, dx, dy)
337
+ t1 = self._annihilate(self._annihilate(Vm, j, 1, self.Nu), i, 0, self.Nu) # c_iu c_jd
338
+ t2 = self._annihilate(self._annihilate(Vm, i, 1, self.Nu), j, 0, self.Nu) # c_ju c_id
339
+ term = g * (t1 + t2) / 2.0
340
+ out = term if out is None else out + term
341
+ return out
342
+
343
+ def pd_at_R(self, vecs, R):
344
+ cl = self.cl
345
+ nvec = vecs.shape[1]
346
+ W = [self.delta(vecs, i) for i in range(cl.Ns)]
347
+ pairs = cl.pairs_at_R(R)
348
+ vals = []
349
+ for (i, j) in pairs:
350
+ v = W[j].reshape(-1, nvec).conj()
351
+ w = W[i].reshape(-1, nvec)
352
+ m = np.sum(v * w, axis=0) # per-multiplet-state <D+(j) D(i)>
353
+ vals.append(float(np.mean(m.real))) # equal weight over the shell
354
+ return float(np.mean(vals)), len(pairs)
355
+
356
+
357
+ # ---------------------------------------------------------------- U=0 (Wick) reference
358
+ def wick4(rho_u, rho_d, P, Q, R, S):
359
+ """<c^+_P c^+_Q c_R c_S> for a Slater state (P,Q creations; R,S annihilations,
360
+ in the written operator order). rho = {0: rho_up, 1: rho_down}."""
361
+ rho = (rho_u, rho_d)
362
+
363
+ def c(a, b):
364
+ return rho[a[1]][a[0], b[0]] if a[1] == b[1] else 0.0
365
+
366
+ return c(P, S) * c(Q, R) - c(P, R) * c(Q, S)
367
+
368
+
369
+ def wick_u0(cl: Cluster, n, R):
370
+ """P_d(R) at U=0 (canonical: equal occupation of the partially filled shell).
371
+
372
+ Closed form from Wick:
373
+ <b^+_{j,jd} b_{i,idd}> = 1/2 [rho(j,i) rho(jd,idd) + rho(jd,i) rho(j,idd)]
374
+ <Delta^+(j) Delta(i)> = 1/4 sum_{d d'} g g' <b^+ b> (Delta = 1/sqrt2 sum g b)
375
+ """
376
+ Ns = cl.Ns
377
+ H1 = np.zeros((Ns, Ns))
378
+ for (p, q) in cl.bonds:
379
+ H1[p, q] -= 1.0
380
+ H1[q, p] -= 1.0
381
+ eps, U = eigh(H1)
382
+ occ = np.zeros(Ns)
383
+ if n >= Ns:
384
+ occ[:] = 1.0
385
+ else:
386
+ eF = eps[n]
387
+ shell = np.abs(eps - eF) < 1e-9
388
+ nbelow = int(np.sum(eps < eF - 1e-9))
389
+ occ[eps < eF - 1e-9] = 1.0
390
+ occ[shell] = (n - nbelow) / shell.sum()
391
+ rho = (U * occ) @ U.T
392
+
393
+ def nn(i, dx, dy):
394
+ x, y = cl.reps[i]
395
+ return cl.site(x + dx, y + dy)
396
+
397
+ vals = []
398
+ pairs = cl.pairs_at_R(R)
399
+ for (i, j) in pairs:
400
+ acc = 0.0
401
+ for (dx1, dy1, g1) in [(1, 0, 1), (-1, 0, 1), (0, 1, -1), (0, -1, -1)]:
402
+ jd = nn(j, dx1, dy1)
403
+ for (dx2, dy2, g2) in [(1, 0, 1), (-1, 0, 1), (0, 1, -1), (0, -1, -1)]:
404
+ idd = nn(i, dx2, dy2)
405
+ acc += g1 * g2 * (rho[j, i] * rho[jd, idd] + rho[jd, i] * rho[j, idd])
406
+ vals.append(0.5 * acc)
407
+ return float(np.mean(vals)), len(pairs)
methods/Tuli99/method_ed/ed_sym.py ADDED
@@ -0,0 +1,465 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Engine 2: momentum-projected ED (translation group Z_m x Z_n) for RECTANGULAR
3
+ periodic clusters. Purpose: 4x4 sectors n=5..8 (electrons per spin) exceed
4
+ engine-1's memory envelope (full-sector hop-table storage ~49 GB at n=6); the
5
+ momentum decomposition splits the exact problem into ~dim/16 blocks with
6
+ IDENTICAL physics (sum_k P_k = I, union of block spectra = full spectrum -
7
+ verified numerically by test_sym.py L3/L4). This is an exact reorganization,
8
+ not an approximation.
9
+
10
+ Spec: WORKLOG.md sections 7 / 7.8 / 7.9 (authoritative). Summary:
11
+
12
+ Geometry REUSED from ed_core.Cluster (bonds / rmax / pairs_at_R identical,
13
+ including the 2x4 x-edge double-count convention). Group element g=(p,q):
14
+ site (x,y) -> ((x+p)%m, (y+q)%n), encoded g = p*n + q;
15
+ chi_{k1,k2}(g) = exp(2 pi i (k1 p/m + k2 q/n)).
16
+ Fermion sign of translating a config: sigma_g(c) = sgn_g[mu]*sgn_g[md] with
17
+ sgn_g[mask] = (-1)^{inversions of the image position sequence}, built from
18
+ the inverting site pairs (i<j, pi(i)>pi(j)) of the site permutation.
19
+
20
+ Config = (mu, md) mask pair, flat index c = iu*Nu + id over the SORTED mask
21
+ list. rep[c] = orbit min of flat index; eta[c] = a group element with
22
+ eta(c) = rep(c). k-basis: rep r enters iff
23
+ S_r = sum_{e in Stab(r)} chi(e) sigma_e(r) != 0,
24
+ n_r = sqrt(|S_r|/|G|), |b_r> = P_k|r>/n_r, P_k = (1/|G|) sum_g chi*(g) U_g.
25
+
26
+ Matrix element (WORKLOG 7.8, corrected chi placement):
27
+ <b_a|A|b_b> = (n_a/n_b) * sum_{t in A|b_b>, rep(t)=r_a}
28
+ amp(t) * chi*(eta[t]) * sigma_{eta[t]}(t)
29
+
30
+ P_d(R): shell vectors expanded back to the full sector
31
+ (|b_r> = P_k|r>/n_r), then PairSpace - a line-by-line copy of the validated
32
+ ed_core.PairOps - applies Delta_d(i); <Delta+(j) Delta(i)> is a full-sector
33
+ inner product (equal to the projected one; no projection of the (n-1,n-1)
34
+ sector needed).
35
+
36
+ Time reversal: blocks (k1,k2) and (m-k1,n-k2) have identical spectra and
37
+ P_d; only representatives are solved (real blocks: k1 in {0,m/2}, k2 in
38
+ {0,n/2}; those are self-mirror).
39
+
40
+ Pure numpy/scipy, deterministic (fixed v0 seeds).
41
+ """
42
+ import numpy as np
43
+ from scipy.sparse import coo_matrix
44
+ from scipy.sparse.linalg import eigsh
45
+ from scipy.linalg import eigh
46
+
47
+ import ed_core as ec
48
+
49
+ DEGEN_TOL = 1e-7 # same shell tolerance as engine 1
50
+ DENSE_KMAX = 4000 # dense block diagonalization below this dim
51
+
52
+
53
+ # ---------------------------------------------------------------- tables
54
+ class SymTables:
55
+ """Signed site/mask translation tables for a rectangular cluster."""
56
+
57
+ def __init__(self, cl: ec.Cluster):
58
+ a1, a2 = cl.a1, cl.a2
59
+ assert a1[1] == 0 and a2[0] == 0 and a1[0] > 0 and a2[1] > 0, \
60
+ "rectangular cluster required"
61
+ self.cl = cl
62
+ self.m, self.n = int(a1[0]), int(a2[1])
63
+ self.Ns = cl.Ns
64
+ assert self.m * self.n == self.Ns
65
+ self.NG = self.Ns
66
+ self.Nmask = 1 << self.Ns
67
+ # site permutation per group element g = p*n + q
68
+ self.perm_site = np.zeros((self.NG, self.Ns), dtype=np.int32)
69
+ for p in range(self.m):
70
+ for q in range(self.n):
71
+ g = p * self.n + q
72
+ for s in range(self.Ns):
73
+ x, y = cl.reps[s]
74
+ self.perm_site[g, s] = cl.site(x + p, y + q)
75
+ masks = np.arange(self.Nmask, dtype=np.int32)
76
+ self.tmask = np.zeros((self.NG, self.Nmask), dtype=np.int32)
77
+ self.sgm = np.zeros((self.NG, self.Nmask), dtype=np.int8)
78
+ for g in range(self.NG):
79
+ pi = self.perm_site[g]
80
+ t = np.zeros(self.Nmask, dtype=np.int32)
81
+ for s in range(self.Ns):
82
+ t |= ((masks >> s) & 1) << int(pi[s])
83
+ self.tmask[g] = t
84
+ # sigma = (-1)^{inversions of image sequence}
85
+ # = prod over occupied inverting pairs (i<j, pi(i)>pi(j))
86
+ sg = np.ones(self.Nmask, dtype=np.int8)
87
+ for i in range(self.Ns):
88
+ for j in range(i + 1, self.Ns):
89
+ if pi[i] > pi[j]:
90
+ sg *= 1 - 2 * (((masks >> i) & 1) & ((masks >> j) & 1)).astype(np.int8)
91
+ self.sgm[g] = sg
92
+
93
+ def chi(self, k1, k2):
94
+ """chi(g) for all g, complex128 (NG,)."""
95
+ p = np.arange(self.NG) // self.n
96
+ q = np.arange(self.NG) % self.n
97
+ return np.exp(2j * np.pi * (k1 * p / self.m + k2 * q / self.n))
98
+
99
+ def is_real_block(self, k1, k2):
100
+ return (2 * k1) % self.m == 0 and (2 * k2) % self.n == 0
101
+
102
+ def mirror(self, k1, k2):
103
+ return ((self.m - k1) % self.m, (self.n - k2) % self.n)
104
+
105
+ def compose(self, g, h):
106
+ """g after h: (g+h) mod periods, encoded g = p*n + q."""
107
+ pg, qg = g // self.n, g % self.n
108
+ ph, qh = h // self.n, h % self.n
109
+ return ((pg + ph) % self.m) * self.n + ((qg + qh) % self.n)
110
+
111
+
112
+ # ---------------------------------------------------------------- configs
113
+ def enumerate_masks(Ns, n):
114
+ """Sorted int64 array of masks with n bits set (same order as engine 1)."""
115
+ out = []
116
+ _rec(0, 0, n, 0, Ns, out)
117
+ return np.array(sorted(out), dtype=np.int64)
118
+
119
+
120
+ def _rec(start, cnt, n, cur, Ns, out):
121
+ if cnt == n:
122
+ out.append(cur)
123
+ return
124
+ for s in range(start, Ns - (n - cnt) + 1):
125
+ _rec(s + 1, cnt + 1, n, cur | (1 << s), Ns, out)
126
+
127
+
128
+ def hop_table(masks, a, b):
129
+ """c+_a c_b on all configs -> (src_idx, dst_idx, fermion sign).
130
+ Verbatim logic of ed_core.SectorED._hop_table (validated)."""
131
+ masks = np.asarray(masks, dtype=np.int64)
132
+ occ_b = (masks >> b) & 1
133
+ s1 = 1 - 2 * (ec.popcount(masks & ((1 << b) - 1)) & 1)
134
+ m1 = masks ^ (1 << b)
135
+ occ_a = (m1 >> a) & 1
136
+ s2 = 1 - 2 * (ec.popcount(m1 & ((1 << a) - 1)) & 1)
137
+ m2 = m1 | (1 << a)
138
+ valid = (occ_b == 1) & (occ_a == 0)
139
+ src = np.arange(len(masks))[valid]
140
+ dst = np.searchsorted(masks, m2[valid])
141
+ return src, dst, (s1 * s2)[valid].astype(np.int64)
142
+
143
+
144
+ # ---------------------------------------------------------------- pair ops
145
+ class PairSpace:
146
+ """Delta_d on full-sector vectors - line-by-line copy of the validated
147
+ ed_core.PairOps (masks built here instead of from a SectorED object,
148
+ which is what blows the memory budget at n>=5)."""
149
+
150
+ def __init__(self, cl: ec.Cluster, n):
151
+ self.cl = cl
152
+ self.n = int(n)
153
+ self.masks_n = enumerate_masks(cl.Ns, self.n)
154
+ self.masks_m = enumerate_masks(cl.Ns, self.n - 1)
155
+ self.Nu, self.Nu1 = len(self.masks_n), len(self.masks_m)
156
+ self._tabs = {}
157
+
158
+ def _ann_tab(self, site):
159
+ """c_site: (n-sector index) -> (n-1-sector index, sign)."""
160
+ if site not in self._tabs:
161
+ mn, mm = self.masks_n, self.masks_m
162
+ occ = (mn >> site) & 1
163
+ s1 = 1 - 2 * (ec.popcount(mn & ((1 << site) - 1)) & 1)
164
+ m1 = mn ^ (1 << site)
165
+ valid = occ == 1
166
+ src = np.arange(len(mn))[valid]
167
+ dst = np.searchsorted(mm, m1[valid])
168
+ self._tabs[site] = (src, dst, s1[valid].astype(np.float64))
169
+ return self._tabs[site]
170
+
171
+ def _annihilate(self, V, site, spin, Nu_in):
172
+ """c_{site,spin}: spin 0 on axis 0, spin 1 on axis 1. V (A, B, nvec)."""
173
+ src, dst, sgn = self._ann_tab(site)
174
+ nvec = V.shape[2]
175
+ if spin == 0:
176
+ out = np.zeros((self.Nu1, V.shape[1], nvec), dtype=V.dtype)
177
+ out[dst, :, :] = sgn[:, None, None] * V[src, :, :]
178
+ else:
179
+ out = np.zeros((Nu_in, self.Nu1, nvec), dtype=V.dtype)
180
+ out[:, dst, :] = sgn[None, :, None] * V[:, src, :]
181
+ return out
182
+
183
+ def _nn(self, i, dx, dy):
184
+ x, y = self.cl.reps[i]
185
+ return self.cl.site(x + dx, y + dy)
186
+
187
+ def delta(self, V, i):
188
+ """Delta_d(i)|V>; V (dim_n, nvec) -> (dim_{n-1}, nvec)."""
189
+ Vm = V.reshape(self.Nu, self.Nu, V.shape[1])
190
+ out = None
191
+ for dx, dy, g in [(1, 0, 1), (-1, 0, 1), (0, 1, -1), (0, -1, -1)]:
192
+ j = self._nn(i, dx, dy)
193
+ t1 = self._annihilate(self._annihilate(Vm, j, 1, self.Nu), i, 0, self.Nu)
194
+ t2 = self._annihilate(self._annihilate(Vm, i, 1, self.Nu), j, 0, self.Nu)
195
+ term = g * (t1 + t2) / 2.0
196
+ out = term if out is None else out + term
197
+ return out
198
+
199
+
200
+ # ---------------------------------------------------------------- engine
201
+ class SymED:
202
+ """Momentum-projected ED for a rectangular cluster, n electrons per spin."""
203
+
204
+ def __init__(self, cl: ec.Cluster, n, U=8.0, verbose=True):
205
+ self.cl, self.n, self.U = cl, int(n), float(U)
206
+ self.tb = SymTables(cl)
207
+ self.verbose = verbose
208
+ self.masks = enumerate_masks(cl.Ns, n)
209
+ self.Nu = len(self.masks)
210
+ self.dim = self.Nu * self.Nu
211
+ self._log(f"init n={n} U={U}: Nu={self.Nu} dim={self.dim}")
212
+ self._scan_rep_eta()
213
+ self._scan_stab_sig()
214
+ self.blocks = {} # (k1,k2) -> dict(w, v, factor, dk)
215
+
216
+ def _log(self, msg):
217
+ if self.verbose:
218
+ print(f" [sym n={self.n}] {msg}", flush=True)
219
+
220
+ # -- full-sector scans --
221
+ def _scan_rep_eta(self):
222
+ Nu = self.Nu
223
+ masks32 = self.masks.astype(np.int32)
224
+ mu_all = np.repeat(masks32, Nu)
225
+ md_all = np.tile(masks32, Nu)
226
+ rep = np.arange(self.dim, dtype=np.int32)
227
+ eta = np.zeros(self.dim, dtype=np.int8)
228
+ tm = self.tb.tmask
229
+ for g in range(1, self.tb.NG):
230
+ mu2 = tm[g][mu_all]
231
+ md2 = tm[g][md_all]
232
+ iu2 = np.searchsorted(masks32, mu2).astype(np.int32)
233
+ id2 = np.searchsorted(masks32, md2).astype(np.int32)
234
+ flat2 = iu2 * Nu + id2
235
+ upd = flat2 < rep
236
+ rep = np.where(upd, flat2, rep)
237
+ eta = np.where(upd, np.int8(g), eta)
238
+ del mu2, md2, iu2, id2, flat2
239
+ self.rep, self.eta = rep, eta
240
+ self._mu_all, self._md_all = mu_all, md_all
241
+ self._log("rep/eta scan done")
242
+
243
+ def _scan_stab_sig(self):
244
+ """stab_bits[c]: bitmask of group elements fixing c;
245
+ sig_bits[c]: bitmask of those e with sigma_e(c) = -1."""
246
+ stab_bits = np.zeros(self.dim, dtype=np.int16)
247
+ sig_bits = np.zeros(self.dim, dtype=np.int16)
248
+ tm, sg = self.tb.tmask, self.tb.sgm
249
+ for e in range(self.tb.NG):
250
+ mu2 = tm[e][self._mu_all]
251
+ md2 = tm[e][self._md_all]
252
+ stab = (mu2 == self._mu_all) & (md2 == self._md_all)
253
+ s = (sg[e][self._mu_all] * sg[e][self._md_all])
254
+ neg = stab & (s < 0)
255
+ stab_bits[stab] |= (1 << e)
256
+ sig_bits[neg] |= (1 << e)
257
+ del mu2, md2, stab, s, neg
258
+ self.stab_bits, self.sig_bits = stab_bits, sig_bits
259
+ del self._mu_all, self._md_all
260
+ self._log("stabilizer scan done")
261
+
262
+ # -- k-block basis --
263
+ def block_basis(self, k1, k2):
264
+ """(basis_flat int64, n_basis float64, rank_of_flat int32 (-1 = none))."""
265
+ chi = self.tb.chi(k1, k2)
266
+ S_re = np.zeros(self.dim, dtype=np.float32)
267
+ S_im = np.zeros(self.dim, dtype=np.float32)
268
+ sb, gb = self.stab_bits, self.sig_bits
269
+ for e in range(self.tb.NG):
270
+ sel = ((sb >> e) & 1).astype(np.float32)
271
+ neg = ((gb >> e) & 1).astype(np.float32)
272
+ w = sel * (1.0 - 2.0 * neg) # sigma_e(c) if e stabilizes c else 0
273
+ S_re += w * np.float32(chi[e].real)
274
+ S_im += w * np.float32(chi[e].imag)
275
+ Smag = np.hypot(S_re, S_im)
276
+ # One config per orbit per k: only orbit representatives with S != 0.
277
+ isrep = self.rep == np.arange(self.dim, dtype=np.int32)
278
+ basis_flat = np.flatnonzero((Smag > 1e-6) & isrep).astype(np.int64)
279
+ n_basis = np.sqrt(Smag[basis_flat].astype(np.float64) / self.tb.NG)
280
+ rank = np.full(self.dim, -1, dtype=np.int32)
281
+ rank[basis_flat] = np.arange(len(basis_flat), dtype=np.int32)
282
+ del S_re, S_im, Smag
283
+ return basis_flat, n_basis, rank
284
+
285
+ # -- H block --
286
+ def build_hk(self, k1, k2):
287
+ """k-block H as CSR; float64 for real-chi blocks, complex128 else."""
288
+ tb = self.tb
289
+ real = tb.is_real_block(k1, k2)
290
+ dtype = np.float64 if real else np.complex128
291
+ chi_c = tb.chi(k1, k2).conj()
292
+ basis_flat, n_basis, rank = self.block_basis(k1, k2)
293
+ dk = len(basis_flat)
294
+ Nu = self.Nu
295
+ masks32 = self.masks.astype(np.int32)
296
+ rep32 = self.rep
297
+ eta32 = self.eta.astype(np.int32)
298
+ sgm = self.tb.sgm
299
+ md_range = np.arange(Nu, dtype=np.int64)
300
+ entr = []
301
+
302
+ def add_chunk(r, c, val):
303
+ ok = (r >= 0) & (c >= 0)
304
+ if ok.any():
305
+ entr.append(coo_matrix((val[ok], (r[ok], c[ok])),
306
+ shape=(dk, dk)).tocsr())
307
+
308
+ def project(row, col, amp):
309
+ # The formula sums t in A|r_b> only: A acts on the orbit
310
+ # REPRESENTATIVE config r_b, not on all |G| translated copies.
311
+ # Summing over all inputs overcounts by |G| coherent copies
312
+ # (factor |G| at k=0, complete cancellation at k!=0 - caught by L4
313
+ # via probe_sym_hk.py: build_hk vs B^+ H_full B).
314
+ keep = rep32[col] == col
315
+ row, col, amp = row[keep], col[keep], amp[keep]
316
+ r = rank[rep32[row]]
317
+ c = rank[rep32[col]]
318
+ ok = (r >= 0) & (c >= 0)
319
+ r, c = r[ok], c[ok]
320
+ t = row[ok]
321
+ e = eta32[t]
322
+ mu_val = masks32[t // Nu]
323
+ md_val = masks32[t % Nu]
324
+ sig = (sgm[e, mu_val] * sgm[e, md_val]).astype(np.float64)
325
+ nrat = n_basis[r] / n_basis[c]
326
+ if real:
327
+ val = amp[ok] * chi_c[e].real * sig * nrat
328
+ else:
329
+ val = amp[ok] * chi_c[e] * sig * nrat
330
+ return r, c, val.astype(dtype)
331
+
332
+ # U diagonal (t = col, eta = 0, sigma = 1, n-ratio = 1)
333
+ step = max(1, (1 << 25) // Nu)
334
+ for i0 in range(0, Nu, step):
335
+ i1 = min(i0 + step, Nu)
336
+ mu = self.masks[i0:i1]
337
+ diag = (self.U * ec.popcount(mu[:, None] & self.masks[None, :])
338
+ ).astype(np.float64).ravel()
339
+ fl = (np.arange(i0, i1, dtype=np.int64)[:, None] * Nu +
340
+ md_range[None, :]).ravel()
341
+ add_chunk(rank[rep32[fl]], rank[fl], diag)
342
+ # hopping: per bond both directions, both spins; amp = -t * fermion sign
343
+ for (p, q) in self.cl.bonds:
344
+ for (a, b) in [(p, q), (q, p)]:
345
+ src, dst, fs = hop_table(self.masks, a, b)
346
+ amp8 = (-fs).astype(np.float64)
347
+ lt = len(src)
348
+ # up spin: axis 0
349
+ row = np.repeat(dst, Nu) * Nu + np.tile(md_range, lt)
350
+ col = np.repeat(src, Nu) * Nu + np.tile(md_range, lt)
351
+ add_chunk(*project(row, col, np.repeat(amp8, Nu)))
352
+ del row, col
353
+ # down spin: axis 1 (row = OUTPUT config (iu, dst), same
354
+ # convention as engine 1's validated matvec; src/dst were
355
+ # swapped in the first version - caught by L4)
356
+ row = np.repeat(md_range, lt) * Nu + np.tile(dst, Nu)
357
+ col = np.repeat(md_range, lt) * Nu + np.tile(src, Nu)
358
+ add_chunk(*project(row, col, np.tile(amp8, Nu)))
359
+ del row, col
360
+ H = entr[0]
361
+ for M in entr[1:]:
362
+ H = H + M
363
+ return H, dk
364
+
365
+ # -- solving --
366
+ def solve_block(self, k1, k2, kk=4):
367
+ H, dk = self.build_hk(k1, k2)
368
+ if dk == 0:
369
+ return np.zeros(0), np.zeros((0, 0))
370
+ kk = min(kk, dk)
371
+ if dk <= DENSE_KMAX:
372
+ w, v = eigh(H.toarray())
373
+ else:
374
+ # No explicit symmetrization: the block is Hermitian by construction
375
+ # (checked numerically in L4); avoids a 2x memory spike on big blocks.
376
+ rs = np.random.RandomState(20260317)
377
+ if H.dtype == np.complex128:
378
+ v0 = rs.standard_normal(dk) + 1j * rs.standard_normal(dk)
379
+ else:
380
+ v0 = rs.standard_normal(dk)
381
+ w, v = eigsh(H, k=kk, which="SA", tol=0.0, v0=v0,
382
+ ncv=min(dk, max(4 * kk + 10, 24)), maxiter=100000)
383
+ o = np.argsort(w[:kk])
384
+ w, v = w[o], v[:, o]
385
+ return np.asarray(w), np.asarray(v)
386
+
387
+ def solve_all(self, kk=4):
388
+ """Solve one representative per k/(-k) mirror pair; store with factor."""
389
+ tb = self.tb
390
+ seen = set()
391
+ for k1 in range(tb.m):
392
+ for k2 in range(tb.n):
393
+ if (k1, k2) in seen:
394
+ continue
395
+ mir = tb.mirror(k1, k2)
396
+ seen.add((k1, k2))
397
+ if mir != (k1, k2):
398
+ seen.add(mir)
399
+ factor = 1 if mir == (k1, k2) else 2
400
+ t0 = _time()
401
+ w, v = self.solve_block(k1, k2, kk=kk)
402
+ self.blocks[(k1, k2)] = dict(w=w, v=v, factor=factor)
403
+ self._log(f"k=({k1},{k2}){'R' if tb.is_real_block(k1, k2) else 'c'} "
404
+ f"dk={len(w)} E0={w[0] if len(w) else float('nan'):.8f} "
405
+ f"[{_time() - t0:.1f}s]")
406
+
407
+ # -- ground shell and P_d --
408
+ def ground_shell(self):
409
+ E0 = min(b["w"][0] for b in self.blocks.values() if len(b["w"]))
410
+ shell = []
411
+ for (k, b) in self.blocks.items():
412
+ idx = np.flatnonzero(b["w"] < E0 + DEGEN_TOL)
413
+ for i in idx:
414
+ shell.append((b["factor"], b["v"][:, i], k))
415
+ return E0, shell
416
+
417
+ def _expand(self, cvec, k1, k2):
418
+ """Expand one k-block vector to the full sector (complex128, (dim,))."""
419
+ basis_flat, n_basis, _ = self.block_basis(k1, k2)
420
+ Nu = self.Nu
421
+ mu_b = self.masks.astype(np.int32)[basis_flat // Nu]
422
+ md_b = self.masks.astype(np.int32)[basis_flat % Nu]
423
+ vfull = np.zeros(self.dim, dtype=np.complex128)
424
+ tm, sg = self.tb.tmask, self.tb.sgm
425
+ masks64 = self.masks
426
+ for g in range(self.tb.NG):
427
+ mu2 = tm[g][mu_b]
428
+ md2 = tm[g][md_b]
429
+ flat2 = (np.searchsorted(masks64, mu2) * Nu +
430
+ np.searchsorted(masks64, md2))
431
+ sgn = (sg[g][mu_b] * sg[g][md_b]).astype(np.float64)
432
+ coef = self.tb.chi(k1, k2).conj()[g] * sgn * cvec / (self.tb.NG * n_basis)
433
+ vfull[flat2] += coef
434
+ return vfull
435
+
436
+ def pd_rmax(self):
437
+ """(P_d(Rmax), npairs, mult, E0) - full pipeline."""
438
+ E0, shell = self.ground_shell()
439
+ cl = self.cl
440
+ ps = PairSpace(cl, self.n)
441
+ pairs = cl.pairs_at_R(cl.rmax)
442
+ und, seen = [], set()
443
+ for (i, j) in pairs:
444
+ key = (min(i, j), max(i, j))
445
+ if key not in seen:
446
+ seen.add(key)
447
+ und.append(key)
448
+ wsum = 0.0
449
+ pd_acc = 0.0
450
+ for (factor, cvec, (k1, k2)) in shell:
451
+ v = self._expand(cvec, k1, k2)[:, None] # (dim, 1) complex
452
+ vals = []
453
+ for (i, j) in und:
454
+ Wi = ps.delta(v, i)
455
+ Wj = ps.delta(v, j)
456
+ m = np.sum(Wj.reshape(-1).conj() * Wi.reshape(-1))
457
+ vals.append(m.real)
458
+ pd_acc += factor * float(np.mean(vals))
459
+ wsum += factor
460
+ return pd_acc / wsum, len(pairs), wsum, E0
461
+
462
+
463
+ def _time():
464
+ import time
465
+ return time.time()
methods/Tuli99/method_ed/fresh_target.json ADDED
@@ -0,0 +1,53 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "scope": "fresh 3x4 finite-cluster ED at delta=1/6; no cached inputs",
3
+ "python": "3.10.20 | packaged by Anaconda, Inc. | (main, Mar 11 2026, 17:42:35) [MSC v.1942 64 bit (AMD64)]",
4
+ "platform": "Windows-10-10.0.26300-SP0",
5
+ "numpy": "1.26.4",
6
+ "scipy": "1.15.3",
7
+ "engine_sha256": "bfa7810b47e242765fd6bf090a696c79fd8a2a465304ea4fac53b55b2149304a",
8
+ "cluster": "3x4",
9
+ "Ns": 12,
10
+ "N_up": 5,
11
+ "N_down": 5,
12
+ "delta": 0.16666666666666666,
13
+ "U_over_t": 8.0,
14
+ "runs": [
15
+ {
16
+ "seed": 20260317,
17
+ "E0": -10.765379110512963,
18
+ "degeneracy": 1,
19
+ "A_d": 0.056826612626876494,
20
+ "residual_max": 1.4233674456192164e-13,
21
+ "orthogonality_error": 5.551115123125783e-15,
22
+ "Rmax": 2.236067977,
23
+ "npairs": 24,
24
+ "seconds": 124.5
25
+ },
26
+ {
27
+ "seed": 104729,
28
+ "E0": -10.765379110512946,
29
+ "degeneracy": 1,
30
+ "A_d": 0.05682661262687705,
31
+ "residual_max": 1.0457968116337151e-13,
32
+ "orthogonality_error": 2.220446049250313e-16,
33
+ "Rmax": 2.236067977,
34
+ "npairs": 24,
35
+ "seconds": 129.97
36
+ },
37
+ {
38
+ "seed": 271828,
39
+ "E0": -10.765379110512967,
40
+ "degeneracy": 1,
41
+ "A_d": 0.05682661262687714,
42
+ "residual_max": 1.2670315141160614e-13,
43
+ "orthogonality_error": 0.0,
44
+ "Rmax": 2.236067977,
45
+ "npairs": 24,
46
+ "seconds": 124.76
47
+ }
48
+ ],
49
+ "complete": true,
50
+ "energy_spread": 2.1316282072803006e-14,
51
+ "A_d_spread": 6.453171330633722e-16,
52
+ "passed": true
53
+ }
methods/Tuli99/method_ed/material_inputs.json ADDED
@@ -0,0 +1,72 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "source": "https://huggingface.co/datasets/FINAL-Bench/OSC-Superconductor/raw/main/active_challenge.csv",
3
+ "retrieved_date": "2026-10-21",
4
+ "materials": {
5
+ "OSC-00747": {
6
+ "osc_id": "OSC-00747",
7
+ "material_id": "2NiS-5",
8
+ "c2db_uid": "2NiS-5",
9
+ "formula": "Ni2S2",
10
+ "family": "discovery",
11
+ "weight_class": "light",
12
+ "sc_relevance": "",
13
+ "status": "ok",
14
+ "t_ev": "0.25142",
15
+ "U_ev": "2.01136",
16
+ "U_over_t": "8.0",
17
+ "ef_scf_ev": "-0.857",
18
+ "n_band": "0.8435",
19
+ "delta_hole": "",
20
+ "solver_delta": "0.1667",
21
+ "nef": "1.40205",
22
+ "nef_method": "gaussian_dos_scf_mesh",
23
+ "A_dwave": "0.05569",
24
+ "runtime_s": "",
25
+ "ph_mapped": ""
26
+ },
27
+ "OSC-00754": {
28
+ "osc_id": "OSC-00754",
29
+ "material_id": "2NiTe-5",
30
+ "c2db_uid": "2NiTe-5",
31
+ "formula": "Ni2Te2",
32
+ "family": "discovery",
33
+ "weight_class": "light",
34
+ "sc_relevance": "",
35
+ "status": "ok",
36
+ "t_ev": "0.24796",
37
+ "U_ev": "1.98368",
38
+ "U_over_t": "8.0",
39
+ "ef_scf_ev": "-0.3644",
40
+ "n_band": "0.8419",
41
+ "delta_hole": "",
42
+ "solver_delta": "0.1667",
43
+ "nef": "1.4494",
44
+ "nef_method": "gaussian_dos_scf_mesh",
45
+ "A_dwave": "0.05569",
46
+ "runtime_s": "",
47
+ "ph_mapped": ""
48
+ },
49
+ "OSC-01665": {
50
+ "osc_id": "OSC-01665",
51
+ "material_id": "2CuNiI3-1",
52
+ "c2db_uid": "2CuNiI3-1",
53
+ "formula": "Cu2I6Ni2",
54
+ "family": "discovery",
55
+ "weight_class": "light",
56
+ "sc_relevance": "",
57
+ "status": "ok",
58
+ "t_ev": "0.05271",
59
+ "U_ev": "0.42168",
60
+ "U_over_t": "8.0",
61
+ "ef_scf_ev": "-0.8024",
62
+ "n_band": "0.8692",
63
+ "delta_hole": "",
64
+ "solver_delta": "0.1667",
65
+ "nef": "1.58283",
66
+ "nef_method": "gaussian_dos_scf_mesh",
67
+ "A_dwave": "0.05569",
68
+ "runtime_s": "",
69
+ "ph_mapped": ""
70
+ }
71
+ }
72
+ }
methods/Tuli99/method_ed/reproduce_target.py ADDED
@@ -0,0 +1,77 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Fresh independent-start ED of the submitted 3x4, N_up=N_down=5 point.
2
+
3
+ This never reads results_4x4.json or ad_table_own.json. The existing ED engine
4
+ is unchanged; only its Lanczos starting vector is overridden per run.
5
+ """
6
+ import argparse
7
+ import hashlib
8
+ import json
9
+ import platform
10
+ import sys
11
+ import time
12
+ from pathlib import Path
13
+
14
+ import numpy as np
15
+ import scipy
16
+ import ed_core as ec
17
+
18
+ HERE = Path(__file__).resolve().parent
19
+
20
+
21
+ class IndependentStartED(ec.SectorED):
22
+ def __init__(self, *args, seed, **kwargs):
23
+ self.seed = seed
24
+ super().__init__(*args, **kwargs)
25
+
26
+ def _v0(self):
27
+ v = np.random.RandomState(self.seed).standard_normal(self.dim)
28
+ return v / np.linalg.norm(v)
29
+
30
+
31
+ def main():
32
+ ap = argparse.ArgumentParser(description=__doc__)
33
+ ap.add_argument('--seeds', nargs='+', type=int,
34
+ default=[20260317, 104729, 271828])
35
+ ap.add_argument('--output', type=Path, default=HERE / 'fresh_target.json')
36
+ args = ap.parse_args()
37
+ report = {
38
+ 'scope': 'fresh 3x4 finite-cluster ED at delta=1/6; no cached inputs',
39
+ 'python': sys.version, 'platform': platform.platform(),
40
+ 'numpy': np.__version__, 'scipy': scipy.__version__,
41
+ 'engine_sha256': hashlib.sha256((HERE / 'ed_core.py').read_bytes()).hexdigest(),
42
+ 'cluster': '3x4', 'Ns': 12, 'N_up': 5, 'N_down': 5,
43
+ 'delta': 1 / 6, 'U_over_t': 8.0, 'runs': [], 'complete': False,
44
+ }
45
+ cl = ec.cluster_3x4()
46
+ for seed in args.seeds:
47
+ t0 = time.perf_counter()
48
+ ed = IndependentStartED(cl, 5, U=8.0, seed=seed)
49
+ energy, vectors = ed.solve_gs()
50
+ pd, npairs = ec.PairOps(ed).pd_at_R(vectors, cl.rmax)
51
+ residuals = [float(np.linalg.norm(ed.matvec(vectors[:, i]) -
52
+ energy * vectors[:, i]))
53
+ for i in range(vectors.shape[1])]
54
+ orth = float(np.max(np.abs(vectors.T @ vectors - np.eye(vectors.shape[1]))))
55
+ row = dict(seed=seed, E0=energy, degeneracy=vectors.shape[1], A_d=pd,
56
+ residual_max=max(residuals), orthogonality_error=orth,
57
+ Rmax=cl.rmax, npairs=npairs,
58
+ seconds=round(time.perf_counter() - t0, 2))
59
+ report['runs'].append(row)
60
+ args.output.write_text(json.dumps(report, indent=2) + '\n', encoding='utf-8')
61
+ print(json.dumps(row), flush=True)
62
+ if row['residual_max'] > 1e-8 or orth > 1e-9 or vectors.shape[1] != 1:
63
+ raise SystemExit('Fresh target residual/orthogonality/degeneracy check failed')
64
+ del ed, vectors
65
+ energies = [r['E0'] for r in report['runs']]
66
+ values = [r['A_d'] for r in report['runs']]
67
+ report['energy_spread'] = max(energies) - min(energies)
68
+ report['A_d_spread'] = max(values) - min(values)
69
+ report['passed'] = report['energy_spread'] < 1e-8 and report['A_d_spread'] < 1e-8
70
+ report['complete'] = True
71
+ args.output.write_text(json.dumps(report, indent=2) + '\n', encoding='utf-8')
72
+ print('Independent-start check:', 'PASS' if report['passed'] else 'FAIL', flush=True)
73
+ raise SystemExit(0 if report['passed'] else 1)
74
+
75
+
76
+ if __name__ == '__main__':
77
+ main()
methods/Tuli99/method_ed/requirements.txt ADDED
@@ -0,0 +1,2 @@
 
 
 
1
+ numpy==1.26.4
2
+ scipy==1.15.3
methods/Tuli99/method_ed/results_4x4.json ADDED
@@ -0,0 +1,178 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "1": {
3
+ "cluster": "4x4",
4
+ "Ne": 1,
5
+ "n": 0.125,
6
+ "delta": 0.875,
7
+ "dim": 256,
8
+ "E0": -7.764090590903901,
9
+ "deg": 1,
10
+ "P_org_U8": 7.222237291452134e-35,
11
+ "P_org_U0": 1.3552527156068805e-19,
12
+ "npairs": 16,
13
+ "Rmax": 2.828427125,
14
+ "sec": 1.0
15
+ },
16
+ "2": {
17
+ "cluster": "4x4",
18
+ "Ne": 2,
19
+ "n": 0.25,
20
+ "delta": 0.75,
21
+ "dim": 14400,
22
+ "E0": -11.32149713321177,
23
+ "deg": 3,
24
+ "P_org_U8": 0.012094024007304124,
25
+ "P_org_U0": 3.9607260613611084e-18,
26
+ "npairs": 16,
27
+ "Rmax": 2.828427125,
28
+ "sec": 2.2
29
+ },
30
+ "3": {
31
+ "cluster": "4x4",
32
+ "Ne": 3,
33
+ "n": 0.375,
34
+ "delta": 0.625,
35
+ "dim": 313600,
36
+ "E0": -14.723540317907524,
37
+ "deg": 1,
38
+ "P_org_U8": -0.013730852586326413,
39
+ "P_org_U0": 0.015625000000000017,
40
+ "npairs": 16,
41
+ "Rmax": 2.828427125,
42
+ "sec": 50.7
43
+ },
44
+ "4": {
45
+ "cluster": "4x4",
46
+ "Ne": 4,
47
+ "n": 0.5,
48
+ "delta": 0.5,
49
+ "dim": 3312400,
50
+ "E0": -16.46062675368174,
51
+ "deg": 3,
52
+ "P_org_U8": 0.048075923542662026,
53
+ "P_org_U0": 0.046875000000000035,
54
+ "npairs": 16,
55
+ "Rmax": 2.828427125,
56
+ "sec": 935.6
57
+ },
58
+ "5": {
59
+ "cluster": "4x4",
60
+ "Ne": 5,
61
+ "n": 0.625,
62
+ "delta": 0.375,
63
+ "dim": 19079424,
64
+ "E0": -17.510366694878634,
65
+ "deg": 1,
66
+ "P_org_U8": 0.06012194560348784,
67
+ "P_org_U0": 0.09375000000000006,
68
+ "npairs": 16,
69
+ "Rmax": 2.828427125,
70
+ "engine": "sym-projection",
71
+ "sec": 775.3
72
+ },
73
+ "6": {
74
+ "cluster": "4x4",
75
+ "Ne": 6,
76
+ "n": 0.75,
77
+ "delta": 0.25,
78
+ "dim": 64128064,
79
+ "E0": -14.925310215108519,
80
+ "deg": 2,
81
+ "P_org_U8": 0.009831080963260455,
82
+ "P_org_U0": 0.0416666666666667,
83
+ "npairs": 16,
84
+ "Rmax": 2.828427125,
85
+ "engine": "sym-projection",
86
+ "sec": 3775.5
87
+ },
88
+ "7": {
89
+ "cluster": "4x4",
90
+ "Ne": 7,
91
+ "n": 0.875,
92
+ "delta": 0.125,
93
+ "dim": 130873600,
94
+ "E0": -11.86883556956405,
95
+ "deg": 3,
96
+ "P_org_U8": 0.019219005559767213,
97
+ "P_org_U0": 0.01041666666666668,
98
+ "npairs": 16,
99
+ "Rmax": 2.828427125,
100
+ "engine": "sym-projection",
101
+ "sec": 8545.6
102
+ },
103
+ "8": {
104
+ "cluster": "4x4",
105
+ "Ne": 8,
106
+ "n": 1.0,
107
+ "delta": 0.0,
108
+ "dim": 165636900,
109
+ "E0": -8.468875014196815,
110
+ "deg": 1,
111
+ "P_org_U8": 0.0061970902582232975,
112
+ "P_org_U0": -9.486769009248164e-20,
113
+ "npairs": 16,
114
+ "Rmax": 2.828427125,
115
+ "engine": "sym-projection",
116
+ "sec": 9602.0
117
+ },
118
+ "12": {
119
+ "cluster": "4x4",
120
+ "Ne": 12,
121
+ "n": 1.5,
122
+ "delta": -0.5,
123
+ "dim": 3312400,
124
+ "E0": 47.5393732463182,
125
+ "deg": 3,
126
+ "P_org_U8": 0.04807592354266225,
127
+ "P_org_U0": 0.046875,
128
+ "npairs": 16,
129
+ "Rmax": 2.828427125,
130
+ "engine": "sym-projection",
131
+ "sec": 232.8
132
+ },
133
+ "13": {
134
+ "cluster": "4x4",
135
+ "Ne": 13,
136
+ "n": 1.625,
137
+ "delta": -0.625,
138
+ "dim": 313600,
139
+ "E0": 65.2764596820923,
140
+ "deg": 1,
141
+ "P_org_U8": -0.013730852586326406,
142
+ "P_org_U0": 0.015624999999999995,
143
+ "npairs": 16,
144
+ "Rmax": 2.828427125,
145
+ "engine": "sym-projection",
146
+ "sec": 14.1
147
+ },
148
+ "14": {
149
+ "cluster": "4x4",
150
+ "Ne": 14,
151
+ "n": 1.75,
152
+ "delta": -0.75,
153
+ "dim": 14400,
154
+ "E0": 84.67850286678824,
155
+ "deg": 3,
156
+ "P_org_U8": 0.012094024007303987,
157
+ "P_org_U0": -3.791319471910248e-18,
158
+ "npairs": 16,
159
+ "Rmax": 2.828427125,
160
+ "engine": "sym-projection",
161
+ "sec": 7.8
162
+ },
163
+ "15": {
164
+ "cluster": "4x4",
165
+ "Ne": 15,
166
+ "n": 1.875,
167
+ "delta": -0.875,
168
+ "dim": 256,
169
+ "E0": 104.2359094090961,
170
+ "deg": 1,
171
+ "P_org_U8": -3.1170812458958252e-19,
172
+ "P_org_U0": 1.0570971181733668e-18,
173
+ "npairs": 16,
174
+ "Rmax": 2.828427125,
175
+ "engine": "sym-projection",
176
+ "sec": 1.6
177
+ }
178
+ }
methods/Tuli99/method_ed/run_4x4.py ADDED
@@ -0,0 +1,93 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """4x4 Hubbard ED (engine-1, validated 19/19 vs ku-ku) for the gold-track A_d(delta) table.
3
+
4
+ Computes E0(U=8), GS degeneracy, P_org(Rmax) and the U=0 Wick reference for
5
+ Ne = 1..4 and their particle-hole mirrors Ne = 12..15.
6
+
7
+ Purpose of the Ne = 12..15 rows: DIRECT numeric test of the PHS theorem
8
+ A_d(Ne) = A_d(16-Ne) on the 4x4 cluster (they are on the electron-doped side,
9
+ delta = 1 - n < 0, and are excluded from the hole-doped dome curve in
10
+ ad_table.py). The 4x4 dome points delta in [0.1, 0.3] correspond to
11
+ Ne = 6, 7 (n = 0.75, 0.875) and need the momentum-projection engine (ed_sym).
12
+ Ne = 1..4 cross-check the ku-ku 4x4 rows (their un-cross-checked phase6 code)
13
+ - an independent validation the reference table lacks.
14
+
15
+ Usage: python run_4x4.py [Ne ...] default: 1 2 3 4 12 13 14 15
16
+ Output: results_4x4.json (dict Ne -> record; rewritten after each finished Ne)
17
+ """
18
+ import sys, json, os, time
19
+ import numpy as np
20
+ import ed_core as ec
21
+
22
+ HERE = os.path.dirname(os.path.abspath(__file__))
23
+ OUT = os.path.join(HERE, "results_4x4.json")
24
+
25
+ # ku-ku 4x4 rows (multisize_ED_table_kuku.md) - their phase6 code was NOT
26
+ # cross-checked against their own smaller-cluster code, so differences here
27
+ # are informative, not automatically our error (our engine passed 19/19).
28
+ KUKU_4X4 = {
29
+ 1: (-7.76409059, 1, 0.0),
30
+ 2: (-11.32149713, 3, 0.0120940),
31
+ 3: (-14.72354031, 1, -0.0137308),
32
+ 4: (-16.46062675, 3, 0.0480759),
33
+ 5: (-17.51036669, 1, 0.0601219),
34
+ 6: (-14.92531021, 2, 0.00983108),
35
+ 7: (-11.86883556, 3, 0.0192190),
36
+ 8: (-8.46887501, 1, 0.00619709),
37
+ }
38
+ TOL_E, TOL_P = 5e-7, 2e-6
39
+
40
+
41
+ def run_ne(cl, ne):
42
+ t0 = time.time()
43
+ ed = ec.SectorED(cl, ne, U=8.0)
44
+ E0, vecs = ed.solve_gs()
45
+ deg = vecs.shape[1]
46
+ pops = ec.PairOps(ed)
47
+ p8, npair = pops.pd_at_R(vecs, cl.rmax)
48
+ p0, _ = ec.wick_u0(cl, ne, cl.rmax)
49
+ rec = dict(cluster="4x4", Ne=ne, n=round(2.0 * ne / cl.Ns, 6),
50
+ delta=round(1.0 - 2.0 * ne / cl.Ns, 6),
51
+ dim=ed.dim, E0=E0, deg=deg, P_org_U8=p8, P_org_U0=p0,
52
+ npairs=npair, Rmax=cl.rmax, sec=round(time.time() - t0, 1))
53
+ return rec
54
+
55
+
56
+ def main():
57
+ nes = [int(x) for x in sys.argv[1:]] or [1, 2, 3, 4, 12, 13, 14, 15]
58
+ cl = ec.cluster_4x4()
59
+ results = {}
60
+ if os.path.exists(OUT):
61
+ try:
62
+ results = json.load(open(OUT))
63
+ except Exception:
64
+ results = {}
65
+ for ne in nes:
66
+ if str(ne) in results:
67
+ print(f"[skip] Ne={ne} already done", flush=True)
68
+ continue
69
+ print(f"\n=== 4x4 Ne={ne} (n={2*ne/16:.4f}, delta={1-2*ne/16:.4f}) ===", flush=True)
70
+ rec = run_ne(cl, ne)
71
+ results[str(ne)] = rec
72
+ # cross-check vs ku-ku where available
73
+ chk = ""
74
+ if ne in KUKU_4X4:
75
+ e0r, dr, pr = KUKU_4X4[ne]
76
+ ok = (abs(rec["E0"] - e0r) < TOL_E and rec["deg"] == dr
77
+ and abs(rec["P_org_U8"] - pr) < TOL_P)
78
+ chk = f" ku-ku: E0={e0r} deg={dr} P={pr} -> {'MATCH' if ok else 'DIFFER'}"
79
+ # PHS mirror check
80
+ mir = results.get(str(16 - ne))
81
+ phs = ""
82
+ if mir:
83
+ d = abs(rec["P_org_U8"] - mir["P_org_U8"])
84
+ phs = f" PHS vs Ne={16-ne}: dP={d:.2e} {'OK' if d < 1e-6 else 'VIOLATED'}"
85
+ print(f" dim={rec['dim']} E0={rec['E0']:.8f} deg={rec['deg']} "
86
+ f"P_org(U8)={rec['P_org_U8']:.8f} P_org(U0)={rec['P_org_U0']:.8f} "
87
+ f"[{rec['sec']}s]{chk}{phs}", flush=True)
88
+ json.dump(results, open(OUT, "w"), indent=1)
89
+ print("\n[done] results_4x4.json written", flush=True)
90
+
91
+
92
+ if __name__ == "__main__":
93
+ main()
methods/Tuli99/method_ed/run_all.py ADDED
@@ -0,0 +1,65 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Fresh submission reproduction, cached audit, or isolated full ED rebuild.
2
+
3
+ submission (default): recompute the actual submitted 3x4 point using three
4
+ independent starts, audit cached 27-point evidence, regenerate submissions.
5
+ cached: no eigensolves; audit supplied records and regenerate submissions.
6
+ full: copy inputs/sources to a new directory and recompute every ED point.
7
+ Full reproduction takes many hours and substantial memory, not 45-60 minutes.
8
+ """
9
+ import argparse
10
+ import datetime
11
+ import os
12
+ from pathlib import Path
13
+ import shutil
14
+ import subprocess
15
+ import sys
16
+
17
+ HERE = Path(__file__).resolve().parent
18
+
19
+
20
+ def sh(args, cwd=HERE):
21
+ print("\n>>> " + " ".join(map(str, args)), flush=True)
22
+ subprocess.run([sys.executable, *map(str, args)], cwd=cwd, check=True)
23
+
24
+
25
+ def full_run(author):
26
+ stamp = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%dT%H%M%SZ")
27
+ runroot = HERE.parent / "reproduction_runs" / stamp
28
+ target = runroot / "method_ed"
29
+ target.mkdir(parents=True)
30
+ for p in HERE.glob("*.py"):
31
+ shutil.copy2(p, target / p.name)
32
+ shutil.copy2(HERE / "material_inputs.json", target)
33
+ for p in HERE.parent.glob("submission_OSC-*.json"):
34
+ shutil.copy2(p, runroot / p.name)
35
+ shutil.copytree(HERE.parent / "validation", runroot / "validation")
36
+ sh(["validate_ed.py"], target)
37
+ sh(["test_sym.py", "L1", "L2", "L3", "L4", "L5"], target)
38
+ sh(["run_4x4.py", "1", "2", "3", "4"], target)
39
+ sh(["run_sym_4x4.py", "5", "6", "7", "8", "12", "13", "14", "15"], target)
40
+ sh(["ad_table.py"], target)
41
+ sh(["reproduce_target.py"], target)
42
+ sh(["audit_results.py"], target)
43
+ sh(["submit_gold.py", "--author", author], target)
44
+ print("Fresh full reproduction saved to:", runroot, flush=True)
45
+
46
+
47
+ def main():
48
+ ap = argparse.ArgumentParser(description=__doc__)
49
+ ap.add_argument("--mode", choices=["submission", "cached", "full"], default="submission")
50
+ ap.add_argument("--author", default="Tuli99")
51
+ args = ap.parse_args()
52
+ for name in ["OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"]:
53
+ os.environ.setdefault(name, "4")
54
+ if args.mode == "full":
55
+ full_run(args.author)
56
+ else:
57
+ if args.mode == "submission":
58
+ sh(["reproduce_target.py"])
59
+ sh(["audit_results.py"])
60
+ sh(["submit_gold.py", "--author", args.author])
61
+ print("All requested checks passed.", flush=True)
62
+
63
+
64
+ if __name__ == "__main__":
65
+ main()
methods/Tuli99/method_ed/run_full.sh ADDED
@@ -0,0 +1,7 @@
 
 
 
 
 
 
 
 
1
+ #!/usr/bin/env bash
2
+ set -euo pipefail
3
+ cd "$(dirname "$0")"
4
+ export OMP_NUM_THREADS="${OMP_NUM_THREADS:-4}"
5
+ export MKL_NUM_THREADS="${MKL_NUM_THREADS:-4}"
6
+ export OPENBLAS_NUM_THREADS="${OPENBLAS_NUM_THREADS:-4}"
7
+ "${PYTHON:-python3}" run_all.py --mode full --author Tuli99
methods/Tuli99/method_ed/run_submission.ps1 ADDED
@@ -0,0 +1,11 @@
 
 
 
 
 
 
 
 
 
 
 
 
1
+ param([string]$Python = 'python')
2
+ $ErrorActionPreference = 'Stop'
3
+ $env:PYTHONUTF8 = '1'
4
+ if (-not $env:OMP_NUM_THREADS) { $env:OMP_NUM_THREADS = '4' }
5
+ if (-not $env:MKL_NUM_THREADS) { $env:MKL_NUM_THREADS = '4' }
6
+ if (-not $env:OPENBLAS_NUM_THREADS) { $env:OPENBLAS_NUM_THREADS = '4' }
7
+ Push-Location $PSScriptRoot
8
+ try {
9
+ & $Python run_all.py --mode submission --author Tuli99
10
+ if ($LASTEXITCODE -ne 0) { throw "Reproduction failed: exit $LASTEXITCODE" }
11
+ } finally { Pop-Location }
methods/Tuli99/method_ed/run_submission.sh ADDED
@@ -0,0 +1,7 @@
 
 
 
 
 
 
 
 
1
+ #!/usr/bin/env bash
2
+ set -euo pipefail
3
+ cd "$(dirname "$0")"
4
+ export OMP_NUM_THREADS="${OMP_NUM_THREADS:-4}"
5
+ export MKL_NUM_THREADS="${MKL_NUM_THREADS:-4}"
6
+ export OPENBLAS_NUM_THREADS="${OPENBLAS_NUM_THREADS:-4}"
7
+ "${PYTHON:-python3}" run_all.py --mode submission --author Tuli99
methods/Tuli99/method_ed/run_sym_4x4.py ADDED
@@ -0,0 +1,89 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """4x4 momentum-projected ED (engine-2, ed_sym.py) for the sectors engine-1
3
+ cannot reach on 32GB RAM:
4
+ n = 5..8 electrons per spin (full-sector dims C(16,n)^2 = 19M..166M;
5
+ dome points: delta = 0.25 at n=6, delta = 0.125 at n=7)
6
+ n = 12..15 (particle-hole mirrors of 4..1: DIRECT numeric
7
+ test of A_d(Ne) = A_d(16-Ne); excluded from the dome curve by ad_table.py)
8
+
9
+ Engine-2 was validated by test_sym.py L1-L5 (14/14 points: E0 to 4e-10,
10
+ P_d to 3.9e-7 vs the ku-ku reference / engine-1). Same record schema as
11
+ run_4x4.py, same cache file results_4x4.json (breakpoint resume: finished
12
+ Ne are skipped). Records carry an extra "engine" field for traceability.
13
+
14
+ Usage: python run_sym_4x4.py [Ne ...] default: 5 6 7 8 12 13 14 15
15
+ Output: results_4x4.json (rewritten after each finished Ne)
16
+ """
17
+ import sys, json, os, time
18
+ import numpy as np
19
+ import ed_core as ec
20
+ import ed_sym as es
21
+
22
+ HERE = os.path.dirname(os.path.abspath(__file__))
23
+ OUT = os.path.join(HERE, "results_4x4.json")
24
+
25
+ # ku-ku 4x4 rows for n = 5..8 (multisize_ED_table_kuku.md). Their phase6 code
26
+ # was not cross-checked against their own smaller clusters; differences here
27
+ # are informative, not automatically our error (engine-2 passed L1-L5).
28
+ KUKU_4X4 = {
29
+ 5: (-17.51036669, 1, 0.0601219),
30
+ 6: (-14.92531021, 2, 0.00983108),
31
+ 7: (-11.86883556, 3, 0.0192190),
32
+ 8: (-8.46887501, 1, 0.00619709),
33
+ }
34
+ TOL_E, TOL_P = 5e-7, 2e-6
35
+ KK = 6 # eigsh states per block (all known 4x4 shells are <= 3-fold)
36
+
37
+
38
+ def run_ne(cl, ne):
39
+ t0 = time.time()
40
+ ed = es.SymED(cl, ne, U=8.0, verbose=True)
41
+ ed.solve_all(kk=KK)
42
+ p8, npair, mult, E0 = ed.pd_rmax()
43
+ p0, _ = ec.wick_u0(cl, ne, cl.rmax)
44
+ rec = dict(cluster="4x4", Ne=ne, n=round(2.0 * ne / cl.Ns, 6),
45
+ delta=round(1.0 - 2.0 * ne / cl.Ns, 6),
46
+ dim=ed.dim, E0=E0, deg=int(mult), P_org_U8=p8, P_org_U0=p0,
47
+ npairs=npair, Rmax=cl.rmax, engine="sym-projection",
48
+ sec=round(time.time() - t0, 1))
49
+ return rec
50
+
51
+
52
+ def main():
53
+ nes = [int(x) for x in sys.argv[1:]] or [5, 6, 7, 8, 12, 13, 14, 15]
54
+ cl = ec.cluster_4x4()
55
+ results = {}
56
+ if os.path.exists(OUT):
57
+ try:
58
+ results = json.load(open(OUT))
59
+ except Exception:
60
+ results = {}
61
+ for ne in nes:
62
+ if str(ne) in results:
63
+ print(f"[skip] Ne={ne} already done", flush=True)
64
+ continue
65
+ print(f"\n=== 4x4 Ne={ne} (n={2*ne/16:.4f}, delta={1-2*ne/16:.4f}) "
66
+ f"[engine-2 momentum projection] ===", flush=True)
67
+ rec = run_ne(cl, ne)
68
+ results[str(ne)] = rec
69
+ chk = ""
70
+ if ne in KUKU_4X4:
71
+ e0r, dr, pr = KUKU_4X4[ne]
72
+ ok = (abs(rec["E0"] - e0r) < TOL_E and rec["deg"] == dr
73
+ and abs(rec["P_org_U8"] - pr) < TOL_P)
74
+ chk = f" ku-ku: E0={e0r} deg={dr} P={pr} -> {'MATCH' if ok else 'DIFFER'}"
75
+ # PHS mirror check vs the already-stored mirror row (engine-1 for 1..4)
76
+ mir = results.get(str(16 - ne))
77
+ phs = ""
78
+ if mir:
79
+ d = abs(rec["P_org_U8"] - mir["P_org_U8"])
80
+ phs = f" PHS vs Ne={16-ne}: dP={d:.2e} {'OK' if d < 1e-6 else 'VIOLATED'}"
81
+ print(f" dim={rec['dim']} E0={rec['E0']:.8f} deg={rec['deg']} "
82
+ f"P_org(U8)={rec['P_org_U8']:.8f} P_org(U0)={rec['P_org_U0']:.8f} "
83
+ f"[{rec['sec']}s]{chk}{phs}", flush=True)
84
+ json.dump(results, open(OUT, "w"), indent=1)
85
+ print("\n[done] results_4x4.json written", flush=True)
86
+
87
+
88
+ if __name__ == "__main__":
89
+ main()
methods/Tuli99/method_ed/submit_gold.py ADDED
@@ -0,0 +1,123 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Produce gold/method-track submissions using our own ED A_d(delta).
3
+
4
+ Reads the existing light-track submissions (material parameters) and the own
5
+ dome curve (ad_table_own.json, built by ad_table.py from two validated ED
6
+ engines: full-sector ED + momentum-projection ED, 27/27 match vs the published
7
+ independent ED reference), re-scores each material
8
+ with A_d_own(delta) and writes submission_gold_<id>.json with track="gold".
9
+
10
+ Method summary (goes into each submission):
11
+ H = -t sum (c^+c + h.c.) + U n_up n_down, U/t = 8, Sz = 0, periodic clusters
12
+ 2x4 / sqrt8 / sqrt10 / 3x4 / 4x4; A_d(delta) = P_org(R_max) = d-wave pair
13
+ correlator at largest min-image distance, degenerate GS shell equal-weight.
14
+ Engines validated 27/27 against the published independent ED (19 small-cluster
15
+ points + 4x4 Ne=1..4 via full ED + 4x4 Ne=5..8 via momentum-projection ED),
16
+ plus Wick U=0 cross-checks and the numeric particle-hole test
17
+ A_d(Ne) = A_d(16-Ne) on 4x4 (Ne=12..15, dP <= 2.3e-16).
18
+ """
19
+ import argparse, json, os, glob, hashlib
20
+
21
+ HERE = os.path.dirname(os.path.abspath(__file__))
22
+ TAB = os.path.join(HERE, "ad_table_own.json")
23
+ METHOD_NAME = "own-ED-Hubbard U/t=8 (validated vs independent ED)"
24
+ METHOD_NOTE = {
25
+ "model": "square-lattice Hubbard, H=-t(sum c+c + h.c.) + U n_up n_dn, U/t=8, Sz=0",
26
+ "clusters": ["2x4", "sqrt8", "sqrt10", "3x4", "4x4"],
27
+ "observable": "A_d = P_org(R_max) = <Delta_d^+(j) Delta_d(i)>, organizer normalization",
28
+ "engine": ("matrix-free Sz=0 ED (Lanczos+deflation, dense for dim<=8000); "
29
+ "4x4 Ne=5..8 via momentum-projection ED (translation group Z4xZ4, "
30
+ "per-k Lanczos on projected blocks, dim/16)"),
31
+ "U0_check": "canonical Wick vs ED U=0 agreement on all small clusters",
32
+ "validation": "27/27 match vs published independent ED (19 small-cluster pts + "
33
+ "4x4 Ne=1..4 full-ED + 4x4 Ne=5..8 momentum-projection, E0 diff <=1e-8); "
34
+ "PHS A_d(Ne)=A_d(16-Ne) verified numerically on 4x4 (Ne=12..15, dP<=2.3e-16)",
35
+ "limitations": "Exact only on the stated finite clusters. Different sizes/shapes/Rmax "
36
+ "are not a converged thermodynamic sequence. No claim that 3x4 improves "
37
+ "the organizer 6x6 estimate; claimed scores await organizer reproduction "
38
+ "and do not override canonical leaderboard scores.",
39
+ "particle_number_convention": "Ne in result tables means N_up=N_down, not total electrons; "
40
+ "density=2*Ne/Ns and delta=1-density.",
41
+ }
42
+
43
+
44
+ def main():
45
+ ap = argparse.ArgumentParser()
46
+ ap.add_argument('--author', required=True)
47
+ args = ap.parse_args()
48
+ curve = json.load(open(TAB))["curve"]
49
+ inputs = json.load(open(os.path.join(HERE, 'material_inputs.json'), encoding='utf-8'))
50
+ fresh_path = os.path.join(HERE, 'fresh_target.json')
51
+ fresh = json.load(open(fresh_path, encoding='utf-8')) if os.path.exists(fresh_path) else None
52
+ if fresh is not None:
53
+ engine_hash = hashlib.sha256(open(os.path.join(HERE, 'ed_core.py'), 'rb').read()).hexdigest()
54
+ if not (fresh.get('complete') and fresh.get('passed') and
55
+ fresh.get('engine_sha256') == engine_hash):
56
+ raise SystemExit('fresh_target.json is incomplete, failed, or refers to another engine')
57
+
58
+ def ad_of(delta):
59
+ xs = [c["delta"] for c in curve]
60
+ ys = [c["A_d"] for c in curve]
61
+ # solver_delta is rounded in the challenge table (e.g. "0.1667" = 1/6);
62
+ # match grid points to that granularity
63
+ for x, y, c in zip(xs, ys, curve):
64
+ if round(x, 4) == round(delta, 4):
65
+ return y, "exact", f"{c['cluster']} Ne={c['Ne']}"
66
+ if delta <= xs[0]:
67
+ return ys[0], "clamped-low", None
68
+ if delta >= xs[-1]:
69
+ return ys[-1], "clamped-high", None
70
+ import bisect
71
+ i = bisect.bisect_left(xs, delta)
72
+ x0, x1, y0, y1 = xs[i - 1], xs[i], ys[i - 1], ys[i]
73
+ return (y0 + (y1 - y0) * (delta - x0) / (x1 - x0),
74
+ f"interp({x0},{x1})", None)
75
+
76
+ for osc_id, canonical in sorted(inputs['materials'].items()):
77
+ base = dict(material_id=osc_id, t=float(canonical['t_ev']),
78
+ U=float(canonical['U_ev']), nef=float(canonical['nef']),
79
+ U_over_t=float(canonical['U_over_t']),
80
+ solver_delta=canonical['solver_delta'],
81
+ A_dwave=float(canonical['A_dwave']))
82
+ base['provisional_score'] = round(base['nef'] * max(0, base['A_dwave']) * 300, 3)
83
+ delta = float(base["solver_delta"])
84
+ a_d, how, src = ad_of(delta)
85
+ if fresh is not None and round(delta, 4) == round(fresh['delta'], 4):
86
+ a_d = fresh['runs'][0]['A_d']
87
+ osc_id = base['material_id']
88
+ canonical = inputs['materials'][osc_id]
89
+ for key, source in [('nef', 'nef'), ('t', 't_ev'), ('U', 'U_ev')]:
90
+ if abs(float(base[key]) - float(canonical[source])) > 1e-10:
91
+ raise SystemExit(f'{osc_id}: stale {key}; refresh inputs and rerun')
92
+ if delta != float(canonical['solver_delta']):
93
+ raise SystemExit(f'{osc_id}: stale solver_delta')
94
+ score = round(base["nef"] * a_d * 300.0, 3)
95
+ if a_d <= 0:
96
+ level = "off-dome — no d-wave at this filling"
97
+ elif score >= 15:
98
+ level = "STRONG d-wave candidate"
99
+ elif score >= 8:
100
+ level = "MODERATE"
101
+ elif score >= 2:
102
+ level = "WEAK"
103
+ else:
104
+ level = "negligible"
105
+ sub = dict(base)
106
+ sub.update(author=args.author, osc_id=osc_id,
107
+ material_id=canonical['material_id'], formula=canonical['formula'],
108
+ A_dwave=round(a_d, 8), provisional_score=score, level=level,
109
+ method_name=METHOD_NAME, track="gold", method=METHOD_NOTE,
110
+ A_d_source=dict(rule=how, point=src,
111
+ finite_cluster_exact=True,
112
+ delta_matching='official solver_delta rounded to 4 decimals',
113
+ fresh_independent_starts=len(fresh['runs']) if fresh else 0,
114
+ baseline_published_A_d=base["A_dwave"],
115
+ ratio_own_vs_published=round(a_d / base["A_dwave"], 4)))
116
+ out = os.path.join(HERE, "..", f"submission_gold_{osc_id}.json")
117
+ json.dump(sub, open(out, "w"), indent=1)
118
+ print(f"{base['material_id']}: delta={delta} A_d_own={a_d:.6f} [{how}] "
119
+ f"score {base['provisional_score']} -> {score} -> {os.path.basename(out)}")
120
+
121
+
122
+ if __name__ == "__main__":
123
+ main()
methods/Tuli99/method_ed/test_sym.py ADDED
@@ -0,0 +1,268 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Layered tests for engine 2 (ed_sym) - WORKLOG 7.6. Run layers IN ORDER;
3
+ do not skip a failing layer.
4
+
5
+ Usage: python test_sym.py [L1 L2 L3 L4 L5] (default: all, sequential)
6
+
7
+ L1 group law of the signed translation operators (mask tables + vectors)
8
+ L2 rep/eta correctness vs brute force orbit minima
9
+ L3 projector algebra: P_k^2 = P_k, Hermitian, sum_k P_k = I, basis
10
+ orthonormality, sum_k dim_k = full dim
11
+ L4 block spectra: union over k == full-sector spectrum (engine 1);
12
+ block Hermiticity; E0/deg vs published reference
13
+ L5 P_d(Rmax) full pipeline vs published reference (TOL 2e-6)
14
+ """
15
+ import sys
16
+ import numpy as np
17
+
18
+ import ed_core as ec
19
+ import ed_sym as es
20
+ from validate_ed import REF
21
+
22
+ TOL_E = 5e-7
23
+ TOL_P = 2e-6
24
+
25
+
26
+ def ref_rows(cluster):
27
+ return [(n, e0, d, p8, p0) for (c, n, e0, d, p8, p0) in REF if c == cluster]
28
+
29
+
30
+ # ---------------------------------------------------------------- L1
31
+ def L1():
32
+ ok = True
33
+ for name in ["2x4", "4x4"]:
34
+ cl = ec.CLUSTERS[name]()
35
+ tb = es.SymTables(cl)
36
+ NG, Nmask = tb.NG, tb.Nmask
37
+ worst_m = worst_s = 0
38
+ for g in range(NG):
39
+ for h in range(NG):
40
+ gh = tb.compose(g, h)
41
+ m = np.arange(Nmask, dtype=np.int32)
42
+ # masks: t_g(t_h(m)) == t_gh(m)
43
+ d1 = tb.tmask[g][tb.tmask[h][m]] - tb.tmask[gh][m]
44
+ worst_m = max(worst_m, int(np.abs(d1).max()))
45
+ # signs: sigma_g(t_h(m)) * sigma_h(m) == sigma_gh(m)
46
+ s = (tb.sgm[g][tb.tmask[h][m]].astype(np.int64) *
47
+ tb.sgm[h][m].astype(np.int64) - tb.sgm[gh][m].astype(np.int64))
48
+ worst_s = max(worst_s, int(np.abs(s).max()))
49
+ # random-vector check on 2x4-like small Nu only (4x4 Nu too big here)
50
+ print(f"L1[{name}]: mask-compose err={worst_m} sign-compose err={worst_s}",
51
+ "PASS" if worst_m == 0 and worst_s == 0 else "FAIL")
52
+ ok &= (worst_m == 0 and worst_s == 0)
53
+ # vector-level U_g U_h = U_gh on 2x4 n=2
54
+ cl = ec.cluster_2x4()
55
+ tb = es.SymTables(cl)
56
+ n = 2
57
+ masks = es.enumerate_masks(cl.Ns, n)
58
+ Nu = len(masks)
59
+ rs = np.random.RandomState(7)
60
+ V = rs.standard_normal((Nu, Nu))
61
+ masks32 = masks.astype(np.int32)
62
+
63
+ def apply_g(g, V):
64
+ out = np.empty_like(V)
65
+ for iu in range(Nu):
66
+ mu2 = tb.tmask[g][masks32[iu]]
67
+ iu2 = int(np.searchsorted(masks32, mu2))
68
+ md2 = tb.tmask[g][masks32] # vector over md
69
+ id2 = np.searchsorted(masks32, md2)
70
+ sg = tb.sgm[g][masks32[iu]] * tb.sgm[g][masks32]
71
+ out[iu2, id2] = sg.astype(np.float64) * V[iu, :]
72
+ return out
73
+
74
+ worst = 0.0
75
+ for g in range(tb.NG):
76
+ for h in range(tb.NG):
77
+ gh = tb.compose(g, h)
78
+ worst = max(worst, float(np.abs(apply_g(g, apply_g(h, V)) -
79
+ apply_g(gh, V)).max()))
80
+ print(f"L1[vector 2x4 n=2]: max|U_g U_h - U_gh| = {worst:.2e}",
81
+ "PASS" if worst < 1e-12 else "FAIL")
82
+ return ok and worst < 1e-12
83
+
84
+
85
+ # ---------------------------------------------------------------- L2
86
+ def L2():
87
+ ok = True
88
+ for name, ns in [("2x4", [1, 2]), ("3x4", [1]), ("4x4", [1])]:
89
+ cl = ec.CLUSTERS[name]()
90
+ tb = es.SymTables(cl)
91
+ for n in ns:
92
+ ed = es.SymED(cl, n, verbose=False)
93
+ masks32 = ed.masks.astype(np.int32)
94
+ Nu = ed.Nu
95
+ dim = ed.dim
96
+ iu = np.repeat(np.arange(Nu, dtype=np.int64), Nu)
97
+ idn = np.tile(np.arange(Nu, dtype=np.int64), Nu)
98
+ # brute force orbit minima
99
+ worst_eta = 0
100
+ rep_bf = np.full(dim, 10**9, dtype=np.int64)
101
+ for g in range(tb.NG):
102
+ mu2 = tb.tmask[g][masks32[iu]]
103
+ md2 = tb.tmask[g][masks32[idn]]
104
+ flat2 = np.searchsorted(masks32, mu2) * Nu + np.searchsorted(masks32, md2)
105
+ rep_bf = np.minimum(rep_bf, flat2)
106
+ worst_rep = int(np.abs(ed.rep.astype(np.int64) - rep_bf).max())
107
+ # eta maps config to its rep
108
+ for g in range(tb.NG):
109
+ sel = np.flatnonzero(ed.eta == g)
110
+ if len(sel) == 0:
111
+ continue
112
+ mu2 = tb.tmask[g][masks32[sel // Nu]]
113
+ md2 = tb.tmask[g][masks32[sel % Nu]]
114
+ flat2 = np.searchsorted(masks32, mu2) * Nu + np.searchsorted(masks32, md2)
115
+ worst_eta = max(worst_eta, int(np.abs(flat2 - ed.rep[sel]).max()))
116
+ good = worst_rep == 0 and worst_eta == 0
117
+ print(f"L2[{name} n={n}]: dim={dim} rep_err={worst_rep} eta_err={worst_eta}",
118
+ "PASS" if good else "FAIL")
119
+ ok &= good
120
+ return ok
121
+
122
+
123
+ # ---------------------------------------------------------------- L3
124
+ def L3():
125
+ ok = True
126
+ for name, n in [("2x4", 2), ("4x4", 2)]:
127
+ cl = ec.CLUSTERS[name]()
128
+ tb = es.SymTables(cl)
129
+ ed = es.SymED(cl, n, verbose=False)
130
+ NG = tb.NG
131
+ masks32 = ed.masks.astype(np.int32)
132
+ Nu, dim = ed.Nu, ed.dim
133
+ iu = np.repeat(np.arange(Nu, dtype=np.int64), Nu)
134
+ idn = np.tile(np.arange(Nu, dtype=np.int64), Nu)
135
+ # config translation: flat -> (flat2, sign) per g
136
+ tr = []
137
+ for g in range(NG):
138
+ mu2 = tb.tmask[g][masks32[iu]]
139
+ md2 = tb.tmask[g][masks32[idn]]
140
+ flat2 = np.searchsorted(masks32, mu2) * Nu + np.searchsorted(masks32, md2)
141
+ sgn = (tb.sgm[g][masks32[iu]] * tb.sgm[g][masks32[idn]]).astype(np.float64)
142
+ tr.append((flat2, sgn))
143
+ sumP = np.zeros((dim, dim), dtype=np.complex128)
144
+ sum_dk = 0
145
+ rng = np.random.RandomState(20260317)
146
+ DENSE_MAX = 4000 # dense P@P only for small sectors (dim=14400 would
147
+ # cost ~1.2e13 flops per k-block -> random-vector check)
148
+ for k1 in range(tb.m):
149
+ for k2 in range(tb.n):
150
+ chi = tb.chi(k1, k2)
151
+ P = np.zeros((dim, dim), dtype=np.complex128)
152
+ for g in range(NG):
153
+ flat2, sgn = tr[g]
154
+ np.add.at(P, (flat2, np.arange(dim)), np.conj(chi[g]) * sgn / NG)
155
+ if dim <= DENSE_MAX:
156
+ # P^2 = P, Hermitian (full matrix)
157
+ e1 = np.abs(P @ P - P).max()
158
+ e2 = np.abs(P - P.conj().T).max()
159
+ else:
160
+ # random-vector verification of the same properties;
161
+ # Hermitian + idempotent + sum_k P_k = I (below) together
162
+ # imply an orthogonal decomposition (ranges orthogonal)
163
+ v = rng.standard_normal(dim) + 1j * rng.standard_normal(dim)
164
+ w = rng.standard_normal(dim) + 1j * rng.standard_normal(dim)
165
+ v /= np.linalg.norm(v)
166
+ w /= np.linalg.norm(w)
167
+ Pv = P @ v
168
+ e1 = float(np.linalg.norm(P @ Pv - Pv))
169
+ e2 = float(abs(np.vdot(w, Pv) - np.vdot(P @ w, v)))
170
+ basis, nb, rank = ed.block_basis(k1, k2)
171
+ B = P[:, basis] / nb[None, :]
172
+ G = B.conj().T @ B
173
+ e3 = np.abs(G - np.eye(len(basis))).max()
174
+ good = e1 < 1e-9 and e2 < 1e-9 and e3 < 1e-9
175
+ print(f"L3[{name} n={n}] k=({k1},{k2}): dk={len(basis)} "
176
+ f"|P^2-P|={e1:.1e} |P-P^T*|={e2:.1e} |Gram-I|={e3:.1e} "
177
+ + ("PASS" if good else "FAIL"))
178
+ ok &= good
179
+ sumP += P
180
+ sum_dk += len(basis)
181
+ e4 = np.abs(sumP - np.eye(dim)).max()
182
+ print(f"L3[{name} n={n}]: sum_k P_k = I err={e4:.1e}; "
183
+ f"sum dk={sum_dk} vs dim={dim} "
184
+ + ("PASS" if e4 < 1e-9 and sum_dk == dim else "FAIL"))
185
+ ok &= (e4 < 1e-9 and sum_dk == dim)
186
+ return ok
187
+
188
+
189
+ # ---------------------------------------------------------------- L4
190
+ def L4():
191
+ ok = True
192
+ # (a) union of block spectra == full spectrum, dense-able sectors
193
+ for name, n in [("2x4", 1), ("2x4", 2), ("2x4", 3), ("3x4", 2)]:
194
+ cl = ec.CLUSTERS[name]()
195
+ tb = es.SymTables(cl)
196
+ ed = es.SymED(cl, n, verbose=False)
197
+ ed1 = ec.SectorED(cl, n, U=8.0)
198
+ Hf = np.empty((ed1.dim, ed1.dim))
199
+ for i in range(ed1.dim):
200
+ e = np.zeros(ed1.dim)
201
+ e[i] = 1.0
202
+ Hf[:, i] = ed1.matvec(e)
203
+ Hf = (Hf + Hf.T) * 0.5
204
+ wf = np.linalg.eigvalsh(Hf)
205
+ wb = []
206
+ herm = 0.0
207
+ for k1 in range(tb.m):
208
+ for k2 in range(tb.n):
209
+ H, dk = ed.build_hk(k1, k2)
210
+ herm = max(herm, float(np.abs(H - H.conj().T).max()) if H.nnz else 0.0)
211
+ wb.extend(np.linalg.eigvalsh(H.toarray()).tolist())
212
+ wb = np.sort(np.array(wb))
213
+ e = float(np.abs(wb - wf).max())
214
+ good = e < 1e-7 and herm < 1e-8
215
+ print(f"L4[{name} n={n}]: dim={ed1.dim} spectrum-union err={e:.2e} "
216
+ f"herm={herm:.1e} " + ("PASS" if good else "FAIL"))
217
+ ok &= good
218
+ # (b) E0/deg vs reference on 4x4 n=2 (sparse full sector)
219
+ cl = ec.cluster_4x4()
220
+ tb = es.SymTables(cl)
221
+ ed = es.SymED(cl, 2, verbose=False)
222
+ ed.solve_all(kk=4)
223
+ E0s = [b["w"][0] for b in ed.blocks.values() if len(b["w"])]
224
+ E0b = min(E0s)
225
+ mult = sum(b["factor"] * int(np.sum(b["w"] < E0b + es.DEGEN_TOL))
226
+ for b in ed.blocks.values() if len(b["w"]))
227
+ E0f, vf = ec.SectorED(cl, 2, U=8.0).solve_gs()
228
+ row = [r for r in REF if r[0] == "4x4" and r[1] == 2][0]
229
+ good = (abs(E0b - row[2]) < TOL_E and mult == row[3] and abs(E0b - E0f) < 1e-8)
230
+ print(f"L4[4x4 n=2]: E0_block={E0b:.8f} E0_full={E0f:.8f} ref={row[2]} "
231
+ f"deg={mult} ref_deg={row[3]} " + ("PASS" if good else "FAIL"))
232
+ ok &= good
233
+ return ok
234
+
235
+
236
+ # ---------------------------------------------------------------- L5
237
+ def L5():
238
+ ok = True
239
+ cases = [("2x4", 1), ("2x4", 2), ("2x4", 3), ("2x4", 4),
240
+ ("3x4", 1), ("3x4", 2), ("3x4", 3), ("3x4", 4), ("3x4", 5), ("3x4", 6),
241
+ ("4x4", 1), ("4x4", 2), ("4x4", 3), ("4x4", 4)]
242
+ for name, n in cases:
243
+ row = [r for r in REF if r[0] == name and r[1] == n][0]
244
+ cl = ec.CLUSTERS[name]()
245
+ ed = es.SymED(cl, n, verbose=False)
246
+ ed.solve_all(kk=4)
247
+ pd, npair, mult, E0 = ed.pd_rmax()
248
+ p0, _ = ec.wick_u0(cl, n, cl.rmax)
249
+ e_ok = abs(E0 - row[2]) < TOL_E
250
+ d_ok = mult == row[3]
251
+ p_ok = abs(pd - row[4]) < TOL_P
252
+ good = e_ok and d_ok and p_ok
253
+ print(f"L5[{name} n={n}]: E0={E0:.8f}({row[2]}) deg={mult}({row[3]}) "
254
+ f"P={pd:.7f}({row[4]}) dP={abs(pd - row[4]):.1e} "
255
+ + ("PASS" if good else "FAIL"))
256
+ ok &= good
257
+ return ok
258
+
259
+
260
+ if __name__ == "__main__":
261
+ layers = sys.argv[1:] or ["L1", "L2", "L3", "L4", "L5"]
262
+ fns = {"L1": L1, "L2": L2, "L3": L3, "L4": L4, "L5": L5}
263
+ all_ok = True
264
+ for L in layers:
265
+ print(f"\n======== {L} ========")
266
+ all_ok &= fns[L]()
267
+ print("\n==== ALL PASS ====" if all_ok else "\n==== FAILURES PRESENT ====")
268
+ sys.exit(0 if all_ok else 1)
methods/Tuli99/method_ed/validate_ed.py ADDED
@@ -0,0 +1,145 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Validate our own ED against the published independent ED reference
3
+ (validation/multisize_ED_table_kuku.md, team ku-ku, 2026-10-01).
4
+
5
+ Checks per point: E0(U=8), GS degeneracy, P_org(U=8), P_org(U=0) [Wick].
6
+ Also a brute-force Fock-space check of the Wick 4-operator identity.
7
+
8
+ Usage: python validate_ed.py [2x4 sqrt8 sqrt10 3x4]
9
+ """
10
+ import sys
11
+ import numpy as np
12
+ import ed_core as ec
13
+
14
+ # cluster, Nup=Ndn, E0(U=8), deg(U=8), P_org(U=8), P_org(U=0) [ku-ku table]
15
+ REF = [
16
+ ("2x4", 1, -7.51754096, 1, 0.00216029, 0.0),
17
+ ("2x4", 2, -10.49762201, 1, -0.00363614, 0.0312499),
18
+ ("2x4", 3, -10.62689735, 1, 0.193846, 0.187500),
19
+ ("2x4", 4, -7.12671234, 1, 0.0328407, 0.0625000),
20
+ ("sqrt8", 1, -7.46479305, 1, 0.0, 0.0),
21
+ ("sqrt8", 2, -6.70043783, 4, 0.0462048, 0.0277777),
22
+ ("sqrt8", 3, -5.95282782, 4, 0.0151149, 0.0277777),
23
+ ("sqrt8", 4, -3.78398080, 1, -0.0815632, 0.0),
24
+ ("sqrt10", 1, -7.59126715, 1, 0.0, 0.0),
25
+ ("sqrt10", 2, -8.86885383, 5, 0.0321150, 0.0),
26
+ ("sqrt10", 3, -9.83963907, 1, -0.0370993, 0.0499999),
27
+ ("sqrt10", 4, -8.11706774, 5, 0.0909946, 0.149999),
28
+ ("sqrt10", 5, -5.10409191, 1, 0.0359803, 0.300000),
29
+ ("3x4", 1, -7.67599209, 1, 5.7526378308795875e-05, 0.0),
30
+ ("3x4", 2, -11.037873924, 1, -0.00649435, 0.0138888),
31
+ ("3x4", 3, -13.067143245, 1, 0.103875, 0.0833333),
32
+ ("3x4", 4, -12.64005415, 1, 0.0360609, 0.0868055),
33
+ ("3x4", 5, -10.76537911, 1, 0.0568266, 0.121527),
34
+ ("3x4", 6, -5.83348425, 1, 0.0100270, 0.0347222),
35
+ ("4x4", 1, -7.76409059, 1, 0.0, 0.0),
36
+ ("4x4", 2, -11.32149713, 3, 0.0120940, 0.0),
37
+ ("4x4", 3, -14.72354031, 1, -0.0137308, 0.0156250),
38
+ ("4x4", 4, -16.46062675, 3, 0.0480759, 0.0468749),
39
+ ("4x4", 5, -17.51036669, 1, 0.0601219, 0.0937500),
40
+ ("4x4", 6, -14.92531021, 2, 0.00983108, 0.0416666),
41
+ ("4x4", 7, -11.86883556, 3, 0.0192190, 0.0104166),
42
+ ("4x4", 8, -8.46887501, 1, 0.00619709, 0.0),
43
+ ]
44
+
45
+ TOL_E = 5e-7 # E0 table has 8-9 decimals
46
+ TOL_P = 2e-6 # P table truncated to 6-7 significant digits
47
+
48
+
49
+ def test_wick_bf():
50
+ """Brute-force check of wick4 on a Slater determinant (3 sites, 1 up + 1 down)."""
51
+ Ns = 4
52
+ cl = ec.Cluster((2, 0), (0, 2), "t2x2ring")
53
+ H1 = np.zeros((Ns, Ns))
54
+ for (p, q) in cl.bonds:
55
+ H1[p, q] -= 1.0
56
+ H1[q, p] -= 1.0
57
+ eps, U = ec.eigh(H1)
58
+ occ = np.zeros(Ns)
59
+ occ[0] = 1.0 # unique orbital per spin (non-degenerate here)
60
+ a = U[:, 0] # orbital coefficients
61
+ rho = np.outer(a, a)
62
+ # Fock vector over (up_mask, dn_mask): single particle per spin
63
+ amp = {}
64
+ for x in range(Ns):
65
+ for y in range(Ns):
66
+ amp[(1 << x) | (1 << (Ns + y))] = a[x] * a[y]
67
+
68
+ def apply(st, site, spin, create):
69
+ m, sgn = st, 1.0
70
+ bit = site + (Ns if spin == 1 else 0)
71
+ occ_bit = (m >> bit) & 1
72
+ if create:
73
+ if occ_bit:
74
+ return None, 0.0
75
+ sgn = 1 - 2 * (bin(m & ((1 << bit) - 1)).count("1") & 1)
76
+ return m | (1 << bit), float(sgn)
77
+ if not occ_bit:
78
+ return None, 0.0
79
+ sgn = 1 - 2 * (bin(m & ((1 << bit) - 1)).count("1") & 1)
80
+ return m ^ (1 << bit), float(sgn)
81
+
82
+ import itertools
83
+ worst = 0.0
84
+ for P in itertools.product(range(Ns), [0, 1]):
85
+ for Q in itertools.product(range(Ns), [0, 1]):
86
+ for R in itertools.product(range(Ns), [0, 1]):
87
+ for S in itertools.product(range(Ns), [0, 1]):
88
+ tot = 0.0
89
+ for st0, a0 in amp.items():
90
+ m1, s1 = apply(st0, S[0], S[1], False) # c_S
91
+ if m1 is None:
92
+ continue
93
+ m2, s2 = apply(m1, R[0], R[1], False) # c_R
94
+ if m2 is None:
95
+ continue
96
+ m3, s3 = apply(m2, Q[0], Q[1], True) # c^+_Q
97
+ if m3 is None:
98
+ continue
99
+ m4, s4 = apply(m3, P[0], P[1], True) # c^+_P
100
+ if m4 is None:
101
+ continue
102
+ tot += a0 * s1 * s2 * s3 * s4 * amp.get(m4, 0.0)
103
+ ref = ec.wick4(rho, rho, P, Q, R, S)
104
+ worst = max(worst, abs(tot - ref))
105
+ return worst
106
+
107
+
108
+ def main():
109
+ which = sys.argv[1:] or ["2x4", "sqrt8", "sqrt10", "3x4"]
110
+ w = test_wick_bf()
111
+ print(f"[wick4 brute-force] max |diff| = {w:.3e} ->", "PASS" if w < 1e-12 else "FAIL")
112
+ npass = nfail = 0
113
+ for (cname, ne, e0_ref, deg_ref, p8_ref, p0_ref) in REF:
114
+ if cname not in which:
115
+ continue
116
+ cl = ec.CLUSTERS[cname]()
117
+ ed = ec.SectorED(cl, ne, U=8.0)
118
+ E0, vecs = ed.solve_gs()
119
+ deg = vecs.shape[1]
120
+ pops = ec.PairOps(ed)
121
+ p8, npair = pops.pd_at_R(vecs, cl.rmax)
122
+ p0, _ = ec.wick_u0(cl, ne, cl.rmax)
123
+ rows = [
124
+ ("dim", ed.dim, ""),
125
+ ("E0", E0, e0_ref),
126
+ ("deg", deg, deg_ref),
127
+ ("P_org U=8", p8, p8_ref),
128
+ ("P_org U=0", p0, p0_ref),
129
+ ]
130
+ ok = (abs(E0 - e0_ref) < TOL_E and deg == deg_ref
131
+ and abs(p8 - p8_ref) < TOL_P and abs(p0 - p0_ref) < TOL_P)
132
+ npass += ok
133
+ nfail += (not ok)
134
+ print(f"\n== {cname} Ne={ne} (n={2*ne/cl.Ns:.4f}) Rmax={cl.rmax:.4f} npairs={npair} "
135
+ f"{'PASS' if ok else 'FAIL'}")
136
+ for (k, got, ref) in rows:
137
+ rs = f"{ref:.8f}" if isinstance(ref, float) else str(ref)
138
+ d = f" diff={got-ref:+.2e}" if isinstance(ref, float) and k != "dim" else ""
139
+ print(f" {k:12s} got={got!r:22} ref={rs}{d}")
140
+ print(f"\n==== {npass} PASS / {nfail} FAIL ====")
141
+ sys.exit(0 if nfail == 0 and npass > 0 and w < 1e-12 else 1)
142
+
143
+
144
+ if __name__ == "__main__":
145
+ main()
methods/Tuli99/method_ed/validation_report.json ADDED
@@ -0,0 +1,310 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "scope": "cached 27-point reference audit, cached PHS audit; fresh target separately",
3
+ "reference_credit": "Team ku-ku, 2026-10-01, CC-BY-NC 4.0",
4
+ "reference_sha256": "126892ef7a810834ba5e72eb9609e057ca0434c6b0516081964523e90f7ecde7",
5
+ "reference_checks": [
6
+ {
7
+ "cluster": "2x4",
8
+ "Ne": 1,
9
+ "differences": {
10
+ "E0": 6.287268483617936e-09,
11
+ "A_d": 8.750284254555735e-09,
12
+ "A_d_U0": 4.336808689942018e-19
13
+ },
14
+ "passed": true
15
+ },
16
+ {
17
+ "cluster": "2x4",
18
+ "Ne": 2,
19
+ "differences": {
20
+ "E0": 8.801578132988652e-09,
21
+ "A_d": 7.96652423933411e-09,
22
+ "A_d_U0": 9.99999999681811e-08
23
+ },
24
+ "passed": true
25
+ },
26
+ {
27
+ "cluster": "2x4",
28
+ "Ne": 3,
29
+ "differences": {
30
+ "E0": 4.717264801001875e-09,
31
+ "A_d": 3.286995726436981e-07,
32
+ "A_d_U0": 5.551115123125783e-17
33
+ },
34
+ "passed": true
35
+ },
36
+ {
37
+ "cluster": "2x4",
38
+ "Ne": 4,
39
+ "differences": {
40
+ "E0": 4.4222288053674674e-09,
41
+ "A_d": 7.959290020120857e-08,
42
+ "A_d_U0": 6.245004513516506e-17
43
+ },
44
+ "passed": true
45
+ },
46
+ {
47
+ "cluster": "sqrt8",
48
+ "Ne": 1,
49
+ "differences": {
50
+ "E0": 3.609113008451459e-11,
51
+ "A_d": 5.7777898331617076e-33,
52
+ "A_d_U0": 2.168404344971009e-18
53
+ },
54
+ "passed": true
55
+ },
56
+ {
57
+ "cluster": "sqrt8",
58
+ "Ne": 2,
59
+ "differences": {
60
+ "E0": 3.37228200919526e-09,
61
+ "A_d": 2.062828526050442e-08,
62
+ "A_d_U0": 7.777777777731587e-08
63
+ },
64
+ "passed": true
65
+ },
66
+ {
67
+ "cluster": "sqrt8",
68
+ "Ne": 3,
69
+ "differences": {
70
+ "E0": 7.724902495453989e-09,
71
+ "A_d": 4.30197885543937e-08,
72
+ "A_d_U0": 7.777777777731587e-08
73
+ },
74
+ "passed": true
75
+ },
76
+ {
77
+ "cluster": "sqrt8",
78
+ "Ne": 4,
79
+ "differences": {
80
+ "E0": 8.912222959622795e-09,
81
+ "A_d": 3.762146780217357e-08,
82
+ "A_d_U0": 1.3877787807814457e-17
83
+ },
84
+ "passed": true
85
+ },
86
+ {
87
+ "cluster": "sqrt10",
88
+ "Ne": 1,
89
+ "differences": {
90
+ "E0": 2.6112516593457258e-09,
91
+ "A_d": 2.157041537713704e-33,
92
+ "A_d_U0": 2.7755575615628915e-18
93
+ },
94
+ "passed": true
95
+ },
96
+ {
97
+ "cluster": "sqrt10",
98
+ "Ne": 2,
99
+ "differences": {
100
+ "E0": 9.155350255696248e-09,
101
+ "A_d": 3.3561590111197415e-08,
102
+ "A_d_U0": 3.729655473350135e-18
103
+ },
104
+ "passed": true
105
+ },
106
+ {
107
+ "cluster": "sqrt10",
108
+ "Ne": 3,
109
+ "differences": {
110
+ "E0": 6.993502665864071e-09,
111
+ "A_d": 2.2169822810891304e-08,
112
+ "A_d_U0": 1.0000000000981446e-07
113
+ },
114
+ "passed": true
115
+ },
116
+ {
117
+ "cluster": "sqrt10",
118
+ "Ne": 4,
119
+ "differences": {
120
+ "E0": 6.17873574526584e-09,
121
+ "A_d": 9.011227528055166e-08,
122
+ "A_d_U0": 1.0000000000842668e-06
123
+ },
124
+ "passed": true
125
+ },
126
+ {
127
+ "cluster": "sqrt10",
128
+ "Ne": 5,
129
+ "differences": {
130
+ "E0": 3.90858012622175e-10,
131
+ "A_d": 1.9639112898428568e-08,
132
+ "A_d_U0": 1.1102230246251565e-16
133
+ },
134
+ "passed": true
135
+ },
136
+ {
137
+ "cluster": "3x4",
138
+ "Ne": 1,
139
+ "differences": {
140
+ "E0": 1.3912648810787687e-09,
141
+ "A_d": 3.049318610115481e-19,
142
+ "A_d_U0": 2.168404344971009e-19
143
+ },
144
+ "passed": true
145
+ },
146
+ {
147
+ "cluster": "3x4",
148
+ "Ne": 2,
149
+ "differences": {
150
+ "E0": 1.2313172703670716e-10,
151
+ "A_d": 7.636545259863403e-09,
152
+ "A_d_U0": 8.888888889009572e-08
153
+ },
154
+ "passed": true
155
+ },
156
+ {
157
+ "cluster": "3x4",
158
+ "Ne": 3,
159
+ "differences": {
160
+ "E0": 5.95541393977328e-10,
161
+ "A_d": 3.897630346388903e-07,
162
+ "A_d_U0": 3.33333333574215e-08
163
+ },
164
+ "passed": true
165
+ },
166
+ {
167
+ "cluster": "3x4",
168
+ "Ne": 4,
169
+ "differences": {
170
+ "E0": 2.026091294737853e-09,
171
+ "A_d": 2.1729700427908227e-08,
172
+ "A_d_U0": 5.5555555586450645e-08
173
+ },
174
+ "passed": true
175
+ },
176
+ {
177
+ "cluster": "3x4",
178
+ "Ne": 5,
179
+ "differences": {
180
+ "E0": 5.129034974515889e-10,
181
+ "A_d": 1.2626876766397288e-08,
182
+ "A_d_U0": 7.777777777939754e-07
183
+ },
184
+ "passed": true
185
+ },
186
+ {
187
+ "cluster": "3x4",
188
+ "Ne": 6,
189
+ "differences": {
190
+ "E0": 7.498091925128847e-09,
191
+ "A_d": 8.938305499396615e-08,
192
+ "A_d_U0": 2.2222222229029143e-08
193
+ },
194
+ "passed": true
195
+ },
196
+ {
197
+ "cluster": "4x4",
198
+ "Ne": 1,
199
+ "differences": {
200
+ "E0": 9.039009540856568e-10,
201
+ "A_d": 7.222237291452134e-35,
202
+ "A_d_U0": 1.3552527156068805e-19
203
+ },
204
+ "passed": true
205
+ },
206
+ {
207
+ "cluster": "4x4",
208
+ "Ne": 2,
209
+ "differences": {
210
+ "E0": 3.2117704051870533e-09,
211
+ "A_d": 2.4007304123829787e-08,
212
+ "A_d_U0": 3.9607260613611084e-18
213
+ },
214
+ "passed": true
215
+ },
216
+ {
217
+ "cluster": "4x4",
218
+ "Ne": 3,
219
+ "differences": {
220
+ "E0": 7.907523524863791e-09,
221
+ "A_d": 5.258632641315375e-08,
222
+ "A_d_U0": 1.734723475976807e-17
223
+ },
224
+ "passed": true
225
+ },
226
+ {
227
+ "cluster": "4x4",
228
+ "Ne": 4,
229
+ "differences": {
230
+ "E0": 3.6817411341871775e-09,
231
+ "A_d": 2.3542662028197547e-08,
232
+ "A_d_U0": 1.0000000003757004e-07
233
+ },
234
+ "passed": true
235
+ },
236
+ {
237
+ "cluster": "4x4",
238
+ "Ne": 5,
239
+ "differences": {
240
+ "E0": 4.878632609006672e-09,
241
+ "A_d": 4.560348784016233e-08,
242
+ "A_d_U0": 5.551115123125783e-17
243
+ },
244
+ "passed": true
245
+ },
246
+ {
247
+ "cluster": "4x4",
248
+ "Ne": 6,
249
+ "differences": {
250
+ "E0": 5.108519829377656e-09,
251
+ "A_d": 9.63260454039938e-10,
252
+ "A_d_U0": 6.666666670096522e-08
253
+ },
254
+ "passed": true
255
+ },
256
+ {
257
+ "cluster": "4x4",
258
+ "Ne": 7,
259
+ "differences": {
260
+ "E0": 9.56404910823494e-09,
261
+ "A_d": 5.55976721258733e-09,
262
+ "A_d_U0": 6.666666668014853e-08
263
+ },
264
+ "passed": true
265
+ },
266
+ {
267
+ "cluster": "4x4",
268
+ "Ne": 8,
269
+ "differences": {
270
+ "E0": 4.1968153396965135e-09,
271
+ "A_d": 2.5822329777908104e-10,
272
+ "A_d_U0": 9.486769009248164e-20
273
+ },
274
+ "passed": true
275
+ }
276
+ ],
277
+ "particle_hole_checks": [
278
+ {
279
+ "Ne": 12,
280
+ "mirror": 4,
281
+ "A_d_difference": 2.220446049250313e-16,
282
+ "energy_shift_error": 5.684341886080802e-14,
283
+ "passed": true
284
+ },
285
+ {
286
+ "Ne": 13,
287
+ "mirror": 3,
288
+ "A_d_difference": 6.938893903907228e-18,
289
+ "energy_shift_error": 1.8474111129762605e-13,
290
+ "passed": true
291
+ },
292
+ {
293
+ "Ne": 14,
294
+ "mirror": 2,
295
+ "A_d_difference": 1.3704315460216776e-16,
296
+ "energy_shift_error": 0.0,
297
+ "passed": true
298
+ },
299
+ {
300
+ "Ne": 15,
301
+ "mirror": 1,
302
+ "A_d_difference": 3.117081245895826e-19,
303
+ "energy_shift_error": 0.0,
304
+ "passed": true
305
+ }
306
+ ],
307
+ "curve_consistent": true,
308
+ "fresh_target_passed": true,
309
+ "passed": true
310
+ }
methods/Tuli99/submission_gold_OSC-00747.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "material_id": "2NiS-5",
3
+ "t": 0.25142,
4
+ "U": 2.01136,
5
+ "nef": 1.40205,
6
+ "U_over_t": 8.0,
7
+ "solver_delta": "0.1667",
8
+ "A_dwave": 0.05682661,
9
+ "provisional_score": 23.902,
10
+ "author": "Tuli99",
11
+ "osc_id": "OSC-00747",
12
+ "formula": "Ni2S2",
13
+ "level": "STRONG d-wave candidate",
14
+ "method_name": "own-ED-Hubbard U/t=8 (validated vs independent ED)",
15
+ "track": "gold",
16
+ "method": {
17
+ "model": "square-lattice Hubbard, H=-t(sum c+c + h.c.) + U n_up n_dn, U/t=8, Sz=0",
18
+ "clusters": [
19
+ "2x4",
20
+ "sqrt8",
21
+ "sqrt10",
22
+ "3x4",
23
+ "4x4"
24
+ ],
25
+ "observable": "A_d = P_org(R_max) = <Delta_d^+(j) Delta_d(i)>, organizer normalization",
26
+ "engine": "matrix-free Sz=0 ED (Lanczos+deflation, dense for dim<=8000); 4x4 Ne=5..8 via momentum-projection ED (translation group Z4xZ4, per-k Lanczos on projected blocks, dim/16)",
27
+ "U0_check": "canonical Wick vs ED U=0 agreement on all small clusters",
28
+ "validation": "27/27 match vs published independent ED (19 small-cluster pts + 4x4 Ne=1..4 full-ED + 4x4 Ne=5..8 momentum-projection, E0 diff <=1e-8); PHS A_d(Ne)=A_d(16-Ne) verified numerically on 4x4 (Ne=12..15, dP<=2.3e-16)",
29
+ "limitations": "Exact only on the stated finite clusters. Different sizes/shapes/Rmax are not a converged thermodynamic sequence. No claim that 3x4 improves the organizer 6x6 estimate; claimed scores await organizer reproduction and do not override canonical leaderboard scores.",
30
+ "particle_number_convention": "Ne in result tables means N_up=N_down, not total electrons; density=2*Ne/Ns and delta=1-density."
31
+ },
32
+ "A_d_source": {
33
+ "rule": "exact",
34
+ "point": "3x4 Ne=5",
35
+ "finite_cluster_exact": true,
36
+ "delta_matching": "official solver_delta rounded to 4 decimals",
37
+ "fresh_independent_starts": 3,
38
+ "baseline_published_A_d": 0.05569,
39
+ "ratio_own_vs_published": 1.0204
40
+ }
41
+ }
methods/Tuli99/submission_gold_OSC-00754.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "material_id": "2NiTe-5",
3
+ "t": 0.24796,
4
+ "U": 1.98368,
5
+ "nef": 1.4494,
6
+ "U_over_t": 8.0,
7
+ "solver_delta": "0.1667",
8
+ "A_dwave": 0.05682661,
9
+ "provisional_score": 24.709,
10
+ "author": "Tuli99",
11
+ "osc_id": "OSC-00754",
12
+ "formula": "Ni2Te2",
13
+ "level": "STRONG d-wave candidate",
14
+ "method_name": "own-ED-Hubbard U/t=8 (validated vs independent ED)",
15
+ "track": "gold",
16
+ "method": {
17
+ "model": "square-lattice Hubbard, H=-t(sum c+c + h.c.) + U n_up n_dn, U/t=8, Sz=0",
18
+ "clusters": [
19
+ "2x4",
20
+ "sqrt8",
21
+ "sqrt10",
22
+ "3x4",
23
+ "4x4"
24
+ ],
25
+ "observable": "A_d = P_org(R_max) = <Delta_d^+(j) Delta_d(i)>, organizer normalization",
26
+ "engine": "matrix-free Sz=0 ED (Lanczos+deflation, dense for dim<=8000); 4x4 Ne=5..8 via momentum-projection ED (translation group Z4xZ4, per-k Lanczos on projected blocks, dim/16)",
27
+ "U0_check": "canonical Wick vs ED U=0 agreement on all small clusters",
28
+ "validation": "27/27 match vs published independent ED (19 small-cluster pts + 4x4 Ne=1..4 full-ED + 4x4 Ne=5..8 momentum-projection, E0 diff <=1e-8); PHS A_d(Ne)=A_d(16-Ne) verified numerically on 4x4 (Ne=12..15, dP<=2.3e-16)",
29
+ "limitations": "Exact only on the stated finite clusters. Different sizes/shapes/Rmax are not a converged thermodynamic sequence. No claim that 3x4 improves the organizer 6x6 estimate; claimed scores await organizer reproduction and do not override canonical leaderboard scores.",
30
+ "particle_number_convention": "Ne in result tables means N_up=N_down, not total electrons; density=2*Ne/Ns and delta=1-density."
31
+ },
32
+ "A_d_source": {
33
+ "rule": "exact",
34
+ "point": "3x4 Ne=5",
35
+ "finite_cluster_exact": true,
36
+ "delta_matching": "official solver_delta rounded to 4 decimals",
37
+ "fresh_independent_starts": 3,
38
+ "baseline_published_A_d": 0.05569,
39
+ "ratio_own_vs_published": 1.0204
40
+ }
41
+ }
methods/Tuli99/submission_gold_OSC-01665.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "material_id": "2CuNiI3-1",
3
+ "t": 0.05271,
4
+ "U": 0.42168,
5
+ "nef": 1.58283,
6
+ "U_over_t": 8.0,
7
+ "solver_delta": "0.1667",
8
+ "A_dwave": 0.05682661,
9
+ "provisional_score": 26.984,
10
+ "author": "Tuli99",
11
+ "osc_id": "OSC-01665",
12
+ "formula": "Cu2I6Ni2",
13
+ "level": "STRONG d-wave candidate",
14
+ "method_name": "own-ED-Hubbard U/t=8 (validated vs independent ED)",
15
+ "track": "gold",
16
+ "method": {
17
+ "model": "square-lattice Hubbard, H=-t(sum c+c + h.c.) + U n_up n_dn, U/t=8, Sz=0",
18
+ "clusters": [
19
+ "2x4",
20
+ "sqrt8",
21
+ "sqrt10",
22
+ "3x4",
23
+ "4x4"
24
+ ],
25
+ "observable": "A_d = P_org(R_max) = <Delta_d^+(j) Delta_d(i)>, organizer normalization",
26
+ "engine": "matrix-free Sz=0 ED (Lanczos+deflation, dense for dim<=8000); 4x4 Ne=5..8 via momentum-projection ED (translation group Z4xZ4, per-k Lanczos on projected blocks, dim/16)",
27
+ "U0_check": "canonical Wick vs ED U=0 agreement on all small clusters",
28
+ "validation": "27/27 match vs published independent ED (19 small-cluster pts + 4x4 Ne=1..4 full-ED + 4x4 Ne=5..8 momentum-projection, E0 diff <=1e-8); PHS A_d(Ne)=A_d(16-Ne) verified numerically on 4x4 (Ne=12..15, dP<=2.3e-16)",
29
+ "limitations": "Exact only on the stated finite clusters. Different sizes/shapes/Rmax are not a converged thermodynamic sequence. No claim that 3x4 improves the organizer 6x6 estimate; claimed scores await organizer reproduction and do not override canonical leaderboard scores.",
30
+ "particle_number_convention": "Ne in result tables means N_up=N_down, not total electrons; density=2*Ne/Ns and delta=1-density."
31
+ },
32
+ "A_d_source": {
33
+ "rule": "exact",
34
+ "point": "3x4 Ne=5",
35
+ "finite_cluster_exact": true,
36
+ "delta_matching": "official solver_delta rounded to 4 decimals",
37
+ "fresh_independent_starts": 3,
38
+ "baseline_published_A_d": 0.05569,
39
+ "ratio_own_vs_published": 1.0204
40
+ }
41
+ }
methods/Tuli99/validation/multisize_ED_table_kuku.md ADDED
@@ -0,0 +1,55 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Multi-size ED of the U/t=8 Hubbard model: d-wave pair correlation at the largest distance
2
+ Prepared 2026-10-01 by team ku-ku. Shared for discussion only; this is not a submission.
3
+
4
+ ## Definitions
5
+ - Model: square-lattice Hubbard model, t=1, U=8 or U=0. Periodic tilted clusters with lattice vectors 2x4 (2,0),(0,4); sqrt8 (2,2),(-2,2); sqrt10 (3,1),(-1,3); 3x4 (3,0),(0,4); 4x4 (4,0),(0,4). Sector Sz=0, N_up=N_dn.
6
+ - Pair operator (ours): Delta_d(i) = 1/2 sum_delta g(delta) b_{i,i+delta}, where b_ij = (c_i↑ c_j↓ + c_j↑ c_i↓)/sqrt2, g(±x)=+1 and g(±y)=-1. P_d(R) is <Delta_d(j)^† Delta_d(i)> averaged over all pairs whose minimum-image separation is R.
7
+ - Organizers' normalization: P_org = 2·P_ours. We derived this analytically and checked it numerically to 1e-15 on 4x4.
8
+ - R_max is the largest minimum-image distance on each cluster: sqrt5 for 2x4, sqrt10 and 3x4; 2 for sqrt8; 2·sqrt2 for 4x4.
9
+ - Degenerate ground states (|E-E0|<1e-7) are averaged with equal weight. For N≤12 the full degenerate multiplet is obtained with dense diagonalization (dim≤5000) or with Lanczos plus deflation until no further state lies within 1e-7. The largest residual ‖Hψ−E0ψ‖ is 9.6e-12.
10
+ - U=0 reference: canonical ED, using the same equal-weight average over the degenerate ground manifold. This agrees with a canonical Wick evaluation (equal occupation of the partially filled shell) to ≤1.9e-13. The grand-canonical Wick value at T=0.01 is also listed in the CSV. One exception is 4x4 at n=1: there the U=0 value is canonical Wick, not ED (400-fold degeneracy).
11
+ - 4x4 values come from our earlier run (phase6). That run used a separate symmetry-adapted code (translation + C4v) with the same operator definitions. We did not cross-check the two codes on a common cluster in this step, so the 4x4 rows come from a different code but are not independently validated against the smaller-cluster code.
12
+
13
+ ## Table (values truncated from the CSV; ratio = P_d(U=8)/P_d(U=0), blank when |P_d(U=0)|<1e-12)
14
+ | cluster | N | n | N_up=N_dn | dim | E0 (U=8) | deg U=8 | deg U=0 | R_max | P_d(R_max) U=8 ours | P_org U=8 | P_d U=0 ours | P_org U=0 | ratio U8/U0 | U=0 method |
15
+ |---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
16
+ | 2x4 | 8 | 0.25 | 1 | 64 | -7.51754096 | 1 | 1 | 2.2360 | 0.00108014 | 0.00216029 | 0 | 0 | — | canonical ED |
17
+ | 2x4 | 8 | 0.5 | 2 | 784 | -10.49762201 | 1 | 4 | 2.2360 | -0.00181807 | -0.00363614 | 0.0156249 | 0.0312499 | -0.1163 | canonical ED |
18
+ | 2x4 | 8 | 0.75 | 3 | 3136 | -10.62689735 | 1 | 1 | 2.2360 | 0.0969231 | 0.193846 | 0.0937500 | 0.187500 | 1.03384 | canonical ED |
19
+ | 2x4 | 8 | 1.0 | 4 | 4900 | -7.12671234 | 1 | 4 | 2.2360 | 0.0164203 | 0.0328407 | 0.0312500 | 0.0625000 | 0.5254 | canonical ED |
20
+ | sqrt8 | 8 | 0.25 | 1 | 64 | -7.46479305 | 1 | 1 | 2.0 | 0 | 0 | 0 | 0 | — | canonical ED |
21
+ | sqrt8 | 8 | 0.5 | 2 | 784 | -6.70043783 | 4 | 36 | 2.0 | 0.0231024 | 0.0462048 | 0.0138888 | 0.0277777 | 1.6633 | canonical ED |
22
+ | sqrt8 | 8 | 0.75 | 3 | 3136 | -5.95282782 | 4 | 225 | 2.0 | 0.00755747 | 0.0151149 | 0.0138888 | 0.0277777 | 0.5441 | canonical ED |
23
+ | sqrt8 | 8 | 1.0 | 4 | 4900 | -3.78398080 | 1 | 400 | 2.0 | -0.0407816 | -0.0815632 | 0 | 0 | — | canonical ED |
24
+ | sqrt10 | 10 | 0.2 | 1 | 100 | -7.59126715 | 1 | 1 | 2.2360 | 0 | 0 | 0 | 0 | — | canonical ED |
25
+ | sqrt10 | 10 | 0.4 | 2 | 2025 | -8.86885383 | 5 | 16 | 2.2360 | 0.0160575 | 0.0321150 | 0 | 0 | — | canonical ED |
26
+ | sqrt10 | 10 | 0.6 | 3 | 14400 | -9.83963907 | 1 | 36 | 2.2360 | -0.0185496 | -0.0370993 | 0.0249999 | 0.0499999 | -0.7419 | canonical ED |
27
+ | sqrt10 | 10 | 0.8 | 4 | 44100 | -8.11706774 | 5 | 16 | 2.2360 | 0.0454973 | 0.0909946 | 0.0749999 | 0.149999 | 0.6066 | canonical ED |
28
+ | sqrt10 | 10 | 1.0 | 5 | 63504 | -5.10409191 | 1 | 1 | 2.2360 | 0.0179901 | 0.0359803 | 0.150000 | 0.300000 | 0.1199 | canonical ED |
29
+ | 3x4 | 12 | 0.1666 | 1 | 144 | -7.67599209 | 1 | 1 | 2.2360 | 2.8763189154397937e-05 | 5.7526378308795875e-05 | 0 | 0 | — | canonical ED |
30
+ | 3x4 | 12 | 0.3333 | 2 | 4356 | -11.037873924 | 1 | 4 | 2.2360 | -0.00324717 | -0.00649435 | 0.00694444 | 0.0138888 | -0.4675 | canonical ED |
31
+ | 3x4 | 12 | 0.5 | 3 | 48400 | -13.067143245 | 1 | 1 | 2.2360 | 0.0519376 | 0.103875 | 0.0416666 | 0.0833333 | 1.2465 | canonical ED |
32
+ | 3x4 | 12 | 0.6666 | 4 | 245025 | -12.64005415 | 1 | 4 | 2.2360 | 0.0180304 | 0.0360609 | 0.0434027 | 0.0868055 | 0.4154 | canonical ED |
33
+ | 3x4 | 12 | 0.8333 | 5 | 627264 | -10.76537911 | 1 | 1 | 2.2360 | 0.0284133 | 0.0568266 | 0.0607638 | 0.121527 | 0.4676 | canonical ED |
34
+ | 3x4 | 12 | 1.0 | 6 | 853776 | -5.83348425 | 1 | 1 | 2.2360 | 0.00501354 | 0.0100270 | 0.0173611 | 0.0347222 | 0.2887 | canonical ED |
35
+ | 4x4 | 16 | 0.125 | 1 | 256 | -7.76409059 | 1 | 1 | 2.8284 | 0 | 0 | 0 | 0 | — | canonical ED |
36
+ | 4x4 | 16 | 0.25 | 2 | 14400 | -11.32149713 | 3 | 16 | 2.8284 | 0.00604701 | 0.0120940 | 0 | 0 | — | canonical ED |
37
+ | 4x4 | 16 | 0.375 | 3 | 313600 | -14.72354031 | 1 | 36 | 2.8284 | -0.00686542 | -0.0137308 | 0.00781250 | 0.0156250 | -0.8787 | canonical ED |
38
+ | 4x4 | 16 | 0.5 | 4 | 3312400 | -16.46062675 | 3 | 16 | 2.8284 | 0.0240379 | 0.0480759 | 0.0234374 | 0.0468749 | 1.02561 | canonical ED |
39
+ | 4x4 | 16 | 0.625 | 5 | 19079424 | -17.51036669 | 1 | 1 | 2.8284 | 0.0300609 | 0.0601219 | 0.0468750 | 0.0937500 | 0.6413 | canonical ED |
40
+ | 4x4 | 16 | 0.75 | 6 | 64128064 | -14.92531021 | 2 | 36 | 2.8284 | 0.00491554 | 0.00983108 | 0.0208333 | 0.0416666 | 0.2359 | canonical ED |
41
+ | 4x4 | 16 | 0.875 | 7 | 130873600 | -11.86883556 | 3 | 225 | 2.8284 | 0.00960950 | 0.0192190 | 0.00520833 | 0.0104166 | 1.8450 | canonical ED |
42
+ | 4x4 | 16 | 1.0 | 8 | 165636900 | -8.46887501 | 1 | 400 | 2.8284 | 0.00309854 | 0.00619709 | — | 0 | — | canonical Wick, not ED |
43
+
44
+ ## Size-dependence check (rule fixed before this recomputation: adjacent-size differences shrink monotonically, and the last difference is ≤25% of the largest-size value)
45
+ Only fillings available on ≥3 cluster sizes are judged. Sizes ordered by N; 2x4 and sqrt8 (both N=8) in our cluster-list order. Swapping them changes no verdict.
46
+ | n | sizes | P_org U=8 per size | sign stable (N≥10) | monotone | last diff / 25% limit | converged | absolute calibration |
47
+ |---|---|---|---|---|---|---|---|
48
+ | 0.25 | 2x4, sqrt8, 4x4 | 2x4 0.002160, sqrt8 0, 4x4 0.01209 | yes (one size only) | no | 0.01209 / 0.003023 | no | not allowed |
49
+ | 0.5 | 2x4, sqrt8, 3x4, 4x4 | 2x4 -0.003636, sqrt8 0.04620, 3x4 0.1038, 4x4 0.04807 | yes | no | 0.05579 / 0.01201 | no | not allowed |
50
+ | 0.75 | 2x4, sqrt8, 4x4 | 2x4 0.1938, sqrt8 0.01511, 4x4 0.009831 | yes (one size only) | yes | 0.005283 / 0.002457 | no | not allowed |
51
+ | 1.0 | 2x4, sqrt8, sqrt10, 3x4, 4x4 | 2x4 0.03284, sqrt8 -0.08156, sqrt10 0.03598, 3x4 0.01002, 4x4 0.006197 | yes | no | 0.003829 / 0.001549 | no | not allowed |
52
+
53
+ **Reading:** the sign of P_d(R_max, U=8) is the same on the N≥10 clusters at all four fillings (for n=0.25 and 0.75 only 4x4 qualifies, so that check is trivial). No filling shows converged absolute values, so on these sizes we consider only the sign and ranking of the 4x4 values usable for calibration.
54
+
55
+ Caveats: N≤16 clusters with different shapes and different R_max are not a strict finite-size sequence. 2x4 and sqrt8 have strongly degenerate U=0 shells (up to 400-fold), and sqrt8 has R_max=2, where pair operators still share sites.
methods/Tuli99/verification/ISOLATED_REPRODUCTION.md ADDED
@@ -0,0 +1,26 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Supplemental entry-point reproduction — 21 October 2026
2
+
3
+ The original submitted ZIP was extracted to a new directory and its 30-file
4
+ manifest verified. A new virtual environment was created without installing
5
+ packages. User site packages and custom Python paths were disabled. The actual
6
+ submission PowerShell entry point was invoked after removing old fresh-target
7
+ records, the generated validation report, and the three gold output JSON files
8
+ from the extracted copy.
9
+
10
+ **PASS:** the entire entry point completed in 329.72 seconds and regenerated all
11
+ three gold submission JSON files identically to the uploaded originals. The
12
+ three fresh Lanczos runs agree within 2.3e-16; their maximum eigenvector residual
13
+ is below 3.8e-14. The subsequent cached reference audits passed 27/27 and PHS 4/4.
14
+ Those audits remain checks of stored production records, not fresh 4x4 solves.
15
+
16
+ The check used Python 3.10.20, NumPy 2.2.5 and SciPy 1.15.3; the original recorded
17
+ submission environment used NumPy 1.26.4. Libraries came from an existing base
18
+ environment. This verifies the extracted entry point and compatibility with a
19
+ second installed NumPy version, not a fresh dependency build or an independent
20
+ machine. It does not establish thermodynamic convergence or organizer verification.
21
+
22
+ The original ZIP and SHA256 remain unchanged:
23
+ `719d19f30cfb908b59d5259c1c2a528fe14e2079c23e5457d56edec0c5cb655c`.
24
+
25
+ See `isolated_reproduction.json` for measured results and `run_submission.log`
26
+ for the complete entry-point output.
methods/Tuli99/verification/isolated_reproduction.json ADDED
@@ -0,0 +1,74 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "date": "2026-10-21",
3
+ "archive_sha256": "719d19f30cfb908b59d5259c1c2a528fe14e2079c23e5457d56edec0c5cb655c",
4
+ "scope": "Freshly extracted archive in a new venv with user site and custom Python paths disabled; numerical libraries reused from installed base environment, NumPy 2.2.5 instead of original 1.26.4; not an independent-machine reproduction",
5
+ "entry_point": "method_ed/run_submission.ps1 -Python <new venv python>",
6
+ "old_target_evidence_and_gold_outputs_removed_before_run": true,
7
+ "python_version": "3.10.20 | packaged by Anaconda, Inc. | (main, Mar 11 2026, 17:42:35) [MSC v.1942 64 bit (AMD64)]",
8
+ "numpy": "2.2.5",
9
+ "scipy": "1.15.3",
10
+ "user_site_disabled": true,
11
+ "PYTHONPATH_and_PYTHONHOME_removed": true,
12
+ "dependencies_installed_for_this_check": false,
13
+ "exit_code": 0,
14
+ "elapsed_seconds": 329.72,
15
+ "fresh_target": {
16
+ "scope": "fresh 3x4 finite-cluster ED at delta=1/6; no cached inputs",
17
+ "python": "3.10.20 | packaged by Anaconda, Inc. | (main, Mar 11 2026, 17:42:35) [MSC v.1942 64 bit (AMD64)]",
18
+ "platform": "Windows-10-10.0.26300-SP0",
19
+ "numpy": "2.2.5",
20
+ "scipy": "1.15.3",
21
+ "engine_sha256": "bfa7810b47e242765fd6bf090a696c79fd8a2a465304ea4fac53b55b2149304a",
22
+ "cluster": "3x4",
23
+ "Ns": 12,
24
+ "N_up": 5,
25
+ "N_down": 5,
26
+ "delta": 0.16666666666666666,
27
+ "U_over_t": 8.0,
28
+ "runs": [
29
+ {
30
+ "seed": 20260317,
31
+ "E0": -10.765379110512942,
32
+ "degeneracy": 1,
33
+ "A_d": 0.056826612626876855,
34
+ "residual_max": 2.789744229777898e-14,
35
+ "orthogonality_error": 9.992007221626409e-16,
36
+ "Rmax": 2.236067977,
37
+ "npairs": 24,
38
+ "seconds": 106.05
39
+ },
40
+ {
41
+ "seed": 104729,
42
+ "E0": -10.76537911051297,
43
+ "degeneracy": 1,
44
+ "A_d": 0.056826612626877084,
45
+ "residual_max": 3.6400610346540385e-14,
46
+ "orthogonality_error": 2.6645352591003757e-15,
47
+ "Rmax": 2.236067977,
48
+ "npairs": 24,
49
+ "seconds": 110.7
50
+ },
51
+ {
52
+ "seed": 271828,
53
+ "E0": -10.765379110512953,
54
+ "degeneracy": 1,
55
+ "A_d": 0.05682661262687703,
56
+ "residual_max": 3.7982724056965017e-14,
57
+ "orthogonality_error": 2.220446049250313e-15,
58
+ "Rmax": 2.236067977,
59
+ "npairs": 24,
60
+ "seconds": 110.46
61
+ }
62
+ ],
63
+ "complete": true,
64
+ "energy_spread": 2.842170943040401e-14,
65
+ "A_d_spread": 2.2898349882893854e-16,
66
+ "passed": true
67
+ },
68
+ "submissions_identical_to_uploaded_package": {
69
+ "submission_gold_OSC-00747.json": true,
70
+ "submission_gold_OSC-00754.json": true,
71
+ "submission_gold_OSC-01665.json": true
72
+ },
73
+ "passed": true
74
+ }
methods/Tuli99/verification/run_submission.log ADDED
@@ -0,0 +1,17 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+
2
+ >>> reproduce_target.py
3
+ {"seed": 20260317, "E0": -10.765379110512942, "degeneracy": 1, "A_d": 0.056826612626876855, "residual_max": 2.789744229777898e-14, "orthogonality_error": 9.992007221626409e-16, "Rmax": 2.236067977, "npairs": 24, "seconds": 106.05}
4
+ {"seed": 104729, "E0": -10.76537911051297, "degeneracy": 1, "A_d": 0.056826612626877084, "residual_max": 3.6400610346540385e-14, "orthogonality_error": 2.6645352591003757e-15, "Rmax": 2.236067977, "npairs": 24, "seconds": 110.7}
5
+ {"seed": 271828, "E0": -10.765379110512953, "degeneracy": 1, "A_d": 0.05682661262687703, "residual_max": 3.7982724056965017e-14, "orthogonality_error": 2.220446049250313e-15, "Rmax": 2.236067977, "npairs": 24, "seconds": 110.46}
6
+ Independent-start check: PASS
7
+
8
+ >>> audit_results.py
9
+ Cached reference audit: 27/27
10
+ Cached PHS audit: 4/4
11
+ Fresh target: True ; curve: True
12
+
13
+ >>> submit_gold.py --author Tuli99
14
+ OSC-00747: delta=0.1667 A_d_own=0.056827 [exact] score 23.424 -> 23.902 -> submission_gold_OSC-00747.json
15
+ OSC-00754: delta=0.1667 A_d_own=0.056827 [exact] score 24.215 -> 24.709 -> submission_gold_OSC-00754.json
16
+ OSC-01665: delta=0.1667 A_d_own=0.056827 [exact] score 26.444 -> 26.984 -> submission_gold_OSC-01665.json
17
+ All requested checks passed.
methods/Tuli99/verify_manifest.py ADDED
@@ -0,0 +1,20 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Verify all SHA256SUMS.txt entries at the package root, without dependencies."""
2
+ import hashlib
3
+ from pathlib import Path
4
+
5
+ root = Path(__file__).resolve().parent
6
+ failures = []
7
+ count = 0
8
+ for line in (root / 'SHA256SUMS.txt').read_text(encoding='utf-8').splitlines():
9
+ expected, name = line.split(' ', 1)
10
+ p = (root / name).resolve()
11
+ if not p.is_relative_to(root) or not p.is_file():
12
+ failures.append(name)
13
+ continue
14
+ if hashlib.sha256(p.read_bytes()).hexdigest() != expected:
15
+ failures.append(name)
16
+ count += 1
17
+ print(f'{count} files checked; {len(failures)} failures')
18
+ if failures:
19
+ print('\n'.join(failures))
20
+ raise SystemExit(1 if failures else 0)
submissions/Tuli99_gold_OSC-00747.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "material_id": "2NiS-5",
3
+ "t": 0.25142,
4
+ "U": 2.01136,
5
+ "nef": 1.40205,
6
+ "U_over_t": 8.0,
7
+ "solver_delta": "0.1667",
8
+ "A_dwave": 0.05682661,
9
+ "provisional_score": 23.902,
10
+ "author": "Tuli99",
11
+ "osc_id": "OSC-00747",
12
+ "formula": "Ni2S2",
13
+ "level": "STRONG d-wave candidate",
14
+ "method_name": "own-ED-Hubbard U/t=8 (validated vs independent ED)",
15
+ "track": "gold",
16
+ "method": {
17
+ "model": "square-lattice Hubbard, H=-t(sum c+c + h.c.) + U n_up n_dn, U/t=8, Sz=0",
18
+ "clusters": [
19
+ "2x4",
20
+ "sqrt8",
21
+ "sqrt10",
22
+ "3x4",
23
+ "4x4"
24
+ ],
25
+ "observable": "A_d = P_org(R_max) = <Delta_d^+(j) Delta_d(i)>, organizer normalization",
26
+ "engine": "matrix-free Sz=0 ED (Lanczos+deflation, dense for dim<=8000); 4x4 Ne=5..8 via momentum-projection ED (translation group Z4xZ4, per-k Lanczos on projected blocks, dim/16)",
27
+ "U0_check": "canonical Wick vs ED U=0 agreement on all small clusters",
28
+ "validation": "27/27 match vs published independent ED (19 small-cluster pts + 4x4 Ne=1..4 full-ED + 4x4 Ne=5..8 momentum-projection, E0 diff <=1e-8); PHS A_d(Ne)=A_d(16-Ne) verified numerically on 4x4 (Ne=12..15, dP<=2.3e-16)",
29
+ "limitations": "Exact only on the stated finite clusters. Different sizes/shapes/Rmax are not a converged thermodynamic sequence. No claim that 3x4 improves the organizer 6x6 estimate; claimed scores await organizer reproduction and do not override canonical leaderboard scores.",
30
+ "particle_number_convention": "Ne in result tables means N_up=N_down, not total electrons; density=2*Ne/Ns and delta=1-density."
31
+ },
32
+ "A_d_source": {
33
+ "rule": "exact",
34
+ "point": "3x4 Ne=5",
35
+ "finite_cluster_exact": true,
36
+ "delta_matching": "official solver_delta rounded to 4 decimals",
37
+ "fresh_independent_starts": 3,
38
+ "baseline_published_A_d": 0.05569,
39
+ "ratio_own_vs_published": 1.0204
40
+ }
41
+ }
submissions/Tuli99_gold_OSC-00754.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "material_id": "2NiTe-5",
3
+ "t": 0.24796,
4
+ "U": 1.98368,
5
+ "nef": 1.4494,
6
+ "U_over_t": 8.0,
7
+ "solver_delta": "0.1667",
8
+ "A_dwave": 0.05682661,
9
+ "provisional_score": 24.709,
10
+ "author": "Tuli99",
11
+ "osc_id": "OSC-00754",
12
+ "formula": "Ni2Te2",
13
+ "level": "STRONG d-wave candidate",
14
+ "method_name": "own-ED-Hubbard U/t=8 (validated vs independent ED)",
15
+ "track": "gold",
16
+ "method": {
17
+ "model": "square-lattice Hubbard, H=-t(sum c+c + h.c.) + U n_up n_dn, U/t=8, Sz=0",
18
+ "clusters": [
19
+ "2x4",
20
+ "sqrt8",
21
+ "sqrt10",
22
+ "3x4",
23
+ "4x4"
24
+ ],
25
+ "observable": "A_d = P_org(R_max) = <Delta_d^+(j) Delta_d(i)>, organizer normalization",
26
+ "engine": "matrix-free Sz=0 ED (Lanczos+deflation, dense for dim<=8000); 4x4 Ne=5..8 via momentum-projection ED (translation group Z4xZ4, per-k Lanczos on projected blocks, dim/16)",
27
+ "U0_check": "canonical Wick vs ED U=0 agreement on all small clusters",
28
+ "validation": "27/27 match vs published independent ED (19 small-cluster pts + 4x4 Ne=1..4 full-ED + 4x4 Ne=5..8 momentum-projection, E0 diff <=1e-8); PHS A_d(Ne)=A_d(16-Ne) verified numerically on 4x4 (Ne=12..15, dP<=2.3e-16)",
29
+ "limitations": "Exact only on the stated finite clusters. Different sizes/shapes/Rmax are not a converged thermodynamic sequence. No claim that 3x4 improves the organizer 6x6 estimate; claimed scores await organizer reproduction and do not override canonical leaderboard scores.",
30
+ "particle_number_convention": "Ne in result tables means N_up=N_down, not total electrons; density=2*Ne/Ns and delta=1-density."
31
+ },
32
+ "A_d_source": {
33
+ "rule": "exact",
34
+ "point": "3x4 Ne=5",
35
+ "finite_cluster_exact": true,
36
+ "delta_matching": "official solver_delta rounded to 4 decimals",
37
+ "fresh_independent_starts": 3,
38
+ "baseline_published_A_d": 0.05569,
39
+ "ratio_own_vs_published": 1.0204
40
+ }
41
+ }
submissions/Tuli99_gold_OSC-01665.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "material_id": "2CuNiI3-1",
3
+ "t": 0.05271,
4
+ "U": 0.42168,
5
+ "nef": 1.58283,
6
+ "U_over_t": 8.0,
7
+ "solver_delta": "0.1667",
8
+ "A_dwave": 0.05682661,
9
+ "provisional_score": 26.984,
10
+ "author": "Tuli99",
11
+ "osc_id": "OSC-01665",
12
+ "formula": "Cu2I6Ni2",
13
+ "level": "STRONG d-wave candidate",
14
+ "method_name": "own-ED-Hubbard U/t=8 (validated vs independent ED)",
15
+ "track": "gold",
16
+ "method": {
17
+ "model": "square-lattice Hubbard, H=-t(sum c+c + h.c.) + U n_up n_dn, U/t=8, Sz=0",
18
+ "clusters": [
19
+ "2x4",
20
+ "sqrt8",
21
+ "sqrt10",
22
+ "3x4",
23
+ "4x4"
24
+ ],
25
+ "observable": "A_d = P_org(R_max) = <Delta_d^+(j) Delta_d(i)>, organizer normalization",
26
+ "engine": "matrix-free Sz=0 ED (Lanczos+deflation, dense for dim<=8000); 4x4 Ne=5..8 via momentum-projection ED (translation group Z4xZ4, per-k Lanczos on projected blocks, dim/16)",
27
+ "U0_check": "canonical Wick vs ED U=0 agreement on all small clusters",
28
+ "validation": "27/27 match vs published independent ED (19 small-cluster pts + 4x4 Ne=1..4 full-ED + 4x4 Ne=5..8 momentum-projection, E0 diff <=1e-8); PHS A_d(Ne)=A_d(16-Ne) verified numerically on 4x4 (Ne=12..15, dP<=2.3e-16)",
29
+ "limitations": "Exact only on the stated finite clusters. Different sizes/shapes/Rmax are not a converged thermodynamic sequence. No claim that 3x4 improves the organizer 6x6 estimate; claimed scores await organizer reproduction and do not override canonical leaderboard scores.",
30
+ "particle_number_convention": "Ne in result tables means N_up=N_down, not total electrons; density=2*Ne/Ns and delta=1-density."
31
+ },
32
+ "A_d_source": {
33
+ "rule": "exact",
34
+ "point": "3x4 Ne=5",
35
+ "finite_cluster_exact": true,
36
+ "delta_matching": "official solver_delta rounded to 4 decimals",
37
+ "fresh_independent_starts": 3,
38
+ "baseline_published_A_d": 0.05569,
39
+ "ratio_own_vs_published": 1.0204
40
+ }
41
+ }