Binomial option pricing: build the tree and work backward

Fix the inputs before choosing the tree size

Use a hypothetical underlying at S = $100 and a strike K = $100, with T = 1 year, annualized volatility σ = 20%, continuously compounded risk-free rate r = 5%, and continuous dividend yield q = 0%. All values below are dollars per share before fees. No observed market prices or trading results enter the example. N = 2 is deliberately coarse so that every node can be checked.

Derive the branch factors and valuation probability

Set Δt = T/N, u = exp(σ√Δt), d = exp(-σ√Δt) = 1/u, and p = [exp((r - q)Δt) - d] / (u - d). The discount factor for one step is D = exp(-rΔt). Here p denotes the risk-neutral up probability; q denotes dividend yield. These symbols are not used consistently across textbooks, so check their definitions.

• The valuation weights satisfy p × u + (1 - p) × d = exp((r - q)Δt). This gives the required risk-neutral growth rate under the continuous-yield convention.
• Require d < exp((r - q)Δt) < u, so 0 < p < 1. With these CRR factors, this is |r - q|√Δt < σ. If it fails, refine the time grid and recheck the inputs. Do not clamp p to zero or one.
• The 55.39% weight does not estimate the real chance that the stock rises. It also does not measure the chance that an option purchase makes money after premium and costs. Historical up frequencies are not substitutes for p in this pricing recursion.

Build the stock nodes and terminal put payoffs

At time step i with j up moves, the stock node is S(i,j) = S × u^j × d^(i-j), for j = 0 through i. Because u × d = 1, an up-then-down path and a down-then-up path meet at the same price. At expiry, use max(S(N,j) - K, 0) for a call or max(K - S(N,j), 0) for a put.

• Two steps give four paths but three terminal prices. When rolling values backward, use each node once; the recursion already accounts for both paths reaching the middle price.
• Carry full precision internally. The displayed node values are rounded for reading, and repeated rounding can change a boundary exercise decision.

Roll back and test American exercise at each node

Continuation value at node (i,j) is H(i,j) = D × [p × V(i+1,j+1) + (1 - p) × V(i+1,j)]. A European option uses V = H before expiry. An American option uses V = max(H, immediate payoff) at each permitted exercise time. Use the resulting child values, including any early exercise, in the next rollback.

• At the down node, H = 0.9753099120 × [0.5539082889 × 0 + 0.4460917111 × 24.6361683556] = $10.7186466634. Exercising the American put pays 100 - 86.8123445395 = $13.1876554605, so the tree chooses exercise.
• The European root is D × (1 - p) × 10.7186466634 = $4.6634437887. Replacing that child value with 13.1876554605 gives the American root $5.7376543771. The early-exercise premium on this grid is $1.0742105884.
• The American result is at least the European value and at least immediate intrinsic value at the root. These are useful checks; applying max only at the root misses the valuable half-year exercise opportunity.
• A finite grid permits exercise only at its nodes and approximates continuous American exercise as the grid is refined. Model-optimal exercise does not predict when a real holder will exercise or a short position will be assigned.

Check convergence instead of trusting one step count

Repeat the same calculation with every input fixed except N, recalculating Δt, u, d, p and D each time. The table reports per-share values to six decimals for comparison, not market-price accuracy. The same-input European Black-Scholes benchmarks are call $10.450584 and put $5.573526. They do not provide a closed-form benchmark for the American put.

• The first three estimates alternate above and below the European benchmark. Increasing N need not move the value in one direction; strike placement on odd and even grids changes the error. Inspect both neighboring grids and doubling sequences.
• From N = 400 to 800, the American put changes by about $0.000996 per share. That is an observed grid difference, not a rigorous upper bound on error. Choose an absolute tolerance before examining the result and refine further when needed.
• For a European check, define d1 = [ln(S/K) + (r - q + σ²/2)T] / (σ√T), d2 = d1 - σ√T, and Φ as the standard normal CDF. C = S exp(-qT)Φ(d1) - K exp(-rT)Φ(d2); P = K exp(-rT)Φ(-d2) - S exp(-qT)Φ(-d1).
• Here d1 = 0.35 and d2 = 0.15. Every European tree also satisfies C - P = S exp(-qT) - K exp(-rT) = $4.87705755 to numerical precision. A put-call parity failure points to inconsistent inputs or rollback logic.

Separate a failed grid from a failed model assumption

A larger N reduces discretization error under the chosen model. It cannot repair an incorrect contract, an unreliable volatility input, or a dividend schedule that the model does not represent. The constant-parameter CRR tree assumes multiplicative price moves with fixed volatility, rates and continuous yield, without trading frictions or jumps.

• At T = 0, return intrinsic payoff directly. If σ = 0, u = d and the probability formula divides by zero; use a deterministic valuation branch instead. Reject negative time or volatility, nonpositive stock or strike, nonfinite inputs, and noninteger or nonpositive N.
• For an explicit invalid-grid example, r = 5%, q = 0%, σ = 1%, T = 1 and N = 1 give p about 3.061, outside [0, 1]. Increasing to N = 100 makes p about 0.7498. This repairs the probability condition, not the economic plausibility of the inputs.
• Known cash dividends require their amounts and dates in a suitable dividend-aware tree. Replacing them with a constant yield changes the model, especially near an ex-dividend date or an American exercise boundary.
• For a non-dividend-paying call with nonnegative rates under this frictionless model, early exercise is not beneficial. Do not transfer that conclusion unchanged to dividend-paying calls, negative rates or puts.
• Compare theoretical premium per share with the same quote unit. Multiply by the verified deliverable or contract multiplier for a position value; do not assume every contract represents 100 shares.

Use TradingView and Pineify to check the contract inputs

In the TradingView options chain, select the underlying and expiration, then identify the call or put and strike. Record available IV and bid/ask values with their timestamp. If using a strategy chart, isolate the same single contract and position size. Chart candles do not specify the binomial step count, and a displayed scenario value may use different pricing conventions.

• Open Pineify AI Stocks & Options Picker for the same ticker and select its Options Chain tab. Choose the same expiration and compare the available contract IV and bid/ask values. Missing provider fields remain unknown; they are not evidence of zero volatility or a zero premium.
• Obtain the exercise style, expiry time, dividend treatment and multiplier from the contract specifications. Record any assumed rate or volatility explicitly. Do not infer these missing model inputs from an AI stock rating.
• For the European benchmark above, open the Black-Scholes Option Calculator and enter stock 100, strike 100, time 1 Year, volatility 20%, rate 5% and dividend yield 0%. Its theoretical call and put values should agree with the closed-form row to displayed precision.
• The linked calculator checks European valuation with explicit inputs; it does not reproduce this American exercise tree. The Options Chain supplies available contract data, not a CRR price or a forecast of profitability. Keep any model-versus-quote difference separate from a trading recommendation.