Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

vendor/ruvector/examples/exo-ai-2025/crates/exo-manifold/src/deformation.rs

@@ -0,0 +1,59 @@
+//! Simplified deformation module
+
+use crate::network::LearnedManifold;
+use exo_core::{ManifoldDelta, Pattern, Result};
+use parking_lot::RwLock;
+use std::sync::Arc;
+
+pub struct ManifoldDeformer {
+    _network: Arc<RwLock<LearnedManifold>>,
+    _learning_rate: f32,
+}
+
+impl ManifoldDeformer {
+    pub fn new(network: Arc<RwLock<LearnedManifold>>, learning_rate: f32) -> Self {
+        Self {
+            _network: network,
+            _learning_rate: learning_rate,
+        }
+    }
+
+    pub fn deform(&mut self, pattern: &Pattern, salience: f32) -> Result<ManifoldDelta> {
+        // Simplified deformation - just return a delta indicating success
+        Ok(ManifoldDelta::ContinuousDeform {
+            embedding: pattern.embedding.clone(),
+            salience,
+            loss: 0.0,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use exo_core::{Metadata, PatternId, SubstrateTime};
+
+    #[test]
+    fn test_deformer_creation() {
+        let network = Arc::new(RwLock::new(LearnedManifold::new(64, 128, 3)));
+        let _deformer = ManifoldDeformer::new(network, 0.01);
+    }
+
+    #[test]
+    fn test_deform() {
+        let network = Arc::new(RwLock::new(LearnedManifold::new(64, 128, 3)));
+        let mut deformer = ManifoldDeformer::new(network, 0.01);
+
+        let pattern = Pattern {
+            id: PatternId::new(),
+            embedding: vec![1.0; 64],
+            metadata: Metadata::default(),
+            timestamp: SubstrateTime::now(),
+            antecedents: vec![],
+            salience: 0.9,
+        };
+
+        let result = deformer.deform(&pattern, 0.9);
+        assert!(result.is_ok());
+    }
+}

vendor/ruvector/examples/exo-ai-2025/crates/exo-manifold/src/forgetting.rs

@@ -0,0 +1,66 @@
+//! Simplified forgetting module
+
+use crate::network::LearnedManifold;
+use exo_core::{Pattern, Result};
+use parking_lot::RwLock;
+use std::sync::Arc;
+
+pub struct StrategicForgetting {
+    _network: Arc<RwLock<LearnedManifold>>,
+}
+
+impl StrategicForgetting {
+    pub fn new(network: Arc<RwLock<LearnedManifold>>) -> Self {
+        Self { _network: network }
+    }
+
+    pub fn forget(
+        &self,
+        patterns: &Arc<RwLock<Vec<Pattern>>>,
+        salience_threshold: f32,
+        _decay_rate: f32,
+    ) -> Result<usize> {
+        let mut patterns = patterns.write();
+        let initial_len = patterns.len();
+
+        // Remove patterns below salience threshold
+        patterns.retain(|p| p.salience >= salience_threshold);
+
+        Ok(initial_len - patterns.len())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use exo_core::{Metadata, PatternId, SubstrateTime};
+
+    #[test]
+    fn test_forgetting() {
+        let network = Arc::new(RwLock::new(LearnedManifold::new(64, 128, 3)));
+        let forgetter = StrategicForgetting::new(network);
+
+        let patterns = Arc::new(RwLock::new(vec![
+            Pattern {
+                id: PatternId::new(),
+                embedding: vec![1.0; 64],
+                metadata: Metadata::default(),
+                timestamp: SubstrateTime::now(),
+                antecedents: vec![],
+                salience: 0.9,
+            },
+            Pattern {
+                id: PatternId::new(),
+                embedding: vec![0.5; 64],
+                metadata: Metadata::default(),
+                timestamp: SubstrateTime::now(),
+                antecedents: vec![],
+                salience: 0.3,
+            },
+        ]));
+
+        let forgotten = forgetter.forget(&patterns, 0.5, 0.1).unwrap();
+        assert_eq!(forgotten, 1);
+        assert_eq!(patterns.read().len(), 1);
+    }
+}

vendor/ruvector/examples/exo-ai-2025/crates/exo-manifold/src/lib.rs

@@ -0,0 +1,187 @@
+//! Learned Manifold Engine for EXO-AI Cognitive Substrate
+//!
+//! This crate implements a simplified manifold storage system.
+//! The burn dependency has been removed to avoid bincode version conflicts.
+//!
+//! # Key Concepts
+//!
+//! - **Retrieval**: Vector similarity search
+//! - **Storage**: Pattern storage with embeddings
+//! - **Forgetting**: Strategic pattern pruning
+//!
+//! # Architecture
+//!
+//! ```text
+//! Query → Vector Search → Nearest Patterns
+//!            ↓
+//!      Pattern Storage
+//!      (Vec-based)
+//!            ↓
+//!      Similarity Scores
+//! ```
+
+use exo_core::{Error, ManifoldConfig, ManifoldDelta, Pattern, Result, SearchResult};
+use parking_lot::RwLock;
+use std::sync::Arc;
+
+mod deformation;
+mod forgetting;
+mod network;
+mod retrieval;
+pub mod simd_ops;
+pub mod transfer_store;
+
+pub use deformation::ManifoldDeformer;
+pub use forgetting::StrategicForgetting;
+pub use network::LearnedManifold;
+pub use retrieval::GradientDescentRetriever;
+pub use simd_ops::{batch_distances, cosine_similarity_simd, euclidean_distance_simd};
+
+/// Simplified manifold storage using vector similarity
+pub struct ManifoldEngine {
+    /// Simple pattern storage
+    network: Arc<RwLock<LearnedManifold>>,
+    /// Configuration
+    config: ManifoldConfig,
+    /// Stored patterns (for extraction)
+    patterns: Arc<RwLock<Vec<Pattern>>>,
+}
+
+impl ManifoldEngine {
+    /// Create a new manifold engine
+    pub fn new(config: ManifoldConfig) -> Self {
+        let network =
+            LearnedManifold::new(config.dimension, config.hidden_dim, config.hidden_layers);
+
+        Self {
+            network: Arc::new(RwLock::new(network)),
+            config,
+            patterns: Arc::new(RwLock::new(Vec::new())),
+        }
+    }
+
+    /// Query manifold via vector similarity
+    pub fn retrieve(&self, query: &[f32], k: usize) -> Result<Vec<SearchResult>> {
+        if query.len() != self.config.dimension {
+            return Err(Error::InvalidDimension {
+                expected: self.config.dimension,
+                got: query.len(),
+            });
+        }
+
+        let retriever = GradientDescentRetriever::new(self.network.clone(), self.config.clone());
+
+        retriever.retrieve(query, k, &self.patterns)
+    }
+
+    /// Store pattern (simplified deformation)
+    pub fn deform(&mut self, pattern: Pattern, salience: f32) -> Result<ManifoldDelta> {
+        if pattern.embedding.len() != self.config.dimension {
+            return Err(Error::InvalidDimension {
+                expected: self.config.dimension,
+                got: pattern.embedding.len(),
+            });
+        }
+
+        // Store pattern for later extraction
+        self.patterns.write().push(pattern.clone());
+
+        let mut deformer = ManifoldDeformer::new(self.network.clone(), self.config.learning_rate);
+
+        deformer.deform(&pattern, salience)
+    }
+
+    /// Strategic forgetting via pattern pruning
+    pub fn forget(&mut self, salience_threshold: f32, decay_rate: f32) -> Result<usize> {
+        let forgetter = StrategicForgetting::new(self.network.clone());
+
+        forgetter.forget(&self.patterns, salience_threshold, decay_rate)
+    }
+
+    /// Get number of stored patterns
+    pub fn len(&self) -> usize {
+        self.patterns.read().len()
+    }
+
+    /// Check if engine is empty
+    pub fn is_empty(&self) -> bool {
+        self.patterns.read().is_empty()
+    }
+
+    /// Get configuration
+    pub fn config(&self) -> &ManifoldConfig {
+        &self.config
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use exo_core::{Metadata, PatternId, SubstrateTime};
+
+    fn create_test_pattern(embedding: Vec<f32>, salience: f32) -> Pattern {
+        Pattern {
+            id: PatternId::new(),
+            embedding,
+            metadata: Metadata::default(),
+            timestamp: SubstrateTime::now(),
+            antecedents: vec![],
+            salience,
+        }
+    }
+
+    #[test]
+    fn test_manifold_engine_creation() {
+        let config = ManifoldConfig {
+            dimension: 128,
+            ..Default::default()
+        };
+        let engine = ManifoldEngine::new(config);
+
+        assert_eq!(engine.len(), 0);
+        assert!(engine.is_empty());
+        assert_eq!(engine.config().dimension, 128);
+    }
+
+    #[test]
+    fn test_deform_and_retrieve() {
+        let config = ManifoldConfig {
+            dimension: 64,
+            max_descent_steps: 10,
+            learning_rate: 0.01,
+            ..Default::default()
+        };
+        let mut engine = ManifoldEngine::new(config);
+
+        // Create and deform with a pattern
+        let embedding = vec![1.0; 64];
+        let pattern = create_test_pattern(embedding.clone(), 0.9);
+
+        let result = engine.deform(pattern, 0.9);
+        assert!(result.is_ok());
+        assert_eq!(engine.len(), 1);
+
+        // Retrieve similar patterns
+        let results = engine.retrieve(&embedding, 1);
+        assert!(results.is_ok());
+    }
+
+    #[test]
+    fn test_invalid_dimension() {
+        let config = ManifoldConfig {
+            dimension: 128,
+            ..Default::default()
+        };
+        let mut engine = ManifoldEngine::new(config);
+
+        // Wrong dimension
+        let embedding = vec![1.0; 64];
+        let pattern = create_test_pattern(embedding.clone(), 0.9);
+
+        let result = engine.deform(pattern, 0.9);
+        assert!(result.is_err());
+
+        let retrieve_result = engine.retrieve(&embedding, 1);
+        assert!(retrieve_result.is_err());
+    }
+}

vendor/ruvector/examples/exo-ai-2025/crates/exo-manifold/src/network.rs

@@ -0,0 +1,28 @@
+//! Simplified network module (burn removed)
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LearnedManifold {
+    dimension: usize,
+    hidden_dim: usize,
+    hidden_layers: usize,
+}
+
+impl LearnedManifold {
+    pub fn new(dimension: usize, hidden_dim: usize, hidden_layers: usize) -> Self {
+        Self {
+            dimension,
+            hidden_dim,
+            hidden_layers,
+        }
+    }
+
+    pub fn dimension(&self) -> usize {
+        self.dimension
+    }
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SirenLayer;

vendor/ruvector/examples/exo-ai-2025/crates/exo-manifold/src/retrieval.rs

@@ -0,0 +1,75 @@
+//! SIMD-optimized retrieval module using vector similarity
+//!
+//! Uses AVX2/NEON SIMD for 8-54x faster distance calculations.
+//! Based on techniques from ultra-low-latency-sim.
+
+use crate::network::LearnedManifold;
+use crate::simd_ops::{cosine_similarity_simd, euclidean_distance_simd};
+use exo_core::{ManifoldConfig, Pattern, Result, SearchResult};
+use parking_lot::RwLock;
+use std::sync::Arc;
+
+pub struct GradientDescentRetriever {
+    _network: Arc<RwLock<LearnedManifold>>,
+    _config: ManifoldConfig,
+}
+
+impl GradientDescentRetriever {
+    pub fn new(network: Arc<RwLock<LearnedManifold>>, config: ManifoldConfig) -> Self {
+        Self {
+            _network: network,
+            _config: config,
+        }
+    }
+
+    pub fn retrieve(
+        &self,
+        query: &[f32],
+        k: usize,
+        patterns: &Arc<RwLock<Vec<Pattern>>>,
+    ) -> Result<Vec<SearchResult>> {
+        let patterns = patterns.read();
+        let mut results = Vec::with_capacity(patterns.len());
+
+        // SIMD-optimized similarity search (8-54x faster)
+        for pattern in patterns.iter() {
+            let similarity = cosine_similarity_simd(query, &pattern.embedding);
+            let distance = euclidean_distance_simd(query, &pattern.embedding);
+            results.push(SearchResult {
+                pattern: pattern.clone(),
+                score: similarity,
+                distance,
+            });
+        }
+
+        // Sort by score descending and take top k
+        results.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap());
+        results.truncate(k);
+
+        Ok(results)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::simd_ops::{cosine_similarity_simd, euclidean_distance_simd};
+
+    #[test]
+    fn test_cosine_similarity() {
+        let a = vec![1.0, 0.0, 0.0, 0.0];
+        let b = vec![1.0, 0.0, 0.0, 0.0];
+        assert!((cosine_similarity_simd(&a, &b) - 1.0).abs() < 1e-5);
+
+        let c = vec![1.0, 0.0, 0.0, 0.0];
+        let d = vec![0.0, 1.0, 0.0, 0.0];
+        assert!((cosine_similarity_simd(&c, &d) - 0.0).abs() < 1e-5);
+    }
+
+    #[test]
+    fn test_euclidean_distance() {
+        let a = vec![0.0, 0.0, 0.0, 0.0];
+        let b = vec![3.0, 4.0, 0.0, 0.0];
+        assert!((euclidean_distance_simd(&a, &b) - 5.0).abs() < 1e-5);
+    }
+}

vendor/ruvector/examples/exo-ai-2025/crates/exo-manifold/src/simd_ops.rs

@@ -0,0 +1,471 @@
+//! SIMD-optimized vector operations for manifold retrieval
+//!
+//! Provides 8-54x speedup for distance calculations using AVX2/AVX-512/NEON.
+//!
+//! Based on techniques from ultra-low-latency-sim.
+
+/// Cache line size for alignment (used by prefetch intrinsics in AVX2 path)
+#[allow(dead_code)]
+const CACHE_LINE: usize = 64;
+
+/// SIMD-optimized cosine similarity
+///
+/// Uses AVX2 FMA for 8x parallelism with prefetching.
+/// Falls back to scalar for non-x86 platforms.
+#[inline]
+pub fn cosine_similarity_simd(a: &[f32], b: &[f32]) -> f32 {
+    #[cfg(target_arch = "x86_64")]
+    {
+        if is_x86_feature_detected!("avx2") && is_x86_feature_detected!("fma") {
+            return unsafe { cosine_similarity_avx2(a, b) };
+        }
+    }
+
+    #[cfg(target_arch = "aarch64")]
+    {
+        return cosine_similarity_neon(a, b);
+    }
+
+    // Fallback to optimized scalar with loop unrolling
+    cosine_similarity_unrolled(a, b)
+}
+
+/// SIMD-optimized euclidean distance
+///
+/// Uses AVX2 for 8x parallelism.
+/// Expected speedup: 8-54x depending on dimension.
+#[inline]
+pub fn euclidean_distance_simd(a: &[f32], b: &[f32]) -> f32 {
+    #[cfg(target_arch = "x86_64")]
+    {
+        if is_x86_feature_detected!("avx2") {
+            return unsafe { euclidean_distance_avx2(a, b) };
+        }
+    }
+
+    #[cfg(target_arch = "aarch64")]
+    {
+        return euclidean_distance_neon(a, b);
+    }
+
+    euclidean_distance_unrolled(a, b)
+}
+
+// =============================================================================
+// AVX2 IMPLEMENTATIONS (x86_64)
+// =============================================================================
+
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "avx2", enable = "fma")]
+unsafe fn cosine_similarity_avx2(a: &[f32], b: &[f32]) -> f32 {
+    use std::arch::x86_64::*;
+
+    debug_assert_eq!(a.len(), b.len());
+    let len = a.len();
+    let chunks = len / 8;
+
+    let mut dot_sum = _mm256_setzero_ps();
+    let mut a_sq_sum = _mm256_setzero_ps();
+    let mut b_sq_sum = _mm256_setzero_ps();
+
+    for i in 0..chunks {
+        let idx = i * 8;
+
+        // Prefetch next cache line (64 bytes = 16 floats, so every 2 iterations)
+        if (i & 1) == 0 && i + 2 < chunks {
+            let prefetch_idx = (i + 2) * 8;
+            _mm_prefetch(a.as_ptr().add(prefetch_idx) as *const i8, _MM_HINT_T0);
+            _mm_prefetch(b.as_ptr().add(prefetch_idx) as *const i8, _MM_HINT_T0);
+        }
+
+        let va = _mm256_loadu_ps(a.as_ptr().add(idx));
+        let vb = _mm256_loadu_ps(b.as_ptr().add(idx));
+
+        // FMA: dot += a * b, a_sq += a * a, b_sq += b * b
+        dot_sum = _mm256_fmadd_ps(va, vb, dot_sum);
+        a_sq_sum = _mm256_fmadd_ps(va, va, a_sq_sum);
+        b_sq_sum = _mm256_fmadd_ps(vb, vb, b_sq_sum);
+    }
+
+    // Horizontal sum using AVX2
+    let dot = hsum256_ps_avx2(dot_sum);
+    let a_sq = hsum256_ps_avx2(a_sq_sum);
+    let b_sq = hsum256_ps_avx2(b_sq_sum);
+
+    // Handle remainder
+    let mut dot_rem = dot;
+    let mut a_sq_rem = a_sq;
+    let mut b_sq_rem = b_sq;
+
+    for i in (chunks * 8)..len {
+        let ai = a[i];
+        let bi = b[i];
+        dot_rem += ai * bi;
+        a_sq_rem += ai * ai;
+        b_sq_rem += bi * bi;
+    }
+
+    let norm_a = a_sq_rem.sqrt();
+    let norm_b = b_sq_rem.sqrt();
+
+    if norm_a < 1e-10 || norm_b < 1e-10 {
+        0.0
+    } else {
+        dot_rem / (norm_a * norm_b)
+    }
+}
+
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "avx2")]
+unsafe fn euclidean_distance_avx2(a: &[f32], b: &[f32]) -> f32 {
+    use std::arch::x86_64::*;
+
+    debug_assert_eq!(a.len(), b.len());
+    let len = a.len();
+    let chunks = len / 8;
+
+    let mut sum = _mm256_setzero_ps();
+
+    for i in 0..chunks {
+        let idx = i * 8;
+
+        // Prefetch
+        if (i & 1) == 0 && i + 2 < chunks {
+            let prefetch_idx = (i + 2) * 8;
+            _mm_prefetch(a.as_ptr().add(prefetch_idx) as *const i8, _MM_HINT_T0);
+            _mm_prefetch(b.as_ptr().add(prefetch_idx) as *const i8, _MM_HINT_T0);
+        }
+
+        let va = _mm256_loadu_ps(a.as_ptr().add(idx));
+        let vb = _mm256_loadu_ps(b.as_ptr().add(idx));
+
+        let diff = _mm256_sub_ps(va, vb);
+        sum = _mm256_fmadd_ps(diff, diff, sum);
+    }
+
+    let mut total = hsum256_ps_avx2(sum);
+
+    // Handle remainder
+    for i in (chunks * 8)..len {
+        let diff = a[i] - b[i];
+        total += diff * diff;
+    }
+
+    total.sqrt()
+}
+
+/// Horizontal sum of 8 floats in AVX2 register
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "avx2")]
+#[inline]
+unsafe fn hsum256_ps_avx2(v: std::arch::x86_64::__m256) -> f32 {
+    use std::arch::x86_64::*;
+
+    // Extract high 128 bits
+    let high = _mm256_extractf128_ps(v, 1);
+    let low = _mm256_castps256_ps128(v);
+
+    // Add high and low
+    let sum128 = _mm_add_ps(high, low);
+
+    // Horizontal add within 128 bits
+    let shuf = _mm_movehdup_ps(sum128);
+    let sum64 = _mm_add_ps(sum128, shuf);
+    let shuf2 = _mm_movehl_ps(sum64, sum64);
+    let sum32 = _mm_add_ss(sum64, shuf2);
+
+    _mm_cvtss_f32(sum32)
+}
+
+// =============================================================================
+// NEON IMPLEMENTATIONS (ARM64)
+// =============================================================================
+
+#[cfg(target_arch = "aarch64")]
+fn cosine_similarity_neon(a: &[f32], b: &[f32]) -> f32 {
+    use std::arch::aarch64::*;
+
+    debug_assert_eq!(a.len(), b.len());
+    let len = a.len();
+    let chunks = len / 4;
+
+    let mut dot_sum = unsafe { vdupq_n_f32(0.0) };
+    let mut a_sq_sum = unsafe { vdupq_n_f32(0.0) };
+    let mut b_sq_sum = unsafe { vdupq_n_f32(0.0) };
+
+    for i in 0..chunks {
+        let idx = i * 4;
+        unsafe {
+            let va = vld1q_f32(a.as_ptr().add(idx));
+            let vb = vld1q_f32(b.as_ptr().add(idx));
+
+            dot_sum = vfmaq_f32(dot_sum, va, vb);
+            a_sq_sum = vfmaq_f32(a_sq_sum, va, va);
+            b_sq_sum = vfmaq_f32(b_sq_sum, vb, vb);
+        }
+    }
+
+    // Horizontal sum
+    let dot = unsafe { vaddvq_f32(dot_sum) };
+    let a_sq = unsafe { vaddvq_f32(a_sq_sum) };
+    let b_sq = unsafe { vaddvq_f32(b_sq_sum) };
+
+    // Handle remainder
+    let mut dot_rem = dot;
+    let mut a_sq_rem = a_sq;
+    let mut b_sq_rem = b_sq;
+
+    for i in (chunks * 4)..len {
+        let ai = a[i];
+        let bi = b[i];
+        dot_rem += ai * bi;
+        a_sq_rem += ai * ai;
+        b_sq_rem += bi * bi;
+    }
+
+    let norm_a = a_sq_rem.sqrt();
+    let norm_b = b_sq_rem.sqrt();
+
+    if norm_a < 1e-10 || norm_b < 1e-10 {
+        0.0
+    } else {
+        dot_rem / (norm_a * norm_b)
+    }
+}
+
+#[cfg(target_arch = "aarch64")]
+fn euclidean_distance_neon(a: &[f32], b: &[f32]) -> f32 {
+    use std::arch::aarch64::*;
+
+    debug_assert_eq!(a.len(), b.len());
+    let len = a.len();
+    let chunks = len / 4;
+
+    let mut sum = unsafe { vdupq_n_f32(0.0) };
+
+    for i in 0..chunks {
+        let idx = i * 4;
+        unsafe {
+            let va = vld1q_f32(a.as_ptr().add(idx));
+            let vb = vld1q_f32(b.as_ptr().add(idx));
+            let diff = vsubq_f32(va, vb);
+            sum = vfmaq_f32(sum, diff, diff);
+        }
+    }
+
+    let mut total = unsafe { vaddvq_f32(sum) };
+
+    for i in (chunks * 4)..len {
+        let diff = a[i] - b[i];
+        total += diff * diff;
+    }
+
+    total.sqrt()
+}
+
+// =============================================================================
+// SCALAR FALLBACK (Unrolled)
+// =============================================================================
+
+/// Unrolled scalar cosine similarity (4x unroll)
+fn cosine_similarity_unrolled(a: &[f32], b: &[f32]) -> f32 {
+    debug_assert_eq!(a.len(), b.len());
+    let len = a.len();
+    let chunks = len / 4;
+
+    let mut dot0 = 0.0f32;
+    let mut dot1 = 0.0f32;
+    let mut dot2 = 0.0f32;
+    let mut dot3 = 0.0f32;
+
+    let mut a_sq0 = 0.0f32;
+    let mut a_sq1 = 0.0f32;
+    let mut a_sq2 = 0.0f32;
+    let mut a_sq3 = 0.0f32;
+
+    let mut b_sq0 = 0.0f32;
+    let mut b_sq1 = 0.0f32;
+    let mut b_sq2 = 0.0f32;
+    let mut b_sq3 = 0.0f32;
+
+    for i in 0..chunks {
+        let idx = i * 4;
+
+        let a0 = a[idx];
+        let a1 = a[idx + 1];
+        let a2 = a[idx + 2];
+        let a3 = a[idx + 3];
+
+        let b0 = b[idx];
+        let b1 = b[idx + 1];
+        let b2 = b[idx + 2];
+        let b3 = b[idx + 3];
+
+        dot0 += a0 * b0;
+        dot1 += a1 * b1;
+        dot2 += a2 * b2;
+        dot3 += a3 * b3;
+
+        a_sq0 += a0 * a0;
+        a_sq1 += a1 * a1;
+        a_sq2 += a2 * a2;
+        a_sq3 += a3 * a3;
+
+        b_sq0 += b0 * b0;
+        b_sq1 += b1 * b1;
+        b_sq2 += b2 * b2;
+        b_sq3 += b3 * b3;
+    }
+
+    let mut dot = dot0 + dot1 + dot2 + dot3;
+    let mut a_sq = a_sq0 + a_sq1 + a_sq2 + a_sq3;
+    let mut b_sq = b_sq0 + b_sq1 + b_sq2 + b_sq3;
+
+    // Handle remainder
+    for i in (chunks * 4)..len {
+        let ai = a[i];
+        let bi = b[i];
+        dot += ai * bi;
+        a_sq += ai * ai;
+        b_sq += bi * bi;
+    }
+
+    let norm_a = a_sq.sqrt();
+    let norm_b = b_sq.sqrt();
+
+    if norm_a < 1e-10 || norm_b < 1e-10 {
+        0.0
+    } else {
+        dot / (norm_a * norm_b)
+    }
+}
+
+/// Unrolled scalar euclidean distance (4x unroll)
+fn euclidean_distance_unrolled(a: &[f32], b: &[f32]) -> f32 {
+    debug_assert_eq!(a.len(), b.len());
+    let len = a.len();
+    let chunks = len / 4;
+
+    let mut sum0 = 0.0f32;
+    let mut sum1 = 0.0f32;
+    let mut sum2 = 0.0f32;
+    let mut sum3 = 0.0f32;
+
+    for i in 0..chunks {
+        let idx = i * 4;
+
+        let d0 = a[idx] - b[idx];
+        let d1 = a[idx + 1] - b[idx + 1];
+        let d2 = a[idx + 2] - b[idx + 2];
+        let d3 = a[idx + 3] - b[idx + 3];
+
+        sum0 += d0 * d0;
+        sum1 += d1 * d1;
+        sum2 += d2 * d2;
+        sum3 += d3 * d3;
+    }
+
+    let mut total = sum0 + sum1 + sum2 + sum3;
+
+    for i in (chunks * 4)..len {
+        let diff = a[i] - b[i];
+        total += diff * diff;
+    }
+
+    total.sqrt()
+}
+
+// =============================================================================
+// BATCH OPERATIONS
+// =============================================================================
+
+/// Batch compute distances from query to all database vectors
+///
+/// Uses SIMD for individual distances and benefits from cache locality.
+pub fn batch_distances(query: &[f32], database: &[Vec<f32>]) -> Vec<f32> {
+    database
+        .iter()
+        .map(|vec| euclidean_distance_simd(query, vec))
+        .collect()
+}
+
+/// Batch compute cosine similarities
+pub fn batch_cosine_similarities(query: &[f32], database: &[Vec<f32>]) -> Vec<f32> {
+    database
+        .iter()
+        .map(|vec| cosine_similarity_simd(query, vec))
+        .collect()
+}
+
+// =============================================================================
+// TESTS
+// =============================================================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn approx_eq(a: f32, b: f32, epsilon: f32) -> bool {
+        (a - b).abs() < epsilon
+    }
+
+    #[test]
+    fn test_cosine_similarity_identical() {
+        let a = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
+        let result = cosine_similarity_simd(&a, &a);
+        assert!(approx_eq(result, 1.0, 1e-5), "Expected 1.0, got {}", result);
+    }
+
+    #[test]
+    fn test_cosine_similarity_orthogonal() {
+        let a = vec![1.0, 0.0, 0.0, 0.0];
+        let b = vec![0.0, 1.0, 0.0, 0.0];
+        let result = cosine_similarity_simd(&a, &b);
+        assert!(approx_eq(result, 0.0, 1e-5), "Expected 0.0, got {}", result);
+    }
+
+    #[test]
+    fn test_euclidean_distance_same() {
+        let a = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
+        let result = euclidean_distance_simd(&a, &a);
+        assert!(approx_eq(result, 0.0, 1e-5), "Expected 0.0, got {}", result);
+    }
+
+    #[test]
+    fn test_euclidean_distance_known() {
+        let a = vec![0.0, 0.0, 0.0, 0.0];
+        let b = vec![3.0, 4.0, 0.0, 0.0];
+        let result = euclidean_distance_simd(&a, &b);
+        assert!(approx_eq(result, 5.0, 1e-5), "Expected 5.0, got {}", result);
+    }
+
+    #[test]
+    fn test_large_vectors() {
+        let a: Vec<f32> = (0..768).map(|i| (i as f32).sin()).collect();
+        let b: Vec<f32> = (0..768).map(|i| (i as f32).cos()).collect();
+
+        let cos = cosine_similarity_simd(&a, &b);
+        let dist = euclidean_distance_simd(&a, &b);
+
+        assert!(cos > -1.0 && cos < 1.0);
+        assert!(dist >= 0.0);
+    }
+
+    #[test]
+    fn test_batch_operations() {
+        let query = vec![1.0, 0.0, 0.0, 0.0];
+        let database = vec![
+            vec![1.0, 0.0, 0.0, 0.0],
+            vec![0.0, 1.0, 0.0, 0.0],
+            vec![0.5, 0.5, 0.0, 0.0],
+        ];
+
+        let distances = batch_distances(&query, &database);
+        assert_eq!(distances.len(), 3);
+        assert!(approx_eq(distances[0], 0.0, 1e-5)); // Same vector
+
+        let similarities = batch_cosine_similarities(&query, &database);
+        assert_eq!(similarities.len(), 3);
+        assert!(approx_eq(similarities[0], 1.0, 1e-5)); // Same vector
+    }
+}

