A precise option price can still be wrong

Tutorial
Python
More simulations make an estimated option price more precise, but they leave the error from a wrong volatility input unchanged.
Published

September 23, 2026

Even if you use a lot of simulations to get a precise option price, the simulations come from assumptions, and if those assumptions are wrong, the so-called precise price is also wrong. That is the problem I want to illustrate in this post, using a set of numbers I choose arbitrarily.

I price a one-year call on a stock that trades at 100, with a strike of 100. Simulations are mostly for options with no formula, such as an option on a stock’s average price, so here I only use the Black–Scholes formula to check the simulations.

The price depends on the stock’s volatility. Say I estimate it at 20% a year, for example, from past stock prices. A million simulated stock prices then give a price of 9.41, with a 95% simulation interval of only 9.39 to 9.44. But in the market I construct, the volatility is in fact 30%, which nobody knows when the option is priced, and at 30% the option is worth 13.28.

Defining the option and the two volatilities

The option is a European call on one share, with a strike of 100, and its payoff at maturity is

\[\max(S_T - K,\ 0),\]

where \(S_T\) is the stock price at maturity and \(K\) is the strike. The stock pays no dividends, and the risk-free interest rate is 3% a year, continuously compounded, so a payoff in one year is worth \(e^{-0.03} = 0.9704\) times as much today.

I call the 30% that I set for this market the stock’s volatility, and the 20% that I use to price the option the pricing volatility.

Simulating the stock price

Each simulation draws the stock price at maturity directly, in two steps:

\[X_T = \left(r - \frac{\sigma^2}{2}\right)T + \sigma\sqrt{T}\,Z, \qquad S_T = S_0\, e^{X_T},\]

where \(S_0 = 100\), \(T = 1\) year, \(\sigma = 0.20\) is the pricing volatility, \(r = 0.03\), and \(Z\) is a standard normal draw. As in risk-neutral pricing, the simulated stock grows on average at the risk-free rate.

import numpy as np

STOCK_PRICE = 100.0          # S0, the stock price today
STRIKE = 100.0               # K, the price at which the holder can buy the stock at maturity
MATURITY = 1.0               # T, the time to maturity in years
RISK_FREE_RATE = 0.03        # r, the risk-free rate per year, continuously compounded
STOCK_VOLATILITY = 0.30      # the stock's volatility, which I set for this hypothetical market
PRICING_VOLATILITY = 0.20    # the volatility used to price the option

# With continuous compounding, 1 paid at maturity is worth exp(-r T) today.
DISCOUNT_FACTOR = np.exp(-RISK_FREE_RATE * MATURITY)


def stock_price_at_maturity(draw, volatility):
    """Turn standard normal draws into stock prices at maturity, at the given volatility.

    The draw can be one number or a NumPy array of draws, because NumPy applies arithmetic and
    np.exp to each element of an array.
    """
    # exponent is the log return X_T, and np.exp(exponent) is the price ratio S_T / S_0.
    # ** raises to a power, so volatility**2 is the volatility squared.
    exponent = ((RISK_FREE_RATE - volatility**2 / 2) * MATURITY
                + volatility * np.sqrt(MATURITY) * draw)
    return STOCK_PRICE * np.exp(exponent)


def discounted_payoff(price_at_maturity):
    """Return the call's payoff, max(S_T - K, 0), in today's money.

    np.maximum takes the larger of each element and 0, so the function takes one price or an array.
    """
    payoff = np.maximum(price_at_maturity - STRIKE, 0.0)
    return DISCOUNT_FACTOR * payoff


# An f-string, f"...", fills in the value of each expression in braces: {x:.4f} writes x with
# four decimals, {x:+.0f} with its sign and no decimals, and {x:,} with commas between thousands.
print(f"discount factor exp(-rT): {DISCOUNT_FACTOR:.4f}")
for draw in [1.0, -1.0]:
    price_at_maturity = stock_price_at_maturity(draw, PRICING_VOLATILITY)
    payoff = np.maximum(price_at_maturity - STRIKE, 0.0)
    print(f"draw {draw:+.0f}: stock price at maturity {price_at_maturity:.2f}, "
          f"payoff {payoff:.2f}, discounted payoff {discounted_payoff(price_at_maturity):.2f}")
discount factor exp(-rT): 0.9704
draw +1: stock price at maturity 123.37, payoff 23.37, discounted payoff 22.68
draw -1: stock price at maturity 82.70, payoff 0.00, discounted payoff 0.00

