feat(ruview-gamma): RuVector self-learning layer (ADR-250 §10 items 3-6)

New ruvector module: anonymized ProfileStore (one-way SHA-256 hashed tags,
safe-session scores only), deterministic exact kNN, cohort warm-start (a new
person's optimizer seeded from the k nearest responders as down-weighted GP
pseudo-observations), physiological drift detection (Welford centroid with
stimulus-input fields masked out of the distance), and deterministic k-means
response clustering.

Honesty guarantees, asserted in tests: cohort priors carry >=25x the
real-observation noise, are excluded from the EI incumbent, the audit log,
and the clinician report — borrowed expectations never masquerade as this
person's measured response. The GP gains per-observation noise; the real
path is arithmetically unchanged (pinned witness 13cb164c... preserved).

Governor wiring: seed_from_cohort, export_anonymized_profile, per-session
drift_status. Integration tests: cohort warm-start beats the cold 40 Hz
prior for a detuned subject; collapsed physiology flags Drifted.

Crate: 75 tests + 1 doctest. Workspace gate: 2,876 passed, 0 failed.
Benches: kNN/500 profiles ~15us, warm-start ~16us; no regression on
existing paths (recommend ~15us, calibration sweep ~111us).

https://claude.ai/code/session_01MjBucx95K4BuUxZi8NWwRH

CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+- **`ruview-gamma` RuVector self-learning layer (ADR-250 §10 items 3–6).** New `ruvector` module: anonymized `ProfileStore` (one-way SHA-256 hashed tags, never `person_id`; safe-session scores only), deterministic exact kNN (fixed-range normalization, index tie-break), **cohort warm-start** — a new person's optimizer is seeded from the k nearest responders as down-weighted GP pseudo-observations (`BayesianOptimizer::observe_prior`, ≥25× real-observation noise, excluded from the EI incumbent / audit / clinician report), **physiological drift detection** (Welford centroid with stimulus-input fields masked out of the distance; `Drifted` recommends re-calibration), and deterministic k-means response clustering (farthest-point seeding, no RNG). Wired into `RufloGovernor` (`seed_from_cohort`, `export_anonymized_profile`, per-session `drift_status`). The GP gains per-observation noise (real path unchanged — pinned witness `13cb164c…` preserved). 11 new module tests + 2 integration tests (cohort warm-start beats the cold 40 Hz prior for a detuned subject; collapsed physiology flags drift); crate now 75 tests + 1 doctest. Benches: kNN over 500 profiles ~15 µs, full warm-start ~16 µs; no regression on existing paths.
 - **`ruview-gamma` crate (ADR-250) — Adaptive Gamma Entrainment.** Governed, deterministic, safety-constrained personalization of 40 Hz-prior light+sound stimulation, treating 40 Hz as the evidence-based *starting prior* and learning each person's safe entrainment response curve. Eleven modules: `stimulus` (params + `SafetyEnvelope` validate/clamp), `safety` (exclusion screen + latched `SafetyMonitor` with hard-stop reasons), `response` (`RuViewState`, optional `EegMeasurement`, 20-field `PersonResponseVector` with sticky adverse flag), `objective` (safe-entrainment score; safety is a hard gate, not a weight), `simulator` (deterministic ChaCha20 `frequency_response_curve`), `optimizer` (Phase-1 calibration sweep + Phase-2 GP/Expected-Improvement + Phase-4 closed-loop control), `bandit` (Phase-3 LinUCB over envelope-safe arms), `session` (reproducible SHA-256 `session_hash`), `ruflo` (consent→exclusion→envelope→run→monitor→score→update→witnessed audit, trial/sham mode, clinician export, claim discipline), `proof` (deterministic bundle witness), `math` (dependency-light numerics). **Safety invariant** (asserted in tests): no recommendation, calibration step, bandit arm, or closed-loop nudge can ever emit a stimulus outside the `SafetyEnvelope`; non-finite inputs clamp to the conservative floor. **Claim discipline**: the only product claim is `PRODUCT_CLAIM` = "personalized entrainment optimization" — never Alzheimer's treatment (ADR-250 §19). Standalone leaf crate (no internal RuView deps), `publish = false` pending safety sign-off. 64 unit/integration tests + 1 doctest pass; deterministic witness pinned (`13cb164c…`); criterion benches (safety-stop tick ~9.3 ns vs the ADR §17 500 ms bound, Bayesian recommend ~105 µs, full 9-session governed sweep ~486 µs). See [ADR-250](docs/adr/ADR-250-adaptive-gamma-entrainment.md).
 - **RuView beyond-SOTA research series** (`docs/research/ruview-beyond-sota/`, 6 docs) — research-swarm output defining the beyond-SOTA bar and the path to it: system capability audit (role→crate maturity matrix, gap analysis, risk register), web-verified 2026 SOTA landscape per capability axis (incl. ratified IEEE 802.11bf-2025), 8-pillar target architecture on the ADR-136 contract spine (no rewrite), 6-layer benchmark/validation methodology (all 15 criterion bench targets inventoried; ADR-149 statistical protocol), and a determinism-safe optimization roadmap. Includes session validation evidence: 2,797 workspace tests / 0 failed, Python proof PASS (bit-exact), paired pre/post criterion runs.
 

docs/adr/ADR-250-adaptive-gamma-entrainment.md

@@ -188,6 +188,7 @@ outcomes; consumer deployment is safe without screening; 40 Hz is always optimal
 | M4 EEG validation (contract) | `response.rs` (`EegMeasurement`), `objective.rs` | **Optional input implemented** |
 | M5 Adaptive optimizer | `optimizer.rs` (Phase 1+2), `bandit.rs` (Phase 3), closed-loop | **Implemented** |
 | M6 Trial mode | `ruflo.rs` (consent, inclusion/exclusion, sham, audit, session hash) | **Implemented** |
+| §10 RuVector self-learning | `ruvector.rs` (anonymized `ProfileStore`, deterministic kNN, cohort warm-start priors via down-weighted GP pseudo-observations, physiological drift detection, deterministic clustering) | **Implemented** |
 
 The crate is a **deterministic, dependency-light leaf** (no internal RuView
 deps, ChaCha20 PRNG, SHA-256 witness — same discipline as `nvsim`), so the

v2/crates/ruview-gamma/README.md

