1. What Monte Carlo actually does

Pricing view:

“Simulate many risk-neutral paths, compute payoffs, discount, average.”

For a payoff $ (S_T, ) $:

Price≈e−rT⋅1N∑k=1NΠ(k) \text{Price} \approx e^{-rT} \cdot \frac{1}{N} \sum_{k=1}^N \Pi^{(k)}

  • NN: number of simulated paths.
  • Under risk-neutral measure (drift = r, adjusted for dividends/forwards).
  • Law of large numbers → convergence as N→∞N \to \infty.

Why MC?

  • Works for:
    • Path-dependent payoffs (Asian, barriers, cliquets, storage, swing),
    • High-dimensional models (many factors),
    • Complex exercise rules (LSMC, dynamic programming).

Cost:

  • Slow convergence: error ~ O(1/N)O(1/\sqrt{N}).
  • Need many paths for small noise unless you use variance reduction.

2. Variance reduction – basic intuition

Goal:

“Get the same accuracy with fewer paths.”

Two simple (but powerful) tools:

2.1 Antithetic variates

Idea:

  • For each normal draw ZZ, also use −Z-Z.
  • For GBM paths, ZZ and −Z-Z are negatively correlated in payoff space.

Effect:

  • Payoff average from pairs has lower variance than from independent samples.
  • Easy to implement; almost always worth doing.

2.2 Control variates

Idea:

  • Use a related payoff with known analytic price as a control.

Example:

  • Pricing an exotic that depends on STS_T.
  • Use the European call with same S0,K,TS_0, K, T as control:
    • Simulate both exotic payoff and call payoff on the same paths.
    • Call price is known analytically (e.g. Black–Scholes).

Mechanics (simplified):

P̂cv=Π‾−β(C‾−Canalytic) \hat{P}^{\text{cv}} = \bar{\Pi} - \beta (\bar{C} - C_{\text{analytic}})

  • Π‾\bar{\Pi}: sample mean of exotic payoffs.
  • C‾\bar{C}: sample mean of call payoffs from MC.
  • CanalyticC_{\text{analytic}}: exact call price.
  • β\beta: regression coefficient (often estimated, or start with 1 if lazy).

Effect:

  • If exotic and control are highly correlated, variance drops a lot.

3. Reproducibility and seeds

Monte Carlo must be deterministic in production:

  • Same config + same seed → same result.
  • Otherwise:
    • Regression tests are unstable.
    • P&L explain / risk numbers jump just due to RNG.

Good practice:

  • Explicit seed passed through all MC calls.
  • If you have multiple pricers:
    • Derive sub-seeds via a stable mapping, e.g. seed + trade_id * large_prime.
  • Use common random numbers when comparing two prices / scenarios:
    • Use the same underlying random streams to reduce noise when looking at differences.

For a risk engine:

  • Store seeds (or seed recipe) in run configuration.
  • MC pricers should be pure functions of (trade, snapshot, model, MC_config).

4. Monte Carlo in a pricing library – practical concerns

  • Discretisation:
    • Time steps small enough to capture path features (barriers, early exercise, storage decisions).
  • Path grouping:
    • Batch many trades under the same paths when possible (same model, same factors) for speed.
  • Greeks:
    • Pathwise estimators, likelihood ratio methods, bump-and-revalue with common random numbers.
  • Error reporting:
    • Return price and standard error / confidence interval.
    • For risk, you may cap noise via minimum path counts or reporting tolerances.

5. Interview soundbite

“Monte Carlo prices derivatives by simulating risk-neutral paths, discounting payoffs, and averaging. It’s the flexible workhorse for path-dependent and high-dimensional problems. Convergence is only 1/N1/\sqrt{N}, so we lean heavily on variance reduction: antithetic variates are almost free, and control variates using analytic benchmarks can cut variance dramatically. In a production library, MC must be reproducible: seeds are explicit, part of the run configuration, and we use common random numbers across bumps and scenarios so differences are stable and regression tests don’t flicker.”