lqft-python-engine 0.1.8__tar.gz → 0.2.0__tar.gz

lqft_python_engine-0.2.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: lqft-python-engine
+Version: 0.2.0
+Summary: LQFT Engine: Full CRUD Support & Enterprise Scaling (v4.5 Stable)
+Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
+Author: Parjad Minooei
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: psutil
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Log-Quantum Fractal Tree Engine

{lqft_python_engine-0.1.8 → lqft_python_engine-0.2.0}/lqft_engine.c

@@ -11,12 +11,12 @@
 #include <stdint.h>
 
 /**
- * LQFT C-Engine - V4.4 (Large Payload Support)
+ * LQFT C-Engine - V4.5 (Full CRUD & Large Payload)
  * Architect: Parjad Minooei
  * * CHANGE LOG:
- * - Removed fixed 8KB stack buffer in get_canonical.
- * - Implemented Incremental FNV-1a Hashing to support multi-MB payloads.
- * - Optimized string interning for high-concurrency memory safety.
+ * - Added 'delete' method with bottom-up path reconstruction.
+ * - Maintains Incremental FNV-1a Hashing for large payloads.
+ * - Fixed Stack-to-Heap collision for multi-MB data.
  */
 
 #define BIT_PARTITION 5
@@ -35,7 +35,6 @@ static LQFTNode** registry = NULL;
 static int physical_node_count = 0;
 static LQFTNode* global_root = NULL;
 
-// Incremental FNV-1a Constants
 const uint64_t FNV_OFFSET_BASIS = 14695981039346656037ULL;
 const uint64_t FNV_PRIME = 1099511628211ULL;
 
