holographic-memory 0.4.0

A high-performance Holographic Memory System (HMS) implementing Vector Symbolic Architectures (VSA).
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

// Copyright 2024-2026 WritersLogic Contributors
// SPDX-License-Identifier: Apache-2.0

use super::HmsCore;
use crate::core::entangled::EntangledHVec;
use crate::core::types::RetrievalResult;
use anyhow::Result;

impl HmsCore {
    /// Encode a (head, relation, tail) triplet as `h XOR r XOR t` and memorize it.
    pub fn memorize_triplet(&self, id: String, h: String, r: String, t: String) -> Result<()> {
        let vec_h = self.encode_text(&h);
        let vec_r = self.encode_text(&r);
        let vec_t = self.encode_text(&t);
        let triplet = vec_h.bind(&vec_r).bind(&vec_t);
        self.memorize(id, triplet)
    }

    /// Encode an ordered sequence using position-based permutation and memorize it.
    pub fn memorize_sequence(&self, id: String, sequence: &[String]) -> Result<()> {
        if sequence.is_empty() {
            return Ok(());
        }
        let mut vecs = Vec::new();
        for (i, item) in sequence.iter().enumerate() {
            let v = self.encode_text(item).permute(i);
            vecs.push(v);
        }
        let trajectory = self.bundle(&vecs);
        self.memorize(id, trajectory)
    }

    /// Query for tails matching `head XOR relation`.
    pub fn query_triplet(&self, h: String, r: String, k: u32) -> Result<Vec<RetrievalResult>> {
        let vec_h = self.encode_text(&h);
        let vec_r = self.encode_text(&r);
        let query_vec = vec_h.bind(&vec_r);
        Ok(self.query(&query_vec, k))
    }

    /// Find analogy: A is to B as C is to ? Returns k closest matches.
    pub fn find_analogy(&self, a: &str, b: &str, c: &str, k: u32) -> Vec<RetrievalResult> {
        let vec_a = self.encode_text(a);
        let vec_b = self.encode_text(b);
        let vec_c = self.encode_text(c);
        let target = vec_a.bind(&vec_b).bind(&vec_c);
        self.query(&target, k)
    }

    /// Query for sequences matching a partial sequence prefix.
    pub fn query_sequence(&self, partial: &[String], k: u32) -> Result<Vec<RetrievalResult>> {
        if partial.is_empty() {
            return Ok(vec![]);
        }
        let vecs: Vec<EntangledHVec> = partial
            .iter()
            .enumerate()
            .map(|(i, item)| self.encode_text(item).permute(i))
            .collect();
        let query_vec = self.bundle(&vecs);
        Ok(self.query(&query_vec, k))
    }
}