guldo-cli 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- guldo/__init__.py +0 -0
- guldo/_src/COMPILER.md +329 -0
- guldo/_src/DEPLOY.md +200 -0
- guldo/_src/LAUNCH.md +85 -0
- guldo/_src/PROTOCOL.md +294 -0
- guldo/_src/RULES.md +25 -0
- guldo/_src/SUBMIT.md +170 -0
- guldo/_src/__init__.py +0 -0
- guldo/_src/attest.py +257 -0
- guldo/_src/build_site.py +958 -0
- guldo/_src/bundle_templates/check.py +1382 -0
- guldo/_src/bundle_templates/qcheck.py +253 -0
- guldo/_src/bundle_templates/qscore.py +402 -0
- guldo/_src/bundle_templates/score.py +649 -0
- guldo/_src/certificate.py +828 -0
- guldo/_src/certs_site.py +108 -0
- guldo/_src/claims.py +343 -0
- guldo/_src/compile_domain.py +1312 -0
- guldo/_src/compile_quality.py +286 -0
- guldo/_src/count_runner.py +248 -0
- guldo/_src/counted.py +274 -0
- guldo/_src/declared.py +215 -0
- guldo/_src/deploy/Caddyfile +48 -0
- guldo/_src/deploy/ledger-backup.service +9 -0
- guldo/_src/deploy/ledger-backup.sh +73 -0
- guldo/_src/deploy/ledger-backup.timer +10 -0
- guldo/_src/deploy/ledger-export.service +12 -0
- guldo/_src/deploy/ledger-export.timer +9 -0
- guldo/_src/deploy/ledger-web.service +38 -0
- guldo/_src/deploy/pin_cpu.sh +34 -0
- guldo/_src/deploy/provision_eval.sh +128 -0
- guldo/_src/deploy_smoke.py +148 -0
- guldo/_src/dlog_experiment.py +165 -0
- guldo/_src/domains/aidecode/compiled.json +586 -0
- guldo/_src/domains/aidecode/decl.py +134 -0
- guldo/_src/domains/aidecode/reference.py +73 -0
- guldo/_src/domains/aiinfer/compiled.json +722 -0
- guldo/_src/domains/aiinfer/decl.py +91 -0
- guldo/_src/domains/aiinfer/reference.py +42 -0
- guldo/_src/domains/dlog/compiled.json +248 -0
- guldo/_src/domains/dlog/decl.py +41 -0
- guldo/_src/domains/dlog/reference.py +10 -0
- guldo/_src/domains/maxcut/compiled.json +291 -0
- guldo/_src/domains/maxcut/decl.py +46 -0
- guldo/_src/domains/maxcut/reference.py +16 -0
- guldo/_src/drift_check.py +89 -0
- guldo/_src/export_bundle.py +750 -0
- guldo/_src/extrapolate.py +326 -0
- guldo/_src/families.py +53 -0
- guldo/_src/gen_cheat_table.py +36 -0
- guldo/_src/gpu_meter.py +634 -0
- guldo/_src/gpu_runner.py +63 -0
- guldo/_src/harness.py +273 -0
- guldo/_src/instances.py +86 -0
- guldo/_src/instances_factor.py +40 -0
- guldo/_src/instances_mlwe.py +69 -0
- guldo/_src/judge.py +278 -0
- guldo/_src/limits_plan.py +158 -0
- guldo/_src/official.py +189 -0
- guldo/_src/ops.py +281 -0
- guldo/_src/portal.py +313 -0
- guldo/_src/portal_core.py +57 -0
- guldo/_src/power.py +174 -0
- guldo/_src/prereg.py +173 -0
- guldo/_src/public_portal.py +500 -0
- guldo/_src/quality_core.py +126 -0
- guldo/_src/recheck.py +236 -0
- guldo/_src/remeasure.py +88 -0
- guldo/_src/report_html.py +493 -0
- guldo/_src/results/.keep +0 -0
- guldo/_src/rounds.py +846 -0
- guldo/_src/runner.py +52 -0
- guldo/_src/sandbox/Dockerfile +11 -0
- guldo/_src/sandbox/Dockerfile.v2 +19 -0
- guldo/_src/sandbox/README.md +40 -0
- guldo/_src/sandbox/linux_selftest.py +117 -0
- guldo/_src/sandbox/meter.py +89 -0
- guldo/_src/sandbox/meter_core.py +28 -0
- guldo/_src/site_assets.py +176 -0
- guldo/_src/site_live_check.py +79 -0
- guldo/_src/solvers/aidecode_flops_kv.py +73 -0
- guldo/_src/solvers/aidecode_flops_lossy.py +73 -0
- guldo/_src/solvers/aidecode_flops_ref.py +64 -0
- guldo/_src/solvers/aidecode_kv.py +76 -0
- guldo/_src/solvers/aidecode_kv_f32.py +77 -0
- guldo/_src/solvers/aidecode_lossy.py +76 -0
- guldo/_src/solvers/aidecode_repeat.py +5 -0
- guldo/_src/solvers/aiinfer_batched.py +40 -0
- guldo/_src/solvers/aiinfer_f32.py +41 -0
- guldo/_src/solvers/aiinfer_gpu_batched.py +42 -0
- guldo/_src/solvers/aiinfer_gpu_ref.py +45 -0
- guldo/_src/solvers/aiinfer_lossy.py +42 -0
- guldo/_src/solvers/baseline_bkz.py +14 -0
- guldo/_src/solvers/cheat_lookup.py +24 -0
- guldo/_src/solvers/cheat_table.json +1 -0
- guldo/_src/solvers/cheat_table_v1_stale.json +1 -0
- guldo/_src/solvers/daemon_cpu_hider.py +17 -0
- guldo/_src/solvers/dlog_bsgs.py +19 -0
- guldo/_src/solvers/dlog_stride4.py +18 -0
- guldo/_src/solvers/egg_base.py +11 -0
- guldo/_src/solvers/egg_eightaxis.py +68 -0
- guldo/_src/solvers/egg_template.py +11 -0
- guldo/_src/solvers/factor_brent.py +34 -0
- guldo/_src/solvers/factor_floyd.py +19 -0
- guldo/_src/solvers/factor_trial_fast_py.py +21 -0
- guldo/_src/solvers/factor_trial_np.py +21 -0
- guldo/_src/solvers/factor_trial_py.py +12 -0
- guldo/_src/solvers/fixed_overhead_ref.py +21 -0
- guldo/_src/solvers/fork_bomb.py +18 -0
- guldo/_src/solvers/gpu_noop.py +6 -0
- guldo/_src/solvers/hostile_probe.py +36 -0
- guldo/_src/solvers/kill_meter.py +27 -0
- guldo/_src/solvers/memory_bomb.py +10 -0
- guldo/_src/solvers/noop.py +5 -0
- guldo/_src/solvers/orphan_cpu_hider.py +16 -0
- guldo/_src/solvers/planted_peek.py +23 -0
- guldo/_src/solvers/sleeping_daemon_hang.py +12 -0
- guldo/_src/solvers/small_n_trick.py +22 -0
- guldo/_src/solvers/starter_template.py +21 -0
- guldo/_src/solvers/stdout_flood.py +9 -0
- guldo/_src/solvers/tmp_fill.py +10 -0
- guldo/_src/solvers/tuned_bkz.py +25 -0
- guldo/_src/static_check.py +214 -0
- guldo/_src/submit_check.py +166 -0
- guldo/_src/svp.py +889 -0
- guldo/_src/tensorops.py +304 -0
- guldo/_src/tflops.py +453 -0
- guldo/_src/tflops_runner.py +134 -0
- guldo/cli.py +60 -0
- guldo_cli-0.1.0.dist-info/METADATA +30 -0
- guldo_cli-0.1.0.dist-info/RECORD +134 -0
- guldo_cli-0.1.0.dist-info/WHEEL +5 -0
- guldo_cli-0.1.0.dist-info/entry_points.txt +2 -0
- guldo_cli-0.1.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,291 @@
|
|
|
1
|
+
{
|
|
2
|
+
"compiled_at": "2026-11-21T18:37:23Z",
|
|
3
|
+
"compiler_sha256": "d8d6d8d7fe4f039a849630ce9ef477ce82c016ba4345d0e6c455d6d00d5f4b1b",
|
|
4
|
+
"decl_sha256": "b90531dcb8e42c6561a669944c02c9a7a73c553517a06940122db165da83a026",
|
|
5
|
+
"dims": [
|
|
6
|
+
60,
|
|
7
|
+
120,
|
|
8
|
+
180,
|
|
9
|
+
240,
|
|
10
|
+
300
|
|
11
|
+
],
|
|
12
|
+
"format": "svp-compiled-v1",
|
|
13
|
+
"kind": "quality",
|
|
14
|
+
"name": "maxcut",
|
|
15
|
+
"official": {
|
|
16
|
+
"budget": 5.0,
|
|
17
|
+
"n": 12
|
|
18
|
+
},
|
|
19
|
+
"practice_dims": [
|
|
20
|
+
60,
|
|
21
|
+
120
|
|
22
|
+
],
|
|
23
|
+
"quality": {
|
|
24
|
+
"budget": 5.0,
|
|
25
|
+
"cpu_hours": {
|
|
26
|
+
"reference_expected": 0.0,
|
|
27
|
+
"worst_case": 0.5
|
|
28
|
+
},
|
|
29
|
+
"headroom_mean_cap": 0.95,
|
|
30
|
+
"min_gain": 0.02,
|
|
31
|
+
"notes": [],
|
|
32
|
+
"power": {
|
|
33
|
+
"boot": 60,
|
|
34
|
+
"curve": {
|
|
35
|
+
"0.0": {
|
|
36
|
+
"all_seeds": 0.0,
|
|
37
|
+
"single": 0.0
|
|
38
|
+
},
|
|
39
|
+
"0.01": {
|
|
40
|
+
"all_seeds": 0.0,
|
|
41
|
+
"single": 0.0
|
|
42
|
+
},
|
|
43
|
+
"0.02": {
|
|
44
|
+
"all_seeds": 0.0,
|
|
45
|
+
"single": 0.1
|
|
46
|
+
},
|
|
47
|
+
"0.03": {
|
|
48
|
+
"all_seeds": 0.933,
|
|
49
|
+
"single": 0.978
|
|
50
|
+
},
|
|
51
|
+
"0.04": {
|
|
52
|
+
"all_seeds": 1.0,
|
|
53
|
+
"single": 1.0
|
|
54
|
+
},
|
|
55
|
+
"0.06": {
|
|
56
|
+
"all_seeds": 1.0,
|
|
57
|
+
"single": 1.0
|
|
58
|
+
},
|
|
59
|
+
"0.1": {
|
|
60
|
+
"all_seeds": 1.0,
|
|
61
|
+
"single": 1.0
|
|
62
|
+
},
|
|
63
|
+
"0.2": {
|
|
64
|
+
"all_seeds": 1.0,
|
|
65
|
+
"single": 1.0
|
|
66
|
+
}
|
|
67
|
+
},
|
|
68
|
+
"max_certifiable": 0.2,
|
|
69
|
+
"min_certifiable": 0.03,
|
|
70
|
+
"n": 12,
|
|
71
|
+
"noise": 0.02,
|
|
72
|
+
"noise_assumed": true,
|
|
73
|
+
"notes": [],
|
|
74
|
+
"target_effect": 0.04,
|
|
75
|
+
"target_power": 0.8,
|
|
76
|
+
"threshold": 0.02,
|
|
77
|
+
"trials": 30,
|
|
78
|
+
"tried": {
|
|
79
|
+
"12": 1.0
|
|
80
|
+
}
|
|
81
|
+
},
|
|
82
|
+
"profile": {
|
|
83
|
+
"k": 8,
|
|
84
|
+
"median_cpu": {
|
|
85
|
+
"120": 0.022,
|
|
86
|
+
"180": 0.024,
|
|
87
|
+
"240": 0.022,
|
|
88
|
+
"300": 0.023,
|
|
89
|
+
"60": 0.022
|
|
90
|
+
},
|
|
91
|
+
"seed": "svp-compiler-profile-seed-v1",
|
|
92
|
+
"sizes": {
|
|
93
|
+
"120": {
|
|
94
|
+
"mean": 0.8385,
|
|
95
|
+
"q": [
|
|
96
|
+
0.8813,
|
|
97
|
+
0.8377,
|
|
98
|
+
0.8031,
|
|
99
|
+
0.8179,
|
|
100
|
+
0.8346,
|
|
101
|
+
0.8512,
|
|
102
|
+
0.8364,
|
|
103
|
+
0.8458
|
|
104
|
+
],
|
|
105
|
+
"sd": 0.0216,
|
|
106
|
+
"timeouts": 0
|
|
107
|
+
},
|
|
108
|
+
"180": {
|
|
109
|
+
"mean": 0.8492,
|
|
110
|
+
"q": [
|
|
111
|
+
0.8424,
|
|
112
|
+
0.8791,
|
|
113
|
+
0.8083,
|
|
114
|
+
0.8378,
|
|
115
|
+
0.848,
|
|
116
|
+
0.8643,
|
|
117
|
+
0.8415,
|
|
118
|
+
0.8722
|
|
119
|
+
],
|
|
120
|
+
"sd": 0.0211,
|
|
121
|
+
"timeouts": 0
|
|
122
|
+
},
|
|
123
|
+
"240": {
|
|
124
|
+
"mean": 0.8399,
|
|
125
|
+
"q": [
|
|
126
|
+
0.8092,
|
|
127
|
+
0.8379,
|
|
128
|
+
0.8886,
|
|
129
|
+
0.8184,
|
|
130
|
+
0.8359,
|
|
131
|
+
0.8333,
|
|
132
|
+
0.8469,
|
|
133
|
+
0.8491
|
|
134
|
+
],
|
|
135
|
+
"sd": 0.0223,
|
|
136
|
+
"timeouts": 0
|
|
137
|
+
},
|
|
138
|
+
"300": {
|
|
139
|
+
"mean": 0.8389,
|
|
140
|
+
"q": [
|
|
141
|
+
0.8406,
|
|
142
|
+
0.8305,
|
|
143
|
+
0.8347,
|
|
144
|
+
0.8273,
|
|
145
|
+
0.8157,
|
|
146
|
+
0.8715,
|
|
147
|
+
0.8335,
|
|
148
|
+
0.8571
|
|
149
|
+
],
|
|
150
|
+
"sd": 0.0165,
|
|
151
|
+
"timeouts": 0
|
|
152
|
+
},
|
|
153
|
+
"60": {
|
|
154
|
+
"mean": 0.8519,
|
|
155
|
+
"q": [
|
|
156
|
+
0.8526,
|
|
157
|
+
0.9105,
|
|
158
|
+
0.7828,
|
|
159
|
+
0.8119,
|
|
160
|
+
0.8743,
|
|
161
|
+
0.8457,
|
|
162
|
+
0.8396,
|
|
163
|
+
0.898
|
|
164
|
+
],
|
|
165
|
+
"sd": 0.0397,
|
|
166
|
+
"timeouts": 0
|
|
167
|
+
}
|
|
168
|
+
}
|
|
169
|
+
},
|
|
170
|
+
"simulation": {
|
|
171
|
+
"mean": {
|
|
172
|
+
"120": 0.8384845444835485,
|
|
173
|
+
"180": 0.8491772694158268,
|
|
174
|
+
"240": 0.8399086412388147,
|
|
175
|
+
"300": 0.8388845238608824,
|
|
176
|
+
"60": 0.8519361215575074
|
|
177
|
+
},
|
|
178
|
+
"sd": {
|
|
179
|
+
"120": 0.021623685137521137,
|
|
180
|
+
"180": 0.021093367667705958,
|
|
181
|
+
"240": 0.022288139973720335,
|
|
182
|
+
"300": 0.01654134107403892,
|
|
183
|
+
"60": 0.03972576460099539
|
|
184
|
+
},
|
|
185
|
+
"sizes": [
|
|
186
|
+
60,
|
|
187
|
+
120,
|
|
188
|
+
180,
|
|
189
|
+
240,
|
|
190
|
+
300
|
|
191
|
+
]
|
|
192
|
+
}
|
|
193
|
+
},
|
|
194
|
+
"quality_compiler_sha256": "09835f01815620f1bdd5d35865b09b79fbc8c1535fee050328caaf366e27130b",
|
|
195
|
+
"reference_note": "One random assignment improved by a single greedy sweep of single-node flips. Repeated local search or simulated annealing is known to beat it by several quality points within the same budget.",
|
|
196
|
+
"reference_sha256": "9890c58349ea75c9529a429ee1c9e431a9a79b2498644445407017290e7605ee",
|
|
197
|
+
"selftest": {
|
|
198
|
+
"controls": [
|
|
199
|
+
{
|
|
200
|
+
"check": "zero gain",
|
|
201
|
+
"detail": "reference vs itself credits 0.0000 (must be 0)",
|
|
202
|
+
"status": "pass"
|
|
203
|
+
},
|
|
204
|
+
{
|
|
205
|
+
"check": "never answers",
|
|
206
|
+
"detail": "a solver with no valid answer credits 0.0000 (must be 0)",
|
|
207
|
+
"status": "pass"
|
|
208
|
+
},
|
|
209
|
+
{
|
|
210
|
+
"check": "known gain",
|
|
211
|
+
"detail": "a true gain of 0.06 is credited 0.0593 (must reach 0.02)",
|
|
212
|
+
"status": "pass"
|
|
213
|
+
}
|
|
214
|
+
],
|
|
215
|
+
"kind": "estimator controls on synthetic ladders from the profile; the exported bundle's `check.py selftest` covers the declaration itself",
|
|
216
|
+
"status": "pass"
|
|
217
|
+
},
|
|
218
|
+
"size_range": [
|
|
219
|
+
60,
|
|
220
|
+
300
|
|
221
|
+
],
|
|
222
|
+
"size_step": 60,
|
|
223
|
+
"validation": [
|
|
224
|
+
{
|
|
225
|
+
"check": "declaration",
|
|
226
|
+
"detail": "maxcut maxcut-v1, sizes 60..300 step 60",
|
|
227
|
+
"status": "pass"
|
|
228
|
+
},
|
|
229
|
+
{
|
|
230
|
+
"check": "reference",
|
|
231
|
+
"detail": "reference.py",
|
|
232
|
+
"status": "pass"
|
|
233
|
+
},
|
|
234
|
+
{
|
|
235
|
+
"check": "baseline statement",
|
|
236
|
+
"detail": "REFERENCE_NOTE says what the reference is and what is known to beat it",
|
|
237
|
+
"status": "pass"
|
|
238
|
+
},
|
|
239
|
+
{
|
|
240
|
+
"check": "shape",
|
|
241
|
+
"detail": "args are JSON-serializable lists at sizes [60, 180, 300]",
|
|
242
|
+
"status": "pass"
|
|
243
|
+
},
|
|
244
|
+
{
|
|
245
|
+
"check": "determinism",
|
|
246
|
+
"detail": "pure in (master, size, index); 8/8 distinct indices; seed-dependent",
|
|
247
|
+
"status": "pass"
|
|
248
|
+
},
|
|
249
|
+
{
|
|
250
|
+
"check": "process purity",
|
|
251
|
+
"detail": "identical instances in fresh interpreters with two hash seeds",
|
|
252
|
+
"status": "pass"
|
|
253
|
+
},
|
|
254
|
+
{
|
|
255
|
+
"check": "witness",
|
|
256
|
+
"detail": "verify() accepts the planted witness on 12 instances; it is not in the arguments",
|
|
257
|
+
"status": "pass"
|
|
258
|
+
},
|
|
259
|
+
{
|
|
260
|
+
"check": "junk rejected",
|
|
261
|
+
"detail": "verify() rejected all 19 junk answers on 6 instances",
|
|
262
|
+
"status": "pass"
|
|
263
|
+
},
|
|
264
|
+
{
|
|
265
|
+
"check": "no trivial answer",
|
|
266
|
+
"detail": "no argument, its neighbour or the argument list verifies",
|
|
267
|
+
"status": "pass"
|
|
268
|
+
},
|
|
269
|
+
{
|
|
270
|
+
"check": "witness reuse",
|
|
271
|
+
"detail": "0 of 30 cross-instance witnesses accepted",
|
|
272
|
+
"status": "pass"
|
|
273
|
+
},
|
|
274
|
+
{
|
|
275
|
+
"check": "reference solves",
|
|
276
|
+
"detail": "solved 3 instances at each of sizes [60, 120, 180]; median cost 60: 0.001s, 120: 0.001s, 180: 0.001s",
|
|
277
|
+
"status": "pass"
|
|
278
|
+
},
|
|
279
|
+
{
|
|
280
|
+
"check": "quality settings",
|
|
281
|
+
"detail": "budget 5 s per instance, certification threshold 0.02 quality points",
|
|
282
|
+
"status": "pass"
|
|
283
|
+
},
|
|
284
|
+
{
|
|
285
|
+
"check": "quality range",
|
|
286
|
+
"detail": "finite, in [0, 1] and deterministic on 9 planted witnesses (range 1.000..1.000)",
|
|
287
|
+
"status": "pass"
|
|
288
|
+
}
|
|
289
|
+
],
|
|
290
|
+
"version": "maxcut-v1"
|
|
291
|
+
}
|
|
@@ -0,0 +1,46 @@
|
|
|
1
|
+
"""Declaration of a QUALITY challenge: max-cut on graphs with a planted good cut (see COMPILER.md, "Quality challenges").
|
|
2
|
+
|
|
3
|
+
A solver receives (n, edges) and returns a list of n bits (a side for every node). ANY such list is valid; the score is how many edges it cuts relative to the planted
|
|
4
|
+
partition's cut, capped at 1. So the question is not "who answers first" but "who finds the better cut inside the same CPU budget". The reference is a one-sweep greedy:
|
|
5
|
+
simulated annealing or repeated local search beats it by many points.
|
|
6
|
+
"""
|
|
7
|
+
import hashlib
|
|
8
|
+
import hmac
|
|
9
|
+
import random
|
|
10
|
+
|
|
11
|
+
NAME = "maxcut"
|
|
12
|
+
VERSION = "maxcut-v1" # bump whenever derive() changes
|
|
13
|
+
SIZE_RANGE = (60, 300) # number of nodes
|
|
14
|
+
SIZE_STEP = 60
|
|
15
|
+
REFERENCE_SOLVER = "reference.py"
|
|
16
|
+
QUALITY_BUDGET = 5 # CPU seconds per instance, for everyone
|
|
17
|
+
QUALITY_MIN_GAIN = 0.02 # a mean gain of two quality points is worth certifying
|
|
18
|
+
DOC = "solve(n, edges): return a list of n integers, each 0 or 1 (the side of every node). The score is the number of edges cut, divided by the planted partition's cut (at most 1)."
|
|
19
|
+
REFERENCE_NOTE = ("One random assignment improved by a single greedy sweep of single-node flips. Repeated local search or simulated annealing is known to beat it "
|
|
20
|
+
"by several quality points within the same budget.")
|
|
21
|
+
CROSS = 0.8 # probability an edge crosses the planted partition
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
def derive(master: bytes, size: int, idx: int) -> dict:
|
|
25
|
+
rng = random.Random(hmac.new(master, f"maxcut-v1:{size}:{idx}".encode(), hashlib.sha256).digest())
|
|
26
|
+
side = [rng.randrange(2) for _ in range(size)]
|
|
27
|
+
edges = []
|
|
28
|
+
while len(edges) < 4 * size:
|
|
29
|
+
u, v = rng.randrange(size), rng.randrange(size)
|
|
30
|
+
if u == v:
|
|
31
|
+
continue
|
|
32
|
+
if (side[u] != side[v]) == (rng.random() < CROSS):
|
|
33
|
+
edges.append([u, v])
|
|
34
|
+
best = sum(side[u] != side[v] for u, v in edges)
|
|
35
|
+
return {"args": [size, edges], "planted": side, "best": best}
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
def verify(inst: dict, ans) -> bool:
|
|
39
|
+
n = inst["args"][0]
|
|
40
|
+
return isinstance(ans, list) and len(ans) == n and all(isinstance(b, int) and not isinstance(b, bool) and b in (0, 1) for b in ans)
|
|
41
|
+
|
|
42
|
+
|
|
43
|
+
def quality(inst: dict, ans) -> float:
|
|
44
|
+
edges = inst["args"][1]
|
|
45
|
+
cut = sum(ans[u] != ans[v] for u, v in edges)
|
|
46
|
+
return min(1.0, cut / inst["best"])
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
"""Baseline: one random assignment, then a single greedy sweep of single-node flips."""
|
|
2
|
+
import random
|
|
3
|
+
|
|
4
|
+
|
|
5
|
+
def solve(n, edges):
|
|
6
|
+
rng = random.Random(12345)
|
|
7
|
+
side = [rng.randrange(2) for _ in range(n)]
|
|
8
|
+
adj = [[] for _ in range(n)]
|
|
9
|
+
for u, v in edges:
|
|
10
|
+
adj[u].append(v)
|
|
11
|
+
adj[v].append(u)
|
|
12
|
+
for u in range(n):
|
|
13
|
+
same = sum(side[v] == side[u] for v in adj[u])
|
|
14
|
+
if same > len(adj[u]) - same:
|
|
15
|
+
side[u] ^= 1
|
|
16
|
+
return side
|
|
@@ -0,0 +1,89 @@
|
|
|
1
|
+
"""Does running instances concurrently change their measured CPU time? Run before trusting `harness.py --jobs K`.
|
|
2
|
+
|
|
3
|
+
python3 drift_check.py [--solver solvers/baseline_bkz.py] [--dims 62 64] [--n 6] [--jobs 4 6 8]
|
|
4
|
+
|
|
5
|
+
Runs the SAME instances once sequentially (the reference) and once per job count, then reports the paired
|
|
6
|
+
log2(concurrent cpu / sequential cpu): the median is the systematic bias in bits, the sd is the extra noise.
|
|
7
|
+
A bias under ~0.05 bits is negligible next to the 0.5-1.5 bit per-instance noise; above that, use fewer jobs.
|
|
8
|
+
Exit code 1 if any tested job count shows a median bias above --max-bias.
|
|
9
|
+
"""
|
|
10
|
+
import argparse
|
|
11
|
+
import math
|
|
12
|
+
import os
|
|
13
|
+
import statistics
|
|
14
|
+
import sys
|
|
15
|
+
from concurrent.futures import ThreadPoolExecutor
|
|
16
|
+
|
|
17
|
+
import families
|
|
18
|
+
import harness
|
|
19
|
+
import instances
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
def run_all(solver, tasks, budget, jobs):
|
|
23
|
+
def work(t):
|
|
24
|
+
dim, idx = t
|
|
25
|
+
return harness.run_one(solver, families.derive("gm", instances.PRACTICE_SEED, dim, idx), budget)
|
|
26
|
+
|
|
27
|
+
with ThreadPoolExecutor(max_workers=jobs) as ex:
|
|
28
|
+
return list(ex.map(work, tasks))
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
def compare(seq, par, floor=0.05):
|
|
32
|
+
"""Paired log2(par/seq) over instances both solved, with cost above `floor` seconds. Returns (median, sd, n)."""
|
|
33
|
+
v = [math.log2(p["cpu"] / s["cpu"]) for s, p in zip(seq, par)
|
|
34
|
+
if s["status"] == "solved" and p["status"] == "solved" and s["cpu"] > floor and p["cpu"] > floor]
|
|
35
|
+
if len(v) < 3:
|
|
36
|
+
return None, None, len(v)
|
|
37
|
+
return statistics.median(v), statistics.pstdev(v), len(v)
|
|
38
|
+
|
|
39
|
+
|
|
40
|
+
def ratio_shift(seq1, seq2, par1, par2, floor=0.05):
|
|
41
|
+
"""What matters for credit: does the paired log2(solver1/solver2) SPEEDUP change under concurrency?
|
|
42
|
+
Per instance: (log2 c1/c2 under parallel) - (log2 c1/c2 sequential). Returns (median, sd, n)."""
|
|
43
|
+
v = []
|
|
44
|
+
for s1, s2, p1, p2 in zip(seq1, seq2, par1, par2):
|
|
45
|
+
if all(r["status"] == "solved" and r["cpu"] > floor for r in (s1, s2, p1, p2)):
|
|
46
|
+
v.append(math.log2(p1["cpu"] / p2["cpu"]) - math.log2(s1["cpu"] / s2["cpu"]))
|
|
47
|
+
if len(v) < 3:
|
|
48
|
+
return None, None, len(v)
|
|
49
|
+
return statistics.median(v), statistics.pstdev(v), len(v)
|
|
50
|
+
|
|
51
|
+
|
|
52
|
+
def main():
|
|
53
|
+
ap = argparse.ArgumentParser()
|
|
54
|
+
ap.add_argument("--solver2", help="a second solver: also report the shift of the SPEEDUP (solver / solver2), "
|
|
55
|
+
"which is what the credit uses and in which a uniform slowdown cancels")
|
|
56
|
+
ap.add_argument("--solver", default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "solvers", "baseline_bkz.py"))
|
|
57
|
+
ap.add_argument("--dims", type=int, nargs="+", default=[62, 64])
|
|
58
|
+
ap.add_argument("--n", type=int, default=6)
|
|
59
|
+
ap.add_argument("--jobs", type=int, nargs="+", default=[4, 6, 8])
|
|
60
|
+
ap.add_argument("--budget", type=float, default=60)
|
|
61
|
+
ap.add_argument("--max-bias", type=float, default=0.05)
|
|
62
|
+
a = ap.parse_args()
|
|
63
|
+
solver = os.path.abspath(a.solver)
|
|
64
|
+
tasks = [(d, i) for d in a.dims for i in range(a.n)]
|
|
65
|
+
print(f"{len(tasks)} instances; machine has {os.cpu_count()} logical CPUs", flush=True)
|
|
66
|
+
seq = run_all(solver, tasks, a.budget, 1)
|
|
67
|
+
ref2 = run_all(solver, tasks, a.budget, 1) # a second sequential pass: the noise floor of the comparison itself
|
|
68
|
+
med, sd, n = compare(seq, ref2)
|
|
69
|
+
print(f"sequential vs sequential (noise floor): median {med:+.3f} bits, sd {sd:.3f}, n={n}", flush=True)
|
|
70
|
+
solver2 = os.path.abspath(a.solver2) if a.solver2 else None
|
|
71
|
+
seq2 = run_all(solver2, tasks, a.budget, 1) if solver2 else None
|
|
72
|
+
bad = False
|
|
73
|
+
for j in a.jobs:
|
|
74
|
+
par = run_all(solver, tasks, a.budget, j)
|
|
75
|
+
med, sd, n = compare(seq, par)
|
|
76
|
+
print(f"jobs={j:2d} vs sequential: absolute cpu time shifts by median {med:+.3f} bits, sd {sd:.3f}, n={n}", flush=True)
|
|
77
|
+
if solver2:
|
|
78
|
+
par2 = run_all(solver2, tasks, a.budget, j)
|
|
79
|
+
m2, s2, n2 = ratio_shift(seq, seq2, par, par2)
|
|
80
|
+
flag = "" if m2 is not None and abs(m2) <= a.max_bias else " <-- BIASED"
|
|
81
|
+
bad |= bool(flag)
|
|
82
|
+
print(f" SPEEDUP estimate shifts by median {m2:+.3f} bits, sd {s2:.3f}, n={n2}{flag}", flush=True)
|
|
83
|
+
else:
|
|
84
|
+
bad |= med is None or abs(med) > a.max_bias
|
|
85
|
+
sys.exit(1 if bad else 0)
|
|
86
|
+
|
|
87
|
+
|
|
88
|
+
if __name__ == "__main__":
|
|
89
|
+
main()
|