LessonThis is a lesson restated in new words. Any figure in it is an example from the source, not this desk's record.
Fractional Brownian motion keeps a memory. Ordinary Brownian motion is Markovian: given the present, the older path does not change the next step. Fractional Gaussian noise has a covariance that depends on the lag and on a Hurst parameter H, and fractional Brownian motion is the cumulative sum of that noise, started at zero. The Davies-Harte method builds one such path from a circulant embedding and a Fourier transform. In the lecture's check at 64 steps, the relative error in variance was about 10 percent for the noise and 0.42 percent for the motion. Raising the step count pulled both errors down. The method is a sampler, not a fast way to calibrate a live volatility surface.
Why it matters
Log volatility is one place researchers put this process, because volatility shows long-range dependence that a Markov variance cannot. The lecture's spoken Hurst value is garbled, so the safe statement is the definition rather than a fitted number: H equal to one half recovers ordinary Brownian increments, H above one half makes increments persist, and H below one half makes them turn over more than a standard Brownian path. The cost of the extra memory is that the variance path is path-dependent. Fitting a surface then means simulating whole paths on a strike-maturity grid inside a parameter search. There is no closed price to lean on. This article stays with the sampler.
The idea in plain words
Inputs are H, a time horizon T that is usually scaled to 1, and a step count N. More steps make the sample moments sit closer to the theory. The seven moves are these. Build a grid of N+1 times from 0 to T. Write the autocovariance of fractional Gaussian noise at lag k, and treat lags outside the path as zero. Stack that covariance into a circulant vector: lags 0 through N, then back down toward 1. The first half is an ordinary loop of the covariance function. The second half is the same function walked backward so the vector is the right length for a circulant embedding. Take a real Fourier transform of that vector and keep the eigenvalues that are real and positive. A covariance embedding that produces a negative eigenvalue was built wrong, and the lecture's code is meant to fail loudly. NumPy's forward transform is the unnormalized discrete Fourier transform, which is the scaling this step wants. Do not divide it by the length. The eigenvalue vector is longer than N. Length 2N is the figure to expect. Draw a complex Gaussian vector of that length. The two endpoints are real standard normals scaled by the square root of the matching eigenvalues. Each interior frequency is a pair of independent standard normals, one of them multiplied by the imaginary unit, then scaled by the square root of the eigenvalue over two. Negative frequencies are the conjugates. Invert the transform, undo its division by the vector length, scale by (T/N) to the power H, and take a running sum from zero. That sum is the path.
How to use it
Check variances before you check pictures. At 64 steps the lecture saw about 10 percent relative error on the noise variance and 0.42 percent on the motion. A finer grid printed about minus 8 percent on the noise and a still smaller error on the motion. At 256 steps both were described as close to the theoretical dispersion. A covariance heatmap of the motion matched the theoretical grid, with a very small squared error. More paths should shrink that error like one over the square root of the path count, and a finer grid should shrink the noise-variance error. The lecture's curves did both. One plotted path will not catch a missing square-root correction.
What usually goes wrong
Forgetting the inverse-transform rescaling, which the lecture says sends empirical variances toward zero as the grid is refined. Using (T/N) to the 2H on the noise instead of on the variance. Dropping conjugate symmetry and producing a complex path where a real path was required. And treating a 10 percent variance error at 64 steps as a broken proof. The lecture's own next grids reduced it. The remaining use error is economic. A correct sampler is still too slow to nest inside a live calibration, which is why the lecture separates "can I generate the path" from "can I mark a book with it."
Questions people ask
What is being simulated, the noise or the motion?
Both, in that order. Fractional Gaussian noise comes out of the inverse transform. Fractional Brownian motion is its running sum, starting at zero. The lecture checks both variances so a bug in the sum is not confused with a bug in the noise.
Why did 64 steps show a 10 percent error?
That was the relative variance error of the noise on a coarse grid. The motion's relative error on the same grid was 0.42 percent. At 256 steps the lecture describes both as close to theory. Coarse grids are a weak indictment of the method.
What does Hurst control?
The lag covariance. One half is ordinary Brownian memory. The lecture motivates the process with long-range volatility dependence and does not leave a clean numerical estimate of H to quote.