@@ -42,6 +42,7 @@ conservative floor, never the cap.
 | `simulator` | §21 M1 | deterministic ChaCha20 `frequency_response_curve(person, state, stimulus)` |
 | `optimizer` | §8 | Phase-1 calibration sweep, Phase-2 GP + Expected-Improvement, Phase-4 closed-loop control |
 | `bandit` | §8 P3 | LinUCB contextual bandit over envelope-safe arms |
+| `ruvector` | §10 items 3–6 | anonymized `ProfileStore` (one-way hashed tags), deterministic kNN, cohort warm-start priors (down-weighted pseudo-observations), `DriftDetector` over the physiological sub-vector, deterministic k-means clustering |
 | `session` | §11, §13 | hashable `SessionRecord`, reproducible `session_hash` (SHA-256, quantized canonical form) |
 | `ruflo` | §11 | consent → exclusion → envelope → run → monitor → score → update → witnessed audit; trial/sham mode; clinician export; claim discipline |
 | `proof` | — | deterministic bundle witness (mirrors `nvsim` / `verify.py`) |
@@ -91,10 +92,27 @@ the optimizer, simulator, response update, or session hashing.
 | `gamma_bandit_select` | ~74 ns | LinUCB decision |
 | `gamma_bayesian_recommend` | ~19 µs | GP + EI over the 0.1 Hz envelope grid (was ~105 µs: the GP is now factorized once per recommend, not once per grid candidate — −81%, bit-identical) |
 | `gamma_calibration_sweep` | ~135 µs | full 9-session enroll → simulate → score → update → witness (was ~486 µs, −71%) |
+| `gamma_cohort_knn_500` | ~15 µs | exact kNN over 500 anonymized profiles |
+| `gamma_cohort_warm_start_500` | ~16 µs | full cohort prior construction (runs once per enrollment) |
+
+## Self-learning across people (ADR-250 §10)
+
+`RufloGovernor::export_anonymized_profile()` publishes a participant's 20-field
+vector + per-frequency scores from **safe sessions only** under a one-way hashed
+tag; `seed_from_cohort(&store, k)` warm-starts a new person's optimizer from the
+k nearest responders as **down-weighted pseudo-observations**
+(`observe_prior`, ≥25× the real-observation noise). Priors shape where the
+optimizer looks first but never count as measured data — they are excluded from
+the EI incumbent, the audit log, and the clinician report. Per-session
+`drift_status()` (Welford centroid over the *physiological* sub-vector —
+stimulus inputs masked out) flags when recalibration is warranted.
 
 ## Roadmap (ADR-250 §21)
 
 M1 simulator ✅ · M2 device harness (envelope + e-stop contract) ✅ · M3 RuView
 state contract ✅ · M4 optional EEG input ✅ · M5 adaptive optimizer (BO + bandit
-+ closed-loop) ✅ · M6 trial mode (sham/blinding + clinician export) ✅. Hardware
-actuation, real RF sensing, and real EEG land behind feature-flagged adapters.
++ closed-loop) ✅ · M6 trial mode (sham/blinding + clinician export) ✅ ·
+§10 RuVector self-learning (cohort warm-start, drift detection, clustering) ✅.
+Hardware actuation, real RF sensing, and real EEG land behind feature-flagged
+adapters. An HNSW backend (the `ruvector` crates) drops in for `ProfileStore`
+once cohorts grow past ~10⁵ profiles.

v2/crates/ruview-gamma/benches/optimizer_bench.rs

@@ -11,6 +11,7 @@ use ruview_gamma::bandit::{BanditContext, ContextualBandit};
 use ruview_gamma::optimizer::BayesianOptimizer;
 use ruview_gamma::response::RuViewState;
 use ruview_gamma::ruflo::{Consent, RufloGovernor};
+use ruview_gamma::ruvector::{AnonymizedProfile, ProfileStore, VECTOR_DIM};
 use ruview_gamma::safety::{SafetyMonitor, SafetyTick};
 use ruview_gamma::simulator::{LatentPerson, ResponseSimulator};
 use ruview_gamma::stimulus::{SafetyEnvelope, StimulusParameters};
@@ -80,11 +81,40 @@ fn bench_bandit(c: &mut Criterion) {
     });
 }
 
+fn cohort_store(n: usize) -> ProfileStore {
+    let mut store = ProfileStore::new();
+    for i in 0..n {
+        let mut vector = [0.5; VECTOR_DIM];
+        vector[5] = 12.0 + (i % 8) as f64; // breathing_rate spread
+        vector[11] = 36.0 + (i % 9) as f64; // frequency spread
+        store.upsert(AnonymizedProfile {
+            profile_tag: format!("p{i:04}"),
+            vector,
+            frequency_scores: (36..=44).map(|f| (f as f64, 0.5 + 0.01 * (i % 7) as f64)).collect(),
+        });
+    }
+    store
+}
+
+fn bench_cohort_knn(c: &mut Criterion) {
+    let store = cohort_store(500);
+    let mut q = [0.5; VECTOR_DIM];
+    q[5] = 14.0;
+    q[11] = 39.0;
+    c.bench_function("gamma_cohort_knn_500", |b| {
+        b.iter(|| black_box(store.k_nearest(black_box(&q), 5)))
+    });
+    c.bench_function("gamma_cohort_warm_start_500", |b| {
+        b.iter(|| black_box(store.warm_start_prior(black_box(&q), 5, 1e-4)))
+    });
+}
+
 criterion_group!(
     benches,
     bench_calibration,
     bench_recommend,
     bench_safety_tick,
-    bench_bandit
+    bench_bandit,
+    bench_cohort_knn
 );
 criterion_main!(benches);

v2/crates/ruview-gamma/src/lib.rs

@@ -75,6 +75,7 @@ pub mod optimizer;
 pub mod proof;
 pub mod response;
 pub mod ruflo;
+pub mod ruvector;
 pub mod safety;
 pub mod session;
 pub mod simulator;
