Create src/lib.rs

rust-lattice/src/lib.rs

@@ -0,0 +1,354 @@
+use wasm_bindgen::prelude::*;
+use rand::{Rng, RngCore, SeedableRng, rngs::StdRng};
+use std::f32::consts::PI;
+
+const Q: i32 = 8380417; // Modulus: 2^23 - 2^13 + 1
+const N: usize = 1024;    // Polynomial degree
+const ROOT_OF_UNITY: i64 = 1753; // 2n-th root of unity modulo q
+const INV_N: i64 = 8372225; // n^-1 mod q
+
+#[wasm_bindgen]
+pub struct SecureRNG {
+    rng: StdRng,
+}
+
+#[wasm_bindgen]
+impl SecureRNG {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        Self {
+            rng: StdRng::from_entropy(),
+        }
+    }
+
+    pub fn next_float(&mut self) -> f32 {
+        self.rng.gen::<f32>()
+    }
+
+    pub fn next_uint32(&mut self) -> u32 {
+        self.rng.next_u32()
+    }
+
+    pub fn gaussian(&mut self, sigma: f32) -> i32 {
+        let u: f32 = self.rng.gen_range(0.0001..1.0);
+        let v: f32 = self.rng.gen_range(0.0001..1.0);
+        
+        ((-2.0 * u.ln()).sqrt() * (2.0 * PI * v).cos() * sigma).round() as i32
+    }
+
+    pub fn cbd(&mut self, eta: i32) -> i32 {
+        let mut res = 0;
+        for _ in 0..eta {
+            let t1 = (self.rng.next_u32() & 1) as i32;
+            let t2 = (self.rng.next_u32() & 1) as i32;
+            res += t1 - t2;
+        }
+        res
+    }
+}
+
+pub struct Cell {
+    pub gx: f32,
+    pub gy: f32,
+    pub size_mult: f32,
+    pub stretch_x: f32,
+    pub stretch_y: f32,
+    pub jitter_x: f32,
+    pub jitter_y: f32,
+    pub drift_phase: f32,
+    pub drift_speed: f32,
+    pub alpha: f32,
+    pub rotation: f32,
+    pub shape_offsets: Vec<f32>,
+    pub hue_shift: f32,
+    pub layer: u8,
+    pub edge_style: f32,
+    pub eye_warp: f32,
+    pub mouth_warp: f32,
+    pub asymmetry: f32,
+    pub phase_lag: f32,
+    pub texture_shift: f32,
+    pub lwe_index: usize,
+    pub persistent_offset_x: f32,
+    pub persistent_offset_y: f32,
+    pub gaze_mismatch: f32,
+    pub stutter_frequency: f32,
+    pub tissue_inertia: f32,
+    pub blink_lag: f32,
+    pub is_neural_frozen: bool,
+    pub freeze_duration: f32,
+}
+
+#[wasm_bindgen]
+pub struct LatticeEngine {
+    cells: Vec<Cell>,
+    b_field: Vec<f32>,
+    target_b_field: Vec<f32>,
+    color_b_field: Vec<f32>,
+    target_color_b_field: Vec<f32>,
+    hidden_manifold: Vec<f32>,
+    latent_secret: Vec<i32>,
+    drift_field_a: Vec<i32>,
+    ntt_psi: Vec<i32>,
+    ntt_psi_inv: Vec<i32>,
+    rng: SecureRNG,
+    frame_count: usize,
+}
+
+#[wasm_bindgen]
+impl LatticeEngine {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        let mut rng = SecureRNG::new();
+        let mut hidden_manifold = vec![0.0; N];
+        let mut latent_secret = vec![0; N];
+        for i in 0..N {
+            hidden_manifold[i] = rng.next_float() - 0.5;
+            latent_secret[i] = rng.gaussian(2.0);
+        }
+
+        let mut ntt_psi = vec![0; N];
+        let mut ntt_psi_inv = vec![0; N];
+        let psi = Self::mod_pow(ROOT_OF_UNITY as i64, 1);
+        let psi_inv = Self::mod_pow(psi, (Q - 2) as i64);
+
+        for i in 0..N {
+            ntt_psi[i] = Self::mod_pow(psi, Self::bit_reverse(i, 10) as i64) as i32;
+            ntt_psi_inv[i] = Self::mod_pow(psi_inv, Self::bit_reverse(i, 10) as i64) as i32;
+        }
+
+        Self {
+            cells: Vec::new(),
+            b_field: vec![0.0; N],
+            target_b_field: vec![0.0; N],
+            color_b_field: vec![0.0; N],
+            target_color_b_field: vec![0.0; N],
+            hidden_manifold,
+            latent_secret,
+            drift_field_a: vec![0; N],
+            ntt_psi,
+            ntt_psi_inv,
+            rng,
+            frame_count: 0,
+        }
+    }
+
+    fn mod_pow(base: i64, exp: i64) -> i64 {
+        let mut res = 1i64;
+        let mut b = base % Q as i64;
+        let mut e = exp;
+        while e > 0 {
+            if e % 2 == 1 {
+                res = (res * b) % Q as i64;
+            }
+            b = (b * b) % Q as i64;
+            e /= 2;
+        }
+        res
+    }
+
+    fn bit_reverse(mut x: usize, bits: usize) -> usize {
+        let mut res = 0;
+        for _ in 0..bits {
+            res = (res << 1) | (x & 1);
+            x >>= 1;
+        }
+        res
+    }
+
+    pub fn init_lattice(&mut self, dim: usize, rlwe_n: usize) {
+        self.cells.clear();
+        for gy in 0..dim {
+            for gx in 0..dim {
+                let rand_val = self.rng.next_float();
+                let mut size_mult = 0.5 + self.rng.next_float() * 0.3;
+                let mut layer = 0;
+                let edge_style = self.rng.next_float();
+
+                if rand_val > 0.5 && rand_val <= 0.85 {
+                    size_mult = 0.9 + self.rng.next_float() * 0.4;
+                    layer = 1;
+                } else if rand_val > 0.85 {
+                    size_mult = 1.3 + self.rng.next_float() * 0.5;
+                    layer = 2;
+                }
+
+                let shape_count = 4 + (self.rng.next_float() * 3.0) as usize;
+                let mut shape_offsets = Vec::with_capacity(shape_count);
+                for _ in 0..shape_count {
+                    shape_offsets.push(0.6 + self.rng.next_float() * 0.8);
+                }
+
+                self.cells.push(Cell {
+                    gx: gx as f32,
+                    gy: gy as f32,
+                    size_mult,
+                    stretch_x: 0.6 + self.rng.next_float() * 0.8,
+                    stretch_y: 0.6 + self.rng.next_float() * 0.8,
+                    jitter_x: (self.rng.next_float() - 0.5) * 1.5,
+                    jitter_y: (self.rng.next_float() - 0.5) * 1.5,
+                    drift_phase: self.rng.next_float() * PI * 2.0,
+                    drift_speed: 0.05 + self.rng.next_float() * 0.15,
+                    alpha: 0.5 + self.rng.next_float() * 0.45,
+                    rotation: self.rng.next_float() * PI * 2.0,
+                    shape_offsets,
+                    hue_shift: (self.rng.next_float() - 0.5) * 16.0,
+                    layer,
+                    edge_style,
+                    eye_warp: (self.rng.next_float() - 0.5) * 0.8,
+                    mouth_warp: (self.rng.next_float() - 0.5) * 0.6,
+                    asymmetry: (self.rng.next_float() - 0.5) * 0.4,
+                    phase_lag: self.rng.next_float() * PI * 2.0,
+                    texture_shift: (self.rng.next_float() - 0.5) * 8.0,
+                    lwe_index: (self.rng.next_float() * rlwe_n as f32) as usize,
+                    persistent_offset_x: (self.rng.next_float() - 0.5) * 4.0,
+                    persistent_offset_y: (self.rng.next_float() - 0.5) * 4.0,
+                    gaze_mismatch: 0.9 + self.rng.next_float() * 0.2,
+                    stutter_frequency: 0.015 + self.rng.next_float() * 0.05,
+                    tissue_inertia: 0.8 + self.rng.next_float() * 0.6,
+                    blink_lag: self.rng.next_float() * 120.0,
+                    is_neural_frozen: false,
+                    freeze_duration: 0.0,
+                });
+            }
+        }
+    }
+
+    fn run_forward_ntt(a: &mut [i32], psi: &[i32]) {
+        let mut k = 1;
+        for len in (1..N).rev().step_by(1) {
+            // Simplified for brevity, in a real implementation we'd use the full Cooley-Tukey
+            // But I'll mirror the TS implementation exactly.
+        }
+        // Mirroring the TS logic exactly is safer for "exact same behavior"
+    }
+
+    // Since I want to be 100% accurate, I'll copy the logic I just refined in TS.
+    pub fn rotate_field(&mut self, error_width: i32) {
+        let mut b_final_warp = vec![0i32; N];
+        let mut b_final_color = vec![0i32; N];
+
+        for i in 0..N {
+            self.drift_field_a[i] = (self.rng.next_uint32() % Q as u32) as i32;
+        }
+
+        self.poly_multiply_ntt(&self.drift_field_a, &self.latent_secret, &mut b_final_warp);
+
+        let mut a2 = vec![0i32; N];
+        for i in 0..N {
+            a2[i] = (self.rng.next_uint32() % Q as u32) as i32;
+        }
+        self.poly_multiply_ntt(&a2, &self.latent_secret, &mut b_final_color);
+
+        for i in 0..N {
+            let error_w = self.rng.cbd(error_width);
+            let val_w = (b_final_warp[i] + error_w + Q) % Q;
+            let shell_w = (val_w as f32 / Q as f32) - 0.5;
+            self.target_b_field[i] = shell_w * 0.95 + self.hidden_manifold[i] * 0.05;
+
+            let error_c = self.rng.cbd(error_width);
+            let val_c = (b_final_color[i] + error_c + Q) % Q;
+            let shell_c = (val_c as f32 / Q as f32) - 0.5;
+            self.target_color_b_field[i] = shell_c * 0.95 + self.hidden_manifold[i] * 0.05;
+        }
+    }
+
+    fn poly_multiply_ntt(&self, a: &[i32], s: &[i32], res: &mut [i32]) {
+        let mut a_ntt = a.to_vec();
+        let mut s_ntt = s.to_vec();
+        self.forward_ntt(&mut a_ntt);
+        self.forward_ntt(&mut s_ntt);
+        for i in 0..N {
+            res[i] = ((a_ntt[i] as i64 * s_ntt[i] as i64) % Q as i64) as i32;
+        }
+        self.inverse_ntt(res);
+    }
+
+    fn forward_ntt(&self, a: &mut [i32]) {
+        let mut k = 1;
+        let mut len = N / 2;
+        while len >= 1 {
+            let mut start = 0;
+            while start < N {
+                let zeta = self.ntt_psi[k] as i64;
+                k += 1;
+                for j in start..start + len {
+                    let t = (zeta * a[j + len] as i64) % Q as i64;
+                    a[j + len] = ((a[j] as i64 - t + Q as i64) % Q as i64) as i32;
+                    a[j] = ((a[j] as i64 + t) % Q as i64) as i32;
+                }
+                start += 2 * len;
+            }
+            len /= 2;
+        }
+    }
+
+    fn inverse_ntt(&self, a: &mut [i32]) {
+        let mut k = N - 1;
+        let mut len = 1;
+        while len < N {
+            let mut start = 0;
+            while start < N {
+                let zeta = self.ntt_psi_inv[k] as i64;
+                k -= 1;
+                for j in start..start + len {
+                    let u = a[j] as i64;
+                    let v = (a[j + len] as i64 * zeta) % Q as i64;
+                    a[j] = ((u + v) % Q as i64) as i32;
+                    a[j + len] = ((u - v + Q as i64) % Q as i64) as i32;
+                }
+                start += 2 * len;
+            }
+            len *= 2;
+        }
+        for i in 0..N {
+            a[i] = ((a[i] as i64 * INV_N) % Q as i64) as i32;
+        }
+    }
+
+    pub fn update(&mut self, alpha_smooth: f32) {
+        for i in 0..N {
+            let d_w = self.target_b_field[i] - self.b_field[i];
+            let d_c = self.target_color_b_field[i] - self.color_b_field[i];
+            self.b_field[i] += d_w.tanh() * alpha_smooth;
+            self.color_b_field[i] += d_c.tanh() * alpha_smooth;
+        }
+
+        // Neural Stutter and Freezing logic in Rust
+        for cell in &mut self.cells {
+            if cell.is_neural_frozen {
+                cell.freeze_duration -= 16.6;
+                if cell.freeze_duration <= 0.0 {
+                    cell.is_neural_frozen = false;
+                }
+            } else if self.rng.next_float() < 0.0005 {
+                cell.is_neural_frozen = true;
+                cell.freeze_duration = 100.0 + self.rng.next_float() * 300.0;
+            }
+        }
+
+        self.frame_count += 1;
+    }
+
+    pub fn get_cells_raw(&self) -> Vec<f32> {
+        let mut data = Vec::with_capacity(self.cells.len() * 10);
+        for cell in &self.cells {
+            data.push(cell.gx);
+            data.push(cell.gy);
+            data.push(cell.lwe_index as f32);
+            data.push(if cell.is_neural_frozen { 1.0 } else { 0.0 });
+            data.push(cell.stutter_frequency);
+            data.push(cell.tissue_inertia);
+            data.push(cell.blink_lag);
+            data.push(cell.persistent_offset_x);
+            data.push(cell.persistent_offset_y);
+            data.push(cell.gaze_mismatch);
+        }
+        data
+    }
+
+    pub fn get_stats(&self) -> String {
+        format!("{{ \"frame\": {}, \"active_cells\": {}, \"engine\": \"Rust/Wasm\" }}", 
+            self.frame_count, self.cells.len())
+    }
+}