qualia_core_db/solvers/statistics/regression/
spurious.rs1use serde::Serialize;
4
5use crate::solvers::statistics::{adf_proxy, descriptive::mean};
6
7#[derive(Debug, Clone, PartialEq, Serialize)]
8pub struct SpuriousGuard {
9 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 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 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
45pub 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}