Add 4-to-2 one-hot decoder threshold circuit

2 neurons, 1 layer, 10 parameters, magnitude 6.

.gitattributes

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

README.md

@@ -0,0 +1,95 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- encoding
+---
+
+# threshold-onehot-decoder
+
+4-to-2 one-hot decoder. Converts a 4-bit one-hot representation to a 2-bit binary value.
+
+## Function
+
+onehot_decode(y3, y2, y1, y0) -> (a1, a0)
+
+Input must have exactly one bit set.
+
+## Truth Table
+
+| y3 | y2 | y1 | y0 | a1 | a0 | Value |
+|----|----|----|----|----|-----|-------|
+| 0 | 0 | 0 | 1 | 0 | 0 | 0 |
+| 0 | 0 | 1 | 0 | 0 | 1 | 1 |
+| 0 | 1 | 0 | 0 | 1 | 0 | 2 |
+| 1 | 0 | 0 | 0 | 1 | 1 | 3 |
+
+## Architecture
+
+Single-layer implementation:
+
+```
+  y3   y2   y1   y0
+   │    │    │    │
+   └────┴────┴────┘
+         │
+    ┌────┴────┐
+    │         │
+    ▼         ▼
+  ┌───┐     ┌───┐
+  │a1 │     │a0 │  Layer 1
+  │OR │     │OR │
+  └───┘     └───┘
+    │         │
+    ▼         ▼
+```
+
+Each output is a single OR gate:
+- a0 = OR(y1, y3): w=[1,0,1,0], b=-1
+- a1 = OR(y2, y3): w=[1,1,0,0], b=-1
+
+The decoder recognizes that:
+- Bit 0 of position = 1 for positions 1 and 3
+- Bit 1 of position = 1 for positions 2 and 3
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 4 |
+| Outputs | 2 |
+| Neurons | 2 |
+| Layers | 1 |
+| Parameters | 10 |
+| Magnitude | 6 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def decode(y3, y2, y1, y0):
+    inp = torch.tensor([float(y3), float(y2), float(y1), float(y0)])
+    a0 = int((inp @ w['a0.weight'].T + w['a0.bias'] >= 0).item())
+    a1 = int((inp @ w['a1.weight'].T + w['a1.bias'] >= 0).item())
+    return a1, a0
+
+# decode(0, 1, 0, 0) = (1, 0)  # value 2
+```
+
+## Applications
+
+- Priority encoder output processing
+- State machine decoding
+- Memory address reconstruction
+- Neural network output interpretation
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-onehot-decoder",
+  "description": "4-to-2 one-hot decoder",
+  "inputs": 4,
+  "outputs": 2,
+  "neurons": 2,
+  "layers": 1,
+  "parameters": 10
+}

create_safetensors.py

@@ -0,0 +1,76 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# One-Hot Decoder (4-to-2)
+# Inputs: y3, y2, y1, y0 (one-hot encoding, exactly one bit set)
+# Outputs: a1, a0 (binary value 0-3)
+#
+# y3 y2 y1 y0 | a1 a0 | value
+# -----------+-------+------
+#  0  0  0  1 |  0  0 |   0
+#  0  0  1  0 |  0  1 |   1
+#  0  1  0  0 |  1  0 |   2
+#  1  0  0  0 |  1  1 |   3
+#
+# Single layer implementation:
+# a0 = OR(y1, y3) = 1 when position 1 or 3
+# a1 = OR(y2, y3) = 1 when position 2 or 3
+
+# a0 = OR(y1, y3)
+weights['a0.weight'] = torch.tensor([[1.0, 0.0, 1.0, 0.0]], dtype=torch.float32)
+weights['a0.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# a1 = OR(y2, y3)
+weights['a1.weight'] = torch.tensor([[1.0, 1.0, 0.0, 0.0]], dtype=torch.float32)
+weights['a1.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+def onehot_decode(y3, y2, y1, y0):
+    inp = torch.tensor([float(y3), float(y2), float(y1), float(y0)])
+
+    a0 = int((inp @ weights['a0.weight'].T + weights['a0.bias'] >= 0).item())
+    a1 = int((inp @ weights['a1.weight'].T + weights['a1.bias'] >= 0).item())
+
+    return a1, a0
+
+def reference_decode(y3, y2, y1, y0):
+    if y0 == 1:
+        return 0, 0
+    if y1 == 1:
+        return 0, 1
+    if y2 == 1:
+        return 1, 0
+    if y3 == 1:
+        return 1, 1
+    return 0, 0
+
+print("Verifying One-Hot Decoder (4-to-2)...")
+errors = 0
+test_cases = [(0,0,0,1), (0,0,1,0), (0,1,0,0), (1,0,0,0)]
+for y3, y2, y1, y0 in test_cases:
+    result = onehot_decode(y3, y2, y1, y0)
+    expected = reference_decode(y3, y2, y1, y0)
+    if result != expected:
+        errors += 1
+        print(f"ERROR: ({y3},{y2},{y1},{y0}) -> {result}, expected {expected}")
+
+if errors == 0:
+    print("All 4 test cases passed!")
+else:
+    print(f"FAILED: {errors} errors")
+
+print("\nTruth Table:")
+print("y3 y2 y1 y0 | a1 a0 | value")
+print("-" * 30)
+for y3, y2, y1, y0 in test_cases:
+    a1, a0 = onehot_decode(y3, y2, y1, y0)
+    val = a1 * 2 + a0
+    print(f" {y3}  {y2}  {y1}  {y0}  |  {a1}  {a0}  |   {val}")
+
+mag = sum(t.abs().sum().item() for t in weights.values())
+print(f"\nMagnitude: {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,23 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def onehot_decode(y3, y2, y1, y0, weights):
+    """Convert 4-bit one-hot encoding to 2-bit binary."""
+    inp = torch.tensor([float(y3), float(y2), float(y1), float(y0)])
+
+    a0 = int((inp @ weights['a0.weight'].T + weights['a0.bias'] >= 0).item())
+    a1 = int((inp @ weights['a1.weight'].T + weights['a1.bias'] >= 0).item())
+
+    return a1, a0
+
+if __name__ == '__main__':
+    w = load_model()
+    print('One-Hot Decoder (4-to-2):')
+    test_cases = [(0,0,0,1), (0,0,1,0), (0,1,0,0), (1,0,0,0)]
+    for y3, y2, y1, y0 in test_cases:
+        a1, a0 = onehot_decode(y3, y2, y1, y0, w)
+        val = a1 * 2 + a0
+        print(f'  {y3}{y2}{y1}{y0} -> {a1}{a0} = {val}')

model.safetensors

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