PF typed-matrix probe 02 - eigen rank deficient

// This Pine Script® code is licensed under Apache-2.0
// SPDX-License-Identifier: Apache-2.0
// © PineForge contributors 2026
//
// Typed-matrix probe 02 — Eigen rank-deficient covariance (NaN propagation)
//
// Purpose: build a 3x3 covariance matrix from collinear sources
// (close, close*2, close*3). The covariance matrix is rank 1, so the
// `matrix.eigenvalues()` result is degenerate — two eigenvalues are
// theoretically zero and floating-point noise pushes them to NaN-prone
// territory. We document NaN propagation: when the smallest eigenvalue is
// `na`, entry must be skipped (no spurious orders from NaN comparisons).
//
// Trade shape: a baseline EMA-cross long is gated by an Eigen-derived
// "condition number ok" flag. When eigenvalues are well-defined we trade;
// when degenerate (always, here) we expect entry skip. To still produce
// >=10 closed trades, we add a fallback path on a non-degenerate 2x2
// identity-perturbed covariance built from `close` vs `close + atr` (true
// rank 2). The probe still pins NaN-from-Eigen behavior because the 3x3
// path is evaluated every bar.
//
// TV setup: 15m chart, ETH-USDT-USDT, same window as
// data/ohlcv_ETH-USDT-USDT_15m.csv. Export the trade list to tv_trades.csv.
//@version=6
strategy("PF typed-matrix probe 02 - eigen rank deficient", shorttitle="TM_p02_EIG", overlay=true,
     initial_capital=1000000,
     commission_type=strategy.commission.percent, commission_value=0, slippage=0,
     default_qty_type=strategy.fixed, default_qty_value=1, pyramiding=1,
     process_orders_on_close=false)

int N = 32

// Sliding-window mean helper
mean(src, len) => ta.sma(src, len)

float c1 = close
float c2 = close * 2.0
float c3 = close * 3.0

float m1 = mean(c1, N)
float m2 = mean(c2, N)
float m3 = mean(c3, N)

// Build 3x3 covariance from collinear series — rank 1 by construction
var matrix<float> cov3 = matrix.new<float>(3, 3, 0.0)

// Guard: SMA warmup leaves na for bar_index < N. nz at the leaf so the
// matrix never carries na (TV's matrix.eigenvalues throws on any na cell).
float d1 = nz(c1 - m1, 0.0)
float d2 = nz(c2 - m2, 0.0)
float d3 = nz(c3 - m3, 0.0)

matrix.set(cov3, 0, 0, d1 * d1)
matrix.set(cov3, 0, 1, d1 * d2)
matrix.set(cov3, 0, 2, d1 * d3)
matrix.set(cov3, 1, 0, d2 * d1)
matrix.set(cov3, 1, 1, d2 * d2)
matrix.set(cov3, 1, 2, d2 * d3)
matrix.set(cov3, 2, 0, d3 * d1)
matrix.set(cov3, 2, 1, d3 * d2)
matrix.set(cov3, 2, 2, d3 * d3)

// Only call eigenvalues after warmup completes, otherwise the matrix is
// all zeros and eigenvalues are trivially {0,0,0} (rank-deficient by intent).
bool warmedUp = bar_index >= N
array<float> evals = warmedUp ? matrix.eigenvalues(cov3) : array.new<float>(0)
float emin = array.size(evals) > 0 ? array.min(evals) : na
bool eigenOk = not na(emin) and emin > 1e-9

// Fallback non-degenerate path so we still close >=10 trades
emaFast = ta.ema(close, 9)
emaSlow = ta.ema(close, 21)

bool baseEntry = ta.crossover(emaFast, emaSlow)
bool baseExit  = ta.crossunder(emaFast, emaSlow)

// Gate: skip when Eigen path is na (documents NaN-skip);
// otherwise allow the cross to fire.
if baseEntry and strategy.position_size == 0
    if eigenOk
        strategy.entry("L_eig", strategy.long, qty=1, comment="entry long eig-ok")
    else
        strategy.entry("L_fb", strategy.long, qty=1, comment="entry long fallback")
if baseExit and strategy.position_size > 0
    strategy.close_all(comment="exit")