chaotic_semantic_memory 0.3.6

AI memory systems with hyperdimensional vectors and chaotic reservoirs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

//! Property-based tests for hypervector and singularity operations.
//!
//! Float comparisons allowed: proptest assertions for exact association strengths.

#![allow(clippy::float_cmp)]

use std::collections::HashMap;

use chaotic_semantic_memory::hyperdim::HVec10240;
use chaotic_semantic_memory::singularity::{Concept, Singularity, SingularityConfig};
use proptest::prelude::*;

const NS: &str = "_default";

fn hvec_from_bytes(bytes: &[u8]) -> HVec10240 {
    HVec10240::from_bytes(bytes).expect("strategy always yields 1280-byte vectors")
}

proptest! {
    #[test]
    fn hypervector_roundtrip_from_and_to_bytes(bytes in proptest::collection::vec(any::<u8>(), 1280)) {
        let vector = hvec_from_bytes(&bytes);
        let recovered = HVec10240::from_bytes(&vector.to_bytes()).unwrap();
        prop_assert_eq!(recovered, vector);
    }

    #[test]
    fn cosine_similarity_stays_within_bounds(
        a_bytes in proptest::collection::vec(any::<u8>(), 1280),
        b_bytes in proptest::collection::vec(any::<u8>(), 1280),
    ) {
        let a = hvec_from_bytes(&a_bytes);
        let b = hvec_from_bytes(&b_bytes);

        let similarity = a.cosine_similarity(&b);
        prop_assert!(similarity >= -1.0);
        prop_assert!(similarity <= 1.0);
    }

    #[test]
    fn bundling_is_order_invariant_for_three_vectors(
        a_bytes in proptest::collection::vec(any::<u8>(), 1280),
        b_bytes in proptest::collection::vec(any::<u8>(), 1280),
        c_bytes in proptest::collection::vec(any::<u8>(), 1280),
    ) {
        let a = hvec_from_bytes(&a_bytes);
        let b = hvec_from_bytes(&b_bytes);
        let c = hvec_from_bytes(&c_bytes);

        let abc = HVec10240::bundle(&[a, b, c]).unwrap();
        let bca = HVec10240::bundle(&[b, c, a]).unwrap();
        prop_assert_eq!(abc, bca);
    }

    #[test]
    fn associate_creates_queryable_link(strength in 0.0f32..=1.0f32) {
        let mut singularity = Singularity::new(SingularityConfig::default());
        let concept_a = Concept {
            id: "a".to_string(),
            vector: HVec10240::random(),
            metadata: HashMap::new(),
            created_at: 1,
            modified_at: 1,
            expires_at: None,
            canonical_concept_ids: Vec::new(),
        };
        let concept_b = Concept {
            id: "b".to_string(),
            vector: HVec10240::random(),
            metadata: HashMap::new(),
            created_at: 1,
            modified_at: 1,
            expires_at: None,
            canonical_concept_ids: Vec::new(),
        };

        singularity.inject(NS, concept_a).unwrap();
        singularity.inject(NS, concept_b).unwrap();
        singularity.associate(NS, "a", "b", strength).unwrap();

        let links = singularity.get_associations(NS, "a");
        prop_assert_eq!(links.len(), 1);
        prop_assert_eq!(links[0].0.as_str(), "b");
        prop_assert_eq!(links[0].1, strength);
    }
}