| """C.3 Attribution: Retracted Evidence. |
| |
| Task (paper, verbatim protocol): an archive of source notes, derived evidence |
| notes, and candidate conclusions. |
| - A source note states a numerical claim ("specimen Iona has baseline |
| resonance 22"). |
| - A derived note names a specimen and metric, applies a signed numerical |
| adjustment to one earlier claim, and reports the result. Its TRUE parent is |
| the unique preceding note whose specimen, metric and value make the |
| calculation correct. Decoy notes report nearby values; only one value makes |
| each stated transformation correct. |
| - A conclusion states that one candidate answers one question and names the |
| claim required to support it. An artifact is valid only if its producer and |
| every artifact in its ancestry remain valid. |
| - One intermediate artifact is authored by a RETRACTED laboratory; multiple |
| downstream branches attach to it, so all conclusions below it are invalid. |
| - For each of P questions, exactly one of the C candidate conclusions has a |
| fully clean lineage. |
| |
| Treatments: both give workers a persistent catalog + all earlier reads and |
| submissions. attribution: catalog rows carry producer + immediate parent IDs. |
| no_attribution: those fields are absent; lineage must be reconstructed from |
| the numerical statements. The prompt does not name the treatment. |
| |
| Settings: P=4 questions, C=2 candidates, 4 sequential workers, 3 seeds; |
| per-worker read budget k = ceil(|A|/4). Sweeps: lineage depth L, semantic |
| ambiguity A, fan-out F, one factor at a time. |
| |
| Metric: fraction of unique archive artifacts read before the FIRST exact |
| submission (a submission is exact when every question is answered with the |
| unique clean-lineage candidate). |
| """ |
|
|
| import json |
| import os |
| import random |
| import subprocess |
|
|
| from agent import run_worker_episode |
|
|
|
|
| def generate_archive(seed, P=4, C=2, L=4, A=1, F=2, n_decoys=8): |
| """Build the archive. L: ancestry levels ending at a conclusion; |
| A: plausible same-(specimen,metric) decoy parents per derivation step; |
| F: downstream branches below the retracted artifact.""" |
| rng = random.Random(seed) |
| specimens = [f"specimen-{rng.randrange(100,999)}" for _ in range(6)] |
| metrics = [f"metric-{chr(97+i)}" for i in range(4)] |
| artifacts = {} |
| order = [] |
|
|
| def new_id(kind, i): |
| return f"{kind}{i:04d}_{rng.randrange(1000,9999)}" |
|
|
| def _unique_adj(parent_val, sp, me): |
| """Draw an adjustment whose result value does not coincide with any |
| existing (sp, me) note, so the stated transform has exactly ONE |
| valid source among earlier notes: the declared parent.""" |
| taken = {a["value"] for a in artifacts.values() |
| if a["type"] in ("source", "derived") |
| and a["specimen"] == sp and a["metric"] == me} |
| for _ in range(500): |
| adj = rng.randrange(-9, 10) or 3 |
| nv = parent_val + adj |
| if nv not in taken and 0 <= nv < 300: |
| return adj, nv |
| raise RuntimeError("could not draw a unique adjustment") |
|
|
| |
| |
| retracted_idx = max(1, L // 2) |
| spec0 = rng.choice(specimens) |
| met0 = rng.choice(metrics) |
| val = rng.randrange(5, 100) |
| root_id = new_id("s", 0) |
| artifacts[root_id] = {"type": "source", "specimen": spec0, "metric": met0, |
| "value": val, "producer": "lab_alpha", |
| "parent": None, "retracted": False, |
| "text": f"Source note: {spec0} has baseline {met0} " |
| f"of {val}."} |
| order.append(root_id) |
| chain = [root_id] |
| for lvl in range(1, L): |
| prev = chain[-1] |
| adj, new_val = _unique_adj(artifacts[prev]["value"], spec0, met0) |
| rid = new_id("d", lvl) |
| prod = f"lab_{rng.choice('bcdefg')}" |
| lab = ("RETRACTED laboratory " + prod if lvl == retracted_idx |
| else "laboratory " + prod) |
| artifacts[rid] = { |
| "type": "derived", "specimen": spec0, "metric": met0, |
| "value": new_val, "adjustment": adj, |
| "parent": prev, "producer": prod, |
| "retracted": lvl == retracted_idx, |
| "text": (f"Derived note ({lab}): {spec0} {met0} " |
| f"after adjustment {adj:+d} applied to the recorded " |
| f"{met0} claim reads {new_val}.")} |
| artifacts[rid]["text"] = artifacts[rid]["text"].replace( |
| "laboratory :", "").replace(" ", " ") |
| order.append(rid) |
| chain.append(rid) |
|
|
| |
| retracted_id = chain[retracted_idx] |
| artifacts[retracted_id]["producer"] = "lab_retracted" |
| artifacts[retracted_id]["text"] = artifacts[retracted_id]["text"].replace( |
| "laboratory", "RETRACTED laboratory").replace( |
| "RETRACTED LABORATORY", "RETRACTED laboratory") |
|
|
| |
| def extend_branch(parent_id, length, branch_tag): |
| cur = parent_id |
| for i in range(length): |
| adj, new_val = _unique_adj(artifacts[cur]["value"], spec0, met0) |
| rid = new_id("d", i) |
| artifacts[rid] = { |
| "type": "derived", "specimen": spec0, "metric": met0, |
| "value": new_val, "adjustment": adj, "parent": cur, |
| "producer": f"lab_{rng.choice('bcdefg')}", "retracted": False, |
| "text": f"Derived note (laboratory): {spec0} {met0} after " |
| f"adjustment {adj:+d} applied to the recorded {met0} " |
| f"claim reads {new_val}."} |
| order.append(rid) |
| cur = rid |
| return cur |
|
|
| poisoned_leaves = [extend_branch(retracted_id, max(1, L - retracted_idx), |
| f"poison{b}") for b in range(F)] |
|
|
| |
| clean_leaves = [] |
| for _ in range(P * C): |
| sp = rng.choice([s for s in specimens if s != spec0]) |
| me = rng.choice(metrics) |
| |
| |
| |
| v = rng.randrange(5, 100) |
| while any(a["specimen"] == sp and a["metric"] == me |
| and a["value"] == v for a in artifacts.values()): |
| v = rng.randrange(5, 100) |
| sid = new_id("s", len(order)) |
| artifacts[sid] = {"type": "source", "specimen": sp, "metric": me, |
| "value": v, "producer": "lab_alpha", |
| "parent": None, "retracted": False, |
| "text": f"Source note: {sp} has baseline {me} of {v}."} |
| order.append(sid) |
| cur = sid |
| for lvl in range(1, L): |
| adj, nv = _unique_adj(artifacts[cur]["value"], sp, me) |
| rid = new_id("d", lvl) |
| artifacts[rid] = { |
| "type": "derived", "specimen": sp, "metric": me, |
| "value": nv, "adjustment": adj, "parent": cur, |
| "producer": f"lab_{rng.choice('bcdefg')}", "retracted": False, |
| "text": f"Derived note (laboratory): {sp} {me} after " |
| f"adjustment {adj:+d} applied to the recorded {me} " |
| f"claim reads {nv}."} |
| order.append(rid) |
| cur = rid |
| clean_leaves.append(cur) |
|
|
| |
| |
| |
| base = len(artifacts) |
| for aid in [a for a in order if artifacts[a]["type"] == "derived"]: |
| for j in range(max(0, A - 1)): |
| sp = artifacts[aid]["specimen"] |
| me = artifacts[aid]["metric"] |
| v = artifacts[aid]["value"] + rng.choice([-3, -2, 2, 3, 5, -5]) |
| did = new_id("x", j) |
| artifacts[did] = {"type": "derived", "specimen": sp, "metric": me, |
| "value": v, "adjustment": None, "parent": None, |
| "producer": f"lab_{rng.choice('bcdefg')}", |
| "retracted": False, |
| "text": f"Derived note (laboratory): {sp} {me} " |
| f"after an adjustment applied to the " |
| f"recorded {me} claim reads {v}."} |
| order.append(did) |
| |
| |
|
|
| |
| questions = {} |
| for q in range(P): |
| clean_leaf = clean_leaves[q] |
| poisoned = rng.choice(poisoned_leaves) |
| qid = f"q{q+1}" |
| cands = [] |
| clean_slot = rng.randrange(C) |
| for c in range(C): |
| cid = new_id("c", c) |
| if c == clean_slot: |
| artifacts[cid] = { |
| "type": "conclusion", "question": qid, |
| "answer": f"answer-{rng.randrange(10,99)}", |
| "support_claim": clean_leaf, "parent": None, |
| "producer": f"lab_{rng.choice('bcdefg')}", |
| "retracted": False, |
| "text": f"Conclusion: candidate {cid} answers question " |
| f"{qid}; it is supported by the claim recorded in " |
| f"artifact {clean_leaf}."} |
| valid = True |
| else: |
| artifacts[cid] = { |
| "type": "conclusion", "question": qid, |
| "answer": f"answer-{rng.randrange(10,99)}", |
| "support_claim": poisoned, "parent": None, |
| "producer": f"lab_{rng.choice('bcdefg')}", |
| "retracted": False, |
| "text": f"Conclusion: candidate {cid} answers question " |
| f"{qid}; it is supported by the claim recorded in " |
| f"artifact {poisoned}."} |
| valid = False |
| order.append(cid) |
| cands.append((cid, valid)) |
| |
| questions[qid] = cands |
|
|
| answer_key = {q: next(cid for cid, ok in cands if ok) |
| for q, cands in questions.items()} |
| return {"artifacts": artifacts, "order": order, "questions": questions, |
| "answer_key": answer_key, "P": P, "C": C} |
|
|
|
|
| def artifact_text(a): |
| return json.dumps({k: v for k, v in a.items() if k != "text"}, |
| ensure_ascii=False) + " || " + a["text"] |
|
|
|
|
| def catalog_rows(archive, attribution): |
| rows = [] |
| for aid in archive["order"]: |
| a = archive["artifacts"][aid] |
| row = {"id": aid, "type": a["type"], "title": a["text"][:60]} |
| if a["type"] == "conclusion": |
| row["question_id"] = a["question"] |
| row["candidate_answer"] = a["answer"] |
| if attribution: |
| row["producer"] = a["producer"] |
| row["parent"] = a["parent"] |
| rows.append(row) |
| return rows |
|
|
|
|
| def system_prompt(k, rows, peer_obs): |
| peer_txt = "" |
| if peer_obs: |
| peer_txt = ("\n\nOBSERVATIONS FROM EARLIER WORKERS on this same " |
| "archive (read-only):\n" + peer_obs + |
| "\nTheir submitted answers are also recorded above.") |
| return f"""You are an evidence-checking worker. |
| |
| THE ARCHIVE: source notes (numerical claims about specimens), derived notes |
| (each applies a stated signed adjustment to one earlier claim and reports the |
| result), and candidate conclusions (each says which question it answers and |
| which claim supports it). An artifact is VALID only if its producer is not |
| retracted AND every artifact in its ancestry is valid. Some derived notes are |
| decoys: only one preceding note's specimen, metric and value make each stated |
| adjustment correct, so a note's true parent is unique. |
| |
| YOUR TASK: for each question, decide which candidate conclusion has a fully |
| clean lineage. Exactly one candidate per question is clean. |
| |
| THE CATALOG below lists every artifact's ID, type and title. |
| |
| TOOLS (reply with exactly one JSON object per turn): |
| {{"tool": "read_artifacts", "args": {{"artifact_ids": ["<id>", ...]}}}} |
| - Returns full text of the requested artifacts; costs ONE read per artifact. |
| {{"tool": "submit_answers", "args": {{"answers": {{"<question_id>": "<artifact_id>"}}}}}} |
| - Submit one candidate per question; ends the episode. |
| {{"tool": "yield_worker", "args": {{"summary": "..."}}}} ends the episode. |
| |
| READ BUDGET: exactly {k} artifact reads. |
| {peer_txt} |
| |
| CATALOG: |
| {json.dumps(rows, indent=1)} |
| """ |
|
|
|
|
| def run_condition(client, out_root, seed, L, A, F, treatment, usage=None, |
| P=4, C=2, n_workers=4): |
| """treatment: 'attribution' or 'no_attribution'.""" |
| archive = generate_archive(seed, P=P, C=C, L=L, A=A, F=F) |
| archive_size = len(archive["order"]) |
| k = (archive_size + n_workers - 1) // n_workers |
| attribution = treatment == "attribution" |
| rows = catalog_rows(archive, attribution) |
| run_dir = os.path.join(out_root, |
| f"evidence_L{L}_A{A}_F{F}_{treatment}_seed{seed}") |
| os.makedirs(run_dir, exist_ok=True) |
| with open(os.path.join(run_dir, "archive.json"), "w") as f: |
| json.dump({"artifacts": archive["artifacts"], |
| "order": archive["order"], |
| "answer_key": archive["answer_key"], |
| "L": L, "A": A, "F": F}, f) |
|
|
| shared_obs = [] |
| submissions = [] |
| read_union = set() |
| result_reads = None |
|
|
| for w in range(n_workers): |
| wdir = os.path.join(run_dir, f"worker_{w}") |
| os.makedirs(wdir, exist_ok=True) |
| obs_path = os.path.join(wdir, "observations.jsonl") |
| state = {"reads": 0, "submitted": None, "read_ids": []} |
|
|
| def read_artifacts(args): |
| ids = [str(i) for i in (args.get("artifact_ids") or [])] |
| if not ids: |
| return "ERROR: artifact_ids must be a non-empty list.", False |
| if state["reads"] >= k: |
| return ("ERROR: read budget exhausted. Call submit_answers " |
| "now."), False |
| unknown = [i for i in ids if i not in archive["artifacts"]] |
| if unknown: |
| return f"ERROR: unknown artifact ids: {unknown}", False |
| charge = min(len(ids), k - state["reads"]) |
| granted = ids[:charge] |
| state["reads"] += charge |
| state["read_ids"].extend(granted) |
| texts = {i: artifact_text(archive["artifacts"][i]) |
| for i in granted} |
| for i in granted: |
| entry = {"id": i, "text": texts[i]} |
| shared_obs.append(entry) |
| read_union.add(i) |
| with open(obs_path, "a") as f: |
| f.write(json.dumps(entry) + "\n") |
| if len(ids) > len(granted): |
| texts["_note"] = "budget exhausted; remaining ids not returned" |
| return json.dumps(texts), False |
|
|
| def submit(args): |
| state["submitted"] = args.get("answers", {}) |
| return "Answers recorded.", True |
|
|
| def yield_worker(args): |
| state["summary"] = args.get("summary", "") |
| return "Episode committed.", True |
|
|
| peer_txt = "" |
| if shared_obs: |
| peer_txt = json.dumps(shared_obs)[:20000] |
| if submissions: |
| peer_txt += "\nEARLIER SUBMISSIONS: " + json.dumps(submissions) |
| tools = {"read_artifacts": read_artifacts, "submit_answers": submit, |
| "yield_worker": yield_worker} |
| prompt = system_prompt(k, rows, peer_txt) |
| done = run_worker_episode(prompt, tools, usage=usage, client=client) |
| if state["submitted"]: |
| submissions.append({"worker": w, "answers": state["submitted"]}) |
| exact = state["submitted"] == archive["answer_key"] |
| submissions[-1]["exact"] = exact |
| if exact and result_reads is None: |
| result_reads = len(read_union) |
| break |
|
|
| frac = (result_reads / archive_size) if result_reads is not None else None |
| return {"task": "evidence", "seed": seed, "L": L, "A": A, "F": F, |
| "treatment": treatment, "archive_size": archive_size, "k": k, |
| "reads_before_first_exact": result_reads, |
| "fraction_read": frac, |
| "n_workers_used": len(submissions) if result_reads is not None |
| else n_workers, |
| "any_exact": result_reads is not None, |
| "run_dir": run_dir} |
