creating-intelligence 0.1.0a7__py3-none-win_amd64.whl

creating_intelligence/memory_c_ffi.py

@@ -0,0 +1,170 @@
+"""
+Copyright (c) 2026 Peter Overmann
+ 
+SPDX-License-Identifier: MIT
+ 
+This file is part of the "Creating Intelligence" project. It is licensed 
+under the MIT License. You may obtain a copy of the License in the LICENSE 
+file in the root directory of this repository.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+"""
+
+import ctypes
+import os
+import sys
+import importlib.machinery
+from pathlib import Path
+
+def _candidate_paths():
+    """Yield possible locations of the compiled C library, most preferred first."""
+    # 1. Explicit override, e.g. MEMORY_LIB_PATH=/path/to/libmemory.so
+    override = os.environ.get("MEMORY_LIB_PATH")
+    if override:
+        yield Path(override)
+
+    # 2. Extension built by pip/setuptools, under any suffix this interpreter
+    #    accepts (.cpython-312-x86_64-linux-gnu.so, .abi3.so, .cp312-win_amd64.pyd, ...)
+    pkg_dir = Path(__file__).resolve().parent
+    for suffix in importlib.machinery.EXTENSION_SUFFIXES:
+        yield pkg_dir / f"libmemory{suffix}"
+
+    # 3. Local development build from the C Makefile (<repo>/c/lib/)
+    if sys.platform == "darwin":
+        lib_name = "libmemory.dylib"
+    elif sys.platform == "win32":
+        lib_name = "libmemory.dll"
+    else:
+        lib_name = "libmemory.so"
+    yield pkg_dir.parent.parent / "c" / "lib" / lib_name
+
+
+def _load_library():
+    tried = []
+    for path in _candidate_paths():
+        if not path.is_file():
+            tried.append(f"  {path} (not found)")
+            continue
+        try:
+            return ctypes.CDLL(str(path))
+        except OSError as e:
+            tried.append(f"  {path} ({e})")
+    raise OSError("Could not load the C memory library. Tried:\n" + "\n".join(tried))
+
+
+lib = _load_library()        
+        
+# Define the C 'Set' struct in Python.
+class CSet(ctypes.Structure):
+    _fields_ = [
+        ("a", ctypes.POINTER(ctypes.c_int)),
+        ("n", ctypes.c_int),
+        ("p", ctypes.c_int)
+    ]
+
+# Define FFI signatures mapped from the C implementations.
+lib.Memory_new.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+lib.Memory_new.restype = ctypes.c_void_p
+
+lib.Memory_set_threshold.argtypes = [ctypes.c_void_p, ctypes.c_int]
+lib.Memory_set_threshold.restype = None
+
+lib.Memory_get_threshold.argtypes = [ctypes.c_void_p]
+lib.Memory_get_threshold.restype = ctypes.c_int
+
+lib.Memory_set_fraction.argtypes = [ctypes.c_void_p, ctypes.c_double]
+lib.Memory_set_fraction.restype = None
+
+lib.Memory_get_fraction.argtypes = [ctypes.c_void_p]
+lib.Memory_get_fraction.restype = ctypes.c_double
+
+lib.Memory_count.argtypes = [ctypes.c_void_p]
+lib.Memory_count.restype = ctypes.c_int64
+
+lib.Memory_free.argtypes = [ctypes.c_void_p]
+lib.Memory_free.restype = None
+
+lib.Memory_write.argtypes = [ctypes.c_void_p, ctypes.POINTER(CSet), ctypes.POINTER(CSet)]
+lib.Memory_write.restype = None
+
+lib.Memory_read.argtypes = [ctypes.c_void_p, ctypes.POINTER(CSet), ctypes.POINTER(CSet)]
+lib.Memory_read.restype = ctypes.POINTER(CSet)
+
+def Memory(config: dict) -> dict:
+    NA, PA = config["A_parameters"] 
+    NB, PB = config["B_parameters"] 
+    
+    # Construct the underlying C memory object.
+    M = lib.Memory_new(NA, PA, NB, PB)
+    
+    # Push user-defined threshold scaling if provided.
+    if config.get("threshold") is not None:
+        scaled_threshold = round(config.get("threshold") * PA)
+        lib.Memory_set_threshold(M, scaled_threshold) 
+        
+    # Push optional relative threshold (fraction of the query population).
+    if config.get("fraction") is not None:
+        lib.Memory_set_fraction(M, float(config.get("fraction")))
+
+    # Retrieve final absolute threshold from C backend.
+    T = lib.Memory_get_threshold(M) 
+
+    # Retrieve fraction parameter from C backend
+    fraction = lib.Memory_get_fraction(M) 
+
+    def _make_cset(data_list, dimension):
+        """Creates a CSet and holds the underlying array reference to prevent garbage collection."""
+        length = len(data_list)
+        shifted_data = [x - 1 for x in data_list]
+        arr = (ctypes.c_int * length)(*shifted_data)
+        cset = CSet(a=ctypes.cast(arr, ctypes.POINTER(ctypes.c_int)), n=dimension, p=length)
+        return cset, arr
+             
+    def store(A, B=None):
+        # Store auto-association A -> A in memory if B is omitted.
+        if B is None:
+            B = A 
+            
+        if len(A) > 0 and len(B) > 0: 
+            cset_A, _ref_A = _make_cset(A, NA)
+            cset_B, _ref_B = _make_cset(B, NB)
+            lib.Memory_write(M, ctypes.byref(cset_A), ctypes.byref(cset_B)) 
+
+    def retrieve(A):
+        if len(A) == 0: 
+            return []
+            
+        cset_A, _ref_A = _make_cset(A, NA)
+        
+        # Allocate space for retrieved values up to max dimension NB.
+        Y_arr = (ctypes.c_int * NB)() 
+        cset_Y = CSet(a=ctypes.cast(Y_arr, ctypes.POINTER(ctypes.c_int)), n=NB, p=0)
+        
+        # Memory_read returns a pointer to the populated result Set.
+        res_ptr = lib.Memory_read(M, ctypes.byref(cset_A), ctypes.byref(cset_Y)) 
+        
+        if not res_ptr:
+            return []
+            
+        res_set = res_ptr.contents
+        return [res_set.a[i] + 1 for i in range(res_set.p)]
+        
+    def memorycount():
+        return lib.Memory_count(M)
+
+    def clear():
+        lib.Memory_free(M) 
+
+    return  {
+        "A_parameters": (NA, PA),
+        "B_parameters": (NB, PB),
+        "T": T,
+        "fraction": fraction,
+        "store": store,
+        "retrieve": retrieve,
+        "clear": clear,
+        "memorycount": memorycount,
+        "backend": "c_ffi"
+    }

