clm-kernel 0.0.21

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
#![allow(unused_imports)]
use super::*;

/// Pre-computed nullspace basis for Noetherian P-invariants (INV-419).
/// Replaces dynamic Gaussian elimination during transitions with O(1) dot-product checks.
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct PrecomputedInvariants {
    /// Basis vectors v_k where D^T · v_k = 0 (or x^T · D = 0).
    pub basis_vectors: Vec<Vec<i64>>,
    /// Expected invariant constants w · M_0 for initial marking M_0.
    pub initial_constants: Vec<i64>,
}

impl PrecomputedInvariants {
    /// Compile nullspace invariants from an incidence matrix D and initial marking.
    pub fn compile(matrix: &[Vec<i64>], rows: usize, cols: usize, initial_marking: &[i64]) -> Self {
        let basis_vectors = solve_nullspace(matrix, rows, cols, true);
        let mut initial_constants = Vec::with_capacity(basis_vectors.len());
        for b in &basis_vectors {
            let mut sum = 0i64;
            for (p_idx, &w) in b.iter().enumerate() {
                if p_idx < initial_marking.len() {
                    sum += w * initial_marking[p_idx];
                }
            }
            initial_constants.push(sum);
        }
        Self {
            basis_vectors,
            initial_constants,
        }
    }

    /// Fast-path check: returns true if current marking satisfies all basis conservation laws.
    /// Runs in O(k * P) where k is number of basis invariants and P is place count.
    #[inline]
    pub fn verify_marking(&self, marking: &[i64]) -> bool {
        for (i, b) in self.basis_vectors.iter().enumerate() {
            let mut sum = 0i64;
            for (p_idx, &w) in b.iter().enumerate() {
                if p_idx < marking.len() {
                    sum += w * marking[p_idx];
                }
            }
            if i < self.initial_constants.len() && sum != self.initial_constants[i] {
                return false;
            }
        }
        true
    }

    /// Fast-path check on marking delta ΔM: returns true if ΔM · v_k == 0 for all basis vectors.
    #[inline]
    pub fn verify_delta(&self, delta: &[i64]) -> bool {
        for b in &self.basis_vectors {
            let mut sum = 0i64;
            for (p_idx, &w) in b.iter().enumerate() {
                if p_idx < delta.len() {
                    sum += w * delta[p_idx];
                }
            }
            if sum != 0 {
                return false;
            }
        }
        true
    }
}