Simulating a Mean-Reverting Lognormal Process with an OU Log
Summary
The document proposes modeling a positive process by making its logarithm an Ornstein–Uhlenbeck process. In this construction, the log value mean-reverts toward a constant level, so the corresponding process is positive and its long-run central level is the exponential of the log-space level. It illustrates an Euler–Maruyama simulation, updating the log process with a mean-reversion term and a normally distributed shock scaled by the square root of the time increment, then exponentiating the simulated path.
The author asks whether mean reversion should instead be specified directly for the level with multiplicative noise, and asks about drawbacks and more accurate discretization. The document contains no replies or empirical comparison, so it does not resolve which model is preferable. The simulated path alone cannot establish that either process matches a particular asset; model choice depends on the intended dynamics, and the displayed discretization is an approximation.
Key ideas
- An Ornstein–Uhlenbeck process for log values produces a positive level process after exponentiation.
- The log process reverts toward a constant, corresponding to an exponential long-run level in the original scale.
- The example uses Euler–Maruyama with normally distributed increments scaled by the square root of the time step.
- The document raises, but does not answer, how this model compares with direct level mean reversion and multiplicative noise.
- The simulation method and model suitability are not empirically evaluated.
Tags
Full text
# OU Mean-Reverting Lognormal Process Simulation
# OU Mean-Reverting Lognormal Process Simulation
I want to make sure that the following reasoning and simulation technique is reliable (also valid) due I'm trying to model a mean-reverting lognormal process.
The idea is to define a process $S_t$
Such that
$\ln(S_t) = X_t \sim \text{Ornstein-Uhlenbeck}$ $ \Rightarrow \quad S_t = e^{X_t} $
This should result in a lognormally distributed process that reverts to a long-term level in log-space ($\ln(S_t)$ reverts to $\mu$, so $S_t$ reverts to $e^{\mu}$)
This is the simulation code I managed to write (Not written from scratch; I have been researching around the web) For the OU process in log-space using Euler-Maruyama:
```
import numpy as np
import matplotlib.pyplot as plt
# Set parameters for the process
mu = 1.0
theta = 0.5
sigma = 0.2 # The randomness or volatility in the process
X0 = np.log(1.0) # Starting value
# Set up time variables
T = 10.0
N = 1000
dt = T / N
t = np.linspace(0, T, N+1)
X = np.zeros(N+1)
X[0] = X0
for i in range(1, N+1):
Z = np.random.normal() # Generate random noise from a normal distribution
# Calculate the next value based on previous value, mean reversion, and noise
X[i] = X[i-1] + theta * (mu - X[i-1]) * dt + sigma * np.sqrt(dt) * Z
S = np.exp(X)
# Plot the result
plt.plot(t, S)
plt.title("Mean-Reverting Lognormal Process")
plt.xlabel("Time")
plt.ylabel("S(t)")
plt.grid(True)
plt.show()
```
My questions,
- Is it theoretically or practically justified to model mean reversion directly on the process $( S_t )$ with multiplicative noise, instead of applying mean reversion on its logarithm $\ln (S_t)$? What are the potential implications or benefits of choosing one approach over the other?
- Does this method have any known drawbacks or potential enhancements (such as more accurate simulation or improved discretization)?
Any thoughts or recommendations on this would be greatly appreciated.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.