creating_intelligence/memory_python.py

@@ -0,0 +1,143 @@
+"""
+Copyright (c) 2026 Peter Overmann
+ 
+SPDX-License-Identifier: MIT
+ 
+This file is part of the "Creating Intelligence" project. It is licensed 
+under the MIT License. You may obtain a copy of the License in the LICENSE 
+file in the root directory of this repository.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+"""
+
+import math
+import numpy as np
+from itertools import combinations
+
+def Memory(config: dict) -> dict:
+    # Extract hyperparameters
+    NA, PA = config["A_parameters"]
+    NB, PB = config["B_parameters"]
+    
+    # Memory capacity, needed for default threshold calculation
+    if NA == NB and PA == PB:
+        capacity = round((math.log(2.0) * NA * (NA - 1) * (NA - 2)) / 
+                         (PA * (PA - 1) * (PA - 2)))
+    else:
+        capacity = round((math.log(2.0) * NA * (NA - 1) * NB) / 
+                         (PA * (PA - 1) * PB))
+        
+    # Default pattern matching threshold
+    T = 1
+    while (T < PA and 
+           (capacity**2 * math.comb(PA, T) * 
+            math.comb(NA - PA, PA - T) / 
+            math.comb(NA, PA)) >= 1):
+        T += 1
+        
+    # User-defined (scaled) threshold via get()
+    if config.get("threshold") is not None:
+        T = round(config["threshold"] * PA)
+    
+    T = max(2, T)
+
+    # Optional relative threshold: fraction of the query population that must
+    # match (1.0 = all input bits). Absent or 0 keeps the fixed threshold T.
+    fraction = config.get("fraction") or 0.0
+
+    # Initialize enclosed memory dictionary and zero array
+    mem = {}
+    zero = np.zeros(NB + 1, dtype=np.int8)
+
+    def store(A, B=None):
+        if B is None:
+            B = A
+            
+        # Empty patterns store nothing
+        if not A or not B:
+            return            
+            
+        v = zero.copy()
+        v[B] = 1 
+        
+        for pair in combinations(A, 2):
+            key = tuple(sorted(pair))
+            
+            if key not in mem:
+                mem[key] = v.copy() 
+            else:
+                mem[key] = np.bitwise_or(mem[key], v)
+
+    def retrieve(A):
+
+        X = A
+        
+        # Per-query threshold, at least the fixed threshold T
+        Tq = max(T, math.ceil(fraction * len(X) - 1e-9))
+
+        while True:
+            P = len(X)
+            if P < Tq:
+                return []
+
+            Ri = np.zeros((P, NB + 1), dtype=np.int32)
+
+            for i, j in combinations(range(P), 2):
+                key = tuple(sorted([X[i], X[j]]))
+                v = mem.get(key, zero)
+                Ri[i] += v
+                Ri[j] += v
+
+            R = np.sum(Ri, axis=0) // 2
+
+            R_valid = R[1:] 
+            sorted_R = np.sort(R_valid)
+            
+            t_val = sorted_R[-PB] if PB <= len(sorted_R) else sorted_R[0]
+            t = max(1, t_val)
+
+            if t < (Tq * (Tq - 1)) / 2:
+                return []
+            
+            Y = [i for i in range(1, NB + 1) if R[i] >= t]
+            w = np.sum(Ri[:, Y], axis=1)
+
+            ws = np.sort(w)
+            h = P
+            
+            while h > 0 and ws[-h] < len(Y) * (h - 1):
+                h -= 1
+
+            if h < Tq:
+                return []
+
+            cutoff = ws[-h]
+            new_X = [X[i] for i in range(P) if w[i] >= cutoff]
+
+            if h == Tq and h < len(new_X):
+                return []
+
+            if len(new_X) == P:
+                return Y
+
+            X = new_X
+
+    def memorycount():
+        return sum(np.sum(v) for v in mem.values())
+
+    def clear():
+        mem.clear()
+        
+    return  {
+        "A_parameters": (NA, PA),
+        "B_parameters": (NB, PB),
+        "T": T,
+        "fraction": fraction,
+        "store": store,
+        "retrieve": retrieve,
+        "clear": clear,
+        "memorycount": memorycount,
+        "backend": "python"
+    }

