Add 4-bit buffer threshold circuit

4 neurons, 1 layer, 20 parameters, magnitude 8.

.gitattributes

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

README.md

@@ -0,0 +1,83 @@
+---
+license: mit
+tags:
+- pytorch
+- safetensors
+- threshold-logic
+- neuromorphic
+---
+
+# threshold-buffer
+
+4-bit buffer (identity function). Passes input through unchanged.
+
+## Function
+
+buffer4(x3, x2, x1, x0) -> (y3, y2, y1, y0)
+
+Output equals input: y_i = x_i for all i.
+
+## Truth Table
+
+| Input | Output |
+|-------|--------|
+| 0000 | 0000 |
+| 0001 | 0001 |
+| ... | ... |
+| 1111 | 1111 |
+
+## Architecture
+
+Single-layer, each output independently buffers one input:
+
+```
+x3   x2   x1   x0
+│    │    │    │
+▼    ▼    ▼    ▼
+○    ○    ○    ○   Layer 1
+│    │    │    │
+▼    ▼    ▼    ▼
+y3   y2   y1   y0
+```
+
+Each neuron: w=[...,1,...], b=-1 (single input with weight 1).
+
+## Parameters
+
+| | |
+|---|---|
+| Inputs | 4 |
+| Outputs | 4 |
+| Neurons | 4 |
+| Layers | 1 |
+| Parameters | 20 |
+| Magnitude | 8 |
+
+## Purpose
+
+While trivial, buffers serve several purposes:
+- Signal regeneration in long chains
+- Fan-out amplification
+- Timing alignment
+- Isolation between circuit stages
+
+## Usage
+
+```python
+from safetensors.torch import load_file
+import torch
+
+w = load_file('model.safetensors')
+
+def buffer(x3, x2, x1, x0):
+    inp = torch.tensor([float(x3), float(x2), float(x1), float(x0)])
+    y0 = int((inp @ w['y0.weight'].T + w['y0.bias'] >= 0).item())
+    y1 = int((inp @ w['y1.weight'].T + w['y1.bias'] >= 0).item())
+    y2 = int((inp @ w['y2.weight'].T + w['y2.bias'] >= 0).item())
+    y3 = int((inp @ w['y3.weight'].T + w['y3.bias'] >= 0).item())
+    return y3, y2, y1, y0
+```
+
+## License
+
+MIT

config.json

@@ -0,0 +1,9 @@
+{
+  "name": "threshold-buffer",
+  "description": "4-bit buffer (identity)",
+  "inputs": 4,
+  "outputs": 4,
+  "neurons": 4,
+  "layers": 1,
+  "parameters": 20
+}

create_safetensors.py

@@ -0,0 +1,66 @@
+import torch
+from safetensors.torch import save_file
+
+weights = {}
+
+# 4-bit Buffer (identity function)
+# Inputs: x3, x2, x1, x0
+# Outputs: y3, y2, y1, y0 (same as inputs)
+#
+# Each output is a threshold neuron that fires when input >= 1
+# y_i = 1 iff x_i = 1
+
+# y0 = x0
+weights['y0.weight'] = torch.tensor([[0.0, 0.0, 0.0, 1.0]], dtype=torch.float32)
+weights['y0.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# y1 = x1
+weights['y1.weight'] = torch.tensor([[0.0, 0.0, 1.0, 0.0]], dtype=torch.float32)
+weights['y1.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# y2 = x2
+weights['y2.weight'] = torch.tensor([[0.0, 1.0, 0.0, 0.0]], dtype=torch.float32)
+weights['y2.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+# y3 = x3
+weights['y3.weight'] = torch.tensor([[1.0, 0.0, 0.0, 0.0]], dtype=torch.float32)
+weights['y3.bias'] = torch.tensor([-1.0], dtype=torch.float32)
+
+save_file(weights, 'model.safetensors')
+
+def buffer4(x3, x2, x1, x0):
+    inp = torch.tensor([float(x3), float(x2), float(x1), float(x0)])
+
+    y0 = int((inp @ weights['y0.weight'].T + weights['y0.bias'] >= 0).item())
+    y1 = int((inp @ weights['y1.weight'].T + weights['y1.bias'] >= 0).item())
+    y2 = int((inp @ weights['y2.weight'].T + weights['y2.bias'] >= 0).item())
+    y3 = int((inp @ weights['y3.weight'].T + weights['y3.bias'] >= 0).item())
+
+    return y3, y2, y1, y0
+
+print("Verifying 4-bit Buffer...")
+errors = 0
+for i in range(16):
+    x3, x2, x1, x0 = (i >> 3) & 1, (i >> 2) & 1, (i >> 1) & 1, i & 1
+    y3, y2, y1, y0 = buffer4(x3, x2, x1, x0)
+    if (y3, y2, y1, y0) != (x3, x2, x1, x0):
+        errors += 1
+        print(f"ERROR: ({x3},{x2},{x1},{x0}) -> ({y3},{y2},{y1},{y0})")
+
+if errors == 0:
+    print("All 16 test cases passed!")
+else:
+    print(f"FAILED: {errors} errors")
+
+print("\nTruth Table:")
+print("x3 x2 x1 x0 | y3 y2 y1 y0")
+print("-" * 26)
+for i in range(16):
+    x3, x2, x1, x0 = (i >> 3) & 1, (i >> 2) & 1, (i >> 1) & 1, i & 1
+    y3, y2, y1, y0 = buffer4(x3, x2, x1, x0)
+    print(f" {x3}  {x2}  {x1}  {x0}  |  {y3}  {y2}  {y1}  {y0}")
+
+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,24 @@
+import torch
+from safetensors.torch import load_file
+
+def load_model(path='model.safetensors'):
+    return load_file(path)
+
+def buffer4(x3, x2, x1, x0, weights):
+    """4-bit buffer (identity function)."""
+    inp = torch.tensor([float(x3), float(x2), float(x1), float(x0)])
+
+    y0 = int((inp @ weights['y0.weight'].T + weights['y0.bias'] >= 0).item())
+    y1 = int((inp @ weights['y1.weight'].T + weights['y1.bias'] >= 0).item())
+    y2 = int((inp @ weights['y2.weight'].T + weights['y2.bias'] >= 0).item())
+    y3 = int((inp @ weights['y3.weight'].T + weights['y3.bias'] >= 0).item())
+
+    return y3, y2, y1, y0
+
+if __name__ == '__main__':
+    w = load_model()
+    print('4-bit Buffer:')
+    for i in [0, 5, 10, 15]:
+        x3, x2, x1, x0 = (i >> 3) & 1, (i >> 2) & 1, (i >> 1) & 1, i & 1
+        y3, y2, y1, y0 = buffer4(x3, x2, x1, x0, w)
+        print(f'  {x3}{x2}{x1}{x0} -> {y3}{y2}{y1}{y0}')

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:89cccbe884732d059b828b98ca85631a621ac89e7274315d03f33f671a236221
+size 592