Estimating the price and its 95% simulation interval

The option’s price at 20% is the expected discounted payoff:

\[C_{20\%} = e^{-rT}\,\mathrm{E}\bigl[\max(S_T - K,\ 0)\bigr],\]

Monte Carlo simulation replaces the expected value with an average over \(n\) independent draws:

\[\hat{C} = e^{-rT}\,\frac{1}{n}\sum_{i=1}^{n} \max(S_{T,i} - K,\ 0),\]

where \(S_{T,i}\) is the stock price at maturity for the draw \(Z_i\). A new set of draws would give a different estimate, and I measure that variation with the standard error:

\[\text{standard error} = \frac{s}{\sqrt{n}},\]

where \(s\) is the standard deviation of the \(n\) discounted payoffs. The 95% simulation interval is then

\[\hat{C} \pm 1.96 \times \text{standard error},\]

The interval only measures the variation from the random draws, with the volatility fixed at 20%. I compute the estimate and its interval from 1,000, 10,000, 100,000 and 1,000,000 simulations.

import pandas as pd

NUMBERS_OF_SIMULATIONS = [1_000, 10_000, 100_000, 1_000_000]    # Python reads 1_000 as 1000
Z_95 = 1.96    # a standard normal draw is between -1.96 and 1.96 with a probability of 95%
# rng is NumPy's random number generator. Starting it from a fixed number, the seed 2026,
# gives the same draws on every run, so every number in the post reproduces.
rng = np.random.default_rng(2026)

# Start with an empty list and add one row of results for each number of simulations.
rows = []
for n_simulations in NUMBERS_OF_SIMULATIONS:
    # a new set of draws for each number of simulations, one draw per simulation
    draws = rng.standard_normal(n_simulations)
    prices_at_maturity = stock_price_at_maturity(draws, PRICING_VOLATILITY)
    discounted_payoffs = discounted_payoff(prices_at_maturity)

    estimate = discounted_payoffs.mean()
    # std() divides the sum of squared deviations from the average by n before the square
    # root is taken; ddof=1 divides by n - 1 instead, the usual formula for a sample of draws
    standard_deviation = discounted_payoffs.std(ddof=1)
    standard_error = standard_deviation / np.sqrt(n_simulations)
    rows.append({"simulations": n_simulations,
                 "estimate": estimate,
                 "standard deviation of discounted payoffs": standard_deviation,
                 "standard error": standard_error,
                 "interval low": estimate - Z_95 * standard_error,
                 "interval high": estimate + Z_95 * standard_error})

results = pd.DataFrame(rows)    # each dictionary becomes a row, its keys the column names
# index=False leaves out the row numbers, formatters writes the numbers of simulations with
# commas, and float_format gives every other number four decimals
print(results.to_string(index=False, formatters={"simulations": "{:,}".format},
                        float_format="{:.4f}".format))
simulations  estimate  standard deviation of discounted payoffs  standard error  interval low  interval high
      1,000    9.9160                                   14.7517          0.4665        9.0017        10.8303
     10,000    9.3674                                   13.8442          0.1384        9.0961         9.6388
    100,000    9.3836                                   14.0530          0.0444        9.2965         9.4707
  1,000,000    9.4141                                   14.1347          0.0141        9.3864         9.4418

Each tenfold increase in simulations divides the standard error by roughly \(\sqrt{10} = 3.16\), and with a million simulations, the interval is only 0.055 wide.

Computing the Black–Scholes price at 20% and at 30%

At 20%, the Black–Scholes formula checks the simulation, and at 30% it gives the option’s price in this market:

\[ \begin{aligned} d_1 &= \frac{\ln(S_0/K) + (r + \sigma^2/2)\,T}{\sigma\sqrt{T}}, \\ d_2 &= d_1 - \sigma\sqrt{T}, \\ C &= S_0\, N(d_1) - K e^{-rT} N(d_2), \end{aligned} \]

where \(N\) is the standard normal distribution function.

For each number of simulations, I compute the simulation error (the estimate minus the Black–Scholes price at 20%) and the total error (the estimate minus the price at 30%), and check whether the interval contains each of the two prices.

from scipy.stats import norm


def black_scholes_call(volatility):
    """Return the Black–Scholes price of the call at the given volatility.

    norm.cdf is N, the standard normal distribution function: norm.cdf(0) is 0.5.
    """
    d1 = ((np.log(STOCK_PRICE / STRIKE) + (RISK_FREE_RATE + volatility**2 / 2) * MATURITY)
          / (volatility * np.sqrt(MATURITY)))
    d2 = d1 - volatility * np.sqrt(MATURITY)
    return STOCK_PRICE * norm.cdf(d1) - STRIKE * DISCOUNT_FACTOR * norm.cdf(d2)


