methods/Yuseon84: ED and Néel-field VMC references behind #56 (δ = 0) — scripts and outputs

#69
by Yuseon84 - opened
Files changed (38) hide show
  1. methods/Yuseon84/LICENSE +16 -0
  2. methods/Yuseon84/README.md +44 -0
  3. methods/Yuseon84/SHA256SUMS.txt +37 -0
  4. methods/Yuseon84/code/ed_hubbard.py +154 -0
  5. methods/Yuseon84/code/ed_ksector.py +257 -0
  6. methods/Yuseon84/code/ed_ksector_gpu.py +126 -0
  7. methods/Yuseon84/code/pd_free.py +45 -0
  8. methods/Yuseon84/code/pd_free66.py +20 -0
  9. methods/Yuseon84/code/vmc_dwave.py +353 -0
  10. methods/Yuseon84/code/vmc_gpu.py +324 -0
  11. methods/Yuseon84/code/vmc_gpu2.py +539 -0
  12. methods/Yuseon84/code/vmc_gpu3.py +374 -0
  13. methods/Yuseon84/configs/vmc4x4_Ne10.json +33 -0
  14. methods/Yuseon84/configs/vmc4x4_Ne12.json +33 -0
  15. methods/Yuseon84/configs/vmc4x4_Ne14.json +33 -0
  16. methods/Yuseon84/configs/vmc4x4_Ne16.json +33 -0
  17. methods/Yuseon84/configs/vmc4x4_Ne8.json +33 -0
  18. methods/Yuseon84/configs/vmc6x6_Ne20.json +41 -0
  19. methods/Yuseon84/configs/vmc6x6_Ne22.json +41 -0
  20. methods/Yuseon84/configs/vmc6x6_Ne24.json +41 -0
  21. methods/Yuseon84/configs/vmc6x6_Ne26.json +41 -0
  22. methods/Yuseon84/configs/vmc6x6_Ne28.json +41 -0
  23. methods/Yuseon84/configs/vmc6x6_Ne30.json +41 -0
  24. methods/Yuseon84/configs/vmc6x6_Ne32.json +41 -0
  25. methods/Yuseon84/configs/vmc6x6_Ne34.json +41 -0
  26. methods/Yuseon84/configs/vmc6x6_Ne36.json +41 -0
  27. methods/Yuseon84/expected/ed4x4_Ne10_U8.json +25 -0
  28. methods/Yuseon84/expected/ed4x4_Ne12_U8.json +118 -0
  29. methods/Yuseon84/expected/ed4x4_Ne14_U8.json +118 -0
  30. methods/Yuseon84/expected/ed4x4_Ne16_U8.json +110 -0
  31. methods/Yuseon84/expected/ed4x4_Ne8_U8.json +112 -0
  32. methods/Yuseon84/expected/vmc4x4_vs_ed.json +52 -0
  33. methods/Yuseon84/expected/vmc6x6_best_by_energy.json +74 -0
  34. methods/Yuseon84/run_delta0.sh +14 -0
  35. methods/Yuseon84/run_ed_4x4.sh +7 -0
  36. methods/Yuseon84/run_free.sh +4 -0
  37. methods/Yuseon84/run_vmc_4x4.sh +8 -0
  38. methods/Yuseon84/run_vmc_6x6_seeds.sh +9 -0
