ruvector_consciousness/

collapse.rs

//! Quantum-inspired consciousness collapse.
//!
//! Models the partition search as a quantum-inspired process:
//! each bipartition exists in superposition with an amplitude
//! proportional to 1/sqrt(information_loss). Grover-like iterations
//! amplify the MIP, then "measurement" collapses to it.
//!
//! This provides a sublinear approximation for finding the minimum
//! information partition without exhaustive search.

use crate::arena::PhiArena;
use crate::error::ConsciousnessError;
use crate::traits::ConsciousnessCollapse;
use crate::types::{Bipartition, PhiAlgorithm, PhiResult, TransitionMatrix};

use rand::rngs::StdRng;
use rand::{Rng, SeedableRng};
use std::f64::consts::PI;
use std::time::Instant;

/// Quantum-inspired partition collapse engine.
///
/// Uses amplitude-based search inspired by Grover's algorithm:
/// 1. Initialize uniform amplitudes over sampled partitions
/// 2. Oracle: phase-rotate proportional to information loss (low loss = high rotation)
/// 3. Diffusion: inversion about the mean amplitude
/// 4. Collapse: sample from |amplitude|² distribution
///
/// Achieves approximately √N speedup over exhaustive search.
pub struct QuantumCollapseEngine {
    /// Number of partitions to hold in the "register".
    register_size: usize,
}

impl QuantumCollapseEngine {
    pub fn new(register_size: usize) -> Self {
        Self { register_size }
    }
}

impl Default for QuantumCollapseEngine {
    fn default() -> Self {
        Self {
            register_size: 256,
        }
    }
}

impl ConsciousnessCollapse for QuantumCollapseEngine {
    fn collapse_to_mip(
        &self,
        tpm: &TransitionMatrix,
        iterations: usize,
        seed: u64,
    ) -> Result<PhiResult, ConsciousnessError> {
        let n = tpm.n;
        let start = Instant::now();
        let arena = PhiArena::with_capacity(n * n * 16);

        let mut rng = StdRng::seed_from_u64(seed);
        let total_partitions = (1u64 << n) - 2;

        // Sample partitions into the register.
        let reg_size = self.register_size.min(total_partitions as usize);
        let mut partitions: Vec<Bipartition> = Vec::with_capacity(reg_size);
        let mut seen = std::collections::HashSet::new();

        while partitions.len() < reg_size {
            let mask = loop {
                let m = rng.gen::<u64>() & ((1u64 << n) - 1);
                if m != 0 && m != (1u64 << n) - 1 && !seen.contains(&m) {
                    break m;
                }
            };
            seen.insert(mask);
            partitions.push(Bipartition { mask, n });
        }

        // Compute information loss for each partition.
        let losses: Vec<f64> = partitions
            .iter()
            .map(|p| {
                let loss = super::phi::partition_information_loss_pub(tpm, 0, p, &arena);
                arena.reset();
                loss
            })
            .collect();

        // Initialize amplitudes: uniform superposition.
        let inv_sqrt = 1.0 / (reg_size as f64).sqrt();
        let mut amplitudes: Vec<f64> = vec![inv_sqrt; reg_size];

        // Grover-like iterations.
        let optimal_iters = iterations.min(((reg_size as f64).sqrt() * PI / 4.0) as usize);

        for _ in 0..optimal_iters {
            // Oracle: phase-rotate based on information loss.
            // Low loss = high phase kick (we want to amplify the minimum).
            let max_loss = losses.iter().copied().fold(f64::MIN, f64::max);
            if max_loss < 1e-15 {
                break;
            }
            let inv_max = 1.0 / max_loss;

            for i in 0..reg_size {
                let relevance = 1.0 - (losses[i] * inv_max);
                let phase = PI * relevance;
                amplitudes[i] *= phase.cos();
            }

            // Diffusion: inversion about the mean.
            let mean: f64 = amplitudes.iter().sum::<f64>() / reg_size as f64;
            for amp in &mut amplitudes {
                *amp = 2.0 * mean - *amp;
            }
        }

        // Collapse: sample from |amplitude|² distribution.
        let probs: Vec<f64> = amplitudes.iter().map(|a| a * a).collect();
        let total_prob: f64 = probs.iter().sum();

        let best_idx = if total_prob > 1e-15 {
            // Weighted sampling.
            let r: f64 = rng.gen::<f64>() * total_prob;
            let mut cumsum = 0.0;
            let mut selected = 0;
            for (i, &p) in probs.iter().enumerate() {
                cumsum += p;
                if cumsum >= r {
                    selected = i;
                    break;
                }
            }
            selected
        } else {
            // Fallback: pick the one with minimum loss.
            losses
                .iter()
                .enumerate()
                .min_by(|a, b| a.1.partial_cmp(b.1).unwrap())
                .map(|(i, _)| i)
                .unwrap_or(0)
        };

        Ok(PhiResult {
            phi: losses[best_idx],
            mip: partitions[best_idx].clone(),
            partitions_evaluated: reg_size as u64,
            total_partitions,
            algorithm: PhiAlgorithm::Collapse,
            elapsed: start.elapsed(),
            convergence: vec![losses[best_idx]],
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn simple_tpm() -> TransitionMatrix {
        #[rustfmt::skip]
        let data = vec![
            0.5, 0.25, 0.25, 0.0,
            0.5, 0.25, 0.25, 0.0,
            0.5, 0.25, 0.25, 0.0,
            0.0, 0.0,  0.0,  1.0,
        ];
        TransitionMatrix::new(4, data)
    }

    #[test]
    fn collapse_finds_partition() {
        let tpm = simple_tpm();
        let engine = QuantumCollapseEngine::new(32);
        let result = engine.collapse_to_mip(&tpm, 10, 42).unwrap();
        assert!(result.phi >= 0.0);
        assert!(result.mip.is_valid());
    }

    #[test]
    fn collapse_deterministic_with_seed() {
        let tpm = simple_tpm();
        let engine = QuantumCollapseEngine::new(32);
        let r1 = engine.collapse_to_mip(&tpm, 10, 42).unwrap();
        let r2 = engine.collapse_to_mip(&tpm, 10, 42).unwrap();
        assert_eq!(r1.mip, r2.mip);
    }
}