black_scholes_price_at_20 = black_scholes_call(PRICING_VOLATILITY)
black_scholes_price_at_30 = black_scholes_call(STOCK_VOLATILITY)
pricing_error_from_wrong_volatility = black_scholes_price_at_20 - black_scholes_price_at_30
print(f"Black–Scholes price at 20%: {black_scholes_price_at_20:.4f}")
print(f"Black–Scholes price at 30%: {black_scholes_price_at_30:.4f}")
print(f"pricing error from the wrong volatility, the price at 20% minus the price at 30%: "
      f"{pricing_error_from_wrong_volatility:.4f}\n")

# a new table with one row per number of simulations, like results
comparison = pd.DataFrame({"simulations": results["simulations"]})
comparison["simulation error"] = results["estimate"] - black_scholes_price_at_20
comparison["total error"] = results["estimate"] - black_scholes_price_at_30
# An interval contains a price when its low end is at or below the price and the price is at
# or below its high end. & combines two columns of True and False row by row, giving True
# where both are True. Python applies & before <=, so each comparison needs its own parentheses.
comparison["interval contains price at 20%"] = (
    (results["interval low"] <= black_scholes_price_at_20)
    & (black_scholes_price_at_20 <= results["interval high"]))
comparison["interval contains price at 30%"] = (
    (results["interval low"] <= black_scholes_price_at_30)
    & (black_scholes_price_at_30 <= results["interval high"]))
print(comparison.to_string(index=False, formatters={"simulations": "{:,}".format},
                           float_format="{:.4f}".format))
Black–Scholes price at 20%: 9.4134
Black–Scholes price at 30%: 13.2833
pricing error from the wrong volatility, the price at 20% minus the price at 30%: -3.8699

simulations  simulation error  total error  interval contains price at 20%  interval contains price at 30%
      1,000            0.5026      -3.3673                            True                           False
     10,000           -0.0460      -3.9159                            True                           False
    100,000           -0.0298      -3.8997                            True                           False
  1,000,000            0.0007      -3.8692                            True                           False

The Black–Scholes price at 20% is 9.4134, and at every number of simulations, the interval contains it but misses the price at 30%, 13.2833. The total error is the sum of two errors:

\[\underbrace{\hat{C} - C_{30\%}}_{\text{total error}} = \underbrace{\hat{C} - C_{20\%}}_{\text{simulation error}} + \underbrace{C_{20\%} - C_{30\%}}_{\substack{\text{pricing error from}\\ \text{the wrong volatility}}},\]

The simulation error comes only from using a finite number of simulations, 0.5026 with 1,000 simulations and 0.0007 with a million. The pricing error from the wrong volatility, 9.4134 − 13.2833 = −3.8699, uses no simulation, so it is the same at every number of simulations. So more simulations shrink the simulation error and leave the pricing error unchanged.

In the chart, each teal point is an estimate at 20% with its interval, the gray dashed line is the Black–Scholes price at 20%, and the red line is the price at 30%. The intervals shrink around the 20% price, while the gap to the red line stays the same.

import matplotlib.pyplot as plt

RED, TEAL, GREY = "#C0392B", "#17868A", "#888888"
# The site's chart colours, in order: the cream background, the text, the light grid lines,
# the pale frame and the axis labels, the same on every chart of the site.
BG, INK, GRID, SPINE, AXIS_TEXT = "#FCEFE3", "#1f1f1f", "#EADCCC", "#D5C6B4", "#4a4a4a"


def style_chart(figure, axis):
    """Give a finished chart the site's cream background, light grid and pale frame."""
    figure.patch.set_facecolor(BG)
    axis.set_facecolor(BG)
    axis.grid(True, axis="y", color=GRID, lw=1.0)
    axis.set_axisbelow(True)
    for side in ("top", "right"):
        axis.spines[side].set_visible(False)
    for side in ("left", "bottom"):
        axis.spines[side].set_color(SPINE)
    axis.tick_params(axis="both", length=0, colors=INK, pad=6)
    axis.xaxis.label.set_color(AXIS_TEXT)
    axis.yaxis.label.set_color(AXIS_TEXT)
    axis.title.set_color(INK)
    # Write each legend entry in the colour of what it labels: a line's colour or a bar's fill
    # colour. get_legend() returns None when the chart has no legend.
    legend = axis.get_legend()
    if legend is not None:
        for text, handle in zip(legend.get_texts(), legend.legend_handles):
            if hasattr(handle, "get_color"):
                text.set_color(handle.get_color())
            else:
                text.set_color(handle.get_facecolor())


