8-bit parity tree

README.md

@@ -0,0 +1,96 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- parity
+---
+
+# threshold-parity-tree
+
+8-bit parity computation using balanced XOR tree structure for minimum depth.
+
+## Circuit
+
+```
+x7 ─┬─[XOR]─┐
+x6 ─┘       ├─[XOR]─┐
+x5 ─┬─[XOR]─┘       │
+x4 ─┘               ├─[XOR]──► parity
+x3 ─┬─[XOR]─┐       │
+x2 ─┘       ├─[XOR]─┘
+x1 ─┬─[XOR]─┘
+x0 ─┘
+```
+
+## Output
+
+- **parity = 0**: Even number of 1s in input
+- **parity = 1**: Odd number of 1s in input
+
+## Tree vs Linear
+
+```
+Linear chain (depth 7):
+x0─[XOR]─[XOR]─[XOR]─[XOR]─[XOR]─[XOR]─[XOR]─► parity
+    x1    x2    x3    x4    x5    x6    x7
+
+Tree structure (depth 3):
+Layer 1: 4 parallel XORs
+Layer 2: 2 parallel XORs
+Layer 3: 1 final XOR
+```
+
+## Architecture
+
+| Layer | XOR Gates | Function |
+|-------|-----------|----------|
+| 1 | 4 | Pairs: (0,1), (2,3), (4,5), (6,7) |
+| 2 | 2 | Pairs: (01,23), (45,67) |
+| 3 | 1 | Final: (0123,4567) |
+
+**Total: 21 neurons (7 XORs × 3), 111 parameters, 3 layers**
+
+## Scalability
+
+For n-bit parity:
+- Tree depth: log₂(n)
+- XOR gates: n - 1
+- Linear depth: n - 1
+
+| Bits | Tree Depth | Linear Depth |
+|------|------------|--------------|
+| 8 | 3 | 7 |
+| 16 | 4 | 15 |
+| 32 | 5 | 31 |
+| 64 | 6 | 63 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+
+w = load_file('model.safetensors')
+
+# Examples:
+# 0x00 (00000000) → parity=0
+# 0x01 (00000001) → parity=1
+# 0x03 (00000011) → parity=0
+# 0xFF (11111111) → parity=0
+```
+
+## Files
+
+```
+threshold-parity-tree/
+├── model.safetensors
+├── create_safetensors.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-parity-tree",
+  "description": "8-bit parity using balanced XOR tree",
+  "inputs": 8,
+  "outputs": 1,
+  "neurons": 21,
+  "layers": 3,
+  "parameters": 111
+}

create_safetensors.py

@@ -0,0 +1,92 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# 8-bit Parity Tree
+# Inputs: x7,x6,x5,x4,x3,x2,x1,x0 (8 inputs)
+# Output: parity (1 output)
+#
+# Tree structure (balanced, depth 3):
+# Layer 1: XOR pairs (4 XORs)
+#   p01 = x0 XOR x1
+#   p23 = x2 XOR x3
+#   p45 = x4 XOR x5
+#   p67 = x6 XOR x7
+# Layer 2: XOR pairs (2 XORs)
+#   p0123 = p01 XOR p23
+#   p4567 = p45 XOR p67
+# Layer 3: Final XOR
+#   parity = p0123 XOR p4567
+
+def add_xor_from_inputs(name, a_idx, b_idx, total_inputs):
+    w_or = [0.0] * total_inputs
+    w_or[a_idx] = 1.0
+    w_or[b_idx] = 1.0
+    weights[f'{name}.or.weight'] = torch.tensor([w_or], dtype=torch.float32)
+    weights[f'{name}.or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+    w_nand = [0.0] * total_inputs
+    w_nand[a_idx] = -1.0
+    w_nand[b_idx] = -1.0
+    weights[f'{name}.nand.weight'] = torch.tensor([w_nand], dtype=torch.float32)
+    weights[f'{name}.nand.bias'] = torch.tensor([1.0], dtype=torch.float32)
+    weights[f'{name}.and.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+    weights[f'{name}.and.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+def add_xor(name):
+    weights[f'{name}.or.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+    weights[f'{name}.or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+    weights[f'{name}.nand.weight'] = torch.tensor([[-1.0, -1.0]], dtype=torch.float32)
+    weights[f'{name}.nand.bias'] = torch.tensor([1.0], dtype=torch.float32)
+    weights[f'{name}.and.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+    weights[f'{name}.and.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# Layer 1: XOR pairs from inputs
+add_xor_from_inputs('xor01', 0, 1, 8)
+add_xor_from_inputs('xor23', 2, 3, 8)
+add_xor_from_inputs('xor45', 4, 5, 8)
+add_xor_from_inputs('xor67', 6, 7, 8)
+
+# Layer 2: XOR pairs
+add_xor('xor0123')
+add_xor('xor4567')
+
+# Layer 3: Final XOR
+add_xor('parity')
+
+save_file(weights, 'model.safetensors')
+
+def eval_xor(a, b):
+    return int((a or b) and not (a and b))
+
+def parity_tree(x):
+    bits = [(x >> i) & 1 for i in range(8)]
+    p01 = eval_xor(bits[0], bits[1])
+    p23 = eval_xor(bits[2], bits[3])
+    p45 = eval_xor(bits[4], bits[5])
+    p67 = eval_xor(bits[6], bits[7])
+    p0123 = eval_xor(p01, p23)
+    p4567 = eval_xor(p45, p67)
+    return eval_xor(p0123, p4567)
+
+print("Verifying 8-bit Parity Tree...")
+errors = 0
+for x in range(256):
+    result = parity_tree(x)
+    expected = bin(x).count('1') % 2
+    if result != expected:
+        errors += 1
+        if errors <= 5:
+            print(f"ERROR: x={x:08b} ({x}), got {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"Parameters: {sum(t.numel() for t in weights.values())}")
+
+print("\nTree depth: 3 (vs 7 for linear chain)")
+print("Total XOR gates: 7")