8-bit popcount threshold circuit, magnitude 163

README.md

@@ -0,0 +1,61 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+---
+
+# threshold-popcount8
+
+8-bit population count. Counts the number of 1 bits in an 8-bit input.
+
+## Function
+
+popcount8(a7..a0) = count of 1 bits (0 to 8)
+
+Output is 4 bits: y3y2y1y0 representing count in binary.
+
+## Truth Table (selected rows)
+
+| Input | Count | Output |
+|-------|-------|--------|
+| 00000000 | 0 | 0000 |
+| 00000001 | 1 | 0001 |
+| 01010101 | 4 | 0100 |
+| 11110000 | 4 | 0100 |
+| 11111111 | 8 | 1000 |
+
+## Architecture
+
+- y3 = (sum == 8)
+- y2 = (sum >= 4) AND (sum <= 7)
+- y1 = ((sum >= 2) AND (sum <= 3)) OR ((sum >= 6) AND (sum <= 7))
+- y0 = XOR8 (parity of all 8 bits)
+
+The parity computation uses a tree of XOR gates: XOR pairs, then XOR the results.
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 8 |
+| Outputs | 4 |
+| Neurons | 31 |
+| Layers | 5 |
+| Parameters | 177 |
+| Magnitude | 163 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+# See create_safetensors.py for full implementation
+
+# popcount8(1,0,1,0,1,0,1,0) = [0,1,0,0] = 4
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-popcount8",
+  "description": "8-bit population count (count 1 bits)",
+  "inputs": 8,
+  "outputs": 4,
+  "neurons": 31,
+  "layers": 5,
+  "parameters": 177
+}

create_safetensors.py