vendor/ruvector/examples/exo-ai-2025/crates/exo-manifold/src/transfer_store.rs

@@ -0,0 +1,202 @@
+//! Phase 2 – Transfer Manifold
+//!
+//! Stores cross-domain transfer priors as deformable patterns in the EXO
+//! manifold. Each `(src, dst)` prior is encoded as a 64-dim sinusoidal
+//! embedding and written via `ManifoldEngine::deform`. Semantically similar
+//! past transfers are recalled via cosine distance.
+
+use exo_core::{ManifoldConfig, Metadata, Pattern, PatternId, SearchResult, SubstrateTime};
+use ruvector_domain_expansion::{ArmId, ContextBucket, DomainId, TransferPrior};
+use std::collections::HashMap;
+
+use crate::ManifoldEngine;
+
+const DIM: usize = 64;
+
+// ─── embedding helpers ────────────────────────────────────────────────────────
+
+/// Hash a domain-ID string into `n` sinusoidal floats starting at `offset`.
+fn domain_to_floats(id: &str, out: &mut [f32], offset: usize, n: usize) {
+    let bytes = id.as_bytes();
+    let cap = out.len().saturating_sub(offset);
+    for i in 0..n.min(cap) {
+        let b = bytes[i % bytes.len().max(1)] as f32 / 255.0;
+        let freq = (1 + i) as f32;
+        out[offset + i] = (b * freq * std::f32::consts::TAU).sin() * 0.5 + 0.5;
+    }
+}
+
+/// Build a 64-dim embedding for `(src, dst, prior, cycle)`.
+///
+/// Layout:
+/// * `[0..16]`  – src domain identity (sinusoidal)
+/// * `[16..32]` – dst domain identity (sinusoidal)
+/// * `[32..44]` – BetaParams for up to 3 arms (4 floats × 3)
+/// * `[44]`     – cycle (log-normalised)
+/// * `[45..64]` – zero-padded
+fn build_embedding(src: &DomainId, dst: &DomainId, prior: &TransferPrior, cycle: u64) -> Vec<f32> {
+    let mut emb = vec![0.0f32; DIM];
+    domain_to_floats(&src.0, &mut emb, 0, 16);
+    domain_to_floats(&dst.0, &mut emb, 16, 16);
+
+    let bucket = ContextBucket {
+        difficulty_tier: "medium".to_string(),
+        category: "transfer".to_string(),
+    };
+    for (i, arm_name) in ["arm_0", "arm_1", "arm_2"].iter().enumerate() {
+        let arm_id = ArmId(arm_name.to_string());
+        let bp = prior.get_prior(&bucket, &arm_id);
+        let off = 32 + i * 4;
+        if off + 3 < DIM {
+            emb[off] = bp.mean().clamp(0.0, 1.0);
+            emb[off + 1] = bp.variance().clamp(0.0, 0.25) * 4.0;
+            emb[off + 2] = (1.0 - bp.variance().clamp(0.0, 0.25) * 4.0).max(0.0);
+            emb[off + 3] = 0.0; // reserved
+        }
+    }
+    let cycle_norm = (cycle as f32).ln_1p() / (1000.0_f32).ln_1p();
+    emb[44] = cycle_norm.clamp(0.0, 1.0);
+    emb
+}
+
+// ─── TransferManifold ─────────────────────────────────────────────────────────
+
+/// Stores transfer priors as deformable patterns in the EXO manifold.
+///
+/// Each `(src_domain, dst_domain)` pair is encoded as a 64-dim embedding and
+/// deformed into the manifold. `retrieve_similar` performs cosine-distance
+/// search to find structurally-similar past transfer priors.
+pub struct TransferManifold {
+    engine: ManifoldEngine,
+    /// Maps `(src_domain, dst_domain)` → the last PatternId stored for that pair.
+    index: HashMap<(String, String), PatternId>,
+}
+
+impl TransferManifold {
+    /// Create a new `TransferManifold` with 64-dim embeddings.
+    pub fn new() -> Self {
+        let config = ManifoldConfig {
+            dimension: DIM,
+            max_descent_steps: 20,
+            learning_rate: 0.01,
+            ..Default::default()
+        };
+        Self {
+            engine: ManifoldEngine::new(config),
+            index: HashMap::new(),
+        }
+    }
+
+    /// Store (or update) the transfer prior for a domain pair.
+    ///
+    /// Salience is set to the mean reward of the primary arm so that
+    /// high-performing priors are retained longer by strategic forgetting.
+    pub fn store_prior(
+        &mut self,
+        src: &DomainId,
+        dst: &DomainId,
+        prior: &TransferPrior,
+        cycle: u64,
+    ) -> exo_core::Result<()> {
+        let embedding = build_embedding(src, dst, prior, cycle);
+        let bucket = ContextBucket {
+            difficulty_tier: "medium".to_string(),
+            category: "transfer".to_string(),
+        };
+        let arm_id = ArmId("arm_0".to_string());
+        let salience = prior.get_prior(&bucket, &arm_id).mean().clamp(0.05, 1.0);
+
+        let pattern = Pattern {
+            id: PatternId::new(),
+            embedding,
+            metadata: Metadata::default(),
+            timestamp: SubstrateTime::now(),
+            antecedents: vec![],
+            salience,
+        };
+        let pid = pattern.id;
+        self.engine.deform(pattern, salience)?;
+        self.index.insert((src.0.clone(), dst.0.clone()), pid);
+        Ok(())
+    }
+
+    /// Retrieve the `k` most similar stored transfer priors for a source domain.
+    ///
+    /// Uses the source domain's sinusoidal hash as the query vector.
+    pub fn retrieve_similar(
+        &self,
+        src: &DomainId,
+        k: usize,
+    ) -> exo_core::Result<Vec<SearchResult>> {
+        let mut query = vec![0.0f32; DIM];
+        domain_to_floats(&src.0, &mut query, 0, 16);
+        self.engine.retrieve(&query, k)
+    }
+
+    /// Whether a prior has been stored for this exact domain pair.
+    pub fn has_pair(&self, src: &DomainId, dst: &DomainId) -> bool {
+        self.index.contains_key(&(src.0.clone(), dst.0.clone()))
+    }
+
+    /// Number of stored transfer priors.
+    pub fn len(&self) -> usize {
+        self.engine.len()
+    }
+
+    /// True when no priors have been stored.
+    pub fn is_empty(&self) -> bool {
+        self.engine.is_empty()
+    }
+}
+
+impl Default for TransferManifold {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_store_and_retrieve() {
+        let mut tm = TransferManifold::new();
+        let src = DomainId("exo-retrieval".to_string());
+        let dst = DomainId("exo-graph".to_string());
+        let prior = TransferPrior::uniform(src.clone());
+
+        tm.store_prior(&src, &dst, &prior, 10).unwrap();
+        assert_eq!(tm.len(), 1);
+        assert!(tm.has_pair(&src, &dst));
+
+        let results = tm.retrieve_similar(&src, 1).unwrap();
+        assert!(!results.is_empty());
+    }
+
+    #[test]
+    fn test_multiple_domain_pairs() {
+        let mut tm = TransferManifold::new();
+        for (s, d) in [("a", "b"), ("c", "d"), ("e", "f")] {
+            let src = DomainId(s.to_string());
+            let dst = DomainId(d.to_string());
+            let prior = TransferPrior::uniform(src.clone());
+            tm.store_prior(&src, &dst, &prior, 1).unwrap();
+        }
+        assert_eq!(tm.len(), 3);
+        let results = tm.retrieve_similar(&DomainId("a".to_string()), 2).unwrap();
+        assert!(!results.is_empty());
+    }
+
+    #[test]
+    fn test_embedding_dimension() {
+        let src = DomainId("test-src".to_string());
+        let dst = DomainId("test-dst".to_string());
+        let prior = TransferPrior::uniform(src.clone());
+        let emb = build_embedding(&src, &dst, &prior, 42);
+        assert_eq!(emb.len(), DIM);
+        for &v in &emb {
+            assert!(v >= 0.0 && v <= 1.0, "out-of-range value: {}", v);
+        }
+    }
+}