草稿被拒绝后，为什么不能直接重新抽一次？

"""Exact one-token probability ledger; no model calls or random simulation."""
import csv
import json
from fractions import Fraction as F
from pathlib import Path

TOKENS = ("A", "B", "C")
CASES = (
    ("main", ("1/2", "3/10", "1/5"), ("1/5", "3/5", "1/5")),
    ("equal", ("1/2", "3/10", "1/5"), ("1/2", "3/10", "1/5")),
    ("draft_zero", ("1/2", "3/10", "1/5"), ("0", "4/5", "1/5")),
    ("disjoint", ("1", "0", "0"), ("0", "1", "0")),
    ("two_residual_tokens", ("1/2", "2/5", "1/10"), ("1/5", "1/5", "3/5")),
)


def distribution(values):
    if len(values) != len(TOKENS) or any(type(x) is not str for x in values):
        raise ValueError("provide exactly three rational-number strings")
    result = tuple(F(x) for x in values)
    if any(x < 0 for x in result) or sum(result) != 1:
        raise ValueError("probabilities must be nonnegative and sum exactly to one")
    return result


def exact_strings(values):
    return [None if x is None else str(x) for x in values]


def enumerate_case(name, target_values, draft_values):
    p, q = distribution(target_values), distribution(draft_values)
    acceptance = tuple(min(F(1), pi / qi) if qi else None for pi, qi in zip(p, q))
    accepted = tuple(qi * ai if ai is not None else F(0) for qi, ai in zip(q, acceptance))
    rejected = tuple(qi - ai for qi, ai in zip(q, accepted))
    rejection = sum(rejected)
    deficit = tuple(max(F(0), pi - qi) for pi, qi in zip(p, q))
    assert sum(deficit) == rejection
    residual = tuple(x / rejection for x in deficit) if rejection else None
    rows, totals = [], {}
    for method in ("correct_residual", "wrong_redraw_target"):
        final = [F(0) for _ in TOKENS]
        for i, candidate in enumerate(TOKENS):
            if accepted[i]:
                final[i] += accepted[i]
                rows.append({"case": name, "method": method, "candidate": candidate,
                             "path": "accept", "output": candidate, "mass": str(accepted[i])})
            if rejected[i]:
                fallback = residual if method == "correct_residual" else p
                assert fallback is not None
                for j, output in enumerate(TOKENS):
                    joint_mass = rejected[i] * fallback[j]
                    if joint_mass:
                        final[j] += joint_mass
                        rows.append({"case": name, "method": method, "candidate": candidate,
                                     "path": "reject_then_replace", "output": output,
                                     "mass": str(joint_mass)})
        assert sum(final) == 1
        totals[method] = tuple(final)
    assert totals["correct_residual"] == p
    assert totals["wrong_redraw_target"] == tuple(a + rejection * pi for a, pi in zip(accepted, p))
    report = {"case": name, "tokens": list(TOKENS), "target_p": exact_strings(p),
              "draft_q": exact_strings(q), "conditional_acceptance": exact_strings(acceptance),
              "accepted_mass": exact_strings(accepted), "rejected_mass_by_candidate": exact_strings(rejected),
              "rejection_probability": str(rejection), "positive_deficit": exact_strings(deficit),
              "residual_given_rejection": exact_strings(residual) if residual is not None else None,
              "correct_final": exact_strings(totals["correct_residual"]),
              "wrong_final": exact_strings(totals["wrong_redraw_target"]),
              "wrong_equals_target_in_this_case": totals["wrong_redraw_target"] == p}
    return report, rows


def expect_invalid(values):
    try:
        distribution(values)
    except (ValueError, ZeroDivisionError):
        return
    raise AssertionError("invalid distribution was accepted")


def main():
    reports, rows = [], []
    for name, target, draft in CASES:
        report, case_rows = enumerate_case(name, target, draft)
        reports.append(report)
        rows.extend(case_rows)
    main_report = reports[0]
    assert main_report["accepted_mass"] == ["1/5", "3/10", "1/5"]
    assert main_report["rejection_probability"] == "3/10"
    assert main_report["residual_given_rejection"] == ["1", "0", "0"]
    assert main_report["wrong_final"] == ["7/20", "39/100", "13/50"]
    assert reports[1]["residual_given_rejection"] is None
    assert reports[2]["conditional_acceptance"][0] is None
    assert reports[3]["rejection_probability"] == "1"
    assert reports[3]["wrong_equals_target_in_this_case"]
    assert reports[4]["residual_given_rejection"] == ["3/5", "2/5", "0"]
    for invalid in (("0", "0", "0"), ("-1", "1", "1"), ("1/2", "1/2"),
                    ("1/2", "1/2", 0), ("nan", "0", "1"), ("1/0", "0", "0")):
        expect_invalid(invalid)
    # Independently sum all exported branches by case, method, and final token.
    for report in reports:
        for method, key in (("correct_residual", "correct_final"), ("wrong_redraw_target", "wrong_final")):
            subset = [r for r in rows if r["case"] == report["case"] and r["method"] == method]
            reconstructed = [sum((F(r["mass"]) for r in subset if r["output"] == t), F(0)) for t in TOKENS]
            assert exact_strings(reconstructed) == report[key]
    output = Path.cwd()
    (output / "probability-inputs.json").write_text(json.dumps([
        {"case": name, "target_p": list(p), "draft_q": list(q)} for name, p, q in CASES
    ], indent=2) + "\n", encoding="utf-8")
    (output / "sampling-ledger-report.json").write_text(json.dumps({
        "scope": "Exact one-token finite probability enumeration; no random draws or model inference.",
        "zero_convention": "null acceptance means q=0; null residual means rejection probability is zero.",
        "cases": reports
    }, indent=2) + "\n", encoding="utf-8")
    with (output / "probability-branches.csv").open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=("case", "method", "candidate", "path", "output", "mass"))
        writer.writeheader()
        writer.writerows(rows)
    print(json.dumps({"status": "PASS", "cases": len(reports), "branch_rows": len(rows),
                      "main_correct": main_report["correct_final"], "main_wrong": main_report["wrong_final"]}))


if __name__ == "__main__":
    main()