@@ -0,0 +1,175 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# 8-bit popcount: count number of 1s, output 0-8 in binary (4 bits)
+# y3 = (sum == 8)
+# y2 = (sum >= 4) AND (sum <= 7)
+# y1 = ((sum >= 2) AND (sum <= 3)) OR ((sum >= 6) AND (sum <= 7))
+# y0 = XOR8 (parity)
+
+# Layer 1: threshold comparisons and XOR components
+ones = [1.0] * 8
+neg_ones = [-1.0] * 8
+
+# y3 = sum >= 8
+weights['y3.weight'] = torch.tensor([ones], dtype=torch.float32)
+weights['y3.bias'] = torch.tensor([-8.0], dtype=torch.float32)
+
+# ge4 = sum >= 4
+weights['ge4.weight'] = torch.tensor([ones], dtype=torch.float32)
+weights['ge4.bias'] = torch.tensor([-4.0], dtype=torch.float32)
+
+# le7 = sum <= 7
+weights['le7.weight'] = torch.tensor([neg_ones], dtype=torch.float32)
+weights['le7.bias'] = torch.tensor([7.0], dtype=torch.float32)
+
+# ge2 = sum >= 2
+weights['ge2.weight'] = torch.tensor([ones], dtype=torch.float32)
+weights['ge2.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# le3 = sum <= 3
+weights['le3.weight'] = torch.tensor([neg_ones], dtype=torch.float32)
+weights['le3.bias'] = torch.tensor([3.0], dtype=torch.float32)
+
+# ge6 = sum >= 6
+weights['ge6.weight'] = torch.tensor([ones], dtype=torch.float32)
+weights['ge6.bias'] = torch.tensor([-6.0], dtype=torch.float32)
+
+# XOR pairs for parity: XOR(a0,a1), XOR(a2,a3), XOR(a4,a5), XOR(a6,a7)
+for i, pair in enumerate([(0,1), (2,3), (4,5), (6,7)]):
+    w = [0.0] * 8
+    w[pair[0]] = 1.0
+    w[pair[1]] = 1.0
+    weights[f'xor_{i}_or.weight'] = torch.tensor([w], dtype=torch.float32)
+    weights[f'xor_{i}_or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+    w_nand = [0.0] * 8
+    w_nand[pair[0]] = -1.0
+    w_nand[pair[1]] = -1.0
+    weights[f'xor_{i}_nand.weight'] = torch.tensor([w_nand], dtype=torch.float32)
+    weights[f'xor_{i}_nand.bias'] = torch.tensor([1.0], dtype=torch.float32)
+
+# Layer 2: y2, first-level XORs, and y1 components
+# y2 = AND(ge4, le7)
+weights['y2.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['y2.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# in23 = AND(ge2, le3)
+weights['in23.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['in23.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# in67 = AND(ge6, le7)
+weights['in67.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['in67.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# XOR results
+for i in range(4):
+    weights[f'xor_{i}.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+    weights[f'xor_{i}.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# Layer 3: y1 = OR(in23, in67), XOR pairs for next level
+weights['y1.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['y1.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# XOR(xor_0, xor_1)
+weights['xor_01_or.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['xor_01_or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+weights['xor_01_nand.weight'] = torch.tensor([[-1.0, -1.0]], dtype=torch.float32)
+weights['xor_01_nand.bias'] = torch.tensor([1.0], dtype=torch.float32)
+
+# XOR(xor_2, xor_3)
+weights['xor_23_or.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['xor_23_or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+weights['xor_23_nand.weight'] = torch.tensor([[-1.0, -1.0]], dtype=torch.float32)
+weights['xor_23_nand.bias'] = torch.tensor([1.0], dtype=torch.float32)
+
+# Layer 4
+weights['xor_01.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['xor_01.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+weights['xor_23.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['xor_23.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# XOR(xor_01, xor_23)
+weights['xor_final_or.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['xor_final_or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+weights['xor_final_nand.weight'] = torch.tensor([[-1.0, -1.0]], dtype=torch.float32)
+weights['xor_final_nand.bias'] = torch.tensor([1.0], dtype=torch.float32)
+
+# Layer 5
+weights['y0.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['y0.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+# Verify
+def popcount8(a7, a6, a5, a4, a3, a2, a1, a0):
+    inp = torch.tensor([float(a7), float(a6), float(a5), float(a4),
+                        float(a3), float(a2), float(a1), float(a0)])
+
+    # Layer 1
+    y3 = int((inp @ weights['y3.weight'].T + weights['y3.bias'] >= 0).item())
+    ge4 = int((inp @ weights['ge4.weight'].T + weights['ge4.bias'] >= 0).item())
+    le7 = int((inp @ weights['le7.weight'].T + weights['le7.bias'] >= 0).item())
+    ge2 = int((inp @ weights['ge2.weight'].T + weights['ge2.bias'] >= 0).item())
+    le3 = int((inp @ weights['le3.weight'].T + weights['le3.bias'] >= 0).item())
+    ge6 = int((inp @ weights['ge6.weight'].T + weights['ge6.bias'] >= 0).item())
+
+    xor_ors = []
+    xor_nands = []
+    for i in range(4):
+        xor_ors.append(int((inp @ weights[f'xor_{i}_or.weight'].T + weights[f'xor_{i}_or.bias'] >= 0).item()))
+        xor_nands.append(int((inp @ weights[f'xor_{i}_nand.weight'].T + weights[f'xor_{i}_nand.bias'] >= 0).item()))
+
+    # Layer 2
+    y2 = int((torch.tensor([float(ge4), float(le7)]) @ weights['y2.weight'].T + weights['y2.bias'] >= 0).item())
+    in23 = int((torch.tensor([float(ge2), float(le3)]) @ weights['in23.weight'].T + weights['in23.bias'] >= 0).item())
+    in67 = int((torch.tensor([float(ge6), float(le7)]) @ weights['in67.weight'].T + weights['in67.bias'] >= 0).item())
+
+    xors = []
+    for i in range(4):
+        x = int((torch.tensor([float(xor_ors[i]), float(xor_nands[i])]) @ weights[f'xor_{i}.weight'].T + weights[f'xor_{i}.bias'] >= 0).item())
+        xors.append(x)
+
+    # Layer 3
+    y1 = int((torch.tensor([float(in23), float(in67)]) @ weights['y1.weight'].T + weights['y1.bias'] >= 0).item())
+
+    xor_01_or = int((torch.tensor([float(xors[0]), float(xors[1])]) @ weights['xor_01_or.weight'].T + weights['xor_01_or.bias'] >= 0).item())
+    xor_01_nand = int((torch.tensor([float(xors[0]), float(xors[1])]) @ weights['xor_01_nand.weight'].T + weights['xor_01_nand.bias'] >= 0).item())
+    xor_23_or = int((torch.tensor([float(xors[2]), float(xors[3])]) @ weights['xor_23_or.weight'].T + weights['xor_23_or.bias'] >= 0).item())
+    xor_23_nand = int((torch.tensor([float(xors[2]), float(xors[3])]) @ weights['xor_23_nand.weight'].T + weights['xor_23_nand.bias'] >= 0).item())
+
+    # Layer 4
+    xor_01 = int((torch.tensor([float(xor_01_or), float(xor_01_nand)]) @ weights['xor_01.weight'].T + weights['xor_01.bias'] >= 0).item())
+    xor_23 = int((torch.tensor([float(xor_23_or), float(xor_23_nand)]) @ weights['xor_23.weight'].T + weights['xor_23.bias'] >= 0).item())
+
+    xor_final_or = int((torch.tensor([float(xor_01), float(xor_23)]) @ weights['xor_final_or.weight'].T + weights['xor_final_or.bias'] >= 0).item())
+    xor_final_nand = int((torch.tensor([float(xor_01), float(xor_23)]) @ weights['xor_final_nand.weight'].T + weights['xor_final_nand.bias'] >= 0).item())
+
+    # Layer 5
+    y0 = int((torch.tensor([float(xor_final_or), float(xor_final_nand)]) @ weights['y0.weight'].T + weights['y0.bias'] >= 0).item())
+
+    return [y3, y2, y1, y0]
+
+print("Verifying popcount8...")
+errors = 0
+for i in range(256):
+    bits = [(i >> j) & 1 for j in range(7, -1, -1)]
+    result = popcount8(*bits)
+    count = sum(bits)
+    expected = [(count >> 3) & 1, (count >> 2) & 1, (count >> 1) & 1, count & 1]
+    if result != expected:
+        errors += 1
+        if errors <= 5:
+            print(f"ERROR: {i:08b} count={count} -> {result}, expected {expected}")
+
+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}")
+print(f"Neurons: {len([k for k in weights.keys() if 'weight' in k])}")
+print(f"Parameters: {sum(t.numel() for t in weights.values())}")

model.py

@@ -0,0 +1,22 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def popcount8(a7, a6, a5, a4, a3, a2, a1, a0, weights):
+    """8-bit population count: returns count of 1 bits as 4-bit value"""
+    inp = torch.tensor([float(a7), float(a6), float(a5), float(a4),
+                        float(a3), float(a2), float(a1), float(a0)])
+    # See create_safetensors.py for full implementation
+    # Returns [y3, y2, y1, y0] where y3y2y1y0 is the count in binary
+    pass
+
+if __name__ == '__main__':
+    w = load_model()
+    print('Popcount8 examples:')
+    examples = [0b00000000, 0b00000001, 0b01010101, 0b11111111, 0b11110000]
+    for val in examples:
+        bits = [(val >> j) & 1 for j in range(7, -1, -1)]
+        count = sum(bits)
+        print(f'  {val:08b} -> {count}')