methods/Yuseon84/LICENSE ADDED
@@ -0,0 +1,16 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ MIT License
2
+
3
+ Copyright (c) 2026 Yuseon84
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
6
+ documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
7
+ rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
8
+ persons to whom the Software is furnished to do so, subject to the following conditions:
9
+
10
+ The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
11
+ Software.
12
+
13
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
14
+ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
15
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
16
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
methods/Yuseon84/README.md ADDED
@@ -0,0 +1,44 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Yuseon84 — ED and Néel-field VMC references for the OSC d-wave pair correlation
2
+
3
+ Supplementary material for Discussion #56 (A_d at half filling) and #15/#18. Code: MIT (see LICENSE). Numbers and
4
+ reference values from the OSC dataset keep the dataset's CC-BY-NC 4.0.
5
+
6
+ Observable: P_d(R) = ½ · (1/N) Σ_i ⟨Δ†_{i+R} Δ_i⟩, Δ_i = (1/√2) Σ_δ g_δ (c_{i↑} c_{i+δ↓} − c_{i↓} c_{i+δ↑}), g = +1 (x),
7
+ −1 (y): the organizer normalization (½ × the singlet definition; checked against the published 4×4 U = 0 column).
8
+ Hubbard model, periodic boundaries, t = 1, U/t = 8, Sz = 0.
9
+
10
+ ## The δ = 0 numbers in #56 — `run_delta0.sh`
11
+
12
+ | quantity | lattice, R | value | file |
13
+ |---|---|---|---|
14
+ | ED, Ne = 16 (n = 1), equal-weight average over the ground manifold | 4×4, (2,2) | 0.006197 | `expected/ed4x4_Ne16_U8.json` |
15
+ | Néel-field VMC, Ne = 36, lowest-energy state, 3 seeds | 6×6, (3,3) | 0.0049 ± 0.0007 | `expected/vmc6x6_best_by_energy.json` |
16
+
17
+ The same VMC ansatz on 4×4 at n = 1 gives 0.0075 with energy within 4.6 % of ED (`expected/vmc4x4_vs_ed.json`).
18
+
19
+ ## Everything else in the package
20
+
21
+ | script | what it reproduces |
22
+ |---|---|
23
+ | `run_ed_4x4.sh` | 4×4 ED, Ne = 8–16 (R = (2,2)); all five values equal the published Ku-ku table to 6 digits, with per-momentum-sector values of each degenerate manifold |
24
+ | `run_free.sh` | exact U = 0 pair correlation with degenerate-shell averaging (4×4 normalization check; 6×6 shell decomposition of A_d) |
25
+ | `run_vmc_4x4.sh` | frozen Néel-field VMC states on 4×4 vs ED (energy within 6 % at every filling; P_d 1.7–3.6× above ED at n = 0.75–0.875) |
26
+ | `run_vmc_6x6_seeds.sh` | the 6×6 table below, three measurement seeds |
27
+
28
+ 6×6 Néel-field VMC (lowest-energy state per filling, never selected by P_d; energy below the OSC-family ansatz at every
29
+ filling):
30
+
31
+ | Ne | δ | A_d published | P_d (3 seeds) |
32
+ |---|---|---|---|
33
+ | 36 | 0.000 | 0.0384 | 0.0049 ± 0.0007 |
34
+ | 34 | 0.056 | 0.0452 | 0.0309 ± 0.0002 |
35
+ | 32 | 0.111 | 0.0473 | 0.0400 ± 0.0006 |
36
+ | 30 | 0.167 | 0.0557 | 0.0437 ± 0.0001 |
37
+ | 28 | 0.222 | 0.0481 | 0.0464 ± 0.0004 |
38
+ | 26 | 0.278 | 0.0585 | 0.0342 ± 0.0001 |
39
+ | 24 | 0.333 | 0.0430 | 0.0398 ± 0.0004 |
40
+
41
+ Values at δ ≥ 0.389 are omitted: there this ansatz exceeds even the U = 0 result (open-shell bias).
42
+
43
+ Limits: variational, not exact; 4×4 ED is small. Not a request to change any score of our own entries.
44
+ Requirements: Python 3.10, numpy, scipy; PyTorch with CUDA for the GPU scripts. Prepared with AI assistance (Claude Code).
methods/Yuseon84/SHA256SUMS.txt ADDED
@@ -0,0 +1,37 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ 065e472d891b938564e538453feef3db047cf84b268eecb0f3e1f6163b61ca48 *./LICENSE
2
+ 19c64bb8ee160159538763b8d53db3f9243f2026d3e14244f914c3b8556182f5 *./README.md
3
+ 3e3ae84d7c73f0ec37bf9d0387f338759cef4f77b092b619acfae38df4f26597 *./code/ed_hubbard.py
4
+ 0432c753bad0bc4c4702bcc1293ce38c94fe75018f3ca310211e4ad3285117a0 *./code/ed_ksector.py
5
+ 518f46af8cf0294a163b5a1cec8aa37c9661f9844c2085637146d548fc61b388 *./code/ed_ksector_gpu.py
6
+ 7041aafec1e9b43bf410aae038124011d999e961babac1e0bd10802a42697790 *./code/pd_free.py
7
+ 3ff5ff7d74e6c27efdd22fe8401adea4bd2ae06f8bcade1d8d557a446aa0de24 *./code/pd_free66.py
8
+ 11143cc32f69e40e630e12d6028b9ab76216441b6d1b0ffe2642f9c577d60419 *./code/vmc_dwave.py
9
+ aa88304ebc1f67b66c5e7528b0eb9e4ad0b5b1e27ba5c5fc7db5fafd9a48031e *./code/vmc_gpu.py
10
+ 03ec08aea607010403df9dbbf432aee070e309f097df7d059af92b720746e65e *./code/vmc_gpu2.py
11
+ d46fcba969cae69bcce38d3bf2c5d9b1c127fda224c9909dd1780a924202d9d7 *./code/vmc_gpu3.py
12
+ 9d1f45bd9dcf578e5cc913323bcd4fde8ef5fc877031613c2232e2e65fdcaa6e *./configs/vmc4x4_Ne10.json
13
+ 623db3716a5e04e447d10bf3503fa867cab14b28bd73bd3a2dc9890e12375376 *./configs/vmc4x4_Ne12.json
14
+ 740487d54a278633759bc83f68a6de7df23ef54258517177f4ff4f0047da52a5 *./configs/vmc4x4_Ne14.json
15
+ 2350abb243ffbce4ea23a80de70b9b22c27c7e98200b87baabeec5b4500a12fa *./configs/vmc4x4_Ne16.json
16
+ f74fc3e640d4ff83a154ebed4cc7fec3a579a4f29e5e7a1791aad1e06614cf55 *./configs/vmc4x4_Ne8.json
17
+ 7817316d6c7377169a6308c28fb2a01eebd8357ac634e3377221dc3e7dd6a5da *./configs/vmc6x6_Ne20.json
18
+ 416fe562b39d121740a84fe971441522563afbb66e88afc3ff4ad0667969a842 *./configs/vmc6x6_Ne22.json
19
+ 5b1e75f37a8fba5cd550597837ca6baa10664f87613099bb65056e06f95f0222 *./configs/vmc6x6_Ne24.json
20
+ 4a6775b1f37dea0bba87e594d49c205afd80fc28d20635e6e7b5d28a94c04944 *./configs/vmc6x6_Ne26.json
21
+ 488216a2924559da872e4748cc6969acafdb34b996f5b9325320dc26acbc7e3c *./configs/vmc6x6_Ne28.json
22
+ 3c305ffb1c58463b78c7fb88ce596e7574b2e9c2b6385afd825fc4325c6f0c74 *./configs/vmc6x6_Ne30.json
23
+ d514e03d8cf2f72cfd1731e0cfa74461e508cbb2dfe00ad0c59f1859af4887fb *./configs/vmc6x6_Ne32.json
24
+ d23c0c9331fe5ce60677ffab99504e83132d3a6d3a9194579f87289a9e3b7cb5 *./configs/vmc6x6_Ne34.json
25
+ 55d7b00e20a08ff2b0ddf66770b1d2680f6e2cd52561334d813f0240498dfc3d *./configs/vmc6x6_Ne36.json
26
+ a2f07179fe323491a87e1f9c7e6513442ebf5e992ed0d51ddd7ee70cf82cc71f *./expected/ed4x4_Ne10_U8.json
27
+ 95aa02d489bd3729170c24214f34c9950a755c7d8061a92a8ddfc01edfb3cd48 *./expected/ed4x4_Ne12_U8.json
28
+ c065119134a5269f76def253de6f57b1d4ad3c6d301163b24efe7b3f41c860b9 *./expected/ed4x4_Ne14_U8.json
29
+ d95338c8d7750cf70f5dfb2bea04e38941ad8fe45aa351dbed833654f0b53ab8 *./expected/ed4x4_Ne16_U8.json
30
+ f25373243445a414624ec30de42d02276746b5fc937add954f39d02d860832f6 *./expected/ed4x4_Ne8_U8.json
31
+ 5a4c969718b658a15ae8c8b63de83a36d812de5a61bfade80c5f2f83031c41b5 *./expected/vmc4x4_vs_ed.json
32
+ 57d0d21c3e18bd8e20345ffe3cb04e8c0f5bc735115f74ae54e521fbae8eec28 *./expected/vmc6x6_best_by_energy.json
33
+ 033e2aad3dc878469b928161a6bbf4b9bab996a9081f2e8ca6e57533c6f4236c *./run_delta0.sh
34
+ 3334ddd02a19ca8c0b33d539c2e88be6b80f17e939c1ed4a7519a3cc640117a2 *./run_ed_4x4.sh
35
+ b7425f0baf819fdd89a5815c3539cca3b154e50aa8f906e6c4d6262302db54da *./run_free.sh
36
+ 6559d31fc13207fe29cad75162271f6ae7d015189473b6285b65695ca1954c18 *./run_vmc_4x4.sh
37
+ 381b40f2801cfc48ee983d42849224996223e7f480d025a90c2c4c4804847308 *./run_vmc_6x6_seeds.sh
methods/Yuseon84/code/ed_hubbard.py ADDED
@@ -0,0 +1,154 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Exact diagonalization of the 2D Hubbard model on an LxL periodic cluster, Sz=0 sector,
3
+ and the OSC d-wave pair correlation P_d(R).
4
+
5
+ Matrix-free product basis: psi is a [dim_up, dim_dn] matrix,
6
+ H psi = T_up @ psi + psi @ T_dn^T + U * D * psi, D[a,b] = popcount(up_a & dn_b)
7
+ Fermion ordering: all up operators left of all down operators, sites ascending.
8
+
9
+ OSC normalization (pinned by the U=0 check in pd_free.py):
10
+ P_org(R) = 1/2 * (1/N) sum_i <D_{i+R}^dag D_i>,
11
+ D_i = 1/sqrt2 sum_d g_d (c_{i,up} c_{i+d,dn} - c_{i,dn} c_{i+d,up}), g = +1 (x), -1 (y)
12
+ Degenerate ground states are averaged with equal weight (as in the Ku-ku ED reference).
13
+ """
14
+ import argparse, itertools, json, time
15
+ import numpy as np
16
+ import scipy.sparse as sp
17
+ from scipy.sparse.linalg import LinearOperator, eigsh
18
+
19
+ NB = [((1, 0), 1.0), ((-1, 0), 1.0), ((0, 1), -1.0), ((0, -1), -1.0)]
20
+
21
+
22
+ def site(L, x, y):
23
+ return (x % L) * L + (y % L)
24
+
25
+
26
+ def basis(Ns, n):
27
+ st = np.array(sorted(sum(1 << i for i in c) for c in itertools.combinations(range(Ns), n)),
28
+ dtype=np.int64)
29
+ return st
30
+
31
+
32
+ def popcount(a):
33
+ a = a.copy(); c = np.zeros_like(a)
34
+ while a.any():
35
+ c += a & 1; a >>= 1
36
+ return c
37
+
38
+
39
+ def hop_matrix(L, st, t=1.0):
40
+ """-t sum_<ab> (c_a^dag c_b + h.c.) on one spin species."""
41
+ Ns = L * L
42
+ bonds = set()
43
+ for x in range(L):
44
+ for y in range(L):
45
+ a = site(L, x, y)
46
+ for b in (site(L, x + 1, y), site(L, x, y + 1)):
47
+ bonds.add((min(a, b), max(a, b)))
48
+ rows, cols, vals = [], [], []
49
+ for (a, b) in sorted(bonds):
50
+ mask_between = ((1 << b) - 1) ^ ((1 << (a + 1)) - 1) # sites strictly between a and b
51
+ for src, dst in ((a, b), (b, a)): # c_dst^dag c_src
52
+ has = (st >> src) & 1
53
+ emp = ((st >> dst) & 1) == 0
54
+ ok = np.nonzero(has.astype(bool) & emp)[0]
55
+ new = st[ok] ^ (1 << src) ^ (1 << dst)
56
+ sign = 1 - 2 * (popcount(st[ok] & mask_between) & 1)
57
+ rows.append(np.searchsorted(st, new)); cols.append(ok); vals.append(-t * sign)
58
+ n = len(st)
59
+ return sp.csr_matrix((np.concatenate(vals).astype(float),
60
+ (np.concatenate(rows), np.concatenate(cols))), shape=(n, n))
61
+
62
+
63
+ def annihilator(st_from, st_to, i):
64
+ """c_i : basis(n) -> basis(n-1), with sign (-1)^{#occupied below i}."""
65
+ ok = np.nonzero((st_from >> i) & 1)[0]
66
+ new = st_from[ok] ^ (1 << i)
67
+ sign = 1 - 2 * (popcount(st_from[ok] & ((1 << i) - 1)) & 1)
68
+ return sp.csr_matrix((sign.astype(float), (np.searchsorted(st_to, new), ok)),
69
+ shape=(len(st_to), len(st_from)))
70
+
71
+
72
+ def ground_states(L, nup, ndn, U, k=6, tol=1e-10, degen_tol=1e-7, ncv=None):
73
+ Ns = L * L
74
+ su, sd = basis(Ns, nup), basis(Ns, ndn)
75
+ Tu, Td = hop_matrix(L, su), hop_matrix(L, sd)
76
+ bu = ((su[:, None] >> np.arange(Ns)) & 1).astype(np.float32)
77
+ bd = ((sd[:, None] >> np.arange(Ns)) & 1).astype(np.float32)
78
+ D = (bu @ bd.T).astype(np.float64)
79
+ du, dd = len(su), len(sd)
80
+ def mv(v):
81
+ P = v.reshape(du, dd)
82
+ out = Tu @ P
83
+ out += (Td @ P.T).T # psi @ T_dn^T (T_dn symmetric)
84
+ out += U * D * P
85
+ return out.ravel()
86
+
87
+ H = LinearOperator((du * dd, du * dd), matvec=mv, dtype=np.float64)
88
+ k = min(k, du * dd - 2)
89
+ w, V = eigsh(H, k=k, which="SA", tol=tol, ncv=ncv)
90
+ o = np.argsort(w); w, V = w[o], V[:, o]
91
+ e0 = w[0]
92
+ deg = int(np.sum(np.abs(w - e0) < degen_tol * max(1.0, abs(e0))))
93
+ if deg == k:
94
+ print(f"[warn] degeneracy may exceed k={k}; rerun with larger --k")
95
+ return dict(su=su, sd=sd, E=w, E0=e0, deg=deg, V=V[:, :deg], du=du, dd=dd)
96
+
97
+
98
+ def pair_corr(L, gs, Rs):
99
+ Ns = L * L
100
+ su, sd, du, dd = gs["su"], gs["sd"], gs["du"], gs["dd"]
101
+ nup, ndn = bin(int(su[0])).count("1"), bin(int(sd[0])).count("1")
102
+ su1, sd1 = basis(Ns, nup - 1), basis(Ns, ndn - 1)
103
+ Au = [annihilator(su, su1, i) for i in range(Ns)]
104
+ Ad = [annihilator(sd, sd1, i) for i in range(Ns)]
105
+ out = {R: 0.0 for R in Rs}
106
+ for s in range(gs["deg"]):
107
+ P = gs["V"][:, s].reshape(du, dd)
108
+ phi = []
109
+ for x in range(L):
110
+ for y in range(L):
111
+ i = site(L, x, y)
112
+ acc = np.zeros((len(su1), len(sd1)))
113
+ for (d, g) in NB:
114
+ j = site(L, x + d[0], y + d[1])
115
+ # c_{i,up} c_{j,dn} - c_{i,dn} c_{j,up} = c_{i,up}c_{j,dn} + c_{j,up}c_{i,dn}
116
+ acc += g * ((Au[i] @ (Ad[j] @ P.T).T) + (Au[j] @ (Ad[i] @ P.T).T))
117
+ phi.append(acc / np.sqrt(2.0))
118
+ for R in Rs:
119
+ tot = 0.0
120
+ for x in range(L):
121
+ for y in range(L):
122
+ i, j = site(L, x, y), site(L, x + R[0], y + R[1])
123
+ tot += np.vdot(phi[j], phi[i]).real
124
+ out[R] += 0.5 * tot / Ns / gs["deg"] # 0.5 = OSC (organizer) normalization
125
+ return out
126
+
127
+
128
+ def main():
129
+ ap = argparse.ArgumentParser()
130
+ ap.add_argument("--L", type=int, default=4)
131
+ ap.add_argument("--Ne", type=int, nargs="+", default=[8, 10])
132
+ ap.add_argument("--U", type=float, default=8.0)
133
+ ap.add_argument("--k", type=int, default=8)
134
+ ap.add_argument("--ncv", type=int, default=None)
135
+ ap.add_argument("--out", default="")
136
+ a = ap.parse_args()
137
+ L = a.L; Rmax = (L // 2, L // 2)
138
+ res = []
139
+ for Ne in a.Ne:
140
+ t0 = time.time()
141
+ gs = ground_states(L, Ne // 2, Ne // 2, a.U, k=a.k, ncv=a.ncv)
142
+ pc = pair_corr(L, gs, [Rmax, (1, 1), (2, 0)] if L >= 4 else [Rmax])
143
+ r = dict(L=L, Ne=Ne, n=Ne / L ** 2, U=a.U, E0=gs["E0"], deg=gs["deg"],
144
+ dim=gs["du"] * gs["dd"], lowest=[round(float(x), 8) for x in gs["E"][:min(6, len(gs["E"]))]],
145
+ Pd={f"{R[0]},{R[1]}": round(v, 6) for R, v in pc.items()},
146
+ sec=round(time.time() - t0, 1))
147
+ print(json.dumps(r), flush=True)
148
+ res.append(r)
149
+ if a.out:
150
+ json.dump(res, open(a.out, "w"), indent=1)
151
+
152
+
153
+ if __name__ == "__main__":
154
+ main()
methods/Yuseon84/code/ed_ksector.py ADDED
@@ -0,0 +1,257 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Momentum-sector ED of the Hubbard model on an LxL periodic cluster (Sz=0), with the OSC
3
+ d-wave pair correlation averaged over the full degenerate ground-state manifold.
4
+
5
+ Basis: "up-representative" coding. A k-state is P_k sum_{r,d} f[r,d] |r,d>, with r running over
6
+ translation-orbit representatives of the up configuration and d over ALL down configurations.
7
+ Rows r with a non-trivial stabilizer S_r are kept symmetrized (Sym), and coordinates are scaled by
8
+ sqrt|S_r| so the induced metric is Euclidean -> the operator is Hermitian on the symmetric subspace
9
+ (it is zero on its complement, which only adds spurious zero eigenvalues; ground energies are < 0).
10
+
11
+ P_k|c'> = sigma * exp(-i k.g) * P_k|a> when T_g c' = sigma * a.
12
+
13
+ Pair correlation: for a momentum eigenstate, (1/N) sum_i <D+_{i+R} D_i> = <D+_R D_0>, evaluated
14
+ as sum of <(c+_{p'up} c_{p up})(c+_{q'dn} c_{q dn})> bilinears on the expanded wavefunction.
15
+ OSC normalization = 1/2 x standard singlet definition (see pd_free.py / ed_hubbard.py).
16
+ """
17
+ import argparse, json, time, itertools
18
+ import numpy as np
19
+ import scipy.sparse as sp
20
+ from scipy.sparse.linalg import LinearOperator, eigsh
21
+ from ed_hubbard import basis, popcount, hop_matrix, site, NB
22
+
23
+
24
+ def translations(L):
25
+ G = [(gx, gy) for gx in range(L) for gy in range(L)]
26
+ perm = np.array([[site(L, x + gx, y + gy) for x in range(L) for y in range(L)] for gx, gy in G])
27
+ return G, perm
28
+
29
+
30
+ def act(st, perm_g):
31
+ """Image index and fermion sign of T_g on every basis state of one spin species."""
32
+ Ns = len(perm_g)
33
+ occ = ((st[:, None] >> np.arange(Ns)) & 1).astype(np.int64)
34
+ new = (occ << perm_g[None, :]).sum(1)
35
+ inv = np.zeros(len(st), dtype=np.int64)
36
+ for s1 in range(Ns):
37
+ for s2 in range(s1 + 1, Ns):
38
+ if perm_g[s1] > perm_g[s2]:
39
+ inv += occ[:, s1] & occ[:, s2]
40
+ return np.searchsorted(st, new), 1.0 - 2.0 * (inv & 1)
41
+
42
+
43
+ def bilinear(st, a, b):
44
+ """Matrix of c+_a c_b on one spin species (a may equal b)."""
45
+ n = len(st)
46
+ if a == b:
47
+ return sp.diags(((st >> a) & 1).astype(float)).tocsr()
48
+ has = ((st >> b) & 1).astype(bool) & (((st >> a) & 1) == 0)
49
+ ok = np.nonzero(has)[0]
50
+ new = st[ok] ^ (1 << a) ^ (1 << b)
51
+ lo, hi = min(a, b), max(a, b)
52
+ between = ((1 << hi) - 1) ^ ((1 << (lo + 1)) - 1)
53
+ sign = 1 - 2 * (popcount(st[ok] & between) & 1)
54
+ return sp.csr_matrix((sign.astype(float), (np.searchsorted(st, new), ok)), shape=(n, n))
55
+
56
+
57
+ class Sector:
58
+ def __init__(self, L, nup, ndn, U, k):
59
+ self.L, self.U, self.k = L, U, k
60
+ Ns = L * L
61
+ self.su, self.sd = basis(Ns, nup), basis(Ns, ndn)
62
+ self.G, permS = translations(L)
63
+ nG = len(self.G)
64
+ self.ph = np.array([np.exp(-2j * np.pi / L * (k[0] * g[0] + k[1] * g[1])) for g in self.G])
65
+ self.img_u, self.sg_u, self.img_d, self.sg_d = [], [], [], []
66
+ for g in range(nG):
67
+ i, s = act(self.su, permS[g]); self.img_u.append(i); self.sg_u.append(s)
68
+ i, s = act(self.sd, permS[g]); self.img_d.append(i); self.sg_d.append(s)
69
+ self.img_u = np.array(self.img_u); self.sg_u = np.array(self.sg_u)
70
+ self.img_d = np.array(self.img_d); self.sg_d = np.array(self.sg_d)
71
+ du, dd = len(self.su), len(self.sd)
72
+ g0 = np.argmin(self.img_u, axis=0) # g0[u]: T_g0 u = rep(u)
73
+ rep_of = self.img_u[g0, np.arange(du)]
74
+ self.reps = np.unique(rep_of)
75
+ pos = -np.ones(du, dtype=np.int64); pos[self.reps] = np.arange(len(self.reps))
76
+ nR = len(self.reps); self.nR, self.dd, self.du = nR, dd, du
77
+ # stabilizers and symmetrizers for rows with non-trivial S_r
78
+ self.S = np.ones(nR)
79
+ self.sym = [] # (row, [(src, coef)])
80
+ for ri, r in enumerate(self.reps):
81
+ stab = [g for g in range(nG) if self.img_u[g, r] == r]
82
+ self.S[ri] = len(stab)
83
+ if len(stab) > 1:
84
+ terms = []
85
+ for h in stab:
86
+ # f_sym[d''] = mean_h sigma_u(h,r) sigma_d(h,src) e^{-ik.h} f[src], src = h^-1 d''
87
+ src = np.empty(dd, dtype=np.int64); src[self.img_d[h]] = np.arange(dd)
88
+ coef = self.sg_u[h, r] * self.sg_d[h][src] * self.ph[h]
89
+ terms.append((src, coef))
90
+ self.sym.append((ri, terms))
91
+ self.sqS = np.sqrt(self.S)
92
+ # interaction
93
+ bu = ((self.su[self.reps][:, None] >> np.arange(Ns)) & 1).astype(np.float32)
94
+ bd = ((self.sd[:, None] >> np.arange(Ns)) & 1).astype(np.float32)
95
+ self.Dm = (bu @ bd.T).astype(np.float64)
96
+ # hopping
97
+ self.Td = hop_matrix(L, self.sd)
98
+ Tu = hop_matrix(L, self.su).tocsc()
99
+ rows = {g: ([], [], []) for g in range(nG)}
100
+ for ri, r in enumerate(self.reps):
101
+ for idx in range(Tu.indptr[r], Tu.indptr[r + 1]):
102
+ u2, amp = Tu.indices[idx], Tu.data[idx]
103
+ g = g0[u2]; rj = pos[rep_of[u2]]
104
+ c = amp * self.sg_u[g, u2] * self.ph[g]
105
+ rows[g][0].append(rj); rows[g][1].append(ri); rows[g][2].append(c)
106
+ self.Up = [(g, sp.csr_matrix((np.array(v[2], dtype=complex), (v[0], v[1])), shape=(nR, nR)))
107
+ for g, v in rows.items() if v[0]]
108
+ self.rep_of, self.g0, self.pos = rep_of, g0, pos
109
+
110
+ def symm(self, F):
111
+ for ri, terms in self.sym:
112
+ acc = np.zeros(self.dd, dtype=complex)
113
+ for src, coef in terms:
114
+ acc += coef * F[ri, src]
115
+ F[ri] = acc / len(terms)
116
+ return F
117
+
118
+ def matvec(self, v):
119
+ F = self.symm(v.reshape(self.nR, self.dd) / self.sqS[:, None])
120
+ out = self.U * self.Dm * F
121
+ out += (self.Td @ F.T).T
122
+ for g, M in self.Up:
123
+ out[:, self.img_d[g]] += M @ (F * self.sg_d[g][None, :])
124
+ out = self.symm(out)
125
+ return (out * self.sqS[:, None]).ravel()
126
+
127
+ def solve(self, k=4, tol=1e-10, ncv=None):
128
+ n = self.nR * self.dd
129
+ H = LinearOperator((n, n), matvec=self.matvec, dtype=complex)
130
+ rng = np.random.default_rng(1)
131
+ v0 = rng.normal(size=n) + 1j * rng.normal(size=n)
132
+ v0 = (self.symm(v0.reshape(self.nR, self.dd) / self.sqS[:, None]) * self.sqS[:, None]).ravel()
133
+ w, V = eigsh(H, k=k, which="SA", tol=tol, v0=v0, ncv=ncv)
134
+ o = np.argsort(w)
135
+ return w[o], V[:, o]
136
+
137
+ def expand(self, v):
138
+ """Full-product-basis wavefunction Psi[u,d] (normalized) of the k-state with coords v."""
139
+ F = self.symm(v.reshape(self.nR, self.dd) / self.sqS[:, None])
140
+ Psi = np.zeros((self.du, self.dd), dtype=complex)
141
+ for ri, r in enumerate(self.reps):
142
+ for g in range(len(self.G)):
143
+ u = self.img_u[g, r]
144
+ Psi[u, self.img_d[g]] += self.ph[g] * self.sg_u[g, r] * self.sg_d[g] * F[ri]
145
+ Psi /= np.linalg.norm(Psi)
146
+ return Psi
147
+
148
+
149
+ def pair_corr_k(L, su, sd, Psi, R, blk=2048):
150
+ """<D+_R D_0>, OSC normalization."""
151
+ Rs = site(L, R[0], R[1])
152
+ terms = []
153
+ for (d, g) in NB:
154
+ dj = site(L, d[0], d[1])
155
+ for (dp, gp) in NB:
156
+ Rj = site(L, R[0] + dp[0], R[1] + dp[1])
157
+ for (p, q) in ((0, dj), (dj, 0)):
158
+ for (pp, qp) in ((Rs, Rj), (Rj, Rs)):
159
+ terms.append((g * gp, pp, p, qp, q))
160
+ cache_u, cache_d = {}, {}
161
+ tot = 0.0
162
+ for c, pp, p, qp, q in terms:
163
+ A = cache_u.setdefault((pp, p), bilinear(su, pp, p))
164
+ B = cache_d.setdefault((qp, q), bilinear(sd, qp, q))
165
+ val = 0.0
166
+ for a0 in range(0, Psi.shape[0], blk):
167
+ X = A[a0:a0 + blk] @ Psi
168
+ Y = (B @ X.T).T
169
+ val += np.vdot(Psi[a0:a0 + blk], Y)
170
+ tot += c * val
171
+ return 0.5 * 0.5 * tot.real # 1/2 from sqrt2*sqrt2, 1/2 OSC normalization
172
+
173
+
174
+ def irreducible_k(L):
175
+ """C4v-irreducible momenta with star multiplicities."""
176
+ seen, out = set(), []
177
+ for kx in range(L):
178
+ for ky in range(L):
179
+ if (kx, ky) in seen:
180
+ continue
181
+ star = set()
182
+ for (a, b) in [(kx, ky), (ky, kx)]:
183
+ for sx in (1, -1):
184
+ for sy in (1, -1):
185
+ star.add(((sx * a) % L, (sy * b) % L))
186
+ seen |= star
187
+ out.append(((kx, ky), len(star)))
188
+ return out
189
+
190
+
191
+ def main():
192
+ ap = argparse.ArgumentParser()
193
+ ap.add_argument("--L", type=int, default=4)
194
+ ap.add_argument("--Ne", type=int, required=True)
195
+ ap.add_argument("--U", type=float, default=8.0)
196
+ ap.add_argument("--k", type=int, default=4, help="eigenpairs per sector")
197
+ ap.add_argument("--degen_tol", type=float, default=1e-7)
198
+ ap.add_argument("--ncv", type=int, default=None)
199
+ ap.add_argument("--out", default="")
200
+ ap.add_argument("--sector", type=int, default=-1, help="solve only this irreducible-k index, save to --save")
201
+ ap.add_argument("--save", default="", help="directory for per-sector npz files")
202
+ ap.add_argument("--combine", action="store_true", help="combine saved sectors from --save")
203
+ a = ap.parse_args()
204
+ L, Ne = a.L, a.Ne
205
+ R = (L // 2, L // 2)
206
+ t0 = time.time()
207
+ ks = irreducible_k(L)
208
+ tag = f"L{L}_Ne{Ne}_U{a.U:g}"
209
+ if a.sector >= 0: # solve one sector, persist low states
210
+ kv, mult = ks[a.sector]
211
+ S = Sector(L, Ne // 2, Ne // 2, a.U, kv)
212
+ w, V = S.solve(k=a.k, ncv=a.ncv)
213
+ low = [i for i, e in enumerate(w) if abs(e - w[0]) < a.degen_tol * abs(w[0])]
214
+ np.savez(f"{a.save}/{tag}_k{kv[0]}{kv[1]}.npz", k=np.array(kv), mult=mult, E=w, V=V[:, low])
215
+ print(f"k={kv} x{mult} dim={S.nR*S.dd} nlow={len(low)} E={np.round(w,8).tolist()} "
216
+ f"({time.time()-t0:.0f}s)", flush=True)
217
+ if len(low) == len(w):
218
+ print(f"[warn] k={kv}: all {len(low)} eigenpairs degenerate; raise --k", flush=True)
219
+ return
220
+ sec = []
221
+ if a.combine:
222
+ for kv, mult in ks:
223
+ z = np.load(f"{a.save}/{tag}_k{kv[0]}{kv[1]}.npz")
224
+ sec.append(dict(k=kv, mult=mult, E=z["E"].tolist(), V=z["V"], nlow=z["V"].shape[1], S=None))
225
+ else:
226
+ for kv, mult in ks:
227
+ S = Sector(L, Ne // 2, Ne // 2, a.U, kv)
228
+ w, V = S.solve(k=a.k, ncv=a.ncv)
229
+ low = [i for i, e in enumerate(w) if abs(e - w[0]) < a.degen_tol * abs(w[0])]
230
+ sec.append(dict(k=kv, mult=mult, E=w.tolist(), S=S, V=V[:, low].copy(), nlow=len(low)))
231
+ del V
232
+ print(f"k={kv} x{mult} dim={S.nR*S.dd} E={np.round(w,8).tolist()} ({time.time()-t0:.0f}s)", flush=True)
233
+ E0 = min(s["E"][0] for s in sec)
234
+ acc, wsum, manifold = 0.0, 0, []
235
+ for s in sec:
236
+ idx = [i for i in range(s["nlow"]) if abs(s["E"][i] - E0) < a.degen_tol * abs(E0)]
237
+ if idx and s["S"] is None:
238
+ s["S"] = Sector(L, Ne // 2, Ne // 2, a.U, s["k"])
239
+ for i in idx:
240
+ Psi = s["S"].expand(s["V"][:, i])
241
+ p = pair_corr_k(L, s["S"].su, s["S"].sd, Psi, R)
242
+ del Psi
243
+ acc += s["mult"] * p; wsum += s["mult"]
244
+ manifold.append(dict(k=s["k"], mult=s["mult"], Pd=round(p, 8)))
245
+ print(f" GS in k={s['k']} x{s['mult']}: Pd={p:.6f}", flush=True)
246
+ s["S"] = None
247
+ res = dict(L=L, Ne=Ne, n=Ne / L ** 2, U=a.U, E0=E0, deg=wsum, R=list(R),
248
+ Pd=round(acc / wsum, 6), manifold=manifold,
249
+ sectors=[dict(k=s["k"], mult=s["mult"], E=[round(e, 8) for e in s["E"]]) for s in sec],
250
+ sec=round(time.time() - t0, 1))
251
+ print(json.dumps(res), flush=True)
252
+ if a.out:
253
+ json.dump(res, open(a.out, "w"), indent=1)
254
+
255
+
256
+ if __name__ == "__main__":
257
+ main()
methods/Yuseon84/code/ed_ksector_gpu.py ADDED
@@ -0,0 +1,126 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """GPU (torch/CUDA) matvec for the momentum-sector ED in ed_ksector.py.
3
+
4
+ Same basis, same npz output format (so CPU- and GPU-solved sectors can be combined with
5
+ `ed_ksector.py --combine`). ARPACK (scipy eigsh) stays on the CPU; only H*v runs on the GPU.
6
+ Complex sparse products are split into real ones for portability.
7
+ """
8
+ import argparse, time
9
+ import numpy as np
10
+ import torch
11
+ from scipy.sparse.linalg import LinearOperator, eigsh
12
+ from ed_ksector import Sector, irreducible_k
13
+
14
+ DEV = torch.device("cuda")
15
+
16
+
17
+ def to_sparse(m):
18
+ m = m.tocsr()
19
+ return torch.sparse_csr_tensor(torch.from_numpy(m.indptr.astype(np.int64)),
20
+ torch.from_numpy(m.indices.astype(np.int64)),
21
+ torch.from_numpy(np.ascontiguousarray(m.data, dtype=np.float64)),
22
+ size=m.shape, device=DEV)
23
+
24
+
25
+ class GPUSector:
26
+ def __init__(self, S):
27
+ self.S = S
28
+ self.nR, self.dd = S.nR, S.dd
29
+ self.U = S.U
30
+ self.Dm = torch.from_numpy(S.Dm).to(DEV)
31
+ self.Td = to_sparse(S.Td)
32
+ self.up = []
33
+ for g, M in S.Up:
34
+ self.up.append((to_sparse(M.real), to_sparse(M.imag) if abs(M.imag).max() > 0 else None,
35
+ torch.from_numpy(S.sg_d[g]).to(DEV),
36
+ torch.from_numpy(S.img_d[g].astype(np.int64)).to(DEV)))
37
+ self.sym = [(ri, [(torch.from_numpy(src).to(DEV), torch.from_numpy(coef).to(DEV)) for src, coef in terms])
38
+ for ri, terms in S.sym]
39
+ self.sqS = torch.from_numpy(S.sqS).to(DEV)
40
+
41
+ def symm(self, F):
42
+ for ri, terms in self.sym:
43
+ acc = torch.zeros(self.dd, dtype=torch.complex128, device=DEV)
44
+ for src, coef in terms:
45
+ acc += coef * F[ri, src]
46
+ F[ri] = acc / len(terms)
47
+ return F
48
+
49
+ @staticmethod
50
+ def spmm(A, X): # real sparse x complex dense
51
+ return torch.complex(A @ X.real.contiguous(), A @ X.imag.contiguous())
52
+
53
+ def matvec_t(self, F):
54
+ F = self.symm(F / self.sqS[:, None])
55
+ out = self.U * self.Dm * F
56
+ out += self.spmm(self.Td, F.T.contiguous()).T
57
+ for Mr, Mi, sg, img in self.up:
58
+ X = F * sg[None, :]
59
+ Y = self.spmm(Mr, X)
60
+ if Mi is not None:
61
+ Y = Y + 1j * self.spmm(Mi, X)
62
+ out.index_add_(1, img, Y)
63
+ out = self.symm(out)
64
+ return out * self.sqS[:, None]
65
+
66
+ def matvec(self, v):
67
+ F = torch.from_numpy(np.ascontiguousarray(v.reshape(self.nR, self.dd))).to(DEV)
68
+ return self.matvec_t(F).cpu().numpy().ravel()
69
+
70
+ def solve(self, k=5, tol=1e-10, ncv=None):
71
+ n = self.nR * self.dd
72
+ H = LinearOperator((n, n), matvec=self.matvec, dtype=complex)
73
+ rng = np.random.default_rng(1)
74
+ v0 = rng.normal(size=n) + 1j * rng.normal(size=n)
75
+ v0 = (self.S.symm(v0.reshape(self.nR, self.dd) / self.S.sqS[:, None]) * self.S.sqS[:, None]).ravel()
76
+ w, V = eigsh(H, k=k, which="SA", tol=tol, v0=v0, ncv=ncv)
77
+ o = np.argsort(w)
78
+ return w[o], V[:, o]
79
+
80
+
81
+ def main():
82
+ ap = argparse.ArgumentParser()
83
+ ap.add_argument("--L", type=int, default=4)
84
+ ap.add_argument("--Ne", type=int, required=True)
85
+ ap.add_argument("--U", type=float, default=8.0)
86
+ ap.add_argument("--k", type=int, default=5)
87
+ ap.add_argument("--ncv", type=int, default=14)
88
+ ap.add_argument("--degen_tol", type=float, default=1e-7)
89
+ ap.add_argument("--sectors", default="all", help="comma list of irreducible-k indices, or 'all'")
90
+ ap.add_argument("--save", default="sectors")
91
+ ap.add_argument("--bench", action="store_true", help="time a few matvecs vs CPU and check agreement")
92
+ a = ap.parse_args()
93
+ ks = irreducible_k(a.L)
94
+ idx = range(len(ks)) if a.sectors == "all" else [int(x) for x in a.sectors.split(",")]
95
+ tag = f"L{a.L}_Ne{a.Ne}_U{a.U:g}"
96
+ for i in idx:
97
+ kv, mult = ks[i]
98
+ t0 = time.time()
99
+ S = Sector(a.L, a.Ne // 2, a.Ne // 2, a.U, kv)
100
+ G = GPUSector(S)
101
+ tb = time.time() - t0
102
+ if a.bench:
103
+ v = np.random.default_rng(0).normal(size=S.nR * S.dd) + 0j
104
+ v = (S.symm(v.reshape(S.nR, S.dd) / S.sqS[:, None]) * S.sqS[:, None]).ravel()
105
+ t1 = time.time(); c = S.matvec(v); tc = time.time() - t1
106
+ G.matvec(v); torch.cuda.synchronize()
107
+ t1 = time.time()
108
+ for _ in range(5):
109
+ g = G.matvec(v)
110
+ torch.cuda.synchronize(); tg = (time.time() - t1) / 5
111
+ print(f"k={kv} dim={S.nR*S.dd} build={tb:.0f}s CPU matvec {tc:.2f}s GPU matvec {tg:.3f}s "
112
+ f"max|diff|={np.abs(c-g).max():.2e}", flush=True)
113
+ continue
114
+ w, V = G.solve(k=a.k, ncv=a.ncv)
115
+ low = [j for j, e in enumerate(w) if abs(e - w[0]) < a.degen_tol * abs(w[0])]
116
+ np.savez(f"{a.save}/{tag}_k{kv[0]}{kv[1]}.npz", k=np.array(kv), mult=mult, E=w, V=V[:, low])
117
+ print(f"k={kv} x{mult} dim={S.nR*S.dd} nlow={len(low)} E={np.round(w,8).tolist()} "
118
+ f"({time.time()-t0:.0f}s, GPU)", flush=True)
119
+ if len(low) == len(w):
120
+ print(f"[warn] k={kv}: all {len(low)} eigenpairs degenerate; raise --k", flush=True)
121
+ del G, S, V
122
+ torch.cuda.empty_cache()
123
+
124
+
125
+ if __name__ == "__main__":
126
+ main()
methods/Yuseon84/code/pd_free.py ADDED
@@ -0,0 +1,45 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Free-fermion d-wave pair correlation on LxL periodic square lattice (Wick), to pin OSC normalization.
2
+ import numpy as np, itertools
3
+ def lattice(L):
4
+ N=L*L; idx=lambda x,y:(x%L)*L+(y%L); return N,idx
5
+ def orbitals(L):
6
+ ks=[(2*np.pi*a/L,2*np.pi*b/L) for a in range(L) for b in range(L)]
7
+ e=np.array([-2*(np.cos(kx)+np.cos(ky)) for kx,ky in ks])
8
+ return ks,e
9
+ def G_from(occ,L):
10
+ N,idx=lattice(L); ks,_=orbitals(L)
11
+ r=np.array([(x,y) for x in range(L) for y in range(L)])
12
+ phi=np.array([[np.exp(1j*(k[0]*x+k[1]*y))/np.sqrt(N) for (x,y) in r] for k in ks]) # [k,site]
13
+ P=phi[list(occ)]
14
+ return (P.conj().T@P) # G[a,b]=<c†_a c_b> = sum_k phi*_k(a) phi_k(b)
15
+ def Pd(Gu,Gd,L,R):
16
+ N,idx=lattice(L)
17
+ nb=[((1,0),1),((-1,0),1),((0,1),-1),((0,-1),-1)]
18
+ tot=0
19
+ for x in range(L):
20
+ for y in range(L):
21
+ i=idx(x,y); j=idx(x+R[0],y+R[1])
22
+ for (d,g) in nb:
23
+ for (dp,gp) in nb:
24
+ a=idx(x+d[0],y+d[1]); b=idx(x+R[0]+dp[0],y+R[1]+dp[1])
25
+ # singlet D_i = (1/sqrt2) sum_d g (c_i↑ c_{i+d}↓ - c_i↓ c_{i+d}↑)
26
+ # <D†_j D_i> = 1/2 sum g g' [Gu(j,i)Gd(b,a)+Gd(j,i)Gu(b,a)+Gu(b,a)Gd(j,i)... cross terms]
27
+ t = (Gu[j,i]*Gd[b,a] + Gu[b,a]*Gd[j,i] + Gu[j,a]*Gd[b,i] + Gu[b,i]*Gd[j,a])
28
+ tot += g*gp*t/2
29
+ return (tot/N).real
30
+ def shells(L):
31
+ ks,e=orbitals(L); order=np.argsort(e,kind='stable'); return e,order
32
+ def avg_Pd(L,Ne,R):
33
+ e,order=shells(L); n=Ne//2
34
+ es=np.round(e,8); levels=sorted(set(es))
35
+ full=[k for k in range(L*L) if es[k]<sorted(es)[n-1]]
36
+ top=[k for k in range(L*L) if es[k]==sorted(es)[n-1]]
37
+ m=n-len(full); combos=list(itertools.combinations(top,m))
38
+ vals=[]
39
+ for cu in combos:
40
+ Gu=G_from(full+list(cu),L)
41
+ for cd in combos:
42
+ Gd=G_from(full+list(cd),L); vals.append(Pd(Gu,Gd,L,R))
43
+ return np.mean(vals),len(combos)**2
44
+ for Ne,ref in [(8,0.046875),(10,0.09375),(12,0.041667),(14,0.010417),(16,0.0)]:
45
+ v,nd=avg_Pd(4,Ne,(2,2)); print(f"4x4 Ne={Ne:2d} n={Ne/16:.3f} P_free={v:.6f} ED_U0(org)={ref} ratio={ref/v if abs(v)>1e-12 else float('nan'):.4f} (#degenerate={nd})")
methods/Yuseon84/code/pd_free66.py ADDED
@@ -0,0 +1,20 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import numpy as np, json
2
+ import os, sys
3
+ HERE = os.path.dirname(os.path.abspath(__file__))
4
+ exec(open(os.path.join(HERE, 'pd_free.py'), encoding='utf-8').read().split('for Ne,ref in')[0])
5
+ def avgG(L,n):
6
+ ks,e=orbitals(L); es=np.round(e,8); s=sorted(es); ef=s[n-1]
7
+ full=[k for k in range(L*L) if es[k]<ef]; top=[k for k in range(L*L) if es[k]==ef]
8
+ m=n-len(full)
9
+ return G_from(full,L)+(m/len(top))*G_from(top,L) if top else G_from(full,L), len(top), m
10
+ def Pd_avg(L,Ne,R):
11
+ G,d,m=avgG(L,Ne//2); return 0.5*Pd(G,G,L,R), d, m # 0.5 = OSC convention
12
+ # sanity: 4x4 must reproduce ED U=0
13
+ print("4x4 check:",[round(Pd_avg(4,Ne,(2,2))[0],6) for Ne in (8,10,12,14,16)])
14
+ # usage: python pd_free66.py [path/to/scoring_meta.json] (file from the OSC dataset)
15
+ meta=json.load(open(sys.argv[1] if len(sys.argv) > 1 else 'scoring_meta.json'))['A_by_Ne']
16
+ print(" Ne delta A_d(VMC,U=8) P_free(U=0) ratio shell")
17
+ for Ne in sorted(meta,key=int,reverse=True):
18
+ delta,Ad=meta[Ne]; Ne=int(Ne)
19
+ p,d,m=Pd_avg(6,Ne,(3,3))
20
+ print(f"{Ne:3d} {delta:6.4f} {Ad:9.5f} {p:9.5f} {Ad/p if abs(p)>1e-9 else float('nan'):6.2f} {m}/{d}")
methods/Yuseon84/code/vmc_dwave.py ADDED
@@ -0,0 +1,353 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """VMC for the 2D Hubbard model with a Jastrow-Gutzwiller x projected d-wave BCS (AGP) wavefunction.
3
+
4
+ Psi(x) = J(x) det M(x), M[i,j] = phi(r_i^up - r_j^dn)
5
+ phi(r) = (1/N) sum_k a_k cos(k.r), a_k = D_k / (xi_k + E_k)
6
+ D_k = Delta (cos kx - cos ky), xi_k = -2(cos kx + cos ky) - mu, E_k = sqrt(xi^2 + D_k^2)
7
+ log J = -g * D + sum_{i<j} v_c(ij) n_i n_j (D = double occupancy, c = distance class)
8
+
9
+ Labeled-electron first quantization: an in-place hop has matrix element -t with no extra sign.
10
+ P_d uses the OSC normalization (1/2 x standard singlet), see pd_free.py.
11
+ See PHASE2_VMC_DESIGN.md for the validation ladder.
12
+ """
13
+ import argparse, json, time
14
+ import numpy as np
15
+
16
+ EPS_DK = 1e-6
17
+
18
+
19
+ class Lattice:
20
+ def __init__(self, L):
21
+ self.L, self.N = L, L * L
22
+ self.xy = np.array([(s // L, s % L) for s in range(self.N)])
23
+ self.nb = np.array([[((x + dx) % L) * L + (y + dy) % L for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1))]
24
+ for x, y in self.xy])
25
+ d = (self.xy[:, None, :] - self.xy[None, :, :]) % L # displacement table
26
+ self.dx, self.dy = d[..., 0], d[..., 1]
27
+ m = np.minimum(d, L - d)
28
+ cls = np.sort(m, axis=-1)
29
+ keys = sorted({tuple(c) for c in cls.reshape(-1, 2)} - {(0, 0)})
30
+ self.classes = keys
31
+ self.cls = np.full((self.N, self.N), -1)
32
+ for ci, kk in enumerate(keys):
33
+ self.cls[(cls[..., 0] == kk[0]) & (cls[..., 1] == kk[1])] = ci
34
+ self.site = lambda x, y: (x % L) * L + (y % L)
35
+
36
+
37
+ def phi_table(L, Delta, mu):
38
+ ks = 2 * np.pi * np.arange(L) / L
39
+ KX, KY = np.meshgrid(ks, ks, indexing="ij")
40
+ xi = -2 * (np.cos(KX) + np.cos(KY)) - mu
41
+ f = np.cos(KX) - np.cos(KY)
42
+ if abs(Delta) < 1e-12: # Fermi-sea limit (projected)
43
+ a = np.where(xi < -1e-9, 1.0, np.where(xi > 1e-9, 1e-8, 0.5))
44
+ else:
45
+ # nodal k (f=0): u_k=0 would make a_k infinite and M ill-conditioned; use half of the
46
+ # smallest non-zero lattice gap there instead (the orbital is still effectively filled).
47
+ fmin = np.min(np.abs(f[np.abs(f) > EPS_DK]))
48
+ Dk = Delta * np.where(np.abs(f) > EPS_DK, f, 0.5 * fmin)
49
+ a = Dk / (xi + np.sqrt(xi ** 2 + Dk ** 2))
50
+ a = a / np.max(np.abs(a))
51
+ X = np.arange(L)
52
+ # phi[dx,dy] = (1/N) sum_k a_k cos(kx dx + ky dy)
53
+ ph = np.einsum("ab,xa,yb->xy", a, np.cos(np.outer(X, ks)), np.cos(np.outer(X, ks))) \
54
+ - np.einsum("ab,xa,yb->xy", a, np.sin(np.outer(X, ks)), np.sin(np.outer(X, ks)))
55
+ return ph / (L * L)
56
+
57
+
58
+ class Walker:
59
+ def __init__(self, lat, n, par, rng, U):
60
+ self.lat, self.n, self.rng, self.U = lat, n, rng, U
61
+ self.set_params(par)
62
+ N = lat.N
63
+ while True:
64
+ self.up = rng.choice(N, n, replace=False)
65
+ self.dn = rng.choice(N, n, replace=False)
66
+ self.refresh()
67
+ if np.isfinite(self.Minv).all() and abs(np.linalg.det(self.M)) > 1e-300:
68
+ break
69
+
70
+ def set_params(self, par):
71
+ self.par = dict(par)
72
+ L = self.lat.L
73
+ self.phi = phi_table(L, par["Delta"], par["mu"])
74
+ v = np.asarray(par.get("v", np.zeros(len(self.lat.classes))))
75
+ self.V = np.where(self.lat.cls >= 0, v[np.maximum(self.lat.cls, 0)], 0.0)
76
+ self.g = par.get("g", 0.0)
77
+
78
+ def Mmat(self, up, dn):
79
+ lat = self.lat
80
+ return self.phi[lat.dx[np.ix_(up, dn)], lat.dy[np.ix_(up, dn)]]
81
+
82
+ def refresh(self):
83
+ N = self.lat.N
84
+ self.M = self.Mmat(self.up, self.dn)
85
+ self.Minv = np.linalg.inv(self.M)
86
+ self.nu = np.zeros(N); self.nu[self.up] = 1
87
+ self.nd = np.zeros(N); self.nd[self.dn] = 1
88
+ self.h = self.V @ (self.nu + self.nd)
89
+
90
+ # ---------- single moves ----------
91
+ def jas_ratio_log(self, a, b, spin):
92
+ other = self.nd if spin == 0 else self.nu
93
+ dD = other[b] - other[a]
94
+ return -self.g * dD + (self.h[b] - self.h[a] - self.V[a, b])
95
+
96
+ def step(self):
97
+ lat, n = self.lat, self.n
98
+ spin = self.rng.integers(2)
99
+ e = self.rng.integers(n)
100
+ if spin == 0:
101
+ a = self.up[e]; b = lat.nb[a, self.rng.integers(4)]
102
+ if self.nu[b]:
103
+ return False
104
+ row = self.phi[lat.dx[b, self.dn], lat.dy[b, self.dn]]
105
+ w = row @ self.Minv
106
+ q = w[e]
107
+ else:
108
+ a = self.dn[e]; b = lat.nb[a, self.rng.integers(4)]
109
+ if self.nd[b]:
110
+ return False
111
+ col = self.phi[lat.dx[self.up, b], lat.dy[self.up, b]]
112
+ z = self.Minv @ col
113
+ q = z[e]
114
+ r = q * np.exp(self.jas_ratio_log(a, b, spin))
115
+ if self.rng.random() >= r * r:
116
+ return False
117
+ if spin == 0:
118
+ w[e] -= 1.0
119
+ self.Minv -= np.outer(self.Minv[:, e], w) / q
120
+ self.M[e, :] = row
121
+ self.up[e] = b; self.nu[a] = 0; self.nu[b] = 1
122
+ else:
123
+ z[e] -= 1.0
124
+ self.Minv -= np.outer(z, self.Minv[e, :]) / q
125
+ self.M[:, e] = col
126
+ self.dn[e] = b; self.nd[a] = 0; self.nd[b] = 1
127
+ self.h += self.V[:, b] - self.V[:, a]
128
+ return True
129
+
130
+ def sweep(self, nsteps=None):
131
+ acc = 0
132
+ for _ in range(nsteps or 2 * self.n):
133
+ acc += self.step()
134
+ return acc
135
+
136
+ # ---------- estimators ----------
137
+ def local_energy(self):
138
+ lat = self.lat
139
+ D = float(self.nu @ self.nd)
140
+ kin = 0.0
141
+ # up hops: rows for all (alpha, neighbour)
142
+ tgt = lat.nb[self.up] # (n,4)
143
+ rows = self.phi[lat.dx[tgt[..., None], self.dn[None, None, :]],
144
+ lat.dy[tgt[..., None], self.dn[None, None, :]]] # (n,4,n)
145
+ q = np.einsum("anj,ja->an", rows, self.Minv)
146
+ src = np.repeat(self.up[:, None], 4, 1)
147
+ jl = -self.g * (self.nd[tgt] - self.nd[src]) + (self.h[tgt] - self.h[src] - self.V[src, tgt])
148
+ kin += np.sum(np.where(self.nu[tgt] == 0, q * np.exp(jl), 0.0))
149
+ tgt = lat.nb[self.dn]
150
+ cols = self.phi[lat.dx[self.up[None, None, :], tgt[..., None]],
151
+ lat.dy[self.up[None, None, :], tgt[..., None]]] # (n,4,n) [beta,nb,i]
152
+ q = np.einsum("bi,bni->bn", self.Minv, cols)
153
+ src = np.repeat(self.dn[:, None], 4, 1)
154
+ jl = -self.g * (self.nu[tgt] - self.nu[src]) + (self.h[tgt] - self.h[src] - self.V[src, tgt])
155
+ kin += np.sum(np.where(self.nd[tgt] == 0, q * np.exp(jl), 0.0))
156
+ return self.U * D - kin
157
+
158
+ def pair_terms(self, R):
159
+ """Precompute (coef, p, p2, q, q2) for (1/N) sum_i <D+_{i+R} D_i>: move up p->p2, down q->q2."""
160
+ lat = self.lat
161
+ NB = [((1, 0), 1.0), ((-1, 0), 1.0), ((0, 1), -1.0), ((0, -1), -1.0)]
162
+ T = []
163
+ for (x, y) in lat.xy:
164
+ i = lat.site(x, y); j = lat.site(x + R[0], y + R[1])
165
+ for d, g in NB:
166
+ di = lat.site(x + d[0], y + d[1])
167
+ for dp, gp in NB:
168
+ dj = lat.site(x + R[0] + dp[0], y + R[1] + dp[1])
169
+ for (p, q) in ((i, di), (di, i)):
170
+ for (p2, q2) in ((j, dj), (dj, j)):
171
+ T.append((g * gp, p, p2, q, q2))
172
+ T = np.array(T)
173
+ return T[:, 0], T[:, 1:].astype(int)
174
+
175
+ def pair_corr(self, coef, idx):
176
+ """OSC-normalized P_d(R) single-sample estimator (real part)."""
177
+ lat = self.lat
178
+ p, p2, q, q2 = idx.T
179
+ ok = (self.nu[p] == 1) & (self.nd[q] == 1) & (self.nu[p2] == 0) & (self.nd[q2] == 0)
180
+ if not ok.any():
181
+ return 0.0
182
+ c, p, p2, q, q2 = coef[ok], p[ok], p2[ok], q[ok], q2[ok]
183
+ eu = np.full(lat.N, -1); eu[self.up] = np.arange(self.n)
184
+ ed = np.full(lat.N, -1); ed[self.dn] = np.arange(self.n)
185
+ al, be = eu[p], ed[q]
186
+ # new row alpha (with the down electron beta already at q2), new column beta (up alpha at p2)
187
+ dn_new = np.repeat(self.dn[None, :], len(c), 0); dn_new[np.arange(len(c)), be] = q2
188
+ up_new = np.repeat(self.up[None, :], len(c), 0); up_new[np.arange(len(c)), al] = p2
189
+ Rn = self.phi[lat.dx[p2[:, None], dn_new], lat.dy[p2[:, None], dn_new]] # (T,n)
190
+ Cn = self.phi[lat.dx[up_new, q2[:, None]], lat.dy[up_new, q2[:, None]]] # (T,n)
191
+ a = Rn - self.M[al] # row change
192
+ b = Cn - self.M[:, be].T
193
+ b[np.arange(len(c)), al] = 0.0 # (al,be) set by row
194
+ Mi = self.Minv
195
+ x11 = np.einsum("tj,jt->t", a, Mi[:, al])
196
+ x22 = np.einsum("ti,ti->t", Mi[be], b)
197
+ x21 = Mi[be, al]
198
+ x12 = np.einsum("tj,jk,tk->t", a, Mi, b)
199
+ det_r = (1 + x11) * (1 + x22) - x12 * x21
200
+ # Jastrow: up p->p2 then down q->q2
201
+ V, h, g = self.V, self.h, self.g
202
+ j1 = -g * (self.nd[p2] - self.nd[p]) + (h[p2] - h[p] - V[p, p2])
203
+ nu2_q2 = self.nu[q2] - (q2 == p) + (q2 == p2)
204
+ nu2_q = self.nu[q] - (q == p) + (q == p2)
205
+ h2q2 = h[q2] - V[q2, p] + V[q2, p2]
206
+ h2q = h[q] - V[q, p] + V[q, p2]
207
+ j2 = -g * (nu2_q2 - nu2_q) + (h2q2 - h2q - V[q, q2])
208
+ val = np.sum(c * det_r * np.exp(j1 + j2))
209
+ return 0.25 * val / lat.N # 1/2 (sqrt2^2) x 1/2 (OSC normalization)
210
+
211
+
212
+ def unpack(theta, keys, base, nv):
213
+ par = dict(base); par["v"] = np.array(base.get("v", np.zeros(nv)), dtype=float)
214
+ for kname, val in zip(keys, theta):
215
+ if kname.startswith("v"):
216
+ par["v"][int(kname[1:])] = val
217
+ else:
218
+ par[kname] = val
219
+ return par
220
+
221
+
222
+ def log_derivs(w, keys, dphi):
223
+ """O_k = d log Psi / d theta_k for the current configuration."""
224
+ lat = w.lat
225
+ n = w.nu + w.nd
226
+ out = []
227
+ for kname in keys:
228
+ if kname == "g":
229
+ out.append(-float(w.nu @ w.nd))
230
+ elif kname.startswith("v"):
231
+ c = int(kname[1:])
232
+ out.append(0.5 * float(n @ (lat.cls == c) @ n))
233
+ else:
234
+ dM = dphi[kname][lat.dx[np.ix_(w.up, w.dn)], lat.dy[np.ix_(w.up, w.dn)]]
235
+ out.append(float(np.sum(w.Minv.T * dM)))
236
+ return np.array(out)
237
+
238
+
239
+ def optimize(L, Ne, U, par0, keys, n_iter=150, nsamp=1500, ntherm=150, lr=0.05, seed=0, log=None,
240
+ eps_rel=0.05, eps_abs=1e-3):
241
+ """Stochastic reconfiguration on the parameters named in `keys` (Delta, mu, g, v0..)."""
242
+ lat = Lattice(L)
243
+ nv = len(lat.classes)
244
+ rng = np.random.default_rng(seed)
245
+ theta = np.array([unpack([], [], par0, nv)[k] if not k.startswith("v")
246
+ else np.asarray(par0.get("v", np.zeros(nv)))[int(k[1:])] for k in keys], float)
247
+ w = Walker(lat, Ne // 2, unpack(theta, keys, par0, nv), rng, U)
248
+ for s in range(ntherm):
249
+ w.sweep()
250
+ hist = []
251
+ for it in range(n_iter):
252
+ par = unpack(theta, keys, par0, nv)
253
+ w.set_params(par); w.refresh()
254
+ h = 1e-5
255
+ dphi = {}
256
+ for kname in keys:
257
+ if kname in ("Delta", "mu"):
258
+ pp, pm = dict(par), dict(par); pp[kname] += h; pm[kname] -= h
259
+ dphi[kname] = (phi_table(L, pp["Delta"], pp["mu"]) - phi_table(L, pm["Delta"], pm["mu"])) / (2 * h)
260
+ for s in range(20):
261
+ w.sweep()
262
+ Es, Os = [], []
263
+ for s in range(nsamp):
264
+ w.sweep()
265
+ if s % 20 == 0:
266
+ w.refresh()
267
+ Es.append(w.local_energy()); Os.append(log_derivs(w, keys, dphi))
268
+ E, O = np.array(Es), np.array(Os)
269
+ Om = O.mean(0)
270
+ S = (O - Om).T @ (O - Om) / len(E)
271
+ F = ((E - E.mean())[:, None] * (O - Om)).mean(0)
272
+ S += np.diag(eps_rel * np.diag(S) + eps_abs)
273
+ dth = -lr * np.linalg.solve(S, F)
274
+ theta = theta + dth
275
+ if "Delta" in keys: # +Delta and -Delta give the same state (global sign)
276
+ i = keys.index("Delta"); theta[i] = abs(theta[i])
277
+ rec = dict(it=it, E=float(E.mean()), dE=float(E.std() / np.sqrt(len(E))),
278
+ theta=[round(float(x), 5) for x in theta])
279
+ hist.append(rec)
280
+ if log:
281
+ print(json.dumps(rec), file=log, flush=True)
282
+ tail = np.array([r["theta"] for r in hist[2 * n_iter // 3:]])
283
+ theta_avg = tail.mean(0)
284
+ return unpack(theta_avg, keys, par0, nv), hist
285
+
286
+
287
+ def run(L, Ne, U, par, nsamp, nthermal, seed, R=None, every=1):
288
+ lat = Lattice(L)
289
+ rng = np.random.default_rng(seed)
290
+ w = Walker(lat, Ne // 2, par, rng, U)
291
+ for s in range(nthermal):
292
+ w.sweep()
293
+ if s % 20 == 0:
294
+ w.refresh()
295
+ R = R or (L // 2, L // 2)
296
+ coef, idx = w.pair_terms(R)
297
+ E, P = [], []
298
+ acc = 0
299
+ for s in range(nsamp):
300
+ acc += w.sweep()
301
+ if s % 20 == 0:
302
+ w.refresh()
303
+ E.append(w.local_energy())
304
+ if s % every == 0:
305
+ P.append(w.pair_corr(coef, idx))
306
+ E, P = np.array(E), np.array(P)
307
+
308
+ def err(x, nb=20):
309
+ b = x[: len(x) // nb * nb].reshape(nb, -1).mean(1)
310
+ return b.std(ddof=1) / np.sqrt(nb)
311
+ return dict(E=E.mean(), dE=err(E), varE=E.var(), Pd=P.mean(), dPd=err(P),
312
+ acc=acc / (nsamp * 2 * (Ne // 2)))
313
+
314
+
315
+ def main():
316
+ ap = argparse.ArgumentParser()
317
+ ap.add_argument("--L", type=int, default=6)
318
+ ap.add_argument("--Ne", type=int, default=26)
319
+ ap.add_argument("--U", type=float, default=8.0)
320
+ ap.add_argument("--Delta", type=float, default=0.15)
321
+ ap.add_argument("--mu", type=float, default=0.0)
322
+ ap.add_argument("--g", type=float, default=0.0)
323
+ ap.add_argument("--nsamp", type=int, default=2000)
324
+ ap.add_argument("--ntherm", type=int, default=200)
325
+ ap.add_argument("--seed", type=int, default=0)
326
+ ap.add_argument("--opt", default="", help="comma list of params to optimize, e.g. Delta,mu,g,jas")
327
+ ap.add_argument("--iters", type=int, default=150)
328
+ ap.add_argument("--nsamp_opt", type=int, default=1500)
329
+ ap.add_argument("--lr", type=float, default=0.1)
330
+ ap.add_argument("--out", default="")
331
+ a = ap.parse_args()
332
+ t0 = time.time()
333
+ par = dict(Delta=a.Delta, mu=a.mu, g=a.g)
334
+ hist = []
335
+ if a.opt:
336
+ nv = len(Lattice(a.L).classes)
337
+ keys = []
338
+ for kname in a.opt.split(","):
339
+ keys += [f"v{c}" for c in range(nv)] if kname == "jas" else [kname]
340
+ log = open(a.out.replace(".json", ".opt.log"), "w") if a.out else None
341
+ par, hist = optimize(a.L, a.Ne, a.U, par, keys, a.iters, a.nsamp_opt, a.ntherm, a.lr, a.seed, log)
342
+ r = run(a.L, a.Ne, a.U, par, a.nsamp, a.ntherm, a.seed + 1000)
343
+ r = {k: float(v) for k, v in r.items()}
344
+ r.update(L=a.L, Ne=a.Ne, U=a.U, opt=a.opt,
345
+ par={k: (np.round(v, 5).tolist() if isinstance(v, np.ndarray) else round(float(v), 5)) for k, v in par.items()},
346
+ sec=round(time.time() - t0, 1))
347
+ print(json.dumps(r))
348
+ if a.out:
349
+ json.dump(dict(result=r, hist=hist), open(a.out, "w"), indent=1)
350
+
351
+
352
+ if __name__ == "__main__":
353
+ main()
methods/Yuseon84/code/vmc_gpu.py ADDED
@@ -0,0 +1,324 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Batched-walker GPU (torch/CUDA) version of vmc_dwave.py — same wavefunction, estimators and
3
+ output format, with B independent Markov chains advanced in lock-step.
4
+
5
+ A sweep = n up-electron moves then n down-electron moves (random electron, random neighbour),
6
+ each a symmetric proposal accepted with |Psi'/Psi|^2. Error bars come from per-walker means
7
+ (walkers are independent), so no blocking is needed.
8
+ """
9
+ import argparse, json, time
10
+ import numpy as np
11
+ import torch
12
+ from vmc_dwave import Lattice, phi_table
13
+
14
+ DEV = torch.device("cuda")
15
+ DT = torch.float64
16
+
17
+
18
+ class BatchVMC:
19
+ def __init__(self, L, Ne, U, par, B, seed):
20
+ self.lat = Lattice(L)
21
+ self.L, self.N, self.n, self.U, self.B = L, L * L, Ne // 2, U, B
22
+ self.gen = torch.Generator(device=DEV); self.gen.manual_seed(seed)
23
+ lat = self.lat
24
+ self.nb = torch.tensor(lat.nb, device=DEV)
25
+ self.cls = torch.tensor(lat.cls, device=DEV)
26
+ C = len(lat.classes)
27
+ self.Cmat = torch.stack([(self.cls == c).to(DT) for c in range(C)]) # (C,N,N)
28
+ self.ar = torch.arange(B, device=DEV)
29
+ self.set_params(par)
30
+ self.init_walkers()
31
+
32
+ # ---------------- parameters ----------------
33
+ def phi_sites(self, Delta, mu):
34
+ ph = torch.tensor(phi_table(self.L, Delta, mu), dtype=DT, device=DEV)
35
+ dx = torch.tensor(self.lat.dx, device=DEV); dy = torch.tensor(self.lat.dy, device=DEV)
36
+ return ph[dx, dy] # (N,N): phi(r_a - r_b)
37
+
38
+ def set_params(self, par):
39
+ self.par = dict(par)
40
+ self.PHI = self.phi_sites(par["Delta"], par["mu"])
41
+ v = torch.tensor(np.asarray(par.get("v", np.zeros(len(self.lat.classes)))), dtype=DT, device=DEV)
42
+ self.V = torch.where(self.cls >= 0, v[self.cls.clamp(min=0)], torch.zeros((), dtype=DT, device=DEV))
43
+ self.g = float(par.get("g", 0.0))
44
+
45
+ # ---------------- walkers ----------------
46
+ def rand_conf(self, m):
47
+ k = torch.rand(m, self.N, generator=self.gen, device=DEV).argsort(1)[:, : self.n]
48
+ return k
49
+
50
+ def init_walkers(self):
51
+ B = self.B
52
+ self.up = self.rand_conf(B); self.dn = self.rand_conf(B)
53
+ for _ in range(50):
54
+ self.refresh()
55
+ bad = ~torch.isfinite(self.Minv).all(-1).all(-1) | (torch.linalg.det(self.M).abs() < 1e-200)
56
+ if not bad.any():
57
+ break
58
+ nb_ = int(bad.sum())
59
+ self.up[bad] = self.rand_conf(nb_); self.dn[bad] = self.rand_conf(nb_)
60
+ self.refresh()
61
+
62
+ def refresh(self):
63
+ B, N = self.B, self.N
64
+ self.M = self.PHI[self.up[:, :, None], self.dn[:, None, :]]
65
+ self.Minv, info = torch.linalg.inv_ex(self.M)
66
+ bad = (info != 0) | ~torch.isfinite(self.Minv).all(-1).all(-1)
67
+ if bad.any() and not bad.all():
68
+ # walkers sitting on a node of the (new) wavefunction have zero weight: replace each by
69
+ # a copy of a random healthy walker
70
+ good = torch.nonzero(~bad).squeeze(1)
71
+ src = good[torch.randint(0, len(good), (int(bad.sum()),), generator=self.gen, device=DEV)]
72
+ self.up[bad] = self.up[src]; self.dn[bad] = self.dn[src]
73
+ self.M = self.PHI[self.up[:, :, None], self.dn[:, None, :]]
74
+ self.Minv, info = torch.linalg.inv_ex(self.M)
75
+ self.nu = torch.zeros(B, N, dtype=DT, device=DEV); self.nu.scatter_(1, self.up, 1.0)
76
+ self.nd = torch.zeros(B, N, dtype=DT, device=DEV); self.nd.scatter_(1, self.dn, 1.0)
77
+ self.h = (self.nu + self.nd) @ self.V
78
+
79
+ def _rand(self, hi):
80
+ return torch.randint(0, hi, (self.B,), generator=self.gen, device=DEV)
81
+
82
+ def step(self, spin):
83
+ ar, n = self.ar, self.n
84
+ e = self._rand(n); d = self._rand(4)
85
+ pos, same, other = (self.up, self.nu, self.nd) if spin == 0 else (self.dn, self.nd, self.nu)
86
+ a = pos[ar, e]; t = self.nb[a, d]
87
+ blocked = same[ar, t] > 0.5
88
+ if spin == 0:
89
+ vec = self.PHI[t[:, None], self.dn] # new row
90
+ w = torch.einsum("bj,bjk->bk", vec, self.Minv)
91
+ else:
92
+ vec = self.PHI[self.up, t[:, None]] # new column
93
+ w = torch.einsum("bij,bj->bi", self.Minv, vec)
94
+ q = w[ar, e]
95
+ dJ = -self.g * (other[ar, t] - other[ar, a]) + self.h[ar, t] - self.h[ar, a] - self.V[a, t]
96
+ r = q * torch.exp(dJ)
97
+ acc = (torch.rand(self.B, generator=self.gen, device=DEV, dtype=DT) < r * r) & ~blocked
98
+ idx = torch.nonzero(acc).squeeze(1)
99
+ if idx.numel() == 0:
100
+ return 0
101
+ ei, wi, qi = e[idx], w[idx].clone(), q[idx]
102
+ wi[torch.arange(len(idx), device=DEV), ei] -= 1.0
103
+ if spin == 0:
104
+ self.Minv[idx] -= self.Minv[idx, :, ei][:, :, None] * wi[:, None, :] / qi[:, None, None]
105
+ self.M[idx, ei, :] = vec[idx]
106
+ self.up[idx, ei] = t[idx]
107
+ self.nu[idx, a[idx]] = 0.0; self.nu[idx, t[idx]] = 1.0
108
+ else:
109
+ self.Minv[idx] -= wi[:, :, None] * self.Minv[idx, ei, :][:, None, :] / qi[:, None, None]
110
+ self.M[idx, :, ei] = vec[idx]
111
+ self.dn[idx, ei] = t[idx]
112
+ self.nd[idx, a[idx]] = 0.0; self.nd[idx, t[idx]] = 1.0
113
+ self.h[idx] += self.V[t[idx]] - self.V[a[idx]]
114
+ return len(idx)
115
+
116
+ def sweep(self):
117
+ acc = 0
118
+ for spin in (0, 1):
119
+ for _ in range(self.n):
120
+ acc += self.step(spin)
121
+ return acc / (2 * self.n * self.B)
122
+
123
+ # ---------------- estimators ----------------
124
+ def local_energy(self):
125
+ nu, nd, h, V, g, Mi, P = self.nu, self.nd, self.h, self.V, self.g, self.Minv, self.PHI
126
+ bi = self.ar[:, None, None]
127
+ D = (nu * nd).sum(1)
128
+ tgt = self.nb[self.up] # (B,n,4)
129
+ rows = P[tgt[..., None], self.dn[:, None, None, :]] # (B,n,4,n)
130
+ q = torch.einsum("banj,bja->ban", rows, Mi)
131
+ src = self.up[:, :, None].expand_as(tgt)
132
+ jl = -g * (nd[bi, tgt] - nd[bi, src]) + h[bi, tgt] - h[bi, src] - V[src, tgt]
133
+ kin = torch.where(nu[bi, tgt] < 0.5, q * torch.exp(jl), torch.zeros_like(q)).sum((1, 2))
134
+ tgt = self.nb[self.dn]
135
+ cols = P[self.up[:, None, None, :], tgt[..., None]] # (B,n,4,n) [b,beta,k,i]
136
+ q = torch.einsum("bmi,bmki->bmk", Mi, cols)
137
+ src = self.dn[:, :, None].expand_as(tgt)
138
+ jl = -g * (nu[bi, tgt] - nu[bi, src]) + h[bi, tgt] - h[bi, src] - V[src, tgt]
139
+ kin = kin + torch.where(nd[bi, tgt] < 0.5, q * torch.exp(jl), torch.zeros_like(q)).sum((1, 2))
140
+ return self.U * D - kin
141
+
142
+ def pair_terms(self, R):
143
+ lat = self.lat
144
+ NB = [((1, 0), 1.0), ((-1, 0), 1.0), ((0, 1), -1.0), ((0, -1), -1.0)]
145
+ T = []
146
+ for (x, y) in lat.xy:
147
+ i = lat.site(x, y); j = lat.site(x + R[0], y + R[1])
148
+ for d, g in NB:
149
+ di = lat.site(x + d[0], y + d[1])
150
+ for dp, gp in NB:
151
+ dj = lat.site(x + R[0] + dp[0], y + R[1] + dp[1])
152
+ for (p, q) in ((i, di), (di, i)):
153
+ for (p2, q2) in ((j, dj), (dj, j)):
154
+ T.append((g * gp, p, p2, q, q2))
155
+ T = np.array(T)
156
+ self.pc = torch.tensor(T[:, 0], dtype=DT, device=DEV)
157
+ self.pidx = torch.tensor(T[:, 1:].astype(np.int64), device=DEV)
158
+
159
+ def pair_corr(self, chunk=128):
160
+ """OSC-normalized P_d(R) per walker, shape (B,)."""
161
+ out = torch.zeros(self.B, dtype=DT, device=DEV)
162
+ p, p2, q, q2 = self.pidx.T
163
+ n, T = self.n, len(self.pc)
164
+ ar_n = torch.arange(n, device=DEV)
165
+ for s in range(0, self.B, chunk):
166
+ sl = slice(s, min(s + chunk, self.B)); b = sl.stop - sl.start
167
+ nu, nd, up, dn = self.nu[sl], self.nd[sl], self.up[sl], self.dn[sl]
168
+ M, Mi, h = self.M[sl], self.Minv[sl], self.h[sl]
169
+ ok = (nu[:, p] > 0.5) & (nd[:, q] > 0.5) & (nu[:, p2] < 0.5) & (nd[:, q2] < 0.5) # (b,T)
170
+ eu = torch.full((b, self.N), 0, dtype=torch.long, device=DEV); eu.scatter_(1, up, ar_n.expand(b, n))
171
+ ed = torch.full((b, self.N), 0, dtype=torch.long, device=DEV); ed.scatter_(1, dn, ar_n.expand(b, n))
172
+ al, be = eu[:, p], ed[:, q] # (b,T)
173
+ dn_new = torch.where(ar_n[None, None, :] == be[..., None], q2[None, :, None], dn[:, None, :])
174
+ up_new = torch.where(ar_n[None, None, :] == al[..., None], p2[None, :, None], up[:, None, :])
175
+ Rn = self.PHI[p2[None, :, None], dn_new] # (b,T,n)
176
+ Cn = self.PHI[up_new, q2[None, :, None]]
177
+ a = Rn - torch.gather(M, 1, al[..., None].expand(-1, -1, n))
178
+ bv = Cn - torch.gather(M.transpose(1, 2), 1, be[..., None].expand(-1, -1, n))
179
+ bv = bv.scatter(2, al[..., None], 0.0)
180
+ col_al = torch.gather(Mi.transpose(1, 2), 1, al[..., None].expand(-1, -1, n)) # Minv[:,al]
181
+ row_be = torch.gather(Mi, 1, be[..., None].expand(-1, -1, n)) # Minv[be,:]
182
+ x11 = (a * col_al).sum(-1)
183
+ x22 = (row_be * bv).sum(-1)
184
+ x21 = torch.gather(row_be, 2, al[..., None]).squeeze(-1)
185
+ x12 = (torch.bmm(a, Mi) * bv).sum(-1)
186
+ det_r = (1 + x11) * (1 + x22) - x12 * x21
187
+ V, g = self.V, self.g
188
+ j1 = -g * (nd[:, p2] - nd[:, p]) + h[:, p2] - h[:, p] - V[p, p2]
189
+ nu2_q2 = nu[:, q2] - (q2 == p).to(DT) + (q2 == p2).to(DT)
190
+ nu2_q = nu[:, q] - (q == p).to(DT) + (q == p2).to(DT)
191
+ h2q2 = h[:, q2] - V[q2, p] + V[q2, p2]
192
+ h2q = h[:, q] - V[q, p] + V[q, p2]
193
+ j2 = -g * (nu2_q2 - nu2_q) + (h2q2 - h2q - V[q, q2])
194
+ val = torch.where(ok, self.pc * det_r * torch.exp(j1 + j2), torch.zeros_like(det_r)).sum(1)
195
+ out[sl] = 0.25 * val / self.N
196
+ return out
197
+
198
+ def log_derivs(self, keys, dPHI):
199
+ cols = []
200
+ ntot = self.nu + self.nd
201
+ for k in keys:
202
+ if k == "g":
203
+ cols.append(-(self.nu * self.nd).sum(1))
204
+ elif k.startswith("v"):
205
+ c = int(k[1:])
206
+ cols.append(0.5 * torch.einsum("bi,ij,bj->b", ntot, self.Cmat[c], ntot))
207
+ else:
208
+ dM = dPHI[k][self.up[:, :, None], self.dn[:, None, :]]
209
+ cols.append((self.Minv.transpose(1, 2) * dM).sum((1, 2)))
210
+ return torch.stack(cols, 1)
211
+
212
+
213
+ def unpack(theta, keys, base, nv):
214
+ par = dict(base); par["v"] = np.array(base.get("v", np.zeros(nv)), dtype=float)
215
+ for k, val in zip(keys, theta):
216
+ if k.startswith("v"):
217
+ par["v"][int(k[1:])] = val
218
+ else:
219
+ par[k] = float(val)
220
+ return par
221
+
222
+
223
+ def optimize(vm, par0, keys, n_iter, nmeas, lr, log=None, eps_rel=0.05, eps_abs=1e-3, gap=2):
224
+ nv = len(vm.lat.classes)
225
+ theta = np.array([par0[k] if not k.startswith("v") else np.asarray(par0.get("v", np.zeros(nv)))[int(k[1:])]
226
+ for k in keys], float)
227
+ hist = []
228
+ for it in range(n_iter):
229
+ par = unpack(theta, keys, par0, nv)
230
+ vm.set_params(par); vm.refresh()
231
+ h = 1e-5
232
+ dPHI = {}
233
+ for k in keys:
234
+ if k in ("Delta", "mu"):
235
+ pp, pm = dict(par), dict(par); pp[k] += h; pm[k] -= h
236
+ dPHI[k] = (vm.phi_sites(pp["Delta"], pp["mu"]) - vm.phi_sites(pm["Delta"], pm["mu"])) / (2 * h)
237
+ for _ in range(3):
238
+ vm.sweep()
239
+ Es, Os = [], []
240
+ for m in range(nmeas):
241
+ for _ in range(gap):
242
+ vm.sweep()
243
+ vm.refresh()
244
+ Es.append(vm.local_energy()); Os.append(vm.log_derivs(keys, dPHI))
245
+ E = torch.cat(Es); O = torch.cat(Os)
246
+ Om = O.mean(0)
247
+ S = ((O - Om).T @ (O - Om) / len(E)).cpu().numpy()
248
+ F = (((E - E.mean())[:, None] * (O - Om)).mean(0)).cpu().numpy()
249
+ S += np.diag(eps_rel * np.diag(S) + eps_abs)
250
+ theta = theta - lr * np.linalg.solve(S, F)
251
+ if "Delta" in keys:
252
+ i = keys.index("Delta"); theta[i] = abs(theta[i])
253
+ rec = dict(it=it, E=float(E.mean()), dE=float(E.std() / np.sqrt(len(E))),
254
+ theta=[round(float(x), 5) for x in theta])
255
+ hist.append(rec)
256
+ if log:
257
+ print(json.dumps(rec), file=log, flush=True)
258
+ tail = np.array([r["theta"] for r in hist[2 * n_iter // 3:]])
259
+ return unpack(tail.mean(0), keys, par0, nv), hist
260
+
261
+
262
+ def measure(vm, nmeas, gap=2, R=None):
263
+ R = R or (vm.L // 2, vm.L // 2)
264
+ vm.pair_terms(R)
265
+ Es, Ps, acc = [], [], []
266
+ for m in range(nmeas):
267
+ for _ in range(gap):
268
+ acc.append(vm.sweep())
269
+ vm.refresh()
270
+ Es.append(vm.local_energy()); Ps.append(vm.pair_corr())
271
+ E = torch.stack(Es, 1); P = torch.stack(Ps, 1) # (B, nmeas)
272
+ Ew, Pw = E.mean(1), P.mean(1) # per-walker means (independent)
273
+ sq = np.sqrt(vm.B)
274
+ return dict(E=float(Ew.mean()), dE=float(Ew.std() / sq), varE=float(E.var()),
275
+ Pd=float(Pw.mean()), dPd=float(Pw.std() / sq), acc=float(np.mean(acc)))
276
+
277
+
278
+ def main():
279
+ ap = argparse.ArgumentParser()
280
+ ap.add_argument("--L", type=int, default=6)
281
+ ap.add_argument("--Ne", type=int, default=26)
282
+ ap.add_argument("--U", type=float, default=8.0)
283
+ ap.add_argument("--Delta", type=float, default=0.15)
284
+ ap.add_argument("--mu", type=float, default=0.0)
285
+ ap.add_argument("--g", type=float, default=0.0)
286
+ ap.add_argument("--walkers", type=int, default=2048)
287
+ ap.add_argument("--ntherm", type=int, default=100, help="thermalization sweeps")
288
+ ap.add_argument("--nmeas", type=int, default=20, help="measurement rounds (x walkers = samples)")
289
+ ap.add_argument("--opt", default="")
290
+ ap.add_argument("--iters", type=int, default=150)
291
+ ap.add_argument("--nmeas_opt", type=int, default=2)
292
+ ap.add_argument("--lr", type=float, default=0.05)
293
+ ap.add_argument("--seed", type=int, default=0)
294
+ ap.add_argument("--out", default="")
295
+ a = ap.parse_args()
296
+ t0 = time.time()
297
+ par = dict(Delta=a.Delta, mu=a.mu, g=a.g)
298
+ vm = BatchVMC(a.L, a.Ne, a.U, par, a.walkers, a.seed)
299
+ for s in range(a.ntherm):
300
+ vm.sweep()
301
+ if s % 10 == 0:
302
+ vm.refresh()
303
+ hist = []
304
+ if a.opt:
305
+ nv = len(vm.lat.classes)
306
+ keys = []
307
+ for k in a.opt.split(","):
308
+ keys += [f"v{c}" for c in range(nv)] if k == "jas" else [k]
309
+ log = open(a.out.replace(".json", ".opt.log"), "w") if a.out else None
310
+ par, hist = optimize(vm, par, keys, a.iters, a.nmeas_opt, a.lr, log)
311
+ vm.set_params(par); vm.refresh()
312
+ for _ in range(20):
313
+ vm.sweep()
314
+ r = measure(vm, a.nmeas)
315
+ r.update(L=a.L, Ne=a.Ne, U=a.U, opt=a.opt, walkers=a.walkers,
316
+ par={k: (np.round(v, 5).tolist() if isinstance(v, np.ndarray) else round(float(v), 5)) for k, v in par.items()},
317
+ sec=round(time.time() - t0, 1), engine="gpu")
318
+ print(json.dumps(r))
319
+ if a.out:
320
+ json.dump(dict(result=r, hist=hist), open(a.out, "w"), indent=1)
321
+
322
+
323
+ if __name__ == "__main__":
324
+ main()
methods/Yuseon84/code/vmc_gpu2.py ADDED
@@ -0,0 +1,539 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """vmc_gpu.py + (1) doublon-holon Jastrow and (2) a free pairing function a_k.
3
+
4
+ Psi(x) = J(x) det[phi(r_i^up - r_j^dn)]
5
+ log J = -g D + sum_{i<j} v_c n_i n_j - kd * Nd_free - kh * Nh_free
6
+ Nd_free = # doublons with no nearest-neighbour holon, Nh_free = # holons with no NN doublon
7
+ pairing "bcs": a_k = D_k / (xi_k + E_k) (parameters Delta, mu; as in vmc_dwave.py)
8
+ pairing "bdg": F_ij from a real-space BdG mean field with d+s pairing, chemical potential,
9
+ Neel field maf and auxiliary t' (bdg_pair); breaks translation when maf != 0.
10
+ pairing "free": a_k = s(k) * theta_o(k), one free amplitude per C4v orbit o of k, with the
11
+ d-wave sign pattern s(k) = sign(cos kx - cos ky) (+1 on the diagonals).
12
+ BCS is the special case theta_o = |a_k^BCS|. theta of the k=0 orbit is fixed to 1.
13
+ Estimators and output format are those of vmc_gpu.py.
14
+ """
15
+ import argparse, json, time
16
+ import numpy as np
17
+ import torch
18
+ from vmc_dwave import Lattice, phi_table
19
+
20
+ DEV = torch.device("cuda")
21
+ DT = torch.float64
22
+
23
+
24
+ def k_orbits(L):
25
+ """C4v orbit index and d-wave sign for every k on the LxL grid."""
26
+ orb, keys = np.zeros((L, L), int), []
27
+ for a in range(L):
28
+ for b in range(L):
29
+ x, y = min(a, L - a), min(b, L - b)
30
+ key = (max(x, y), min(x, y))
31
+ if key not in keys:
32
+ keys.append(key)
33
+ orb[a, b] = keys.index(key)
34
+ ks = 2 * np.pi * np.arange(L) / L
35
+ f = np.cos(ks)[:, None] - np.cos(ks)[None, :]
36
+ s = np.where(np.abs(f) < 1e-9, 1.0, np.sign(f))
37
+ return orb, s, keys
38
+
39
+
40
+ def a_bcs(L, Delta, mu):
41
+ """|a_k| of the BCS form (same regularization as vmc_dwave.phi_table)."""
42
+ ks = 2 * np.pi * np.arange(L) / L
43
+ KX, KY = np.meshgrid(ks, ks, indexing="ij")
44
+ xi = -2 * (np.cos(KX) + np.cos(KY)) - mu
45
+ f = np.cos(KX) - np.cos(KY)
46
+ fmin = np.min(np.abs(f[np.abs(f) > 1e-6]))
47
+ Dk = Delta * np.where(np.abs(f) > 1e-6, f, 0.5 * fmin)
48
+ a = Dk / (xi + np.sqrt(xi ** 2 + Dk ** 2))
49
+ return a / np.max(np.abs(a))
50
+
51
+
52
+ def phi_from_a(L, a):
53
+ ks = 2 * np.pi * np.arange(L) / L
54
+ X = np.arange(L)
55
+ C, S = np.cos(np.outer(X, ks)), np.sin(np.outer(X, ks))
56
+ ph = np.einsum("ab,xa,yb->xy", a, C, C) - np.einsum("ab,xa,yb->xy", a, S, S)
57
+ return ph / (L * L)
58
+
59
+
60
+ def bdg_pair(lat, Delta, ds, mu, maf, tp=0.0):
61
+ """Pair function F_ij (up site i, down site j) of the real-space BdG mean field
62
+ h_sigma = -t(nn) - tp(nnn) - mu +/- maf (-1)^(x+y), pairing Delta*g_ij on nn bonds + ds on site.
63
+ F = -U V^{-1} from the negative-energy eigenvectors (equals the BCS phi when maf=tp=0)."""
64
+ N = lat.N
65
+ T = np.zeros((N, N)); Dm = ds * np.eye(N)
66
+ for s in range(N):
67
+ x, y = lat.xy[s]
68
+ for (dx, dy), gd in (((1, 0), 1.0), ((0, 1), -1.0)):
69
+ j = lat.site(x + dx, y + dy)
70
+ T[s, j] -= 1; T[j, s] -= 1
71
+ Dm[s, j] += Delta * gd; Dm[j, s] += Delta * gd
72
+ if tp:
73
+ for dx, dy in ((1, 1), (1, -1)):
74
+ j = lat.site(x + dx, y + dy)
75
+ T[s, j] -= tp; T[j, s] -= tp
76
+ stag = np.diag([(-1.0) ** (x + y) for x, y in lat.xy])
77
+ H = np.block([[T - mu * np.eye(N) + maf * stag, Dm], [Dm.T, -(T - mu * np.eye(N) - maf * stag).T]])
78
+ w, W = np.linalg.eigh(H)
79
+ F = -W[:N, :N] @ np.linalg.inv(W[N:, :N])
80
+ return F / np.max(np.abs(F))
81
+
82
+
83
+ BDG_KEYS = ("Delta", "ds", "mu", "maf", "tp")
84
+
85
+
86
+ class BatchVMC2:
87
+ def __init__(self, L, Ne, U, par, B, seed, pairing="bcs"):
88
+ self.lat = Lattice(L)
89
+ self.L, self.N, self.n, self.U, self.B = L, L * L, Ne // 2, U, B
90
+ self.pairing = pairing
91
+ self.gen = torch.Generator(device=DEV); self.gen.manual_seed(seed)
92
+ lat = self.lat
93
+ self.nb = torch.tensor(lat.nb, device=DEV)
94
+ self.cls = torch.tensor(lat.cls, device=DEV)
95
+ self.Cmat = torch.stack([(self.cls == c).to(DT) for c in range(len(lat.classes))])
96
+ self.dx = torch.tensor(lat.dx, device=DEV); self.dy = torch.tensor(lat.dy, device=DEV)
97
+ self.orb, self.sk, self.okeys = k_orbits(L)
98
+ self.ar = torch.arange(B, device=DEV)
99
+ self.set_params(par)
100
+ self.init_walkers()
101
+
102
+ # ---------------- parameters ----------------
103
+ def a_table(self, par):
104
+ if self.pairing == "bcs":
105
+ return a_bcs(self.L, par["Delta"], par["mu"])
106
+ th = np.asarray(par["a"], float)
107
+ return self.sk * th[self.orb]
108
+
109
+ def phi_sites_from_a(self, a):
110
+ ph = torch.tensor(phi_from_a(self.L, a), dtype=DT, device=DEV)
111
+ return ph[self.dx, self.dy]
112
+
113
+ def pair_matrix(self, par):
114
+ if self.pairing == "bdg":
115
+ return torch.tensor(bdg_pair(self.lat, par["Delta"], par.get("ds", 0.05), par["mu"],
116
+ par.get("maf", 0.0), par.get("tp", 0.0)), dtype=DT, device=DEV)
117
+ return self.phi_sites_from_a(self.a_table(par))
118
+
119
+ def set_params(self, par):
120
+ self.par = dict(par)
121
+ self.PHI = self.pair_matrix(par)
122
+ v = torch.tensor(np.asarray(par.get("v", np.zeros(len(self.lat.classes)))), dtype=DT, device=DEV)
123
+ self.V = torch.where(self.cls >= 0, v[self.cls.clamp(min=0)], torch.zeros((), dtype=DT, device=DEV))
124
+ self.g = float(par.get("g", 0.0))
125
+ self.kd = float(par.get("kd", 0.0)); self.kh = float(par.get("kh", 0.0))
126
+ u = torch.tensor(np.asarray(par.get("u", np.zeros(len(self.lat.classes)))), dtype=DT, device=DEV)
127
+ self.Us = torch.where(self.cls >= 0, u[self.cls.clamp(min=0)], torch.zeros((), dtype=DT, device=DEV))
128
+ self.use_dh = (self.kd != 0.0) or (self.kh != 0.0) or par.get("dh_on", False)
129
+
130
+ # ---------------- doublon-holon ----------------
131
+ def dh_counts(self, nu, nd):
132
+ d = nu * nd
133
+ h = (1 - nu) * (1 - nd)
134
+ h_nb = h[..., self.nb].sum(-1) > 0.5
135
+ d_nb = d[..., self.nb].sum(-1) > 0.5
136
+ return (d * (~h_nb)).sum(-1), (h * (~d_nb)).sum(-1)
137
+
138
+ def dh_log(self, nu, nd):
139
+ if not self.use_dh:
140
+ return torch.zeros(nu.shape[:-1], dtype=DT, device=DEV)
141
+ Nd, Nh = self.dh_counts(nu, nd)
142
+ return -self.kd * Nd - self.kh * Nh
143
+
144
+ # ---------------- walkers ----------------
145
+ def rand_conf(self, m):
146
+ return torch.rand(m, self.N, generator=self.gen, device=DEV).argsort(1)[:, : self.n]
147
+
148
+ def init_walkers(self):
149
+ B = self.B
150
+ self.up = self.rand_conf(B); self.dn = self.rand_conf(B)
151
+ for _ in range(50):
152
+ self.refresh()
153
+ bad = ~torch.isfinite(self.Minv).all(-1).all(-1) | (torch.linalg.det(self.M).abs() < 1e-200)
154
+ if not bad.any():
155
+ break
156
+ k = int(bad.sum())
157
+ self.up[bad] = self.rand_conf(k); self.dn[bad] = self.rand_conf(k)
158
+ self.refresh()
159
+
160
+ def refresh(self):
161
+ B, N = self.B, self.N
162
+ self.M = self.PHI[self.up[:, :, None], self.dn[:, None, :]]
163
+ self.Minv, info = torch.linalg.inv_ex(self.M)
164
+ bad = (info != 0) | ~torch.isfinite(self.Minv).all(-1).all(-1)
165
+ if bad.any() and not bad.all():
166
+ good = torch.nonzero(~bad).squeeze(1)
167
+ src = good[torch.randint(0, len(good), (int(bad.sum()),), generator=self.gen, device=DEV)]
168
+ self.up[bad] = self.up[src]; self.dn[bad] = self.dn[src]
169
+ self.M = self.PHI[self.up[:, :, None], self.dn[:, None, :]]
170
+ self.Minv, info = torch.linalg.inv_ex(self.M)
171
+ self.nu = torch.zeros(B, N, dtype=DT, device=DEV); self.nu.scatter_(1, self.up, 1.0)
172
+ self.nd = torch.zeros(B, N, dtype=DT, device=DEV); self.nd.scatter_(1, self.dn, 1.0)
173
+ self.h = (self.nu + self.nd) @ self.V
174
+ self.hs = (self.nu - self.nd) @ self.Us
175
+ self.dhl = self.dh_log(self.nu, self.nd)
176
+
177
+ def _rand(self, hi):
178
+ return torch.randint(0, hi, (self.B,), generator=self.gen, device=DEV)
179
+
180
+ @staticmethod
181
+ def _moved(occ, src, dst):
182
+ """Copy of occ (..., N) with one particle moved src->dst; src/dst broadcast over leading dims."""
183
+ o = occ.clone()
184
+ o.scatter_(-1, src[..., None], 0.0)
185
+ o.scatter_(-1, dst[..., None], 1.0)
186
+ return o
187
+
188
+ def step(self, spin):
189
+ ar, n = self.ar, self.n
190
+ e = self._rand(n); d = self._rand(4)
191
+ pos, same, other = (self.up, self.nu, self.nd) if spin == 0 else (self.dn, self.nd, self.nu)
192
+ a = pos[ar, e]; t = self.nb[a, d]
193
+ blocked = same[ar, t] > 0.5
194
+ if spin == 0:
195
+ vec = self.PHI[t[:, None], self.dn]
196
+ w = torch.einsum("bj,bjk->bk", vec, self.Minv)
197
+ else:
198
+ vec = self.PHI[self.up, t[:, None]]
199
+ w = torch.einsum("bij,bj->bi", self.Minv, vec)
200
+ q = w[ar, e]
201
+ dJ = -self.g * (other[ar, t] - other[ar, a]) + self.h[ar, t] - self.h[ar, a] - self.V[a, t]
202
+ sg = 1.0 if spin == 0 else -1.0
203
+ dJ = dJ + sg * (self.hs[ar, t] - self.hs[ar, a]) - self.Us[a, t]
204
+ if self.use_dh:
205
+ new_same = self._moved(same, a, t)
206
+ nl = self.dh_log(new_same, other) if spin == 0 else self.dh_log(other, new_same)
207
+ dJ = dJ + nl - self.dhl
208
+ r = q * torch.exp(dJ)
209
+ acc = (torch.rand(self.B, generator=self.gen, device=DEV, dtype=DT) < r * r) & ~blocked
210
+ idx = torch.nonzero(acc).squeeze(1)
211
+ if idx.numel() == 0:
212
+ return 0
213
+ ei, wi, qi = e[idx], w[idx].clone(), q[idx]
214
+ wi[torch.arange(len(idx), device=DEV), ei] -= 1.0
215
+ if spin == 0:
216
+ self.Minv[idx] -= self.Minv[idx, :, ei][:, :, None] * wi[:, None, :] / qi[:, None, None]
217
+ self.M[idx, ei, :] = vec[idx]
218
+ self.up[idx, ei] = t[idx]
219
+ self.nu[idx, a[idx]] = 0.0; self.nu[idx, t[idx]] = 1.0
220
+ else:
221
+ self.Minv[idx] -= wi[:, :, None] * self.Minv[idx, ei, :][:, None, :] / qi[:, None, None]
222
+ self.M[idx, :, ei] = vec[idx]
223
+ self.dn[idx, ei] = t[idx]
224
+ self.nd[idx, a[idx]] = 0.0; self.nd[idx, t[idx]] = 1.0
225
+ self.h[idx] += self.V[t[idx]] - self.V[a[idx]]
226
+ self.hs[idx] += sg * (self.Us[t[idx]] - self.Us[a[idx]])
227
+ if self.use_dh:
228
+ self.dhl[idx] = self.dh_log(self.nu[idx], self.nd[idx])
229
+ return len(idx)
230
+
231
+ def sweep(self):
232
+ acc = 0
233
+ for spin in (0, 1):
234
+ for _ in range(self.n):
235
+ acc += self.step(spin)
236
+ return acc / (2 * self.n * self.B)
237
+
238
+ # ---------------- estimators ----------------
239
+ def local_energy(self):
240
+ nu, nd, h, V, g, Mi, P = self.nu, self.nd, self.h, self.V, self.g, self.Minv, self.PHI
241
+ bi = self.ar[:, None, None]
242
+ D = (nu * nd).sum(1)
243
+ kin = torch.zeros(self.B, dtype=DT, device=DEV)
244
+ for spin in (0, 1):
245
+ pos, same, other = (self.up, nu, nd) if spin == 0 else (self.dn, nd, nu)
246
+ tgt = self.nb[pos] # (B,n,4)
247
+ src = pos[:, :, None].expand_as(tgt)
248
+ if spin == 0:
249
+ rows = P[tgt[..., None], self.dn[:, None, None, :]]
250
+ q = torch.einsum("banj,bja->ban", rows, Mi)
251
+ else:
252
+ cols = P[self.up[:, None, None, :], tgt[..., None]]
253
+ q = torch.einsum("bmi,bmki->bmk", Mi, cols)
254
+ jl = -g * (other[bi, tgt] - other[bi, src]) + h[bi, tgt] - h[bi, src] - V[src, tgt]
255
+ sg = 1.0 if spin == 0 else -1.0
256
+ jl = jl + sg * (self.hs[bi, tgt] - self.hs[bi, src]) - self.Us[src, tgt]
257
+ if self.use_dh:
258
+ ns = self._moved(same[:, None, None, :].expand(-1, self.n, 4, -1), src, tgt)
259
+ ot = other[:, None, None, :].expand_as(ns)
260
+ nl = self.dh_log(ns, ot) if spin == 0 else self.dh_log(ot, ns)
261
+ jl = jl + nl - self.dhl[:, None, None]
262
+ kin = kin + torch.where(same[bi, tgt] < 0.5, q * torch.exp(jl), torch.zeros_like(q)).sum((1, 2))
263
+ return self.U * D - kin
264
+
265
+ def pair_terms(self, R):
266
+ lat = self.lat
267
+ NB = [((1, 0), 1.0), ((-1, 0), 1.0), ((0, 1), -1.0), ((0, -1), -1.0)]
268
+ T = []
269
+ for (x, y) in lat.xy:
270
+ i = lat.site(x, y); j = lat.site(x + R[0], y + R[1])
271
+ for d, g in NB:
272
+ di = lat.site(x + d[0], y + d[1])
273
+ for dp, gp in NB:
274
+ dj = lat.site(x + R[0] + dp[0], y + R[1] + dp[1])
275
+ for (p, q) in ((i, di), (di, i)):
276
+ for (p2, q2) in ((j, dj), (dj, j)):
277
+ T.append((g * gp, p, p2, q, q2))
278
+ T = np.array(T)
279
+ self.pc = torch.tensor(T[:, 0], dtype=DT, device=DEV)
280
+ self.pidx = torch.tensor(T[:, 1:].astype(np.int64), device=DEV)
281
+
282
+ def pair_corr(self, chunk=64):
283
+ out = torch.zeros(self.B, dtype=DT, device=DEV)
284
+ p, p2, q, q2 = self.pidx.T
285
+ n = self.n
286
+ ar_n = torch.arange(n, device=DEV)
287
+ for s in range(0, self.B, chunk):
288
+ sl = slice(s, min(s + chunk, self.B)); b = sl.stop - sl.start
289
+ nu, nd, up, dn = self.nu[sl], self.nd[sl], self.up[sl], self.dn[sl]
290
+ M, Mi, h = self.M[sl], self.Minv[sl], self.h[sl]
291
+ ok = (nu[:, p] > 0.5) & (nd[:, q] > 0.5) & (nu[:, p2] < 0.5) & (nd[:, q2] < 0.5)
292
+ eu = torch.zeros((b, self.N), dtype=torch.long, device=DEV); eu.scatter_(1, up, ar_n.expand(b, n).contiguous())
293
+ ed = torch.zeros((b, self.N), dtype=torch.long, device=DEV); ed.scatter_(1, dn, ar_n.expand(b, n).contiguous())
294
+ al, be = eu[:, p], ed[:, q]
295
+ dn_new = torch.where(ar_n[None, None, :] == be[..., None], q2[None, :, None], dn[:, None, :])
296
+ up_new = torch.where(ar_n[None, None, :] == al[..., None], p2[None, :, None], up[:, None, :])
297
+ Rn = self.PHI[p2[None, :, None], dn_new]
298
+ Cn = self.PHI[up_new, q2[None, :, None]]
299
+ a = Rn - torch.gather(M, 1, al[..., None].expand(-1, -1, n))
300
+ bv = Cn - torch.gather(M.transpose(1, 2), 1, be[..., None].expand(-1, -1, n))
301
+ bv = bv.scatter(2, al[..., None], 0.0)
302
+ col_al = torch.gather(Mi.transpose(1, 2), 1, al[..., None].expand(-1, -1, n))
303
+ row_be = torch.gather(Mi, 1, be[..., None].expand(-1, -1, n))
304
+ x11 = (a * col_al).sum(-1)
305
+ x22 = (row_be * bv).sum(-1)
306
+ x21 = torch.gather(row_be, 2, al[..., None]).squeeze(-1)
307
+ x12 = (torch.bmm(a, Mi) * bv).sum(-1)
308
+ det_r = (1 + x11) * (1 + x22) - x12 * x21
309
+ V, g = self.V, self.g
310
+ j1 = -g * (nd[:, p2] - nd[:, p]) + h[:, p2] - h[:, p] - V[p, p2]
311
+ nu2_q2 = nu[:, q2] - (q2 == p).to(DT) + (q2 == p2).to(DT)
312
+ nu2_q = nu[:, q] - (q == p).to(DT) + (q == p2).to(DT)
313
+ h2q2 = h[:, q2] - V[q2, p] + V[q2, p2]
314
+ h2q = h[:, q] - V[q, p] + V[q, p2]
315
+ j2 = -g * (nu2_q2 - nu2_q) + (h2q2 - h2q - V[q, q2])
316
+ hs, Us = self.hs[sl], self.Us
317
+ s1 = hs[:, p2] - hs[:, p] - Us[p, p2] # up p->p2
318
+ hs2q2 = hs[:, q2] + Us[q2, p2] - Us[q2, p]
319
+ hs2q = hs[:, q] + Us[q, p2] - Us[q, p]
320
+ s2 = -(hs2q2 - hs2q) - Us[q, q2] # then down q->q2
321
+ jl = j1 + j2 + s1 + s2
322
+ if self.use_dh:
323
+ T = len(p)
324
+ nu_new = self._moved(nu[:, None, :].expand(-1, T, -1), p[None, :].expand(b, -1), p2[None, :].expand(b, -1))
325
+ nd_new = self._moved(nd[:, None, :].expand(-1, T, -1), q[None, :].expand(b, -1), q2[None, :].expand(b, -1))
326
+ jl = jl + self.dh_log(nu_new, nd_new) - self.dhl[sl][:, None]
327
+ val = torch.where(ok, self.pc * det_r * torch.exp(jl), torch.zeros_like(det_r)).sum(1)
328
+ out[sl] = 0.25 * val / self.N
329
+ return out
330
+
331
+ def log_derivs(self, keys, dPHI):
332
+ cols = []
333
+ ntot = self.nu + self.nd
334
+ if any(k in ("kd", "kh") for k in keys):
335
+ Nd, Nh = self.dh_counts(self.nu, self.nd)
336
+ for k in keys:
337
+ if k == "g":
338
+ cols.append(-(self.nu * self.nd).sum(1))
339
+ elif k == "kd":
340
+ cols.append(-Nd)
341
+ elif k == "kh":
342
+ cols.append(-Nh)
343
+ elif k.startswith("v"):
344
+ c = int(k[1:])
345
+ cols.append(0.5 * torch.einsum("bi,ij,bj->b", ntot, self.Cmat[c], ntot))
346
+ elif k.startswith("u"):
347
+ c = int(k[1:]); m = self.nu - self.nd
348
+ cols.append(0.5 * torch.einsum("bi,ij,bj->b", m, self.Cmat[c], m))
349
+ else: # Delta, mu, or a<o>
350
+ dM = dPHI[k][self.up[:, :, None], self.dn[:, None, :]]
351
+ cols.append((self.Minv.transpose(1, 2) * dM).sum((1, 2)))
352
+ return torch.stack(cols, 1)
353
+
354
+ def dphi(self, par, keys):
355
+ out = {}
356
+ for k in keys:
357
+ if k in BDG_KEYS:
358
+ h = 1e-5
359
+ pp, pm = dict(par), dict(par)
360
+ pp[k] = pp.get(k, 0.0) + h; pm[k] = pm.get(k, 0.0) - h
361
+ out[k] = (self.pair_matrix(pp) - self.pair_matrix(pm)) / (2 * h)
362
+ elif k.startswith("a"):
363
+ o = int(k[1:])
364
+ out[k] = self.phi_sites_from_a(np.where(self.orb == o, self.sk, 0.0))
365
+ return out
366
+
367
+
368
+ def unpack(theta, keys, base, nv, na):
369
+ par = dict(base)
370
+ par["v"] = np.array(base.get("v", np.zeros(nv)), dtype=float)
371
+ par["u"] = np.array(base.get("u", np.zeros(nv)), dtype=float)
372
+ if "a" in base:
373
+ par["a"] = np.array(base["a"], dtype=float)
374
+ for k, val in zip(keys, theta):
375
+ if k.startswith("v"):
376
+ par["v"][int(k[1:])] = val
377
+ elif k.startswith("u"):
378
+ par["u"][int(k[1:])] = val
379
+ elif k.startswith("a"):
380
+ par["a"][int(k[1:])] = val
381
+ else:
382
+ par[k] = float(val)
383
+ return par
384
+
385
+
386
+ def get(par, k):
387
+ if k.startswith("v"):
388
+ return float(par["v"][int(k[1:])]) if "v" in par else 0.0
389
+ if k.startswith("u"):
390
+ return float(par["u"][int(k[1:])]) if "u" in par else 0.0
391
+ if k.startswith("a"):
392
+ return float(par["a"][int(k[1:])])
393
+ return float(par.get(k, 0.0))
394
+
395
+
396
+ def optimize(vm, par0, keys, n_iter, nmeas, lr, log=None, eps_rel=0.05, eps_abs=1e-3, gap=2, pre=3):
397
+ nv, na = len(vm.lat.classes), len(vm.okeys)
398
+ theta = np.array([get(par0, k) for k in keys], float)
399
+ hist = []
400
+ good, E_good, lr0 = theta.copy(), None, lr
401
+ for it in range(n_iter):
402
+ par = unpack(theta, keys, par0, nv, na)
403
+ vm.set_params(par); vm.refresh()
404
+ dPHI = vm.dphi(par, keys)
405
+ for _ in range(pre):
406
+ vm.sweep()
407
+ Es, Os = [], []
408
+ for m in range(nmeas):
409
+ for _ in range(gap):
410
+ vm.sweep()
411
+ vm.refresh()
412
+ Es.append(vm.local_energy()); Os.append(vm.log_derivs(keys, dPHI))
413
+ E = torch.cat(Es); O = torch.cat(Os)
414
+ ok = torch.isfinite(E) & torch.isfinite(O).all(1)
415
+ E, O = E[ok], O[ok]
416
+ Em = float(E.mean()) if len(E) else float("nan")
417
+ if (not np.isfinite(Em)) or (E_good is not None and abs(Em) > 10 * abs(E_good)):
418
+ # wavefunction broke down (e.g. near-degenerate mean field): revert and slow down
419
+ theta, lr = good.copy(), lr * 0.5
420
+ hist.append(dict(it=it, E=Em, dE=float("nan"), theta=[round(float(x), 5) for x in theta], reverted=True))
421
+ if log:
422
+ print(json.dumps(hist[-1]), file=log, flush=True)
423
+ continue
424
+ good, E_good = theta.copy(), Em
425
+ lr = min(lr0, lr * 1.1)
426
+ Om = O.mean(0)
427
+ S = ((O - Om).T @ (O - Om) / len(E)).cpu().numpy()
428
+ F = (((E - E.mean())[:, None] * (O - Om)).mean(0)).cpu().numpy()
429
+ S += np.diag(eps_rel * np.diag(S) + eps_abs)
430
+ step = -lr * np.linalg.solve(S, F)
431
+ cap = 0.1 * np.maximum(0.3, np.abs(theta)) # trust region per parameter
432
+ step = step / max(1.0, float(np.max(np.abs(step) / cap)))
433
+ theta = theta + step
434
+ if "Delta" in keys:
435
+ i = keys.index("Delta"); theta[i] = max(abs(theta[i]), getattr(vm, "delta_floor", 0.0))
436
+ for k, fl in getattr(vm, "floors", {}).items(): # keep gaps open (well-conditioned W)
437
+ if k in keys:
438
+ i = keys.index(k); theta[i] = max(theta[i], fl)
439
+ rec = dict(it=it, E=float(E.mean()), dE=float(E.std() / np.sqrt(len(E))),
440
+ theta=[round(float(x), 5) for x in theta])
441
+ hist.append(rec)
442
+ if log:
443
+ print(json.dumps(rec), file=log, flush=True)
444
+ tail = np.array([r["theta"] for r in hist[2 * n_iter // 3:] if not r.get("reverted")] or [good])
445
+ return unpack(tail.mean(0), keys, par0, nv, na), hist
446
+
447
+
448
+ def measure(vm, nmeas, gap=2, R=None):
449
+ R = R or (vm.L // 2, vm.L // 2)
450
+ vm.pair_terms(R)
451
+ Es, Ps, acc = [], [], []
452
+ for m in range(nmeas):
453
+ for _ in range(gap):
454
+ acc.append(vm.sweep())
455
+ vm.refresh()
456
+ Es.append(vm.local_energy()); Ps.append(vm.pair_corr())
457
+ E = torch.stack(Es, 1); P = torch.stack(Ps, 1)
458
+ Ew, Pw = E.mean(1), P.mean(1)
459
+ sq = np.sqrt(vm.B)
460
+ return dict(E=float(Ew.mean()), dE=float(Ew.std() / sq), varE=float(E.var()),
461
+ Pd=float(Pw.mean()), dPd=float(Pw.std() / sq), acc=float(np.mean(acc)))
462
+
463
+
464
+ def main():
465
+ ap = argparse.ArgumentParser()
466
+ ap.add_argument("--L", type=int, default=6)
467
+ ap.add_argument("--Ne", type=int, default=26)
468
+ ap.add_argument("--U", type=float, default=8.0)
469
+ ap.add_argument("--pairing", choices=["bcs", "free", "bdg"], default="bcs")
470
+ ap.add_argument("--ds", type=float, default=0.05, help="bdg: on-site s component (keeps U,V invertible)")
471
+ ap.add_argument("--maf", type=float, default=0.0, help="bdg: staggered (Neel) field")
472
+ ap.add_argument("--tp", type=float, default=0.0, help="bdg: auxiliary next-nearest hopping")
473
+ ap.add_argument("--Delta", type=float, default=0.15)
474
+ ap.add_argument("--mu", type=float, default=0.0)
475
+ ap.add_argument("--g", type=float, default=0.0)
476
+ ap.add_argument("--kd", type=float, default=0.0)
477
+ ap.add_argument("--kh", type=float, default=0.0)
478
+ ap.add_argument("--init", default="", help="json result file to start from (par is reused)")
479
+ ap.add_argument("--walkers", type=int, default=2048)
480
+ ap.add_argument("--ntherm", type=int, default=100)
481
+ ap.add_argument("--nmeas", type=int, default=20)
482
+ ap.add_argument("--opt", default="", help="comma list: Delta,mu,g,jas,dh,afree (afree = all free a_k but k=0)")
483
+ ap.add_argument("--iters", type=int, default=150)
484
+ ap.add_argument("--nmeas_opt", type=int, default=1)
485
+ ap.add_argument("--lr", type=float, default=0.05)
486
+ ap.add_argument("--seed", type=int, default=0)
487
+ ap.add_argument("--out", default="")
488
+ a = ap.parse_args()
489
+ t0 = time.time()
490
+ par = dict(Delta=a.Delta, mu=a.mu, g=a.g, kd=a.kd, kh=a.kh)
491
+ if a.pairing == "bdg":
492
+ par.update(ds=a.ds, maf=a.maf, tp=a.tp)
493
+ if a.init:
494
+ p0 = json.load(open(a.init))["result"]["par"]
495
+ par.update({k: (np.array(v) if isinstance(v, list) else v) for k, v in p0.items()})
496
+ nv = len(Lattice(a.L).classes)
497
+ orb, sk, okeys = k_orbits(a.L)
498
+ if a.pairing == "free" and "a" not in par:
499
+ ab = np.abs(a_bcs(a.L, par["Delta"], par["mu"])) # start from the BCS amplitudes
500
+ par["a"] = np.array([ab[orb == o].mean() for o in range(len(okeys))])
501
+ par["a"] = par["a"] / par["a"][0]
502
+ if "dh" in a.opt:
503
+ par["dh_on"] = True
504
+ vm = BatchVMC2(a.L, a.Ne, a.U, par, a.walkers, a.seed, a.pairing)
505
+ for s in range(a.ntherm):
506
+ vm.sweep()
507
+ if s % 10 == 0:
508
+ vm.refresh()
509
+ hist = []
510
+ if a.opt:
511
+ keys = []
512
+ for k in a.opt.split(","):
513
+ if k == "jas":
514
+ keys += [f"v{c}" for c in range(nv)]
515
+ elif k == "dh":
516
+ keys += ["kd", "kh"]
517
+ elif k == "sjas":
518
+ keys += [f"u{c}" for c in range(nv)]
519
+ elif k == "afree":
520
+ keys += [f"a{o}" for o in range(1, len(okeys))]
521
+ else:
522
+ keys.append(k)
523
+ log = open(a.out.replace(".json", ".opt.log"), "w") if a.out else None
524
+ par, hist = optimize(vm, par, keys, a.iters, a.nmeas_opt, a.lr, log)
525
+ vm.set_params(par); vm.refresh()
526
+ for _ in range(20):
527
+ vm.sweep()
528
+ r = measure(vm, a.nmeas)
529
+ r.update(L=a.L, Ne=a.Ne, U=a.U, opt=a.opt, pairing=a.pairing, walkers=a.walkers,
530
+ par={k: (np.round(v, 5).tolist() if isinstance(v, np.ndarray) else (v if isinstance(v, bool) else round(float(v), 5)))
531
+ for k, v in par.items()},
532
+ sec=round(time.time() - t0, 1), engine="gpu2")
533
+ print(json.dumps(r))
534
+ if a.out:
535
+ json.dump(dict(result=r, hist=hist), open(a.out, "w"), indent=1)
536
+
537
+
538
+ if __name__ == "__main__":
539
+ main()
methods/Yuseon84/code/vmc_gpu3.py ADDED
@@ -0,0 +1,374 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Particle-hole (Yokoyama-Shiba type) determinant VMC: BdG mean field with d+s pairing, chemical
3
+ potential, Neel field and auxiliary t', times the Jastrow factors of vmc_gpu2 (Gutzwiller, density,
4
+ spin, doublon-holon).
5
+
6
+ Down spins are particle-hole transformed: with W the 2N x N negative-energy BdG eigenvectors
7
+ (basis c_up, c+_dn), the amplitude of a configuration is
8
+ Psi(x) = (-1)^(sum of down positions) * det A(x) * J(x),
9
+ A rows = W[up sites] (labeled up electrons) and W[N + hole sites] (labeled down holes).
10
+ This stays well conditioned with a Neel field, unlike the AGP pair function -U V^-1.
11
+ Sign rules (checked against exact H on 4x4): an up hop contributes -t*det-ratio (row of that up
12
+ electron replaced); a down hop a->t contributes +t*det-ratio (row of the hole at t replaced by
13
+ W[N+a]); the pair estimator picks up an overall factor -1 from its down-spin part.
14
+ """
15
+ import argparse, json, time
16
+ import numpy as np
17
+ import torch
18
+ from vmc_dwave import Lattice
19
+ import vmc_gpu2 as V2
20
+
21
+ DEV, DT = V2.DEV, V2.DT
22
+ KEYS = ("Delta", "ds", "mu", "maf", "tp")
23
+
24
+
25
+ def bdg_W(lat, Delta, ds, mu, maf, tp=0.0):
26
+ N = lat.N
27
+ T = np.zeros((N, N)); Dm = ds * np.eye(N)
28
+ for s in range(N):
29
+ x, y = lat.xy[s]
30
+ for (dx, dy), gd in (((1, 0), 1.0), ((0, 1), -1.0)):
31
+ j = lat.site(x + dx, y + dy)
32
+ T[s, j] -= 1; T[j, s] -= 1
33
+ Dm[s, j] += Delta * gd; Dm[j, s] += Delta * gd
34
+ if tp:
35
+ for dx, dy in ((1, 1), (1, -1)):
36
+ j = lat.site(x + dx, y + dy)
37
+ T[s, j] -= tp; T[j, s] -= tp
38
+ st = np.diag([(-1.0) ** (x + y) for x, y in lat.xy])
39
+ H = np.block([[T - mu * np.eye(N) + maf * st, Dm], [Dm.T, -(T - mu * np.eye(N) - maf * st).T]])
40
+ w, Wv = np.linalg.eigh(H)
41
+ return Wv[:, :N]
42
+
43
+
44
+ class BatchVMC3(V2.BatchVMC2):
45
+ delta_floor = 0.02 # keep the BdG pairing gap open (avoids degenerate, ill-defined W)
46
+ floors = {"ds": 0.02} # on-site s component keeps nodal quasiparticles gapped (U, V invertible)
47
+
48
+ def __init__(self, L, Ne, U, par, B, seed):
49
+ super().__init__(L, Ne, U, par, B, seed, pairing="ph")
50
+
51
+ # ---------------- orbitals ----------------
52
+ def W_of(self, par):
53
+ return bdg_W(self.lat, par["Delta"], par.get("ds", 0.05), par["mu"], par.get("maf", 0.0), par.get("tp", 0.0))
54
+
55
+ def set_params(self, par):
56
+ self.par = dict(par)
57
+ self.W0 = self.W_of(par)
58
+ self.Wt = torch.tensor(self.W0, dtype=DT, device=DEV)
59
+ v = torch.tensor(np.asarray(par.get("v", np.zeros(len(self.lat.classes)))), dtype=DT, device=DEV)
60
+ z = torch.zeros((), dtype=DT, device=DEV)
61
+ self.V = torch.where(self.cls >= 0, v[self.cls.clamp(min=0)], z)
62
+ u = torch.tensor(np.asarray(par.get("u", np.zeros(len(self.lat.classes)))), dtype=DT, device=DEV)
63
+ self.Us = torch.where(self.cls >= 0, u[self.cls.clamp(min=0)], z)
64
+ self.g = float(par.get("g", 0.0))
65
+ self.kd = float(par.get("kd", 0.0)); self.kh = float(par.get("kh", 0.0))
66
+ self.use_dh = (self.kd != 0.0) or (self.kh != 0.0) or par.get("dh_on", False)
67
+
68
+ def dphi(self, par, keys):
69
+ """dA/dtheta via gauge-aligned finite differences of W (W -> W R leaves log-derivatives
70
+ unchanged up to a constant)."""
71
+ out = {}
72
+ W0 = self.W0
73
+ for k in keys:
74
+ if k in KEYS:
75
+ h = 1e-5
76
+ Ws = []
77
+ for sgn in (1, -1):
78
+ pp = dict(par); pp[k] = pp.get(k, 0.0) + sgn * h
79
+ Wp = self.W_of(pp)
80
+ Ws.append(Wp @ np.linalg.inv(W0.T @ Wp))
81
+ out[k] = torch.tensor((Ws[0] - Ws[1]) / (2 * h), dtype=DT, device=DEV)
82
+ return out
83
+
84
+ # ---------------- walkers ----------------
85
+ def build(self):
86
+ B, N, n = self.B, self.N, self.n
87
+ self.nd = torch.zeros(B, N, dtype=DT, device=DEV); self.nd.scatter_(1, self.dn, 1.0)
88
+ self.holes = torch.argsort(self.nd, dim=1, stable=True)[:, : N - n]
89
+ self.hl = torch.full((B, N), -1, dtype=torch.long, device=DEV)
90
+ self.hl.scatter_(1, self.holes, torch.arange(N - n, device=DEV).expand(B, -1).contiguous())
91
+ self.A = torch.cat([self.Wt[self.up], self.Wt[N + self.holes]], 1)
92
+ self.Ainv, info = torch.linalg.inv_ex(self.A)
93
+ return (info != 0) | ~torch.isfinite(self.Ainv).all(-1).all(-1)
94
+
95
+ def refresh(self):
96
+ B, N = self.B, self.N
97
+ bad = self.build()
98
+ if bad.any() and not bad.all():
99
+ good = torch.nonzero(~bad).squeeze(1)
100
+ src = good[torch.randint(0, len(good), (int(bad.sum()),), generator=self.gen, device=DEV)]
101
+ self.up[bad] = self.up[src]; self.dn[bad] = self.dn[src]
102
+ self.build()
103
+ self.nu = torch.zeros(B, N, dtype=DT, device=DEV); self.nu.scatter_(1, self.up, 1.0)
104
+ self.h = (self.nu + self.nd) @ self.V
105
+ self.hs = (self.nu - self.nd) @ self.Us
106
+ self.dhl = self.dh_log(self.nu, self.nd)
107
+ self.M, self.Minv = self.A, self.Ainv # for code that only checks finiteness
108
+
109
+ def init_walkers(self):
110
+ B = self.B
111
+ self.up = self.rand_conf(B); self.dn = self.rand_conf(B)
112
+ for _ in range(50):
113
+ bad = self.build()
114
+ if not bad.any():
115
+ break
116
+ k = int(bad.sum())
117
+ self.up[bad] = self.rand_conf(k); self.dn[bad] = self.rand_conf(k)
118
+ self.refresh()
119
+
120
+ # ---------------- Jastrow helper ----------------
121
+ def jas_single(self, spin, a, t, bshape_idx):
122
+ """log J ratio for moving one spin-`spin` electron a->t (a, t broadcast with bshape_idx)."""
123
+ bi = bshape_idx
124
+ same, other = (self.nu, self.nd) if spin == 0 else (self.nd, self.nu)
125
+ V, g = self.V, self.g
126
+ jl = -g * (other[bi, t] - other[bi, a]) + self.h[bi, t] - self.h[bi, a] - V[a, t]
127
+ sg = 1.0 if spin == 0 else -1.0
128
+ jl = jl + sg * (self.hs[bi, t] - self.hs[bi, a]) - self.Us[a, t]
129
+ return jl
130
+
131
+ # ---------------- moves ----------------
132
+ def step(self, spin):
133
+ ar, n, N = self.ar, self.n, self.N
134
+ e = self._rand(n); d = self._rand(4)
135
+ pos, same, other = (self.up, self.nu, self.nd) if spin == 0 else (self.dn, self.nd, self.nu)
136
+ a = pos[ar, e]; t = self.nb[a, d]
137
+ blocked = same[ar, t] > 0.5
138
+ if spin == 0:
139
+ row = e
140
+ vec = self.Wt[t]
141
+ else:
142
+ row = n + self.hl[ar, t].clamp(min=0)
143
+ vec = self.Wt[N + a]
144
+ w = torch.einsum("bk,bkj->bj", vec, self.Ainv)
145
+ q = w[ar, row]
146
+ dJ = self.jas_single(spin, a, t, ar)
147
+ if self.use_dh:
148
+ new_same = self._moved(same, a, t)
149
+ nl = self.dh_log(new_same, other) if spin == 0 else self.dh_log(other, new_same)
150
+ dJ = dJ + nl - self.dhl
151
+ r = q * torch.exp(dJ)
152
+ acc = (torch.rand(self.B, generator=self.gen, device=DEV, dtype=DT) < r * r) & ~blocked
153
+ idx = torch.nonzero(acc).squeeze(1)
154
+ if idx.numel() == 0:
155
+ return 0
156
+ ri, wi, qi = row[idx], w[idx].clone(), q[idx]
157
+ wi[torch.arange(len(idx), device=DEV), ri] -= 1.0
158
+ self.Ainv[idx] -= self.Ainv[idx, :, ri][:, :, None] * wi[:, None, :] / qi[:, None, None]
159
+ self.A[idx, ri, :] = vec[idx]
160
+ # a large or tiny ratio means the old inverse was ill-conditioned (walker near a node):
161
+ # recompute those inverses from scratch instead of trusting the rank-1 update
162
+ big = (qi.abs() > 1e3) | (qi.abs() < 1e-3)
163
+ if big.any():
164
+ jb = idx[big]
165
+ self.Ainv[jb] = torch.linalg.inv_ex(self.A[jb])[0]
166
+ ai, ti = a[idx], t[idx]
167
+ if spin == 0:
168
+ self.up[idx, e[idx]] = ti
169
+ self.nu[idx, ai] = 0.0; self.nu[idx, ti] = 1.0
170
+ else:
171
+ beta = self.hl[idx, ti]
172
+ self.dn[idx, e[idx]] = ti
173
+ self.holes[idx, beta] = ai
174
+ self.hl[idx, ai] = beta; self.hl[idx, ti] = -1
175
+ self.nd[idx, ai] = 0.0; self.nd[idx, ti] = 1.0
176
+ sg = 1.0 if spin == 0 else -1.0
177
+ self.h[idx] += self.V[ti] - self.V[ai]
178
+ self.hs[idx] += sg * (self.Us[ti] - self.Us[ai])
179
+ if self.use_dh:
180
+ self.dhl[idx] = self.dh_log(self.nu[idx], self.nd[idx])
181
+ return len(idx)
182
+
183
+ def step_exchange(self):
184
+ """Swap a neighbouring (up at i, down at j) pair with i, j singly occupied: up i->j, down j->i.
185
+ D, density and DH counts are unchanged; only the spin Jastrow and the determinant change."""
186
+ ar, n, N = self.ar, self.n, self.N
187
+ e = self._rand(n); d = self._rand(4)
188
+ i = self.up[ar, e]; j = self.nb[i, d]
189
+ ok = (self.nd[ar, j] > 0.5) & (self.nu[ar, j] < 0.5) & (self.nd[ar, i] < 0.5)
190
+ r = n + self.hl[ar, i].clamp(min=0) # hole at i moves to j
191
+ AinvT = self.Ainv.transpose(1, 2)
192
+ ca, cr = AinvT[ar, e], AinvT[ar, r]
193
+ u1, u2 = self.Wt[j], self.Wt[N + j]
194
+ det_r = (u1 * ca).sum(-1) * (u2 * cr).sum(-1) - (u1 * cr).sum(-1) * (u2 * ca).sum(-1)
195
+ jl = 2 * (self.hs[ar, j] - self.hs[ar, i]) - 4 * self.Us[i, j]
196
+ rr = det_r * torch.exp(jl)
197
+ acc = (torch.rand(self.B, generator=self.gen, device=DEV, dtype=DT) < rr * rr) & ok
198
+ idx = torch.nonzero(acc).squeeze(1)
199
+ if idx.numel() == 0:
200
+ return 0
201
+ ii, jj, ei, ri = i[idx], j[idx], e[idx], r[idx]
202
+ beta = self.hl[idx, ii]
203
+ ed = (self.dn[idx] == jj[:, None]).to(torch.long).argmax(1) # label of the down electron at j
204
+ self.up[idx, ei] = jj
205
+ self.dn[idx, ed] = ii
206
+ self.holes[idx, beta] = jj
207
+ self.hl[idx, jj] = beta; self.hl[idx, ii] = -1
208
+ self.nu[idx, ii] = 0.0; self.nu[idx, jj] = 1.0
209
+ self.nd[idx, jj] = 0.0; self.nd[idx, ii] = 1.0
210
+ self.hs[idx] += 2 * (self.Us[jj] - self.Us[ii])
211
+ self.A[idx, ei, :] = self.Wt[jj]
212
+ self.A[idx, ri, :] = self.Wt[N + jj]
213
+ self.Ainv[idx] = torch.linalg.inv_ex(self.A[idx])[0]
214
+ return len(idx)
215
+
216
+ def sweep(self):
217
+ acc = super().sweep()
218
+ for _ in range(self.n):
219
+ self.step_exchange()
220
+ self.refresh() # cheap (batched NxN inverse); keeps Ainv exact each sweep
221
+ return acc
222
+
223
+ # ---------------- estimators ----------------
224
+ def local_energy(self):
225
+ nu, nd, N, n = self.nu, self.nd, self.N, self.n
226
+ bi = self.ar[:, None, None]
227
+ D = (nu * nd).sum(1)
228
+ AinvT = self.Ainv.transpose(1, 2) # [b, col, k]
229
+ E = self.U * D
230
+ for spin in (0, 1):
231
+ pos, same, other = (self.up, nu, nd) if spin == 0 else (self.dn, nd, nu)
232
+ tgt = self.nb[pos]
233
+ src = pos[:, :, None].expand_as(tgt)
234
+ if spin == 0:
235
+ rows = self.Wt[tgt] # (B,n,4,N)
236
+ cols = AinvT[:, :n, :][:, :, None, :] # column alpha = electron label
237
+ q = (rows * cols).sum(-1)
238
+ else:
239
+ vec = self.Wt[N + pos][:, :, None, :] # (B,n,1,N)
240
+ r = n + self.hl[bi, tgt].clamp(min=0) # (B,n,4)
241
+ q = (vec * AinvT[bi, r]).sum(-1)
242
+ jl = self.jas_single(spin, src, tgt, bi)
243
+ if self.use_dh:
244
+ ns = self._moved(same[:, None, None, :].expand(-1, n, 4, -1), src, tgt)
245
+ ot = other[:, None, None, :].expand_as(ns)
246
+ nl = self.dh_log(ns, ot) if spin == 0 else self.dh_log(ot, ns)
247
+ jl = jl + nl - self.dhl[:, None, None]
248
+ term = torch.where(same[bi, tgt] < 0.5, q * torch.exp(jl), torch.zeros_like(q)).sum((1, 2))
249
+ E = E - term if spin == 0 else E + term
250
+ return E
251
+
252
+ def pair_corr(self, chunk=64):
253
+ out = torch.zeros(self.B, dtype=DT, device=DEV)
254
+ p, p2, q, q2 = self.pidx.T
255
+ n, N = self.n, self.N
256
+ ar_n = torch.arange(n, device=DEV)
257
+ for s in range(0, self.B, chunk):
258
+ sl = slice(s, min(s + chunk, self.B)); b = sl.stop - sl.start
259
+ nu, nd, up = self.nu[sl], self.nd[sl], self.up[sl]
260
+ AinvT, h, hs, hl = self.Ainv[sl].transpose(1, 2), self.h[sl], self.hs[sl], self.hl[sl]
261
+ ok = (nu[:, p] > 0.5) & (nd[:, q] > 0.5) & (nu[:, p2] < 0.5) & (nd[:, q2] < 0.5)
262
+ eu = torch.zeros((b, N), dtype=torch.long, device=DEV); eu.scatter_(1, up, ar_n.expand(b, n).contiguous())
263
+ al = eu[:, p] # up electron label at p
264
+ rr = n + hl[:, q2].clamp(min=0) # row of the hole at q2
265
+ bb = torch.arange(b, device=DEV)[:, None]
266
+ ca, cr = AinvT[bb, al], AinvT[bb, rr] # (b,T,N) columns alpha and r of Ainv
267
+ u1 = self.Wt[p2][None] # new row for alpha
268
+ u2 = self.Wt[N + q][None] # hole moves q2 -> q
269
+ det_r = (u1 * ca).sum(-1) * (u2 * cr).sum(-1) - (u1 * cr).sum(-1) * (u2 * ca).sum(-1)
270
+ V, g, Us = self.V, self.g, self.Us
271
+ j1 = -g * (nd[:, p2] - nd[:, p]) + h[:, p2] - h[:, p] - V[p, p2]
272
+ nu2_q2 = nu[:, q2] - (q2 == p).to(DT) + (q2 == p2).to(DT)
273
+ nu2_q = nu[:, q] - (q == p).to(DT) + (q == p2).to(DT)
274
+ j2 = -g * (nu2_q2 - nu2_q) + (h[:, q2] - V[q2, p] + V[q2, p2]) - (h[:, q] - V[q, p] + V[q, p2]) - V[q, q2]
275
+ s1 = hs[:, p2] - hs[:, p] - Us[p, p2]
276
+ s2 = -((hs[:, q2] + Us[q2, p2] - Us[q2, p]) - (hs[:, q] + Us[q, p2] - Us[q, p])) - Us[q, q2]
277
+ jl = j1 + j2 + s1 + s2
278
+ if self.use_dh:
279
+ T = len(p)
280
+ nu_new = self._moved(nu[:, None, :].expand(-1, T, -1), p[None, :].expand(b, -1), p2[None, :].expand(b, -1))
281
+ nd_new = self._moved(nd[:, None, :].expand(-1, T, -1), q[None, :].expand(b, -1), q2[None, :].expand(b, -1))
282
+ jl = jl + self.dh_log(nu_new, nd_new) - self.dhl[sl][:, None]
283
+ val = torch.where(ok, self.pc * det_r * torch.exp(jl), torch.zeros_like(det_r)).sum(1)
284
+ out[sl] = -0.25 * val / N # -1: down-spin part in hole representation
285
+ return out
286
+
287
+ def log_derivs(self, keys, dPHI):
288
+ cols = []
289
+ ntot, m = self.nu + self.nd, self.nu - self.nd
290
+ if any(k in ("kd", "kh") for k in keys):
291
+ Nd, Nh = self.dh_counts(self.nu, self.nd)
292
+ AinvT = self.Ainv.transpose(1, 2)
293
+ for k in keys:
294
+ if k == "g":
295
+ cols.append(-(self.nu * self.nd).sum(1))
296
+ elif k == "kd":
297
+ cols.append(-Nd)
298
+ elif k == "kh":
299
+ cols.append(-Nh)
300
+ elif k.startswith("v"):
301
+ cols.append(0.5 * torch.einsum("bi,ij,bj->b", ntot, self.Cmat[int(k[1:])], ntot))
302
+ elif k.startswith("u"):
303
+ cols.append(0.5 * torch.einsum("bi,ij,bj->b", m, self.Cmat[int(k[1:])], m))
304
+ else:
305
+ dW = dPHI[k]
306
+ dA = torch.cat([dW[self.up], dW[self.N + self.holes]], 1)
307
+ cols.append((AinvT * dA).sum((1, 2)))
308
+ return torch.stack(cols, 1)
309
+
310
+
311
+ def main():
312
+ ap = argparse.ArgumentParser()
313
+ ap.add_argument("--L", type=int, default=6)
314
+ ap.add_argument("--Ne", type=int, default=26)
315
+ ap.add_argument("--U", type=float, default=8.0)
316
+ ap.add_argument("--Delta", type=float, default=0.2)
317
+ ap.add_argument("--ds", type=float, default=0.05)
318
+ ap.add_argument("--mu", type=float, default=0.0)
319
+ ap.add_argument("--maf", type=float, default=0.0)
320
+ ap.add_argument("--tp", type=float, default=0.0)
321
+ ap.add_argument("--g", type=float, default=1.0)
322
+ ap.add_argument("--init", default="")
323
+ ap.add_argument("--walkers", type=int, default=2048)
324
+ ap.add_argument("--ntherm", type=int, default=100)
325
+ ap.add_argument("--nmeas", type=int, default=20)
326
+ ap.add_argument("--opt", default="", help="comma list of Delta,ds,mu,maf,tp,g,jas,sjas,dh")
327
+ ap.add_argument("--iters", type=int, default=300)
328
+ ap.add_argument("--nmeas_opt", type=int, default=1)
329
+ ap.add_argument("--lr", type=float, default=0.05)
330
+ ap.add_argument("--gap", type=int, default=2, help="sweeps between SR measurements")
331
+ ap.add_argument("--pre", type=int, default=3, help="sweeps after each parameter update")
332
+ ap.add_argument("--seed", type=int, default=0)
333
+ ap.add_argument("--out", default="")
334
+ a = ap.parse_args()
335
+ t0 = time.time()
336
+ par = dict(Delta=a.Delta, ds=a.ds, mu=a.mu, maf=a.maf, tp=a.tp, g=a.g)
337
+ if a.init:
338
+ p0 = json.load(open(a.init))["result"]["par"]
339
+ par.update({k: (np.array(v) if isinstance(v, list) else v) for k, v in p0.items() if k != "a"})
340
+ import sys
341
+ for k in ("Delta", "ds", "mu", "maf", "tp", "g"): # explicit command-line values win over --init
342
+ if any(x == f"--{k}" or x.startswith(f"--{k}=") for x in sys.argv):
343
+ par[k] = getattr(a, k)
344
+ if "dh" in a.opt:
345
+ par["dh_on"] = True
346
+ vm = BatchVMC3(a.L, a.Ne, a.U, par, a.walkers, a.seed)
347
+ for s in range(a.ntherm):
348
+ vm.sweep()
349
+ if s % 10 == 0:
350
+ vm.refresh()
351
+ nv = len(vm.lat.classes)
352
+ hist = []
353
+ if a.opt:
354
+ keys = []
355
+ for k in a.opt.split(","):
356
+ keys += ([f"v{c}" for c in range(nv)] if k == "jas" else [f"u{c}" for c in range(nv)] if k == "sjas"
357
+ else ["kd", "kh"] if k == "dh" else [k])
358
+ log = open(a.out.replace(".json", ".opt.log"), "w") if a.out else None
359
+ par, hist = V2.optimize(vm, par, keys, a.iters, a.nmeas_opt, a.lr, log, gap=a.gap, pre=a.pre)
360
+ vm.set_params(par); vm.refresh()
361
+ for _ in range(20):
362
+ vm.sweep()
363
+ r = V2.measure(vm, a.nmeas)
364
+ r.update(L=a.L, Ne=a.Ne, U=a.U, opt=a.opt, pairing="ph", walkers=a.walkers,
365
+ par={k: (np.round(v, 5).tolist() if isinstance(v, np.ndarray) else (v if isinstance(v, bool) else round(float(v), 5)))
366
+ for k, v in par.items()},
367
+ sec=round(time.time() - t0, 1), engine="gpu3")
368
+ print(json.dumps(r))
369
+ if a.out:
370
+ json.dump(dict(result=r, hist=hist), open(a.out, "w"), indent=1)
371
+
372
+
373
+ if __name__ == "__main__":
374
+ main()
methods/Yuseon84/configs/vmc4x4_Ne10.json ADDED
@@ -0,0 +1,33 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.0998,
5
+ "ds": 0.00206,
6
+ "mu": -0.41572,
7
+ "maf": 0.00176,
8
+ "tp": 0.0,
9
+ "g": 1.12306,
10
+ "dh_on": true,
11
+ "v": [
12
+ -0.06788,
13
+ -0.01024,
14
+ -0.0145,
15
+ 0.02395,
16
+ 0.08593
17
+ ],
18
+ "u": [
19
+ 0.05008,
20
+ 0.00307,
21
+ 0.00473,
22
+ -0.02286,
23
+ -0.07523
24
+ ],
25
+ "kd": 0.19406,
26
+ "kh": 0.03545
27
+ },
28
+ "L": 4,
29
+ "Ne": 10,
30
+ "U": 8.0,
31
+ "source": "ph_4x4_Ne10.json"
32
+ }
33
+ }
methods/Yuseon84/configs/vmc4x4_Ne12.json ADDED
@@ -0,0 +1,33 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.12697,
5
+ "ds": 0.0205,
6
+ "mu": -0.19953,
7
+ "maf": 0.2,
8
+ "tp": 0.0,
9
+ "g": 1.28783,
10
+ "kd": 0.28079,
11
+ "kh": 0.06687,
12
+ "dh_on": true,
13
+ "v": [
14
+ -0.08859,
15
+ -0.01898,
16
+ -0.02656,
17
+ 0.00574,
18
+ 0.04997
19
+ ],
20
+ "u": [
21
+ 0.05543,
22
+ -0.01683,
23
+ 0.01772,
24
+ -0.00663,
25
+ -0.02677
26
+ ]
27
+ },
28
+ "L": 4,
29
+ "Ne": 12,
30
+ "U": 8.0,
31
+ "source": "ph4_4x4_Ne12_maf0.2.json"
32
+ }
33
+ }
methods/Yuseon84/configs/vmc4x4_Ne14.json ADDED
@@ -0,0 +1,33 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.1617,
5
+ "ds": 0.02305,
6
+ "mu": -0.39171,
7
+ "maf": 0.4,
8
+ "tp": 0.0,
9
+ "g": 1.32995,
10
+ "kd": 0.28119,
11
+ "kh": 0.12059,
12
+ "dh_on": true,
13
+ "v": [
14
+ -0.0965,
15
+ -0.00058,
16
+ -0.04149,
17
+ 0.00222,
18
+ 0.03332
19
+ ],
20
+ "u": [
21
+ 0.03165,
22
+ -0.02631,
23
+ -0.00118,
24
+ -0.00086,
25
+ -0.02519
26
+ ]
27
+ },
28
+ "L": 4,
29
+ "Ne": 14,
30
+ "U": 8.0,
31
+ "source": "ph4_4x4_Ne14_maf0.4.json"
32
+ }
33
+ }
methods/Yuseon84/configs/vmc4x4_Ne16.json ADDED
@@ -0,0 +1,33 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.21793,
5
+ "ds": 0.01463,
6
+ "mu": -0.01813,
7
+ "maf": 1.27417,
8
+ "tp": 0.0,
9
+ "g": 1.18359,
10
+ "dh_on": true,
11
+ "v": [
12
+ -0.16538,
13
+ -0.14245,
14
+ -0.15601,
15
+ -0.12525,
16
+ -0.08278
17
+ ],
18
+ "u": [
19
+ 0.04789,
20
+ -0.02247,
21
+ -0.0101,
22
+ -0.01343,
23
+ -0.02826
24
+ ],
25
+ "kd": 0.22127,
26
+ "kh": 0.22412
27
+ },
28
+ "L": 4,
29
+ "Ne": 16,
30
+ "U": 8.0,
31
+ "source": "ph_4x4_Ne16.json"
32
+ }
33
+ }
methods/Yuseon84/configs/vmc4x4_Ne8.json ADDED
@@ -0,0 +1,33 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.13307,
5
+ "ds": -0.0035,
6
+ "mu": -0.74991,
7
+ "maf": 0.00331,
8
+ "tp": 0.0,
9
+ "g": 1.03545,
10
+ "dh_on": true,
11
+ "v": [
12
+ -0.05843,
13
+ -0.02974,
14
+ 0.0094,
15
+ 0.02069,
16
+ 0.05466
17
+ ],
18
+ "u": [
19
+ 0.05041,
20
+ -0.02189,
21
+ 0.01166,
22
+ -0.01824,
23
+ -0.04192
24
+ ],
25
+ "kd": 0.12758,
26
+ "kh": 0.01025
27
+ },
28
+ "L": 4,
29
+ "Ne": 8,
30
+ "U": 8.0,
31
+ "source": "ph_4x4_Ne8.json"
32
+ }
33
+ }
methods/Yuseon84/configs/vmc6x6_Ne20.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.02563,
5
+ "ds": 0.02137,
6
+ "mu": -0.96859,
7
+ "maf": 0.0,
8
+ "tp": 0.0,
9
+ "g": 1.10282,
10
+ "dh_on": true,
11
+ "v": [
12
+ -0.07071,
13
+ -0.00896,
14
+ 0.01409,
15
+ -0.00941,
16
+ 0.0083,
17
+ 0.01897,
18
+ 0.01944,
19
+ 0.02261,
20
+ 0.02977
21
+ ],
22
+ "u": [
23
+ 0.0434,
24
+ 0.00699,
25
+ -0.00655,
26
+ 0.00034,
27
+ -0.00189,
28
+ -0.01199,
29
+ -0.00537,
30
+ -0.01172,
31
+ -0.01583
32
+ ],
33
+ "kd": 0.203,
34
+ "kh": 0.02784
35
+ },
36
+ "L": 6,
37
+ "Ne": 20,
38
+ "U": 8.0,
39
+ "source": "ph66_Ne20_maf0.0.json"
40
+ }
41
+ }
methods/Yuseon84/configs/vmc6x6_Ne22.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.02619,
5
+ "ds": 0.0219,
6
+ "mu": -0.96279,
7
+ "maf": 0.0,
8
+ "tp": 0.0,
9
+ "g": 1.15585,
10
+ "dh_on": true,
11
+ "v": [
12
+ -0.07419,
13
+ -0.00989,
14
+ 0.00981,
15
+ -0.01355,
16
+ 0.01077,
17
+ 0.01917,
18
+ 0.02564,
19
+ 0.02822,
20
+ 0.04184
21
+ ],
22
+ "u": [
23
+ 0.04465,
24
+ 0.007,
25
+ -0.00128,
26
+ 0.00554,
27
+ -0.00164,
28
+ -0.01147,
29
+ -0.00898,
30
+ -0.01758,
31
+ -0.02681
32
+ ],
33
+ "kd": 0.21836,
34
+ "kh": 0.03902
35
+ },
36
+ "L": 6,
37
+ "Ne": 22,
38
+ "U": 8.0,
39
+ "source": "ph66_Ne22_maf0.0.json"
40
+ }
41
+ }
methods/Yuseon84/configs/vmc6x6_Ne24.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.03828,
5
+ "ds": 0.02094,
6
+ "mu": -0.90513,
7
+ "maf": 0.0,
8
+ "tp": 0.0,
9
+ "g": 1.21146,
10
+ "dh_on": true,
11
+ "v": [
12
+ -0.07734,
13
+ -0.00963,
14
+ 0.00809,
15
+ -0.02051,
16
+ 0.01222,
17
+ 0.02135,
18
+ 0.03282,
19
+ 0.03904,
20
+ 0.06109
21
+ ],
22
+ "u": [
23
+ 0.05032,
24
+ 0.00825,
25
+ 0.00047,
26
+ 0.01237,
27
+ -0.0024,
28
+ -0.01123,
29
+ -0.01479,
30
+ -0.02344,
31
+ -0.04102
32
+ ],
33
+ "kd": 0.21347,
34
+ "kh": 0.05345
35
+ },
36
+ "L": 6,
37
+ "Ne": 24,
38
+ "U": 8.0,
39
+ "source": "ph66_Ne24_maf0.0.json"
40
+ }
41
+ }
methods/Yuseon84/configs/vmc6x6_Ne26.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.05392,
5
+ "ds": 0.02047,
6
+ "mu": -0.35407,
7
+ "maf": 0.0,
8
+ "tp": 0.0,
9
+ "g": 1.26641,
10
+ "dh_on": true,
11
+ "v": [
12
+ -0.07925,
13
+ -0.01033,
14
+ 0.00802,
15
+ -0.02867,
16
+ 0.01187,
17
+ 0.02424,
18
+ 0.03973,
19
+ 0.05393,
20
+ 0.08975
21
+ ],
22
+ "u": [
23
+ 0.05749,
24
+ 0.0119,
25
+ 0.00028,
26
+ 0.01901,
27
+ -0.00353,
28
+ -0.01091,
29
+ -0.02145,
30
+ -0.02849,
31
+ -0.05651
32
+ ],
33
+ "kd": 0.22743,
34
+ "kh": 0.07149
35
+ },
36
+ "L": 6,
37
+ "Ne": 26,
38
+ "U": 8.0,
39
+ "source": "ph66_Ne26_maf0.0.json"
40
+ }
41
+ }
methods/Yuseon84/configs/vmc6x6_Ne28.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.07864,
5
+ "ds": 0.02155,
6
+ "mu": -0.20928,
7
+ "maf": 0.0,
8
+ "tp": 0.0,
9
+ "g": 1.32143,
10
+ "dh_on": true,
11
+ "v": [
12
+ -0.08788,
13
+ -6e-05,
14
+ 0.02011,
15
+ -0.03368,
16
+ 0.02117,
17
+ 0.03647,
18
+ 0.04647,
19
+ 0.0579,
20
+ 0.08647
21
+ ],
22
+ "u": [
23
+ 0.05179,
24
+ 0.00981,
25
+ -0.00268,
26
+ 0.02134,
27
+ -0.00275,
28
+ -0.01113,
29
+ -0.01811,
30
+ -0.02732,
31
+ -0.04784
32
+ ],
33
+ "kd": 0.26507,
34
+ "kh": 0.09142
35
+ },
36
+ "L": 6,
37
+ "Ne": 28,
38
+ "U": 8.0,
39
+ "source": "ph66_Ne28_maf0.0.json"
40
+ }
41
+ }
methods/Yuseon84/configs/vmc6x6_Ne30.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.0848,
5
+ "ds": 0.02106,
6
+ "mu": -0.35284,
7
+ "maf": 0.3,
8
+ "tp": 0.0,
9
+ "g": 1.3178,
10
+ "dh_on": true,
11
+ "v": [
12
+ -0.08106,
13
+ 0.00758,
14
+ 0.0201,
15
+ -0.02673,
16
+ 0.02772,
17
+ 0.03987,
18
+ 0.04864,
19
+ 0.05414,
20
+ 0.07247
21
+ ],
22
+ "u": [
23
+ 0.05138,
24
+ 0.00343,
25
+ -0.00425,
26
+ 0.01844,
27
+ 0.00149,
28
+ -0.01418,
29
+ -0.02106,
30
+ -0.02245,
31
+ -0.04151
32
+ ],
33
+ "kd": 0.29551,
34
+ "kh": 0.10045
35
+ },
36
+ "L": 6,
37
+ "Ne": 30,
38
+ "U": 8.0,
39
+ "source": "ph66_Ne30_maf0.3.json"
40
+ }
41
+ }
methods/Yuseon84/configs/vmc6x6_Ne32.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.09129,
5
+ "ds": 0.0218,
6
+ "mu": -0.60162,
7
+ "maf": 0.6,
8
+ "tp": 0.0,
9
+ "g": 1.25719,
10
+ "dh_on": true,
11
+ "v": [
12
+ -0.0668,
13
+ 0.01378,
14
+ 0.02051,
15
+ -0.01795,
16
+ 0.03128,
17
+ 0.0414,
18
+ 0.04698,
19
+ 0.04866,
20
+ 0.05767
21
+ ],
22
+ "u": [
23
+ 0.04554,
24
+ -0.00241,
25
+ -0.00601,
26
+ 0.01561,
27
+ 0.0035,
28
+ -0.01424,
29
+ -0.02091,
30
+ -0.01689,
31
+ -0.03178
32
+ ],
33
+ "kd": 0.32208,
34
+ "kh": 0.10534
35
+ },
36
+ "L": 6,
37
+ "Ne": 32,
38
+ "U": 8.0,
39
+ "source": "ph66_Ne32_maf0.6.json"
40
+ }
41
+ }
methods/Yuseon84/configs/vmc6x6_Ne34.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.10888,
5
+ "ds": 0.02288,
6
+ "mu": -0.84637,
7
+ "maf": 0.9,
8
+ "tp": 0.0,
9
+ "g": 1.16985,
10
+ "dh_on": true,
11
+ "v": [
12
+ -0.05133,
13
+ 0.01513,
14
+ 0.02204,
15
+ -0.01258,
16
+ 0.03235,
17
+ 0.04347,
18
+ 0.04807,
19
+ 0.04994,
20
+ 0.05347
21
+ ],
22
+ "u": [
23
+ 0.03781,
24
+ -0.00965,
25
+ -0.01007,
26
+ 0.01092,
27
+ 0.00386,
28
+ -0.01313,
29
+ -0.01525,
30
+ -0.00916,
31
+ -0.01883
32
+ ],
33
+ "kd": 0.33596,
34
+ "kh": 0.11978
35
+ },
36
+ "L": 6,
37
+ "Ne": 34,
38
+ "U": 8.0,
39
+ "source": "ph66_Ne34_maf0.9.json"
40
+ }
41
+ }
methods/Yuseon84/configs/vmc6x6_Ne36.json ADDED
@@ -0,0 +1,41 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "result": {
3
+ "par": {
4
+ "Delta": 0.19659,
5
+ "ds": 0.04048,
6
+ "mu": -0.05666,
7
+ "maf": 1.6,
8
+ "tp": 0.0,
9
+ "g": 1.08013,
10
+ "dh_on": true,
11
+ "v": [
12
+ -0.05132,
13
+ -0.00532,
14
+ 0.01459,
15
+ -0.03448,
16
+ 0.01007,
17
+ 0.03116,
18
+ 0.0414,
19
+ 0.05586,
20
+ 0.06954
21
+ ],
22
+ "u": [
23
+ 0.05813,
24
+ -0.00466,
25
+ -0.00206,
26
+ 0.00417,
27
+ -0.00046,
28
+ -0.01494,
29
+ -0.01559,
30
+ -0.00803,
31
+ -0.01631
32
+ ],
33
+ "kd": 0.21062,
34
+ "kh": 0.2192
35
+ },
36
+ "L": 6,
37
+ "Ne": 36,
38
+ "U": 8.0,
39
+ "source": "ph66_Ne36_maf1.6.json"
40
+ }
41
+ }
methods/Yuseon84/expected/ed4x4_Ne10_U8.json ADDED
@@ -0,0 +1,25 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ [
2
+ {
3
+ "L": 4,
4
+ "Ne": 10,
5
+ "n": 0.625,
6
+ "U": 8.0,
7
+ "E0": -17.51036669487872,
8
+ "deg": 1,
9
+ "dim": 19079424,
10
+ "lowest": [
11
+ -17.51036669,
12
+ -16.41072802,
13
+ -16.41072802,
14
+ -16.40185429,
15
+ -16.40185429,
16
+ -15.94180026
17
+ ],
18
+ "Pd": {
19
+ "2,2": 0.060122,
20
+ "1,1": -0.02086,
21
+ "2,0": 0.11386
22
+ },
23
+ "sec": 760.7
24
+ }
25
+ ]
methods/Yuseon84/expected/ed4x4_Ne12_U8.json ADDED
@@ -0,0 +1,118 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "L": 4,
3
+ "Ne": 12,
4
+ "n": 0.75,
5
+ "U": 8.0,
6
+ "E0": -14.925310215108421,
7
+ "deg": 2,
8
+ "R": [
9
+ 2,
10
+ 2
11
+ ],
12
+ "Pd": 0.009831,
13
+ "manifold": [
14
+ {
15
+ "k": [
16
+ 0,
17
+ 0
18
+ ],
19
+ "mult": 1,
20
+ "Pd": -0.0038063
21
+ },
22
+ {
23
+ "k": [
24
+ 2,
25
+ 2
26
+ ],
27
+ "mult": 1,
28
+ "Pd": 0.02346846
29
+ }
30
+ ],
31
+ "sectors": [
32
+ {
33
+ "k": [
34
+ 0,
35
+ 0
36
+ ],
37
+ "mult": 1,
38
+ "E": [
39
+ -14.92531022,
40
+ -14.88407343,
41
+ -14.8628084,
42
+ -14.75289456,
43
+ -14.75289456
44
+ ]
45
+ },
46
+ {
47
+ "k": [
48
+ 0,
49
+ 1
50
+ ],
51
+ "mult": 4,
52
+ "E": [
53
+ -14.3356551,
54
+ -14.33138874,
55
+ -14.32786361,
56
+ -14.22099077,
57
+ -14.18839612
58
+ ]
59
+ },
60
+ {
61
+ "k": [
62
+ 0,
63
+ 2
64
+ ],
65
+ "mult": 2,
66
+ "E": [
67
+ -14.8628084,
68
+ -14.83539165,
69
+ -14.73233341,
70
+ -14.06807973,
71
+ -13.8609654
72
+ ]
73
+ },
74
+ {
75
+ "k": [
76
+ 1,
77
+ 1
78
+ ],
79
+ "mult": 4,
80
+ "E": [
81
+ -14.83855246,
82
+ -14.83539165,
83
+ -14.75289456,
84
+ -14.06807973,
85
+ -13.74777826
86
+ ]
87
+ },
88
+ {
89
+ "k": [
90
+ 1,
91
+ 2
92
+ ],
93
+ "mult": 4,
94
+ "E": [
95
+ -14.4413513,
96
+ -14.3356551,
97
+ -14.33138874,
98
+ -14.22099077,
99
+ -14.16796227
100
+ ]
101
+ },
102
+ {
103
+ "k": [
104
+ 2,
105
+ 2
106
+ ],
107
+ "mult": 1,
108
+ "E": [
109
+ -14.92531022,
110
+ -14.88407343,
111
+ -14.83855246,
112
+ -14.83855246,
113
+ -14.73233341
114
+ ]
115
+ }
116
+ ],
117
+ "sec": 294.4
118
+ }
methods/Yuseon84/expected/ed4x4_Ne14_U8.json ADDED
@@ -0,0 +1,118 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "L": 4,
3
+ "Ne": 14,
4
+ "n": 0.875,
5
+ "U": 8.0,
6
+ "E0": -11.868835569563847,
7
+ "deg": 3,
8
+ "R": [
9
+ 2,
10
+ 2
11
+ ],
12
+ "Pd": 0.019219,
13
+ "manifold": [
14
+ {
15
+ "k": [
16
+ 0,
17
+ 0
18
+ ],
19
+ "mult": 1,
20
+ "Pd": 0.02313437
21
+ },
22
+ {
23
+ "k": [
24
+ 0,
25
+ 2
26
+ ],
27
+ "mult": 2,
28
+ "Pd": 0.01726132
29
+ }
30
+ ],
31
+ "sectors": [
32
+ {
33
+ "k": [
34
+ 0,
35
+ 0
36
+ ],
37
+ "mult": 1,
38
+ "E": [
39
+ -11.86883557,
40
+ -11.67827698,
41
+ -11.67827698,
42
+ -11.57364559,
43
+ -11.47497089
44
+ ]
45
+ },
46
+ {
47
+ "k": [
48
+ 0,
49
+ 1
50
+ ],
51
+ "mult": 4,
52
+ "E": [
53
+ -11.35927592,
54
+ -11.33489502,
55
+ -11.29014245,
56
+ -11.24306586,
57
+ -11.21389222
58
+ ]
59
+ },
60
+ {
61
+ "k": [
62
+ 0,
63
+ 2
64
+ ],
65
+ "mult": 2,
66
+ "E": [
67
+ -11.86883557,
68
+ -11.77617927,
69
+ -11.71327391,
70
+ -11.56367048,
71
+ -11.49536334
72
+ ]
73
+ },
74
+ {
75
+ "k": [
76
+ 1,
77
+ 1
78
+ ],
79
+ "mult": 4,
80
+ "E": [
81
+ -11.82490062,
82
+ -11.77617927,
83
+ -11.67827698,
84
+ -11.56367048,
85
+ -11.49536334
86
+ ]
87
+ },
88
+ {
89
+ "k": [
90
+ 1,
91
+ 2
92
+ ],
93
+ "mult": 4,
94
+ "E": [
95
+ -11.35927592,
96
+ -11.33489502,
97
+ -11.29014245,
98
+ -11.24306586,
99
+ -11.21389222
100
+ ]
101
+ },
102
+ {
103
+ "k": [
104
+ 2,
105
+ 2
106
+ ],
107
+ "mult": 1,
108
+ "E": [
109
+ -11.82490062,
110
+ -11.82490062,
111
+ -11.71327391,
112
+ -11.47497089,
113
+ -11.40301738
114
+ ]
115
+ }
116
+ ],
117
+ "sec": 540.6
118
+ }
methods/Yuseon84/expected/ed4x4_Ne16_U8.json ADDED
@@ -0,0 +1,110 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "L": 4,
3
+ "Ne": 16,
4
+ "n": 1.0,
5
+ "U": 8.0,
6
+ "E0": -8.468875014196751,
7
+ "deg": 1,
8
+ "R": [
9
+ 2,
10
+ 2
11
+ ],
12
+ "Pd": 0.006197,
13
+ "manifold": [
14
+ {
15
+ "k": [
16
+ 0,
17
+ 0
18
+ ],
19
+ "mult": 1,
20
+ "Pd": 0.00619709
21
+ }
22
+ ],
23
+ "sectors": [
24
+ {
25
+ "k": [
26
+ 0,
27
+ 0
28
+ ],
29
+ "mult": 1,
30
+ "E": [
31
+ -8.46887501,
32
+ -7.9075633,
33
+ -7.25888668,
34
+ -7.06223958,
35
+ -6.93742613
36
+ ]
37
+ },
38
+ {
39
+ "k": [
40
+ 0,
41
+ 1
42
+ ],
43
+ "mult": 4,
44
+ "E": [
45
+ -7.5392478,
46
+ -7.15783147,
47
+ -7.14422761,
48
+ -6.98852848,
49
+ -6.87194204
50
+ ]
51
+ },
52
+ {
53
+ "k": [
54
+ 0,
55
+ 2
56
+ ],
57
+ "mult": 2,
58
+ "E": [
59
+ -7.51900567,
60
+ -7.25888668,
61
+ -7.09123866,
62
+ -7.03622823,
63
+ -6.93742613
64
+ ]
65
+ },
66
+ {
67
+ "k": [
68
+ 1,
69
+ 1
70
+ ],
71
+ "mult": 4,
72
+ "E": [
73
+ -7.51900567,
74
+ -7.25007145,
75
+ -7.09123866,
76
+ -7.06223958,
77
+ -6.85660296
78
+ ]
79
+ },
80
+ {
81
+ "k": [
82
+ 1,
83
+ 2
84
+ ],
85
+ "mult": 4,
86
+ "E": [
87
+ -7.52722462,
88
+ -7.18256276,
89
+ -7.15783147,
90
+ -6.98852848,
91
+ -6.84011944
92
+ ]
93
+ },
94
+ {
95
+ "k": [
96
+ 2,
97
+ 2
98
+ ],
99
+ "mult": 1,
100
+ "E": [
101
+ -8.28491503,
102
+ -7.31024296,
103
+ -7.25007145,
104
+ -7.25007145,
105
+ -7.03622823
106
+ ]
107
+ }
108
+ ],
109
+ "sec": 327.8
110
+ }
methods/Yuseon84/expected/ed4x4_Ne8_U8.json ADDED
@@ -0,0 +1,112 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "L": 4,
3
+ "Ne": 8,
4
+ "n": 0.5,
5
+ "U": 8.0,
6
+ "E0": -16.46062675368178,
7
+ "deg": 3,
8
+ "R": [
9
+ 2,
10
+ 2
11
+ ],
12
+ "Pd": 0.048076,
13
+ "manifold": [
14
+ {
15
+ "k": [
16
+ 0,
17
+ 0
18
+ ],
19
+ "mult": 1,
20
+ "Pd": 0.07258846
21
+ },
22
+ {
23
+ "k": [
24
+ 0,
25
+ 2
26
+ ],
27
+ "mult": 2,
28
+ "Pd": 0.03581966
29
+ }
30
+ ],
31
+ "sectors": [
32
+ {
33
+ "k": [
34
+ 0,
35
+ 0
36
+ ],
37
+ "mult": 1,
38
+ "E": [
39
+ -16.46062675,
40
+ -16.33833138,
41
+ -16.33833138,
42
+ -15.68310244
43
+ ]
44
+ },
45
+ {
46
+ "k": [
47
+ 0,
48
+ 1
49
+ ],
50
+ "mult": 4,
51
+ "E": [
52
+ -15.44748473,
53
+ -15.29925513,
54
+ -15.29725162,
55
+ -15.18959721
56
+ ]
57
+ },
58
+ {
59
+ "k": [
60
+ 0,
61
+ 2
62
+ ],
63
+ "mult": 2,
64
+ "E": [
65
+ -16.46062675,
66
+ -15.8787787,
67
+ -14.42873422,
68
+ -14.26722188
69
+ ]
70
+ },
71
+ {
72
+ "k": [
73
+ 1,
74
+ 1
75
+ ],
76
+ "mult": 4,
77
+ "E": [
78
+ -16.33833138,
79
+ -15.8787787,
80
+ -14.26722188,
81
+ -14.21673546
82
+ ]
83
+ },
84
+ {
85
+ "k": [
86
+ 1,
87
+ 2
88
+ ],
89
+ "mult": 4,
90
+ "E": [
91
+ -15.29925513,
92
+ -15.29725162,
93
+ -15.18959721,
94
+ -15.18567228
95
+ ]
96
+ },
97
+ {
98
+ "k": [
99
+ 2,
100
+ 2
101
+ ],
102
+ "mult": 1,
103
+ "E": [
104
+ -14.22849099,
105
+ -14.21631143,
106
+ -14.09362039,
107
+ -14.09167066
108
+ ]
109
+ }
110
+ ],
111
+ "sec": 18.9
112
+ }
methods/Yuseon84/expected/vmc4x4_vs_ed.json ADDED
@@ -0,0 +1,52 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ [
2
+ {
3
+ "Ne": 8,
4
+ "E_ed": -16.460627,
5
+ "E_vmc": -16.3102,
6
+ "rel_err": 0.0091,
7
+ "Pd_ed_avg": 0.048076,
8
+ "Pd_ed_k00": 0.07259,
9
+ "Pd_vmc": 0.07555,
10
+ "maf": 0.00331
11
+ },
12
+ {
13
+ "Ne": 10,
14
+ "E_ed": -17.510367,
15
+ "E_vmc": -17.3019,
16
+ "rel_err": 0.0119,
17
+ "Pd_ed_avg": 0.060122,
18
+ "Pd_ed_k00": 0.06012,
19
+ "Pd_vmc": 0.06793,
20
+ "maf": 0.00176
21
+ },
22
+ {
23
+ "Ne": 12,
24
+ "E_ed": -14.92531,
25
+ "E_vmc": -14.3907,
26
+ "rel_err": 0.0358,
27
+ "Pd_ed_avg": 0.009831,
28
+ "Pd_ed_k00": -0.00381,
29
+ "Pd_vmc": 0.03555,
30
+ "maf": 0.2
31
+ },
32
+ {
33
+ "Ne": 14,
34
+ "E_ed": -11.868836,
35
+ "E_vmc": -11.183,
36
+ "rel_err": 0.0578,
37
+ "Pd_ed_avg": 0.019219,
38
+ "Pd_ed_k00": 0.02313,
39
+ "Pd_vmc": 0.03911,
40
+ "maf": 0.4
41
+ },
42
+ {
43
+ "Ne": 16,
44
+ "E_ed": -8.468875,
45
+ "E_vmc": -8.083,
46
+ "rel_err": 0.0456,
47
+ "Pd_ed_avg": 0.006197,
48
+ "Pd_ed_k00": 0.0062,
49
+ "Pd_vmc": 0.00752,
50
+ "maf": 1.27417
51
+ }
52
+ ]
methods/Yuseon84/expected/vmc6x6_best_by_energy.json ADDED
@@ -0,0 +1,74 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "20": {
3
+ "E": -38.3005695842542,
4
+ "dE": 0.006270137991131296,
5
+ "Pd": 0.02008639466157071,
6
+ "dPd": 0.00028052080302624796,
7
+ "maf": 0.0,
8
+ "source": "ph66_Ne20_maf0.0.json"
9
+ },
10
+ "22": {
11
+ "E": -37.68977199064044,
12
+ "dE": 0.007259278422438216,
13
+ "Pd": 0.033899358015224465,
14
+ "dPd": 0.0003107759755719417,
15
+ "maf": 0.0,
16
+ "source": "ph66_Ne22_maf0.0.json"
17
+ },
18
+ "24": {
19
+ "E": -36.561666722737314,
20
+ "dE": 0.008338323087734176,
21
+ "Pd": 0.04018249120571718,
22
+ "dPd": 0.0003484341780663236,
23
+ "maf": 0.0,
24
+ "source": "ph66_Ne24_maf0.0.json"
25
+ },
26
+ "26": {
27
+ "E": -34.97095304685092,
28
+ "dE": 0.009137964514652168,
29
+ "Pd": 0.0342057311776723,
30
+ "dPd": 0.0003375585635617882,
31
+ "maf": 0.0,
32
+ "source": "ph66_Ne26_maf0.0.json"
33
+ },
34
+ "28": {
35
+ "E": -31.61765323295314,
36
+ "dE": 0.01122834776441649,
37
+ "Pd": 0.046465550630268235,
38
+ "dPd": 0.0004690586698101234,
39
+ "maf": 0.0,
40
+ "source": "ph66_Ne28_maf0.0.json"
41
+ },
42
+ "30": {
43
+ "E": -28.141432253114214,
44
+ "dE": 0.01125973117089022,
45
+ "Pd": 0.04373579685905692,
46
+ "dPd": 0.0005372427188067283,
47
+ "maf": 0.3,
48
+ "source": "ph66_Ne30_maf0.3.json"
49
+ },
50
+ "32": {
51
+ "E": -24.748089601854286,
52
+ "dE": 0.01127131858409921,
53
+ "Pd": 0.04058475931382825,
54
+ "dPd": 0.0007236902621490548,
55
+ "maf": 0.6,
56
+ "source": "ph66_Ne32_maf0.6.json"
57
+ },
58
+ "34": {
59
+ "E": -21.487404241108198,
60
+ "dE": 0.010254962615421907,
61
+ "Pd": 0.031059343293219233,
62
+ "dPd": 0.0006024544428974737,
63
+ "maf": 0.9,
64
+ "source": "ph66_Ne34_maf0.9.json"
65
+ },
66
+ "36": {
67
+ "E": -18.398476933684087,
68
+ "dE": 0.0071129092364388274,
69
+ "Pd": 0.0042034371053786546,
70
+ "dPd": 0.0008391372121750209,
71
+ "maf": 1.6,
72
+ "source": "ph66_Ne36_maf1.6.json"
73
+ }
74
+ }
methods/Yuseon84/run_delta0.sh ADDED
@@ -0,0 +1,14 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #!/bin/bash
2
+ # Reproduces the two delta = 0 (half filling, U/t = 8) numbers cited in Discussion #56.
3
+ # (1) 4x4 ED, Ne = 16, R = (2,2): P_d = 0.006197 (manifold average; matches validation/comparison_4x4_ED_vs_VMC.md)
4
+ # -> needs a CUDA GPU for the matvec (about 1 h on an RTX 3060 Ti); expected: expected/ed4x4_Ne16_U8.json
5
+ # (2) 6x6 VMC, Ne = 36, R = (3,3), lowest-energy Neel-field state, three seeds: P_d = 0.0049 +/- 0.0007
6
+ # -> a few minutes per seed on the GPU; expected: expected/vmc6x6_best_by_energy.json (entry "36")
7
+ set -e; cd "$(dirname "$0")/code"; mkdir -p ../out ../sectors
8
+ python ed_ksector_gpu.py --Ne 16 --save ../sectors
9
+ python ed_ksector.py --Ne 16 --combine --save ../sectors --out ../out/ed4x4_Ne16_U8.json
10
+ m=$(python -c "import json;print(json.load(open('../configs/vmc6x6_Ne36.json'))['result']['par']['maf'])")
11
+ for s in 1 2 3; do
12
+ python vmc_gpu3.py --L 6 --Ne 36 --U 8 --init ../configs/vmc6x6_Ne36.json --maf $m \
13
+ --ntherm 1500 --nmeas 40 --walkers 2048 --seed $s --out ../out/vmc6x6_Ne36_seed$s.json
14
+ done
methods/Yuseon84/run_ed_4x4.sh ADDED
@@ -0,0 +1,7 @@
 
 
 
 
 
 
 
 
1
+ #!/bin/bash
2
+ # Reproduces the five 4x4 ED reference values (U/t=8, R=(2,2), equal-weight manifold average) -> expected/ed4x4_Ne*_U8.json
3
+ # CPU only is fine for Ne<=12 (minutes); Ne=14,16 use the GPU matvec (about 1 h on an RTX 3060 Ti).
4
+ set -e; cd "$(dirname "$0")/code"; mkdir -p ../out ../sectors
5
+ for Ne in 8 10 12; do python ed_ksector.py --Ne $Ne --out ../out/ed4x4_Ne${Ne}_U8.json; done
6
+ for Ne in 14 16; do python ed_ksector_gpu.py --Ne $Ne --save ../sectors; python ed_ksector.py --Ne $Ne --combine --save ../sectors --out ../out/ed4x4_Ne${Ne}_U8.json; done
7
+ python ed_hubbard.py --help >/dev/null # independent no-symmetry cross-check code (Ne<=10), see README
methods/Yuseon84/run_free.sh ADDED
@@ -0,0 +1,4 @@
 
 
 
 
 
1
+ #!/bin/bash
2
+ # Exact U=0 pair correlation with degenerate-shell averaging: 4x4 (normalization check) and 6x6 (shell decomposition of A_d).
3
+ set -e; cd "$(dirname "$0")/code"; mkdir -p ../out
4
+ python pd_free.py > ../out/pd_free_4x4.txt; python pd_free66.py > ../out/pd_free_6x6.txt
methods/Yuseon84/run_vmc_4x4.sh ADDED
@@ -0,0 +1,8 @@
 
 
 
 
 
 
 
 
 
1
+ #!/bin/bash
2
+ # Measures the frozen improved-ansatz states (configs/) on 4x4 and compares with ED (expected/vmc4x4_vs_ed.json).
3
+ # Independent-seed robustness: three seeds per filling.
4
+ set -e; cd "$(dirname "$0")/code"; mkdir -p ../out
5
+ for Ne in 8 10 12 14 16; do for s in 1 2 3; do
6
+ python vmc_gpu3.py --L 4 --Ne $Ne --U 8 --init ../configs/vmc4x4_Ne${Ne}.json --maf $(python -c "import json;print(json.load(open('../configs/vmc4x4_Ne${Ne}.json'))['result']['par']['maf'])") \
7
+ --ntherm 1500 --nmeas 40 --walkers 2048 --seed $s --out ../out/vmc4x4_Ne${Ne}_seed$s.json
8
+ done; done
methods/Yuseon84/run_vmc_6x6_seeds.sh ADDED
@@ -0,0 +1,9 @@
 
 
 
 
 
 
 
 
 
 
1
+ #!/bin/bash
2
+ # Re-measures the frozen lowest-energy 6x6 states (configs/vmc6x6_Ne*.json) with independent seeds 2 and 3.
3
+ set -e; cd "$(dirname "$0")/code"; mkdir -p ../out
4
+ for Ne in 36 34 32 30 28 26 24 22 20; do for s in 2 3; do
5
+ m=$(python -c "import json;print(json.load(open('../configs/vmc6x6_Ne${Ne}.json'))['result']['par']['maf'])")
6
+ python vmc_gpu3.py --L 6 --Ne $Ne --U 8 --init ../configs/vmc6x6_Ne${Ne}.json --maf $m \
7
+ --ntherm 1500 --nmeas 40 --walkers 2048 --seed $s --out ../out/vmc6x6_Ne${Ne}_seed$s.json
8
+ done; done
9
+ echo SEEDS_DONE