Merge pull request #150 from AdaWorldAPI/claude/compare-rustynum-ndarray-5ePRn

fix: Container = 16,384 bits (256 × u64) — canonical layout

Author: AdaWorldAPI

crates/ladybug-contract/src/container.rs

@@ -1,27 +1,28 @@
-//! 8192-bit Container — the atomic unit of LadybugDB.
+//! 16,384-bit Container (CogRecord) — the atomic unit of LadybugDB.
 //!
-//! A Container is a 1 KB bit-vector: 128 × u64 = 8,192 bits.
+//! A Container is a 2 KB bit-vector: 256 × u64 = 16,384 bits.
 //! All cognitive operations (XOR bind, Hamming distance, majority-vote bundle)
-//! operate at this granularity.
+//! operate at this granularity.  Each CogRecord IS one container.
 
 /// Total bits in a single container.
-pub const CONTAINER_BITS: usize = 8_192;
+pub const CONTAINER_BITS: usize = 16_384;
 /// Number of u64 words in a container.
-pub const CONTAINER_WORDS: usize = CONTAINER_BITS / 64; // 128
+pub const CONTAINER_WORDS: usize = CONTAINER_BITS / 64; // 256
 /// Number of bytes in a container.
-pub const CONTAINER_BYTES: usize = CONTAINER_WORDS * 8; // 1024
+pub const CONTAINER_BYTES: usize = CONTAINER_WORDS * 8; // 2048
 /// AVX-512 iteration count (8 words per 512-bit register).
-pub const CONTAINER_AVX512_ITERS: usize = CONTAINER_WORDS / 8; // 16
+pub const CONTAINER_AVX512_ITERS: usize = CONTAINER_WORDS / 8; // 32
 /// Maximum content containers in a CogRecord.
 pub const MAX_CONTAINERS: usize = 255;
 /// Expected Hamming distance for two random containers.
-pub const EXPECTED_DISTANCE: u32 = (CONTAINER_BITS / 2) as u32; // 4096
+pub const EXPECTED_DISTANCE: u32 = (CONTAINER_BITS / 2) as u32; // 8192
 /// Standard deviation of Hamming distance for random containers.
-pub const SIGMA: f64 = 45.254833995939045;
+/// sqrt(16384 / 4) = sqrt(4096) = 64.0
+pub const SIGMA: f64 = 64.0;
 /// Integer approximation of sigma.
-pub const SIGMA_APPROX: u32 = 45;
+pub const SIGMA_APPROX: u32 = 64;
 
-/// 8,192-bit binary container for HDC/VSA operations.
+/// 16,384-bit binary container for HDC/VSA operations.
 ///
 /// Cache-line aligned for SIMD; `#[repr(C)]` for binary stability.
 #[derive(Clone, PartialEq, Eq)]
