4-bit magnitude comparator, magnitude 64

README.md

@@ -0,0 +1,87 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+---
+
+# threshold-comparator4bit
+
+4-bit magnitude comparator. Compares two 4-bit unsigned integers.
+
+## Function
+
+compare(A, B) -> (GT, LT, EQ)
+
+- GT = 1 if A > B
+- LT = 1 if A < B
+- EQ = 1 if A = B
+
+## Inputs
+
+| Input | Description |
+|-------|-------------|
+| A3-A0 | 4-bit number A (A3 is MSB) |
+| B3-B0 | 4-bit number B (B3 is MSB) |
+
+## Architecture
+
+```
+A3 A2 A1 A0 B3 B2 B1 B0
+ |  |  |  |  |  |  |  |
+ +--+--+--+--+--+--+--+
+ |                    |
+ v                    v
+[GT: A-B >= 1]    [LT: B-A >= 1]
+     |                 |
+     +--------+--------+
+              |
+              v
+         [EQ: NOR(GT,LT)]
+```
+
+Layer 1:
+- GT: weights [8, 4, 2, 1, -8, -4, -2, -1], bias -1
+- LT: weights [-8, -4, -2, -1, 8, 4, 2, 1], bias -1
+
+Layer 2:
+- EQ: weights [-1, -1], bias 0 (NOR gate)
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 8 |
+| Outputs | 3 (GT, LT, EQ) |
+| Neurons | 3 |
+| Layers | 2 |
+| Parameters | 21 |
+| Magnitude | 64 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def compare4(a3, a2, a1, a0, b3, b2, b1, b0):
+    inp = torch.tensor([float(a3), float(a2), float(a1), float(a0),
+                        float(b3), float(b2), float(b1), float(b0)])
+    gt = int((inp @ w['gt.weight'].T + w['gt.bias'] >= 0).item())
+    lt = int((inp @ w['lt.weight'].T + w['lt.bias'] >= 0).item())
+    gt_lt = torch.tensor([float(gt), float(lt)])
+    eq = int((gt_lt @ w['eq.weight'].T + w['eq.bias'] >= 0).item())
+    return gt, lt, eq
+
+# Compare 5 vs 3
+gt, lt, eq = compare4(0, 1, 0, 1, 0, 0, 1, 1)
+print(f"5 vs 3: GT={gt}, LT={lt}, EQ={eq}")  # GT=1, LT=0, EQ=0
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-comparator4bit",
+  "description": "4-bit magnitude comparator",
+  "inputs": 8,
+  "outputs": 3,
+  "neurons": 3,
+  "layers": 2,
+  "parameters": 21
+}

create_safetensors.py

@@ -0,0 +1,55 @@
+import torch
+from safetensors.torch import save_file
+
+# Inputs: A3, A2, A1, A0, B3, B2, B1, B0
+# Outputs: GT (A>B), LT (A<B), EQ (A=B)
+
+weights = {}
+
+# Layer 1: GT and LT neurons (single layer, direct from inputs)
+# GT: A - B >= 1 (fires when A > B)
+weights['gt.weight'] = torch.tensor([[8.0, 4.0, 2.0, 1.0, -8.0, -4.0, -2.0, -1.0]], dtype=torch.float32)
+weights['gt.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# LT: B - A >= 1 (fires when A < B)
+weights['lt.weight'] = torch.tensor([[-8.0, -4.0, -2.0, -1.0, 8.0, 4.0, 2.0, 1.0]], dtype=torch.float32)
+weights['lt.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# Layer 2: EQ = NOR(GT, LT) - fires when both GT and LT are 0
+weights['eq.weight'] = torch.tensor([[-1.0, -1.0]], dtype=torch.float32)
+weights['eq.bias'] = torch.tensor([0.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+# Verify
+def compare4(a3, a2, a1, a0, b3, b2, b1, b0):
+    inp = torch.tensor([float(a3), float(a2), float(a1), float(a0),
+                        float(b3), float(b2), float(b1), float(b0)])
+    gt = int((inp @ weights['gt.weight'].T + weights['gt.bias'] >= 0).item())
+    lt = int((inp @ weights['lt.weight'].T + weights['lt.bias'] >= 0).item())
+    gt_lt = torch.tensor([float(gt), float(lt)])
+    eq = int((gt_lt @ weights['eq.weight'].T + weights['eq.bias'] >= 0).item())
+    return gt, lt, eq
+
+print("Verifying comparator4bit...")
+errors = 0
+for a in range(16):
+    for b in range(16):
+        a3, a2, a1, a0 = (a >> 3) & 1, (a >> 2) & 1, (a >> 1) & 1, a & 1
+        b3, b2, b1, b0 = (b >> 3) & 1, (b >> 2) & 1, (b >> 1) & 1, b & 1
+        gt, lt, eq = compare4(a3, a2, a1, a0, b3, b2, b1, b0)
+        exp_gt = 1 if a > b else 0
+        exp_lt = 1 if a < b else 0
+        exp_eq = 1 if a == b else 0
+        if (gt, lt, eq) != (exp_gt, exp_lt, exp_eq):
+            errors += 1
+            if errors <= 5:
+                print(f"ERROR: A={a}, B={b}, got ({gt},{lt},{eq}), expected ({exp_gt},{exp_lt},{exp_eq})")
+
+if errors == 0:
+    print("All 256 test cases passed!")
+else:
+    print(f"FAILED: {errors} errors")
+
+mag = sum(t.abs().sum().item() for t in weights.values())
+print(f"Magnitude: {mag:.0f}")

model.py

@@ -0,0 +1,24 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def compare4(a3, a2, a1, a0, b3, b2, b1, b0, weights):
+    """4-bit magnitude comparator. Returns (GT, LT, EQ)."""
+    inp = torch.tensor([float(a3), float(a2), float(a1), float(a0),
+                        float(b3), float(b2), float(b1), float(b0)])
+    gt = int((inp @ weights['gt.weight'].T + weights['gt.bias'] >= 0).item())
+    lt = int((inp @ weights['lt.weight'].T + weights['lt.bias'] >= 0).item())
+    gt_lt = torch.tensor([float(gt), float(lt)])
+    eq = int((gt_lt @ weights['eq.weight'].T + weights['eq.bias'] >= 0).item())
+    return gt, lt, eq
+
+if __name__ == '__main__':
+    w = load_model()
+    print('Comparator4bit examples:')
+    for a, b in [(5, 3), (3, 5), (7, 7), (0, 15), (15, 0)]:
+        a3, a2, a1, a0 = (a >> 3) & 1, (a >> 2) & 1, (a >> 1) & 1, a & 1
+        b3, b2, b1, b0 = (b >> 3) & 1, (b >> 2) & 1, (b >> 1) & 1, b & 1
+        gt, lt, eq = compare4(a3, a2, a1, a0, b3, b2, b1, b0, w)
+        print(f'  A={a:2d}, B={b:2d} -> GT={gt}, LT={lt}, EQ={eq}')