thefinalboss commited on
Commit
ac2f530
·
verified ·
1 Parent(s): 53e7848

v3_scale: scan 64 o code_scale_v1 (Checker) — agrégats + script, dédup PASS

Browse files
v3_scale/recount/code_scale_v1_scan/scan64_code_scale_v1.json ADDED
@@ -0,0 +1,905 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "script": "/workspace/spira_shared/checker/recount/code_scale_v1_scan/scan64_code_scale_v1.py",
3
+ "script_sha256": "5c247ab5e32d6a00bb9e1cdc842bbf272cafa59d87ebbc91b7427c029a53f294",
4
+ "started": "2026-10-24 13:22:18 EDT",
5
+ "test_mode": false,
6
+ "P": 32,
7
+ "method": "hachage par mots u64 (recount64_words.py), table triée + searchsorted, confirmation octet à octet de CHAQUE candidat (vectorisée)",
8
+ "windows": {
9
+ "m7_fresh_en": {
10
+ "kind": "eval17",
11
+ "bytes": 119763,
12
+ "sha256": "67ff20b26ce5e3401cea57c817b1a8417e95f6cd131fd8fb631cd5cd8625331a",
13
+ "n_64grams": 119700,
14
+ "content_id": 0,
15
+ "sha256_eq_hashing_manifest": true
16
+ },
17
+ "m7_fresh_fr": {
18
+ "kind": "eval17",
19
+ "bytes": 1088688,
20
+ "sha256": "875f0906a320e3f7b87e446aab646cf49c74786cb1a0db78b54fa4c62e872715",
21
+ "n_64grams": 1088625,
22
+ "content_id": 1,
23
+ "sha256_eq_hashing_manifest": true
24
+ },
25
+ "m7_neither_code": {
26
+ "kind": "eval17",
27
+ "bytes": 546036,
28
+ "sha256": "f1d728dc1a3db2e57aee703d25745f601ff6154dc31c519ea8a4fd921ff0f954",
29
+ "n_64grams": 545973,
30
+ "content_id": 2,
31
+ "sha256_eq_hashing_manifest": true
32
+ },
33
+ "m7_test20k": {
34
+ "kind": "eval17",
35
+ "bytes": 319940,
36
+ "sha256": "ce0526c62048f8e590a96cca5393a87c2e631f194eb4a2e974c584fd443b6a22",
37
+ "n_64grams": 319877,
38
+ "content_id": 3,
39
+ "sha256_eq_hashing_manifest": true
40
+ },
41
+ "m7_queries": {
42
+ "kind": "eval17",
43
+ "bytes": 27800,
44
+ "sha256": "5aab38d62b2f000df6a913d2574ccd314300e350ccc76e71e16768ed5c73b706",
45
+ "n_64grams": 27737,
46
+ "content_id": 4,
47
+ "sha256_eq_hashing_manifest": true
48
+ },
49
+ "m7_freshcode": {
50
+ "kind": "eval17",
51
+ "bytes": 200000,
52
+ "sha256": "589dbc35997e0cadd2ac8e283fdb0f305ea8c923d021159668104be7dbfcef98",
53
+ "n_64grams": 199937,
54
+ "content_id": 5,
55
+ "sha256_eq_hashing_manifest": true
56
+ },
57
+ "fc2": {
58
+ "kind": "eval17",
59
+ "bytes": 199792,
60
+ "sha256": "b052096b0c1e2b301cd79921502f85e61912f209fc0027151bbf82237de8c2e3",
61
+ "n_64grams": 199729,
62
+ "content_id": 6,
63
+ "sha256_eq_hashing_manifest": true
64
+ },
65
+ "corpus_v3_test": {
66
+ "kind": "eval17",
67
+ "bytes": 3486653,
68
+ "sha256": "a6730bbe877e7b28a5529793b27a0b59f16d04db05ea895f0ee6d4f91807ca84",
69
+ "n_64grams": 3486590,
70
+ "content_id": 7,
71
+ "sha256_eq_hashing_manifest": true
72
+ },
73
+ "corpus_v3_oneshot": {
74
+ "kind": "eval17",
75
+ "bytes": 119763,
76
+ "sha256": "67ff20b26ce5e3401cea57c817b1a8417e95f6cd131fd8fb631cd5cd8625331a",
77
+ "n_64grams": 119700,
78
+ "content_id": 0,
79
+ "sha256_eq_hashing_manifest": true
80
+ },
81
+ "broad_local_v1_test": {
82
+ "kind": "eval17",
83
+ "bytes": 894718,
84
+ "sha256": "e89725bb94d9f167ffad1f68ae372343a14a1957ae0a1f0a67167aa974ec75a9",
85
+ "n_64grams": 894655,
86
+ "content_id": 8,
87
+ "sha256_eq_hashing_manifest": true
88
+ },
89
+ "broad_local_v1_oneshot": {
90
+ "kind": "eval17",
91
+ "bytes": 119763,
92
+ "sha256": "67ff20b26ce5e3401cea57c817b1a8417e95f6cd131fd8fb631cd5cd8625331a",
93
+ "n_64grams": 119700,
94
+ "content_id": 0,
95
+ "sha256_eq_hashing_manifest": true
96
+ },
97
+ "broad_gutenberg_v1_test": {
98
+ "kind": "eval17",
99
+ "bytes": 894718,
100
+ "sha256": "e89725bb94d9f167ffad1f68ae372343a14a1957ae0a1f0a67167aa974ec75a9",
101
+ "n_64grams": 894655,
102
+ "content_id": 8,
103
+ "sha256_eq_hashing_manifest": true
104
+ },
105
+ "broad_gutenberg_v1_oneshot": {
106
+ "kind": "eval17",
107
+ "bytes": 119763,
108
+ "sha256": "67ff20b26ce5e3401cea57c817b1a8417e95f6cd131fd8fb631cd5cd8625331a",
109
+ "n_64grams": 119700,
110
+ "content_id": 0,
111
+ "sha256_eq_hashing_manifest": true
112
+ },
113
+ "old_local_v1_test": {
114
+ "kind": "eval17",
115
+ "bytes": 319940,
116
+ "sha256": "ce0526c62048f8e590a96cca5393a87c2e631f194eb4a2e974c584fd443b6a22",
117
+ "n_64grams": 319877,
118
+ "content_id": 3,
119
+ "sha256_eq_hashing_manifest": true
120
+ },
121
+ "old_local_v1_oneshot": {
122
+ "kind": "eval17",
123
+ "bytes": 119763,
124
+ "sha256": "67ff20b26ce5e3401cea57c817b1a8417e95f6cd131fd8fb631cd5cd8625331a",
125
+ "n_64grams": 119700,
126
+ "content_id": 0,
127
+ "sha256_eq_hashing_manifest": true
128
+ },
129
+ "corpus_diverse_v1_test": {
130
+ "kind": "eval17",
131
+ "bytes": 894718,
132
+ "sha256": "e89725bb94d9f167ffad1f68ae372343a14a1957ae0a1f0a67167aa974ec75a9",
133
+ "n_64grams": 894655,
134
+ "content_id": 8,
135
+ "sha256_eq_hashing_manifest": true
136
+ },
137
+ "corpus_diverse_v1_oneshot": {
138
+ "kind": "eval17",
139
+ "bytes": 119763,
140
+ "sha256": "67ff20b26ce5e3401cea57c817b1a8417e95f6cd131fd8fb631cd5cd8625331a",
141
+ "n_64grams": 119700,
142
+ "content_id": 0,
143
+ "sha256_eq_hashing_manifest": true
144
+ },
145
+ "seen_old_local_v1": {
146
+ "kind": "seen_info",
147
+ "bytes": 200000,
148
+ "sha256": "7585ad82947bbe8b2ae6484b1922511b483c11d84bde5b0a53978135d0eb99ca",
149
+ "n_64grams": 199937,
150
+ "content_id": 9
151
+ },
152
+ "seen_broad_local_v1": {
153
+ "kind": "seen_info",
154
+ "bytes": 200000,
155
+ "sha256": "a2b854f4618b7c1294de623e2300d5f9ed1d62b7e25da5afdfd5bf198aa46a12",
156
+ "n_64grams": 199937,
157
+ "content_id": 10
158
+ },
159
+ "seen_corpus_v3": {
160
+ "kind": "seen_info",
161
+ "bytes": 200000,
162
+ "sha256": "01b8e8b558777390f6dd4fd80a06c900433bed06bf0e5b237555878b2306a812",
163
+ "n_64grams": 199937,
164
+ "content_id": 11
165
+ },
166
+ "seen_broad_gutenberg_v1": {
167
+ "kind": "seen_info",
168
+ "bytes": 200000,
169
+ "sha256": "a2b854f4618b7c1294de623e2300d5f9ed1d62b7e25da5afdfd5bf198aa46a12",
170
+ "n_64grams": 199937,
171
+ "content_id": 10
172
+ },
173
+ "seen_corpus_diverse_v1": {
174
+ "kind": "seen_info",
175
+ "bytes": 200000,
176
+ "sha256": "a2b854f4618b7c1294de623e2300d5f9ed1d62b7e25da5afdfd5bf198aa46a12",
177
+ "n_64grams": 199937,
178
+ "content_id": 10
179
+ },
180
+ "seen_corpus_diverse_v1b": {
181
+ "kind": "seen_info",
182
+ "bytes": 200000,
183
+ "sha256": "a2b854f4618b7c1294de623e2300d5f9ed1d62b7e25da5afdfd5bf198aa46a12",
184
+ "n_64grams": 199937,
185
+ "content_id": 10
186
+ },
187
+ "v4_fc2": {
188
+ "kind": "bench_v4_info",
189
+ "bytes": 199792,
190
+ "sha256": "b052096b0c1e2b301cd79921502f85e61912f209fc0027151bbf82237de8c2e3",
191
+ "n_64grams": 199729,
192
+ "content_id": 6
193
+ },
194
+ "v4_fresh_en": {
195
+ "kind": "bench_v4_info",
196
+ "bytes": 119763,
197
+ "sha256": "67ff20b26ce5e3401cea57c817b1a8417e95f6cd131fd8fb631cd5cd8625331a",
198
+ "n_64grams": 119700,
199
+ "content_id": 0
200
+ },
201
+ "v4_fresh_fr_perrault": {
202
+ "kind": "bench_v4_info",
203
+ "bytes": 1088688,
204
+ "sha256": "875f0906a320e3f7b87e446aab646cf49c74786cb1a0db78b54fa4c62e872715",
205
+ "n_64grams": 1088625,
206
+ "content_id": 1
207
+ },
208
+ "v4_neither_code_kahnn": {
209
+ "kind": "bench_v4_info",
210
+ "bytes": 546036,
211
+ "sha256": "f1d728dc1a3db2e57aee703d25745f601ff6154dc31c519ea8a4fd921ff0f954",
212
+ "n_64grams": 545973,
213
+ "content_id": 2
214
+ },
215
+ "v4_test20k_broad": {
216
+ "kind": "bench_v4_info",
217
+ "bytes": 894718,
218
+ "sha256": "e89725bb94d9f167ffad1f68ae372343a14a1957ae0a1f0a67167aa974ec75a9",
219
+ "n_64grams": 894655,
220
+ "content_id": 8
221
+ },
222
+ "v4_queries_chat_seed": {
223
+ "kind": "bench_v4_info",
224
+ "bytes": 27800,
225
+ "sha256": "5aab38d62b2f000df6a913d2574ccd314300e350ccc76e71e16768ed5c73b706",
226
+ "n_64grams": 27737,
227
+ "content_id": 4
228
+ },
229
+ "v4_test_v3": {
230
+ "kind": "bench_v4_info",
231
+ "bytes": 3486653,
232
+ "sha256": "a6730bbe877e7b28a5529793b27a0b59f16d04db05ea895f0ee6d4f91807ca84",
233
+ "n_64grams": 3486590,
234
+ "content_id": 7
235
+ }
236
+ },
237
+ "n_windows_named": 30,
238
+ "n_eval17": 17,
239
+ "n_unique_contents": 12,
240
+ "window_table": {
241
+ "entries": 7482634,
242
+ "unique_64grams": 6756801,
243
+ "intra_window_hash_collisions": 0
244
+ },
245
+ "stage_A": {
246
+ "code_full": {
247
+ "bytes_streamed": 527734829,
248
+ "sha256_streamed": "ec957b71973a230e61d7fd143b4094550b70934ccec47f34bd0ea6b0eb2189c1",
249
+ "size_ok": true,
250
+ "sha_ok": true,
251
+ "hash_candidates": 1,
252
+ "hash_false_positives": 1,
253
+ "eval17_hit_positions": 0,
254
+ "first_eval17_offsets": [],
255
+ "per_window": {
256
+ "m7_fresh_en": {
257
+ "matched_window_64gram_starts": 0,
258
+ "covered_window_byte_positions": 0,
259
+ "confirmed_stream_positions": 0
260
+ },
261
+ "m7_fresh_fr": {
262
+ "matched_window_64gram_starts": 0,
263
+ "covered_window_byte_positions": 0,
264
+ "confirmed_stream_positions": 0
265
+ },
266
+ "m7_neither_code": {
267
+ "matched_window_64gram_starts": 0,
268
+ "covered_window_byte_positions": 0,
269
+ "confirmed_stream_positions": 0
270
+ },
271
+ "m7_test20k": {
272
+ "matched_window_64gram_starts": 0,
273
+ "covered_window_byte_positions": 0,
274
+ "confirmed_stream_positions": 0
275
+ },
276
+ "m7_queries": {
277
+ "matched_window_64gram_starts": 0,
278
+ "covered_window_byte_positions": 0,
279
+ "confirmed_stream_positions": 0
280
+ },
281
+ "m7_freshcode": {
282
+ "matched_window_64gram_starts": 0,
283
+ "covered_window_byte_positions": 0,
284
+ "confirmed_stream_positions": 0
285
+ },
286
+ "fc2": {
287
+ "matched_window_64gram_starts": 0,
288
+ "covered_window_byte_positions": 0,
289
+ "confirmed_stream_positions": 0
290
+ },
291
+ "corpus_v3_test": {
292
+ "matched_window_64gram_starts": 0,
293
+ "covered_window_byte_positions": 0,
294
+ "confirmed_stream_positions": 0
295
+ },
296
+ "corpus_v3_oneshot": {
297
+ "matched_window_64gram_starts": 0,
298
+ "covered_window_byte_positions": 0,
299
+ "confirmed_stream_positions": 0
300
+ },
301
+ "broad_local_v1_test": {
302
+ "matched_window_64gram_starts": 0,
303
+ "covered_window_byte_positions": 0,
304
+ "confirmed_stream_positions": 0
305
+ },
306
+ "broad_local_v1_oneshot": {
307
+ "matched_window_64gram_starts": 0,
308
+ "covered_window_byte_positions": 0,
309
+ "confirmed_stream_positions": 0
310
+ },
311
+ "broad_gutenberg_v1_test": {
312
+ "matched_window_64gram_starts": 0,
313
+ "covered_window_byte_positions": 0,
314
+ "confirmed_stream_positions": 0
315
+ },
316
+ "broad_gutenberg_v1_oneshot": {
317
+ "matched_window_64gram_starts": 0,
318
+ "covered_window_byte_positions": 0,
319
+ "confirmed_stream_positions": 0
320
+ },
321
+ "old_local_v1_test": {
322
+ "matched_window_64gram_starts": 0,
323
+ "covered_window_byte_positions": 0,
324
+ "confirmed_stream_positions": 0
325
+ },
326
+ "old_local_v1_oneshot": {
327
+ "matched_window_64gram_starts": 0,
328
+ "covered_window_byte_positions": 0,
329
+ "confirmed_stream_positions": 0
330
+ },
331
+ "corpus_diverse_v1_test": {
332
+ "matched_window_64gram_starts": 0,
333
+ "covered_window_byte_positions": 0,
334
+ "confirmed_stream_positions": 0
335
+ },
336
+ "corpus_diverse_v1_oneshot": {
337
+ "matched_window_64gram_starts": 0,
338
+ "covered_window_byte_positions": 0,
339
+ "confirmed_stream_positions": 0
340
+ },
341
+ "seen_old_local_v1": {
342
+ "matched_window_64gram_starts": 0,
343
+ "covered_window_byte_positions": 0,
344
+ "confirmed_stream_positions": 0
345
+ },
346
+ "seen_broad_local_v1": {
347
+ "matched_window_64gram_starts": 0,
348
+ "covered_window_byte_positions": 0,
349
+ "confirmed_stream_positions": 0
350
+ },
351
+ "seen_corpus_v3": {
352
+ "matched_window_64gram_starts": 0,
353
+ "covered_window_byte_positions": 0,
354
+ "confirmed_stream_positions": 0
355
+ },
356
+ "seen_broad_gutenberg_v1": {
357
+ "matched_window_64gram_starts": 0,
358
+ "covered_window_byte_positions": 0,
359
+ "confirmed_stream_positions": 0
360
+ },
361
+ "seen_corpus_diverse_v1": {
362
+ "matched_window_64gram_starts": 0,
363
+ "covered_window_byte_positions": 0,
364
+ "confirmed_stream_positions": 0
365
+ },
366
+ "seen_corpus_diverse_v1b": {
367
+ "matched_window_64gram_starts": 0,
368
+ "covered_window_byte_positions": 0,
369
+ "confirmed_stream_positions": 0
370
+ },
371
+ "v4_fc2": {
372
+ "matched_window_64gram_starts": 0,
373
+ "covered_window_byte_positions": 0,
374
+ "confirmed_stream_positions": 0
375
+ },
376
+ "v4_fresh_en": {
377
+ "matched_window_64gram_starts": 0,
378
+ "covered_window_byte_positions": 0,
379
+ "confirmed_stream_positions": 0
380
+ },
381
+ "v4_fresh_fr_perrault": {
382
+ "matched_window_64gram_starts": 0,
383
+ "covered_window_byte_positions": 0,
384
+ "confirmed_stream_positions": 0
385
+ },
386
+ "v4_neither_code_kahnn": {
387
+ "matched_window_64gram_starts": 0,
388
+ "covered_window_byte_positions": 0,
389
+ "confirmed_stream_positions": 0
390
+ },
391
+ "v4_test20k_broad": {
392
+ "matched_window_64gram_starts": 0,
393
+ "covered_window_byte_positions": 0,
394
+ "confirmed_stream_positions": 0
395
+ },
396
+ "v4_queries_chat_seed": {
397
+ "matched_window_64gram_starts": 0,
398
+ "covered_window_byte_positions": 0,
399
+ "confirmed_stream_positions": 0
400
+ },
401
+ "v4_test_v3": {
402
+ "matched_window_64gram_starts": 0,
403
+ "covered_window_byte_positions": 0,
404
+ "confirmed_stream_positions": 0
405
+ }
406
+ }
407
+ },
408
+ "code_delta": {
409
+ "bytes_streamed": 308316044,
410
+ "sha256_streamed": "36f69c2fb1139597c8f913535ffe478a9565cae4a4edaa9aa3dbb26124e6ed31",
411
+ "size_ok": true,
412
+ "sha_ok": true,
413
+ "hash_candidates": 0,
414
+ "hash_false_positives": 0,
415
+ "eval17_hit_positions": 0,
416
+ "first_eval17_offsets": [],
417
+ "per_window": {
418
+ "m7_fresh_en": {
419
+ "matched_window_64gram_starts": 0,
420
+ "covered_window_byte_positions": 0,
421
+ "confirmed_stream_positions": 0
422
+ },
423
+ "m7_fresh_fr": {
424
+ "matched_window_64gram_starts": 0,
425
+ "covered_window_byte_positions": 0,
426
+ "confirmed_stream_positions": 0
427
+ },
428
+ "m7_neither_code": {
429
+ "matched_window_64gram_starts": 0,
430
+ "covered_window_byte_positions": 0,
431
+ "confirmed_stream_positions": 0
432
+ },
433
+ "m7_test20k": {
434
+ "matched_window_64gram_starts": 0,
435
+ "covered_window_byte_positions": 0,
436
+ "confirmed_stream_positions": 0
437
+ },
438
+ "m7_queries": {
439
+ "matched_window_64gram_starts": 0,
440
+ "covered_window_byte_positions": 0,
441
+ "confirmed_stream_positions": 0
442
+ },
443
+ "m7_freshcode": {
444
+ "matched_window_64gram_starts": 0,
445
+ "covered_window_byte_positions": 0,
446
+ "confirmed_stream_positions": 0
447
+ },
448
+ "fc2": {
449
+ "matched_window_64gram_starts": 0,
450
+ "covered_window_byte_positions": 0,
451
+ "confirmed_stream_positions": 0
452
+ },
453
+ "corpus_v3_test": {
454
+ "matched_window_64gram_starts": 0,
455
+ "covered_window_byte_positions": 0,
456
+ "confirmed_stream_positions": 0
457
+ },
458
+ "corpus_v3_oneshot": {
459
+ "matched_window_64gram_starts": 0,
460
+ "covered_window_byte_positions": 0,
461
+ "confirmed_stream_positions": 0
462
+ },
463
+ "broad_local_v1_test": {
464
+ "matched_window_64gram_starts": 0,
465
+ "covered_window_byte_positions": 0,
466
+ "confirmed_stream_positions": 0
467
+ },
468
+ "broad_local_v1_oneshot": {
469
+ "matched_window_64gram_starts": 0,
470
+ "covered_window_byte_positions": 0,
471
+ "confirmed_stream_positions": 0
472
+ },
473
+ "broad_gutenberg_v1_test": {
474
+ "matched_window_64gram_starts": 0,
475
+ "covered_window_byte_positions": 0,
476
+ "confirmed_stream_positions": 0
477
+ },
478
+ "broad_gutenberg_v1_oneshot": {
479
+ "matched_window_64gram_starts": 0,
480
+ "covered_window_byte_positions": 0,
481
+ "confirmed_stream_positions": 0
482
+ },
483
+ "old_local_v1_test": {
484
+ "matched_window_64gram_starts": 0,
485
+ "covered_window_byte_positions": 0,
486
+ "confirmed_stream_positions": 0
487
+ },
488
+ "old_local_v1_oneshot": {
489
+ "matched_window_64gram_starts": 0,
490
+ "covered_window_byte_positions": 0,
491
+ "confirmed_stream_positions": 0
492
+ },
493
+ "corpus_diverse_v1_test": {
494
+ "matched_window_64gram_starts": 0,
495
+ "covered_window_byte_positions": 0,
496
+ "confirmed_stream_positions": 0
497
+ },
498
+ "corpus_diverse_v1_oneshot": {
499
+ "matched_window_64gram_starts": 0,
500
+ "covered_window_byte_positions": 0,
501
+ "confirmed_stream_positions": 0
502
+ },
503
+ "seen_old_local_v1": {
504
+ "matched_window_64gram_starts": 0,
505
+ "covered_window_byte_positions": 0,
506
+ "confirmed_stream_positions": 0
507
+ },
508
+ "seen_broad_local_v1": {
509
+ "matched_window_64gram_starts": 0,
510
+ "covered_window_byte_positions": 0,
511
+ "confirmed_stream_positions": 0
512
+ },
513
+ "seen_corpus_v3": {
514
+ "matched_window_64gram_starts": 0,
515
+ "covered_window_byte_positions": 0,
516
+ "confirmed_stream_positions": 0
517
+ },
518
+ "seen_broad_gutenberg_v1": {
519
+ "matched_window_64gram_starts": 0,
520
+ "covered_window_byte_positions": 0,
521
+ "confirmed_stream_positions": 0
522
+ },
523
+ "seen_corpus_diverse_v1": {
524
+ "matched_window_64gram_starts": 0,
525
+ "covered_window_byte_positions": 0,
526
+ "confirmed_stream_positions": 0
527
+ },
528
+ "seen_corpus_diverse_v1b": {
529
+ "matched_window_64gram_starts": 0,
530
+ "covered_window_byte_positions": 0,
531
+ "confirmed_stream_positions": 0
532
+ },
533
+ "v4_fc2": {
534
+ "matched_window_64gram_starts": 0,
535
+ "covered_window_byte_positions": 0,
536
+ "confirmed_stream_positions": 0
537
+ },
538
+ "v4_fresh_en": {
539
+ "matched_window_64gram_starts": 0,
540
+ "covered_window_byte_positions": 0,
541
+ "confirmed_stream_positions": 0
542
+ },
543
+ "v4_fresh_fr_perrault": {
544
+ "matched_window_64gram_starts": 0,
545
+ "covered_window_byte_positions": 0,
546
+ "confirmed_stream_positions": 0
547
+ },
548
+ "v4_neither_code_kahnn": {
549
+ "matched_window_64gram_starts": 0,
550
+ "covered_window_byte_positions": 0,
551
+ "confirmed_stream_positions": 0
552
+ },
553
+ "v4_test20k_broad": {
554
+ "matched_window_64gram_starts": 0,
555
+ "covered_window_byte_positions": 0,
556
+ "confirmed_stream_positions": 0
557
+ },
558
+ "v4_queries_chat_seed": {
559
+ "matched_window_64gram_starts": 0,
560
+ "covered_window_byte_positions": 0,
561
+ "confirmed_stream_positions": 0
562
+ },
563
+ "v4_test_v3": {
564
+ "matched_window_64gram_starts": 0,
565
+ "covered_window_byte_positions": 0,
566
+ "confirmed_stream_positions": 0
567
+ }
568
+ }
569
+ },
570
+ "v1b": {
571
+ "bytes_streamed": 520785883,
572
+ "sha256_streamed": "ddf67ffb4e9f340aca7a130639580211e1eaa4b4e850cec93fb19d222f63ddb3",
573
+ "size_ok": true,
574
+ "sha_ok": true,
575
+ "hash_candidates": 949049,
576
+ "hash_false_positives": 1,
577
+ "eval17_hit_positions": 441920,
578
+ "first_eval17_offsets": [
579
+ 19475724,
580
+ 19475725,
581
+ 19475726,
582
+ 19475896,
583
+ 19475897
584
+ ],
585
+ "per_window": {
586
+ "m7_fresh_en": {
587
+ "matched_window_64gram_starts": 0,
588
+ "covered_window_byte_positions": 0,
589
+ "confirmed_stream_positions": 0
590
+ },
591
+ "m7_fresh_fr": {
592
+ "matched_window_64gram_starts": 0,
593
+ "covered_window_byte_positions": 0,
594
+ "confirmed_stream_positions": 0
595
+ },
596
+ "m7_neither_code": {
597
+ "matched_window_64gram_starts": 224171,
598
+ "covered_window_byte_positions": 241715,
599
+ "confirmed_stream_positions": 224971
600
+ },
601
+ "m7_test20k": {
602
+ "matched_window_64gram_starts": 0,
603
+ "covered_window_byte_positions": 0,
604
+ "confirmed_stream_positions": 0
605
+ },
606
+ "m7_queries": {
607
+ "matched_window_64gram_starts": 0,
608
+ "covered_window_byte_positions": 0,
609
+ "confirmed_stream_positions": 0
610
+ },
611
+ "m7_freshcode": {
612
+ "matched_window_64gram_starts": 163445,
613
+ "covered_window_byte_positions": 172156,
614
+ "confirmed_stream_positions": 203264
615
+ },
616
+ "fc2": {
617
+ "matched_window_64gram_starts": 0,
618
+ "covered_window_byte_positions": 0,
619
+ "confirmed_stream_positions": 0
620
+ },
621
+ "corpus_v3_test": {
622
+ "matched_window_64gram_starts": 0,
623
+ "covered_window_byte_positions": 0,
624
+ "confirmed_stream_positions": 0
625
+ },
626
+ "corpus_v3_oneshot": {
627
+ "matched_window_64gram_starts": 0,
628
+ "covered_window_byte_positions": 0,
629
+ "confirmed_stream_positions": 0
630
+ },
631
+ "broad_local_v1_test": {
632
+ "matched_window_64gram_starts": 32344,
633
+ "covered_window_byte_positions": 41514,
634
+ "confirmed_stream_positions": 173689
635
+ },
636
+ "broad_local_v1_oneshot": {
637
+ "matched_window_64gram_starts": 0,
638
+ "covered_window_byte_positions": 0,
639
+ "confirmed_stream_positions": 0
640
+ },
641
+ "broad_gutenberg_v1_test": {
642
+ "matched_window_64gram_starts": 32344,
643
+ "covered_window_byte_positions": 41514,
644
+ "confirmed_stream_positions": 173689
645
+ },
646
+ "broad_gutenberg_v1_oneshot": {
647
+ "matched_window_64gram_starts": 0,
648
+ "covered_window_byte_positions": 0,
649
+ "confirmed_stream_positions": 0
650
+ },
651
+ "old_local_v1_test": {
652
+ "matched_window_64gram_starts": 0,
653
+ "covered_window_byte_positions": 0,
654
+ "confirmed_stream_positions": 0
655
+ },
656
+ "old_local_v1_oneshot": {
657
+ "matched_window_64gram_starts": 0,
658
+ "covered_window_byte_positions": 0,
659
+ "confirmed_stream_positions": 0
660
+ },
661
+ "corpus_diverse_v1_test": {
662
+ "matched_window_64gram_starts": 32344,
663
+ "covered_window_byte_positions": 41514,
664
+ "confirmed_stream_positions": 173689
665
+ },
666
+ "corpus_diverse_v1_oneshot": {
667
+ "matched_window_64gram_starts": 0,
668
+ "covered_window_byte_positions": 0,
669
+ "confirmed_stream_positions": 0
670
+ },
671
+ "seen_old_local_v1": {
672
+ "matched_window_64gram_starts": 199877,
673
+ "covered_window_byte_positions": 200000,
674
+ "confirmed_stream_positions": 199983
675
+ },
676
+ "seen_broad_local_v1": {
677
+ "matched_window_64gram_starts": 199937,
678
+ "covered_window_byte_positions": 200000,
679
+ "confirmed_stream_positions": 305460
680
+ },
681
+ "seen_corpus_v3": {
682
+ "matched_window_64gram_starts": 199217,
683
+ "covered_window_byte_positions": 200000,
684
+ "confirmed_stream_positions": 304703
685
+ },
686
+ "seen_broad_gutenberg_v1": {
687
+ "matched_window_64gram_starts": 199937,
688
+ "covered_window_byte_positions": 200000,
689
+ "confirmed_stream_positions": 305460
690
+ },
691
+ "seen_corpus_diverse_v1": {
692
+ "matched_window_64gram_starts": 199937,
693
+ "covered_window_byte_positions": 200000,
694
+ "confirmed_stream_positions": 305460
695
+ },
696
+ "seen_corpus_diverse_v1b": {
697
+ "matched_window_64gram_starts": 199937,
698
+ "covered_window_byte_positions": 200000,
699
+ "confirmed_stream_positions": 305460
700
+ },
701
+ "v4_fc2": {
702
+ "matched_window_64gram_starts": 0,
703
+ "covered_window_byte_positions": 0,
704
+ "confirmed_stream_positions": 0
705
+ },
706
+ "v4_fresh_en": {
707
+ "matched_window_64gram_starts": 0,
708
+ "covered_window_byte_positions": 0,
709
+ "confirmed_stream_positions": 0
710
+ },
711
+ "v4_fresh_fr_perrault": {
712
+ "matched_window_64gram_starts": 0,
713
+ "covered_window_byte_positions": 0,
714
+ "confirmed_stream_positions": 0
715
+ },
716
+ "v4_neither_code_kahnn": {
717
+ "matched_window_64gram_starts": 224171,
718
+ "covered_window_byte_positions": 241715,
719
+ "confirmed_stream_positions": 224971
720
+ },
721
+ "v4_test20k_broad": {
722
+ "matched_window_64gram_starts": 32344,
723
+ "covered_window_byte_positions": 41514,
724
+ "confirmed_stream_positions": 173689
725
+ },
726
+ "v4_queries_chat_seed": {
727
+ "matched_window_64gram_starts": 0,
728
+ "covered_window_byte_positions": 0,
729
+ "confirmed_stream_positions": 0
730
+ },
731
+ "v4_test_v3": {
732
+ "matched_window_64gram_starts": 0,
733
+ "covered_window_byte_positions": 0,
734
+ "confirmed_stream_positions": 0
735
+ }
736
+ }
737
+ }
738
+ },
739
+ "stage_B": {
740
+ "v1b_distinct_64grams": 462136149,
741
+ "v1b_intra_hash_collisions": 1384,
742
+ "code_full": {
743
+ "shared_positions": 239297397,
744
+ "distinct_shared_64grams": 170969875,
745
+ "hash_candidates": 239297459,
746
+ "hash_false_positives": 62,
747
+ "recovered_via_collision_table": 1213,
748
+ "distinct_note": "64-grammes distincts comptés par hachage (sous-compte possible <= recovered_via_collision_table)",
749
+ "positions_total": 527734766,
750
+ "covered_bytes": 253247494,
751
+ "bytes_total": 527734829,
752
+ "share_positions": 0.453443,
753
+ "share_bytes_covered": 0.479876
754
+ },
755
+ "code_delta": {
756
+ "shared_positions": 19882968,
757
+ "distinct_shared_64grams": 3383373,
758
+ "hash_candidates": 19883030,
759
+ "hash_false_positives": 62,
760
+ "recovered_via_collision_table": 246,
761
+ "distinct_note": "64-grammes distincts comptés par hachage (sous-compte possible <= recovered_via_collision_table)",
762
+ "positions_total": 308315981,
763
+ "covered_bytes": 33827926,
764
+ "bytes_total": 308316044,
765
+ "share_positions": 0.064489,
766
+ "share_bytes_covered": 0.109718
767
+ },
768
+ "hashing_reference_sampled_share": {
769
+ "code_full": 0.460112,
770
+ "code_delta": 0.081331
771
+ }
772
+ },
773
+ "positive_control_v1b_vs_recount64_words": {
774
+ "broad_local_v1_test": {
775
+ "expected": [
776
+ 32344,
777
+ 41514,
778
+ 173689
779
+ ],
780
+ "got": [
781
+ 32344,
782
+ 41514,
783
+ 173689
784
+ ],
785
+ "ok": true
786
+ },
787
+ "m7_neither_code": {
788
+ "expected": [
789
+ 224171,
790
+ 241715,
791
+ 224971
792
+ ],
793
+ "got": [
794
+ 224171,
795
+ 241715,
796
+ 224971
797
+ ],
798
+ "ok": true
799
+ },
800
+ "m7_freshcode": {
801
+ "expected": [
802
+ 163445,
803
+ 172156,
804
+ 203264
805
+ ],
806
+ "got": [
807
+ 163445,
808
+ 172156,
809
+ 203264
810
+ ],
811
+ "ok": true
812
+ },
813
+ "fc2": {
814
+ "expected": [
815
+ 0,
816
+ 0,
817
+ 0
818
+ ],
819
+ "got": [
820
+ 0,
821
+ 0,
822
+ 0
823
+ ],
824
+ "ok": true
825
+ },
826
+ "m7_fresh_en": {
827
+ "expected": [
828
+ 0,
829
+ 0,
830
+ 0
831
+ ],
832
+ "got": [
833
+ 0,
834
+ 0,
835
+ 0
836
+ ],
837
+ "ok": true
838
+ },
839
+ "m7_fresh_fr": {
840
+ "expected": [
841
+ 0,
842
+ 0,
843
+ 0
844
+ ],
845
+ "got": [
846
+ 0,
847
+ 0,
848
+ 0
849
+ ],
850
+ "ok": true
851
+ },
852
+ "old_local_v1_test": {
853
+ "expected": [
854
+ 0,
855
+ 0,
856
+ 0
857
+ ],
858
+ "got": [
859
+ 0,
860
+ 0,
861
+ 0
862
+ ],
863
+ "ok": true
864
+ },
865
+ "corpus_v3_test": {
866
+ "expected": [
867
+ 0,
868
+ 0,
869
+ 0
870
+ ],
871
+ "got": [
872
+ 0,
873
+ 0,
874
+ 0
875
+ ],
876
+ "ok": true
877
+ },
878
+ "m7_queries": {
879
+ "expected": [
880
+ 0,
881
+ 0,
882
+ 0
883
+ ],
884
+ "got": [
885
+ 0,
886
+ 0,
887
+ 0
888
+ ],
889
+ "ok": true
890
+ }
891
+ },
892
+ "checks": {
893
+ "inputs_size_sha_ok": true,
894
+ "eval17_sha_eq_hashing_manifest": true,
895
+ "eval17_zero_code_full": true,
896
+ "eval17_zero_code_delta": true,
897
+ "posctl_v1b_reproduces_recount64_words": true,
898
+ "posctl_seen_v1b_fully_found_in_v1b": true,
899
+ "window_table_no_collision": true
900
+ },
901
+ "PASS": true,
902
+ "peak_rss_MB": 2141,
903
+ "elapsed_s": 1982.9,
904
+ "finished": "2026-10-24 13:55:21 EDT"
905
+ }
v3_scale/recount/code_scale_v1_scan/scan64_code_scale_v1.md ADDED
@@ -0,0 +1,52 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # scan 64 o code_scale_v1 (Checker) — complet — PASS = True
2
+
3
+ - script sha256 5c247ab5e32d6a00bb9e1cdc842bbf272cafa59d87ebbc91b7427c029a53f294 ; P = 32 ; 2026-10-24 13:22:18 EDT → 2026-10-24 13:55:21 EDT ; pic RSS 2141 Mo
4
+ - fenêtres : 30 nommées (17 eval17 + seen + banc v4), 12 contenus uniques, 6756801 64-grammes uniques, collisions 0
5
+
6
+ | flux | octets | sha ok | candidats | faux positifs | positions eval17 |
7
+ |---|---|---|---|---|---|
8
+ | code_full | 527734829 | True | 1 | 1 | 0 |
9
+ | code_delta | 308316044 | True | 0 | 0 | 0 |
10
+ | v1b | 520785883 | True | 949049 | 1 | 441920 |
11
+
12
+ | fenêtre | type | octets couverts code_full | code_delta | v1b (témoin) |
13
+ |---|---|---|---|---|
14
+ | m7_fresh_en | eval17 | 0 | 0 | 0 |
15
+ | m7_fresh_fr | eval17 | 0 | 0 | 0 |
16
+ | m7_neither_code | eval17 | 0 | 0 | 241715 |
17
+ | m7_test20k | eval17 | 0 | 0 | 0 |
18
+ | m7_queries | eval17 | 0 | 0 | 0 |
19
+ | m7_freshcode | eval17 | 0 | 0 | 172156 |
20
+ | fc2 | eval17 | 0 | 0 | 0 |
21
+ | corpus_v3_test | eval17 | 0 | 0 | 0 |
22
+ | corpus_v3_oneshot | eval17 | 0 | 0 | 0 |
23
+ | broad_local_v1_test | eval17 | 0 | 0 | 41514 |
24
+ | broad_local_v1_oneshot | eval17 | 0 | 0 | 0 |
25
+ | broad_gutenberg_v1_test | eval17 | 0 | 0 | 41514 |
26
+ | broad_gutenberg_v1_oneshot | eval17 | 0 | 0 | 0 |
27
+ | old_local_v1_test | eval17 | 0 | 0 | 0 |
28
+ | old_local_v1_oneshot | eval17 | 0 | 0 | 0 |
29
+ | corpus_diverse_v1_test | eval17 | 0 | 0 | 41514 |
30
+ | corpus_diverse_v1_oneshot | eval17 | 0 | 0 | 0 |
31
+ | seen_old_local_v1 | seen_info | 0 | 0 | 200000 |
32
+ | seen_broad_local_v1 | seen_info | 0 | 0 | 200000 |
33
+ | seen_corpus_v3 | seen_info | 0 | 0 | 200000 |
34
+ | seen_broad_gutenberg_v1 | seen_info | 0 | 0 | 200000 |
35
+ | seen_corpus_diverse_v1 | seen_info | 0 | 0 | 200000 |
36
+ | seen_corpus_diverse_v1b | seen_info | 0 | 0 | 200000 |
37
+ | v4_fc2 | bench_v4_info | 0 | 0 | 0 |
38
+ | v4_fresh_en | bench_v4_info | 0 | 0 | 0 |
39
+ | v4_fresh_fr_perrault | bench_v4_info | 0 | 0 | 0 |
40
+ | v4_neither_code_kahnn | bench_v4_info | 0 | 0 | 241715 |
41
+ | v4_test20k_broad | bench_v4_info | 0 | 0 | 41514 |
42
+ | v4_queries_chat_seed | bench_v4_info | 0 | 0 | 0 |
43
+ | v4_test_v3 | bench_v4_info | 0 | 0 | 0 |
44
+
45
+ Recouvrement avec corpus_diverse_v1b (exact, octet à octet) :
46
+
47
+ - code_full : positions partagées 239297397/527734766 (0.453443), 64-grammes distincts partagés 170969875, octets couverts 253247494/527734829 (0.479876), faux positifs 62 ; référence Hashing (échantillon) 0.460112
48
+ - code_delta : positions partagées 19882968/308315981 (0.064489), 64-grammes distincts partagés 3383373, octets couverts 33827926/308316044 (0.109718), faux positifs 62 ; référence Hashing (échantillon) 0.081331
49
+
50
+ Contrôles : {"inputs_size_sha_ok": true, "eval17_sha_eq_hashing_manifest": true, "eval17_zero_code_full": true, "eval17_zero_code_delta": true, "posctl_v1b_reproduces_recount64_words": true, "posctl_seen_v1b_fully_found_in_v1b": true, "window_table_no_collision": true}
51
+
52
+ Agrégats seulement (aucun contenu, ≤ 5 décalages par flux).
v3_scale/recount/code_scale_v1_scan/scan64_code_scale_v1.py ADDED
@@ -0,0 +1,226 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #!/usr/bin/env python3
2
+ """Checker worker (Toronto, 24 oct. 2026) — scan 64 o INDÉPENDANT de code_scale_v1 (train.bin + train_delta.bin), basé sur
3
+ checker/recount/v1b_dedup_1138/recount64_words.py (hachage par mots 64 bits, PAS le poly recount64 de Hashing) ; chaque candidat confirmé octet à octet.
4
+ Étape A : fenêtres d'éval (les 17 de manifest.decontamination de Hashing, sha256 revérifiés) + seen (train[2.6M:2.8M] de 6 corpus, info) + variantes
5
+ fixes du banc v4 (bench_common.fixed_windows, info) ; flux : code full, code delta, v1b (témoin positif : doit reproduire recount64_words.json).
6
+ Étape B : recouvrement 64-grammes code_scale_v1 (full, delta) avec corpus_diverse_v1b train.bin, exact, en P passes par seau de hachage.
7
+ Écrit UNIQUEMENT dans son dossier (agrégats). Lecture seule ailleurs. Aucune écriture /tmp. SCAN_TEST=1 : tranches courtes (test rapide)."""
8
+ import sys, os, json, hashlib, time, resource, glob, datetime, zoneinfo
9
+ import numpy as np
10
+ from numpy.lib.stride_tricks import as_strided
11
+ S = "/workspace/spira_shared"; OUT = os.path.dirname(os.path.abspath(__file__))
12
+ TEST = os.environ.get("SCAN_TEST") == "1"; P = int(os.environ.get("SCAN_P", "2" if TEST else "32")); PB = P.bit_length() - 1; assert 1 << PB == P
13
+ OD = f"{OUT}/test" if TEST else OUT; os.makedirs(OD, exist_ok=True)
14
+ CS = f"{S}/hashing_gen/code_scale_v1"; V1B = f"{S}/hashing_gen/corpus_v1b/train.bin"
15
+ STREAMS = {"code_full": (f"{CS}/train.bin", 527734829, "ec957b71973a230e61d7fd143b4094550b70934ccec47f34bd0ea6b0eb2189c1"),
16
+ "code_delta": (f"{CS}/train_delta.bin", 308316044, "36f69c2fb1139597c8f913535ffe478a9565cae4a4edaa9aa3dbb26124e6ed31"),
17
+ "v1b": (V1B, 520785883, "ddf67ffb4e9f340aca7a130639580211e1eaa4b4e850cec93fb19d222f63ddb3")}
18
+ TL = 16 << 20 # test : longueur de tranche
19
+ TRANGES = {"code_full": [(0, TL)], "code_delta": [(0, TL)], "v1b": [(0, TL), (281458684, 281458684 + TL)]} # v1b : début (seen 2,6-2,8 M) + début segment multi_lang
20
+ W17 = {"m7_fresh_en": "spira_m7/windows/fresh_en.bin", "m7_fresh_fr": "spira_m7/windows/fresh_fr.bin", "m7_neither_code": "spira_m7/windows/neither_code.bin",
21
+ "m7_test20k": "spira_m7/windows/test20k.bin", "m7_queries": "spira_m7/windows/queries.bin", "m7_freshcode": "spira_m7/windows/freshcode.bin",
22
+ "fc2": "broad/freshcode_v2.bin", "corpus_v3_test": "corpus_v3/test.bin", "corpus_v3_oneshot": "corpus_v3/oneshot.bin",
23
+ "broad_local_v1_test": "broad/broad_local_v1/test.bin", "broad_local_v1_oneshot": "broad/broad_local_v1/oneshot.bin",
24
+ "broad_gutenberg_v1_test": "broad/broad_gutenberg_v1/test.bin", "broad_gutenberg_v1_oneshot": "broad/broad_gutenberg_v1/oneshot.bin",
25
+ "old_local_v1_test": "broad/old_local_v1/test.bin", "old_local_v1_oneshot": "broad/old_local_v1/oneshot.bin",
26
+ "corpus_diverse_v1_test": "corpus_diverse_v1/test.bin", "corpus_diverse_v1_oneshot": "corpus_diverse_v1/oneshot.bin"}
27
+ SEEN = {"seen_old_local_v1": "broad/old_local_v1/train.bin", "seen_broad_local_v1": "broad/broad_local_v1/train.bin", "seen_corpus_v3": "corpus_v3/train.bin",
28
+ "seen_broad_gutenberg_v1": "broad/broad_gutenberg_v1/train.bin", "seen_corpus_diverse_v1": "corpus_diverse_v1/train.bin", "seen_corpus_diverse_v1b": "hashing_gen/corpus_v1b/train.bin"}
29
+ POSCTL = "/workspace/spira_shared/checker/recount/v1b_dedup_1138/recount64_words.json"
30
+ POSMAP = {"info_broad_local_v1_test": "broad_local_v1_test", "info_neither_code_EXCLU": "m7_neither_code", "info_m7_freshcode": "m7_freshcode",
31
+ "fc2": "fc2", "fresh_en": "m7_fresh_en", "fresh_fr": "m7_fresh_fr", "test20k": "old_local_v1_test", "test_v3": "corpus_v3_test", "queries": "m7_queries"}
32
+ K = 64; CH = 8 << 20
33
+ C = np.array([0x9E3779B97F4A7C15, 0xC2B2AE3D27D4EB4F, 0x165667B19E3779F9, 0xD6E8FEB86659FD93,
34
+ 0xFF51AFD7ED558CCD, 0xC4CEB9FE1A85EC53, 0x94D049BB133111EB, 0xBF58476D1CE4E5B9], dtype=np.uint64)
35
+ FM = np.uint64(0x2545F4914F6CDD1D)
36
+ t0 = time.time()
37
+ def rss(): return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss // 1024
38
+ def log(*a): print(f"[{time.time()-t0:7.1f}s rss={rss()}MB]", *a, flush=True)
39
+ now = lambda: datetime.datetime.now(zoneinfo.ZoneInfo("America/Toronto")).strftime("%F %H:%M:%S %Z")
40
+ sha = lambda b: hashlib.sha256(b).hexdigest()
41
+ def hashes(buf): # identique à recount64_words.py
42
+ L = len(buf); n = L - K + 1
43
+ if n <= 0: return np.zeros(0, np.uint64)
44
+ out = np.zeros(n, np.uint64)
45
+ with np.errstate(over="ignore"):
46
+ for r in range(8):
47
+ m = (L - r) // 8
48
+ if m < 8: continue
49
+ w = np.frombuffer(buf, dtype="<u8", count=m, offset=r); npos = m - 7
50
+ h = np.zeros(npos, np.uint64)
51
+ for j in range(8): h += w[j:j + npos] * C[j]
52
+ h ^= h >> np.uint64(31); h *= FM; h ^= h >> np.uint64(29)
53
+ pos = r + 8 * np.arange(npos); keep = pos < n
54
+ out[pos[keep]] = h[keep]
55
+ return out
56
+ def rows(u8, idx): return as_strided(u8, shape=(len(u8) - K + 1, K), strides=(1, 1))[idx]
57
+ def stream(name, do_sha):
58
+ """(base, buf) par tranches de 8 Mo avec recouvrement 63 o ; positions de buf couvrent [base, base+len(buf)-63)."""
59
+ path, size, _ = STREAMS[name]; rngs = TRANGES[name] if TEST else [(0, size)]
60
+ s256 = hashlib.sha256() if do_sha else None; tot = 0
61
+ with open(path, "rb") as f:
62
+ for a, b in rngs:
63
+ f.seek(a); off = a; prev = b""
64
+ while off < b:
65
+ blk = f.read(min(CH, b - off))
66
+ if not blk: break
67
+ if s256: s256.update(blk)
68
+ buf = prev + blk; yield off - len(prev), buf
69
+ prev = buf[-(K - 1):]; off += len(blk); tot += len(blk)
70
+ stream.last = (s256.hexdigest() if s256 else None, tot)
71
+ res = {"script": os.path.abspath(__file__), "script_sha256": sha(open(__file__, "rb").read()), "started": now(), "test_mode": TEST, "P": P,
72
+ "method": "hachage par mots u64 (recount64_words.py), table triée + searchsorted, confirmation octet à octet de CHAQUE candidat (vectorisée)"}
73
+ # ---------------- fenêtres
74
+ man = json.load(open(f"{CS}/manifest.json")); mw = man["decontamination"]["windows"]
75
+ names, data, kind = [], [], {}
76
+ for nm, rp in W17.items():
77
+ d = open(f"{S}/{rp}", "rb").read(); names.append(nm); data.append(d); kind[nm] = "eval17"
78
+ for nm, rp in SEEN.items():
79
+ with open(f"{S}/{rp}", "rb") as f: f.seek(2_600_000); d = f.read(200_000)
80
+ names.append(nm); data.append(d); kind[nm] = "seen_info"
81
+ sys.path.insert(0, f"{S}/checker")
82
+ from windows_v2 import freshcode_v2
83
+ from build_corpus_local import strip_gutenberg_header
84
+ T = "/workspace/repos/toroidal-fractal-intelligence/data"
85
+ for nm, d in {"v4_fc2": freshcode_v2(), "v4_fresh_en": open(f"{S}/broad/broad_local_v1/oneshot.bin", "rb").read(),
86
+ "v4_fresh_fr_perrault": strip_gutenberg_header(open(f"{T}/contes_perrault.txt", "rb").read()),
87
+ "v4_neither_code_kahnn": b"\n\n".join(open(p, "rb").read() for p in sorted(glob.glob("/workspace/kahnn/data/code/*"))),
88
+ "v4_test20k_broad": open(f"{S}/broad/broad_local_v1/test.bin", "rb").read(),
89
+ "v4_queries_chat_seed": open(f"{T}/chat_seed_fr_en.txt", "rb").read(), "v4_test_v3": open(f"{S}/corpus_v3/test.bin", "rb").read()}.items():
90
+ names.append(nm); data.append(d); kind[nm] = "bench_v4_info"
91
+ wsha = [sha(d) for d in data]; usha = list(dict.fromkeys(wsha)); ucont = [data[wsha.index(s)] for s in usha]; wu = [usha.index(s) for s in wsha]
92
+ res["windows"] = {nm: {"kind": kind[nm], "bytes": len(d), "sha256": s, "n_64grams": max(0, len(d) - K + 1), "content_id": u,
93
+ **({"sha256_eq_hashing_manifest": s == mw[nm]["sha256"] and len(d) == mw[nm]["bytes"]} if nm in mw else {})}
94
+ for nm, d, s, u in zip(names, data, wsha, wu)}
95
+ res["n_windows_named"] = len(names); res["n_eval17"] = sum(k == "eval17" for k in kind.values()); res["n_unique_contents"] = len(usha)
96
+ starts = np.cumsum([0] + [len(c) for c in ucont]); Wcat = np.frombuffer(b"".join(ucont), np.uint8)
97
+ HS, CI, GP = [], [], []
98
+ for u, c in enumerate(ucont):
99
+ h = hashes(c); HS.append(h); CI.append(np.full(len(h), u, np.int16)); GP.append(starts[u] + np.arange(len(h), dtype=np.int64))
100
+ HS = np.concatenate(HS); CI = np.concatenate(CI); GP = np.concatenate(GP)
101
+ o = np.argsort(HS, kind="stable"); HS, CI, GP = HS[o], CI[o], GP[o]
102
+ first = np.r_[True, HS[1:] != HS[:-1]]; U = HS[first]; REP = GP[first]; UID = np.cumsum(first) - 1
103
+ dd = np.nonzero(~first)[0]; coll = sum(int((rows(Wcat, GP[dd[i:i + (1 << 18)]]) != rows(Wcat, REP[UID[dd[i:i + (1 << 18)]]])).any(1).sum()) for i in range(0, len(dd), 1 << 18)) # même hachage, octets différents (doublons seulement, par lots)
104
+ res["window_table"] = {"entries": int(len(HS)), "unique_64grams": int(len(U)), "intra_window_hash_collisions": coll}
105
+ log("table fenêtres", len(HS), "uniques", len(U), "collisions", coll)
106
+ is17 = np.zeros(len(U), bool)
107
+ for nm in names:
108
+ if kind[nm] == "eval17": is17[UID[CI == wu[names.index(nm)]]] = True
109
+ del o
110
+ # ---------------- étape A : flux vs fenêtres
111
+ A = {}
112
+ for sn in ["code_full", "code_delta", "v1b"]:
113
+ cnt = np.zeros(len(U), np.int32); cand = fp = 0; first17 = []
114
+ for base, buf in stream(sn, True):
115
+ h = hashes(buf)
116
+ if not len(h): continue
117
+ idx = np.searchsorted(U, h); idx[idx >= len(U)] = 0; p = np.nonzero(U[idx] == h)[0]
118
+ if not len(p): continue
119
+ cand += len(p); u = idx[p]; ok = (rows(np.frombuffer(buf, np.uint8), p) == rows(Wcat, REP[u])).all(1)
120
+ fp += int((~ok).sum()); np.add.at(cnt, u[ok], 1)
121
+ if len(first17) < 5:
122
+ q = p[ok][is17[u[ok]]]; first17 += [int(base + x) for x in q[:5 - len(first17)]]
123
+ s256, nb = stream.last; _, size, exp = STREAMS[sn]
124
+ per = {}
125
+ for nm in names:
126
+ ui = UID[CI == wu[names.index(nm)]]; gp = GP[CI == wu[names.index(nm)]] - starts[wu[names.index(nm)]]
127
+ m = cnt[ui] > 0; cov = np.zeros(len(data[names.index(nm)]), bool)
128
+ for s in gp[m]: cov[s:s + K] = True
129
+ su = np.unique(ui)
130
+ per[nm] = {"matched_window_64gram_starts": int(m.sum()), "covered_window_byte_positions": int(cov.sum()), "confirmed_stream_positions": int(cnt[su].sum())}
131
+ A[sn] = {"bytes_streamed": nb, "sha256_streamed": s256, "size_ok": (nb == size) if not TEST else None, "sha_ok": (s256 == exp) if not TEST else None,
132
+ "hash_candidates": int(cand), "hash_false_positives": int(fp), "eval17_hit_positions": int(cnt[is17].sum()), "first_eval17_offsets": first17, "per_window": per}
133
+ log(sn, "fini : candidats", cand, "fp", fp, "eval17", A[sn]["eval17_hit_positions"]); del cnt
134
+ res["stage_A"] = A
135
+ # ---------------- étape B : recouvrement code_scale_v1 ∩ v1b
136
+ nU = len(U); del HS, CI, GP, U, REP, UID, is17, Wcat
137
+ VB = np.memmap(V1B, dtype=np.uint8, mode="r")
138
+ code_len = {sn: (TL if TEST else STREAMS[sn][1]) for sn in ["code_full", "code_delta"]}
139
+ BM = {sn: np.zeros((code_len[sn] + 7) // 8 + 8, np.uint8) for sn in code_len}
140
+ B = {sn: {"shared_positions": 0, "distinct_shared_64grams": 0, "hash_candidates": 0, "hash_false_positives": 0, "recovered_via_collision_table": 0, "distinct_note": "64-grammes distincts comptés par hachage (sous-compte possible <= recovered_via_collision_table)"} for sn in code_len}
141
+ v1b_distinct = 0; v1b_coll = 0
142
+ for b in range(P):
143
+ hl, pl = [], []
144
+ for base, buf in stream("v1b", False):
145
+ h = hashes(buf); sel = np.nonzero((h >> np.uint64(64 - PB)) == b)[0] if PB else np.arange(len(h))
146
+ hl.append(h[sel]); pl.append((base + sel).astype(np.uint32)); del h, sel
147
+ H = np.concatenate(hl); Pp = np.concatenate(pl); del hl, pl
148
+ o = np.argsort(H, kind="stable"); H = H[o]; Pp = Pp[o]; del o
149
+ f1 = np.r_[True, H[1:] != H[:-1]]
150
+ # collisions intra-v1b (même hachage, octets différents) — vérifiées par lots
151
+ dup = np.nonzero(~f1)[0]; repi = (np.cumsum(f1) - 1); HU = H[f1]; PU = Pp[f1]
152
+ CH_H, CH_P = [], [] # table annexe : entrées v1b de même hachage que le représentant mais d'octets différents
153
+ for i in range(0, len(dup), 1 << 20):
154
+ d = dup[i:i + (1 << 20)]; bad = (rows(VB, Pp[d].astype(np.int64)) != rows(VB, PU[repi[d]].astype(np.int64))).any(1)
155
+ v1b_coll += int(bad.sum()); CH_H.append(H[d[bad]]); CH_P.append(Pp[d[bad]].astype(np.int64))
156
+ CH_H = np.concatenate(CH_H) if CH_H else np.zeros(0, np.uint64); CH_P = np.concatenate(CH_P) if CH_P else np.zeros(0, np.int64)
157
+ del H, Pp, f1, dup, repi; v1b_distinct += len(HU)
158
+ for sn in code_len:
159
+ mh = []
160
+ for base, buf in stream(sn, False):
161
+ h = hashes(buf); sel = np.nonzero((h >> np.uint64(64 - PB)) == b)[0] if PB else np.arange(len(h))
162
+ if not len(sel): continue
163
+ hs = h[sel]; idx = np.searchsorted(HU, hs); idx[idx >= len(HU)] = 0; e = HU[idx] == hs; p = sel[e]; u = idx[e]
164
+ B[sn]["hash_candidates"] += len(p)
165
+ if not len(p): continue
166
+ ok = (rows(np.frombuffer(buf, np.uint8), p) == rows(VB, PU[u].astype(np.int64))).all(1)
167
+ for j in np.nonzero(~ok)[0]: # faux positif vs représentant : vérifier la table annexe (collisions v1b)
168
+ pj = int(p[j]); gj = buf[pj:pj + K]
169
+ if any(bytes(VB[q:q + K]) == gj for q in CH_P[CH_H == hs[e][j]].tolist()): ok[j] = True; B[sn]["recovered_via_collision_table"] += 1
170
+ B[sn]["hash_false_positives"] += int((~ok).sum()); p = p[ok]; mh.append(hs[e][ok])
171
+ B[sn]["shared_positions"] += len(p)
172
+ g = base + p; a0 = (base // 8) * 8; loc = np.zeros(base + len(h) - a0 + 8, bool); loc[g - a0] = True
173
+ pk = np.packbits(loc); BM[sn][a0 // 8: a0 // 8 + len(pk)] |= pk
174
+ if mh: B[sn]["distinct_shared_64grams"] += int(len(np.unique(np.concatenate(mh))))
175
+ del mh
176
+ del HU, PU, CH_H, CH_P
177
+ log(f"passe {b+1}/{P} : v1b distincts cumulés {v1b_distinct} ; " + " ; ".join(f"{sn} partagés {B[sn]['shared_positions']}" for sn in code_len))
178
+ for sn in code_len:
179
+ L = code_len[sn]; npos = L - K + 1; st = np.unpackbits(BM[sn])[:npos].astype(np.int32) if L < (64 << 20) else None
180
+ cov = 0
181
+ if st is not None:
182
+ c = np.concatenate([[0], np.cumsum(st)]); i = np.arange(L); lo = np.maximum(i - K + 1, 0); hi = np.minimum(i, npos - 1)
183
+ cov = int(((c[hi + 1] - c[lo]) > 0).sum())
184
+ else: # par tranches de 32 Mo : octet i couvert ssi un départ dans [i-63, i]
185
+ step = 32 << 20; tail = np.zeros(K - 1, np.int32)
186
+ for a in range(0, L, step):
187
+ bb = min(a + step, L); s = np.unpackbits(BM[sn][a // 8: (bb + 7) // 8])[:bb - a].astype(np.int32)
188
+ s[np.arange(a, bb) >= npos] = 0
189
+ x = np.concatenate([tail, s]); c = np.concatenate([[0], np.cumsum(x)])
190
+ cov += int(((c[K:] - c[:-K]) > 0).sum()); tail = x[-(K - 1):]
191
+ B[sn].update(positions_total=npos, covered_bytes=cov, bytes_total=L, share_positions=round(B[sn]["shared_positions"] / npos, 6), share_bytes_covered=round(cov / L, 6))
192
+ res["stage_B"] = {"v1b_distinct_64grams": int(v1b_distinct), "v1b_intra_hash_collisions": int(v1b_coll), **B,
193
+ "hashing_reference_sampled_share": {"code_full": man["overlap_corpus_diverse_v1b"]["byte_level_sampled"]["full"]["share"],
194
+ "code_delta": man["overlap_corpus_diverse_v1b"]["byte_level_sampled"]["delta"]["share"]}}
195
+ # ---------------- contrôles
196
+ pc = json.load(open(POSCTL))["per_window"]; posctl = {}
197
+ for k0, nm in POSMAP.items():
198
+ a = A["v1b"]["per_window"][nm]; r = pc[k0]
199
+ posctl[nm] = {"expected": [r["matched_window_64gram_starts"], r["covered_window_byte_positions"], r["confirmed_train_positions"]],
200
+ "got": [a["matched_window_64gram_starts"], a["covered_window_byte_positions"], a["confirmed_stream_positions"]]}
201
+ posctl[nm]["ok"] = posctl[nm]["expected"] == posctl[nm]["got"]
202
+ res["positive_control_v1b_vs_recount64_words"] = posctl
203
+ sv = A["v1b"]["per_window"]["seen_corpus_diverse_v1b"]
204
+ ev = [nm for nm in names if kind[nm] == "eval17"]
205
+ res["checks"] = {"inputs_size_sha_ok": None if TEST else all(A[s]["size_ok"] and A[s]["sha_ok"] for s in A),
206
+ "eval17_sha_eq_hashing_manifest": all(res["windows"][nm]["sha256_eq_hashing_manifest"] for nm in ev),
207
+ "eval17_zero_code_full": all(A["code_full"]["per_window"][nm]["covered_window_byte_positions"] == 0 for nm in ev),
208
+ "eval17_zero_code_delta": all(A["code_delta"]["per_window"][nm]["covered_window_byte_positions"] == 0 for nm in ev),
209
+ "posctl_v1b_reproduces_recount64_words": None if TEST else all(v["ok"] for v in posctl.values()),
210
+ "posctl_seen_v1b_fully_found_in_v1b": sv["covered_window_byte_positions"] == 200_000,
211
+ "window_table_no_collision": coll == 0}
212
+ res["PASS"] = None if TEST else all(res["checks"].values())
213
+ res["peak_rss_MB"] = rss(); res["elapsed_s"] = round(time.time() - t0, 1); res["finished"] = now()
214
+ json.dump(res, open(f"{OD}/scan64_code_scale_v1.json", "w"), indent=1, ensure_ascii=False)
215
+ md = [f"# scan 64 o code_scale_v1 (Checker) — {'TEST tranches' if TEST else 'complet'} — PASS = {res['PASS']}", "",
216
+ f"- script sha256 {res['script_sha256']} ; P = {P} ; {res['started']} → {res['finished']} ; pic RSS {res['peak_rss_MB']} Mo",
217
+ f"- fenêtres : {len(names)} nommées ({res['n_eval17']} eval17 + seen + banc v4), {len(usha)} contenus uniques, {nU} 64-grammes uniques, collisions {coll}",
218
+ "", "| flux | octets | sha ok | candidats | faux positifs | positions eval17 |", "|---|---|---|---|---|---|"]
219
+ md += [f"| {s} | {A[s]['bytes_streamed']} | {A[s]['sha_ok']} | {A[s]['hash_candidates']} | {A[s]['hash_false_positives']} | {A[s]['eval17_hit_positions']} |" for s in A]
220
+ md += ["", "| fenêtre | type | octets couverts code_full | code_delta | v1b (témoin) |", "|---|---|---|---|---|"]
221
+ md += [f"| {nm} | {kind[nm]} | {A['code_full']['per_window'][nm]['covered_window_byte_positions']} | {A['code_delta']['per_window'][nm]['covered_window_byte_positions']} | {A['v1b']['per_window'][nm]['covered_window_byte_positions']} |" for nm in names]
222
+ md += ["", "Recouvrement avec corpus_diverse_v1b (exact, octet à octet) :", ""]
223
+ md += [f"- {sn} : positions partagées {B[sn]['shared_positions']}/{B[sn]['positions_total']} ({B[sn]['share_positions']}), 64-grammes distincts partagés {B[sn]['distinct_shared_64grams']}, octets couverts {B[sn]['covered_bytes']}/{B[sn]['bytes_total']} ({B[sn]['share_bytes_covered']}), faux positifs {B[sn]['hash_false_positives']} ; référence Hashing (échantillon) {res['stage_B']['hashing_reference_sampled_share'][sn]}" for sn in B]
224
+ md += ["", f"Contrôles : {json.dumps(res['checks'], ensure_ascii=False)}", "", "Agrégats seulement (aucun contenu, ≤ 5 décalages par flux)."]
225
+ open(f"{OD}/scan64_code_scale_v1.md", "w").write("\n".join(md) + "\n")
226
+ log("DONE PASS", res["PASS"], json.dumps(res["checks"]))