Upload folder using huggingface_hub

README.md

@@ -0,0 +1,159 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- multiplexer
+---
+
+# threshold-mux2
+
+2:1 multiplexer. The fundamental building block for data selection, routing one of two inputs to the output based on a select signal.
+
+## Circuit
+
+```
+    d0      d1
+    │       │
+    │       │       s (select)
+    │       │       │
+    ├───────┼───────┤
+    │       │       │
+    ▼       │       │
+┌───────┐   │       │
+│ sel0  │◄──┼───────┤
+│d0∧¬s  │   │       │
+└───────┘   │       │
+    │       ▼       │
+    │   ┌───────┐   │
+    │   │ sel1  │◄──┘
+    │   │ d1∧s  │
+    │   └───────┘
+    │       │
+    └───┬───┘
+        ▼
+    ┌───────┐
+    │  OR   │
+    └───────┘
+        │
+        ▼
+      output
+```
+
+## Truth Table
+
+| s | d0 | d1 | out | Description |
+|---|----|----|-----|-------------|
+| 0 | 0 | 0 | 0 | Select d0 (0) |
+| 0 | 0 | 1 | 0 | Select d0 (0) |
+| 0 | 1 | 0 | 1 | Select d0 (1) |
+| 0 | 1 | 1 | 1 | Select d0 (1) |
+| 1 | 0 | 0 | 0 | Select d1 (0) |
+| 1 | 0 | 1 | 1 | Select d1 (1) |
+| 1 | 1 | 0 | 0 | Select d1 (0) |
+| 1 | 1 | 1 | 1 | Select d1 (1) |
+
+Formula: `out = (d0 AND NOT s) OR (d1 AND s)`
+
+## Mechanism
+
+**Layer 1 - Selection Gates:**
+
+The circuit uses two AND-with-complement gates that fire only when their respective data input is selected:
+
+| Gate | Weights [d0, d1, s] | Bias | Function |
+|------|---------------------|------|----------|
+| sel0 | [1, 0, -1] | -1 | d0 AND NOT(s) |
+| sel1 | [0, 1, 1] | -2 | d1 AND s |
+
+**sel0** fires when d0=1 AND s=0:
+- The negative weight on s means s=1 inhibits firing
+- Bias -1 requires d0=1 to reach threshold when s=0
+
+**sel1** fires when d1=1 AND s=1:
+- Both d1 and s must be 1 to overcome bias -2
+
+**Layer 2 - Output:**
+
+Simple OR gate combines the two selection paths.
+
+## Architecture
+
+| Component | Weights | Bias | Function |
+|-----------|---------|------|----------|
+| sel0 | [1, 0, -1] | -1 | d0 AND NOT(s) |
+| sel1 | [0, 1, 1] | -2 | d1 AND s |
+| or | [1, 1] | -1 | OR(sel0, sel1) |
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 3 (d0, d1, s) |
+| Outputs | 1 |
+| Neurons | 3 |
+| Layers | 2 |
+| Parameters | 11 |
+| Magnitude | 10 |
+
+## Building Larger Multiplexers
+
+The MUX2 is the primitive for constructing larger multiplexers:
+
+```
+MUX4  = MUX2(MUX2(d0,d1,s0), MUX2(d2,d3,s0), s1)
+MUX8  = MUX2(MUX4(d0-d3), MUX4(d4-d7), s2)
+MUX16 = MUX2(MUX8(d0-d7), MUX8(d8-d15), s3)
+```
+
+Each doubling adds one layer of MUX2 gates.
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def mux2(d0, d1, s):
+    inp = torch.tensor([float(d0), float(d1), float(s)])
+
+    # Layer 1: Selection
+    sel0 = int((inp @ w['sel0.weight'].T + w['sel0.bias'] >= 0).item())
+    sel1 = int((inp @ w['sel1.weight'].T + w['sel1.bias'] >= 0).item())
+
+    # Layer 2: Combine
+    l1 = torch.tensor([float(sel0), float(sel1)])
+    return int((l1 @ w['or.weight'].T + w['or.bias'] >= 0).item())
+
+# Examples
+print(mux2(1, 0, 0))  # 1 (selects d0)
+print(mux2(1, 0, 1))  # 0 (selects d1)
+print(mux2(0, 1, 1))  # 1 (selects d1)
+```
+
+## Applications
+
+- Data routing in ALUs
+- Register file read ports
+- Conditional assignment in hardware
+- Building blocks for barrel shifters
+- Crossbar switches
+
+## Files
+
+```
+threshold-mux2/
+├── model.safetensors
+├── model.py
+├── create_safetensors.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-mux2",
+  "description": "2:1 multiplexer - selects one of two inputs based on select signal",
+  "inputs": 3,
+  "outputs": 1,
+  "neurons": 3,
+  "layers": 2,
+  "parameters": 11
+}