@@ -101,9 +102,102 @@ pub use ruflo::PRODUCT_CLAIM;
 mod integration_tests {
     use crate::response::RuViewState;
     use crate::ruflo::{Consent, RufloGovernor, TrialMode};
+    use crate::ruvector::{DriftStatus, ProfileStore};
     use crate::simulator::{LatentPerson, ResponseSimulator};
     use crate::stimulus::{SafetyEnvelope, StimulusParameters};
 
+    /// ADR-250 §10 item 3 end-to-end: a cohort of calibrated responders with
+    /// similar physiology warm-starts a new person's optimizer — the very
+    /// first recommendation already points near the cohort's peak band instead
+    /// of the flat 40 Hz prior, while never counting as measured data
+    /// (`n_real_obs == 0`, `best() == None`).
+    #[test]
+    fn cohort_warm_start_improves_first_recommendation() {
+        let env = SafetyEnvelope::conservative();
+        let sim = ResponseSimulator::new(404);
+        let state = RuViewState::calm_baseline();
+
+        // Find a latent subject with a clearly detuned peak, then build a
+        // cohort of 3 donors with the *same* latent physiology (similar
+        // responders) who each ran a full calibration.
+        let mut chosen = None;
+        for n in 0..50 {
+            let id = format!("cohort-seed-{n}");
+            let p = LatentPerson::from_id(&id);
+            if (p.peak_hz - 40.0).abs() > 2.0 && p.peak_hz > 37.0 && p.peak_hz < 43.0 {
+                chosen = Some((id, p));
+                break;
+            }
+        }
+        let (seed_id, latent) = chosen.expect("a detuned subject exists");
+
+        let mut store = ProfileStore::new();
+        for d in 0..3 {
+            let donor_id = format!("{seed_id}-donor-{d}");
+            let mut donor =
+                RufloGovernor::enroll(&donor_id, env, &[], Consent::Granted).unwrap();
+            donor.run_calibration(&sim, &latent, &state, 5.0, 0).unwrap();
+            store.upsert(donor.export_anonymized_profile());
+        }
+
+        // New person, zero sessions: cold start recommends the 40 Hz prior...
+        let cold = RufloGovernor::enroll("newcomer", env, &[], Consent::Granted).unwrap();
+        let cold_rec = cold.recommend(&StimulusParameters::prior());
+        assert_eq!(cold_rec.stimulus.frequency_hz, 40.0);
+
+        // ...while a cohort-seeded start points into the cohort's peak band.
+        let mut warm = RufloGovernor::enroll("newcomer", env, &[], Consent::Granted).unwrap();
+        let n_priors = warm.seed_from_cohort(&store, 3);
+        assert!(n_priors > 0);
+        let warm_rec = warm.recommend(&StimulusParameters::prior());
+        assert!(env.contains(&warm_rec.stimulus));
+        let cold_err = (cold_rec.stimulus.frequency_hz - latent.peak_hz).abs();
+        let warm_err = (warm_rec.stimulus.frequency_hz - latent.peak_hz).abs();
+        assert!(
+            warm_err < cold_err,
+            "warm-start ({} Hz) should beat cold start ({} Hz) for peak {} Hz",
+            warm_rec.stimulus.frequency_hz,
+            cold_rec.stimulus.frequency_hz,
+            latent.peak_hz
+        );
+        // Honesty: priors are not measured data.
+        assert!(warm.audit_log().is_empty());
+        assert_eq!(warm.clinician_report().n_sessions, 0);
+    }
+
+    /// ADR-250 §10 item 4: a stable participant stays `Stable`; collapsing
+    /// their physiology (restless, uncomfortable, no entrainment) flags
+    /// `Drifted`, recommending recalibration.
+    #[test]
+    fn drift_is_flagged_when_response_collapses() {
+        let env = SafetyEnvelope::conservative();
+        let sim = ResponseSimulator::new(77);
+        let latent = LatentPerson::from_id("drift-subject");
+        let calm = RuViewState::calm_baseline();
+        let mut gov = RufloGovernor::enroll("drift-subject", env, &[], Consent::Granted).unwrap();
+
+        // Settle in: calibration sweep (9 sessions) → stable.
+        gov.run_calibration(&sim, &latent, &calm, 5.0, 0).unwrap();
+        assert_eq!(gov.drift_status(), DriftStatus::Stable);
+
+        // Physiology collapses: restless, fragmented breathing, low stillness.
+        let mut collapsed = calm;
+        collapsed.restlessness_score = 1.0;
+        collapsed.stillness_score = 0.0;
+        collapsed.breathing_stability = 0.1;
+        collapsed.motion_artifact = 0.9;
+        let stim = StimulusParameters::prior();
+        let mut drifted = false;
+        for i in 0..6 {
+            gov.run_session(&sim, &latent, &collapsed, &stim, 100 + i).unwrap();
+            if gov.drift_status() == DriftStatus::Drifted {
+                drifted = true;
+                break;
+            }
+        }
+        assert!(drifted, "collapsed physiology must flag drift");
+    }
+
     /// ADR-250 §18 acceptance: adaptive recommendation beats the fixed 40 Hz
     /// prior in mean simulated entrainment for a person whose peak is away
     /// from 40 Hz. (We assert improvement, not the exact ≥20% figure, which is

v2/crates/ruview-gamma/src/optimizer.rs

@@ -51,6 +51,13 @@ impl CalibrationPlan {
 
 /// Gaussian-process surrogate over the 1-D frequency axis with an
 /// Expected-Improvement acquisition (ADR-250 §8 Phase 2).
+///
+/// Supports two observation classes: **real** sessions from this person
+/// ([`observe`](Self::observe), noise `noise_var`) and **cohort priors** from
+/// anonymized similar responders ([`observe_prior`](Self::observe_prior),
+/// caller-supplied larger noise). Priors shape the posterior mean where the
+/// person has no data yet, but are honestly down-weighted and never define the
+/// EI incumbent — only the person's own sessions can do that.
 #[derive(Debug, Clone)]
 pub struct BayesianOptimizer {
     /// RBF length scale in Hz.
@@ -64,6 +71,10 @@ pub struct BayesianOptimizer {
     /// Observed `(frequency_hz, score)` pairs.
     obs_x: Vec<f64>,
     obs_y: Vec<f64>,
+    /// Per-observation noise variance (diagonal of the noise term in K).
+    obs_noise: Vec<f64>,
+    /// `true` for cohort pseudo-observations (excluded from the incumbent).
+    obs_prior: Vec<bool>,
 }
 
 impl Default for BayesianOptimizer {
@@ -75,26 +86,51 @@ impl Default for BayesianOptimizer {
             xi: 0.01,
             obs_x: Vec::new(),
             obs_y: Vec::new(),
+            obs_noise: Vec::new(),
+            obs_prior: Vec::new(),
         }
     }
 }
 
 impl BayesianOptimizer {
-    /// Record a calibration/optimization result.
+    /// Record a calibration/optimization result from a **real** session.
     pub fn observe(&mut self, frequency_hz: f64, score: f64) {
         self.obs_x.push(frequency_hz);
         self.obs_y.push(score);
+        self.obs_noise.push(self.noise_var);
+        self.obs_prior.push(false);
     }
 
-    /// Number of observations so far.
+    /// Record a **cohort prior** pseudo-observation (ADR-250 §10 item 3):
+    /// the expected score at `frequency_hz` inferred from anonymized similar
+    /// responders, with `noise_var` reflecting how little it is trusted
+    /// (must be ≥ the real-observation noise; clamped up if not).
+    pub fn observe_prior(&mut self, frequency_hz: f64, score: f64, noise_var: f64) {
+        self.obs_x.push(frequency_hz);
+        self.obs_y.push(score);
+        self.obs_noise.push(noise_var.max(self.noise_var));
+        self.obs_prior.push(true);
+    }
+
+    /// Number of observations so far (real + prior).
     pub fn n_obs(&self) -> usize {
         self.obs_x.len()
     }
 
-    /// Best observed score, or `None` if no observations.
+    /// Number of **real** (non-prior) observations.
+    pub fn n_real_obs(&self) -> usize {
+        self.obs_prior.iter().filter(|p| !**p).count()
+    }
+
+    /// Best **real** observed score, or `None` if no real observations.
+    /// Cohort priors are deliberately excluded: a borrowed expectation must
+    /// never masquerade as this person's measured response.
     pub fn best(&self) -> Option<(f64, f64)> {
         let mut best: Option<(f64, f64)> = None;
-        for (&x, &y) in self.obs_x.iter().zip(&self.obs_y) {
+        for ((&x, &y), &prior) in self.obs_x.iter().zip(&self.obs_y).zip(&self.obs_prior) {
+            if prior {
+                continue;
+            }
             if best.map(|(_, by)| y > by).unwrap_or(true) {
                 best = Some((x, y));
             }
@@ -102,10 +138,25 @@ impl BayesianOptimizer {
         best
     }
 
-    /// Factorize the GP once: Cholesky `L` of `K = RBF(X,X)+noise·I` and the
-    /// weight vector `alpha = K⁻¹ y`. Both depend only on the observations, not
-    /// on any query point, so a single fit serves the whole acquisition grid.
-    /// Returns `None` when there are no observations or `K` is not SPD.
+    /// EI incumbent: the best real observation, falling back to the best prior
+    /// when the person has no sessions yet (so cohort-seeded recommendation
+    /// still explores sensibly rather than treating 0 as the bar).
+    fn incumbent(&self) -> Option<f64> {
+        if let Some((_, by)) = self.best() {
+            return Some(by);
+        }
+        self.obs_y.iter().copied().fold(None, |acc, y| {
+            Some(match acc {
+                Some(a) if a >= y => a,
+                _ => y,
+            })
+        })
+    }
+
+    /// Factorize the GP once: Cholesky `L` of `K = RBF(X,X)+diag(noise)` and
+    /// the weight vector `alpha = K⁻¹ y`. Both depend only on the observations,
+    /// not on any query point, so a single fit serves the whole acquisition
+    /// grid. Returns `None` when there are no observations or `K` is not SPD.
     ///
     /// The per-query arithmetic in [`GpFit::predict`] is identical to the old
     /// inline path, so predictions (and therefore the session witness) are
@@ -115,7 +166,7 @@ impl BayesianOptimizer {
         if n == 0 {
             return None;
         }
-        // K (lower triangle is all Cholesky reads) = RBF(X,X) + noise·I.
+        // K (lower triangle is all Cholesky reads) = RBF(X,X) + diag(noise).
         let mut k = vec![0.0f64; n * n];
         for i in 0..n {
             for j in 0..=i {
@@ -126,7 +177,7 @@ impl BayesianOptimizer {
                     self.signal_var,
                 );
                 if i == j {
-                    v += self.noise_var;
+                    v += self.obs_noise[i];
                 }
                 k[i * n + j] = v;
             }
@@ -156,8 +207,8 @@ impl BayesianOptimizer {
 
     /// Expected Improvement (for maximization) at `x`.
     pub fn expected_improvement(&self, x: f64) -> f64 {
-        let best = match self.best() {
-            Some((_, by)) => by,
+        let best = match self.incumbent() {
+            Some(by) => by,
             None => return self.signal_var.sqrt(), // pure exploration
         };
         match self.fit() {
@@ -189,8 +240,8 @@ impl BayesianOptimizer {
                 };
             }
         };
-        // best() is Some here (fit exists ⇒ ≥1 observation).
-        let best = self.best().map(|(_, by)| by).unwrap_or(0.0);
+        // incumbent() is Some here (fit exists ⇒ ≥1 observation).
+        let best = self.incumbent().unwrap_or(0.0);
         let grid = fine_grid(envelope);
         let mut best_f = base.frequency_hz;
         let mut best_ei = f64::NEG_INFINITY;

v2/crates/ruview-gamma/src/ruflo.rs

@@ -10,6 +10,7 @@
 use crate::objective::{SafeEntrainmentObjective, ScoreInputs};
 use crate::optimizer::{BayesianOptimizer, CalibrationPlan, Recommendation};
 use crate::response::{PersonResponseVector, RuViewState, SessionObservation, SubjectiveReport};
+use crate::ruvector::{AnonymizedProfile, DriftDetector, DriftStatus, ProfileStore};
 use crate::safety::{
     ExclusionCondition, ExclusionScreen, SafetyMonitor, SafetyTick, ScreenOutcome, StopReason,
 };
@@ -76,6 +77,9 @@ pub struct RufloGovernor {
     confidence_floor: f64,
     audit: Vec<SessionRecord>,
     next_index: u64,
+    // ADR-250 §10 item 4: per-person drift detection over the response vector.
+    drift: DriftDetector,
+    drift_status: DriftStatus,
 }
 
 impl RufloGovernor {
@@ -109,9 +113,56 @@ impl RufloGovernor {
             envelope,
             audit: Vec::new(),
             next_index: 0,
+            drift: DriftDetector::default(),
+            drift_status: DriftStatus::Warmup,
         })
     }
 
+    /// Seed the optimizer from a cohort of anonymized similar responders
+    /// (ADR-250 §10 item 3): the `k` nearest profiles' frequency responses
+    /// enter as **down-weighted pseudo-observations**, shaping where the
+    /// optimizer looks first without ever counting as this person's measured
+    /// data ([`BayesianOptimizer::observe_prior`]). Returns how many priors
+    /// were installed.
+    pub fn seed_from_cohort(&mut self, store: &ProfileStore, k: usize) -> usize {
+        let query = self.response.as_array();
+        let priors =
+            store.warm_start_prior(&query, k, self.optimizer.noise_var);
+        for p in &priors {
+            // Only frequencies inside this participant's envelope are usable.
+            if p.frequency_hz >= self.envelope.min_hz && p.frequency_hz <= self.envelope.max_hz {
+                self.optimizer
+                    .observe_prior(p.frequency_hz, p.expected_score, p.noise_var);
+            }
+        }
+        priors.len()
+    }
+
+    /// Export this participant as an anonymized profile for the cohort store
+    /// (ADR-250 §10 items 3/6). Carries the one-way hashed tag, the response
+    /// vector, and per-frequency scores from **safe sessions only** — never
+    /// the `person_id`, never raw sensor data.
+    pub fn export_anonymized_profile(&self) -> AnonymizedProfile {
+        let frequency_scores: Vec<(f64, f64)> = self
+            .audit
+            .iter()
+            .filter(|r| r.outcome.safety_pass)
+            .map(|r| (r.stimulus.frequency_hz, r.outcome.entrainment_score))
+            .collect();
+        AnonymizedProfile {
+            profile_tag: AnonymizedProfile::tag_for(&self.person_id),
+            vector: self.response.as_array(),
+            frequency_scores,
+        }
+    }
+
+    /// Latest drift judgment (ADR-250 §10 item 4). `Drifted` recommends
+    /// re-running the Phase-1 calibration sweep before trusting further
+    /// optimization.
+    pub fn drift_status(&self) -> DriftStatus {
+        self.drift_status
+    }
+
     /// Switch trial mode (e.g., to `Sham` for a blinded arm).
     pub fn set_mode(&mut self, mode: TrialMode) {
         self.mode = mode;
@@ -219,7 +270,7 @@ impl RufloGovernor {
             self.optimizer.observe(stimulus.frequency_hz, score);
         }
 
-        // --- Update RuVector memory. ---
+        // --- Update RuVector memory + drift detection (ADR-250 §10 item 4). ---
         self.response.update(&SessionObservation {
             stimulus: *stimulus,
             ruview: resp.ruview,
@@ -228,6 +279,7 @@ impl RufloGovernor {
             safety_pass,
             adverse_event: resp.adverse_event,
         });
+        self.drift_status = self.drift.update(&self.response.as_array());
 
         // --- Recommend next frequency for the record. ---
         let next = self.optimizer.recommend(&self.envelope, stimulus);

v2/crates/ruview-gamma/src/ruvector.rs

@@ -0,0 +1,546 @@
+//! RuVector self-learning layer (ADR-250 §10, items 3–6).
+//!
+//! The adaptive memory *across* people: anonymized 20-field response vectors
+//! ([`crate::response::PersonResponseVector::as_array`]) stored in a
+//! [`ProfileStore`], queried by deterministic k-nearest-neighbor to
+//! **warm-start a new person's optimizer** from similar responders (instead of
+//! the flat 40 Hz prior), plus per-person **drift detection** (item 4) and
+//! cohort **response clustering** (item 5).
+//!
+//! Privacy posture: profiles carry only a one-way hashed tag (never a
+//! `person_id`) and the 20 normalized response fields — no identity, no raw
+//! sensor data. Cohort knowledge enters the optimizer exclusively as
+//! down-weighted pseudo-observations ([`crate::optimizer::BayesianOptimizer::
+//! observe_prior`]) that can shape *where to look first* but never define what
+//! this person's measured response is.
+//!
+//! Everything here is deterministic: distances are fixed-range normalized,
+//! ties break by insertion index, clustering uses farthest-point seeding from
+//! index 0 — same inputs, same outputs, on every machine.
+
+use serde::{Deserialize, Serialize};
+
+use crate::math::clamp_safe;
+use crate::simulator::stable_hash;
+
+/// Dimensionality of the response vector (ADR-250 §6).
+pub const VECTOR_DIM: usize = 20;
+
+/// Fixed per-field normalization ranges `(lo, hi)` for distance computation,
+/// in the ADR-250 §6 field order. Constants (not data-derived statistics) so
+/// distances are stable as the store grows.
+pub const NORM_RANGES: [(f64, f64); VECTOR_DIM] = [
+    (0.0, 1.0),   // baseline_gamma
+    (0.0, 1.0),   // baseline_alpha
+    (0.0, 5.0),   // alpha_gamma_ratio
+    (0.0, 1.0),   // gamma_power_gain
+    (0.0, 1.0),   // phase_locking_value
+    (6.0, 30.0),  // breathing_rate (bpm)
+    (0.0, 1.0),   // breathing_stability
+    (0.0, 1.0),   // motion_artifact
+    (0.0, 1.0),   // posture_state
+    (0.0, 1.0),   // sleep_state
+    (0.0, 1.0),   // restlessness_score
+    (36.0, 44.0), // stimulus_frequency (Hz)
+    (0.0, 1.0),   // brightness_level
+    (0.0, 1.0),   // sound_level
+    (0.0, 1.0),   // duty_cycle
+    (-5.0, 5.0),  // phase_offset (ms)
+    (0.0, 15.0),  // session_duration (min)
+    (0.0, 1.0),   // comfort_score
+    (0.0, 1.0),   // adherence_score
+    (0.0, 1.0),   // adverse_event_flag
+];
+
+/// Normalize a raw response vector to the unit hypercube using
+/// [`NORM_RANGES`]. Non-finite fields clamp to the range floor.
+pub fn normalize(v: &[f64; VECTOR_DIM]) -> [f64; VECTOR_DIM] {
+    let mut out = [0.0; VECTOR_DIM];
+    for (i, (&val, &(lo, hi))) in v.iter().zip(NORM_RANGES.iter()).enumerate() {
+        out[i] = clamp_safe((val - lo) / (hi - lo), 0.0, 1.0);
+    }
+    out
+}
+
+/// Euclidean distance between two normalized vectors.
+fn unit_distance(a: &[f64; VECTOR_DIM], b: &[f64; VECTOR_DIM]) -> f64 {
+    a.iter()
+        .zip(b)
+        .map(|(x, y)| (x - y) * (x - y))
+        .sum::<f64>()
+        .sqrt()
+}
+
+/// One anonymized responder profile: the hashed tag, the response vector, and
+/// the per-frequency scores their sessions established.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct AnonymizedProfile {
+    /// One-way tag: first 16 hex chars of SHA-256("gamma-profile" ‖ person_id).
+    /// Never the `person_id` itself.
+    pub profile_tag: String,
+    /// Raw (un-normalized) 20-field response vector.
+    pub vector: [f64; VECTOR_DIM],
+    /// `(frequency_hz, safe-entrainment score)` summaries from this profile's
+    /// safe sessions — the transferable response surface.
+    pub frequency_scores: Vec<(f64, f64)>,
+}
+
+impl AnonymizedProfile {
+    /// Derive the one-way profile tag from a pseudonymous person id.
+    pub fn tag_for(person_id: &str) -> String {
+        let h = stable_hash(&[b"gamma-profile", person_id.as_bytes()]);
+        let mut s = String::with_capacity(16);
+        for b in &h[..8] {
+            s.push_str(&format!("{b:02x}"));
+        }
+        s
+    }
+}
+
+/// A cohort prior for one frequency, produced by [`ProfileStore::warm_start_prior`].
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct CohortPrior {
+    pub frequency_hz: f64,
+    /// Similarity-weighted mean score across the k nearest profiles.
+    pub expected_score: f64,
+    /// Noise variance to attach to the pseudo-observation: grows with cohort
+    /// disagreement and with distance, so dissimilar or conflicting cohorts
+    /// are trusted less.
+    pub noise_var: f64,
+}
+
+/// Deterministic in-memory store of anonymized profiles.
+///
+/// Linear-scan kNN: exact, allocation-light, and fast at research-cohort scale
+/// (sub-µs at hundreds of profiles). An HNSW backend (the `ruvector` crates)
+/// is a drop-in replacement once cohorts grow past ~10⁵ — the public API is
+/// already shaped for it.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct ProfileStore {
+    profiles: Vec<AnonymizedProfile>,
+}
+
+impl ProfileStore {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Number of stored profiles.
+    pub fn len(&self) -> usize {
+        self.profiles.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.profiles.is_empty()
+    }
+
+    /// Insert or replace (by `profile_tag`) a profile.
+    pub fn upsert(&mut self, profile: AnonymizedProfile) {
+        if let Some(p) = self
+            .profiles
+            .iter_mut()
+            .find(|p| p.profile_tag == profile.profile_tag)
+        {
+            *p = profile;
+        } else {
+            self.profiles.push(profile);
+        }
+    }
+
+    /// k nearest profiles to `query` (raw vector) as `(index, distance)`,
+    /// ascending distance, ties broken by insertion index (deterministic).
+    pub fn k_nearest(&self, query: &[f64; VECTOR_DIM], k: usize) -> Vec<(usize, f64)> {
+        let q = normalize(query);
+        let mut d: Vec<(usize, f64)> = self
+            .profiles
+            .iter()
+            .enumerate()
+            .map(|(i, p)| (i, unit_distance(&q, &normalize(&p.vector))))
+            .collect();
+        d.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal).then(a.0.cmp(&b.0)));
+        d.truncate(k);
+        d
+    }
+
+    /// Profile by index (as returned from [`k_nearest`](Self::k_nearest)).
+    pub fn profile(&self, idx: usize) -> Option<&AnonymizedProfile> {
+        self.profiles.get(idx)
+    }
+
+    /// Build cohort priors for a new person: for each integer frequency the
+    /// k nearest profiles have scored, the similarity-weighted mean score and
+    /// an honesty-scaled noise variance (ADR-250 §10 item 3 + item 6
+    /// "protocol recommendation").
+    ///
+    /// `base_noise` is the optimizer's real-observation noise; priors carry at
+    /// least `PRIOR_NOISE_FLOOR ×` that, inflated further by cohort variance
+    /// and mean neighbor distance.
+    pub fn warm_start_prior(
+        &self,
+        query: &[f64; VECTOR_DIM],
+        k: usize,
+        base_noise: f64,
+    ) -> Vec<CohortPrior> {
+        let neighbors = self.k_nearest(query, k);
+        if neighbors.is_empty() {
+            return Vec::new();
+        }
+        // Bucket scores by quantized frequency (0.1 Hz) across neighbors,
+        // weighting each neighbor by 1/(1+distance).
+        use std::collections::BTreeMap;
+        let mut buckets: BTreeMap<i64, Vec<(f64, f64)>> = BTreeMap::new(); // q_hz -> (score, weight)
+        for &(idx, dist) in &neighbors {
+            let w = 1.0 / (1.0 + dist);
+            for &(hz, score) in &self.profiles[idx].frequency_scores {
+                if !hz.is_finite() || !score.is_finite() {
+                    continue;
+                }
+                let q = (hz * 10.0).round() as i64;
+                buckets.entry(q).or_default().push((score, w));
+            }
+        }
+        let mean_dist =
+            neighbors.iter().map(|(_, d)| d).sum::<f64>() / neighbors.len() as f64;
+        buckets
+            .into_iter()
+            .map(|(q, entries)| {
+                let wsum: f64 = entries.iter().map(|(_, w)| w).sum();
+                let mean: f64 = entries.iter().map(|(s, w)| s * w).sum::<f64>() / wsum;
+                let var: f64 = entries
+                    .iter()
+                    .map(|(s, w)| w * (s - mean) * (s - mean))
+                    .sum::<f64>()
+                    / wsum;
+                CohortPrior {
+                    frequency_hz: q as f64 / 10.0,
+                    expected_score: mean,
+                    // Floor × base, inflated by cohort disagreement and distance.
+                    noise_var: base_noise * Self::PRIOR_NOISE_FLOOR * (1.0 + mean_dist)
+                        + var,
+                }
+            })
+            .collect()
+    }
+
+    /// Minimum factor by which a cohort prior is noisier than a real
+    /// observation (priors must never outweigh measured sessions).
+    pub const PRIOR_NOISE_FLOOR: f64 = 25.0;
+
+    /// Deterministic k-means over normalized vectors (ADR-250 §10 item 5):
+    /// farthest-point seeding from index 0, fixed `iters` Lloyd steps, ties to
+    /// the lowest cluster index. Returns each profile's cluster assignment.
+    /// Returns an empty vec if the store is empty or `k == 0`.
+    pub fn cluster(&self, k: usize, iters: usize) -> Vec<usize> {
+        let n = self.profiles.len();
+        if n == 0 || k == 0 {
+            return Vec::new();
+        }
+        let k = k.min(n);
+        let pts: Vec<[f64; VECTOR_DIM]> =
+            self.profiles.iter().map(|p| normalize(&p.vector)).collect();
+
+        // Farthest-point initialization (deterministic, no RNG).
+        let mut centers: Vec<[f64; VECTOR_DIM]> = vec![pts[0]];
+        while centers.len() < k {
+            let (far_idx, _) = pts
+                .iter()
+                .enumerate()
+                .map(|(i, p)| {
+                    let dmin = centers
+                        .iter()
+                        .map(|c| unit_distance(p, c))
+                        .fold(f64::INFINITY, f64::min);
+                    (i, dmin)
+                })
+                .fold((0usize, -1.0f64), |acc, (i, d)| if d > acc.1 { (i, d) } else { acc });
+            centers.push(pts[far_idx]);
+        }
+
+        let mut assign = vec![0usize; n];
+        for _ in 0..iters {
+            // Assignment step.
+            for (i, p) in pts.iter().enumerate() {
+                let mut best = 0usize;
+                let mut bd = f64::INFINITY;
+                for (c, center) in centers.iter().enumerate() {
+                    let d = unit_distance(p, center);
+                    if d < bd {
+                        bd = d;
+                        best = c;
+                    }
+                }
+                assign[i] = best;
+            }
+            // Update step.
+            for (c, center) in centers.iter_mut().enumerate() {
+                let members: Vec<&[f64; VECTOR_DIM]> = pts
+                    .iter()
+                    .zip(&assign)
+                    .filter(|(_, &a)| a == c)
+                    .map(|(p, _)| p)
+                    .collect();
+                if members.is_empty() {
+                    continue; // keep the old center (deterministic)
+                }
+                let mut mean = [0.0; VECTOR_DIM];
+                for m in &members {
+                    for (dst, src) in mean.iter_mut().zip(m.iter()) {
+                        *dst += src;
+                    }
+                }
+                for dst in mean.iter_mut() {
+                    *dst /= members.len() as f64;
+                }
+                *center = mean;
+            }
+        }
+        assign
+    }
+}
+
+/// Fields that participate in **drift** distance: the person's physiology and
+/// response, *not* the stimulus parameters (indices 11–16) — those are inputs
+/// the protocol changes deliberately (the calibration sweep swings frequency
+/// across the whole band) and must not register as the person drifting.
+pub const DRIFT_MASK: [bool; VECTOR_DIM] = [
+    true,  // baseline_gamma
+    true,  // baseline_alpha
+    true,  // alpha_gamma_ratio
+    true,  // gamma_power_gain
+    true,  // phase_locking_value
+    true,  // breathing_rate
+    true,  // breathing_stability
+    true,  // motion_artifact
+    true,  // posture_state
+    true,  // sleep_state
+    true,  // restlessness_score
+    false, // stimulus_frequency   (protocol input)
+    false, // brightness_level     (protocol input)
+    false, // sound_level          (protocol input)
+    false, // duty_cycle           (protocol input)
+    false, // phase_offset         (protocol input)
+    false, // session_duration     (protocol input)
+    true,  // comfort_score
+    true,  // adherence_score
+    true,  // adverse_event_flag
+];
+
+/// Euclidean distance over the [`DRIFT_MASK`]-selected fields of two
+/// normalized vectors.
+fn drift_distance(a: &[f64; VECTOR_DIM], b: &[f64; VECTOR_DIM]) -> f64 {
+    a.iter()
+        .zip(b)
+        .zip(DRIFT_MASK.iter())
+        .filter(|(_, &m)| m)
+        .map(|((x, y), _)| (x - y) * (x - y))
+        .sum::<f64>()
+        .sqrt()
+}
+
+/// Drift status for one person (ADR-250 §10 item 4).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum DriftStatus {
+    /// Not enough sessions yet to judge.
+    Warmup,
+    /// Latest vector is consistent with this person's running centroid.
+    Stable,
+    /// Latest vector departed from the centroid — recommend recalibration
+    /// (re-run the Phase-1 sweep) before trusting further optimization.
+    Drifted,
+}
+
+/// Per-person drift detector: running mean (Welford) of the normalized
+/// response vector; a session whose [`DRIFT_MASK`]-restricted distance from
+/// the centroid exceeds `threshold` flags drift. Deterministic and O(1) per
+/// update.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DriftDetector {
+    centroid: [f64; VECTOR_DIM],
+    count: u64,
+    /// Distance (in normalized space) above which a session counts as drifted.
+    pub threshold: f64,
+    /// Sessions required before drift can be judged.
+    pub warmup: u64,
+}
+
+impl Default for DriftDetector {
+    fn default() -> Self {
+        Self {
+            centroid: [0.0; VECTOR_DIM],
+            count: 0,
+            threshold: 0.35,
+            warmup: 3,
+        }
+    }
+}
+
+impl DriftDetector {
+    /// Feed the post-session response vector; returns the drift judgment for
+    /// this session. The centroid update happens *after* the judgment, so a
+    /// drifted session is compared against the pre-drift baseline.
+    pub fn update(&mut self, raw: &[f64; VECTOR_DIM]) -> DriftStatus {
+        let v = normalize(raw);
+        let status = if self.count < self.warmup {
+            DriftStatus::Warmup
+        } else if drift_distance(&v, &self.centroid) > self.threshold {
+            DriftStatus::Drifted
+        } else {
+            DriftStatus::Stable
+        };
+        // Welford running-mean update.
+        self.count += 1;
+        let inv = 1.0 / self.count as f64;
+        for (c, x) in self.centroid.iter_mut().zip(v.iter()) {
+            *c += (x - *c) * inv;
+        }
+        status
+    }
+
+    /// Sessions observed so far.
+    pub fn sessions(&self) -> u64 {
+        self.count
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn profile(tag: &str, freq: f64, peak_score: f64) -> AnonymizedProfile {
+        let mut vector = [0.5; VECTOR_DIM];
+        vector[5] = 13.0; // breathing_rate in range
+        vector[11] = freq; // stimulus_frequency
+        AnonymizedProfile {
+            profile_tag: tag.into(),
+            vector,
+            frequency_scores: vec![
+                (freq - 1.0, peak_score - 0.2),
+                (freq, peak_score),
+                (freq + 1.0, peak_score - 0.2),
+            ],
+        }
+    }
+
+    #[test]
+    fn tag_is_one_way_and_stable() {
+        let t1 = AnonymizedProfile::tag_for("subject-A");
+        let t2 = AnonymizedProfile::tag_for("subject-A");
+        assert_eq!(t1, t2);
+        assert_eq!(t1.len(), 16);
+        assert!(!t1.contains("subject"));
+        assert_ne!(t1, AnonymizedProfile::tag_for("subject-B"));
+    }
+
+    #[test]
+    fn knn_orders_by_distance_with_deterministic_ties() {
+        let mut store = ProfileStore::new();
+        store.upsert(profile("a", 38.0, 0.8));
+        store.upsert(profile("b", 42.0, 0.8));
+        store.upsert(profile("c", 38.0, 0.8)); // identical vector to "a"
+
+        let mut q = [0.5; VECTOR_DIM];
+        q[5] = 13.0;
+        q[11] = 38.0;
+        let nn = store.k_nearest(&q, 2);
+        assert_eq!(nn.len(), 2);
+        // "a" (index 0) and "c" (index 2) are equidistant; tie → lower index first.
+        assert_eq!(nn[0].0, 0);
+        assert_eq!(nn[1].0, 2);
+    }
+
+    #[test]
+    fn upsert_replaces_by_tag() {
+        let mut store = ProfileStore::new();
+        store.upsert(profile("a", 38.0, 0.8));
+        store.upsert(profile("a", 42.0, 0.9));
+        assert_eq!(store.len(), 1);
+        assert_eq!(store.profile(0).unwrap().frequency_scores[1].0, 42.0);
+    }
+
+    #[test]
+    fn warm_start_prior_is_noisier_than_real_observations() {
+        let mut store = ProfileStore::new();
+        store.upsert(profile("a", 39.0, 0.8));
+        store.upsert(profile("b", 39.0, 0.7));
+        let mut q = [0.5; VECTOR_DIM];
+        q[5] = 13.0;
+        q[11] = 39.0;
+        let base_noise = 1e-4;
+        let priors = store.warm_start_prior(&q, 2, base_noise);
+        assert!(!priors.is_empty());
+        for p in &priors {
+            assert!(p.noise_var >= base_noise * ProfileStore::PRIOR_NOISE_FLOOR);
+            assert!(p.expected_score.is_finite());
+        }
+        // The shared peak frequency carries the highest expected score.
+        let best = priors
+            .iter()
+            .max_by(|a, b| a.expected_score.partial_cmp(&b.expected_score).unwrap())
+            .unwrap();
+        assert_eq!(best.frequency_hz, 39.0);
+    }
+
+    #[test]
+    fn warm_start_empty_store_returns_nothing() {
+        let store = ProfileStore::new();
+        let q = [0.5; VECTOR_DIM];
+        assert!(store.warm_start_prior(&q, 3, 1e-4).is_empty());
+    }
+
+    #[test]
+    fn clustering_separates_detuned_groups() {
+        let mut store = ProfileStore::new();
+        // Two clear groups: peaks near 37 Hz and near 43 Hz.
+        for i in 0..4 {
+            store.upsert(profile(&format!("lo{i}"), 37.0, 0.8));
+            store.upsert(profile(&format!("hi{i}"), 43.0, 0.8));
+        }
+        let assign = store.cluster(2, 10);
+        assert_eq!(assign.len(), 8);
+        // All "lo" profiles share a cluster, all "hi" share the other.
+        let lo: Vec<usize> = (0..8).step_by(2).map(|i| assign[i]).collect();
+        let hi: Vec<usize> = (1..8).step_by(2).map(|i| assign[i]).collect();
+        assert!(lo.iter().all(|&c| c == lo[0]));
+        assert!(hi.iter().all(|&c| c == hi[0]));
+        assert_ne!(lo[0], hi[0]);
+    }
+
+    #[test]
+    fn clustering_is_deterministic() {
+        let mut store = ProfileStore::new();
+        for i in 0..6 {
+            store.upsert(profile(&format!("p{i}"), 36.0 + i as f64, 0.7));
+        }
+        assert_eq!(store.cluster(3, 5), store.cluster(3, 5));
+    }
+
+    #[test]
+    fn drift_detector_warmup_then_stable_then_drift() {
+        let mut d = DriftDetector::default();
+        let mut calm = [0.5; VECTOR_DIM];
+        calm[5] = 13.0;
+        // Warmup sessions.
+        for _ in 0..3 {
+            assert_eq!(d.update(&calm), DriftStatus::Warmup);
+        }
+        // Consistent sessions are stable.
+        assert_eq!(d.update(&calm), DriftStatus::Stable);
+        // A strongly departed vector flags drift.
+        let mut shifted = calm;
+        shifted[3] = 0.0; // gamma gain collapsed
+        shifted[7] = 1.0; // motion artifact saturated
+        shifted[10] = 1.0; // restlessness saturated
+        shifted[17] = 0.0; // comfort collapsed
+        assert_eq!(d.update(&shifted), DriftStatus::Drifted);
+    }
+
+    #[test]
+    fn normalize_handles_non_finite() {
+        let mut v = [0.5; VECTOR_DIM];
+        v[0] = f64::NAN;
+        v[5] = f64::INFINITY;
+        let n = normalize(&v);
+        assert_eq!(n[0], 0.0);
+        assert_eq!(n[5], 0.0);
+    }
+}