4-to-2 priority encoder, magnitude 13

README.md

@@ -0,0 +1,73 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- encoder
+---
+
+# threshold-priorityencoder4
+
+4-to-2 priority encoder. Outputs binary encoding of highest-priority active input.
+
+## Function
+
+priority_encode(i3, i2, i1, i0) -> (y1, y0, valid)
+
+- i3 = highest priority, i0 = lowest priority
+- y1,y0 = 2-bit binary encoding of highest active input
+- valid = 1 if any input is active
+
+## Truth Table (selected)
+
+| i3 | i2 | i1 | i0 | y1 | y0 | v | highest |
+|----|----|----|----|----|----|----|---------|
+| 0 | 0 | 0 | 0 | 0 | 0 | 0 | none |
+| 0 | 0 | 0 | 1 | 0 | 0 | 1 | i0 |
+| 0 | 0 | 1 | X | 0 | 1 | 1 | i1 |
+| 0 | 1 | X | X | 1 | 0 | 1 | i2 |
+| 1 | X | X | X | 1 | 1 | 1 | i3 |
+
+## Architecture
+
+Single layer with 3 neurons:
+
+- y1 = i3 OR i2: weights [1,1,0,0], bias -1
+- y0 = i3 OR (i1 AND NOT i2): weights [2,-1,1,0], bias -1
+- v = i3 OR i2 OR i1 OR i0: weights [1,1,1,1], bias -1
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 4 |
+| Outputs | 3 |
+| Neurons | 3 |
+| Layers | 1 |
+| Parameters | 15 |
+| Magnitude | 13 |
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def priority_encode(i3, i2, i1, i0):
+    inp = torch.tensor([float(i3), float(i2), float(i1), float(i0)])
+    y1 = int((inp @ w['y1.weight'].T + w['y1.bias'] >= 0).item())
+    y0 = int((inp @ w['y0.weight'].T + w['y0.bias'] >= 0).item())
+    v = int((inp @ w['v.weight'].T + w['v.bias'] >= 0).item())
+    return y1, y0, v
+
+print(priority_encode(0, 1, 1, 0))  # (1, 0, 1) -> i2 is highest
+print(priority_encode(1, 1, 1, 1))  # (1, 1, 1) -> i3 is highest
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-priorityencoder4",
+  "description": "4-to-2 priority encoder as threshold circuit",
+  "inputs": 4,
+  "outputs": 3,
+  "neurons": 3,
+  "layers": 1,
+  "parameters": 15
+}

create_safetensors.py

@@ -0,0 +1,57 @@
+import torch
+from safetensors.torch import save_file
+
+# Input order: i3, i2, i1, i0 (i3 = highest priority)
+# Outputs: y1, y0 (binary encoding), v (valid)
+
+weights = {
+    # y1 = i3 OR i2
+    'y1.weight': torch.tensor([[1.0, 1.0, 0.0, 0.0]], dtype=torch.float32),
+    'y1.bias': torch.tensor([-1.0], dtype=torch.float32),
+    # y0 = i3 OR (NOT i2 AND i1)
+    'y0.weight': torch.tensor([[2.0, -1.0, 1.0, 0.0]], dtype=torch.float32),
+    'y0.bias': torch.tensor([-1.0], dtype=torch.float32),
+    # v = i3 OR i2 OR i1 OR i0
+    'v.weight': torch.tensor([[1.0, 1.0, 1.0, 1.0]], dtype=torch.float32),
+    'v.bias': torch.tensor([-1.0], dtype=torch.float32),
+}
+save_file(weights, 'model.safetensors')
+
+def priority_encode(i3, i2, i1, i0):
+    inp = torch.tensor([float(i3), float(i2), float(i1), float(i0)])
+    y1 = int((inp @ weights['y1.weight'].T + weights['y1.bias'] >= 0).item())
+    y0 = int((inp @ weights['y0.weight'].T + weights['y0.bias'] >= 0).item())
+    v = int((inp @ weights['v.weight'].T + weights['v.bias'] >= 0).item())
+    return y1, y0, v
+
+print("Verifying priorityencoder4...")
+errors = 0
+for val in range(16):
+    i3, i2, i1, i0 = (val >> 3) & 1, (val >> 2) & 1, (val >> 1) & 1, val & 1
+    y1, y0, v = priority_encode(i3, i2, i1, i0)
+
+    # Determine expected output
+    if i3:
+        exp_idx, exp_v = 3, 1
+    elif i2:
+        exp_idx, exp_v = 2, 1
+    elif i1:
+        exp_idx, exp_v = 1, 1
+    elif i0:
+        exp_idx, exp_v = 0, 1
+    else:
+        exp_idx, exp_v = 0, 0
+
+    exp_y1, exp_y0 = (exp_idx >> 1) & 1, exp_idx & 1
+    if exp_v == 0:
+        exp_y1, exp_y0 = 0, 0  # don't care, but we output 0
+
+    if v != exp_v or (v == 1 and (y1 != exp_y1 or y0 != exp_y0)):
+        errors += 1
+        print(f"ERROR: {i3}{i2}{i1}{i0} -> y1={y1},y0={y0},v={v}, expected {exp_y1},{exp_y0},{exp_v}")
+
+if errors == 0:
+    print("All 16 test cases passed!")
+
+mag = sum(t.abs().sum().item() for t in weights.values())
+print(f"Magnitude: {mag:.0f}")

model.py

@@ -0,0 +1,24 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def priority_encode(i3, i2, i1, i0, weights):
+    """4-to-2 priority encoder. Returns (y1, y0, valid)."""
+    inp = torch.tensor([float(i3), float(i2), float(i1), float(i0)])
+    y1 = int((inp @ weights['y1.weight'].T + weights['y1.bias'] >= 0).item())
+    y0 = int((inp @ weights['y0.weight'].T + weights['y0.bias'] >= 0).item())
+    v = int((inp @ weights['v.weight'].T + weights['v.bias'] >= 0).item())
+    return y1, y0, v
+
+if __name__ == '__main__':
+    w = load_model()
+    print('Priority Encoder 4')
+    print('i3 i2 i1 i0 | y1 y0 v | highest')
+    print('-' * 35)
+    for val in range(16):
+        i3, i2, i1, i0 = (val >> 3) & 1, (val >> 2) & 1, (val >> 1) & 1, val & 1
+        y1, y0, v = priority_encode(i3, i2, i1, i0, w)
+        highest = 'none' if v == 0 else f'i{2*y1 + y0}'
+        print(f' {i3}  {i2}  {i1}  {i0}  |  {y1}  {y0} {v} | {highest}')