Upload folder using huggingface_hub

README.md

@@ -0,0 +1,124 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- prefix
+- parity
+---
+
+# threshold-prefix-xor
+
+4-bit parallel prefix XOR (running parity). Computes cumulative XOR from MSB to each position. Essential for parity-based error detection.
+
+## Circuit
+
+```
+    x3      x2      x1      x0
+     │       │       │       │
+     ▼       │       │       │
+   ┌───┐     │       │       │
+   │y3 │     │       │       │
+   │=x3│     │       │       │
+   └───┘     ▼       │       │
+     │     ┌─────┐   │       │
+     └────►│ XOR │   │       │
+           │ y2  │   │       │
+           └─────┘   ▼       │
+             │     ┌─────┐   │
+             └────►│ XOR │   │
+                   │ y1  │   │
+                   └─────┘   ▼
+                     │     ┌─────┐
+                     └────►│ XOR │
+                           │ y0  │
+                           └─────┘
+```
+
+## Function
+
+```
+prefix_xor(x3, x2, x1, x0) -> (y3, y2, y1, y0)
+
+y3 = x3
+y2 = x3 XOR x2
+y1 = x3 XOR x2 XOR x1
+y0 = x3 XOR x2 XOR x1 XOR x0  (full parity)
+```
+
+Each output yi is the XOR (parity) of all inputs from x3 down to xi.
+
+## Truth Table (selected)
+
+| x3 x2 x1 x0 | y3 y2 y1 y0 | y0 = parity |
+|-------------|-------------|-------------|
+| 0 0 0 0 | 0 0 0 0 | even (0) |
+| 0 0 0 1 | 0 0 0 1 | odd (1) |
+| 0 0 1 1 | 0 0 1 0 | even (0) |
+| 0 1 1 1 | 0 1 0 1 | odd (1) |
+| 1 1 1 1 | 1 0 1 0 | even (0) |
+| 1 0 1 0 | 1 1 0 0 | even (0) |
+| 1 1 0 0 | 1 0 0 0 | even (0) |
+
+## Mechanism
+
+Unlike prefix-AND and prefix-OR, prefix-XOR requires sequential XOR gates because XOR is not a simple threshold function.
+
+**Architecture:** Chain of 3 XOR gates (each XOR = 3 neurons)
+
+| Stage | Computes | Neurons |
+|-------|----------|---------|
+| 1 | y3 = x3 (passthrough) | 0 |
+| 2 | y2 = y3 XOR x2 | 3 |
+| 3 | y1 = y2 XOR x1 | 3 |
+| 4 | y0 = y1 XOR x0 | 3 |
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 4 |
+| Outputs | 4 |
+| Neurons | 9 |
+| Layers | 6 |
+| Parameters | 27 |
+| Magnitude | 30 |
+
+## Applications
+
+- **Running parity:** y_i gives parity of bits from MSB to position i
+- **Error detection:** Final y0 is overall parity bit
+- **Gray code generation:** Related to Gray code conversions
+- **Checksum computation:** Partial checksums at each position
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def xor2(a, b, prefix):
+    inp = torch.tensor([float(a), float(b)])
+    or_out = int((inp @ w[f'{prefix}.or.weight'].T + w[f'{prefix}.or.bias'] >= 0).item())
+    nand_out = int((inp @ w[f'{prefix}.nand.weight'].T + w[f'{prefix}.nand.bias'] >= 0).item())
+    l1 = torch.tensor([float(or_out), float(nand_out)])
+    return int((l1 @ w[f'{prefix}.and.weight'].T + w[f'{prefix}.and.bias'] >= 0).item())
+
+def prefix_xor(x3, x2, x1, x0):
+    y3 = x3
+    y2 = xor2(y3, x2, 'xor2')
+    y1 = xor2(y2, x1, 'xor1')
+    y0 = xor2(y1, x0, 'xor0')
+    return y3, y2, y1, y0
+
+print(prefix_xor(1, 1, 1, 1))  # (1, 0, 1, 0) - even parity
+print(prefix_xor(1, 0, 0, 0))  # (1, 1, 1, 1) - odd parity
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-prefix-xor",
+  "description": "4-bit parallel prefix XOR (running parity)",
+  "inputs": 4,
+  "outputs": 4,
+  "neurons": 9,
+  "layers": 6,
+  "parameters": 27
+}

