8:1 multiplexer threshold circuit, magnitude 61

README.md

@@ -0,0 +1,88 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+---
+
+# threshold-mux8
+
+8:1 multiplexer. Selects one of 8 data inputs based on 3-bit select signal.
+
+## Function
+
+MUX8(d0-d7, s2,s1,s0) = d[s] where s = 4*s2 + 2*s1 + s0
+
+## Architecture
+
+```
+d0 d1 d2 d3 d4 d5 d6 d7   s2 s1 s0
+ |  |  |  |  |  |  |  |    |  |  |
+ +--+--+--+--+--+--+--+----+--+--+
+ |                              |
+ v                              v
+[N0] d0 AND (s=000)  ----+
+[N1] d1 AND (s=001)  ----|
+[N2] d2 AND (s=010)  ----|
+[N3] d3 AND (s=011)  ----+---> [OR] ---> output
+[N4] d4 AND (s=100)  ----|
+[N5] d5 AND (s=101)  ----|
+[N6] d6 AND (s=110)  ----|
+[N7] d7 AND (s=111)  ----+
+```
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 11 (8 data + 3 select) |
+| Outputs | 1 |
+| Neurons | 9 |
+| Layers | 2 |
+| Parameters | 105 |
+| Magnitude | 61 |
+
+## Layer 1 Weights
+
+Each neuron Ni fires when di=1 AND s=i:
+
+| Neuron | Data weights | Select weights (s2,s1,s0) | Bias |
+|--------|--------------|---------------------------|------|
+| N0 | d0=1 | [-1,-1,-1] | -1 |
+| N1 | d1=1 | [-1,-1,+1] | -2 |
+| N2 | d2=1 | [-1,+1,-1] | -2 |
+| N3 | d3=1 | [-1,+1,+1] | -3 |
+| N4 | d4=1 | [+1,-1,-1] | -2 |
+| N5 | d5=1 | [+1,-1,+1] | -3 |
+| N6 | d6=1 | [+1,+1,-1] | -3 |
+| N7 | d7=1 | [+1,+1,+1] | -4 |
+
+## Layer 2
+
+OR gate: weights [1,1,1,1,1,1,1,1], bias -1
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def mux8(d0, d1, d2, d3, d4, d5, d6, d7, s2, s1, s0):
+    inp = torch.tensor([float(d0), float(d1), float(d2), float(d3),
+                        float(d4), float(d5), float(d6), float(d7),
+                        float(s2), float(s1), float(s0)])
+    l1 = (inp @ w['layer1.weight'].T + w['layer1.bias'] >= 0).float()
+    out = (l1 @ w['layer2.weight'].T + w['layer2.bias'] >= 0).float()
+    return int(out.item())
+
+# Select d5 (s=101)
+print(mux8(0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1))  # 1
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-mux8",
+  "description": "8:1 multiplexer as threshold circuit",
+  "inputs": 11,
+  "outputs": 1,
+  "neurons": 9,
+  "layers": 2,
+  "parameters": 105
+}

create_safetensors.py

@@ -0,0 +1,67 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# Input order: d0, d1, d2, d3, d4, d5, d6, d7, s2, s1, s0 (11 inputs)
+# Layer 1: 8 neurons, each selects di when s = i
+# Layer 2: OR gate combining all 8
+
+layer1_weights = []
+layer1_biases = []
+
+for i in range(8):
+    w = [0.0] * 11
+    # Data input weight
+    w[i] = 1.0
+    # Select weights: +1 if bit should be 1, -1 if bit should be 0
+    s2_bit = (i >> 2) & 1
+    s1_bit = (i >> 1) & 1
+    s0_bit = i & 1
+    w[8] = 1.0 if s2_bit else -1.0   # s2
+    w[9] = 1.0 if s1_bit else -1.0   # s1
+    w[10] = 1.0 if s0_bit else -1.0  # s0
+    # Bias: -(1 + popcount(i))
+    bias = -(1 + bin(i).count('1'))
+    layer1_weights.append(w)
+    layer1_biases.append(bias)
+
+weights['layer1.weight'] = torch.tensor(layer1_weights, dtype=torch.float32)
+weights['layer1.bias'] = torch.tensor(layer1_biases, dtype=torch.float32)
+
+# Layer 2: OR gate
+weights['layer2.weight'] = torch.tensor([[1.0] * 8], dtype=torch.float32)
+weights['layer2.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+# Verify
+def mux8(d0, d1, d2, d3, d4, d5, d6, d7, s2, s1, s0):
+    inp = torch.tensor([float(d0), float(d1), float(d2), float(d3),
+                        float(d4), float(d5), float(d6), float(d7),
+                        float(s2), float(s1), float(s0)])
+    l1 = (inp @ weights['layer1.weight'].T + weights['layer1.bias'] >= 0).float()
+    out = (l1 @ weights['layer2.weight'].T + weights['layer2.bias'] >= 0).float()
+    return int(out.item())
+
+print("Verifying MUX8...")
+errors = 0
+for s in range(8):
+    s2, s1, s0 = (s >> 2) & 1, (s >> 1) & 1, s & 1
+    for d_vals in range(256):
+        d = [(d_vals >> i) & 1 for i in range(8)]
+        result = mux8(*d, s2, s1, s0)
+        expected = d[s]
+        if result != expected:
+            errors += 1
+            if errors <= 5:
+                print(f"ERROR: s={s}, d={d}, got {result}, expected {expected}")
+
+if errors == 0:
+    print("All 2048 test cases passed!")
+else:
+    print(f"FAILED: {errors} errors")
+
+# Print magnitude
+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 mux8(d0, d1, d2, d3, d4, d5, d6, d7, s2, s1, s0, weights):
+    """8:1 Multiplexer: returns d[s] where s = 4*s2 + 2*s1 + s0"""
+    inp = torch.tensor([float(d0), float(d1), float(d2), float(d3),
+                        float(d4), float(d5), float(d6), float(d7),
+                        float(s2), float(s1), float(s0)])
+    l1 = (inp @ weights['layer1.weight'].T + weights['layer1.bias'] >= 0).float()
+    out = (l1 @ weights['layer2.weight'].T + weights['layer2.bias'] >= 0).float()
+    return int(out.item())
+
+if __name__ == '__main__':
+    w = load_model()
+    print('MUX8 verification:')
+    for s in range(8):
+        s2, s1, s0 = (s >> 2) & 1, (s >> 1) & 1, s & 1
+        d = [0] * 8
+        d[s] = 1
+        result = mux8(*d, s2, s1, s0, w)
+        print(f'  s={s} ({s2}{s1}{s0}), d[{s}]=1 -> {result}')