Upload folder using huggingface_hub

README.md

@@ -0,0 +1,137 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- comparison
+---
+
+# threshold-lessthan
+
+4-bit less-than comparator. Returns 1 if a < b, 0 otherwise.
+
+## Circuit
+
+```
+  a0 b0 0         a1 b1          a2 b2          a3 b3
+   │  │ │          │  │           │  │           │  │
+   └──┼─┘          └──┼──┘        └──┼──┘        └──┼──┘
+      ▼               ▼              ▼              ▼
+  ┌───────┐       ┌───────┐      ┌───────┐      ┌───────┐
+  │  FS0  │──b0───│  FS1  │──b1──│  FS2  │──b2──│  FS3  │───► (a < b)
+  └───────┘       └───────┘      └───────┘      └───────┘
+      │               │              │              │
+      ▼               ▼              ▼              ▼
+     d0              d1             d2             d3
+   (unused)       (unused)       (unused)       (unused)
+```
+
+Uses 4 cascaded full subtractors. The final borrow output indicates a < b.
+
+## Mechanism
+
+The circuit computes a - b using subtraction:
+
+- If a ≥ b: no borrow propagates, result is non-negative
+- If a < b: borrow propagates out, indicating underflow
+
+The difference bits (d0-d3) are computed but unused. Only the final borrow matters.
+
+## Truth Table (sample)
+
+| a | b | a < b |
+|---|---|-------|
+| 0 | 0 | 0 |
+| 0 | 1 | 1 |
+| 1 | 0 | 0 |
+| 5 | 10 | 1 |
+| 10 | 5 | 0 |
+| 7 | 7 | 0 |
+| 15 | 0 | 0 |
+| 0 | 15 | 1 |
+
+All 256 input combinations verified correct.
+
+## Full Subtractor Structure
+
+```
+        a       b
+        │       │
+        └───┬───┘
+            ▼
+       ┌─────────┐
+       │   HS1   │
+       └─────────┘
+        │       │
+       d1       b1
+        │        \
+        │   bin   \
+        └──┬──┘    \
+           ▼        \
+      ┌─────────┐    \
+      │   HS2   │     │
+      └─────────┘     │
+       │       │      │
+       d       b2     │
+               │      │
+               └──┬───┘
+                  ▼
+              ┌──────┐
+              │  OR  │
+              └──────┘
+                  │
+                  ▼
+                bout
+```
+
+## Architecture
+
+| Component | Per FS | Total (4 FSs) |
+|-----------|--------|---------------|
+| Neurons | 9 | 36 |
+| Parameters | 27 | 108 |
+
+**Layers: 16** (4 FSs × 4 layers each)
+
+## Comparison Family
+
+| Circuit | Condition | Implementation |
+|---------|-----------|----------------|
+| **LessThan** | a < b | borrow_out of (a - b) |
+| Equal | a = b | NOR of all XOR bits |
+| GreaterThan | a > b | NOT(a < b) AND NOT(a = b) |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+
+w = load_file('model.safetensors')
+
+def less_than(a, b):
+    """a, b: 4-bit lists [a0,a1,a2,a3] (LSB first)
+    Returns: 1 if a < b, 0 otherwise"""
+    # See model.py for full implementation
+    pass
+
+# Example: 5 < 10?
+a = [1, 0, 1, 0]  # 5 in LSB-first
+b = [0, 1, 0, 1]  # 10 in LSB-first
+result = less_than(a, b)  # Returns 1
+```
+
+## Files
+
+```
+threshold-lessthan/
+├── model.safetensors
+├── model.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-lessthan",
+  "description": "4-bit less-than comparator as threshold circuit",
+  "inputs": 8,
+  "outputs": 1,
+  "neurons": 36,
+  "layers": 16,
+  "parameters": 108
+}

model.py

@@ -0,0 +1,40 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def half_sub(a, b, w, prefix):
+    inp = torch.tensor([float(a), float(b)])
+    l1 = (inp @ w[f'{prefix}.xor.layer1.weight'].T + w[f'{prefix}.xor.layer1.bias'] >= 0).float()
+    d = float((l1 @ w[f'{prefix}.xor.layer2.weight'].T + w[f'{prefix}.xor.layer2.bias'] >= 0).item())
+    borrow = float((inp @ w[f'{prefix}.borrow.weight'].T + w[f'{prefix}.borrow.bias'] >= 0).item())
+    return d, borrow
+
+def full_sub(a, b, bin_in, w, prefix):
+    d1, b1 = half_sub(a, b, w, f'{prefix}.hs1')
+    d, b2 = half_sub(d1, bin_in, w, f'{prefix}.hs2')
+    bout = int((torch.tensor([b1, b2]) @ w[f'{prefix}.bout.weight'].T + w[f'{prefix}.bout.bias'] >= 0).item())
+    return int(d), bout
+
+def less_than(a, b, weights):
+    """4-bit less-than comparator.
+    a, b: lists of 4 bits each (LSB first)
+    Returns: 1 if a < b, 0 otherwise
+    """
+    borrows = [0]
+    for i in range(4):
+        d, bout = full_sub(a[i], b[i], borrows[i], weights, f'fs{i}')
+        borrows.append(bout)
+    return borrows[4]
+
+if __name__ == '__main__':
+    w = load_model()
+    print('4-bit LessThan Comparator')
+    print('a < b tests:')
+    tests = [(0, 0), (0, 1), (1, 0), (5, 10), (10, 5), (7, 7), (15, 0), (0, 15)]
+    for a_val, b_val in tests:
+        a = [(a_val >> i) & 1 for i in range(4)]
+        b = [(b_val >> i) & 1 for i in range(4)]
+        result = less_than(a, b, w)
+        print(f'{a_val:2d} < {b_val:2d} = {result}')

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9221161e5cbde88f0223631b5ef8100ea0cea9cc8719fd809191181c5315cb27
+size 4808