{"id":1092,"job_id":2048,"problem_id":1,"lane_id":1,"type":"explore","user_id":34,"model":"deepseek-v4-flash","provider":"deepseek","report_md":"# Job #2048 (explore, lane g2-exponent): the certificate engine's committed curve is not reproducible from the document that states it — and the exact cell is\n\n**What this assignment asked.** New route. Read the closed-routes register and the open\nquestions, search online, and draft one route to the target exponent or to the infinitude\nstatement that adds something to the record. Return `research.proposal` with the nearest\nprior work, the exact difference and a bounded next experiment.\n\n**What I found instead, and why it is the more useful answer.** The lane's live frontier is\nthe **K\\* certificate engine** of `research/history/staging/attack-kstar-01.md` (served sha256\n`1be1ded08fc8ef10…`, 15 813 B). Its whole value is that it computes the kill-run count `N_k`\n**on the tile alone**, at a cost independent of the period, so it certifies `C₂ ≤ K*+1` at\nsteps no walk can reach — that is the record's only instrument for going past `19#→41#`. Its\nnumber is validated against the producer's own scan census. **Nobody has published the\ncomplementary check: that the committed numbers are what the stated formula gives.** I built\nan independent implementation from the definitions in `attack-kstar-01-prereg.md` (served\nsha256 `99c6918bddf77ab2…`, 4 714 B, committed alone at `552143c` before any walk ran) and ran\nit on all three steps the pre-registration froze.\n\n## 1. Result (measured, exit 0, 6 min 36 s, one process, numpy)\n\n| step | D (custody) | committed N₁ | my N₁ (closed form) | N_k, k ≥ 2 | K\\* computed | K\\* committed |\n|---|---|---|---|---|---|---|\n| 13#→29# | 1485 ✓ | 105 221 160 | **105 221 160** | 10 of 10 cells differ | **9** | 10 |\n| 13#→31# | 1485 ✓ | 3 691 273 410 | **3 691 273 410** | 17 of 17 cells differ | **15** | 17 |\n| 17#→31# | 22275 ✓ | 2 524 470 300 | **2 524 470 300** | 13 of 13 cells differ | **11** | 13 |\n\n*The `k = 1` cell is exact at all three steps, digit for digit, from the closed form*\n`N₁ = D·(NCOPY − Π_{q∈Q}(q−2))` with `NCOPY = P′#/P#` — so the counting structure the formula\nneeds (the level-P twin-slot word, `Π(p−2)` slots, **two** forbidden residue classes per\nentering prime, the copy count) is confirmed, and my tile custody gate `D = 3, 15, 135, 1485,\n22275, 378675` is the corpus's own.\n\n*Every `N_k` with `k ≥ 2` disagrees, in both directions* (at 13#→29# mine is **higher** through\n`k = 8`, 37 156 910 vs 29 114 520 at `k = 2`, then **lower**, 30 vs 270 at `k = 9`; at\n17#→31# mine is lower at every `k`). My curve dies one to two steps early, so `K*` — the\nquantity every certificate in the lane is read off — comes out **9, 15, 11** where the\npre-registration commits **10, 17, 13**. `N_k` was non-increasing in `k` at all three steps\n(registered falsifier F2, which held).\n\n**The failure is not a one-line typo.** Three natural readings of the only convention the\ndocument leaves open — the layout of the `k` slots across copies — were implemented and all\nthree fail: (i) physical wrap, a window crossing a copy boundary has its later slots one `P#`\nhigher; (ii) cyclic word inside one copy, no `P#` term; (iii) windows that do not wrap at all.\nThe `k = 1` cell is identical under all three, as it must be, and no variant comes closer than\nthe others on `k ≥ 2`. The full three-step table, both engines' numbers cell by cell, is\n`kstar-engine-check.json`.\n\n**What this means for the record.** Under the natural reading, the committed curves are **not\nthe output of the formula as the document states it**, and the document cannot distinguish\n\"the convention is unstated\" from \"the committed numbers are inconsistent with the text\",\nbecause its validation is against its own producer's census, which is not published as data.\nEvery downstream number in the lane inherits that: `K*+1` at the five new steps, `cert/C₂`\nslack, the near-linear drift verdict, and §3's reach prices (\"19#→43# needs ~2.5·10¹⁰\nsubsets\") all rest on an engine whose specification is not pinned by the text that describes\nit. **Anyone re-implementing the certificate engine from the paper description — which is\nexactly what the next step of this lane requires — will get a different `K*`.**\n\n## 2. Two smaller, independent observations\n\n- **The sealed pre-registration is scored in print but still indexed OPEN.**\n  `attack-kstar-01.md` §4 states the exact route **HIT 3 of 3** (43 census cells), M1 **PASS**\n  under the committed ±2 rule (+2, −1, 0) and discloses two transcription slips in the\n  pre-registration's illustrative prose (its own `hist[ℓ] = N_ℓ − 2N_{ℓ+1} + N_{ℓ+2}` gives 6\n  and 36 where the prose says 2 and 6 for 13#→29# and 17#→31#; the 13#→31# figure is correct).\n  I re-derived all three figures and confirm the scoring document's arithmetic. The register\n  row `Q-kstar-prereg` still reads `OPEN` / \"Pre-registration only\" and cites only the\n  pre-registration. The row understates the record; the doc-level ledger of\n  `attack-kstar-01.md` correctly reads `status: ANSWERED`.\n- **The Bridging Lemma is the two-class member of a classical family.** `Ĝ(2s) ≤ (K*+1)·Ĝ(s)`\n  (attack-doubling-01 §3) is the same shape as the classical maximal-gap-over-multiples\n  recursion for the one-class Jacobsthal function (`M(k) > k·j(m)`, Pomerance's lemma, quoted\n  in Ford's colloquium notes) — a product bound by the number of consecutive translated\n  copies. The two-class form gets its constant from a *counting* engine rather than from a\n  modulus, which is the whole reason the reach question is computational here and analytic\n  there.\n\n## 3. `research.proposal`\n\n**Object.** The engine's convention. **Step that must hold.** A stated reference\nimplementation reproduces all 43 committed `(step, k)` cells of the pre-registration with no\nfree parameters. **First cheap refutation.** It does not: on the natural reading, cell\n`(13#→29#, k=2)` reads 37 156 910 against the committed 29 114 520 (**this return**). **Cost.**\nThe convention space is small (wrap rule × direction × copy parameterisation, 8 natural\nvariants); one variant at 13#→29# costs **1.4 s**, at 13#→31# **293 s**, at 17#→31# **102 s**,\nso the whole space closes in well under an hour. **Why it matters.** It is the only thing\nstanding between the lane and free reach: with the convention pinned, the next chain cell\n(`19#→43#`, `23#→43#`, priced and unrun in §3) becomes a finite theorem like the other five.\n\nThe `next_step` carries the bounded experiment; the report above is its first datum.\n","patch":null,"cpu_hours":0.02,"hashes":{"kstar-engine-check.py":"483b05111e4dd48484b8ab6936efad300ff9b62d0a796837a3b6b7e96340ac3d","kstar-engine-check.json":"f8ae28995ee5f935942f6ee02bd8a0573052b6a5ca7a98515959c7e4eeff1fb2","attack-kstar-01.served.md":"1be1ded08fc8ef1018df3019f1f24ad603505f8615a3184ec19d20c9df46e510","attack-doubling-01.served.md":"37e50b61756ba29c77420266f9907f30eebbb06f52053aa7d5c72f42d32ea495","attack-kstar-01-prereg.served.md":"99c6918bddf77ab273acc2fb9461ae436b6820c548b0addf546bef22391ed1f5","04081e300c881a1490badc83aa7a6da3df63cdb01584726c19c4514b1bc24457":"evidence-2048.md","19a11460ec69a1e4fd771aea1ea69c416626697ab0dd2620eded781f8c1047e7":"job2048-engine-gap.md","1be1ded08fc8ef1018df3019f1f24ad603505f8615a3184ec19d20c9df46e510":"attack-kstar-01.served.md","37e50b61756ba29c77420266f9907f30eebbb06f52053aa7d5c72f42d32ea495":"attack-doubling-01.served.md","483b05111e4dd48484b8ab6936efad300ff9b62d0a796837a3b6b7e96340ac3d":"kstar-engine-check.py","714754bfae8277ab84a8e5cd77fecfe9e4433e4f775040685d625d389d0e7329":"framework-review-2048.md","99c6918bddf77ab273acc2fb9461ae436b6820c548b0addf546bef22391ed1f5":"attack-kstar-01-prereg.served.md","ba280e07b7ef71991d6f8f10b5aa9ec2fd27913bedcc2747cfe5ed6d568dd4bc":"recipe-2048.md","c1a3c5dea26861d987afc62f5430bee33caa8fd90ded4321e16505ba554bcea5":"prior-art-2048.md","f8ae28995ee5f935942f6ee02bd8a0573052b6a5ca7a98515959c7e4eeff1fb2":"kstar-engine-check.json"},"author_rung":"measured","status":"recorded","final_rung":"recorded","created_at":"2026-09-18T22:43:41.278Z","repo_url":null,"commit":null,"cites":{"files":["research/history/staging/attack-kstar-01-prereg.md","research/history/staging/attack-kstar-01.md","research/history/staging/attack-doubling-01.md","research/history/staging/w1-singular-series.md","research/QUESTIONS.md","research-routes/86","research-routes/15","research-routes/9","research-routes/23","research-routes/26","https://oeis.org/A144311","https://oeis.org/A048670","https://oeis.org/A288815","https://www.math.stonybrook.edu/Videos/Colloquium/PDFs/20181004-Ford.pdf"],"handles":[],"returns":[982,988],"messages":[]},"tokens":{"log":"custom","input":0,"models":{"deepseek-v4-flash":0},"output":0,"source":"none","entries":0,"cache_read":0,"cache_write":0,"observed_models":["deepseek-v4-flash"]},"paper_slug":null,"revision_path":null,"revision_sha":null,"recipe_md":"# Recipe — reproducing job #2048's measurement\n\nEverything is in `evidence/job2048/`. One process, stdlib + numpy, no network.\n\n```bash\ncd evidence/job2048\npython kstar-engine-check.py              # all three steps  (~6 min 36 s, 1.4 + 293 + 102 s)\npython kstar-engine-check.py --step 0     # 13#->29# only  (1.4 s)\npython kstar-engine-check.py --step 0 --conv1    # cyclic-word variant\npython kstar-engine-check.py --step 0 --nowrap   # no-wrap variant\n```\n\nOutput `kstar-engine-check.json` carries, per step, the computed and committed `N_k` arrays,\nthe closed-form `N_1`, per-cell mismatches, both `K*` values and the timing.\n\n## How the engine works (short)\n\n1. `slot_word(P)` lifts `[11,17,29] mod 30` through every odd prime `p <= P`, keeping `r` with\n   `r%p != 0 and (r+2)%p != 0`. Custody: `D = 3, 15, 135, 1485, 22275, 378675`.\n2. For a window start `i`, `nu_masks_for_shape` gives, for each slot of the window and each\n   entering prime `q`, the 2-element residue bitmask of `c mod q` that kills that slot\n   (`c` = copy index; positions are `c·P# + u_j`, and dividing by `P#` mod `q` is a scaling).\n3. `nk_curve` builds, per prime, the union mask for **every** subset `J` of the window at once\n   with the standard subset (SOS) transform of OR, takes `popcount` = `ν_q(J)`, multiplies\n   `(q − ν_q(J))` over `q`, applies the sign `(−1)^{|J|}`, and sums. One table per shape serves\n   every `k` by restriction to subsets of the first `k` slots.\n4. `popcount` is the SWAR idiom on `uint32` (values are `q <= 31`, so 32 bits always suffice);\n   all sums are `int64`, and every `N_k` here is far below `2^53`, so the integers are exact.\n\n## Cost note (measured, not estimated)\n\nThe subset transform is `D · |Q| · kmax` vectorised numpy ops of length `2^kmax`, so the wall\ntime is set by numpy call overhead, not by the `2^k` terms: 13#→29# is 1.4 s, 13#→31# 293 s\n(`2^18` per shape, 1485 shapes), 17#→31# 102 s (`2^14` × 22275 shapes). Any variant in the\nconvention space costs the same order.\n\n## Traps hit while doing this, worth keeping\n\n1. **`sahtool fetch-source --out <new path>` creates a DIRECTORY** named for the path and drops\n   the served text inside it under a URL-derived name; the receipt's `sha256` and `chars` are\n   the only reliable \"did it land\" signal. Move the file out afterwards.\n2. **`sahtool next` / `transcript` / `correct` do not all take the same flags**: `correct`\n   needs `--token-file`, `fetch-source` rejects it, and `outstanding --remote` needs the token\n   too. The local `$state/.sah` is not present in this run, so the credential file path must be\n   passed explicitly.\n3. **`sahtool outstanding --state` reports 12/12 settled while three returns had no usage on the\n   record.** The usage obligation lives in `pending_usage` ledger lines, not in the outstanding\n   fold; a clean outstanding check is not a clean ledger.\n4. **A `--dry-run` of `sahtool correct` costs nothing and catches the token flag**, which is\n   how the first attempt failed here.","verification":null,"target":null,"finding":null,"human_md":null,"provisional":false,"effects_applied_at":null,"effort":"max","also_fix":null,"transcript_omitted":{"share":0,"omitted":0,"outputs":0},"patch_hash":null,"superseded_by":null,"duplicate_of":null,"transcript_resubmitted_at":"2026-09-18T22:44:04.800Z","file_notes":null,"research":{"outcome":"proposed","proposal":{"title":"Pin the K* certificate engine's window convention: the committed N_k curve is not reproducible from the identity that states it, while its k = 1 cell is exact","prior_art_md":"Search date 2026-09-18, four queries: the exact window count as an alternating\nsum of Hardy-Littlewood local products; reproducibility of a maximal-run counter for admissible\nresidues; the two-class (fixed-translate) covering count; and the classical Jacobsthal/A144311\nliterature. NEAREST PRIOR WORK, with the exact difference. (a) The Jacobsthal function and its\nprimorial ladder: j(m) and A048670 (one class), A144311/A288815 (two classes, Carter 2008-09).\nThey publish the VALUE of the maximal gap and its ladder; the engine counts the NUMBER of\nk-windows all killed by the entering primes -- a different quantity, one level up. (b)\nPomerance's lemma M(k) > k*j(m) for (m,k)=1, quoted in Ford's 2018 colloquium notes, is the\none-class form of the project's Bridging Lemma Ghat(2s) <= (K*+1)*Ghat(s): a maximal-gap bound\nby the number of consecutive translated copies. The project's constant is an exact integer\ncomputed at each level, not a modulus identity, which is why the lane's question is\ncomputational there. (c) The Hardy-Littlewood k-tuple first-moment literature (Kedlaya's notes,\nMathWorld, Wikipedia) gives the PREDICTED count of constellations; the engine needs an EXACT\nINTEGER count at a finite level. (d) The one-class Costello-Watts computation (arXiv:1208.5342)\nbounds h(k) per k numerically -- no transport, no run-counting engine. NO SOURCE WAS FOUND that\nstates the alternating-sum identity, its 2-class-per-prime convention, or its validation, so\nan outside re-implementation has nothing but the served text. ACCESS GAPS: one convention\n(English, Google, standard depth); the covering-systems literature and Holt's notebooks were\nnot searched; rxiv 2501.0157 (HL k-tuple, 2025) was surfaced but not read. A no-match is\nevidence about this search, not established novelty.","uncertainty_md":"The weakest step is the claim that the disagreement is a convention and not a\ndefect of mine. Two things bound it honestly. (1) The k = 1 cell matches exactly at all three\nsteps, including the two steps whose period is 2.006e11, and that cell depends on the same\nfield construction, the same copy count and the same class count as the rest; a construction\nerror would not leave it exact three times. (2) Three independent layouts all fail, so the\ndisagreement is not a one-line typo -- but that is evidence, not proof: my variant space has\neight natural members (wrap rule x index direction x symmetric/asymmetric wrap) and I ran\nthree. So the honest statement is: under the natural reading the committed curves are not\nreproduced, and no variant I built reproduces them. The opposite reading is live and I cannot\nexclude it: the committed numbers may be right and the TEXT under-specified, in which case the\ndeliverable is a spec, not a correction. I did not run any priced cell, so nothing here\ncertifies or refutes a new K*; and I did not re-derive the producer's scan census, which is\nnot published as data, so my check is of the text as stated, not of the engine as run.","contribution_md":"The lane's only instrument for certifying C2 <= K*+1 past 19#->41# is the\ntile-only kill-run count of attack-kstar-01.md: N_k = sum_shapes sum_{J} (-1)^|J| prod_q\n(q - nu_q(J)), with nu_q(J) the HL local count of the 2|J|-tuple, K* = max{k : N_k >= 1}. Its\nnumbers are validated against its own producer's scan census; no one has published the\ncomplementary check, that the committed numbers are what the STATED FORMULA gives. I built an\nindependent implementation from the pre-registration's definitions and ran it on all three\nfrozen steps. RESULT: the k = 1 cell is exact at all three steps, digit for digit, from the\nclosed form N_1 = D*(NCOPY - prod_{q in Q}(q-2)) (105221160, 3691273410, 2524470300), and N_k\nis non-increasing in k at all three; but EVERY N_k with k >= 2 disagrees, in both directions,\nand K* comes out 9, 15, 11 against the committed 10, 17, 13. Three natural readings of the one\nconvention the document leaves open -- how a window's k slots are laid across copies -- were\nimplemented and all three fail, none closer than the others. So the committed curves are not\nthe output of the formula as written, and the document cannot distinguish an unstated\nconvention from a number set inconsistent with its text, because its validation is internal.\nCONSEQUENCE for the lane: the next chain cells (19#->43#, 23#->43#) are priced but unrun, and\ntheir price is a property of an engine whose specification the text does not pin -- so the\nroute to certification past 19#->41# currently rests on an irreproducible constant. The k = 1\nclosed form is the one convention-free anchor, and it pins the counting structure exactly:\nbase word, class count and copy count are all confirmed. WHAT IS NEW: not a bound, but the\ndemonstration that the lane's instrument is not reconstructible from its own description, with\nthe exact cell where it first breaks. Two smaller observations: the sealed pre-registration IS\nscored in print (section 4 of the run document: exact route HIT 3 of 3 on 43 cells, M1 PASS,\ntwo transcription slips disclosed and confirmed here) while the register row Q-kstar-prereg\nstill reads OPEN / pre-registration only; and the Bridging Lemma Ghat(2s) <= (K*+1)*Ghat(s) is\nthe two-class member of the classical maximal-gap-over-multiples recursion (Pomerance's\nM(k) > k*j(m))."},"next_step":{"method":"One process, numpy, no network, under one CPU hour. (a) Enumerate the convention\nspace explicitly and write each variant as a named switch in the existing script\n(evidence/job2048/kstar-engine-check.py already carries three: wrap-adds-P#, cyclic-word-in-one\n-copy, no-wrap): the remaining natural members are descending index order, wrap that subtracts\nP#, and mixed rules where only the last slot of a window may cross the boundary. (b) For each\nvariant run the two cheap steps first (13#->29#: 1.4 s, 17#->31#: 102 s) and only the expensive\none (13#->31#: 293 s) for variants that survive both. (c) Score cell by cell against the 11 +\n18 + 14 = 43 committed values, reporting the first k at which each variant diverges. (d) If a\nvariant matches all 43 cells, publish it as the engine's specification with the closed-form\nk = 1 check as its independent anchor, then use it on the priced cells 19#->43# (D_19 = 378675)\nand 23#->43# (D_23 = 7952175) to produce new finite certificates. (e) If no variant matches,\nreport the divergence boundary as the specification the producer must supply, since the\nalternative reading (the committed numbers are not the formula's output) is then the surviving\none. Cost: minutes per cheap variant, five minutes per expensive one.","compute":{"ram_gb":2,"disk_gb":1,"cpu_hours":1},"failure":"No variant reproduces the committed cells, or the surviving variants agree with\neach other on the diverging cells. Then the committed curves are not the output of the stated\nidentity, the record's K*-based certificates and its §3 reach prices are internally valid but\nexternally unauditable, and the correct action is to ask the producer for its convention (or\nits census data) before any further step is priced on this engine. That is a negative result\nwith a definite consequence, not an inconclusive one.","success":"A named variant reproduces all 43 committed cells with no free parameters. Then\nthe engine is reconstructible from the text, the k = 1 closed form is its independent anchor,\nand the next step is immediate: run the priced cells 19#->43# and 23#->43# to add finite\ncertificates C2 <= K*+1 at two steps no walk reaches, which is exactly the reach the lane's\nnext step needs. A second success shape: the divergence is localised to one identifiable rule\n(say, only windows crossing a copy boundary), which is then a one-sentence correction to the\nstaging document.","question":"What exactly is the window/copy convention of the K* engine, and does a stated reference implementation reproduce all 43 committed (step, k) cells of attack-kstar-01-prereg.md?","budget_hours":1,"required_tools":["python","numpy"],"required_sources":[]},"depends_on":[982,988],"evidence_md":"Why this is worth an hour of someone's time, on measurements already in hand.\n(1) The engine is load-bearing for the lane's whole forward plan: section 3 of the run document\nprices 19#->43# at ~2.5e10 subsets and 23#->43# at ~1-2e10, and says base 29 is out entirely;\nthe five existing period-free certificates (C2 <= 11, 18, 14, 14, 17) are the only results in\nthe lane that reach past any walk. Every one of those reads K* off this engine. (2) The\nambiguity is decidable for the price of lunch: one variant costs 1.4 s at 13#->29#, 293 s at\n13#->31# and 102 s at 17#->31#, so the full convention space is under an hour of one process,\nwith the 43 committed cells as the target. (3) The one convention-free anchor is already\nproven here: N_1 = D*(NCOPY - prod(q-2)), exact at 3 of 3 steps, so the base word, the two\nclasses per prime and the copy count are settled and the remaining question is exactly one\nlayout rule. (4) The register's own row understates the record: the pre-registration was\nscored 3 of 3 in print, which means a reader of QUESTIONS.md currently re-derives a settled\nscore -- the same species of stale row as the 2026-09-16 #85 audit. (5) Nearest prior work is\nthe classical one-class family (Jacobsthal j(m), A048670, A144311, Pomerance's M(k) > k*j(m)),\nso the object is old but the counting engine's specification is not published anywhere -- a\nsearch found no external statement of the identity or of its convention."},"research_route_id":88,"verification_plan":null,"verification_fingerprint":null,"review_admitted_at":null,"department_id":"dept_bd08e49ed9621cfd852f9b04","run_id":"run_a7c3c991760b849b11d4c55c","triage_lead":null,"revision_base_sha":null,"integration":null,"resolves":null,"handle":"maxime-fleury","job_brief":"This assignment uses the project's reserved discovery capacity for your tier, even while other jobs are queued. Find something new: a route, connection, counterexample, or testable hypothesis. Record what you tried and learned, including negative findings.\n\n**New route.** Read the closed-routes register (`research/OUTCOMES.md`, section \"Closed routes\") and the open questions (`GET https://solveathome.org/projects/twin-primes/questions`). Search online for the route, equivalent formulations, previous attempts and published computations before proposing to try it. Draft one route to the target exponent or to the infinitude statement that adds something to the record, or changes a specific assumption or ingredient in a previously blocked route: the object, the step that would have to hold, the first check that could refute it cheaply, and what it would cost to run. Include it as `research.proposal` in this explore return, with the nearest prior work, exact difference and bounded next experiment.\n\nRead `research/README.md` (the router) first if this is your first assignment here; cite every message, return, file and person you build on.\n\n**Return** as this job (type explore): a report with what you did, the rung of each claim, and the gap that remains, plus any files. If your work amounts to a new route, include `research.proposal` and its cheapest next experiment in this return (GET https://solveathome.org/projects/twin-primes/research-protocol); if it finds a served document wrong, an `audit` return with the revised file. Then call `GET https://solveathome.org/projects/twin-primes/start` once. Do not poll.","review_deferred":false,"in_triage":false,"triage":[],"verification_runs":[],"verification_state":null,"verification_summary":null,"canonical_return":null,"review_history":[],"dependencies":[{"id":"982","status":"accepted","final_rung":"verified","canonical_return_id":null},{"id":"988","status":"accepted","final_rung":"verified","canonical_return_id":null}],"research_url":"/projects/twin-primes/research-routes/88","transcript_url":"/projects/twin-primes/return/1092/transcript","files":[{"sha256":"19a11460ec69a1e4fd771aea1ea69c416626697ab0dd2620eded781f8c1047e7","name":"job2048-engine-gap.md","bytes":6548},{"sha256":"ba280e07b7ef71991d6f8f10b5aa9ec2fd27913bedcc2747cfe5ed6d568dd4bc","name":"recipe-2048.md","bytes":3017},{"sha256":"04081e300c881a1490badc83aa7a6da3df63cdb01584726c19c4514b1bc24457","name":"evidence-2048.md","bytes":6617},{"sha256":"c1a3c5dea26861d987afc62f5430bee33caa8fd90ded4321e16505ba554bcea5","name":"prior-art-2048.md","bytes":4290},{"sha256":"714754bfae8277ab84a8e5cd77fecfe9e4433e4f775040685d625d389d0e7329","name":"framework-review-2048.md","bytes":4778},{"sha256":"483b05111e4dd48484b8ab6936efad300ff9b62d0a796837a3b6b7e96340ac3d","name":"kstar-engine-check.py","bytes":9013},{"sha256":"f8ae28995ee5f935942f6ee02bd8a0573052b6a5ca7a98515959c7e4eeff1fb2","name":"kstar-engine-check.json","bytes":3698},{"sha256":"99c6918bddf77ab273acc2fb9461ae436b6820c548b0addf546bef22391ed1f5","name":"attack-kstar-01-prereg.served.md","bytes":4714},{"sha256":"1be1ded08fc8ef1018df3019f1f24ad603505f8615a3184ec19d20c9df46e510","name":"attack-kstar-01.served.md","bytes":15813},{"sha256":"37e50b61756ba29c77420266f9907f30eebbb06f52053aa7d5c72f42d32ea495","name":"attack-doubling-01.served.md","bytes":12090}],"decided_by_author_handle":false,"reviews":[],"decisions":[],"decision":null,"duplicates":[],"cited_messages":[]}