# subplots creates the figure and its one chart, axis; figsize is the figure's width and height
# in inches.
figure, axis = plt.subplots(figsize=(9, 5.2))
# axhline draws a horizontal line across the chart at a price, and label is its text in the
# legend. lw is the line width and ls the line style: (0, (4, 3)) repeats a dash 4 line widths
# long and a gap 3 line widths long, from the start of the line.
axis.axhline(black_scholes_price_at_30, color=RED, lw=2.0,
             label="Black–Scholes price at 30%, the stock's volatility")
axis.axhline(black_scholes_price_at_20, color=GREY, lw=1.6, ls=(0, (4, 3)),
             label="Black–Scholes price at 20%, the pricing volatility")
# errorbar draws each estimate as a point with a vertical bar through it. yerr is the distance
# from the estimate to either end of the bar, here 1.96 standard errors, so each bar is the
# 95% simulation interval. fmt="o" draws the estimates as points, ms sets the points' size and
# capsize the width of the short line at each end of a bar.
axis.errorbar(results["simulations"], results["estimate"], yerr=Z_95 * results["standard error"],
              fmt="o", color=TEAL, ms=8, lw=2.0, capsize=6,
              label="estimate at 20%, with its 95% simulation interval")

# annotate() with an empty text draws only an arrow, here with a head at each end, from the
# Black–Scholes price at 20% up to the Black–Scholes price at 30%. Its length is the size of the
# pricing error from the wrong volatility. It is at 1,400,000 on the horizontal axis, right of
# the last estimate.
ARROW_POSITION = 1_400_000
axis.annotate("", xy=(ARROW_POSITION, black_scholes_price_at_30),
              xytext=(ARROW_POSITION, black_scholes_price_at_20),
              arrowprops={"arrowstyle": "<->", "color": INK, "lw": 1.2})
# The label is centred (va="center") halfway up the arrow, and ha="right" ends the text at 0.85
# times the arrow's position, just left of the arrow. \n in the text starts a second line.
axis.text(ARROW_POSITION * 0.85, (black_scholes_price_at_20 + black_scholes_price_at_30) / 2,
          f"pricing error from the\nwrong volatility: {pricing_error_from_wrong_volatility:.2f}",
          ha="right", va="center", color=INK)

# On a log scale, 1,000, 10,000, 100,000 and 1,000,000 are equally far apart.
axis.set_xscale("log")
# Mark only the four numbers of simulations on the horizontal axis, written with commas.
axis.minorticks_off()
axis.set_xticks(NUMBERS_OF_SIMULATIONS)
tick_labels = []
for n_simulations in NUMBERS_OF_SIMULATIONS:
    tick_labels.append(f"{n_simulations:,}")
axis.set_xticklabels(tick_labels)
# the ranges shown on the two axes, with room for the arrow right of the last estimate
axis.set_xlim(500, 2_000_000)
axis.set_ylim(8, 14.5)
axis.set_xlabel("Number of simulations (log scale)")
axis.set_ylabel("Option price")
axis.set_title("More simulations leave the pricing error from the wrong volatility unchanged")
# frameon=False draws the legend without a box. bbox_to_anchor puts the legend's lower-left
# corner at 1% across and 50% up the chart, in the empty space between the widest interval and
# the red line.
axis.legend(frameon=False, loc="lower left", bbox_to_anchor=(0.01, 0.5))
style_chart(figure, axis)
# tight_layout() fits the labels inside the figure. savefig writes the chart to a PNG file:
# dpi=140 sets its resolution, bbox_inches="tight" trims the empty margin, and facecolor=BG
# keeps the cream background. show() displays the chart.
plt.tight_layout()
plt.savefig("estimates_by_simulations.png", dpi=140, bbox_inches="tight", facecolor=BG)
plt.show()

Conclusion

So the simulation interval only measures the error from the random draws, and a narrow interval does not show that the price is right. I know the price is wrong here only because I set the volatility myself, so for a real option, the volatility has to be checked on its own, for example against the volatility the stock later shows.

Disclaimer: a teaching example on simulated data. Not investment advice.