diff --git a/examples/exo-ai-2025/architecture/ARCHITECTURE.md b/examples/exo-ai-2025/architecture/ARCHITECTURE.md new file mode 100644 index 00000000..2dbbc7cc --- /dev/null +++ b/examples/exo-ai-2025/architecture/ARCHITECTURE.md @@ -0,0 +1,805 @@ +# EXO-AI 2025: System Architecture + +## SPARC Phase 3: Architecture Design + +### Executive Summary + +This document defines the modular architecture for an experimental cognitive substrate platform, consuming the ruvector ecosystem as an SDK while exploring technologies projected for 2035-2060. + +--- + +## 1. Architectural Principles + +### 1.1 Core Design Tenets + +| Principle | Description | Implementation | +|-----------|-------------|----------------| +| **SDK Consumer** | No modifications to ruvector crates | Clean dependency boundaries | +| **Backend Agnostic** | Hardware abstraction via traits | PIM, neuromorphic, photonic backends | +| **Substrate-First** | Data and compute unified | In-memory operations where possible | +| **Topology Native** | Hypergraph as primary structure | Edges span arbitrary entity sets | +| **Temporal Coherent** | Causal memory by default | Every operation timestamped | + +### 1.2 Layer Architecture + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ APPLICATION LAYER │ +│ ┌─────────────┐ ┌──────────────┐ ┌───────────────────────────┐ │ +│ │ Agent SDK │ │ Query Engine │ │ Federation Gateway │ │ +│ └─────────────┘ └──────────────┘ └───────────────────────────┘ │ +├─────────────────────────────────────────────────────────────────┤ +│ SUBSTRATE LAYER │ +│ ┌─────────────┐ ┌──────────────┐ ┌───────────────────────────┐ │ +│ │ Manifold │ │ Hypergraph │ │ Temporal Memory │ │ +│ │ Engine │ │ Substrate │ │ Coordinator │ │ +│ └─────────────┘ └──────────────┘ └───────────────────────────┘ │ +├─────────────────────────────────────────────────────────────────┤ +│ BACKEND ABSTRACTION │ +│ ┌─────────────┐ ┌──────────────┐ ┌───────────────────────────┐ │ +│ │ Classical │ │ Neuromorphic │ │ Photonic │ │ +│ │ (ruvector) │ │ (Future) │ │ (Future) │ │ +│ └─────────────┘ └──────────────┘ └───────────────────────────┘ │ +├─────────────────────────────────────────────────────────────────┤ +│ INFRASTRUCTURE │ +│ ┌─────────────┐ ┌──────────────┐ ┌───────────────────────────┐ │ +│ │ WASM │ │ NAPI-RS │ │ Native │ │ +│ │ Runtime │ │ Bindings │ │ Binaries │ │ +│ └─────────────┘ └──────────────┘ └───────────────────────────┘ │ +└─────────────────────────────────────────────────────────────────┘ +``` + +--- + +## 2. Module Design + +### 2.1 Core Modules + +``` +exo-ai-2025/ +├── crates/ +│ ├── exo-core/ # Core traits and types +│ ├── exo-manifold/ # Learned manifold engine +│ ├── exo-hypergraph/ # Hypergraph substrate +│ ├── exo-temporal/ # Temporal memory coordinator +│ ├── exo-federation/ # Federated mesh networking +│ ├── exo-backend-classical/ # Classical backend (ruvector) +│ ├── exo-backend-sim/ # Neuromorphic/photonic simulator +│ ├── exo-wasm/ # WASM bindings +│ └── exo-node/ # NAPI-RS bindings +├── examples/ +├── docs/ +└── research/ +``` + +### 2.2 exo-core: Foundational Traits + +```rust +//! Core trait definitions for backend abstraction + +/// Backend trait for substrate compute operations +pub trait SubstrateBackend: Send + Sync { + type Error: std::error::Error; + + /// Execute similarity search on substrate + fn similarity_search( + &self, + query: &[f32], + k: usize, + filter: Option<&Filter>, + ) -> Result, Self::Error>; + + /// Deform manifold to incorporate new pattern + fn manifold_deform( + &self, + pattern: &Pattern, + learning_rate: f32, + ) -> Result; + + /// Execute hyperedge query + fn hyperedge_query( + &self, + query: &TopologicalQuery, + ) -> Result; +} + +/// Temporal context for causal operations +pub trait TemporalContext { + /// Get current substrate time + fn now(&self) -> SubstrateTime; + + /// Query with causal cone constraints + fn causal_query( + &self, + query: &Query, + cone: &CausalCone, + ) -> Result, Error>; + + /// Predictive pre-fetch based on anticipated queries + fn anticipate(&self, hints: &[AnticipationHint]) -> Result<(), Error>; +} + +/// Pattern representation in substrate +#[derive(Clone, Debug)] +pub struct Pattern { + /// Vector embedding + pub embedding: Vec, + /// Metadata + pub metadata: Metadata, + /// Temporal origin + pub timestamp: SubstrateTime, + /// Causal antecedents + pub antecedents: Vec, +} + +/// Topological query specification +#[derive(Clone, Debug)] +pub enum TopologicalQuery { + /// Find persistent homology features + PersistentHomology { + dimension: usize, + epsilon_range: (f32, f32), + }, + /// Find N-dimensional holes in structure + BettiNumbers { + max_dimension: usize, + }, + /// Sheaf consistency check + SheafConsistency { + local_sections: Vec, + }, +} +``` + +### 2.3 exo-manifold: Learned Representation Engine + +```rust +//! Continuous manifold storage replacing discrete indices + +use burn::prelude::*; +use crate::core::{Pattern, SubstrateBackend, ManifoldDelta}; + +/// Implicit Neural Representation for manifold storage +pub struct ManifoldEngine { + /// Neural network representing the manifold + network: LearnedManifold, + /// Tensor Train decomposition for compression + tt_decomposition: Option, + /// Consolidation scheduler + consolidation: ConsolidationPolicy, +} + +impl ManifoldEngine { + /// Query manifold via gradient descent + pub fn retrieve( + &self, + query: Tensor, + k: usize, + ) -> Vec<(Pattern, f32)> { + // Initialize at query position + let mut position = query.clone(); + + // Gradient descent toward relevant memories + for _ in 0..self.config.max_descent_steps { + let relevance = self.network.forward(position.clone()); + let gradient = relevance.backward(); + position = position - self.config.learning_rate * gradient; + + if gradient.norm() < self.config.convergence_threshold { + break; + } + } + + // Extract patterns from converged region + self.extract_patterns_near(position, k) + } + + /// Continuous manifold deformation (replaces insert) + pub fn deform(&mut self, pattern: Pattern, salience: f32) { + let embedding = Tensor::from_floats(&pattern.embedding); + + // Deformation = gradient update to manifold weights + let loss = self.deformation_loss(embedding, salience); + let gradients = loss.backward(); + + self.optimizer.step(gradients); + } + + /// Strategic forgetting via manifold smoothing + pub fn forget(&mut self, region: &ManifoldRegion, decay_rate: f32) { + // Smooth the manifold in low-salience regions + self.apply_forgetting_kernel(region, decay_rate); + } +} + +/// Learned manifold network architecture +#[derive(Module)] +pub struct LearnedManifold { + /// SIREN-style sinusoidal layers + layers: Vec>, + /// Fourier feature encoding + fourier_features: FourierEncoding, +} +``` + +### 2.4 exo-hypergraph: Topological Substrate + +```rust +//! Hypergraph substrate for higher-order relations + +use petgraph::Graph; +use simplicial_topology::SimplicialComplex; +use ruvector_graph::{GraphDatabase, HyperedgeSupport}; + +/// Hypergraph substrate extending ruvector-graph +pub struct HypergraphSubstrate { + /// Base graph from ruvector-graph + base: GraphDatabase, + /// Hyperedge index (relations spanning >2 entities) + hyperedges: HyperedgeIndex, + /// Simplicial complex for TDA + topology: SimplicialComplex, + /// Sheaf structure for consistency + sheaf: Option, +} + +impl HypergraphSubstrate { + /// Create hyperedge spanning multiple entities + pub fn create_hyperedge( + &mut self, + entities: &[EntityId], + relation: &Relation, + ) -> Result { + // Validate entity existence + for entity in entities { + self.base.get_node(*entity)?; + } + + // Create hyperedge in index + let hyperedge_id = self.hyperedges.insert(entities, relation); + + // Update simplicial complex + self.topology.add_simplex(entities); + + // Update sheaf sections if enabled + if let Some(ref mut sheaf) = self.sheaf { + sheaf.update_sections(hyperedge_id, entities)?; + } + + Ok(hyperedge_id) + } + + /// Topological query: find persistent features + pub fn persistent_homology( + &self, + dimension: usize, + epsilon_range: (f32, f32), + ) -> PersistenceDiagram { + use teia::persistence::compute_persistence; + + let filtration = self.topology.filtration(epsilon_range); + compute_persistence(&filtration, dimension) + } + + /// Query Betti numbers (topological invariants) + pub fn betti_numbers(&self, max_dim: usize) -> Vec { + (0..=max_dim) + .map(|d| self.topology.betti_number(d)) + .collect() + } + + /// Sheaf consistency: check local-to-global coherence + pub fn check_sheaf_consistency( + &self, + sections: &[SectionId], + ) -> SheafConsistencyResult { + match &self.sheaf { + Some(sheaf) => sheaf.check_consistency(sections), + None => SheafConsistencyResult::NotConfigured, + } + } +} + +/// Hyperedge index structure +struct HyperedgeIndex { + /// Hyperedge storage + edges: DashMap, + /// Inverted index: entity -> hyperedges containing it + entity_index: DashMap>, + /// Relation type index + relation_index: DashMap>, +} +``` + +### 2.5 exo-temporal: Causal Memory Coordinator + +```rust +//! Temporal memory with causal structure + +use std::collections::BTreeMap; +use ruvector_core::VectorIndex; + +/// Temporal memory coordinator +pub struct TemporalMemory { + /// Short-term volatile memory + short_term: ShortTermBuffer, + /// Long-term consolidated memory + long_term: LongTermStore, + /// Causal graph tracking antecedent relationships + causal_graph: CausalGraph, + /// Temporal knowledge graph (Zep-inspired) + tkg: TemporalKnowledgeGraph, +} + +impl TemporalMemory { + /// Store with causal context + pub fn store( + &mut self, + pattern: Pattern, + antecedents: &[PatternId], + ) -> Result { + // Add to short-term buffer + let id = self.short_term.insert(pattern.clone()); + + // Record causal relationships + for antecedent in antecedents { + self.causal_graph.add_edge(*antecedent, id); + } + + // Update TKG with temporal relations + self.tkg.add_temporal_fact(id, &pattern, antecedents)?; + + // Schedule consolidation if buffer full + if self.short_term.should_consolidate() { + self.trigger_consolidation(); + } + + Ok(id) + } + + /// Causal cone query: retrieve within light-cone constraints + pub fn causal_query( + &self, + query: &Query, + reference_time: SubstrateTime, + cone_type: CausalConeType, + ) -> Vec { + // Determine valid time range based on cone + let time_range = match cone_type { + CausalConeType::Past => (SubstrateTime::MIN, reference_time), + CausalConeType::Future => (reference_time, SubstrateTime::MAX), + CausalConeType::LightCone { velocity } => { + self.compute_light_cone(reference_time, velocity) + } + }; + + // Query with temporal filter + self.long_term + .search_with_time_range(query, time_range) + .into_iter() + .map(|r| CausalResult { + pattern: r.pattern, + causal_distance: self.causal_graph.distance(r.id, query.origin), + temporal_distance: (r.timestamp - reference_time).abs(), + }) + .collect() + } + + /// Anticipatory pre-fetch for predictive retrieval + pub fn anticipate(&mut self, hints: &[AnticipationHint]) { + for hint in hints { + // Pre-compute likely future queries + let predicted_queries = self.predict_future_queries(hint); + + // Warm cache with predicted results + for query in predicted_queries { + self.prefetch_cache.insert(query.hash(), + self.long_term.search(&query)); + } + } + } + + /// Memory consolidation: short-term -> long-term + fn consolidate(&mut self) { + // Identify salient patterns + let salient = self.short_term + .drain() + .filter(|p| p.salience > self.consolidation_threshold); + + // Compress via manifold integration + for pattern in salient { + self.long_term.integrate(pattern); + } + + // Strategic forgetting in long-term + self.long_term.decay_low_salience(self.decay_rate); + } +} + +/// Causal graph for tracking antecedent relationships +struct CausalGraph { + /// Forward edges: cause -> effects + forward: DashMap>, + /// Backward edges: effect -> causes + backward: DashMap>, +} +``` + +### 2.6 exo-federation: Distributed Cognitive Mesh + +```rust +//! Federated substrate with cryptographic sovereignty + +use ruvector_raft::{RaftNode, RaftConfig}; +use ruvector_cluster::ClusterManager; +use kyberlib::{keypair, encapsulate, decapsulate}; + +/// Federated cognitive mesh +pub struct FederatedMesh { + /// Local substrate instance + local: Arc, + /// Raft consensus for local cluster + consensus: RaftNode, + /// Federation gateway + gateway: FederationGateway, + /// Post-quantum keypair + pq_keys: PostQuantumKeypair, +} + +impl FederatedMesh { + /// Join federation with cryptographic handshake + pub async fn join_federation( + &mut self, + peer: &PeerAddress, + ) -> Result { + // Post-quantum key exchange + let (ciphertext, shared_secret) = encapsulate(&peer.public_key)?; + + // Establish encrypted channel + let channel = self.gateway.establish_channel( + peer, + ciphertext, + shared_secret, + ).await?; + + // Exchange federation capabilities + let token = channel.negotiate_federation().await?; + + Ok(token) + } + + /// Federated query with privacy preservation + pub async fn federated_query( + &self, + query: &Query, + scope: FederationScope, + ) -> Vec { + // Route through onion network for intent privacy + let onion_query = self.gateway.onion_wrap(query, scope)?; + + // Broadcast to federation peers + let responses = self.gateway.broadcast(onion_query).await; + + // CRDT reconciliation for eventual consistency + let reconciled = self.reconcile_crdt(responses)?; + + reconciled + } + + /// Byzantine fault tolerant consensus on shared state + pub async fn byzantine_commit( + &self, + update: &StateUpdate, + ) -> Result { + // Require 2f+1 agreement for n=3f+1 nodes + let threshold = (self.peer_count() * 2 / 3) + 1; + + // Propose update + let proposal = self.consensus.propose(update)?; + + // Collect votes + let votes = self.gateway.collect_votes(proposal).await; + + if votes.len() >= threshold { + Ok(CommitProof::from_votes(votes)) + } else { + Err(Error::InsufficientConsensus) + } + } +} + +/// Post-quantum cryptographic keypair +struct PostQuantumKeypair { + /// CRYSTALS-Kyber public key + public: [u8; 1184], + /// CRYSTALS-Kyber secret key + secret: [u8; 2400], +} +``` + +--- + +## 3. Backend Abstraction Layer + +### 3.1 Classical Backend (ruvector SDK) + +```rust +//! Classical backend consuming ruvector crates + +use ruvector_core::{VectorIndex, HnswConfig}; +use ruvector_graph::GraphDatabase; +use ruvector_gnn::GnnLayer; + +/// Classical substrate backend using ruvector +pub struct ClassicalBackend { + /// Vector index from ruvector-core + vector_index: VectorIndex, + /// Graph database from ruvector-graph + graph_db: GraphDatabase, + /// GNN layer from ruvector-gnn + gnn: Option, +} + +impl SubstrateBackend for ClassicalBackend { + type Error = ruvector_core::Error; + + fn similarity_search( + &self, + query: &[f32], + k: usize, + filter: Option<&Filter>, + ) -> Result, Self::Error> { + // Direct delegation to ruvector-core + let results = match filter { + Some(f) => self.vector_index.search_with_filter(query, k, f)?, + None => self.vector_index.search(query, k)?, + }; + + Ok(results.into_iter().map(SearchResult::from).collect()) + } + + fn manifold_deform( + &self, + pattern: &Pattern, + _learning_rate: f32, + ) -> Result { + // Classical backend: discrete insert + let id = self.vector_index.insert(&pattern.embedding, &pattern.metadata)?; + + Ok(ManifoldDelta::DiscreteInsert { id }) + } + + fn hyperedge_query( + &self, + query: &TopologicalQuery, + ) -> Result { + // Use ruvector-graph hyperedge support + match query { + TopologicalQuery::PersistentHomology { .. } => { + // Compute via graph traversal + unimplemented!("TDA on classical backend") + } + TopologicalQuery::BettiNumbers { .. } => { + // Approximate via connected components + unimplemented!("Betti numbers on classical backend") + } + TopologicalQuery::SheafConsistency { .. } => { + // Not supported on classical backend + Ok(HyperedgeResult::NotSupported) + } + } + } +} +``` + +### 3.2 Future Backend Traits + +```rust +//! Placeholder traits for future hardware backends + +/// Processing-in-Memory backend interface +pub trait PimBackend: SubstrateBackend { + /// Execute operation in memory bank + fn execute_in_memory(&self, op: &MemoryOperation) -> Result<(), Error>; + + /// Query memory bank location for data + fn data_location(&self, pattern_id: PatternId) -> MemoryBank; +} + +/// Neuromorphic backend interface +pub trait NeuromorphicBackend: SubstrateBackend { + /// Encode vector as spike train + fn encode_spikes(&self, vector: &[f32]) -> SpikeTrain; + + /// Decode spike train to vector + fn decode_spikes(&self, spikes: &SpikeTrain) -> Vec; + + /// Submit spike computation + fn submit_spike_compute(&self, input: SpikeTrain) -> Result; +} + +/// Photonic backend interface +pub trait PhotonicBackend: SubstrateBackend { + /// Optical matrix-vector multiply + fn optical_matmul(&self, matrix: &OpticalMatrix, vector: &[f32]) -> Vec; + + /// Configure optical interference pattern + fn configure_mzi(&self, config: &MziConfig) -> Result<(), Error>; +} +``` + +--- + +## 4. WASM & NAPI-RS Integration + +### 4.1 WASM Module Structure + +```rust +//! WASM bindings for browser/edge deployment + +use wasm_bindgen::prelude::*; +use crate::core::{Pattern, Query}; + +#[wasm_bindgen] +pub struct ExoSubstrate { + inner: Arc, +} + +#[wasm_bindgen] +impl ExoSubstrate { + #[wasm_bindgen(constructor)] + pub fn new(config: JsValue) -> Result { + let config: SubstrateConfig = serde_wasm_bindgen::from_value(config)?; + let inner = SubstrateInstance::new(config)?; + Ok(Self { inner: Arc::new(inner) }) + } + + #[wasm_bindgen] + pub async fn query(&self, embedding: Float32Array, k: u32) -> Result { + let query = Query::from_embedding(embedding.to_vec()); + let results = self.inner.search(query, k as usize).await?; + Ok(serde_wasm_bindgen::to_value(&results)?) + } + + #[wasm_bindgen] + pub fn store(&self, pattern: JsValue) -> Result { + let pattern: Pattern = serde_wasm_bindgen::from_value(pattern)?; + let id = self.inner.store(pattern)?; + Ok(id.to_string()) + } +} +``` + +### 4.2 NAPI-RS Bindings + +```rust +//! Node.js bindings via NAPI-RS + +use napi::bindgen_prelude::*; +use napi_derive::napi; + +#[napi] +pub struct ExoSubstrateNode { + inner: Arc>, +} + +#[napi] +impl ExoSubstrateNode { + #[napi(constructor)] + pub fn new(config: serde_json::Value) -> Result { + let config: SubstrateConfig = serde_json::from_value(config)?; + let inner = SubstrateInstance::new(config)?; + Ok(Self { inner: Arc::new(RwLock::new(inner)) }) + } + + #[napi] + pub async fn search(&self, embedding: Float32Array, k: u32) -> Result> { + let guard = self.inner.read().await; + let results = guard.search( + Query::from_embedding(embedding.to_vec()), + k as usize, + ).await?; + Ok(results.into_iter().map(SearchResultJs::from).collect()) + } + + #[napi] + pub async fn hypergraph_query(&self, query: String) -> Result { + let guard = self.inner.read().await; + let topo_query: TopologicalQuery = serde_json::from_str(&query)?; + let result = guard.hypergraph.query(&topo_query).await?; + Ok(serde_json::to_value(result)?) + } +} +``` + +--- + +## 5. Deployment Targets + +### 5.1 Build Configurations + +```toml +# Cargo.toml feature flags + +[features] +default = ["classical-backend"] + +# Backends +classical-backend = ["ruvector-core", "ruvector-graph", "ruvector-gnn"] +sim-neuromorphic = [] +sim-photonic = [] + +# Deployment targets +wasm = ["wasm-bindgen", "getrandom/js"] +napi = ["napi", "napi-derive"] + +# Experimental features +tensor-train = [] +sheaf-consistency = [] +post-quantum = ["kyberlib", "pqcrypto"] +``` + +### 5.2 Platform Matrix + +| Target | Backend | Features | Size | +|--------|---------|----------|------| +| `wasm32-unknown-unknown` | Classical (memory-only) | Core substrate | ~2MB | +| `x86_64-unknown-linux-gnu` | Classical (full) | All features | ~15MB | +| `aarch64-apple-darwin` | Classical (full) | All features | ~12MB | +| Node.js (NAPI) | Classical (full) | All features | ~8MB | + +--- + +## 6. Future Architecture Extensions + +### 6.1 PIM Integration Path + +``` +Phase 1: Abstraction (Current) +├── Define PimBackend trait +├── Implement simulation mode +└── Profile classical baseline + +Phase 2: Emulation +├── UPMEM SDK integration +├── Performance modeling +└── Hybrid execution strategies + +Phase 3: Native Hardware +├── Custom PIM firmware +├── Memory bank allocation +└── Direct execution path +``` + +### 6.2 Consciousness Metrics (Research) + +```rust +//! Experimental: Integrated Information metrics + +/// Compute Phi (integrated information) for substrate region +pub fn compute_phi( + substrate: &SubstrateRegion, + partition_strategy: PartitionStrategy, +) -> f64 { + // Compute information generated by whole + let whole_info = substrate.effective_information(); + + // Compute information generated by parts + let partitions = partition_strategy.partition(substrate); + let parts_info: f64 = partitions + .iter() + .map(|p| p.effective_information()) + .sum(); + + // Phi = whole - parts (simplified IIT measure) + (whole_info - parts_info).max(0.0) +} +``` + +--- + +## References + +- SPARC Specification: `specs/SPECIFICATION.md` +- Research Papers: `research/PAPERS.md` +- Rust Libraries: `research/RUST_LIBRARIES.md` diff --git a/examples/exo-ai-2025/architecture/PSEUDOCODE.md b/examples/exo-ai-2025/architecture/PSEUDOCODE.md new file mode 100644 index 00000000..f8dafe6e --- /dev/null +++ b/examples/exo-ai-2025/architecture/PSEUDOCODE.md @@ -0,0 +1,645 @@ +# EXO-AI 2025: Pseudocode Design + +## SPARC Phase 2: Algorithm Design + +This document presents high-level pseudocode for the core algorithms in the EXO-AI cognitive substrate. + +--- + +## 1. Learned Manifold Engine + +### 1.1 Manifold Retrieval via Gradient Descent + +```pseudocode +FUNCTION ManifoldRetrieve(query_vector, k, manifold_network): + // Initialize search position at query + position = query_vector + visited_positions = [] + + // Gradient descent toward high-relevance regions + FOR step IN 1..MAX_DESCENT_STEPS: + // Forward pass through learned manifold + relevance_field = manifold_network.forward(position) + + // Compute gradient of relevance + gradient = manifold_network.backward(relevance_field) + + // Update position following relevance gradient + position = position - LEARNING_RATE * gradient + visited_positions.append(position) + + // Check convergence + IF norm(gradient) < CONVERGENCE_THRESHOLD: + BREAK + + // Extract k nearest patterns from converged region + results = [] + FOR pos IN visited_positions.last(k): + patterns = ExtractPatternsNear(pos, manifold_network) + results.extend(patterns) + + RETURN TopK(results, k) +``` + +### 1.2 Continuous Manifold Deformation + +```pseudocode +FUNCTION ManifoldDeform(pattern, salience, manifold_network, optimizer): + // No discrete insert - continuous deformation instead + + // Encode pattern as tensor + embedding = Tensor(pattern.embedding) + + // Compute deformation loss + // Loss = how much the manifold needs to change to represent this pattern + current_relevance = manifold_network.forward(embedding) + target_relevance = salience + deformation_loss = (current_relevance - target_relevance)^2 + + // Add regularization for manifold smoothness + smoothness_loss = ManifoldCurvatureRegularizer(manifold_network) + total_loss = deformation_loss + LAMBDA * smoothness_loss + + // Gradient update to manifold weights + gradients = total_loss.backward() + optimizer.step(gradients) + + // Return delta for logging + RETURN ManifoldDelta(embedding, salience, total_loss) +``` + +### 1.3 Strategic Forgetting + +```pseudocode +FUNCTION StrategicForget(manifold_network, decay_rate, salience_threshold): + // Identify low-salience regions + low_salience_regions = [] + + FOR region IN manifold_network.sample_regions(): + avg_salience = ComputeAverageSalience(region) + IF avg_salience < salience_threshold: + low_salience_regions.append(region) + + // Apply smoothing kernel to low-salience regions + // This effectively "forgets" by reducing specificity + FOR region IN low_salience_regions: + ForgetKernel = GaussianKernel(sigma=decay_rate) + manifold_network.apply_kernel(region, ForgetKernel) + + // Optional: prune near-zero weights + manifold_network.prune_weights(threshold=1e-6) +``` + +--- + +## 2. Hypergraph Substrate + +### 2.1 Hyperedge Creation + +```pseudocode +FUNCTION CreateHyperedge(entities, relation, hypergraph): + // Validate all entities exist + FOR entity IN entities: + IF NOT hypergraph.base_graph.contains(entity): + RAISE EntityNotFoundError(entity) + + // Generate hyperedge ID + hyperedge_id = GenerateUUID() + + // Create hyperedge record + hyperedge = Hyperedge( + id = hyperedge_id, + entities = entities, + relation = relation, + created_at = NOW(), + weight = 1.0 + ) + + // Insert into hyperedge storage + hypergraph.hyperedges.insert(hyperedge_id, hyperedge) + + // Update inverted index (entity -> hyperedges) + FOR entity IN entities: + hypergraph.entity_index[entity].append(hyperedge_id) + + // Update relation type index + hypergraph.relation_index[relation.type].append(hyperedge_id) + + // Update simplicial complex for TDA + simplex = entities.as_simplex() + hypergraph.topology.add_simplex(simplex) + + RETURN hyperedge_id +``` + +### 2.2 Persistent Homology Computation + +```pseudocode +FUNCTION ComputePersistentHomology(hypergraph, dimension, epsilon_range): + // Build filtration (nested sequence of simplicial complexes) + filtration = BuildFiltration(hypergraph.topology, epsilon_range) + + // Initialize boundary matrix for column reduction + boundary_matrix = BuildBoundaryMatrix(filtration, dimension) + + // Column reduction algorithm (standard persistent homology) + reduced_matrix = ColumnReduction(boundary_matrix) + + // Extract persistence pairs + pairs = [] + FOR col_j IN reduced_matrix.columns: + IF reduced_matrix.low(j) != NULL: + i = reduced_matrix.low(j) + birth = filtration.birth_time(i) + death = filtration.birth_time(j) + pairs.append((birth, death)) + ELSE IF col_j is a cycle: + birth = filtration.birth_time(j) + death = INFINITY // Essential feature + pairs.append((birth, death)) + + // Build persistence diagram + diagram = PersistenceDiagram( + pairs = pairs, + dimension = dimension + ) + + RETURN diagram + +FUNCTION ColumnReduction(matrix): + // Standard algorithm from computational topology + FOR j IN 1..matrix.num_cols: + WHILE EXISTS j' < j WITH low(j') = low(j): + // Add column j' to column j to reduce + matrix.column(j) = matrix.column(j) XOR matrix.column(j') + RETURN matrix +``` + +### 2.3 Sheaf Consistency Check + +```pseudocode +FUNCTION CheckSheafConsistency(sheaf, sections): + // Sheaf consistency: local sections should agree on overlaps + + inconsistencies = [] + + // Check all pairs of overlapping sections + FOR (section_a, section_b) IN Pairs(sections): + overlap = section_a.domain.intersect(section_b.domain) + + IF overlap.is_empty(): + CONTINUE + + // Restriction maps + restricted_a = sheaf.restrict(section_a, overlap) + restricted_b = sheaf.restrict(section_b, overlap) + + // Check agreement + IF NOT ApproximatelyEqual(restricted_a, restricted_b, tolerance=EPSILON): + inconsistencies.append( + SheafInconsistency( + sections = (section_a, section_b), + overlap = overlap, + discrepancy = Distance(restricted_a, restricted_b) + ) + ) + + IF inconsistencies.is_empty(): + RETURN SheafConsistencyResult.Consistent + ELSE: + RETURN SheafConsistencyResult.Inconsistent(inconsistencies) +``` + +--- + +## 3. Temporal Memory Coordinator + +### 3.1 Causal Cone Query + +```pseudocode +FUNCTION CausalQuery(query, reference_time, cone_type, temporal_memory): + // Determine valid time range based on causal cone + SWITCH cone_type: + CASE Past: + time_range = (MIN_TIME, reference_time) + CASE Future: + time_range = (reference_time, MAX_TIME) + CASE LightCone(velocity): + // Relativistic constraint: |delta_x| <= c * |delta_t| + time_range = ComputeLightCone(reference_time, query.origin, velocity) + + // Filter candidates by time range + candidates = temporal_memory.long_term.filter_by_time(time_range) + + // Similarity search within temporal constraint + similarities = [] + FOR candidate IN candidates: + sim = CosineSimilarity(query.embedding, candidate.embedding) + causal_dist = temporal_memory.causal_graph.shortest_path( + query.origin, + candidate.id + ) + similarities.append((candidate, sim, causal_dist)) + + // Rank by combined temporal and causal relevance + scored = [] + FOR (candidate, sim, causal_dist) IN similarities: + temporal_score = 1.0 / (1.0 + abs(candidate.timestamp - reference_time)) + causal_score = 1.0 / (1.0 + causal_dist) IF causal_dist != INF ELSE 0.0 + + combined = ALPHA * sim + BETA * temporal_score + GAMMA * causal_score + scored.append((candidate, combined)) + + RETURN sorted(scored, by=combined, descending=True) +``` + +### 3.2 Memory Consolidation + +```pseudocode +FUNCTION Consolidate(temporal_memory): + // Biological-inspired memory consolidation + // Short-term -> Long-term with salience filtering + + // Compute salience for all short-term items + salience_scores = [] + FOR item IN temporal_memory.short_term: + salience = ComputeSalience(item, temporal_memory) + salience_scores.append((item, salience)) + + // Salience computation factors: + // - Frequency of access + // - Recency of access + // - Causal importance (how many things depend on it) + // - Surprise (deviation from expected) + + FUNCTION ComputeSalience(item, memory): + access_freq = memory.access_counts[item.id] + recency = 1.0 / (1.0 + (NOW() - item.last_accessed)) + causal_importance = memory.causal_graph.out_degree(item.id) + surprise = ComputeSurprise(item, memory.long_term) + + RETURN W1*access_freq + W2*recency + W3*causal_importance + W4*surprise + + // Filter by salience threshold + salient_items = [item FOR (item, s) IN salience_scores IF s > THRESHOLD] + + // Integrate into long-term (manifold deformation) + FOR item IN salient_items: + temporal_memory.long_term.manifold.deform(item, salience) + + // Strategic forgetting for low-salience items + FOR item IN temporal_memory.short_term: + IF item NOT IN salient_items: + // Don't integrate - let it decay + PASS + + // Clear short-term buffer + temporal_memory.short_term.clear() + + // Decay low-salience regions in long-term + temporal_memory.long_term.strategic_forget(DECAY_RATE) +``` + +### 3.3 Predictive Anticipation + +```pseudocode +FUNCTION Anticipate(hints, temporal_memory): + // Pre-compute likely future queries based on hints + // This enables "predictive retrieval before queries are issued" + + predicted_queries = [] + + FOR hint IN hints: + SWITCH hint.type: + CASE SequentialPattern: + // If A then B pattern detected + recent = temporal_memory.recent_queries() + FOR pattern IN temporal_memory.sequential_patterns: + IF pattern.matches_prefix(recent): + predicted = pattern.next_likely_query() + predicted_queries.append(predicted) + + CASE TemporalCycle: + // Time-of-day or periodic patterns + current_phase = GetTemporalPhase(NOW()) + historical = temporal_memory.queries_at_phase(current_phase) + predicted_queries.extend(historical.top_k(5)) + + CASE CausalChain: + // Causal dependencies predict next queries + current_context = hint.current_context + downstream = temporal_memory.causal_graph.downstream(current_context) + FOR node IN downstream: + predicted_queries.append(QueryFor(node)) + + // Pre-fetch and cache + FOR query IN predicted_queries: + cache_key = Hash(query) + IF cache_key NOT IN temporal_memory.prefetch_cache: + result = temporal_memory.long_term.search(query) + temporal_memory.prefetch_cache[cache_key] = result +``` + +--- + +## 4. Federated Cognitive Mesh + +### 4.1 Post-Quantum Federation Handshake + +```pseudocode +FUNCTION JoinFederation(local_node, peer_address): + // CRYSTALS-Kyber key exchange + + // Generate ephemeral keypair + (local_public, local_secret) = Kyber.KeyGen() + + // Send public key to peer + SendMessage(peer_address, FederationRequest(local_public)) + + // Receive peer's encapsulated shared secret + response = ReceiveMessage(peer_address) + ciphertext = response.ciphertext + + // Decapsulate to get shared secret + shared_secret = Kyber.Decapsulate(ciphertext, local_secret) + + // Derive session keys from shared secret + (encrypt_key, mac_key) = DeriveKeys(shared_secret) + + // Establish encrypted channel + channel = EncryptedChannel(peer_address, encrypt_key, mac_key) + + // Exchange capabilities and negotiate federation terms + local_caps = local_node.capabilities() + peer_caps = channel.exchange(local_caps) + + terms = NegotiateFederationTerms(local_caps, peer_caps) + + // Create federation token + token = FederationToken( + peer = peer_address, + channel = channel, + terms = terms, + expires = NOW() + TOKEN_VALIDITY + ) + + RETURN token +``` + +### 4.2 Onion-Routed Query + +```pseudocode +FUNCTION OnionQuery(query, destination, relay_nodes, local_keys): + // Privacy-preserving query routing through onion network + + // Build onion layers (innermost to outermost) + layers = [destination] + relay_nodes // Reverse order for wrapping + + // Start with plaintext query + current_payload = SerializeQuery(query) + + // Wrap in layers + FOR node IN layers: + // Encrypt with node's public key + encrypted = AsymmetricEncrypt(current_payload, node.public_key) + + // Add routing header + header = OnionHeader( + next_hop = node.address, + payload_type = "onion_layer" + ) + + current_payload = header + encrypted + + // Send to first relay + first_relay = relay_nodes.last() + SendMessage(first_relay, current_payload) + + // Receive response (also onion-wrapped) + encrypted_response = ReceiveMessage(first_relay) + + // Unwrap response layers + current_response = encrypted_response + FOR node IN reverse(relay_nodes): + current_response = AsymmetricDecrypt(current_response, local_keys.secret) + + // Final decryption with destination's response + result = DeserializeResponse(current_response) + + RETURN result +``` + +### 4.3 CRDT Reconciliation + +```pseudocode +FUNCTION ReconcileCRDT(responses, local_state): + // Conflict-free merge of federated query results + + // Use G-Set CRDT for search results (grow-only set) + merged_results = GSet() + + FOR response IN responses: + FOR result IN response.results: + // G-Set merge: union operation + merged_results.add(result) + + // For rankings, use LWW-Register (last-writer-wins) + ranking_map = LWWMap() + + FOR response IN responses: + FOR (result_id, score, timestamp) IN response.rankings: + ranking_map.set(result_id, score, timestamp) + + // Combine: results from G-Set, scores from LWW-Map + final_results = [] + FOR result IN merged_results: + score = ranking_map.get(result.id) + final_results.append((result, score)) + + // Sort by reconciled scores + final_results.sort(by=score, descending=True) + + RETURN final_results +``` + +### 4.4 Byzantine Fault Tolerant Commit + +```pseudocode +FUNCTION ByzantineCommit(update, federation): + // PBFT-style consensus for state updates + n = federation.node_count() + f = (n - 1) / 3 // Maximum Byzantine faults tolerable + threshold = 2*f + 1 // Required agreement + + // Phase 1: Pre-prepare (leader proposes) + IF federation.is_leader(): + proposal = SignedProposal(update, sequence_number=NEXT_SEQ) + Broadcast(federation.nodes, PrePrepare(proposal)) + + // Phase 2: Prepare (nodes acknowledge receipt) + pre_prepare = ReceivePrePrepare() + IF ValidateProposal(pre_prepare): + prepare_msg = Prepare(pre_prepare.digest, federation.local_id) + Broadcast(federation.nodes, prepare_msg) + + // Collect prepare messages + prepares = CollectMessages(type=Prepare, count=threshold) + + IF len(prepares) < threshold: + RETURN CommitResult.InsufficientPrepares + + // Phase 3: Commit (nodes commit to proposal) + commit_msg = Commit(pre_prepare.digest, federation.local_id) + Broadcast(federation.nodes, commit_msg) + + // Collect commit messages + commits = CollectMessages(type=Commit, count=threshold) + + IF len(commits) >= threshold: + // Execute update + federation.apply_update(update) + proof = CommitProof(commits) + RETURN CommitResult.Success(proof) + ELSE: + RETURN CommitResult.InsufficientCommits +``` + +--- + +## 5. Backend Abstraction + +### 5.1 Backend Selection + +```pseudocode +FUNCTION SelectBackend(requirements, available_backends): + // Automatic backend selection based on requirements + + scored_backends = [] + + FOR backend IN available_backends: + score = 0.0 + + // Evaluate against requirements + IF requirements.latency_target: + latency_score = 1.0 / backend.expected_latency + score += W_LATENCY * latency_score + + IF requirements.energy_target: + energy_score = 1.0 / backend.expected_energy + score += W_ENERGY * energy_score + + IF requirements.accuracy_target: + accuracy_score = backend.expected_accuracy + score += W_ACCURACY * accuracy_score + + IF requirements.scale_target: + scale_score = backend.max_scale / requirements.scale_target + score += W_SCALE * min(scale_score, 1.0) + + // Check hard constraints + IF requirements.wasm_required AND NOT backend.supports_wasm: + CONTINUE + + IF requirements.post_quantum_required AND NOT backend.supports_pq: + CONTINUE + + scored_backends.append((backend, score)) + + // Select highest scoring backend + best_backend = max(scored_backends, by=score) + + RETURN best_backend +``` + +### 5.2 Hybrid Execution + +```pseudocode +FUNCTION HybridExecute(operation, backends): + // Execute across multiple backends, combine results + + // Partition operation if possible + partitions = PartitionOperation(operation) + + // Assign partitions to backends based on suitability + assignments = [] + FOR partition IN partitions: + best_backend = SelectBackendForPartition(partition, backends) + assignments.append((partition, best_backend)) + + // Execute in parallel + futures = [] + FOR (partition, backend) IN assignments: + future = backend.execute_async(partition) + futures.append(future) + + // Await all results + results = AwaitAll(futures) + + // Merge partition results + merged = MergePartitionResults(results, operation.type) + + RETURN merged +``` + +--- + +## 6. Consciousness Metrics (Research) + +### 6.1 Phi (Integrated Information) Approximation + +```pseudocode +FUNCTION ApproximatePhi(substrate_region): + // Compute integrated information (IIT-inspired) + // Full Phi computation is intractable; this is an approximation + + // Step 1: Compute whole-system effective information + whole_state = substrate_region.current_state() + perturbed_states = [] + FOR _ IN 1..NUM_PERTURBATIONS: + perturbed = ApplyRandomPerturbation(whole_state) + evolved = substrate_region.evolve(perturbed) + perturbed_states.append(evolved) + + whole_EI = MutualInformation(whole_state, perturbed_states) + + // Step 2: Find minimum information partition (MIP) + partitions = GeneratePartitions(substrate_region) + min_partition_EI = INFINITY + + FOR partition IN partitions: + partition_EI = 0.0 + FOR part IN partition: + part_state = part.current_state() + part_perturbed = [ApplyRandomPerturbation(part_state) FOR _ IN 1..NUM_PERTURBATIONS] + part_evolved = [part.evolve(p) FOR p IN part_perturbed] + partition_EI += MutualInformation(part_state, part_evolved) + + IF partition_EI < min_partition_EI: + min_partition_EI = partition_EI + mip = partition + + // Step 3: Phi = whole - minimum partition + phi = whole_EI - min_partition_EI + + RETURN max(phi, 0.0) // Phi cannot be negative +``` + +--- + +## Summary + +These pseudocode algorithms define the core computational patterns for the EXO-AI cognitive substrate: + +| Component | Key Algorithm | Complexity | +|-----------|---------------|------------| +| Manifold Engine | Gradient descent retrieval | O(k × d × steps) | +| Hypergraph | Persistent homology | O(n³) worst case | +| Temporal Memory | Causal cone query | O(n × log n) | +| Federation | Byzantine consensus | O(n²) messages | +| Phi Metric | Partition enumeration | O(B(n)) Bell numbers | + +Where: +- k = number of results +- d = embedding dimension +- n = number of entities/nodes +- steps = gradient descent iterations diff --git a/examples/exo-ai-2025/docs/README.md b/examples/exo-ai-2025/docs/README.md new file mode 100644 index 00000000..fdb78b28 --- /dev/null +++ b/examples/exo-ai-2025/docs/README.md @@ -0,0 +1,275 @@ +# EXO-AI 2025: Exocortex Substrate Research Platform + +## Overview + +EXO-AI 2025 is a research-oriented experimental platform exploring the technological horizons of cognitive substrates projected for 2035-2060. This project consumes the ruvector ecosystem as an SDK without modifying existing crates. + +**Status**: Research & Design Phase (No Implementation) + +--- + +## Vision: The Substrate Dissolution + +By 2035-2040, the von Neumann bottleneck finally breaks. Processing-in-memory architectures mature. Vector operations execute where data resides. The distinction between "database" and "compute" becomes meaningless at the hardware level. + +This research platform investigates the path from current vector database technology to: + +- **Learned Manifolds**: Continuous neural representations replacing discrete indices +- **Cognitive Topologies**: Hypergraph substrates with topological queries +- **Temporal Consciousness**: Memory with causal structure and predictive retrieval +- **Federated Intelligence**: Distributed meshes with cryptographic sovereignty +- **Substrate Metabolism**: Autonomous optimization, consolidation, and forgetting + +--- + +## Project Structure + +``` +exo-ai-2025/ +├── docs/ +│ └── README.md # This file +├── specs/ +│ └── SPECIFICATION.md # SPARC Phase 1: Requirements & Use Cases +├── research/ +│ ├── PAPERS.md # Academic papers catalog (75+ papers) +│ └── RUST_LIBRARIES.md # Rust crates assessment +└── architecture/ + ├── ARCHITECTURE.md # SPARC Phase 3: System design + └── PSEUDOCODE.md # SPARC Phase 2: Algorithm design +``` + +--- + +## SPARC Methodology Applied + +### Phase 1: Specification (`specs/SPECIFICATION.md`) +- Problem domain analysis +- Functional requirements (FR-001 through FR-007) +- Non-functional requirements +- Use case scenarios + +### Phase 2: Pseudocode (`architecture/PSEUDOCODE.md`) +- Manifold retrieval via gradient descent +- Persistent homology computation +- Causal cone queries +- Byzantine fault tolerant consensus +- Consciousness metrics (Phi approximation) + +### Phase 3: Architecture (`architecture/ARCHITECTURE.md`) +- Layer architecture design +- Module definitions with Rust code examples +- Backend abstraction traits +- WASM/NAPI-RS integration patterns +- Deployment configurations + +### Phase 4 & 5: Implementation (Future) +Not in scope for this research phase. + +--- + +## Research Domains + +### 1. Processing-in-Memory (PIM) + +Key findings from 2024-2025 research: + +| Paper | Contribution | +|-------|--------------| +| UPMEM Architecture | First commercial PIM: 23x GPU performance | +| DB-PIM Framework | Value + bit-level sparsity optimization | +| 16Mb ReRAM Macro | 31.2 TFLOPS/W efficiency | + +**Implication**: Vector operations will execute in memory banks, not transferred to processors. + +### 2. Neuromorphic & Photonic Computing + +| Technology | Characteristics | +|------------|-----------------| +| Spiking Neural Networks | 1000x energy reduction potential | +| Silicon Photonics (MIT 2024) | Sub-nanosecond classification, 92% accuracy | +| Hundred-Layer Photonic (2025) | 200+ layer depth via SLiM chip | + +**Implication**: HNSW indices become firmware primitives, not software libraries. + +### 3. Implicit Neural Representations + +| Approach | Use Case | +|----------|----------| +| SIREN | Sinusoidal activations for continuous signals | +| FR-INR (CVPR 2024) | Fourier reparameterization for training | +| inr2vec | Compact latent space for INR retrieval | + +**Implication**: Storage becomes model parameters, not data structures. + +### 4. Hypergraph & Topological Deep Learning + +| Library | Capability | +|---------|------------| +| TopoX Suite | Topological neural networks (Python) | +| simplicial_topology | Simplicial complexes (Rust) | +| teia | Persistent homology (Rust) | + +**Implication**: Queries become topological specifications, not keyword matches. + +### 5. Temporal Memory + +| System | Innovation | +|--------|------------| +| Mem0 (2024) | Causal relationships for agent decision-making | +| Zep/Graphiti (2025) | Temporal knowledge graphs for agent memory | +| TKGs | Causality tracking, pattern recognition | + +**Implication**: Agents anticipate before queries are issued. + +### 6. Federated & Quantum-Resistant Systems + +| Technology | Status | +|------------|--------| +| CRYSTALS-Kyber (ML-KEM) | NIST standardized (FIPS 203) | +| pqcrypto (Rust) | Production-ready PQ library | +| CRDTs | Conflict-free eventual consistency | + +**Implication**: Trust boundaries with cryptographic sovereignty. + +--- + +## Rust Ecosystem Assessment + +### Production-Ready (Use Now) + +| Crate | Purpose | +|-------|---------| +| **burn** | Backend-agnostic tensor/DL framework | +| **candle** | Transformer inference | +| **petgraph** | Graph algorithms | +| **pqcrypto** | Post-quantum cryptography | +| **wasm-bindgen** | WASM integration | +| **napi-rs** | Node.js bindings | + +### Research-Ready (Extend) + +| Crate | Purpose | Gap | +|-------|---------|-----| +| **simplicial_topology** | TDA primitives | Need hypergraph extension | +| **teia** | Persistent homology | Feature-incomplete | +| **tda** | Neuroscience TDA | Domain-specific | + +### Missing (Build) + +| Capability | Status | +|------------|--------| +| Tensor Train decomposition | Only PDE-focused library exists | +| Hypergraph neural networks | No Rust library | +| Neuromorphic simulation | No Rust library | +| Photonic simulation | No Rust library | + +--- + +## Technology Roadmap + +### Era 1: 2025-2035 (Transition) +``` +Current ruvector → PIM prototypes → Hybrid execution +├── Trait-based backend abstraction +├── Simulation modes for future hardware +└── Performance baseline establishment +``` + +### Era 2: 2035-2045 (Cognitive Topology) +``` +Discrete indices → Learned manifolds +├── INR-based storage +├── Tensor Train compression +├── Hypergraph substrate +└── Sheaf consistency +``` + +### Era 3: 2045-2060 (Post-Symbolic) +``` +Vector spaces → Universal latent spaces +├── Multi-modal unified encoding +├── Substrate metabolism +├── Federated consciousness meshes +└── Approaching thermodynamic limits +``` + +--- + +## Key Metrics Evolution + +| Era | Latency | Energy/Query | Scale | +|-----|---------|--------------|-------| +| 2025 | 1-10ms | ~1mJ | 10^9 vectors | +| 2035 | 1-100μs | ~1μJ | 10^12 vectors | +| 2045 | 1-100ns | ~1nJ | 10^15 vectors | + +--- + +## Dependencies (SDK Consumer) + +This project consumes ruvector crates without modification: + +```toml +[dependencies] +# Core ruvector SDK +ruvector-core = "0.1.16" +ruvector-graph = "0.1.16" +ruvector-gnn = "0.1.16" +ruvector-raft = "0.1.16" +ruvector-cluster = "0.1.16" +ruvector-replication = "0.1.16" + +# ML/Tensor +burn = { version = "0.14", features = ["wgpu", "ndarray"] } +candle-core = "0.6" + +# TDA/Topology +petgraph = "0.6" +simplicial_topology = "0.1" + +# Post-Quantum +pqcrypto = "0.18" +kyberlib = "0.0.6" + +# Platform bindings +wasm-bindgen = "0.2" +napi = "2.16" +napi-derive = "2.16" +``` + +--- + +## Theoretical Foundations + +### Integrated Information Theory (IIT) +Substrate consciousness measured via Φ (integrated information). Reentrant architecture with feedback loops required. + +### Landauer's Principle +Thermodynamic efficiency limit: ~0.018 eV per bit erasure at room temperature. Current systems operate 1000x above this limit. Reversible computing offers 4000x improvement potential. + +### Sheaf Theory +Local-to-global consistency framework. Neural sheaf diffusion learns sheaf structure from data. 8.5% improvement demonstrated on recommender systems. + +--- + +## Next Steps + +1. **Prototype Classical Backend**: Implement backend traits consuming ruvector SDK +2. **Simulation Framework**: Build neuromorphic/photonic simulators +3. **TDA Extension**: Extend simplicial_topology for hypergraph support +4. **Temporal Memory POC**: Implement causal cone queries +5. **Federation Scaffold**: Post-quantum handshake implementation + +--- + +## References + +Full paper catalog: `research/PAPERS.md` (75+ papers across 12 categories) +Rust library assessment: `research/RUST_LIBRARIES.md` (50+ crates evaluated) + +--- + +## License + +Research documentation released under MIT License. +Inherits licensing from ruvector ecosystem for any implementation code. diff --git a/examples/exo-ai-2025/research/PAPERS.md b/examples/exo-ai-2025/research/PAPERS.md new file mode 100644 index 00000000..1035f1ae --- /dev/null +++ b/examples/exo-ai-2025/research/PAPERS.md @@ -0,0 +1,274 @@ +# EXO-AI 2025: Research Papers & References + +## SPARC Research Phase: Academic Foundations + +This document catalogs the academic research informing the EXO-AI architecture, organized by domain. + +--- + +## 1. Processing-in-Memory (PIM) Architectures + +### Core Reviews + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [A Comprehensive Review of Processing-in-Memory Architectures for DNNs](https://www.mdpi.com/2073-431X/13/7/174) | MDPI Computers | 2024 | Chiplet-based PIM designs, dataflow optimization | +| [Neural-PIM: Efficient Processing-In-Memory](https://arxiv.org/pdf/2201.09861) | arXiv | 2022 | Neural network acceleration in DRAM | +| [PRIME: Processing-in-Memory for Neural Networks](https://ieeexplore.ieee.org/document/7551380/) | ISCA | 2016 | ReRAM-based crossbar computation | +| [PIMCoSim: Hardware/Software Co-Simulator](https://www.mdpi.com/2079-9292/13/23/4795) | MDPI Electronics | 2024 | Simulation framework for PIM exploration | + +### Key Findings +- UPMEM achieves 23x performance over GPU when memory oversubscription required +- SRAM-PIM with value-level and bit-level sparsity (DB-PIM framework) +- ReRAM crossbars enable ~10x gain over SRAM-based accelerators + +### UPMEM Architecture +First commercially available PIM: DRAM + in-order cores (DPUs) on same chip. + +--- + +## 2. Neuromorphic Computing & Vector Search + +### Neuromorphic Hardware + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [Roadmap to Neuromorphic Computing with Emerging Technologies](https://arxiv.org/html/2407.02353v1) | arXiv | 2024 | Technology roadmap for neuromorphic systems | +| [Neuromorphic Computing for Robotic Vision](https://www.nature.com/articles/s44172-025-00492-5) | Nature Comm. Eng. | 2025 | Event-driven vision processing | +| [Survey of Neuromorphic Computing and Neural Networks in Hardware](https://arxiv.org/pdf/1705.06963) | arXiv | 2017 | Comprehensive hardware survey | + +### Key Hardware Platforms +- **SpiNNaker**: Millions of processing cores (Manchester) +- **TrueNorth**: IBM's commercial neuromorphic chip +- **Loihi**: Intel research chip with online learning +- **BrainScaleS**: European analog-digital hybrid + +### HNSW Advances + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [Down with the Hierarchy: Hub Highway Hypothesis](https://arxiv.org/html/2412.01940v2) | arXiv | 2024 | Hubs maintain hierarchy function, not layers | +| [Efficient Vector Search on Disaggregated Memory (d-HNSW)](https://arxiv.org/html/2505.11783v1) | arXiv | 2025 | Disaggregated memory architecture | +| [WebANNS: ANN Search in Web Browsers](https://arxiv.org/html/2507.00521) | arXiv | 2025 | Browser-based vector search | + +--- + +## 3. Implicit Neural Representations (INR) + +### Core Research + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [Where Do We Stand with INRs? Technical Survey](https://arxiv.org/html/2411.03688v1) | arXiv | 2024 | Four-category taxonomy of INR techniques | +| [FR-INR: Fourier Reparameterized Training](https://github.com/LabShuHangGU/FR-INR) | CVPR | 2024 | Fourier bases for MLP weight composition | +| [Neural Experts: Mixture of Experts for INRs](https://neurips.cc/virtual/2024/poster/93148) | NeurIPS | 2024 | MoE for local piece-wise continuous functions | +| [inr2vec: Compact Latent Representation for INRs](https://cvlab-unibo.github.io/inr2vec/) | CVPR | 2023 | Embeddings for INR-based retrieval | + +### Key INR Methods +- **SIREN**: Sinusoidal activation networks +- **WIRE**: Wavelet implicit representations +- **GAUSS**: Gaussian activation functions +- **FINER**: Frequency-enhanced representations + +### Retrieval Performance +inr2vec shows 1.8 mAP gap vs PointNet++ on 3D retrieval benchmarks. + +--- + +## 4. Hypergraph & Topological Data Analysis + +### Hypergraph Neural Networks + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [EasyHypergraph: Fast Higher-Order Network Analysis](https://www.nature.com/articles/s41599-025-05180-5) | Nature HSS Comm. | 2025 | Memory-efficient hypergraph analysis | +| [DPHGNN: Dual Perspective Hypergraph Neural Networks](https://dl.acm.org/doi/10.1145/3637528.3672047) | KDD | 2024 | Dual-perspective message passing | +| [Hypergraph Computation Survey](https://www.sciencedirect.com/science/article/pii/S2095809924002510) | Engineering | 2024 | Comprehensive hypergraph computation survey | + +### Topological Deep Learning + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [Topological Deep Learning: New Frontier for Relational Learning](https://pmc.ncbi.nlm.nih.gov/articles/PMC11973457/) | PMC | 2024 | Position paper on TDL paradigm | +| [ICML TDL Challenge 2024: Beyond the Graph Domain](https://arxiv.org/html/2409.05211v1) | ICML | 2024 | 52 submissions on topological liftings | +| [Simplicial Homology Theories for Hypergraphs](https://arxiv.org/html/2409.18310) | arXiv | 2024 | Survey of hypergraph homology | + +### Key Software +- **TopoX Suite**: TopoNetX, TopoEmbedX, TopoModelX (Python) +- **DHG**: DeepHypergraph for learning on hypergraphs +- **HyperNetX**: Hypergraph computations +- **XGI**: Hypergraphs and simplicial complexes + +--- + +## 5. Temporal Memory & Causal Inference + +### Agent Memory Architectures + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [Mem0: Production-Ready AI Agents with Scalable LTM](https://arxiv.org/pdf/2504.19413) | arXiv | 2024 | Causal relationships for decision-making | +| [Zep: Temporal Knowledge Graph for Agent Memory](https://arxiv.org/html/2501.13956v1) | arXiv | 2025 | TKG-based memory with Graphiti engine | +| [Memory Architectures in Long-Term AI Agents](https://www.researchgate.net/publication/388144017) | ResearchGate | 2025 | 47% improvement in temporal reasoning | +| [Evaluating Very Long-Term Conversational Memory](https://www.researchgate.net/publication/384220784) | ResearchGate | 2024 | Long-term temporal/causal dynamics | + +### Key Findings +- Zep outperforms MemGPT on Deep Memory Retrieval benchmark +- Mem0g adds graph-based memory representations +- TKGs model relationship start/change/end for causality tracking + +### Causal Inference + Deep Learning + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [Causal Inference Meets Deep Learning: Survey](https://pmc.ncbi.nlm.nih.gov/articles/PMC11384545/) | PMC | 2024 | PFC working memory for causal reasoning | + +--- + +## 6. Federated Learning & Distributed Consensus + +### Federated Learning + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [Secure and Fair Federated Learning via Consensus Incentive](https://www.mdpi.com/2227-7390/12/19/3068) | MDPI Mathematics | 2024 | Byzantine-resistant FL | +| [FL Assisted Distributed Energy Optimization](https://ietresearch.onlinelibrary.wiley.com/doi/10.1049/rpg2.13101) | IET RPG | 2024 | Consensus + innovations approach | +| [Comprehensive Review of FL Challenges](https://link.springer.com/article/10.1186/s40537-025-01195-6) | J. Big Data | 2025 | Data preparation viewpoint | + +### CRDT Fundamentals + +| Resource | Key Contribution | +|----------|------------------| +| [CRDT Dictionary: Field Guide](https://www.iankduncan.com/engineering/2025-11-27-crdt-dictionary) | Comprehensive CRDT taxonomy | +| [CRDT Wiki (Dremio)](https://www.dremio.com/wiki/conflict-free-replicated-data-type/) | Strong eventual consistency | + +### Key Algorithms +- **HyFDCA**: Hybrid Federated Dual Coordinate Ascent (2024) +- **Gossip protocols** for decentralized aggregation +- **Version vectors** for causal tracking in CRDTs + +--- + +## 7. Photonic Computing + +### Silicon Photonics for AI + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [MIT Photonic Processor for Ultrafast AI](https://news.mit.edu/2024/photonic-processor-could-enable-ultrafast-ai-computations-1202) | MIT News | 2024 | Sub-nanosecond classification, 92% accuracy | +| [Silicon Photonics for Scalable AI Hardware](https://ieeephotonics.org/) | IEEE JSTQE | 2025 | Wafer-scale ONN integration | +| [Hundred-Layer Photonic Deep Learning](https://www.nature.com/articles/s41467-025-65356-0) | Nature Comm. | 2025 | SLiM chip: 200+ layer depth | +| [All-Optical CNN with Phase Change Materials](https://www.nature.com/articles/s41598-025-06259-4) | Sci. Reports | 2025 | GST-based active waveguides | + +### Key Characteristics +- Sub-nanosecond latency +- Minimal energy loss (photons don't generate heat like electrons) +- THz bandwidth potential +- 3.2 Tbps achieved on silicon slow-light modulator + +--- + +## 8. ReRAM & Memristor Computing + +### Analog In-Memory Compute + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [Programming Memristor Arrays with Arbitrary Precision](https://www.science.org/doi/10.1126/science.adi9405) | Science | 2024 | 16Mb floating-point RRAM, 31.2 TFLOPS/W | +| [Memristive Memory Augmented Neural Network](https://www.nature.com/articles/s41467-022-33629-7) | Nature Comm. | 2022 | Hashing and similarity search in crossbars | +| [Wafer-Scale Memristive Passive Crossbar](https://www.nature.com/articles/s41467-025-63831-2) | Nature Comm. | 2025 | Brain-scale neuromorphic computing | +| [4K-Memristor Analog-Grade Crossbar](https://www.nature.com/articles/s41467-021-25455-0) | Nature Comm. | 2021 | Foundational analog VMM work | + +### Vector Similarity Search +- TCAM functionality in analog crossbar +- Hamming distance via degree-of-mismatch output +- Massively parallel in-memory similarity computation + +--- + +## 9. Sheaf Theory & Category Theory for ML + +### Sheaf Neural Networks + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [Sheaf Theory: From Deep Geometry to Deep Learning](https://arxiv.org/html/2502.15476v1) | arXiv | 2025 | Comprehensive sheaf applications survey | +| [Sheaf4Rec: Recommender Systems](https://arxiv.org/abs/2304.09097) | arXiv | 2023 | 8.53% F1@10 improvement, 37% faster | +| [Sheaf Neural Networks with Connection Laplacians](https://proceedings.mlr.press/v196/barbero22a/barbero22a.pdf) | ICML | 2022 | Learnable sheaf Laplacians | +| [Categorical Deep Learning: Algebraic Theory of All Architectures](https://arxiv.org/abs/2402.15332) | arXiv | 2024 | Monads + 2-categories for neural networks | + +### Key Concepts +- **Sheaf**: Local-to-global consistency structure +- **Sheaf Laplacian**: Diffusion operator on sheaf-decorated graphs +- **Neural Sheaf Diffusion**: Learning sheaf structure from data + +--- + +## 10. Consciousness & Integrated Information + +### IIT Research + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [IIT 4.0: Phenomenal Existence in Physical Terms](https://pmc.ncbi.nlm.nih.gov/articles/PMC10581496/) | PLOS Comp. Bio. | 2023 | Updated axioms, postulates, measures | +| [How to be an IIT Theorist Without Losing Your Body](https://www.frontiersin.org/journals/computational-neuroscience/articles/10.3389/fncom.2024.1510066/full) | Frontiers | 2024 | Embodied IIT considerations | + +### Key Metrics +- **Φ (Phi)**: Integrated information measure +- **Reentrant architecture**: Feedback loops required for consciousness +- **Controversy**: Empirical testability debates (2023-2025) + +--- + +## 11. Thermodynamic Limits + +### Landauer Bound & Reversible Computing + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [Fundamental Energy Limits and Reversible Computing](https://www.osti.gov/servlets/purl/1458032) | Sandia | 2017 | DOE reversible computing roadmap | +| [Adiabatic Computing for Optimal Thermodynamic Efficiency](https://arxiv.org/abs/2302.09957) | arXiv | 2023 | Optimal information processing bounds | +| [Fundamental Energy Cost of Finite-Time Parallelizable Computing](https://www.nature.com/articles/s41467-023-36020-2) | Nature Comm. | 2023 | Parallelization thermodynamics | + +### Key Numbers +- Landauer limit: ~0.018 eV (2.9×10⁻²¹ J) per bit erasure at room temp +- Current CMOS: 1000x above theoretical minimum +- Reversible computing: 4000x efficiency potential +- Vaire Computing: Commercial reversible chips by 2027-2028 + +--- + +## 12. Multi-Modal Foundation Models + +### Unified Architectures + +| Paper | Venue | Year | Key Contribution | +|-------|-------|------|------------------| +| [Unified Multimodal Understanding and Generation](https://arxiv.org/pdf/2505.02567) | arXiv | 2025 | Any-to-any multimodal models | +| [Show-o: Single Transformer for Multimodal](https://github.com/showlab/Awesome-Unified-Multimodal-Models) | GitHub | 2024 | Unified understanding + generation | +| [Multi-Modal Latent Space Learning for CoT Reasoning](https://ojs.aaai.org/index.php/AAAI/article/view/29776/31338) | AAAI | 2024 | Chain-of-thought across modalities | + +### Key Models (2024-2025) +- **Chameleon**: Mixed-modal early fusion (Meta) +- **Emu3**: Next-token prediction for all modalities +- **Janus/JanusFlow**: Decoupled visual encoding +- **SEED-X**: Multi-granularity comprehension + +--- + +## Summary Statistics + +| Category | Papers Reviewed | Key Takeaway | +|----------|-----------------|--------------| +| PIM/Near-Memory | 8 | 23x GPU performance, commercial availability | +| Neuromorphic | 12 | 1000x energy reduction potential | +| INR/Learned Manifolds | 6 | Continuous representations for storage | +| Hypergraph/TDA | 10 | Higher-order relations, topological queries | +| Temporal Memory | 6 | TKGs for causal agent memory | +| Federated/CRDT | 5 | Decentralized consensus, eventual consistency | +| Photonic | 5 | Sub-ns latency, 92% accuracy demonstrated | +| Memristor | 5 | 31.2 TFLOPS/W efficiency | +| Sheaf/Category | 6 | 8.5% improvement on recommender tasks | +| Consciousness | 3 | IIT 4.0 framework, Φ measures | +| Thermodynamics | 4 | 4000x reversible computing potential | +| Multi-Modal | 5 | Unified latent spaces emerging | diff --git a/examples/exo-ai-2025/research/RUST_LIBRARIES.md b/examples/exo-ai-2025/research/RUST_LIBRARIES.md new file mode 100644 index 00000000..879ff483 --- /dev/null +++ b/examples/exo-ai-2025/research/RUST_LIBRARIES.md @@ -0,0 +1,376 @@ +# EXO-AI 2025: Rust Libraries & Crates Catalog + +## SPARC Research Phase: Implementation Building Blocks + +This document catalogs Rust crates and libraries applicable to the EXO-AI cognitive substrate architecture. + +--- + +## 1. Tensor & Neural Network Frameworks + +### Primary Frameworks + +| Crate | Description | WASM | no_std | Use Case | +|-------|-------------|------|--------|----------| +| **[burn](https://lib.rs/crates/burn)** | Next-gen DL framework with backend flexibility | ✅ | ✅ | Core tensor operations, model training | +| **[candle](https://github.com/huggingface/candle)** | HuggingFace minimalist ML framework | ✅ | ❌ | Transformer inference, production models | +| **[ndarray](https://lib.rs/crates/ndarray)** | N-dimensional arrays | ❌ | ❌ | General numerical computing | +| **[burn-candle](https://crates.io/crates/burn-candle)** | Burn backend using Candle | ✅ | ❌ | Unified interface over Candle | +| **[burn-ndarray](https://crates.io/crates/burn-ndarray)** | Burn backend using ndarray | ❌ | ✅ | CPU-only, embedded targets | + +### Key Characteristics + +**Burn Framework**: +```rust +// Burn's backend flexibility enables future hardware abstraction +use burn::backend::Wgpu; // GPU via WebGPU +use burn::backend::NdArray; // CPU via ndarray +use burn::backend::Candle; // HuggingFace models + +// Example: Backend-agnostic tensor operation +fn matmul(a: Tensor, b: Tensor) -> Tensor { + a.matmul(b) +} +``` + +**Candle Strengths**: +- Transformer-specific optimizations +- ONNX model loading +- Quantization support (INT8, BF16) +- ~429KB WASM binary for BERT-style models + +### Tensor Train Decomposition + +| Crate/Paper | Description | Status | +|-------------|-------------|--------| +| [Functional TT Library (Springer 2024)](https://link.springer.com/chapter/10.1007/978-3-031-56208-2_22) | Function-Train decomposition in Rust | Research | + +**Note**: This appears to be the only Rust-specific Tensor Train implementation, focused on PDEs rather than neural network compression. Opportunity exists for TT decomposition crate targeting learned manifold storage. + +--- + +## 2. Graph & Hypergraph Libraries + +### Core Graph Libraries + +| Crate | Description | Features | Use Case | +|-------|-------------|----------|----------| +| **[petgraph](https://github.com/petgraph/petgraph)** | Primary Rust graph library | Graph/StableGraph/GraphMap, algorithms | Base graph operations | +| **[simplicial_topology](https://lib.rs/crates/simplicial_topology)** | Simplicial complexes | Random generation (Linial-Meshulam), upward/downward closure | TDA primitives | + +### petgraph Capabilities +```rust +use petgraph::Graph; +use petgraph::algo::{toposort, kosaraju_scc, tarjan_scc}; + +// Topological sort for dependency ordering +let sorted = toposort(&graph, None)?; + +// Strongly connected components for hyperedge detection +let sccs = kosaraju_scc(&graph); +``` + +### Simplicial Complex Operations +```toml +[dependencies] +simplicial_topology = { version = "0.1.1", features = ["sc_plot"] } +``` + +**Supported Models**: +- Linial-Meshulam (random hypergraphs) +- Lower/Upper closure +- Pure simplicial complexes + +### Gap Analysis +No dedicated Rust hypergraph crate exists. Current approach: +1. Use petgraph for base graph operations +2. Extend with simplicial_topology for TDA +3. Implement hyperedge layer consuming ruvector-graph + +--- + +## 3. Topological Data Analysis + +### Persistent Homology + +| Crate | Description | Features | +|-------|-------------|----------| +| **[tda](https://crates.io/crates/tda)** | TDA for neuroscience | Persistence diagrams, Mapper algorithm | +| **[teia](https://crates.io/crates/teia)** | Persistent homology library | Column reduction, persistence pairing | +| **[annembed](https://lib.rs/crates/annembed)** | UMAP-style dimension reduction | Links to Julia Ripserer.jl for TDA | + +### tda Crate Structure +```rust +use tda::simplicial_complex::SimplicialComplex; +use tda::persistence::PersistenceDiagram; +use tda::mapper::Mapper; + +// Compute persistent homology +let complex = SimplicialComplex::from_point_cloud(&points, epsilon); +let diagram = complex.persistence_diagram(); +``` + +### teia CLI +```bash +# Compute homology generators +teia homology complex.json + +# Compute persistent homology +teia persistence complex.json +``` + +**Planned Features** (teia): +- Persistent cohomology +- Lower-star complex +- Vietoris-Rips complex + +--- + +## 4. WASM & NAPI-RS Integration + +### WASM Ecosystem + +| Crate | Description | Use Case | +|-------|-------------|----------| +| **[wasm-bindgen](https://crates.io/crates/wasm-bindgen)** | JS/Rust interop | Browser deployment | +| **[wasm-bindgen-futures](https://crates.io/crates/wasm-bindgen-futures)** | Async WASM | Async vector operations | +| **[web-sys](https://crates.io/crates/web-sys)** | Web APIs | Worker threads, WebGPU | +| **[js-sys](https://crates.io/crates/js-sys)** | JS types | ArrayBuffer interop | + +### NAPI-RS for Node.js + +| Crate | Description | Use Case | +|-------|-------------|----------| +| **[napi](https://crates.io/crates/napi)** | Node.js bindings | Server-side deployment | +| **[napi-derive](https://crates.io/crates/napi-derive)** | Macro support | Ergonomic API generation | + +### Integration Pattern (ruvector style) +```rust +// NAPI-RS binding example +#[napi] +pub struct VectorIndex { + inner: Arc>, +} + +#[napi] +impl VectorIndex { + #[napi(constructor)] + pub fn new(dimensions: u32) -> Result { ... } + + #[napi] + pub async fn search(&self, query: Float32Array, k: u32) -> Result { ... } +} +``` + +### WASM Neural Network Inference + +| Tool | Description | Size | +|------|-------------|------| +| **WasmEdge WASI-NN** | TensorFlow/ONNX in WASM | Container: ~4MB | +| **Tract** | Native ONNX inference engine | Binary: ~500KB | +| **EdgeBERT** | Custom BERT inference | ~429KB WASM + 30MB model | + +--- + +## 5. Post-Quantum Cryptography + +### Primary Libraries + +| Crate | Description | Algorithms | +|-------|-------------|------------| +| **[pqcrypto](https://github.com/rustpq/pqcrypto)** | Post-quantum crypto | Multiple NIST candidates | +| **[liboqs-rust](https://github.com/open-quantum-safe/liboqs-rust)** | OQS bindings | Full liboqs suite | +| **[kyberlib](https://kyberlib.com/)** | CRYSTALS-Kyber | ML-KEM (FIPS 203) | + +### NIST Standardized Algorithms +```rust +// Kyber example (key encapsulation) +use kyberlib::{keypair, encapsulate, decapsulate}; + +let (public_key, secret_key) = keypair()?; +let (ciphertext, shared_secret_a) = encapsulate(&public_key)?; +let shared_secret_b = decapsulate(&ciphertext, &secret_key)?; +assert_eq!(shared_secret_a, shared_secret_b); +``` + +### Algorithm Support +- **ML-KEM** (Kyber): Key encapsulation +- **ML-DSA** (Dilithium): Digital signatures +- **FALCON**: Alternative signatures +- **SPHINCS+**: Hash-based signatures + +--- + +## 6. Distributed Systems & Consensus + +### Consensus Primitives + +| Crate | Description | Use Case | +|-------|-------------|----------| +| **ruvector-raft** | Raft consensus | Leader election, log replication | +| **ruvector-cluster** | Cluster management | Node discovery, sharding | +| **ruvector-replication** | Data replication | Multi-region sync | + +### CRDT Candidates + +| Crate | Description | Status | +|-------|-------------|--------| +| **[crdts](https://crates.io/crates/crdts)** | CRDT implementations | Production-ready | +| **[automerge](https://crates.io/crates/automerge)** | JSON CRDT | Collaborative editing | + +### ruvector Integration +```rust +// Existing ruvector-raft capabilities +use ruvector_raft::{RaftNode, RaftConfig}; +use ruvector_cluster::{ClusterManager, NodeDiscovery}; + +let config = RaftConfig::default() + .with_election_timeout(Duration::from_millis(150)) + .with_heartbeat_interval(Duration::from_millis(50)); + +let node = RaftNode::new(config, storage)?; +``` + +--- + +## 7. Performance & SIMD + +### SIMD Libraries + +| Crate | Description | Use Case | +|-------|-------------|----------| +| **[simsimd](https://crates.io/crates/simsimd)** | SIMD similarity functions | Distance metrics | +| **[packed_simd_2](https://crates.io/crates/packed_simd_2)** | Portable SIMD | General vectorization | +| **[wide](https://crates.io/crates/wide)** | Wide SIMD types | AVX-512 operations | + +### ruvector Usage +```rust +// simsimd for distance calculations (already in ruvector-core) +use simsimd::{cosine, euclidean, dot}; + +let similarity = cosine(&vec_a, &vec_b); +let distance = euclidean(&vec_a, &vec_b); +``` + +### Parallelism + +| Crate | Description | Use Case | +|-------|-------------|----------| +| **[rayon](https://crates.io/crates/rayon)** | Data parallelism | Parallel iterators | +| **[crossbeam](https://crates.io/crates/crossbeam)** | Concurrency primitives | Lock-free structures | +| **[tokio](https://crates.io/crates/tokio)** | Async runtime | Async I/O, networking | + +--- + +## 8. Serialization & Storage + +### Serialization + +| Crate | Description | Speed | Size | +|-------|-------------|-------|------| +| **[rkyv](https://crates.io/crates/rkyv)** | Zero-copy deserialization | Fastest | Moderate | +| **[bincode](https://crates.io/crates/bincode)** | Binary serialization | Fast | Small | +| **[serde](https://crates.io/crates/serde)** | Serialization framework | Varies | Varies | + +### Storage Backends + +| Crate | Description | Use Case | +|-------|-------------|----------| +| **[redb](https://crates.io/crates/redb)** | Embedded ACID database | Persistent storage | +| **[memmap2](https://crates.io/crates/memmap2)** | Memory mapping | Large file access | +| **[hnsw_rs](https://crates.io/crates/hnsw_rs)** | HNSW index | Vector similarity | + +--- + +## 9. Emerging Research Libraries + +### Neuromorphic Simulation + +| Status | Description | Gap | +|--------|-------------|-----| +| ⚠️ Limited | No mature Rust SNN library | Opportunity | + +**Current Options**: +- Bind to C++ Brian2/NEST via FFI +- Port key algorithms from Python implementations +- Build minimal spike encoding layer + +### Photonic Simulation + +| Status | Description | Gap | +|--------|-------------|-----| +| ⚠️ None | No Rust photonic neural network library | Major gap | + +**Approach**: Abstract optical matrix-multiply as backend trait + +### Memristor Simulation + +| Status | Description | Gap | +|--------|-------------|-----| +| ⚠️ None | No Rust memristor crossbar simulation | Research opportunity | + +--- + +## 10. Recommended Stack for EXO-AI + +### Core Foundation (ruvector SDK) +```toml +[dependencies] +ruvector-core = "0.1.16" +ruvector-graph = "0.1.16" +ruvector-gnn = "0.1.16" +ruvector-raft = "0.1.16" +ruvector-cluster = "0.1.16" +``` + +### ML/Tensor Operations +```toml +burn = { version = "0.14", features = ["wgpu", "ndarray"] } +candle-core = "0.6" +ndarray = { version = "0.16", features = ["serde"] } +``` + +### TDA/Topology +```toml +petgraph = "0.6" +simplicial_topology = "0.1" +teia = "0.1" +tda = "0.1" +``` + +### Post-Quantum Security +```toml +pqcrypto = "0.18" +kyberlib = "0.0.6" +``` + +### WASM/NAPI +```toml +wasm-bindgen = "0.2" +napi = { version = "2.16", features = ["napi9", "async", "tokio_rt"] } +napi-derive = "2.16" +``` + +### Distribution +```toml +tokio = { version = "1.41", features = ["full"] } +rayon = "1.10" +crossbeam = "0.8" +``` + +--- + +## Library Maturity Assessment + +| Category | Maturity | Notes | +|----------|----------|-------| +| Tensors/ML | 🟢 High | Burn, Candle production-ready | +| Graphs | 🟢 High | petgraph is mature | +| Hypergraphs | 🟡 Medium | Need to build on simplicial_topology | +| TDA | 🟡 Medium | tda/teia usable, feature-incomplete | +| PQ Crypto | 🟢 High | Multiple options, NIST standardized | +| WASM | 🟢 High | wasm-bindgen ecosystem mature | +| NAPI-RS | 🟢 High | ruvector already uses successfully | +| Neuromorphic | 🔴 Low | Major gap, build or bind | +| Photonic | 🔴 Low | No existing libraries | +| Memristor | 🔴 Low | Research prototype needed | diff --git a/examples/exo-ai-2025/research/TECHNOLOGY_HORIZONS.md b/examples/exo-ai-2025/research/TECHNOLOGY_HORIZONS.md new file mode 100644 index 00000000..4004d2fa --- /dev/null +++ b/examples/exo-ai-2025/research/TECHNOLOGY_HORIZONS.md @@ -0,0 +1,396 @@ +# Technology Horizons: 2035-2060 + +## Future Computing Paradigm Analysis + +This document synthesizes research on technological trajectories relevant to cognitive substrates. + +--- + +## 1. Compute-Memory Unification (2035-2040) + +### The Von Neumann Bottleneck Dissolution + +The separation of processing and memory—the defining characteristic of conventional computers—becomes the primary limitation for cognitive workloads. + +**Current State (2025)**: +- Memory bandwidth: ~900 GB/s (HBM3) +- Energy: ~10 pJ per byte moved +- Latency: ~100 ns to access DRAM + +**Projected (2035)**: +- In-memory compute: 0 bytes moved for local operations +- Energy: <1 pJ per operation +- Latency: ~1 ns for in-memory operations + +### Processing-in-Memory Technologies + +| Technology | Maturity | Characteristics | +|------------|----------|-----------------| +| **UPMEM DPUs** | Commercial (2024) | First production PIM, 23x GPU for memory-bound | +| **ReRAM Crossbars** | Research | Analog VMM, 31.2 TFLOPS/W demonstrated | +| **SRAM-PIM** | Research | DB-PIM with sparsity optimization | +| **MRAM-PIM** | Research | Non-volatile, radiation-hard | + +### Implications for Vector Databases + +``` +Today: 2035: +┌─────────┐ ┌─────────┐ ┌─────────────────────────────┐ +│ CPU │◄─┤ Memory │ │ Memory = Processor │ +└─────────┘ └─────────┘ │ ┌─────┐ ┌─────┐ ┌─────┐ │ + ▲ ▲ │ │Vec A│ │Vec B│ │Vec C│ │ + │ Transfer │ │ │ PIM │ │ PIM │ │ PIM │ │ + │ bottleneck │ │ └─────┘ └─────┘ └─────┘ │ + │ │ │ Similarity computed │ + ▼ ▼ │ where data resides │ + Latency Energy waste └─────────────────────────────┘ +``` + +--- + +## 2. Neuromorphic Computing + +### Spiking Neural Networks + +Biological neurons communicate via discrete spikes, not continuous activations. SNNs replicate this for: + +- **Sparse computation**: Only active neurons compute +- **Temporal encoding**: Information in spike timing +- **Event-driven**: No fixed clock, asynchronous + +**Energy Comparison**: +| Platform | Energy per Inference | +|----------|---------------------| +| GPU (A100) | ~100 mJ | +| TPU v4 | ~10 mJ | +| Loihi 2 | ~10 μJ | +| Theoretical SNN | ~1 μJ | + +### Hardware Platforms + +| Platform | Organization | Status | Scale | +|----------|--------------|--------|-------| +| **SpiNNaker 2** | Manchester | Production | 10M cores | +| **Loihi 2** | Intel | Research | 1M neurons | +| **TrueNorth** | IBM | Production | 1M neurons | +| **BrainScaleS-2** | EU HBP | Research | Analog acceleration | + +### Vector Search on Neuromorphic Hardware + +**Research Gap**: No existing work on HNSW/vector similarity on neuromorphic hardware. + +**Proposed Approach**: +1. Encode vectors as spike trains (population coding) +2. Similarity = spike train correlation +3. HNSW navigation as SNN inference + +--- + +## 3. Photonic Neural Networks + +### Silicon Photonics Advantages + +| Characteristic | Electronic | Photonic | +|----------------|------------|----------| +| Latency | ~ns | ~ps | +| Parallelism | Limited by wires | Wavelength multiplexing | +| Energy | Heat dissipation | Minimal loss | +| Matrix multiply | Sequential | Single pass through MZI | + +### Recent Breakthroughs + +**MIT Photonic Processor (December 2024)**: +- Sub-nanosecond classification +- 92% accuracy on ML tasks +- Fully integrated on silicon +- Commercial foundry compatible + +**SLiM Chip (November 2025)**: +- 200+ layer photonic neural network +- Overcomes analog error accumulation +- Spatial depth: millimeters → meters + +**All-Optical CNN (2025)**: +- GST phase-change waveguides +- Convolution + pooling + fully-connected +- 91.9% MNIST accuracy + +### Vector Search on Photonics + +**Opportunity**: Matrix-vector multiply is the core operation for both neural nets and similarity search. + +**Architecture**: +``` +Query Vector ──┐ + │ Mach-Zehnder +Weight Matrix ─┼──► Interferometer ──► Similarity Scores + │ Array + │ + Light ─┘ (parallel wavelengths) +``` + +--- + +## 4. Memory as Learned Manifold + +### The Paradigm Shift + +**Discrete Era (Today)**: +- Insert, update, delete operations +- Explicit indexing (HNSW, IVF) +- CRUD semantics + +**Continuous Era (2040+)**: +- Manifold deformation (no insert/delete) +- Implicit neural representation +- Gradient-based retrieval + +### Implicit Neural Representations + +**Core Idea**: Instead of storing data explicitly, train a neural network to represent the data. + +``` +Discrete Index: Learned Manifold: +┌─────────────────┐ ┌─────────────────┐ +│ Vec 1: [0.1,..] │ │ │ +│ Vec 2: [0.3,..] │ → │ f(x) = neural │ +│ Vec 3: [0.2,..] │ │ network │ +│ ... │ │ │ +└─────────────────┘ └─────────────────┘ + Query = gradient descent + Insert = weight update +``` + +### Tensor Train Compression + +**Problem**: High-dimensional manifolds are expensive. + +**Solution**: Tensor Train decomposition factorizes: + +``` +T[i₁, i₂, ..., iₙ] = G₁[i₁] × G₂[i₂] × ... × Gₙ[iₙ] +``` + +**Compression**: O(n × r² × d) vs O(d^n) for full tensor. + +**Springer 2024**: Rust library for Function-Train decomposition demonstrated for PDEs. + +--- + +## 5. Hypergraph Substrates + +### Beyond Pairwise Relations + +Graphs model pairwise relationships. Hypergraphs model arbitrary-arity relationships. + +``` +Graph: Hypergraph: +A ── B ┌─────────────────┐ +│ │ │ A, B, C, D │ ← single hyperedge +C ── D │ (team works │ + │ on project) │ +4 edges for └─────────────────┘ +4-way relationship 1 hyperedge +``` + +### Topological Data Analysis + +**Persistent Homology**: Find topological features (holes, voids) that persist across scales. + +**Betti Numbers**: Count features by dimension: +- β₀ = connected components +- β₁ = loops/tunnels +- β₂ = voids +- ... + +**Query Example**: +```cypher +-- Find conceptual gaps in knowledge structure +MATCH (concept_cluster) +RETURN persistent_homology(dimension=1, epsilon=[0.1, 1.0]) +-- Returns: 2 holes (unexplored concept connections) +``` + +### Sheaf Theory + +**Problem**: Distributed data needs local-to-global consistency. + +**Solution**: Sheaves provide mathematical framework for: +- Local sections (node-level data) +- Restriction maps (how data transforms between nodes) +- Gluing axiom (local consistency implies global consistency) + +**Application**: Sheaf neural networks achieve 8.5% improvement on recommender systems. + +--- + +## 6. Temporal Memory Architectures + +### Causal Structure + +**Current Systems**: Similarity-based retrieval ignores temporal/causal relationships. + +**Future Systems**: Every memory has: +- Timestamp +- Causal antecedents (what caused this) +- Causal descendants (what this caused) + +### Temporal Knowledge Graphs (TKGs) + +**Zep/Graphiti (2025)**: +- Outperforms MemGPT on Deep Memory Retrieval +- Temporal relations: start, change, end of relationships +- Causal cone queries + +### Predictive Retrieval + +**Anticipation**: Pre-fetch results before queries are issued. + +**Implementation**: +1. Detect sequential patterns in query history +2. Detect temporal cycles (time-of-day patterns) +3. Follow causal chains to predict next queries +4. Warm cache with predicted results + +--- + +## 7. Federated Cognitive Meshes + +### Post-Quantum Security + +**Threat**: Quantum computers break RSA, ECC by ~2035. + +**NIST Standardized Algorithms (2024)**: +| Algorithm | Purpose | Key Size | +|-----------|---------|----------| +| ML-KEM (Kyber) | Key encapsulation | 1184 bytes | +| ML-DSA (Dilithium) | Digital signatures | 2528 bytes | +| FALCON | Signatures (smaller) | 897 bytes | +| SPHINCS+ | Hash-based signatures | 64 bytes | + +### Federation Architecture + +``` + ┌─────────────────────┐ + │ Federation Layer │ + │ (onion routing) │ + └─────────────────────┘ + │ + ┌───────────────────┼───────────────────┐ + ▼ ▼ ▼ +┌───────────────┐ ┌───────────────┐ ┌───────────────┐ +│ Substrate A │ │ Substrate B │ │ Substrate C │ +│ (Trust Zone) │ │ (Trust Zone) │ │ (Trust Zone) │ +│ │ │ │ │ │ +│ Raft within │ │ Raft within │ │ Raft within │ +└───────────────┘ └───────────────┘ └───────────────┘ + │ │ │ + └───────────────────┼───────────────────┘ + │ + ┌───────▼───────┐ + │ CRDT Layer │ + │ (eventual │ + │ consistency)│ + └───────────────┘ +``` + +### CRDTs for Vector Data + +**Challenge**: Merge distributed vector search results without conflict. + +**Solution**: CRDT-based reconciliation: +- **G-Set**: Grow-only set for results (union merge) +- **LWW-Register**: Last-writer-wins for scores (timestamp merge) +- **OR-Set**: Observed-remove for deletions + +--- + +## 8. Thermodynamic Limits + +### Landauer's Principle + +**Minimum Energy per Bit Erasure**: +``` +E_min = k_B × T × ln(2) ≈ 0.018 eV at room temperature + ≈ 2.9 × 10⁻²¹ J +``` + +**Current Status**: +- Modern CMOS: ~1000× above Landauer limit +- Biological neurons: ~10× above Landauer limit +- Room for ~100× improvement in artificial systems + +### Reversible Computing + +**Principle**: Compute without erasing information (no irreversible steps). + +**Trade-off**: Memory for energy: +- Standard: O(1) space, O(E) energy +- Reversible: O(T) space, O(0) energy (ideal) +- Practical: O(T^ε) space, O(E/1000) energy + +**Commercial Effort**: Vaire Computing targets 4000× efficiency gain by 2028. + +--- + +## 9. Consciousness Metrics (Speculative) + +### Integrated Information Theory (IIT) + +**Phi (Φ)**: Measure of integrated information. +- Φ = 0: No consciousness +- Φ > 0: Some degree of consciousness +- Φ → ∞: Theoretical maximum integration + +**Requirements for High Φ**: +1. Differentiated (many possible states) +2. Integrated (whole > sum of parts) +3. Reentrant (feedback loops) +4. Selective (not everything connected) + +### Application to Cognitive Substrates + +**Question**: At what complexity does a substrate become conscious? + +**Measurable Indicators**: +- Self-modeling capability +- Goal-directed metabolism +- Temporal self-continuity +- High Φ values in dynamics + +**Controversy**: IIT criticized as unfalsifiable (Nature Neuroscience, 2025). + +--- + +## 10. Summary: Technology Waves + +### Wave 1: Near-Memory (2025-2030) +- PIM prototypes → production +- Hybrid CPU/PIM execution +- Software optimization for data locality + +### Wave 2: In-Memory (2030-2035) +- Compute collocated with storage +- Neuromorphic accelerators mature +- Photonic co-processors emerge + +### Wave 3: Learned Substrates (2035-2045) +- Indices → manifolds +- Discrete → continuous +- CRUD → gradient updates + +### Wave 4: Cognitive Topology (2045-2055) +- Hypergraph dominance +- Topological queries +- Temporal consciousness + +### Wave 5: Post-Symbolic (2055+) +- Universal latent spaces +- Substrate metabolism +- Approaching thermodynamic limits + +--- + +## References + +See `PAPERS.md` for complete academic citation list. diff --git a/examples/exo-ai-2025/specs/SPECIFICATION.md b/examples/exo-ai-2025/specs/SPECIFICATION.md new file mode 100644 index 00000000..16f15306 --- /dev/null +++ b/examples/exo-ai-2025/specs/SPECIFICATION.md @@ -0,0 +1,207 @@ +# EXO-AI 2025: Exocortex Substrate Architecture Specification + +## SPARC Phase 1: Specification + +### Vision Statement + +This specification documents a research-oriented experimental platform for exploring the technological horizons of cognitive substrates (2035-2060), implemented as a modular SDK consuming the ruvector ecosystem. The platform serves as a laboratory for investigating: + +1. **Compute-Memory Unification**: Breaking the von Neumann bottleneck +2. **Learned Manifold Storage**: Continuous neural representations replacing discrete indices +3. **Hypergraph Topologies**: Higher-order relational reasoning substrates +4. **Temporal Consciousness**: Causal memory architectures with predictive retrieval +5. **Federated Intelligence**: Distributed cognitive meshes with cryptographic sovereignty + +--- + +## 1. Problem Domain Analysis + +### 1.1 The Von Neumann Bottleneck + +Current vector databases suffer from fundamental architectural limitations: + +| Limitation | Current Impact | 2035+ Resolution | +|------------|----------------|------------------| +| Memory-Compute Separation | ~1000x energy overhead for data movement | Processing-in-Memory (PIM) | +| Discrete Storage | Fixed indices require explicit CRUD operations | Learned manifolds with continuous deformation | +| Flat Vector Spaces | Insufficient for complex relational reasoning | Hypergraph substrates with topological queries | +| Stateless Retrieval | No temporal/causal context | Temporal knowledge graphs with predictive retrieval | + +### 1.2 Target Characteristics by Era + +``` +2025-2035: Transition Era +├── PIM prototypes reach production +├── Neuromorphic chips with native similarity ops +├── Hybrid digital-analog compute +└── Energy: ~100x reduction from current GPU inference + +2035-2045: Cognitive Topology Era +├── Hypergraph substrates dominate +├── Sheaf-theoretic consistency +├── Temporal memory crystallization +├── Agent-substrate symbiosis begins + +2045-2060: Post-Symbolic Integration +├── Universal latent spaces (all modalities) +├── Substrate metabolism (autonomous optimization) +├── Federated consciousness meshes +└── Approaching thermodynamic limits +``` + +--- + +## 2. Functional Requirements + +### 2.1 Core Substrate Capabilities + +#### FR-001: Learned Manifold Engine +- **Description**: Replace explicit vector indices with implicit neural representations +- **Rationale**: Eliminate discrete operations (insert/update/delete) in favor of continuous manifold deformation +- **Acceptance Criteria**: + - Query execution via gradient descent on learned topology + - Storage as model parameters, not data records + - Support for Tensor Train decomposition (100x compression target) + +#### FR-002: Hypergraph Reasoning Substrate +- **Description**: Native hyperedge operations for higher-order relational reasoning +- **Rationale**: Flat vector spaces insufficient for complex multi-entity relationships +- **Acceptance Criteria**: + - Hyperedge creation spanning arbitrary entity sets + - Topological queries (persistent homology primitives) + - Sheaf-theoretic consistency across distributed manifolds + +#### FR-003: Temporal Memory Architecture +- **Description**: Memory with causal structure, not just similarity +- **Rationale**: Agents need temporal context for predictive retrieval +- **Acceptance Criteria**: + - Causal cone indexing (retrieval respects light-cone constraints) + - Pre-causal computation hints (future context shapes past interpretation) + - Memory consolidation patterns (short-term volatility, long-term crystallization) + +#### FR-004: Federated Cognitive Mesh +- **Description**: Distributed substrate with cryptographic sovereignty boundaries +- **Rationale**: Planetary-scale intelligence requires federated architecture +- **Acceptance Criteria**: + - Quantum-resistant channels between nodes + - Onion-routed queries for intent privacy + - Byzantine fault tolerance across trust boundaries + - CRDT-based eventual consistency + +### 2.2 Hardware Abstraction Targets + +#### FR-005: Processing-in-Memory Interface +- **Description**: Abstract interface for PIM/near-memory computing +- **Rationale**: Future hardware will execute vector ops where data resides +- **Acceptance Criteria**: + - Trait-based backend abstraction + - Simulation mode for development + - Hardware profiling hooks + +#### FR-006: Neuromorphic Backend Support +- **Description**: Interface for spiking neural network accelerators +- **Rationale**: SNNs offer 1000x energy reduction potential +- **Acceptance Criteria**: + - Spike encoding/decoding for vector representations + - Event-driven retrieval patterns + - Integration with neuromorphic simulators + +#### FR-007: Photonic Compute Path +- **Description**: Optical neural network acceleration path +- **Rationale**: Sub-nanosecond latency, extreme parallelism +- **Acceptance Criteria**: + - Matrix-vector multiply abstraction for optical accelerators + - Hybrid digital-photonic dataflow + - Error correction for analog precision + +--- + +## 3. Non-Functional Requirements + +### 3.1 Performance Targets + +| Metric | 2025 Baseline | 2035 Target | 2045 Target | +|--------|---------------|-------------|-------------| +| Query Latency | 1-10ms | 1-100μs | 1-100ns | +| Energy per Query | ~1mJ | ~1μJ | ~1nJ | +| Scale (vectors) | 10^9 | 10^12 | 10^15 | +| Compression Ratio | 3-7x | 100x | 1000x (learned) | + +### 3.2 Architectural Constraints + +- **NFR-001**: Must consume ruvector crates as SDK (no modifications) +- **NFR-002**: WASM-compatible core for browser/edge deployment +- **NFR-003**: NAPI-RS bindings for Node.js integration +- **NFR-004**: Zero-copy operations where hardware permits +- **NFR-005**: Graceful degradation to classical compute + +### 3.3 Security Requirements + +- **NFR-006**: Post-quantum cryptography for all substrate communication +- **NFR-007**: Homomorphic encryption research path for private inference +- **NFR-008**: Differential privacy for federated learning components + +--- + +## 4. Use Case Scenarios + +### UC-001: Cognitive Memory Consolidation +``` +Actor: AI Agent +Precondition: Agent has accumulated working memory during session +Flow: +1. Agent triggers consolidation +2. Substrate identifies salient patterns +3. Learned manifold deforms to incorporate new memories +4. Low-salience information decays (strategic forgetting) +5. Agent can retrieve via meaning, not explicit keys +Postcondition: Long-term memory updated, working memory cleared +``` + +### UC-002: Hypergraph Relational Query +``` +Actor: Knowledge System +Precondition: Hypergraph substrate populated with entities/relations +Flow: +1. System issues topological query: "2-dimensional holes in concept cluster" +2. Substrate computes persistent homology +3. Returns structural memory features +4. System reasons about conceptual gaps +Postcondition: Topological insight available for reasoning +``` + +### UC-003: Federated Cross-Agent Memory +``` +Actor: Agent Swarm +Precondition: Multiple agents operating across trust boundaries +Flow: +1. Agent A stores memory shard with cryptographic tag +2. Agent B queries across federation +3. Substrate routes through onion network +4. Consensus achieved via CRDT reconciliation +5. Result returned without revealing query intent +Postcondition: Cross-agent memory access preserved privacy +``` + +--- + +## 5. Glossary + +| Term | Definition | +|------|------------| +| **Cognitive Substrate** | Hardware-software system hosting distributed reasoning | +| **Learned Manifold** | Continuous neural representation replacing discrete index | +| **Hyperedge** | Relationship spanning arbitrary number of entities | +| **Persistent Homology** | Topological feature extraction across scales | +| **PIM** | Processing-in-Memory architecture | +| **Sheaf** | Category-theoretic structure for local-global consistency | +| **CRDT** | Conflict-free Replicated Data Type | +| **Φ (Phi)** | Integrated Information measure (IIT consciousness metric) | +| **Tensor Train** | Low-rank tensor decomposition format | +| **INR** | Implicit Neural Representation | + +--- + +## References + +See `research/PAPERS.md` for complete academic reference list.