@@ -77,18 +76,13 @@ LQFTNode* create_node(void* value, uint64_t key_hash) {
 LQFTNode* get_canonical(void* value, uint64_t key_hash, LQFTNode** children) {
     if (!init_registry()) return NULL;
 
-    // V4.4 REFACTOR: Incremental hashing instead of sprintf concatenation
-    // This avoids the 8KB buffer overflow for large payloads.
     uint64_t full_hash = FNV_OFFSET_BASIS;
-
     if (value != NULL) {
-        const char* prefix = "leaf:";
-        full_hash = fnv1a_update(full_hash, prefix, 5);
+        full_hash = fnv1a_update(full_hash, "leaf:", 5);
         full_hash = fnv1a_update(full_hash, value, strlen((char*)value));
         full_hash = fnv1a_update(full_hash, &key_hash, sizeof(uint64_t));
     } else {
-        const char* prefix = "branch:";
-        full_hash = fnv1a_update(full_hash, prefix, 7);
+        full_hash = fnv1a_update(full_hash, "branch:", 7);
         if (children) {
             for (int i = 0; i < 32; i++) {
                 if (children[i]) {
@@ -102,8 +96,8 @@ LQFTNode* get_canonical(void* value, uint64_t key_hash, LQFTNode** children) {
     char lookup_hash[17];
     sprintf(lookup_hash, "%016llx", (unsigned long long)full_hash);
     uint32_t idx = full_hash % REGISTRY_SIZE;
-
     uint32_t start_idx = idx;
+
     while (registry[idx] != NULL) {
         if (strcmp(registry[idx]->struct_hash, lookup_hash) == 0) {
             if (value) free(value); 
@@ -124,6 +118,58 @@ LQFTNode* get_canonical(void* value, uint64_t key_hash, LQFTNode** children) {
     return new_node;
 }
 
+static PyObject* method_delete(PyObject* self, PyObject* args) {
+    unsigned long long h;
+    if (!PyArg_ParseTuple(args, "K", &h)) return NULL;
+    if (!global_root) Py_RETURN_NONE;
+
+    LQFTNode* path_nodes[20]; 
+    uint32_t path_segs[20];
+    int path_len = 0;
+    LQFTNode* curr = global_root;
+    int bit_depth = 0;
+
+    // Trace path to target
+    while (curr != NULL && curr->value == NULL) {
+        uint32_t segment = (h >> bit_depth) & MASK;
+        path_nodes[path_len] = curr;
+        path_segs[path_len] = segment;
+        path_len++;
+        curr = curr->children[segment];
+        bit_depth += BIT_PARTITION;
+    }
+
+    // If not found, exit
+    if (curr == NULL || curr->key_hash != h) Py_RETURN_NONE;
+
+    // Rebuild bottom-up: start with NULL (the deleted leaf)
+    LQFTNode* new_sub_node = NULL;
+
+    for (int i = path_len - 1; i >= 0; i--) {
+        LQFTNode* p_node = path_nodes[i];
+        uint32_t segment = path_segs[i];
+        LQFTNode* new_children[32];
+        int has_other_children = 0;
+
+        for (int j = 0; j < 32; j++) {
+            if (j == segment) new_children[j] = new_sub_node;
+            else {
+                new_children[j] = p_node->children[j];
+                if (new_children[j]) has_other_children = 1;
+            }
+        }
+
+        if (!has_other_children && i > 0) {
+            new_sub_node = NULL; // Contract empty branch
+        } else {
+            new_sub_node = get_canonical(NULL, 0, new_children);
+        }
+    }
+
+    global_root = (new_sub_node) ? new_sub_node : get_canonical(NULL, 0, NULL);
+    Py_RETURN_NONE;
+}
+
 static PyObject* method_free_all(PyObject* self, PyObject* args) {
     if (registry != NULL) {
         for (int i = 0; i < REGISTRY_SIZE; i++) {
@@ -145,47 +191,34 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
     unsigned long long h;
     char* val_str;
     if (!PyArg_ParseTuple(args, "Ks", &h, &val_str)) return NULL;
-
     if (!global_root) {
         if (!init_registry()) return PyErr_NoMemory();
         global_root = get_canonical(NULL, 0, NULL);
     }
-
-    LQFTNode* path_nodes[MAX_BITS];
-    uint32_t path_segs[MAX_BITS];
+    LQFTNode* path_nodes[20];
+    uint32_t path_segs[20];
     int path_len = 0;
-
     LQFTNode* curr = global_root;
     int bit_depth = 0;
-
     while (curr != NULL && curr->value == NULL) {
         uint32_t segment = (h >> bit_depth) & MASK;
         path_nodes[path_len] = curr;
         path_segs[path_len] = segment;
         path_len++;
-
-        if (curr->children[segment] == NULL) {
-            curr = NULL;
-            break;
-        }
+        if (curr->children[segment] == NULL) { curr = NULL; break; }
         curr = curr->children[segment];
         bit_depth += BIT_PARTITION;
     }
-
     LQFTNode* new_sub_node = NULL;
-    if (curr == NULL) {
-        new_sub_node = get_canonical(portable_strdup(val_str), h, NULL);
-    } else if (curr->key_hash == h) {
-        new_sub_node = get_canonical(portable_strdup(val_str), h, curr->children);
-    } else {
+    if (curr == NULL) { new_sub_node = get_canonical(portable_strdup(val_str), h, NULL); }
+    else if (curr->key_hash == h) { new_sub_node = get_canonical(portable_strdup(val_str), h, curr->children); }
+    else {
         unsigned long long old_h = curr->key_hash;
         char* old_val = portable_strdup((char*)curr->value);
         int temp_depth = bit_depth;
-
-        while (temp_depth < MAX_BITS) {
+        while (temp_depth < 64) {
             uint32_t s_old = (old_h >> temp_depth) & MASK;
             uint32_t s_new = (h >> temp_depth) & MASK;
-
             if (s_old != s_new) {
                 LQFTNode* c_old = get_canonical(old_val, old_h, curr->children);
                 LQFTNode* c_new = get_canonical(portable_strdup(val_str), h, NULL);
@@ -194,16 +227,10 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
                 new_children[s_new] = c_new;
                 new_sub_node = get_canonical(NULL, 0, new_children);
                 break;
-            } else {
-                path_nodes[path_len] = NULL; 
-                path_segs[path_len] = s_old;
-                path_len++;
-                temp_depth += BIT_PARTITION;
-            }
+            } else { path_nodes[path_len] = NULL; path_segs[path_len] = s_old; path_len++; temp_depth += BIT_PARTITION; }
         }
         if (new_sub_node == NULL) new_sub_node = get_canonical(portable_strdup(val_str), h, curr->children);
     }
-
     for (int i = path_len - 1; i >= 0; i--) {
         if (path_nodes[i] == NULL) {
             LQFTNode* new_children[32] = {NULL};
@@ -218,7 +245,6 @@ static PyObject* method_insert(PyObject* self, PyObject* args) {
             new_sub_node = get_canonical(p_node->value, p_node->key_hash, new_children);
         }
     }
-
     global_root = new_sub_node;
     Py_RETURN_NONE;
 }
@@ -227,7 +253,6 @@ static PyObject* method_search(PyObject* self, PyObject* args) {
     unsigned long long h;
     if (!PyArg_ParseTuple(args, "K", &h)) return NULL;
     if (!global_root) Py_RETURN_NONE;
-
     LQFTNode* curr = global_root;
     int bit_depth = 0;
     while (curr != NULL && curr->value == NULL) {
@@ -244,10 +269,11 @@ static PyObject* method_get_metrics(PyObject* self, PyObject* args) {
 }
 
 static PyMethodDef LQFTMethods[] = {
-    {"insert", method_insert, METH_VARARGS, "Insert payload"},
-    {"search", method_search, METH_VARARGS, "Search hash"},
-    {"get_metrics", method_get_metrics, METH_VARARGS, "Get metrics"},
-    {"free_all", method_free_all, METH_VARARGS, "Reclaim memory"},
+    {"insert", method_insert, METH_VARARGS, "Insert key-value"},
+    {"delete", method_delete, METH_VARARGS, "Delete key"},
+    {"search", method_search, METH_VARARGS, "Search key"},
+    {"get_metrics", method_get_metrics, METH_VARARGS, "Get engine stats"},
+    {"free_all", method_free_all, METH_VARARGS, "Total memory wipe"},
     {NULL, NULL, 0, NULL}
 };
 

{lqft_python_engine-0.1.8 → lqft_python_engine-0.2.0}/lqft_engine.py

@@ -2,7 +2,7 @@ import hashlib
 import weakref
 
 # ---------------------------------------------------------
-# LEGACY PURE PYTHON LQFT (For reference/fallback)
+# LEGACY PURE PYTHON LQFT (For reference/fallback/benchmarks)
 # ---------------------------------------------------------
 class LQFTNode:
     __slots__ = ['children', 'value', 'key_hash', 'struct_hash', '__weakref__']
@@ -115,8 +115,8 @@ except ImportError:
 class AdaptiveLQFT:
     """
     A polymorphic, heuristic-driven data structure wrapper.
-    - Scale < 50,000: Acts as an ultra-lightweight C-Hash (Python Dict).
-    - Scale > 50,000: Automatically migrates to the Native C-Engine LQFT 
+    - Scale < threshold: Acts as an ultra-lightweight C-Hash (Python Dict).
+    - Scale > threshold: Automatically migrates to the Native C-Engine LQFT 
       for Merkle-DAG deduplication and folding.
     """
     def __init__(self, migration_threshold=50000):
@@ -140,7 +140,7 @@ class AdaptiveLQFT:
             
         for key, val in self._light_store.items():
             h = self._get_64bit_hash(key)
-            lqft_c_engine.insert(h, val)
+            lqft_c_engine.insert(h, str(val))
             
         # Clear the lightweight store to free up memory
         self._light_store.clear()
@@ -159,7 +159,7 @@ class AdaptiveLQFT:
         else:
             # Phase 2: Massive Data Operations (Native C-Heap)
             h = self._get_64bit_hash(key)
-            lqft_c_engine.insert(h, value)
+            lqft_c_engine.insert(h, str(value))
 
     def search(self, key):
         if not self.is_native:
@@ -168,9 +168,23 @@ class AdaptiveLQFT:
             h = self._get_64bit_hash(key)
             return lqft_c_engine.search(h)
 
+    def remove(self, key):
+        """Deletes a key from either the light store or the Merkle tree."""
+        if not self.is_native:
+            if key in self._light_store:
+                del self._light_store[key]
+                self.size -= 1
+        else:
+            h = self._get_64bit_hash(key)
+            lqft_c_engine.delete(h)
+
+    def delete(self, key):
+        """Alias for remove to satisfy all testing suites."""
+        self.remove(key)
+
     def clear(self):
         """
-        Memory Reclamation: Manually trigger C-level heap cleanup.
+        Memory Reclamation: Manually trigger heap cleanup.
         In the Adaptive model, this handles both the Python dict and the C-Registry.
         """
         self._light_store.clear()
@@ -179,21 +193,23 @@ class AdaptiveLQFT:
             return lqft_c_engine.free_all()
         return 0
 
+    def get_stats(self):
+        """Fetches memory metrics from the C-Engine if active."""
+        if self.is_native and C_ENGINE_READY:
+            return lqft_c_engine.get_metrics()
+        return {"physical_nodes": 0}
+
     def __del__(self):
-        """
-        Finalizer: Reclaims unmanaged C memory when the Python object is deleted.
-        Crucial for preventing memory leaks in long-running systems.
-        """
+        """Finalizer: Reclaims unmanaged C memory when the Python object is deleted."""
         try:
             self.clear()
         except:
-            # Silence errors during late interpreter shutdown/garbage collection
             pass
 
     def status(self):
         """Returns the current state of the engine."""
         return {
             "mode": "Native Merkle-DAG" if self.is_native else "Lightweight C-Hash",
-            "items": self.size,
+            "items": self.size if not self.is_native else lqft_c_engine.get_metrics().get('physical_nodes', self.size),
             "threshold": self.threshold
         }

lqft_python_engine-0.2.0/lqft_python_engine.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: lqft-python-engine
+Version: 0.2.0
+Summary: LQFT Engine: Full CRUD Support & Enterprise Scaling (v4.5 Stable)
+Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
+Author: Parjad Minooei
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: psutil
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Log-Quantum Fractal Tree Engine

{lqft_python_engine-0.1.8 → lqft_python_engine-0.2.0}/setup.py

@@ -15,10 +15,7 @@ else:
 
 # Load README for PyPI long_description
 long_description = "Log-Quantum Fractal Tree Engine"
-if os.path.exists("readme.md"):
-    with open("readme.md", "r", encoding="utf-8") as fh:
-        long_description = fh.read()
-elif os.path.exists("README.md"):
+if os.path.exists("README.md"):
     with open("README.md", "r", encoding="utf-8") as fh:
         long_description = fh.read()
 
@@ -30,8 +27,8 @@ lqft_extension = Extension(
 
 setup(
     name="lqft-python-engine",
-    version="0.1.8", 
-    description="LQFT Engine: High-Performance Deduplicating Data Structure (V4.4 Stable)",
+    version="0.2.0", 
+    description="LQFT Engine: Full CRUD Support & Enterprise Scaling (v4.5 Stable)",
     long_description=long_description,
     long_description_content_type="text/markdown",
     author="Parjad Minooei",

lqft_python_engine-0.1.8/PKG-INFO

@@ -1,96 +0,0 @@
-Metadata-Version: 2.4
-Name: lqft-python-engine
-Version: 0.1.8
-Summary: LQFT Engine: High-Performance Deduplicating Data Structure (V4.4 Stable)
-Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
-Author: Parjad Minooei
-License: MIT
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE.md
-Requires-Dist: psutil
-Dynamic: author
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Log-Quantum Fractal Tree (LQFT) 🚀
-
-**Architect:** [Parjad Minooei](https://www.linkedin.com/in/parjadminooei) 
-**Portfolio:** [parjadm.ca](https://www.parjadm.ca/)
-
----
-
-## 📌 Executive Summary
-
-The **Log-Quantum Fractal Tree (LQFT)** is a high-performance, scale-invariant data structure engine designed for massive data deduplication and persistent state management. By bridging a **native C-Engine** with a **Python Foreign Function Interface (FFI)**, this project bypasses the Global Interpreter Lock (GIL) to achieve sub-microsecond search latencies and memory efficiency that scales with data entropy rather than data volume.
-
----
-
-## 🧠 Formal Complexity Analysis
-
-As a Systems Architect, I have engineered the LQFT to move beyond the linear limitations of standard Python structures.
-
-### 1. Time Complexity: $O(1)$ (Scale-Invariant)
-Unlike standard Trees ($O(\log N)$) or Lists ($O(N)$), the LQFT uses a fixed-depth 64-bit address space.
-
-* **Search/Insertion:** $O(1)$
-* **Mechanism:** The 64-bit hash is partitioned into 13 segments of 5-bits. This ensures that the path from the root to any leaf is physically capped at 13 hops, providing **deterministic latency** regardless of whether the database holds 1,000 or 1,000,000,000 items.
-
-### 2. Space Complexity: $O(\Sigma)$ (Entropy-Based)
-Standard structures scale linearly based on the number of items ($N$). The LQFT scales based on the **Information Entropy** ($\Sigma$) of the dataset.
-
-* **Space:** $O(\Sigma)$
-* **Mechanism:** Utilizing **Merkle-DAG structural folding**, the engine detects identical data branches and reuses them in physical memory. In highly redundant datasets (e.g., DNA sequences or Log files), this results in sub-linear memory growth.
-
----
-
-## 📊 Performance Benchmarks
-*Tested in Scarborough Lab: Python 3.12 | MinGW-w64 GCC-O3 Optimization*
-
-| Metric | Standard Python ($O(N)$) | LQFT C-Engine ($O(1)$) | Delta |
-| :--- | :--- | :--- | :--- |
-| **Search Latency (N=100k)** | ~3,564.84 μs | 0.50 μs | **7,129x Faster** |
-| **Insertion Time (N=100k)** | 41.05s | 1.07s | **38x Faster** |
-| **Memory (Versioning)** | $O(N \times V)$ | $O(\Sigma + V)$ | **99% Savings** |
-
----
-
-## 🛠️ Architectural Pillars
-
-* **Native C-Engine Core:** Pushes memory allocation and bit-manipulation to the C-layer for hardware-level execution.
-* **Structural Folding:** A recursive structural hashing algorithm that collapses identical sub-trees into single pointers.
-* **Adaptive Migration:** A polymorphic wrapper (`AdaptiveLQFT`) that manages the transition from lightweight Python dictionaries to the heavy-duty C-Engine.
-* **Zero-Knowledge Integrity:** Fixed-depth pathing allows for 208-byte Merkle Proofs to verify data existence in microsecond time.
-
----
-
-## ⚙️ Quick Start
-
-### Compilation
-Ensure you have a C compiler (GCC/Clang) installed to build the FFI layer.
-```bash
-python setup.py build_ext --inplace
-```
-
-### Usage 
-from lqft_engine import AdaptiveLQFT
-
-# Initialize engine with an auto-migration threshold
-engine = AdaptiveLQFT(migration_threshold=50000)
-
-# Insert and Search
-engine.insert("secret_key", "confidential_data")
-result = engine.search("secret_key")
-
-print(f"Found: {result}")

lqft_python_engine-0.1.8/lqft_python_engine.egg-info/PKG-INFO

@@ -1,96 +0,0 @@
-Metadata-Version: 2.4
-Name: lqft-python-engine
-Version: 0.1.8
-Summary: LQFT Engine: High-Performance Deduplicating Data Structure (V4.4 Stable)
-Home-page: https://github.com/ParjadM/Log-Quantum-Fractal-Tree-LQFT-
-Author: Parjad Minooei
-License: MIT
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE.md
-Requires-Dist: psutil
-Dynamic: author
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Log-Quantum Fractal Tree (LQFT) 🚀
-
-**Architect:** [Parjad Minooei](https://www.linkedin.com/in/parjadminooei) 
-**Portfolio:** [parjadm.ca](https://www.parjadm.ca/)
-
----
-
-## 📌 Executive Summary
-
-The **Log-Quantum Fractal Tree (LQFT)** is a high-performance, scale-invariant data structure engine designed for massive data deduplication and persistent state management. By bridging a **native C-Engine** with a **Python Foreign Function Interface (FFI)**, this project bypasses the Global Interpreter Lock (GIL) to achieve sub-microsecond search latencies and memory efficiency that scales with data entropy rather than data volume.
-
----
-
-## 🧠 Formal Complexity Analysis
-
-As a Systems Architect, I have engineered the LQFT to move beyond the linear limitations of standard Python structures.
-
-### 1. Time Complexity: $O(1)$ (Scale-Invariant)
-Unlike standard Trees ($O(\log N)$) or Lists ($O(N)$), the LQFT uses a fixed-depth 64-bit address space.
-
-* **Search/Insertion:** $O(1)$
-* **Mechanism:** The 64-bit hash is partitioned into 13 segments of 5-bits. This ensures that the path from the root to any leaf is physically capped at 13 hops, providing **deterministic latency** regardless of whether the database holds 1,000 or 1,000,000,000 items.
-
-### 2. Space Complexity: $O(\Sigma)$ (Entropy-Based)
-Standard structures scale linearly based on the number of items ($N$). The LQFT scales based on the **Information Entropy** ($\Sigma$) of the dataset.
-
-* **Space:** $O(\Sigma)$
-* **Mechanism:** Utilizing **Merkle-DAG structural folding**, the engine detects identical data branches and reuses them in physical memory. In highly redundant datasets (e.g., DNA sequences or Log files), this results in sub-linear memory growth.
-
----
-
-## 📊 Performance Benchmarks
-*Tested in Scarborough Lab: Python 3.12 | MinGW-w64 GCC-O3 Optimization*
-
-| Metric | Standard Python ($O(N)$) | LQFT C-Engine ($O(1)$) | Delta |
-| :--- | :--- | :--- | :--- |
-| **Search Latency (N=100k)** | ~3,564.84 μs | 0.50 μs | **7,129x Faster** |
-| **Insertion Time (N=100k)** | 41.05s | 1.07s | **38x Faster** |
-| **Memory (Versioning)** | $O(N \times V)$ | $O(\Sigma + V)$ | **99% Savings** |
-
----
-
-## 🛠️ Architectural Pillars
-
-* **Native C-Engine Core:** Pushes memory allocation and bit-manipulation to the C-layer for hardware-level execution.
-* **Structural Folding:** A recursive structural hashing algorithm that collapses identical sub-trees into single pointers.
-* **Adaptive Migration:** A polymorphic wrapper (`AdaptiveLQFT`) that manages the transition from lightweight Python dictionaries to the heavy-duty C-Engine.
-* **Zero-Knowledge Integrity:** Fixed-depth pathing allows for 208-byte Merkle Proofs to verify data existence in microsecond time.
-
----
-
-## ⚙️ Quick Start
-
-### Compilation
-Ensure you have a C compiler (GCC/Clang) installed to build the FFI layer.
-```bash
-python setup.py build_ext --inplace
-```
-
-### Usage 
-from lqft_engine import AdaptiveLQFT
-
-# Initialize engine with an auto-migration threshold
-engine = AdaptiveLQFT(migration_threshold=50000)
-
-# Insert and Search
-engine.insert("secret_key", "confidential_data")
-result = engine.search("secret_key")
-
-print(f"Found: {result}")