Half-Life Estimator (O-U)

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// Half-Life Estimator for Mean Reversion (Ornstein-Uhlenbeck Process)
// Estimates how many bars until price reverts halfway to the mean

//@version=5
indicator('Half-Life Estimator (O-U)', 'HL🔄', precision=2, max_bars_back=1000)

// ══════════════════════════════════════════════════════════════════════════════
// INPUTS
// ══════════════════════════════════════════════════════════════════════════════
group1 = 'Calculation Settings'
group2 = 'Display Settings'

src = input.source(close, 'Source', group=group1)
lookback = input.int(100, 'Lookback Period', minval=20, maxval=500, group=group1, tooltip='Number of bars for regression. Larger = more stable, smaller = more responsive')
showTable = input.bool(true, 'Show Info Table', group=group2)
showBands = input.bool(true, 'Show Mean ± Std Bands', group=group2)
bandMult = input.float(2.0, 'Band Multiplier', minval=0.5, maxval=4.0, step=0.5, group=group2)
bgColor = input.bool(true, 'Dark Background', group=group2)

bgcolor(bgColor ? color.new(#000000, 80) : na)

// ══════════════════════════════════════════════════════════════════════════════
// HALF-LIFE CALCULATION (Ornstein-Uhlenbeck via AR(1) Regression)
// ══════════════════════════════════════════════════════════════════════════════

// Log prices for stationarity
logPrice = math.log(src)

// Lagged difference: y(t) - y(t-1) regressed on y(t-1)
// Model: Δy = λ * (y - μ) + ε  →  Half-life = -ln(2) / ln(1 + λ)
deltaY = logPrice - logPrice[1]
lagY = logPrice[1]

// Calculate means
meanDelta = ta.sma(deltaY, lookback)
meanLag = ta.sma(lagY, lookback)

// OLS Regression: Δy = α + β * y(t-1) + ε
// β (lambda) tells us speed of mean reversion
// Covariance and Variance
float sumCov = 0.0
float sumVar = 0.0

for i = 0 to lookback - 1
    devDelta = nz(deltaY[i]) - meanDelta
    devLag = nz(lagY[i]) - meanLag
    sumCov := sumCov + devDelta * devLag
    sumVar := sumVar + devLag * devLag

// Beta (mean reversion speed parameter)
beta = sumVar != 0 ? sumCov / sumVar : 0

// Half-life in bars: -ln(2) / ln(1 + β)
// Note: β should be negative for mean reversion
float halfLife = na
if beta < 0 and beta > -1
    halfLife := -math.log(2) / math.log(1 + beta)

// Cap half-life for display purposes
halfLifeCapped = halfLife > 500 ? 500 : halfLife < 0 ? na : halfLife

// ══════════════════════════════════════════════════════════════════════════════
// EQUILIBRIUM MEAN & BANDS
// ══════════════════════════════════════════════════════════════════════════════

// Implied equilibrium (long-term mean)
alpha = meanDelta - beta * meanLag
equilibrium = beta != 0 ? math.exp(-alpha / beta) : ta.sma(src, lookback)

// Standard deviation for bands
stdev = ta.stdev(src, lookback)
upperBand = equilibrium + bandMult * stdev
lowerBand = equilibrium - bandMult * stdev

// Z-Score from equilibrium
zScore = stdev != 0 ? (src - equilibrium) / stdev : 0

// ══════════════════════════════════════════════════════════════════════════════
// REGIME CLASSIFICATION
// ══════════════════════════════════════════════════════════════════════════════

isMeanReverting = beta < 0 and halfLifeCapped < 50
isRandom = math.abs(beta) < 0.01 or na(halfLife)
isTrending = beta >= 0 or halfLifeCapped >= 50

regimeColor = isMeanReverting ? color.lime : isTrending ? color.red : color.gray
regimeText = isMeanReverting ? 'Mean Reverting' : isTrending ? 'Trending/Random' : 'Inconclusive'

// ══════════════════════════════════════════════════════════════════════════════
// SIGNALS
// ══════════════════════════════════════════════════════════════════════════════

// Entry signals when mean reverting AND price at extreme
buySignal = isMeanReverting and zScore < -bandMult
sellSignal = isMeanReverting and zScore > bandMult

// ══════════════════════════════════════════════════════════════════════════════
// PLOTS
// ══════════════════════════════════════════════════════════════════════════════

// Half-life plot
plot(halfLifeCapped, 'Half-Life (bars)', color=regimeColor, linewidth=2, style=plot.style_stepline)

// Reference lines
hline(10, 'Fast Reversion (10 bars)', color=color.new(color.green, 50), linestyle=hline.style_dashed)
hline(30, 'Slow Reversion (30 bars)', color=color.new(color.yellow, 50), linestyle=hline.style_dashed)
hline(50, 'Very Slow (50 bars)', color=color.new(color.red, 50), linestyle=hline.style_dashed)

// Background coloring for regime
bgcolor(isMeanReverting ? color.new(color.green, 90) : na)

// Signals
plotshape(buySignal, 'Buy Signal', shape.triangleup, location.bottom, color.lime, size=size.small)
plotshape(sellSignal, 'Sell Signal', shape.triangledown, location.top, color.red, size=size.small)

// ══════════════════════════════════════════════════════════════════════════════
// INFO TABLE
// ══════════════════════════════════════════════════════════════════════════════

var table infoTable = table.new(position.top_right, 2, 5, bgcolor=color.new(#1a1a2e, 10), frame_color=color.gray, frame_width=1, border_width=1)

if barstate.islast and showTable
    table.cell(infoTable, 0, 0, 'Half-Life', text_color=color.white, bgcolor=color.new(color.gray, 50))
    table.cell(infoTable, 1, 0, str.tostring(math.round(halfLifeCapped, 1)) + ' bars', text_color=regimeColor, bgcolor=color.new(regimeColor, 85))
    
    table.cell(infoTable, 0, 1, 'Beta (λ)', text_color=color.white, bgcolor=color.new(color.gray, 50))
    table.cell(infoTable, 1, 1, str.tostring(math.round(beta, 4)), text_color=beta < 0 ? color.lime : color.red, bgcolor=color.new(color.gray, 70))
    
    table.cell(infoTable, 0, 2, 'Regime', text_color=color.white, bgcolor=color.new(color.gray, 50))
    table.cell(infoTable, 1, 2, regimeText, text_color=regimeColor, bgcolor=color.new(regimeColor, 85))
    
    table.cell(infoTable, 0, 3, 'Z-Score', text_color=color.white, bgcolor=color.new(color.gray, 50))
    table.cell(infoTable, 1, 3, str.tostring(math.round(zScore, 2)), text_color=zScore > 0 ? color.red : color.lime, bgcolor=color.new(color.gray, 70))
    
    table.cell(infoTable, 0, 4, 'Equilibrium', text_color=color.white, bgcolor=color.new(color.gray, 50))
    table.cell(infoTable, 1, 4, str.tostring(math.round(equilibrium, 2)), text_color=color.aqua, bgcolor=color.new(color.gray, 70))

// ══════════════════════════════════════════════════════════════════════════════
// ALERTS
// ══════════════════════════════════════════════════════════════════════════════

alertcondition(buySignal, 'Buy Signal', 'Half-Life: Mean reversion BUY (oversold)')
alertcondition(sellSignal, 'Sell Signal', 'Half-Life: Mean reversion SELL (overbought)')
alertcondition(ta.cross(halfLifeCapped, 30), 'Regime Change', 'Half-Life crossed 30 bars threshold')