Add 8-bit magnitude comparator threshold circuit

3 neurons, 2 layers, 37 parameters, magnitude 1024.

.gitattributes

@@ -0,0 +1 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,101 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- comparison
+---
+
+# threshold-comparator8bit
+
+8-bit magnitude comparator. Compares two 8-bit unsigned values.
+
+## Function
+
+compare8(A, B) -> (GT, LT, EQ)
+
+- GT = 1 if A > B
+- LT = 1 if A < B
+- EQ = 1 if A = B
+
+Exactly one output is always active.
+
+## Architecture
+
+```
+A[7:0]          B[7:0]
+   │               │
+   └───────┬───────┘
+           │
+    ┌──────┴──────┐
+    │             │
+    ▼             ▼
+  ┌───┐         ┌───┐
+  │GT │         │LT │   Layer 1
+  │A-B│         │B-A│
+  │>=1│         │>=1│
+  └───┘         └───┘
+    │             │
+    └──────┬──────┘
+           │
+           ▼
+        ┌─────┐
+        │ EQ  │         Layer 2
+        │ NOR │
+        └─────┘
+```
+
+Uses positional weighting: treats inputs as binary numbers.
+
+**GT neuron:** weights A bits positively (128,64,32,16,8,4,2,1), B bits negatively.
+Fires when weighted sum A - B >= 1.
+
+**LT neuron:** opposite weights. Fires when B - A >= 1.
+
+**EQ neuron:** NOR of GT and LT. Fires when both are zero.
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 16 |
+| Outputs | 3 |
+| Neurons | 3 |
+| Layers | 2 |
+| Parameters | 37 |
+| Magnitude | 1024 |
+
+## Truth Table (examples)
+
+| A | B | GT | LT | EQ |
+|-----|-----|----|----|---|
+| 0 | 0 | 0 | 0 | 1 |
+| 100 | 50 | 1 | 0 | 0 |
+| 50 | 100 | 0 | 1 | 0 |
+| 255 | 255 | 0 | 0 | 1 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def compare(a, b):
+    a_bits = [(a >> (7-i)) & 1 for i in range(8)]
+    b_bits = [(b >> (7-i)) & 1 for i in range(8)]
+    inp = torch.tensor([float(x) for x in a_bits + b_bits])
+    gt = int((inp @ w['gt.weight'].T + w['gt.bias'] >= 0).item())
+    lt = int((inp @ w['lt.weight'].T + w['lt.bias'] >= 0).item())
+    eq = int((torch.tensor([float(gt), float(lt)]) @ w['eq.weight'].T + w['eq.bias'] >= 0).item())
+    return gt, lt, eq
+
+# compare(200, 100) = (1, 0, 0)  # 200 > 100
+```
+
+## License
+
+MIT

config.json

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

create_safetensors.py

@@ -0,0 +1,64 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# 8-bit Magnitude Comparator
+# Inputs: A7, A6, A5, A4, A3, A2, A1, A0, B7, B6, B5, B4, B3, B2, B1, B0 (16 inputs)
+# Outputs: GT (A>B), LT (A<B), EQ (A=B)
+#
+# Using positional weighting: A = sum(Ai * 2^i), B = sum(Bi * 2^i)
+# GT fires when A - B >= 1
+# LT fires when B - A >= 1
+# EQ fires when neither GT nor LT
+
+# Layer 1: GT and LT neurons
+# GT: A - B >= 1
+weights['gt.weight'] = torch.tensor([[128.0, 64.0, 32.0, 16.0, 8.0, 4.0, 2.0, 1.0,
+                                      -128.0, -64.0, -32.0, -16.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
+weights['lt.weight'] = torch.tensor([[-128.0, -64.0, -32.0, -16.0, -8.0, -4.0, -2.0, -1.0,
+                                      128.0, 64.0, 32.0, 16.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)
+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')
+
+def compare8(a, b):
+    a_bits = [(a >> (7-i)) & 1 for i in range(8)]
+    b_bits = [(b >> (7-i)) & 1 for i in range(8)]
+    inp = torch.tensor([float(x) for x in a_bits + b_bits])
+
+    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 comparator8bit...")
+errors = 0
+for a in range(256):
+    for b in range(256):
+        gt, lt, eq = compare8(a, b)
+        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 65536 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}")
+print(f"Parameters: {sum(t.numel() for t in weights.values())}")
+print(f"Neurons: {len([k for k in weights.keys() if 'weight' in k])}")

model.py

@@ -0,0 +1,26 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def compare8(a, b, weights):
+    """8-bit magnitude comparator. Returns (GT, LT, EQ)."""
+    a_bits = [(a >> (7-i)) & 1 for i in range(8)]
+    b_bits = [(b >> (7-i)) & 1 for i in range(8)]
+    inp = torch.tensor([float(x) for x in a_bits + b_bits])
+
+    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('8-bit Magnitude Comparator:')
+    examples = [(0, 0), (1, 0), (0, 1), (127, 128), (255, 255), (200, 100)]
+    for a, b in examples:
+        gt, lt, eq = compare8(a, b, w)
+        rel = '>' if gt else ('<' if lt else '=')
+        print(f'  {a:3d} {rel} {b:3d}  (GT={gt}, LT={lt}, EQ={eq})')

model.safetensors

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