decision-tree-solver

Decision Tree Solver

"Should we settle or go to trial" is not answered by instinct or by whoever argues longest — it is three numbers and a probability, and most people have never actually multiplied them. This skill extracts the tree hiding inside a messy decision (the choices, the chances, the payoffs, the costs of playing), computes the rollback with the bundled script, and — the part instinct can never do — finds the break-even: the probability at which the recommendation flips. Because "trial is worth it if you win 60% of the time" is an opinion, but "the answer flips at 90% — are you more than 90% sure?" is a decision made tractable. The script is deterministic, stdlib-only, and shows its arithmetic.

What This Skill Produces

• The extracted tree — decisions, chance nodes with probabilities, outcomes with values, and the costs of each path, pulled from the situation as described
• The rollback — expected value at every node, the best choice named at every fork, from the script
• The break-even scan — for each two-way uncertainty, the probability at which the top-level choice flips, which is the number that makes probability arguments productive
• The robustness read — whether the answer survives the probabilities being argued about, or hinges on a number nobody can defend
• The leaves-out list — what expected value cannot see here: risk appetite, one-shot vs repeated, the unquantified costs

Required Inputs

Ask for these if not provided:

• The choices — the real options on the table, including the do-nothing one
• The uncertainties — what could happen under each choice, and the requester's honest probability for each (pushing back on false precision is part of the job)
• The payoffs and costs — the money (or a stated proxy) at each end point, and what each path costs to walk: fees, time priced honestly, deposits
• The stakes context — one-shot or repeatable, and whether the worst branch is survivable — because expected value is the right tool for repeatable bets and needs a caveat for ruinous one-shots

Framework: Extract, Roll Back, Stress the Probabilities

1. Extract before computing. The tree is usually mis-drawn before it is mis-computed: options that are really the same option, a "risk" that is actually two sequential risks, a payoff that forgot the cost of getting it. Draw it in the script's JSON, read it back to the requester, fix it there.
2. Run the rollback.

   python3 scripts/decision_tree.py --input tree.json          # tree with EVs and best choices
   python3 scripts/decision_tree.py --input tree.json --json   # machine-readable
   python3 scripts/decision_tree.py --demo                     # settle-vs-trial worked example

Outcomes carry values; chance nodes take probability-weighted sums; decisions take the best child; costs subtract along the way. The best path falls out, with the arithmetic visible.

1. Read the break-even before the recommendation. The scan reports where the choice flips. A decision that holds from p=0.3 to p=0.9 is robust and the probability argument can stop; one that flips at 0.55 when the room believes 0.5-to-0.6 is the argument itself, now named precisely.
2. Stress the values too. Nudge the big payoffs ±30% and rerun. An answer that survives sloppy values and sloppy probabilities is a real answer; one that does not is a request for better information, and the tree shows exactly which information.
3. Say what EV cannot see. A 10% chance of ruin is not "priced in" by multiplication for someone who cannot survive it once; reputational and relationship costs sit outside the tree unless explicitly valued. The recommendation carries these as words, not silently.

Output Format

Decision tree: [the decision] · [date]

The tree (as computed — from decision_tree.py)

[rendered tree: choices ▣, chances ◔, outcomes •, EV at every node, best marked]

Recommendation: [the best path] · EV [amount] vs next-best [amount]

Break-even scan

| Uncertainty | Flips the choice at | You believe | Verdict |

|---|---|---|---|

| [chance node] | p ≈ [x] | [their estimate] | robust / hinges here |

Value stress: [the payoffs nudged ±30% — held / flipped, and on which number]

What the numbers leave out: [ruin risk on the worst branch · one-shot vs repeated framing · the unpriced costs, named]

> Decision support, not legal, financial, or any other advice. The probabilities are the requester's own beliefs made explicit — the tree cannot make them true, only make their consequences consistent.

Quality Checks

• [ ] The tree was read back and corrected before anything was computed
• [ ] Every path's costs are on the path, not forgotten at the leaves
• [ ] The break-even scan appears and is compared against the requester's stated belief
• [ ] Values were stressed, not just probabilities
• [ ] The leaves-out list names ruin risk explicitly when the worst branch is severe
• [ ] The recommendation states robustness, not just the EV winner

Anti-Patterns

• Computing the mis-drawn tree. Ten minutes of extraction beats any amount of arithmetic on the wrong structure.
• False precision in probabilities. "About 60%" is honest; "62.5%" from nowhere is decoration — the break-even scan is the cure, since it shows whether the difference even matters.
• EV-maximising a ruinous one-shot. The tool's cleanest failure mode; the caveat is mandatory, not optional.
• Hiding the arithmetic. The script prints every node's EV because a recommendation nobody can check convinces nobody who matters.
• Letting the tree end the conversation. It ends the circular part; the values conversation it surfaces is the productive one.