create_safetensors.py

@@ -0,0 +1,65 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# 2:1 Multiplexer
+# Inputs: d0, d1, s
+# Output: d0 if s=0, d1 if s=1
+#
+# Formula: out = (d0 AND NOT s) OR (d1 AND s)
+#
+# Layer 1:
+#   sel0: d0 AND NOT(s) - fires when d0=1 and s=0
+#   sel1: d1 AND s - fires when d1=1 and s=1
+#
+# Layer 2:
+#   or: OR(sel0, sel1)
+
+# sel0: d0 AND NOT(s)
+# Weights: [d0, d1, s] = [1, 0, -1], bias = -1
+# d0=1, s=0: 1 + 0 - 0 - 1 = 0 >= 0 -> fires
+# d0=1, s=1: 1 + 0 - 1 - 1 = -1 < 0 -> doesn't fire
+weights['sel0.weight'] = torch.tensor([[1.0, 0.0, -1.0]], dtype=torch.float32)
+weights['sel0.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# sel1: d1 AND s
+# Weights: [d0, d1, s] = [0, 1, 1], bias = -2
+# d1=1, s=1: 0 + 1 + 1 - 2 = 0 >= 0 -> fires
+# d1=1, s=0: 0 + 1 + 0 - 2 = -1 < 0 -> doesn't fire
+weights['sel1.weight'] = torch.tensor([[0.0, 1.0, 1.0]], dtype=torch.float32)
+weights['sel1.bias'] = torch.tensor([-2.0], dtype=torch.float32)
+
+# or: OR(sel0, sel1)
+weights['or.weight'] = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+weights['or.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+# Verification
+def mux2(d0, d1, s):
+    inp = torch.tensor([float(d0), float(d1), float(s)])
+    sel0 = int((inp @ weights['sel0.weight'].T + weights['sel0.bias'] >= 0).item())
+    sel1 = int((inp @ weights['sel1.weight'].T + weights['sel1.bias'] >= 0).item())
+    l1 = torch.tensor([float(sel0), float(sel1)])
+    return int((l1 @ weights['or.weight'].T + weights['or.bias'] >= 0).item())
+
+print("Verifying MUX2...")
+errors = 0
+for s in [0, 1]:
+    for d0 in [0, 1]:
+        for d1 in [0, 1]:
+            result = mux2(d0, d1, s)
+            expected = d1 if s else d0
+            if result != expected:
+                errors += 1
+                print(f"ERROR: mux2({d0}, {d1}, {s}) = {result}, expected {expected}")
+
+if errors == 0:
+    print("All 8 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())}")

model.py

@@ -0,0 +1,30 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def mux2(d0, d1, s, weights):
+    """2:1 Multiplexer: returns d0 if s=0, d1 if s=1."""
+    inp = torch.tensor([float(d0), float(d1), float(s)])
+
+    # Layer 1: Selection gates
+    sel0 = int((inp @ weights['sel0.weight'].T + weights['sel0.bias'] >= 0).item())
+    sel1 = int((inp @ weights['sel1.weight'].T + weights['sel1.bias'] >= 0).item())
+
+    # Layer 2: OR gate
+    l1 = torch.tensor([float(sel0), float(sel1)])
+    return int((l1 @ weights['or.weight'].T + weights['or.bias'] >= 0).item())
+
+if __name__ == '__main__':
+    w = load_model()
+    print('MUX2 Truth Table:')
+    print('s  d0 d1 | out | expected')
+    print('-' * 28)
+    for s in [0, 1]:
+        for d0 in [0, 1]:
+            for d1 in [0, 1]:
+                result = mux2(d0, d1, s, w)
+                expected = d1 if s else d0
+                status = 'OK' if result == expected else 'FAIL'
+                print(f'{s}  {d0}  {d1}  |  {result}  |    {expected}     {status}')

model.safetensors

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