#!/usr/bin/env python3 # -*- coding: utf-8 -*- """Assemble artifacts/report-tpc-conditional-1570.md from the graph's own generated output. The prose is here; every table and every count in the report is read out of artifacts/tpc-deps.render.md and work/tpc-deps-selftest.json, which `work/tpc_deps.py` produced. No number in the report is typed by hand, so the document cannot drift from the model it describes: `python work/tpc_deps.py render && python work/make_report1570.py` regenerates it. """ import hashlib import json import os import sys sys.stdout.reconfigure(encoding="utf-8", errors="replace") RUN = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) def read(rel): with open(os.path.join(RUN, rel), encoding="utf-8") as fh: return fh.read() def sha(rel): return hashlib.sha256(open(os.path.join(RUN, rel), "rb").read()).hexdigest() RENDER = read("artifacts/tpc-deps.render.md").rstrip() SELF = json.load(open(os.path.join(RUN, "work", "tpc-deps-selftest.json"), encoding="utf-8")) DEPS = json.load(open(os.path.join(RUN, "artifacts", "tpc-deps.json"), encoding="utf-8")) manifest = {} for line in read("evidence/docs-manifest.jsonl").splitlines(): line = line.strip() if not line: continue j = json.loads(line) if j.get("doc") in ("README.md", "research/ZONE-POSTULATE.md", "research/TWIN-REDUCTION.md", "research/RESEARCH-HANDOFF.md", "research/structured-dispersion-estimate.md", "research/fixed-endpoint-discrepancy.md"): manifest[j["doc"]] = j["sha256"] rows = {r["member"]: r for r in SELF["branches"]} n_open = sum(1 for n in DEPS["nodes"] if n["tag"] == "open") n_ref = sum(1 for n in DEPS["nodes"] if n["tag"] == "refuted") n_est = len(DEPS["nodes"]) - n_open - n_ref BODY = """# The end-to-end conditional implication of the twin-prime target, as a dependency graph Job **#1570** (explore, discovery, lane `formalize`, no route assigned), attempt `fd9501bd50a20b39759d44ec8f1198e2`. The person's instruction: build the conditional implication of TPC end to end — one document plus an executable dependency graph in which every input carries a rung, every leaf is attached to its return or document, and a query returns the root's lethal set. **What this is.** A single object that holds the whole chain, from "infinitely many twin primes" down to the concrete estimates the corpus is working on: **{n_nodes} nodes**, each with a rung from a fixed vocabulary, an owner, the literal tokens that make its numbers checkable in that owner, and its edges. `work/tpc_deps.py` is the graph; `artifacts/tpc-deps.json` is its export; every table below is that tool's own output. **Nothing here is a new estimate, and no rung is upgraded by being assembled:** {n_est} nodes carry an established rung, {n_open} are open obligations and {n_ref} are closed or refuted at their stated scope. **The one measurement this window adds is structural, and it is this:** of the {n_ref} closed items in the graph, **none gates anything**. Deleting any of them leaves the root exactly as derivable as before (generated table in section 5). They are traces of attacks, not steps of a proof, and the corpus's own registers do not always make that distinction — which is how five routes come to look like five views of one obstruction. ## 1. The chain, with rungs The target has **four independent sufficient consumers**, which is why a branch can die without closing the programme: | consumer | exact statement (short) | rung | why it reaches the target | |---|---|---|---| | `ZONE-WEAK` | for infinitely many primes p, the tile `T_p`'s first twin slot lies below `p'^2 - 2` | open | the weak Zone Postulate is *equivalent* to TPC, both directions, elementary | | `MARGIN-SHRINK` | `C2 x + E_dagger(x) >= c0 x/(log x)^K`, fixed `c0 > 0, K >= 0`, unbounded dyadic `x` | open | it gives `>= (c0/2) x/log^(K+2) x` actual prime pairs on the witnessing scales | | `CENTERED-MARGIN` | `D_y(x) >= -4x/25 + o(x)` for the centered prime–Mobius discrepancy | open | the third sufficient formulation, in the centered normalization | | `B-MARGIN` | a signed lower bound on the reviewed endpoint `B`, where `S = C2 x + B + O_A(x/log^A x)` | open | the same conclusion from the reviewed fixed-endpoint normalization | The deductive steps that make those implications real are nodes too, and all four are **derived**, not assumed: `EQ-ZONE-TPC` (the equivalence, elementary), `GAP-REFORM` (the Gap Reformulation; since `ln(p#) ~ p`, the window `p^2` is `(log q)^2`, so zone occupancy follows from a two-class Jacobsthal exponent below 2), `CONSUMER-COUNT` (the counting deduction with the `sqrt(x) log^3 x` prime-power subtraction), and `B-EXACT` (the representation behind the fourth consumer). **The classical base is named, not assumed.** The arithmetic branch rests on five imported theorems — `VAUGHAN`, `PNT`, `BV-LAMBDA` (level `x^(12/25)`), `BV-MU` (level `x^(1/10)`, itself derived from Koukourtopoulos GSM 203 in its own reviewed note) and `EXCLUDED-MEANS` — and on one **derived** node, `REDUCTION`, adjudicated three times with no defect found. That node is tagged *derived* and is nevertheless **irreplaceable inside its branch**: every margin statement there is a statement about `E_dagger`, and `E_dagger` exists only because the reduction holds. Removing it costs the whole branch, and nothing else (`impact REDUCTION` = `MARGIN-SHRINK`). ## 2. The two targets inside one box, and they are not substitutable This is the most consequential thing the assembly exposes, and the corpus says it in its own words (`RESEARCH-HANDOFF.md` section 5). The same rectangle carries **two different required savings, from two different Cauchy arrangements**: * the native orientation, `X_small <= C x^(36/25 - eta)`, needs a saving **strictly greater than `3/50`** (the generic top moment exponent is `3/2`, so `3/50` leaves no fixed slack); * the structured fixed-`q` sector, with block exponent `407/400 = 57/40` (moment majorant) `x 61/100` (first-Cauchy factor), needs **more than `7/200`**. The corpus's warning is explicit: *do not substitute one exponent into the other's sum*. In the graph these are two separate open leaves (`X-SMALL`, `D1-BLOCK`), reachable as **alternatives** from `BOX-CONTROL`, so the tool reports them as two obligations and never as one — which is exactly the failure mode the warning exists to prevent. ## 3. Five routes, one obligation: the attack layer is where the swarm is `BOX-CONTROL` has **{n_attacks} closed attacks attached to it** and one obligation actually underneath it. Reading them as five independent efforts hides that they all die on the same thing: * the eleven published interfaces at `X-SMALL` (`SMALL-DIVISOR-KERNEL` 129/125 against 1; `DFI` 1267/1200; the spectral diagnostic trivial to `x^(19/50)`; `TYPE-I-II` 41/40 with the balanced piece returning to 103/100; `FKM` prime modulus, `1/48` against `3/25`; `WRIGHT` 1157/1000; `GURIA`; `DET-COROLLARY`, which adds exactly zero area; and the Chowla family, wrong average type or saving far below `log^(2+eps) x`); * the run's own four closures at `D1-SMALL-GCD` (`PARSEVAL-L2`, `FOUR-CLASS-SPLIT`, `G-HALF-ETA`, and the scoped ceiling of the fixed-modulus family at `7/380` against `7/190` in c-units). **What the residual work actually is** is one node with two live parts: `D1-SMALL-GCD` (a saving of `7/200` in the remaining small-gcd range) and its neighbour `ROUTE48-RANGE-INPUT` (a published statement covering lengths `n^(o(1))..n^0.21` at composite modulus — blocked, not refuted, and the requirement there is weak: **any** `c^(-delta)`, `delta > 0`, suffices because the deficit is one logarithm and `log y = c^(o(1))`). The graph therefore separates two things the corridor has been running together since the start: **which route is cheapest to finish**, and **which item is the wall**. {a_wall} ## 4. The closures: what must be closed, and what is irreplaceable {RENDER} ## 5. The trap, stated as a node `CORNER` is in the graph and is deliberately **not** a route: on the prescribed-exponent corner `S_0` the endpoint sum becomes a two-point Möbius correlation at the fixed shift 2 with prime-band weights, and the corpus's own finding is that one-sided control of the full corner is, given the full complement at `O_H(x/log^H x)`, **inter-derivable with the sufficient margin itself** — it is the conclusion, not a lemma. A closure query that accepted it would report "close the problem" as a plan, so the tool refuses it and the self-test asserts that it never enters a closure set. The two ceilings around it are nodes as well, and both are load-bearing for what they forbid: `CONTROLLED-REGIONS` (the moment controls `delta+nu < 19/25`, `5 delta + 2 nu < 123/50`, `delta < 19/25` with `delta + 3 nu < 161/100`; the uniform threshold has not moved from 19/25 and the witness `(8/25, 11/25)` lies outside all three) and `EXTREMAL-CEILING` (a uniform saving `gamma` clears the corner exactly at `gamma = 2`; the priced target at one box removes about **3 percent** of the leftover area). `EXTREMAL-CEILING` is why the graph does not route `MARGIN-SHRINK` through `BOX-CONTROL` alone: closing the box, however hard, is necessary and not sufficient. ## 6. The lethal set, and how to read it Three answers, all generated, and they say different things: 1. **Globally fatal single failures: `{n_fatal}`.** No node lies on all four consumer routes, so no single result can close the programme *or* kill it. That is a structural fact about the assembly, not a comfort: it is also why closing one branch is not progress toward another. 2. **Irreplaceable inside each branch.** `fatal(ZONE-WEAK) = {zf}`: the whole zone branch reduces to one statement, `GAP-INF`, where the distance is `4.2665` against `2` and the corpus's own analysis is that a perfect distribution oracle moves the exponent by nothing. `fatal(MARGIN-SHRINK) = {mf}`: the reduction, the box and the global complement. `CENTERED-MARGIN` and `B-MARGIN` have no irreplaceable part above them because each *is* one statement. 3. **What each branch costs in named obligations** (table in section 4). The count is a structural measure and **not a difficulty**: `B-MARGIN` and `CENTERED-MARGIN` are one statement each, and both are exactly where the corpus records no unconditional progress of any size (`B` is exact and unestimated; the finite census to `2^38` cannot see `D_y` because the comparison is dominated by the classical term's slow convergence). ## 7. Integrity: how the graph is checked Four gates, all runnable, all green in this window: * **Source-token gate.** Every node declares the local document or return it is drawn from and the literal tokens that must appear in it; the tool checks all **{n_tokens} tokens across {n_nodes} nodes** against the files (fail on a single miss). The fetched documents are recorded with their sha256 in `evidence/docs-manifest.jsonl` — including `README.md` `{sha_readme}`, `research/ZONE-POSTULATE.md` `{sha_zone}`, `research/TWIN-REDUCTION.md` `{sha_twin}`, `research/RESEARCH-HANDOFF.md` `{sha_handoff}`, `research/structured-dispersion-estimate.md` `{sha_sde}` and `research/fixed-endpoint-discrepancy.md` `{sha_fed}`. * **Graph invariants.** Unique ids, resolvable references, no cycle through the route edges, tags inside the vocabulary, every node reachable from the root, and — the gate that catches the modelling error this graph is most prone to — **the root must not be derivable from the corpus's current rungs**. It is not. * **The closed-attack gate.** The self-test asserts of every refuted node that its impact is empty and that it is not fatal to any branch. A failed bound that gates something would mean the model had silently promoted it to an obligation. * **Determinism.** Every query is re-run and compared. ## 8. Rungs, limits, and what is not claimed | claim | rung | |---|---| | the equivalence, the Gap Reformulation and the counting deduction | **derived** (corpus's own, elementary where stated) | | the reduction `S = C2 x + E_dagger + O_H(x/log^H x)` | **derived**, adjudicated three times, no defect; constants ineffective | | the ceilings, the corner identification, the controlled regions | **derived**, as properties of one argument shape — not impossibility theorems | | the four sufficient margins | **open**, by the corpus's own registers | | the {n_ref} closed interfaces and attacks | **refuted** at their stated scope | | every rung, count and edge in this document | **verified** by the tool's gates, not by hand | | any progress toward TPC, any exponent, any probability, any onset | **NOT CLAIMED** | **Limits.** The graph is only as good as its rungs: they are transcribed from the served documents and from this run's returns, and a rung that is wrong upstream makes the closure set wrong downstream — which is why every node carries its tokens. The graph does not model the *strength* of an obligation (only that it is open), does not model coefficient sizes or error budgets, and does not attempt to decide whether any particular route is reachable. `CORNER` is documented but deliberately unusable. The two-target distinction of section 2 is the corpus's own warning made structural; if a future reader finds that the two arrangements are in fact interchangeable, that node pair must be merged. **Next step, and it is the one the assembly names.** The graph's own cheapest closures point at the four consumers, and the frontier at ten open obligations; the instrument that would move the frontier is the one the corpus has been asking for all along — a new arithmetic estimate with its full payoff — or, for the one leaf where the requirement is only logarithmic, a published statement covering `n^(o(1))..n^0.21` at composite modulus. Everything else in the graph is either established, or a trace of an attack. """ A_WALL = """The wall, in the corpus's own terms, is a **positivity** statement, not a distribution one: the discard points of the dimension-2 sieve were all mapped, distribution hypotheses enter at exactly one of them, and the primorial formulation already saturates it. So `GAP-INF` (distance 4.2665 -> 2) and `MARGIN-SHRINK` (a signed constant comparison where only an absolute `O(x)` bound exists) are two faces of one missing ingredient — and `SMOOTH-ABS` is its most frequently re-derived dead end: a statement can be **proven** and still be a failed step. The graph keeps that distinction in the rung, which is the only place it can be kept.""" out = BODY.format( n_nodes=len(DEPS["nodes"]), n_open=n_open, n_ref=n_ref, n_est=n_est, n_attacks=len([x for x in DEPS["frontier"]["closed_attacks_around_the_paths"]]), n_fatal=(", ".join("`%s`" % x for x in DEPS["globally_fatal"]) or "none"), zf=", ".join("`%s`" % x for x in rows["ZONE-WEAK"]["fatal"]), mf=", ".join("`%s`" % x for x in rows["MARGIN-SHRINK"]["fatal"]), n_tokens=SELF.get("tokens_checked", 0), sha_readme=manifest.get("README.md", "(unrecorded)")[:16], sha_zone=manifest.get("research/ZONE-POSTULATE.md", "(unrecorded)")[:16], sha_twin=manifest.get("research/TWIN-REDUCTION.md", "(unrecorded)")[:16], sha_handoff=manifest.get("research/RESEARCH-HANDOFF.md", "(unrecorded)")[:16], sha_sde=manifest.get("research/structured-dispersion-estimate.md", "(unrecorded)")[:16], sha_fed=manifest.get("research/fixed-endpoint-discrepancy.md", "(unrecorded)")[:16], a_wall=A_WALL, RENDER=RENDER) dst = os.path.join(RUN, "artifacts", "report-tpc-conditional-1570.md") with open(dst, "w", encoding="utf-8", newline="\n") as fh: fh.write(out + "\n") print(json.dumps({"ok": True, "path": os.path.relpath(dst, RUN), "bytes": len(out), "chars": len(out), "sha256": hashlib.sha256(out.encode()).hexdigest(), "generated_from": {"render": sha("artifacts/tpc-deps.render.md"), "deps": sha("artifacts/tpc-deps.json")}}, indent=1))