Upload folder using huggingface_hub

README.md

@@ -0,0 +1,129 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+- decoder
+---
+
+# threshold-3to8decoder
+
+3-to-8 binary decoder. Converts 3-bit binary input to one-hot 8-bit output. A single-layer threshold circuit.
+
+## Circuit
+
+```
+       a₂      a₁      a₀
+        │       │       │
+        ├───────┼───────┤
+        │       │       │
+    ┌───┴───┬───┴───┬───┴───┐
+    │       │       │       │
+    ▼       ▼       ▼       ▼
+┌──────┐┌──────┐┌──────┐┌──────┐
+│  y₀  ││  y₁  ││  y₂  ││ ...  │
+│-1,-1,-1││-1,-1,+1││-1,+1,-1││      │
+│b:  0 ││b: -1 ││b: -1 ││      │
+└──────┘└──────┘└──────┘└──────┘
+    │       │       │       │
+    ▼       ▼       ▼       ▼
+   y₀      y₁      y₂  ... y₇
+```
+
+## One-Hot Encoding
+
+Each input value activates exactly one output:
+
+| Input | a₂a₁a₀ | Output y₀y₁y₂y₃y₄y₅y₆y₇ |
+|-------|--------|--------------------------|
+| 0 | 000 | 10000000 |
+| 1 | 001 | 01000000 |
+| 2 | 010 | 00100000 |
+| 3 | 011 | 00010000 |
+| 4 | 100 | 00001000 |
+| 5 | 101 | 00000100 |
+| 6 | 110 | 00000010 |
+| 7 | 111 | 00000001 |
+
+## Mechanism
+
+Each output yᵢ acts as a "pattern matcher" for input = i:
+
+- **Weight +1** for bit positions that should be 1
+- **Weight -1** for bit positions that should be 0
+- **Bias** = -(number of 1 bits in i)
+
+Example for y₅ (binary 101):
+```
+weights: [+1, -1, +1]  (match 1, reject 0, match 1)
+bias: -2              (need 2 matches to fire)
+```
+
+When input = 101: sum = 1·1 + (-1)·0 + 1·1 = 2, fires
+When input = 111: sum = 1·1 + (-1)·1 + 1·1 = 1, doesn't fire
+
+## The Matching Principle
+
+The circuit computes "how well does input match pattern i?"
+
+- Perfect match: score = (number of 1s in i)
+- One bit wrong: score = (number of 1s in i) - 1
+
+The bias ensures only perfect matches pass.
+
+## Weight Patterns
+
+| Output | Binary | Weights | Bias |
+|--------|--------|---------|------|
+| y₀ | 000 | [-1, -1, -1] | 0 |
+| y₁ | 001 | [-1, -1, +1] | -1 |
+| y₂ | 010 | [-1, +1, -1] | -1 |
+| y₃ | 011 | [-1, +1, +1] | -2 |
+| y₄ | 100 | [+1, -1, -1] | -1 |
+| y₅ | 101 | [+1, -1, +1] | -2 |
+| y₆ | 110 | [+1, +1, -1] | -2 |
+| y₇ | 111 | [+1, +1, +1] | -3 |
+
+## Single-Layer Elegance
+
+Unlike traditional logic (which uses AND, OR, NOT combinations), threshold logic can decode in one layer. Each output neuron directly computes "does input match me?"
+
+## Architecture
+
+**8 neurons, 32 parameters, 1 layer**
+
+All neurons run in parallel - no dependencies.
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def decode(a2, a1, a0):
+    inp = torch.tensor([float(a2), float(a1), float(a0)])
+    return [int((inp * w[f'y{i}.weight']).sum() + w[f'y{i}.bias'] >= 0)
+            for i in range(8)]
+
+# Input 5 -> output 5 is hot
+outputs = decode(1, 0, 1)
+print(outputs)  # [0, 0, 0, 0, 0, 1, 0, 0]
+```
+
+## Files
+
+```
+threshold-3to8decoder/
+├── model.safetensors
+├── model.py
+├── config.json
+└── README.md
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-3to8decoder",
+  "description": "3-to-8 binary decoder as threshold circuit",
+  "inputs": 3,
+  "outputs": 8,
+  "neurons": 8,
+  "layers": 1,
+  "parameters": 32
+}

model.py

@@ -0,0 +1,25 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def decode_3to8(a2, a1, a0, weights):
+    """3-to-8 decoder: converts 3-bit binary to one-hot 8-bit output.
+    Returns list [y0, y1, ..., y7] where yi=1 iff input = i.
+    """
+    inp = torch.tensor([float(a2), float(a1), float(a0)])
+    outputs = []
+    for i in range(8):
+        y = int((inp * weights[f'y{i}.weight']).sum() + weights[f'y{i}.bias'] >= 0)
+        outputs.append(y)
+    return outputs
+
+if __name__ == '__main__':
+    w = load_model()
+    print('3-to-8 Decoder')
+    print('Input -> One-hot output')
+    for val in range(8):
+        a2, a1, a0 = (val >> 2) & 1, (val >> 1) & 1, val & 1
+        outputs = decode_3to8(a2, a1, a0, w)
+        print(f"  {val} ({a2},{a1},{a0}) -> {''.join(map(str, outputs))}")

model.safetensors

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