create_safetensors.py

@@ -0,0 +1,52 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+def add_xor(prefix):
+    weights[f'{prefix}.or.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+    weights[f'{prefix}.or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+    weights[f'{prefix}.nand.weight'] = torch.tensor([[-1.0, -1.0]], dtype=torch.float32)
+    weights[f'{prefix}.nand.bias'] = torch.tensor([1.0], dtype=torch.float32)
+    weights[f'{prefix}.and.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+    weights[f'{prefix}.and.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# y3 = x3 (passthrough, no gate needed)
+# y2 = x3 XOR x2
+add_xor('xor2')
+# y1 = y2 XOR x1
+add_xor('xor1')
+# y0 = y1 XOR x0
+add_xor('xor0')
+
+save_file(weights, 'model.safetensors')
+
+def xor2(a, b, prefix):
+    inp = torch.tensor([float(a), float(b)])
+    or_out = int((inp @ weights[f'{prefix}.or.weight'].T + weights[f'{prefix}.or.bias'] >= 0).item())
+    nand_out = int((inp @ weights[f'{prefix}.nand.weight'].T + weights[f'{prefix}.nand.bias'] >= 0).item())
+    l1 = torch.tensor([float(or_out), float(nand_out)])
+    return int((l1 @ weights[f'{prefix}.and.weight'].T + weights[f'{prefix}.and.bias'] >= 0).item())
+
+def prefix_xor(x3, x2, x1, x0):
+    y3 = x3
+    y2 = xor2(y3, x2, 'xor2')
+    y1 = xor2(y2, x1, 'xor1')
+    y0 = xor2(y1, x0, 'xor0')
+    return y3, y2, y1, y0
+
+print("Verifying prefix-xor...")
+errors = 0
+for i in range(16):
+    x3, x2, x1, x0 = (i >> 3) & 1, (i >> 2) & 1, (i >> 1) & 1, i & 1
+    y3, y2, y1, y0 = prefix_xor(x3, x2, x1, x0)
+    exp_y3 = x3
+    exp_y2 = x3 ^ x2
+    exp_y1 = x3 ^ x2 ^ x1
+    exp_y0 = x3 ^ x2 ^ x1 ^ x0
+    if (y3, y2, y1, y0) != (exp_y3, exp_y2, exp_y1, exp_y0):
+        errors += 1
+        print(f"ERROR: {x3}{x2}{x1}{x0} -> {y3}{y2}{y1}{y0}, expected {exp_y3}{exp_y2}{exp_y1}{exp_y0}")
+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,27 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def xor2(a, b, prefix, w):
+    inp = torch.tensor([float(a), float(b)])
+    or_out = int((inp @ w[f'{prefix}.or.weight'].T + w[f'{prefix}.or.bias'] >= 0).item())
+    nand_out = int((inp @ w[f'{prefix}.nand.weight'].T + w[f'{prefix}.nand.bias'] >= 0).item())
+    l1 = torch.tensor([float(or_out), float(nand_out)])
+    return int((l1 @ w[f'{prefix}.and.weight'].T + w[f'{prefix}.and.bias'] >= 0).item())
+
+def prefix_xor(x3, x2, x1, x0, w):
+    y3 = x3
+    y2 = xor2(y3, x2, 'xor2', w)
+    y1 = xor2(y2, x1, 'xor1', w)
+    y0 = xor2(y1, x0, 'xor0', w)
+    return y3, y2, y1, y0
+
+if __name__ == '__main__':
+    w = load_model()
+    print('Prefix-XOR (running parity):')
+    for i in [0b0000, 0b0001, 0b0011, 0b0111, 0b1111, 0b1010]:
+        x3, x2, x1, x0 = (i >> 3) & 1, (i >> 2) & 1, (i >> 1) & 1, i & 1
+        y3, y2, y1, y0 = prefix_xor(x3, x2, x1, x0, w)
+        print(f'{x3}{x2}{x1}{x0} -> {y3}{y2}{y1}{y0} (parity={y0})')

model.safetensors

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