Simple claim: a recombining tree is a think-then-act schedule; every node is a Clearance that only sees its own past. The trench is multiperiod backward induction as the agent loop.
The problem we left open
Last time the failure was a coin. A physical probability wandered into a risk-neutral expectation, the mark came out 6.7% rich, and the hedge, which never saw a probability at all, kept costing what it always cost. The fix was to type the measure: store (P, Q) as a declared pair and refuse any pricing expectation that binds the physical one.
But that whole argument lived inside a single period. One decision, two states, done. Real claims are not one decision. They run for months and require you to keep acting, at many dates, with information that arrives while you act. And the moment the model has more than one step, a new class of failure opens that the measure card cannot catch.
Three production headaches:
- Hedges that are computed once and then held, as if a position taken today discharges an obligation that keeps changing.
- Rebalancing schedules that quietly use information from later nodes, because the whole tree was in memory and nothing stopped the lookup.
- A single number promoted out of a coarse grid, with no statement of how coarse the grid was.
So the question for this post is simple. If that is the failure mode, what does a real AI solution look like?
The solution, as one stack
The core idea: a multiperiod hedge is not a portfolio, it is a policy, a schedule of decisions, one per node, each allowed to see only what has happened by then. Backward induction is how you compute that policy, and it is structurally the same object as a well-behaved agent loop: value the future first, act in the present, and never let step n read from step n+1. Five moves, one stack.
1. Build a recombining tree and hash it. Over n periods the stock moves by u or d each step. Recombination is the modeling choice that up-then-down lands where down-then-up lands, so the state at time k depends only on the number of ups, not their order, which collapses 2ⁿ paths into n+1 nodes per level. It is also a claim about the world, so it goes on a card: n, (u, d, r), and the recombination flag, hashed together. Two teams quoting the same instrument off differently-meshed trees are not disagreeing about the market. They are running different models and calling both the price.
2. Write terminal values first, then induct backward. At expiry there is no decision left, the claim pays what it pays. From there, every earlier node is a one-period problem you already know how to solve. The node value is the discounted risk-neutral expectation of its two children:
V_k = (1/(1+r)) · E^Q[V_{k+1} | F_k].
Under constant (u, d, r) the same q serves every step, so this is one arithmetic move applied repeatedly. That is dynamic programming, and it is why an intractable path problem becomes a small table.
3. Read a local Δ at every node, not one Δ for the trade. At each node the hedge ratio is the same difference quotient as the one-period case, computed with that node's children:
Δ = (V_up − V_down)/(S_up − S_down).
The hedge is therefore a schedule, not a number. It changes as the underlying moves, and the changes are financed by the money-market leg. A desk that sets Δ once at inception and books the claim as hedged has not hedged it; it has taken the first step of a policy and stopped.
4. Enforce adaptedness, think ≠ act at every node. Δ at a node may depend only on information in the filtration at that node: the coin tosses that have already happened. But the whole tree sits in memory, and every future node is one array index away. Nothing in the arithmetic stops you from reaching forward, and a hedge that reaches forward will backtest beautifully and fail live. Agents may evaluate the entire tree, that is thinking, and backward induction requires it. What executes at a node may only use that node's past. LOOKAHEAD_HEDGE is the same discipline as an as-of clock, expressed in node coordinates.
5. Post the path budget, or refuse the point. A tree price is indexed to its mesh. Promoting a number off a four-step tree as the price of a continuously-traded claim is a category error, and the gap between discrete rebalancing and the continuous ideal is real money. So the artifact carries the mesh alongside the number, and if the claim is not attainable at every node, the output is a band and POINT_ON_INCOMPLETE fires.
Put together: hashed recombining tree, backward induction under Q, local Δ schedule, adaptedness enforced per node, path budget posted. That is the hedge policy. The tree is not a pricing trick. It is the smallest honest picture of an agent that must keep acting under arriving information.
The example: CEH-001's equity leg over two periods
Same never-traded note, same toy world extended by one step. S₀ = 100, u = 1.1, d = 0.9, r = 0.05 per period, K = 100, and q = 0.75 as before.
The tree recombines. Terminal states: S_uu = 121, S_ud = S_du = 99, S_dd = 81. Terminal call values: 21, 0, 0.
Backward one level. At the up node, S = 110, children 121 and 99:
V_u = (0.75 × 21 + 0.25 × 0)/1.05 = 15.75/1.05 = 15.00.
At the down node, S = 90, children 99 and 81, both worthless:
V_d = 0.
Back to the root, children 15.00 and 0:
V₀ = (0.75 × 15.00 + 0.25 × 0)/1.05 = 11.25/1.05 = 10.71.
Now the policy, which is the part that actually gets executed. At the root, Δ₀ = (15.00 − 0)/(110 − 90) = 0.75 shares. At the up node, Δ_u = (21 − 0)/(121 − 99) = 21/22 = 0.955. At the down node, Δ_d = (0 − 0)/(99 − 81) = 0.
Read those three numbers as a behavior. Start at three-quarters of a share. If the stock rallies, buy up to nearly a full share. If it falls, go flat, the claim is dead in that branch and holding stock against it is a new position nobody authorized. That is not a hedge. That is a rebalancing rule, and it is the object the desk needs, not the 10.71.
And it is adapted by construction. Δ_u is 0.955 because of what the up node's children are worth; it never asks whether the next toss is an up. Wire the same tree into a backtest that lets the hedger see one step ahead and the strategy will look almost riskless, because it will be, against a future it was allowed to read.
Against 1.50 versus 2.10: the two frames now owe more than a mark. They owe a rebalancing schedule. If the spread frame and the curve frame imply different Δ paths, the desk can put both in a replay and watch which one tracks the note's obligations through the states that actually occurred. That is a comparison with an answer. 1.80 remains unavailable for the same reason as before, now compounded: a midpoint mark has no tree behind it, therefore no Δ schedule, therefore nothing to execute and nothing to test. It is a number that cannot be held.
The honest ending is still a band. Two steps is a fixture, not the instrument. Post the mesh with the number, and when the real claim is not attainable node-by-node, ship the interval rather than the midpoint of it.
The flow in one breath
Problem: multiperiod claims get hedged once, with information they should not have, off a mesh nobody wrote down. Solution: hash a recombining tree, induct backward under Q to value every node, read a local Δ at each node as a difference quotient, enforce that each Δ sees only its own past, and post the path budget or ship a band. Example: CEH-001's leg values at 10.71 over two periods with a Δ schedule of 0.75 to 0.955 or 0, which is executable, testable, and leaves no node where 1.80 is the cost of anything.
Curious how others enforce adaptedness inside a hedger that has the whole tree in memory, and whether their tree artifacts carry the mesh alongside the price or only the price.
Clearance coupling. Each node is a local information set — no future prints, no cross-path leakage. Agent multi-step plans that condition on future nodes fail filtration checks. Backward induction is the allowed loop shape.
Multiperiod CEH-001 equity leg: recompute Δ at each node under the node σ-algebra; silent use of terminal information is the tree version of tomorrow's 10y.