# What is the error in a naive computation of a path integral? [closed]

If I were to try to brute force compute the following integral:

$$F(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})F(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\left(-\frac{[(x_{i}-x_{i-1})-\mu \cdot(t_{i}-t_{i-1})]^{2}}{2\sigma^{2}(t_{i}-t_{i-1})}\right),$$

where $$x \in (-\infty, \infty)$$ and $$t\in (t_0, t_N)$$, and the remaining symbols are constants. The path integral is:

$$F(t_0, x_0) = \int \int\int...\int \int_{-\infty}^{\infty}e^{-r(t_{N}-t_{N-1})} \cdot G(x_{N}, t_{N}|x_{N-1}, t_{N-1})F(t_N, x_{N}) dx_{N} dx_{N-1} ... dx_1,$$

in the limit of $$N\rightarrow \infty$$. The function $$F(t_N, x_N)$$ is known and the goal is to find $$F(t_0, x_0)$$. I want to compute this directly.

I would discretize the time and $$x$$ domains into a regular grid consisting of $$N_x×N_t$$ grid points. Then I would compute the integral for the points $$x_{N-1}$$ using the trapezoidal rule. This would involve computing $$N_x$$ integrals, one for every grid point at $$t_{N-1}$$. Then I would move to time $$t_{N-2}$$ etc until I arrive at $$t_0$$.

How do I determine what the error in this should be? I know that the error of the trapezoidal rule is $$O(N_x^{-2})$$. At each $$t_i$$, we perform this integration $$N_x$$ times, meaning that the error should compound $$N_x$$ times. Taking into account that, we also have to compute the integral for $$N_t$$ times, meaning that the error is compounded $$N_x^{N_t}$$ times. The total compound error should be on the order of $$O(N_x^{N_t-2})$$.

This would be massive and really should never converge, however, I wrote code that computes the path integral naively like this, and it seems that I do get convergence to the correct value $$F(t_0, x_0)$$. Whats more, if I keep increasing $$N_x$$, I get better and better convergence, even though according to my result I really shouldn't.

How do I actually determine the actual compound error in this calculation?

This method isn't specific to path integrals, but if you have some numerical scheme that is intended to compute value $$f_\text{actual}$$ but produces a value $$f(h)$$ for some step size $$h$$ (usually $$h=1/N$$ for $$N$$ segments), then you can usually write the error as, $$error=f(h)-f_\text{actual}=\alpha h^k+\beta h^{k+1}+\cdots\tag{1}$$ where we would say that the scheme has order $$\mathcal{O}(h^k)$$ convergence if the above holds.
In order to find the $$k$$, you can take the logarithm of both sides of Eq (1), $$\log(error)=\log(\alpha h^k)=\log\alpha+k\log(h)$$ and then by curve fitting the set of $$\log(error)$$ and $$\log(h)$$ values, you can find the slope of this linear equation, which is the (approximate) method order, $$k$$.
Note that this method can also work if you do not have an actual value. In this case, you would replace $$f_\text{actual}$$ with the value from the highest order (i.e., smallest $$h$$) and do the same as the above. The only real "risk" in doing this is that your scheme is converging to the wrong answer, in which case analyzing the error convergence of the scheme is nonsense anyway.