Skip to main content

qualia_core_db/solvers/statistics/regression/
spurious.rs

1//! Spurious-regression guards: trend / ADF-proxy warnings for time-ordered series.
2
3use serde::Serialize;
4
5use crate::solvers::statistics::{adf_proxy, descriptive::mean};
6
7#[derive(Debug, Clone, PartialEq, Serialize)]
8pub struct SpuriousGuard {
9    /// ADF-like coefficient on lagged level (more negative ⇒ more stationary).
10    pub y_adf_proxy: f64,
11    pub x_adf_proxy: Option<f64>,
12    pub y_looks_trended: bool,
13    pub x_looks_trended: bool,
14    /// True when both series look non-stationary — do not trust classical t/F.
15    pub warn_spurious: bool,
16    pub detail: String,
17}
18
19fn looks_trended(series: &[f64]) -> bool {
20    let n = series.len();
21    if n < 8 {
22        return false;
23    }
24    // Linear time trend R² via simple correlation with t.
25    let t: Vec<f64> = (0..n).map(|i| i as f64).collect();
26    let mt = mean(&t).unwrap_or(0.0);
27    let my = mean(series).unwrap_or(0.0);
28    let mut num = 0.0;
29    let mut dt = 0.0;
30    let mut dy = 0.0;
31    for i in 0..n {
32        let a = t[i] - mt;
33        let b = series[i] - my;
34        num += a * b;
35        dt += a * a;
36        dy += b * b;
37    }
38    if dt <= 0.0 || dy <= 0.0 {
39        return false;
40    }
41    let r2 = (num * num) / (dt * dy);
42    r2 > 0.5
43}
44
45/// Guard for bivariate time-series OLS. Pass `x_series = None` for y-only check.
46pub fn spurious_regression_guard(y: &[f64], x_series: Option<&[f64]>) -> Option<SpuriousGuard> {
47    if y.len() < 8 {
48        return None;
49    }
50    let y_adf = adf_proxy(y);
51    if !y_adf.is_finite() {
52        return None;
53    }
54    let y_trended = looks_trended(y) || y_adf > -0.1;
55    let (x_adf, x_trended) = if let Some(x) = x_series {
56        if x.len() != y.len() {
57            return None;
58        }
59        let a = adf_proxy(x);
60        (Some(a), looks_trended(x) || a > -0.1)
61    } else {
62        (None, false)
63    };
64    let warn = match x_adf {
65        Some(_) => y_trended && x_trended,
66        None => y_trended,
67    };
68    let detail = if warn {
69        "both series look non-stationary / trended — classical significance may be spurious"
70            .to_string()
71    } else {
72        "no strong spurious-regression warning".to_string()
73    };
74    Some(SpuriousGuard {
75        y_adf_proxy: y_adf,
76        x_adf_proxy: x_adf,
77        y_looks_trended: y_trended,
78        x_looks_trended: x_trended,
79        warn_spurious: warn,
80        detail,
81    })
82}
83
84#[cfg(test)]
85mod tests {
86    use super::*;
87
88    #[test]
89    fn flags_common_trend() {
90        let y: Vec<f64> = (0..30).map(|i| i as f64 + 0.1).collect();
91        let x: Vec<f64> = (0..30).map(|i| 2.0 * i as f64).collect();
92        let g = spurious_regression_guard(&y, Some(&x)).unwrap();
93        assert!(g.warn_spurious, "{g:?}");
94    }
95
96    #[test]
97    fn clean_noise_not_flagged() {
98        let y = [
99            0.1, -0.2, 0.15, -0.1, 0.05, -0.08, 0.12, -0.03, 0.07, -0.11, 0.02, -0.06, 0.09, -0.04,
100            0.01, -0.07, 0.11, -0.02, 0.08, -0.05,
101        ];
102        let g = spurious_regression_guard(&y, None).unwrap();
103        assert!(!g.warn_spurious);
104    }
105}