American Put Pricing with a Discretized Path Integral
Summary
The document describes a backward path-integral scheme for pricing an American put on a log-price grid. At each time step, it discounts and integrates the next-step option value against a Gaussian propagator for log prices, then applies the early-exercise rule by taking the greater of the payoff and continuation value. Repeating this process propagates values back to the initial time and price.
The author reports that the numerical result can approach a binomial-model value when the spatial grid is large relative to the number of time steps, but finer time stepping can cause growing disagreement and eventually implausible prices. They observe empirically that maintaining convergence seems to require spatial resolution to grow roughly with the square of time resolution, but provide no proof. The document does not resolve whether the issue comes from grid truncation, discretization, or implementation details, and supplies no numerical specifications or confirmed convergence condition.
Key ideas
- The method propagates option values backward by integrating against a Gaussian transition density in log-price space.
- At each grid point, the American exercise value is compared with the discounted continuation value.
- The author reports instability as the time grid is refined unless the spatial grid is also expanded substantially.
- The proposed relationship between time and spatial grid sizes is an empirical observation, not a demonstrated convergence rule.
Tags
Full text
# American option pricing using path integrals
# American option pricing using path integrals
I am writing a brute force code in python that implements the path integral formalism for the American put option, the goal being to obtain its price at given a price $S_0$ of the underlying asset. Let $r$, $\sigma$, and $\mu$ are positive constants. To solve it, I numerically evaluate this integral (using numpy.trapz):
$$V(t_{i-1}, x_{i-1})= e^{-r(t_{i}-t_{i-1})}\int_{-\infty}^{\infty} dx_{i} \cdot G(x_{i}, t_{i}|x_{i-1}, t_{i-1})V(t_i, x_{i}),$$
where $G$ is a propagator defined by: $$G(x_{i}, t_{i}|x_{i-1},t_{i-1}) = \frac{1}{\sqrt{2\pi\sigma^{2}(t_{i}-t_{i-1})}}exp\Biggl(-\frac{[(x_{i}-x_{i-1})-\mu \cdot(t_{i}-t_{i-1})]^{2}}{2\sigma^{2}(t_{i}-t_{i-1})}\Biggr).$$
where $t \in (0, T ) $ and $x =\ln{S}$ $\in (-\infty, +\infty )$, where $S$ is the underlying asset price. The value of the option $V(t_N = T, x_T)$ is propagated back to every price point at time $t_{N-1}$ finding the function $V(t_{N-1}, x_{N-1})$ for all $x$ at that time. Then the exercise condition is checked (the payoff and the continuation value are compared and the greater was taken) and the result is used to find $V(t_{N-2}, x_{N-2})$. This process is repeated until we find $V(t_{0}, x_{0})$.
Practically, I discretize the $t$ and $x$ domains into $N_t$ time steps and $N_x$ price steps, creating a uniform grid in the $(t, x)$ plane, such that each point on the grid can be labeled by two indices $x_{i, j}$, where the $i$ index gives the time position, and the $j$ index gives the position in the $x$ direction. I then performed a nested loop to loop over the $i$ and $j$ indices and obtained $V(t_{0}, x_{0, j})$.
I compared the results to the binomial model and noticed that if the number of price steps $N_x$ is much larger than the number of time steps $N_t$, then the code converges very close to the value predicted by the binomial model. However, I do not understand why as I increase the number of time steps $N_t$, the agreement with the binomial model starts to deviate from the binomial model (this effect is not large, but it is significant enough to ruin the model), and if we increase $N_t$ sufficiently, the result diverges completely, giving absurdly large values for the option price.
After playing with the values $N_t$ and $N_x$ for a bit, I think I noticed that if I want to maintain convergence, then if I increase $N_t$ by a factor $p$, I have to increase $N_x$ by a factor of about $p^2$, although I have no rigorous reason to think this other than the fact that seems to work. How do I explain this? Is there some convergence condition that I am not aware of, or is there some way to get around this problem?Shown in full with attribution under the source's licence. Licence: CC BY-SA 4.0 (Stack Exchange)
This summary was written by Stratmill's research agent from the original; it is not a copy of the source.