@@ -216,7 +217,7 @@ impl Container {
     /// Zero-copy byte view (little-endian).
     #[inline]
     pub fn as_bytes(&self) -> &[u8; CONTAINER_BYTES] {
-        // SAFETY: Container is repr(C), [u64; 128] has same layout as [u8; 1024]
+        // SAFETY: Container is repr(C), [u64; 256] has same layout as [u8; 2048]
         unsafe { &*(self.words.as_ptr() as *const [u8; CONTAINER_BYTES]) }
     }
 
@@ -229,7 +230,7 @@ impl Container {
         Self { words }
     }
 
-    /// Zero-cost borrow a `[u64; 128]` as `&Container`.
+    /// Zero-cost borrow a `[u64; 256]` as `&Container`.
     ///
     /// # Safety
     /// Caller must guarantee 64-byte alignment.
@@ -282,7 +283,7 @@ mod tests {
         let a = Container::random(42);
         let b = Container::random(99);
         let d = a.hamming(&b);
-        assert!(d > 3500 && d < 4700, "hamming={d}, expected ~4096");
+        assert!(d > 7000 && d < 9500, "hamming={d}, expected ~8192");
     }
 
     #[test]

crates/ladybug-contract/src/lib.rs

@@ -15,7 +15,7 @@
 //!
 //! | Module | Contents |
 //! |--------|----------|
-//! | [`container`] | 8192-bit `Container` with XOR, Hamming, bundle ops |
+//! | [`container`] | 16,384-bit `Container` with XOR, Hamming, bundle ops |
 //! | [`geometry`] | `ContainerGeometry` — how content containers are interpreted |
 //! | [`record`] | `CogRecord` — metadata + N content containers |
 //! | [`meta`] | `MetaView` / `MetaViewMut` — zero-copy metadata accessors |
@@ -29,7 +29,7 @@
 //! | [`delegation`] | `DelegationRequest` / `DelegationResponse` |
 //! | [`wire`] | Binary wire protocol: `CogPacket` (8+8/4096 command packets, no JSON) |
 //! | [`legacy`] | V1 JSON backward compatibility (external wire format only) |
-//! | [`schema`] | Unified 2×8192 CogRecord schema constants and field descriptors |
+//! | [`schema`] | Unified 16,384-bit CogRecord schema constants and field descriptors |
 
 pub mod container;
 pub mod wide_container;

crates/ladybug-contract/src/schema.rs

@@ -352,8 +352,8 @@ impl CognitiveKernel {
         packet: &CogPacket,
         node: &mut crate::cognitive::layer_stack::LayerNode,
     ) -> (CognitiveKernelResult, CogPacket) {
-        // Extract fingerprint from Container payload (Container = 8192 bits,
-        // BindSpace = 16384 bits — zero-pad the upper half)
+        // Extract fingerprint from Container payload (Container = 16384 bits,
+        // same width as BindSpace Fingerprint)
         let content = packet.content();
         let input_fp = container_to_fingerprint(content);
 
@@ -469,26 +469,19 @@ impl Default for CognitiveKernel {
 // CONTAINER ↔ FINGERPRINT BRIDGING
 // =============================================================================
 
-/// Convert a Container (8192 bits = 128 × u64) to a Fingerprint-compatible
-/// word array (16384 bits = 256 × u64). Upper half zero-padded.
+/// Convert a Container (16384 bits = 256 × u64) to a Fingerprint.
+/// Container and Fingerprint are now the same width — direct copy.
 fn container_to_fingerprint(container: &Container) -> Fingerprint {
     let mut words = [0u64; FINGERPRINT_WORDS];
-    for (i, &w) in container.words.iter().enumerate() {
-        words[i] = w;
-    }
-    // XOR-fold: replicate lower 128 words into upper 128 with permutation
-    // This preserves information density while filling the full 16K space
-    for i in 0..128 {
-        words[128 + i] = container.words[i].rotate_left(7);
-    }
+    words.copy_from_slice(&container.words);
     Fingerprint::from_raw(words)
 }
 
 /// Convert a BindSpace fingerprint array back to a Container.
-/// Truncates to 128 words (8192 bits).
+/// Container and Fingerprint are now the same width — direct copy.
 fn fingerprint_to_container(fp: &[u64; FINGERPRINT_WORDS]) -> Container {
-    let mut words = [0u64; 128];
-    words.copy_from_slice(&fp[..128]);
+    let mut words = [0u64; FINGERPRINT_WORDS];
+    words.copy_from_slice(fp);
     Container { words }
 }
 

src/cognitive/cognitive_kernel.rs

@@ -27,8 +27,8 @@ pub fn belichtungsmesser(a: &Container, b: &Container) -> u32 {
     for &idx in &SAMPLE_POINTS {
         estimate += (a.words[idx] ^ b.words[idx]).count_ones();
     }
-    // Scale: 7 samples × 64 bits = 448 bits sampled out of 8192
-    // Scale factor: 8192 / 448 ≈ 18.29
+    // Scale: 7 samples × 64 bits = 448 bits sampled out of CONTAINER_BITS
+    // Scale factor: CONTAINER_BITS / 448
     estimate * CONTAINER_BITS as u32 / 448
 }
 

src/container/search.rs

@@ -191,10 +191,10 @@ fn test_container_as_bytes() {
 
 #[test]
 fn test_container_constants() {
-    assert_eq!(CONTAINER_BITS, 8192);
-    assert_eq!(CONTAINER_WORDS, 128);
-    assert_eq!(CONTAINER_BYTES, 1024);
-    assert_eq!(CONTAINER_AVX512_ITERS, 16);
+    assert_eq!(CONTAINER_BITS, 16384);
+    assert_eq!(CONTAINER_WORDS, 256);
+    assert_eq!(CONTAINER_BYTES, 2048);
+    assert_eq!(CONTAINER_AVX512_ITERS, 32);
     assert_eq!(CONTAINER_BITS % 64, 0);
     assert_eq!(CONTAINER_WORDS % 8, 0); // AVX-512 aligned
     assert!(CONTAINER_BITS.is_power_of_two());

src/container/tests.rs

@@ -83,7 +83,7 @@ pub fn fingerprint_dot_u8i8(a: &Fingerprint, b: &Fingerprint) -> i64 {
 }
 
 // ────────────────────────────────────────────────────────────────
-// Container operations (8192-bit = 1024 bytes = 128 u64 words)
+// Container operations (16384-bit = 2048 bytes = 256 u64 words)
 // ────────────────────────────────────────────────────────────────
 
 /// Popcount a Container using runtime-dispatched VPOPCNTDQ.

src/core/rustynum_accel.rs

@@ -305,7 +305,7 @@ impl SpoStore {
 
     /// Compute chain coherence: product of normalized link coherences.
     ///
-    /// coherence_per_link = 1.0 - (hamming(Z_i, X_{i+1}) / 8192.0)
+    /// coherence_per_link = 1.0 - (hamming(Z_i, X_{i+1}) / CONTAINER_BITS)
     /// chain_coherence = product of all link coherences
     pub fn chain_coherence(&self, dns: &[u64]) -> f32 {
         if dns.len() < 2 { return 1.0; }
@@ -319,7 +319,7 @@ impl SpoStore {
             let (x_b, _, _) = match self.unpack_record(b) { Ok(v) => v, Err(_) => return 0.0 };
 
             let dist = SparseContainer::hamming_sparse(&z_a, &x_b);
-            let link_coherence = 1.0 - (dist as f32 / 8192.0);
+            let link_coherence = 1.0 - (dist as f32 / ladybug_contract::container::CONTAINER_BITS as f32);
             coherence *= link_coherence;
         }
 
@@ -357,7 +357,7 @@ impl SpoStore {
                 let (_, _, z) = match self.unpack_record(record) { Ok(v) => v, Err(_) => return TruthValue::unknown() };
                 let (x, _, _) = match self.unpack_record(next) { Ok(v) => v, Err(_) => return TruthValue::unknown() };
                 let dist = SparseContainer::hamming_sparse(&z, &x);
-                let link_coh = 1.0 - (dist as f32 / 8192.0);
+                let link_coh = 1.0 - (dist as f32 / ladybug_contract::container::CONTAINER_BITS as f32);
                 c_chain *= link_coh;
             }
         }

src/graph/spo/store.rs

@@ -45,7 +45,7 @@ impl Default for DreamConfig {
     fn default() -> Self {
         Self {
             prune_confidence_threshold: 0.2,
-            merge_hamming_threshold: 1500, // ~18% of 8192 bits
+            merge_hamming_threshold: 3000, // ~18% of 16384 bits
             recombination_count: 5,
             permute_offset: 7,
             max_output: 0,

src/learning/dream.rs

@@ -594,7 +594,7 @@ mod tests {
     #[test]
     fn test_truth_from_hamming_random() {
         // ~50% distance = random noise
-        let tv = truth_from_hamming(8192, 16384);
+        let tv = truth_from_hamming(8192, 16384); // 8192 = half of 16384 = random noise
         assert!((tv.f - 0.5).abs() < 0.01);
         assert!(tv.c < 0.1, "random should have low confidence");
     }