2-bit equality comparator, magnitude 18

README.md

@@ -0,0 +1,63 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+---
+
+# threshold-equals2
+
+2-bit equality comparator. Outputs 1 if 2-bit A equals 2-bit B.
+
+## Function
+
+equals2(a1, a0, b1, b0) = 1 if (a1,a0) == (b1,b0), else 0
+
+## Architecture
+
+Checks if each bit pair matches using XNOR, then ANDs the results.
+
+XNOR(x, y) = (x AND y) OR (NOT x AND NOT y)
+
+**Layer 1:** (4 neurons on raw inputs)
+- and1: a1 AND b1
+- nor1: NOR(a1, b1)
+- and0: a0 AND b0
+- nor0: NOR(a0, b0)
+
+**Layer 2:** (2 neurons)
+- xnor1: OR(and1, nor1) - bit 1 matches
+- xnor0: OR(and0, nor0) - bit 0 matches
+
+**Layer 3:** (1 neuron)
+- eq: AND(xnor1, xnor0) - both bits match
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 4 (a1, a0, b1, b0) |
+| Outputs | 1 |
+| Neurons | 7 |
+| Layers | 3 |
+| Parameters | 31 |
+| Magnitude | 18 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+# Check if 2 == 2 (binary 10 == 10)
+# a1=1, a0=0, b1=1, b0=0
+# Result: 1 (equal)
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-equals2",
+  "description": "2-bit equality comparator",
+  "inputs": 4,
+  "outputs": 1,
+  "neurons": 7,
+  "layers": 3,
+  "parameters": 31
+}

create_safetensors.py

@@ -0,0 +1,69 @@
+import torch
+from safetensors.torch import save_file
+
+# equals2: checks if 2-bit A == 2-bit B
+# Inputs: a1, a0, b1, b0 (4 inputs)
+# XNOR(a1,b1) AND XNOR(a0,b0)
+# XNOR uses: AND + NOR + OR structure
+
+weights = {
+    # Layer 1: compute AND and NOR for each bit pair
+    # For bit 1: a1 (idx 0), b1 (idx 2)
+    'layer1.and1.weight': torch.tensor([[1.0, 0.0, 1.0, 0.0]], dtype=torch.float32),
+    'layer1.and1.bias': torch.tensor([-2.0], dtype=torch.float32),
+    'layer1.nor1.weight': torch.tensor([[-1.0, 0.0, -1.0, 0.0]], dtype=torch.float32),
+    'layer1.nor1.bias': torch.tensor([0.0], dtype=torch.float32),
+    # For bit 0: a0 (idx 1), b0 (idx 3)
+    'layer1.and0.weight': torch.tensor([[0.0, 1.0, 0.0, 1.0]], dtype=torch.float32),
+    'layer1.and0.bias': torch.tensor([-2.0], dtype=torch.float32),
+    'layer1.nor0.weight': torch.tensor([[0.0, -1.0, 0.0, -1.0]], dtype=torch.float32),
+    'layer1.nor0.bias': torch.tensor([0.0], dtype=torch.float32),
+
+    # Layer 2: OR(AND, NOR) = XNOR for each bit
+    'layer2.xnor1.weight': torch.tensor([[1.0, 1.0, 0.0, 0.0]], dtype=torch.float32),  # and1, nor1
+    'layer2.xnor1.bias': torch.tensor([-1.0], dtype=torch.float32),
+    'layer2.xnor0.weight': torch.tensor([[0.0, 0.0, 1.0, 1.0]], dtype=torch.float32),  # and0, nor0
+    'layer2.xnor0.bias': torch.tensor([-1.0], dtype=torch.float32),
+
+    # Layer 3: AND of both XNORs
+    'layer3.eq.weight': torch.tensor([[1.0, 1.0]], dtype=torch.float32),
+    'layer3.eq.bias': torch.tensor([-2.0], dtype=torch.float32),
+}
+
+save_file(weights, 'model.safetensors')
+
+def equals2(a1, a0, b1, b0):
+    inp = torch.tensor([float(a1), float(a0), float(b1), float(b0)])
+
+    # Layer 1
+    and1 = int((inp * weights['layer1.and1.weight']).sum() + weights['layer1.and1.bias'] >= 0)
+    nor1 = int((inp * weights['layer1.nor1.weight']).sum() + weights['layer1.nor1.bias'] >= 0)
+    and0 = int((inp * weights['layer1.and0.weight']).sum() + weights['layer1.and0.bias'] >= 0)
+    nor0 = int((inp * weights['layer1.nor0.weight']).sum() + weights['layer1.nor0.bias'] >= 0)
+
+    l1 = torch.tensor([float(and1), float(nor1), float(and0), float(nor0)])
+
+    # Layer 2
+    xnor1 = int((l1 * weights['layer2.xnor1.weight']).sum() + weights['layer2.xnor1.bias'] >= 0)
+    xnor0 = int((l1 * weights['layer2.xnor0.weight']).sum() + weights['layer2.xnor0.bias'] >= 0)
+
+    l2 = torch.tensor([float(xnor1), float(xnor0)])
+
+    # Layer 3
+    eq = int((l2 * weights['layer3.eq.weight']).sum() + weights['layer3.eq.bias'] >= 0)
+    return eq
+
+print("Verifying equals2...")
+errors = 0
+for a in range(4):
+    for b in range(4):
+        a1, a0 = (a >> 1) & 1, a & 1
+        b1, b0 = (b >> 1) & 1, b & 1
+        result = equals2(a1, a0, b1, b0)
+        expected = 1 if a == b else 0
+        if result != expected:
+            errors += 1
+            print(f"ERROR: {a} == {b}? got {result}, expected {expected}")
+if errors == 0:
+    print("All 16 test cases passed!")
+print(f"Magnitude: {sum(t.abs().sum().item() for t in weights.values()):.0f}")

model.py

@@ -0,0 +1,28 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def equals2(a1, a0, b1, b0, w):
+    inp = torch.tensor([float(a1), float(a0), float(b1), float(b0)])
+
+    and1 = int((inp * w['layer1.and1.weight']).sum() + w['layer1.and1.bias'] >= 0)
+    nor1 = int((inp * w['layer1.nor1.weight']).sum() + w['layer1.nor1.bias'] >= 0)
+    and0 = int((inp * w['layer1.and0.weight']).sum() + w['layer1.and0.bias'] >= 0)
+    nor0 = int((inp * w['layer1.nor0.weight']).sum() + w['layer1.nor0.bias'] >= 0)
+
+    l1 = torch.tensor([float(and1), float(nor1), float(and0), float(nor0)])
+    xnor1 = int((l1 * w['layer2.xnor1.weight']).sum() + w['layer2.xnor1.bias'] >= 0)
+    xnor0 = int((l1 * w['layer2.xnor0.weight']).sum() + w['layer2.xnor0.bias'] >= 0)
+
+    l2 = torch.tensor([float(xnor1), float(xnor0)])
+    return int((l2 * w['layer3.eq.weight']).sum() + w['layer3.eq.bias'] >= 0)
+
+if __name__ == '__main__':
+    w = load_model()
+    print('equals2 truth table:')
+    for a in range(4):
+        for b in range(4):
+            a1, a0, b1, b0 = (a >> 1) & 1, a & 1, (b >> 1) & 1, b & 1
+            print(f'  {a} == {b}? {equals2(a1, a0, b1, b0, w)}')