每一步保留九成概率，整句话还保留九成吗？

"""Enumerate a two-step probability tree exactly; no random draws or model calls."""
import csv
import json
from fractions import Fraction as F
from pathlib import Path

TREE = {"root": {"A": "3/5", "B": "3/10", "C": "1/10"},
        "A": {"x": "9/10", "y": "3/50", "z": "1/25"},
        "B": {"x": "3/5", "y": "7/20", "z": "1/20"},
        "C": {"x": "1/2", "y": "3/10", "z": "1/5"}}


def parse(values):
    result = {k: F(v) for k, v in values.items()}
    if not result or any(v < 0 for v in result.values()) or sum(result.values()) != 1:
        raise ValueError("nonnegative probabilities summing to one required")
    return result


def nucleus(probabilities, threshold):
    if not 0 < threshold <= 1:
        raise ValueError("threshold must be in (0,1]")
    if not probabilities or any(v < 0 for v in probabilities.values()) or sum(probabilities.values()) != 1:
        raise ValueError("invalid distribution")
    ordered = sorted(probabilities, key=lambda key: (-probabilities[key], key))
    kept, mass = [], F(0)
    for token in ordered:
        kept.append(token)
        mass += probabilities[token]
        if mass >= threshold:  # Equality stops; tied probabilities use lexical token order.
            break
    normalized = {token: probabilities[token] / mass if token in kept else F(0)
                  for token in probabilities}
    assert sum(normalized.values()) == 1
    return kept, mass, normalized


def enumerate_tree(threshold):
    original = {name: parse(values) for name, values in TREE.items()}
    filtered = {name: nucleus(values, threshold) for name, values in original.items()}
    paths = []
    for first, p_first in original["root"].items():
        for second, p_second in original[first].items():
            kept = first in filtered["root"][0] and second in filtered[first][0]
            paths.append({"threshold": str(threshold), "path": first + second,
                          "first": first, "second": second, "kept": kept,
                          "original": p_first * p_second,
                          "local": filtered["root"][2][first] * filtered[first][2][second],
                          "root_mass": filtered["root"][1], "child_mass": filtered[first][1]})
    event_mass = sum((row["original"] for row in paths if row["kept"]), F(0))
    for row in paths:
        row["conditioned_whole_sequence"] = row["original"] / event_mass if row["kept"] else F(0)
    assert sum(row["original"] for row in paths) == 1
    assert sum(row["local"] for row in paths) == 1
    assert sum(row["conditioned_whole_sequence"] for row in paths) == 1
    assert event_mass >= threshold ** 2
    summary = {"threshold": str(threshold), "original_mass_of_kept_paths": str(event_mass),
               "two_step_lower_bound": str(threshold ** 2),
               "nodes": {node: {"kept": kept, "mass_before_rescaling": str(mass),
                                  "after_rescaling": {k: str(v) for k, v in probabilities.items()}}
                         for node, (kept, mass, probabilities) in filtered.items()},
               "local_equals_whole_conditioning": all(row["local"] == row["conditioned_whole_sequence"] for row in paths)}
    return summary, paths


def main():
    summaries, all_paths = [], []
    for threshold in (F(3, 5), F(9, 10), F(19, 20), F(1)):
        summary, paths = enumerate_tree(threshold)
        summaries.append(summary)
        all_paths.extend(paths)
    main_paths = {r["path"]: r for r in all_paths if r["threshold"] == "9/10"}
    assert summaries[1]["original_mass_of_kept_paths"] == "33/40"
    assert {k for k, r in main_paths.items() if r["kept"]} == {"Ax", "Bx", "By"}
    assert [main_paths[k]["original"] for k in ("Ax", "Bx", "By")] == [F(27, 50), F(9, 50), F(21, 200)]
    assert [main_paths[k]["local"] for k in ("Ax", "Bx", "By")] == [F(2, 3), F(4, 19), F(7, 57)]
    assert [main_paths[k]["conditioned_whole_sequence"] for k in ("Ax", "Bx", "By")] == [F(36, 55), F(12, 55), F(7, 55)]
    assert not summaries[1]["local_equals_whole_conditioning"]
    assert summaries[-1]["original_mass_of_kept_paths"] == "1"
    assert summaries[-1]["local_equals_whole_conditioning"]
    assert nucleus(parse({"A": "1/2", "B": "1/2"}), F(1, 2))[0] == ["A"]
    assert nucleus(parse({"A": "1", "B": "0"}), F(1))[0] == ["A"]
    for invalid in (F(0), F(-1), F(2)):
        try:
            nucleus(parse(TREE["root"]), invalid)
        except ValueError:
            pass
        else:
            raise AssertionError("invalid threshold accepted")
    Path("nucleus-inputs.json").write_text(json.dumps(TREE, indent=2) + "\n", encoding="utf-8")
    Path("nucleus-report.json").write_text(json.dumps({
        "scope": "Exact fixed-length two-step finite tree; no EOS, temperature, random draws or model calls.",
        "rule": "descending probability; lexical token tie-break; stop at cumulative mass >= threshold",
        "cases": summaries}, indent=2) + "\n", encoding="utf-8")
    with Path("nucleus-paths.csv").open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(all_paths[0]))
        writer.writeheader()
        writer.writerows(all_paths)
    print(json.dumps({"status": "PASS", "thresholds": 4, "path_rows": len(all_paths),
                      "main_retained_original_mass": "33/40", "main_local_equals_conditioned": False}))


if __name__ == "__main__":
    main()