creating_intelligence-0.1.0a7.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: creating-intelligence
+Version: 0.1.0a7
+Summary: A computational foundation for AGI, based on hyperdimensional sparse data and framed in set theory.
+Author-email: Peter Overmann <mail@creatingintelligence.org>
+License-Expression: MIT
+Project-URL: Homepage, https://creatingintelligence.org
+Project-URL: Documentation, https://creatingintelligence.org/docs
+Project-URL: Repository, https://github.com/PeterOvermann/CreatingIntelligence
+Keywords: artificial intelligence,computational theory of mind,hyperdimensional computing,sparse distributed representations,topological associative memory,subset matching algorithm,spiking neural networks,neuromorphic computing,theoretical neuroscience
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: matplotlib>=3.5.0
+Requires-Dist: networkx>=2.8.0
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: scipy>=1.8.0
+Provides-Extra: viz
+Requires-Dist: pydot>=1.4.2; extra == "viz"
+Provides-Extra: all
+Requires-Dist: creating-intelligence[viz]; extra == "all"
+
+# Creating Intelligence
+
+A computational foundation for AGI, based on hyperdimensional sparse data and framed in set theory. 
+
+The mind performs computations on sparse binary data using Sparse Distributed Representations (SDRs) for perceptual information and Sparse Holographic Representations (SHRs) for symbols. The centerpiece of this project is Topological Associative Memory — a newly discovered associative memory for sparse data, serving as the computational kernel that models the brain's core algorithm.
+
+### Links
+
+* **Website:** https://creatingintelligence.org
+* **Documentation:** https://creatingintelligence.org/docs
+* **GitHub Repository:** https://github.com/PeterOvermann/CreatingIntelligence
+* **Preprint:** [arXiv:2606.31819](https://arxiv.org/abs/2606.31819)
+
+### Installation
+
+```bash
+pip install creating-intelligence
+```
+
+
+#### Optional installations
+
+| Extra | Installs | Purpose |
+| ----- | -------- | ------- |
+| `viz` | `pydot` | Left-to-right layouts when drawing circuit diagrams |
+| `all` | every extra above | Everything optional in one step |
+
+```bash
+pip install "creating-intelligence[viz]"
+pip install "creating-intelligence[all]"
+```

creating_intelligence-0.1.0a7.dist-info/RECORD

@@ -0,0 +1,9 @@
+creating_intelligence/__init__.py,sha256=-PCADoMkzPtoP2yBYxCKs2wUVL38IqLR8KIG0PtEpOE,1309
+creating_intelligence/circuits.py,sha256=WgQvS0cWxwKfo-tHQzHttWqfTTglQ3Zv8czhJyu0G9c,59299
+creating_intelligence/libmemory.pyd,sha256=VkPrWUIrrs2ieqYH8tuEHs9xhxKDVGZwUKYmpS5gmOk,19968
+creating_intelligence/memory_c_ffi.py,sha256=PLPssHaIE2CFJ48XavCFe18be2QWKF45cAP-F_34bco,5910
+creating_intelligence/memory_python.py,sha256=sWayWH0_h15XiJyb5OjNO94-hf9JqWYmoU_s4GfG2e0,4096
+creating_intelligence-0.1.0a7.dist-info/METADATA,sha256=6BZCMsUIVWornAN0OLI7IbTyFYTOi7Y0XHFbWzTdcns,2404
+creating_intelligence-0.1.0a7.dist-info/WHEEL,sha256=Zx98gwb_dQKckJK3HEOVKnxxD52EfU_PXDG_usMJ2ng,98
+creating_intelligence-0.1.0a7.dist-info/top_level.txt,sha256=H5O7jHPu13cfTnlha8xX5GjLNEwY_9NAXlO401214ds,22
+creating_intelligence-0.1.0a7.dist-info/RECORD,,

creating_intelligence-0.1.0a7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+

creating_intelligence-0.1.0a7.dist-info/top_level.txt

@@ -0,0 +1 @@
+creating_intelligence