Fractional Differentiation

Modeling prices runs into a dilemma. Raw price levels are non-stationary, they trend and wander, so most statistical and machine-learning models choke on them (see Stationarity and Unit Roots and the ADF Test). The usual fix is to take returns, that is, to difference the series once. But a full difference is a sledgehammer: it makes the series stationary and erases almost all of its memory. Today's return tells you nothing about whether the price is high or low, near a support level, or far from its recent range. You threw away the very "level" information a predictor might want.

Fractional differentiation is the scalpel. Instead of differencing a whole step (order $1$, which gives returns) or not at all (order $0$, the raw level), you difference by a fractional order $d$ between $0$ and $1$, just enough to pass a stationarity test while keeping as much memory as possible.

The fractional difference operator

Differencing is the operator $(1 - B)$, where $B$ is the backshift (lag) operator: $B X_t = X_{t-1}$. A first difference is $(1-B)X_t = X_t - X_{t-1}$. Raising it to a real power $d$ and expanding the binomial series gives an infinite weighted sum of past values:

$$(1 - B)^d X_t = \sum_{k=0}^{\infty} w_k\, X_{t-k}, \qquad w_k = -\,w_{k-1}\,\frac{d - k + 1}{k},\ \ w_0 = 1.$$

In words: the fractionally-differenced value at time $t$ is a weighted sum of the current and all past prices, with weights $w_k$ that you build by a simple recursion starting from $w_0 = 1$. The key is how fast those weights decay. For $d = 1$ they collapse to $\{1, -1, 0, 0, \dots\}$, ordinary returns, no memory beyond one lag. For $d = 0$ they are $\{1, 0, 0, \dots\}$, the untouched level. For a fraction like $d = 0.5$, the weights decay slowly, so the series keeps a long, fading memory of the past.

Lag $k$	$d = 0$ (level)	$d = 0.5$	$d = 1$ (return)
0	1	1	1
1	0	−0.500	−1
2	0	−0.125	0
3	0	−0.063	0
4	0	−0.039	0
5	0	−0.027	0

Weights on past prices for three differencing orders. Returns ($d=1$) keep only lag 0 and 1, wiping out all longer memory. The fractional order $d=0.5$ keeps a slowly-decaying tail, so the transformed series still remembers where the price has been.

The stationarity-vs-memory trade-off

As you raise $d$ from $0$ toward $1$, two things move in opposite directions. Stationarity improves, the ADF test statistic gets more negative and eventually rejects the unit root. Memory fades, the correlation between the transformed series and the original price level drops toward zero. The sweet spot is the smallest $d$ that passes the stationarity test: you buy just enough stationarity and pay the minimum possible in lost memory.

Worked example

You have a log-price series that fails the ADF test badly (it has a unit root). Two extremes:

• Returns ($d = 1$). The ADF test strongly rejects the unit root, fully stationary, but the correlation between returns and the price level is essentially $0$. Every trace of "how high is the price" is gone.
• Level ($d = 0$). Correlation with the original is $1.0$ (it is the original), but it's hopelessly non-stationary.

Now sweep $d$ upward and re-run ADF at each step. Suppose the series first passes the ADF test at the $5\%$ level around $d \approx 0.4$. At that $d$, the transformed series still has a correlation of roughly $0.99$ with the original price level, it is now stationary yet has kept almost all of its memory. Compare that to returns, which are stationary but retain none. Feed the $d = 0.4$ series to your model and it gets both a well-behaved input and the level information; feed it returns and it only gets the latter erased. That preserved memory is often exactly what carries the predictive signal.

Pitfalls

• Truncating the weights too early. The weight tail decays slowly, so a short window drops real memory. Use a small weight-threshold cutoff, not an arbitrary fixed window.
• Look-ahead through the window. The weighted sum uses past values only, but make sure your implementation never reaches forward, and fit any scaler after differencing, inside each CV fold.
• Over-differencing. Picking a large $d$ "to be safe" needlessly destroys memory, the opposite of the goal. Smallest passing $d$ wins.
• Assuming it creates signal. Fractional differencing is a preprocessing step that preserves information; it doesn't manufacture predictability where none exists.

In interviews

If asked "how do you make a price series stationary without losing its memory?", name fractional differentiation: difference by a real order $d$ between $0$ and $1$, chosen as the smallest value that passes the ADF test, so the weights on past prices decay slowly and retain memory. Contrast it with returns ($d=1$, stationary but memoryless) and levels ($d=0$, full memory but non-stationary), and mention that it's a feature-engineering step feeding the model's inputs, not a source of alpha by itself.